diff --git a/CHANGELOG.md b/CHANGELOG.md
index deb774534..4248ca03f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -395,6 +395,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In JavaScript and TypeScript, react-dom's `root.render(<Popup />)` no longer links to your own class component's `render()`, such as an error boundary's, when `root` is declared outside the function making the call, like a module's `let root: Root | null`, or holds what `createRoot(el)` returned. A call on a variable declared outside the calling function now goes by the type that declaration gives it, so one declared with your own class, like `const store = new Store()` at the top of a file, links to that class's method, and a class component's `render()` and lifecycle methods, which only React calls, are no longer a guess for an untyped value. Re-index JavaScript and TypeScript projects after upgrading. Thanks @inth3shadows for the report. (#2589)
 - In JavaScript and TypeScript, a method called on a freshly constructed object, like `new RegExp(p).exec(s)`, `new URL(u).toString()` or `new Runner().run()`, now links only to that class's own or inherited method, on the class the file imports when several share its name, and no longer to an unrelated project method of the same name; a class from outside your project links nothing. Re-index JavaScript and TypeScript projects after upgrading. Thanks @danusha2345. (#1945)
 - In Python, `import a.b as X` written inside a function now links its calls like `X.f()`, as the same import at module level already did. Thanks @Egrn for the report. (#2600)
+- In Python, a call through a name the file imports as a module, like `other.update(…)` after `from pkg import other`, now links to that module only where nothing closer gives the name another value: a parameter, a local, a `with … as` or `except … as` target, a loop or comprehension variable, a lambda parameter or a `case` capture named `other` is that value, so its calls no longer show up as calls into the module. A `from pkg import third as other` written inside a function now links that function's `other.get()` to `third`, and no longer the rest of the file's. Re-index Python projects after upgrading. Thanks @BGamboa13. (#2632)
 - In Python, `from app import email` no longer links the importing file to a project variable named `app`, such as a FastAPI or Flask `app = FastAPI()`. (#2584)
 - In Python, a from-import of a module whose name has no dot, like `from loader import Registry` with `loader.py` at the repository root, or `from mypackage import helper` in a `src/` layout, now links the importing file to that module's file, as `import loader` and `from pkg.loader import Registry` already did. Before, the file's dependency on the module itself was left out, so `codegraph affected` and impact could miss the files that import it. When the file also imported something else under the module's name, like `from django.core import mail` beside `from mail import …`, the module was linked to that instead. Re-index Python projects after upgrading.
 - In Python, a call through a module-level instance, like `_svc.delete(obj)` after `_svc = SceneService()`, now links to the method its class has or inherits, even when other classes have a method of that name. (#2582)
@@ -491,6 +492,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - In Vue, a `<script lang="tsx">` block is now read as TSX. Before, it was read as JavaScript, which can't read its TypeScript: a script holding only `defineProps` or `withDefaults` was reported as producing no symbols, and in a script with other code an `interface` or type it declared was missing from the graph without any warning. Re-index Vue projects that use `lang="tsx"` after upgrading. Thanks @leadingGo for the report, and @maxmilian and @yanhongwang1017. (#2570)
 - In Astro and Svelte, a self-closing script like Astro's `<script is:inline set:html={code} />` or `<script src="/analytics.js" />` in `<svelte:head>` no longer swallows the `<script>` that follows it. Before, that script's symbols and calls were dropped with a "parse produced no symbols" warning, and calls and components in the markup between the two were missed too, as they were after a self-closing `<style />`. Re-index Astro and Svelte projects after upgrading. Thanks @rezaularif for the report and @maxmilian for the fix. (#2989)
+- In Astro, Svelte and Vue, a self-closing script like Astro's `<script is:inline set:html={code} />`, `<script src="/analytics.js" />` in `<svelte:head>` or a Vue `<script src="./legacy.js" />` block no longer swallows the `<script>` that follows it. Before, that script's symbols and calls were dropped with a "parse produced no symbols" warning, and calls and components in the markup between the two were missed too, as they were after a self-closing `<style />`. Re-index Astro, Svelte and Vue projects after upgrading. Thanks @rezaularif for the report and @maxmilian for the fix. (#2989)
 - In COBOL, asking `codegraph_explore` (or `codegraph explore` and `codegraph context`) about a copybook by name, such as `CVACT01Y` or a member brought in with `EXEC SQL INCLUDE`, now answers with the copybook's own source when it is indexed and every `COPY` or `EXEC SQL INCLUDE` statement that includes it, and says so when the copybook's source isn't part of the project. Before, it answered "No relevant code found", or showed an unrelated program whose name was a letter or two away. Thanks @popolusiak for the report. (#2342)
 
 - In Dart, reading a getter such as `box.area` or `status.label` now counts as calling it, so `codegraph callers` and impact list the code that reads it — whether the getter is declared on the class, inherited, or added by an extension — and a method an extension adds to an enum, like `shape.shout()`, now links as well. A plain field, a getter of a type from outside your project, or a value whose type isn't written down still links nothing. Re-index Dart projects after upgrading. Thanks @brookly255-lv for the report. (#2338)
@@ -530,6 +532,9 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `codegraph_explore` and `codegraph context` now include some of the subtypes and implementors of a class or interface you ask about, and the type hierarchy the library returns for one (`getTypeHierarchy`) now lists all of them. Before, a bug in the hierarchy walk left every type without subtypes, so only what it extends or implements came back. Thanks @jocax for the report and @danusha2345 for the fix. (#2833)
 - In Rust, code that uses an enum only through its variants, like `mode::Mode::A` in an expression, a `Mode::B =>` match arm or `Self::A` inside the enum's own `impl`, now shows up in that enum's callers and impact, linked to the enum that actually declares the variant rather than to a same-named type elsewhere. Standard-library variants like `Ordering::Less` or `Option::Some` and associated items like `Foo::new()` or `Foo::MAX` don't count as using a project enum. Re-index Rust projects after upgrading. Thanks @mg-mg-mg for the report and @danusha2345. (#2328)
 
+- In Rust, a call through a type that a path or a `use` names, like `sim::items::ItemPool::for_def(…)` into another crate of your workspace, `ItemPool::for_def(…)` under `use sim::items::ItemPool;` or `crate::models::Mode::Fast(1)`, now links to that type's own function or variant, even when a type of the same name in another crate or module has one too, and a `use` of a `pub const` or `static`, like `use sim::RANK_COUNT;`, links to it. A type written on the line below its module path, as rustfmt wraps a long signature (`scheduler::` then `Handle`), now links by that path rather than by a `use` of its name. A workspace member listed outside the project, like `../shared`, is no longer read. Re-index Rust projects after upgrading. Thanks @BGamboa13. (#2631)
+- In Rust, a module loaded with `#[path = "…"]`, like tests kept in another folder as `#[path = "../../../tests/unit/scaling_tests.rs"] mod tests;`, is now part of the module that declares it: its `use super::*` brings in that module's items, private ones included, `super::` and `crate::` start from there, and the path is read as Rust reads it, from the declaring file's folder or an inline module's own. A call through such a module, like `support::make()` in each test that loads a shared helper, reaches the file it names. A module whose `#[cfg]` alternatives each name a file of their own, or whose path a `cfg_attr` sets, depends on the build and is left alone. An example, test or bench that `Cargo.toml` places at a path of its own, like `examples/07-fullstack/handling_errors.rs`, is now its own crate, so its `crate::` starts from it. Re-index Rust projects after upgrading. Thanks @seonghobae. (#1892)
+
 - Axum routes now link to their handler when rustfmt wraps the `.route(` call so the handler sits on a later line, and when the handler's name also appears elsewhere on the line, as in `delete(handlers::user::delete)` or `.route("/login", post(handlers::user::login))`; Actix's `web::resource(…)` and `.route(…)` registrations get the same fix. A call inside a closure handler is no longer mistaken for a route, and an Actix resource no longer takes the next route's handler as its own. Thanks @mg-mg-mg for the report and @danusha2345. (#2326)
 
 - In Play projects, a route or a call like `MediaType.parse(...)` now links to a method of the class or object it names, and a call to an overloaded one to the overload its arguments fit. Before, it went to the first method of that name anywhere in the class's file, often a nested or sibling class's. When a Scala and a Java type share a name, as Play's own `RequestAuthority` does, each language's calls now reach their own. Thanks @danusha2345.
@@ -631,6 +636,8 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In C++, a base class like `Message` in `class DynamicMessage final : public Message` now links to the class C++ itself would pick: the one declared in the namespaces around the class, or brought in by the file's `using` declarations and namespace aliases, and the class a `typedef` or `using` alias names. Before, a base class was matched by its name alone, so it could land on a class of the same name in another namespace or another language: in protocolbuffers/protobuf, `DynamicMessage` derived from the JSON parser's internal `Message` class, and in google/leveldb and RocksDB, iterators derived from an unrelated nested `Iterator` class such as the skip list's. The wrong base showed up in `codegraph_explore`'s type hierarchy and in impact, and tied the base's methods to the wrong overrides. A template parameter used as a base no longer links to a class that shares its name, and a base written from the global scope, like `public ::testing::Test`, now links to its class. Re-index C++ projects after upgrading.
 - In C++ and Rust, a call written with a qualifier, like `Status::OK()`, now links to a method of the class it names, never to one of a class whose name only ends the same way. Before, facebook/rocksdb's calls to `Status::OK()`, `Status::InvalidArgument(…)` and `Status::Corruption(…)` linked to `IOStatus`'s methods of those names, a subclass calling its base, like `return FileSystemWrapper::NewWritableFile(…)` or google/leveldb's `return DB::Put(…)`, linked to another subclass or to the calling method itself, and BurntSushi/ripgrep's `Path::new(…)` on the standard library's `Path` linked to its own `PrinterPath::new`. When classes in several languages share the name, the one in the call's own language is taken, so protocolbuffers/protobuf's C++ `DescriptorPool::generated_pool()` calls, which met its Ruby namesake first and linked to nothing, now link to the C++ method. A C++ call through a template parameter, like `CacheShard::ComputeHash(key)` in rocksdb's `template <class CacheShard> class ShardedCache`, no longer links to a class that merely shares words with the parameter's name, unless that class is the parameter's default, like `TcParser` in `template <typename Parser = TcParser>`. A template's value parameter, like `const PrefetchOpts& kOpts`, is no longer mistaken for a type parameter, so references to `PrefetchOpts` inside it now link. Re-index C++ and Rust projects after upgrading.
 - In Ruby, a call on a class written with its namespace, like `Billing::ChargeCard.call(…)` or `::Billing::ChargeCard.call(…)`, now links the caller to that class and to the class method it calls, as `ChargeCard.call(…)` already linked to the class. Before, a class used only through such calls looked like it had no callers. The name is looked up the way Ruby does it, from the namespaces around the call outward, so `Users::Create.call` reaches `Users::Create` and never a `Billing::Create`, a call inside `module Api; module V2` reaches `Api::V2`'s class before another version's, and a library's class like `ActiveRecord::Base` is never taken for a project class of the same last name. Re-index Ruby projects after upgrading. Thanks @james-jang for the report and @drakeo338 for the pull request. (#2503)
+- In Ruby, a call to a method whose name ends in `!` or `?` now links when its receiver's class is known, like `writer.flush!` or `writer.ready?` after `writer = CacheWriter.new`, or `CacheWriter.create!(…)` on the class. A method called straight on a new object, like `CacheWriter.new(key).write_cache` or `Billing::Ledger.new.charge!`, now links to that class's method or to one it inherits. Before, all of these linked nothing. The class is looked up the way Ruby does it, from the namespaces around the call outward, and one from outside your project, like rack's `Request` used inside `Rack::Protection`, links nothing rather than a project class of the same name. Re-index Ruby projects after upgrading. Thanks @ricobl.
+- In Ruby, a call on an instance variable, like `@writer.flush`, now links to the method of the class the variable holds when the class's `initialize` sets it to a new object of one class, like `@writer = CacheWriter.new`. Before, no call on an instance variable linked. A variable that `initialize` sets to anything else, or to objects of two classes, stays unlinked rather than guessed. Re-index Ruby projects after upgrading.
 - In PHP, a class written through a namespace alias in a different case than its `use` statement, like `new field\FirstName()` after `use App\Fields as Field;`, now links to that class, since PHP reads namespace names without regard to case. Before, the name was read relative to the file's own namespace and stayed unlinked. Re-index PHP projects after upgrading. Thanks @danusha2345. (#2369)
 - In C++, a call through a class template's specialization written with its arguments, like fmtlib/fmt's `formatter<int>::format(42, ctx)`, no longer links to a member defined for another specialization, like a test's `formatter<incomplete_type>::format`, and when the template declares no such member, as for `formatter<std::tm, Char>::parse(ctx)`, the call is no longer matched to another class's method of that name, like `native_formatter::parse`. A call to the specialization a member is defined for, and to a template's own members, links as before. Re-index C++ projects after upgrading.
 - In C++, a function is now named by its declarator, never by something written in the clauses after its parameters. nlohmann/json's constructor `basic_json(CompatibleType&& val) noexcept(noexcept(JSONSerializer<U>::to_json(…)))` was missing from the index, replaced by a method `JSONSerializer::to_json` that doesn't exist and that other `JSONSerializer<T>::to_json(…)` calls linked to; a method declared with `throw(std::bad_alloc)` was indexed as `std::bad_alloc`, and a function with a trailing `requires std::integral<T>` as `std::integral<T>`. Re-index C++ projects after upgrading.
@@ -820,6 +827,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `codegraph sync` and the file watcher now link a component to the JSX that renders it, like `<Team />`, when the component is added in a file with no JSX of its own, as in `export default function Team() { return null; }`. Before, the link waited for an unrelated change to a file with JSX, or for a re-index, so the new component looked unused.
 
 - In JavaScript and TypeScript, a default import now links to what the module's `export default` statement exports, wherever the statement sits in the file. Before, a module that declares its default, like `export default function Vans() {…}` or `export default class Store {…}`, had its default import linked to the first function it exports instead: in a React Router data-router app, where a page exports its `loader` or `action` above the page component, `import Vans, { loader as vansLoader } from './pages/Vans'` made the route `/vans` and every use of `Vans` lead to the loader. A component file that also exports a styled or memoized component no longer hands its default import to that component, and an anonymous default, like `export default function () {…}` or `export default () => …`, is no longer linked to a function exported beside it or nested inside it. A module loaded with `require('./x').default` is read the same way. Re-index JavaScript and TypeScript projects after upgrading.
+- In JavaScript and TypeScript, a line like `export default App` written inside a template literal, as code generators and build plugins write the modules they produce, no longer counts as the module's own default export. Before, when that text named a function the file declares, a default import of the module linked to that function instead of the one the real `export default` statement names, and an unnamed `export default () => …` in such text could leave the default import linked to nothing. Re-index JavaScript and TypeScript projects after upgrading. Thanks @inth3shadows for the report and @johnhldiver-beep for the first fix. (#2968)
 
 - In Kotlin, a call on a typed receiver now links to an extension function declared in a package, like `value.shout()` or the infix `a join b` with `value: Foo` and `fun Foo.shout()` under `package demo`, including one declared in another file of the package. Before, it linked only when the file had no `package` line, so the usual Kotlin project got no edge. On JetBrains Exposed, 1,020 such calls now link (`Table.selectAll()` to `FieldSet.selectAll`, `transaction.throwUnsupportedException(…)`), and none that linked before is lost. A member of the receiver's class still wins over an extension of the same name.
 
diff --git a/__tests__/default-export-declaration.test.ts b/__tests__/default-export-declaration.test.ts
index 1518a8d26..ac7671031 100644
--- a/__tests__/default-export-declaration.test.ts
+++ b/__tests__/default-export-declaration.test.ts
@@ -205,6 +205,97 @@ export default class AnimatedColor {
   const { default: Color } = require("./AnimatedColor")
   return [new AnimatedColor("red"), new Color("blue")]
 }
+`,
+  // An `export default` line written in a template literal is text, not the
+  // module's statement (#2968). A code generator's template names the file's
+  // own `App`, above the real default — the issue's own example first.
+  'src/gen/issue.ts': `export function App() { return 1; }
+export function Main() { return 2; }
+export const template = \`
+export default App
+\`;
+export default Main;
+`,
+  // Returned by a function, behind a template nested in an interpolation.
+  'src/gen/render.ts': `export function App() { return 1 }
+export function Main() { return 2 }
+export function render() {
+  return \`intro \${\`nested\`}
+export default App
+\`
+}
+export default Main
+`,
+  // Passed at module scope, where no declaration encloses it, and a class field.
+  'src/gen/write.ts': `import { writeFileSync } from "fs"
+export function App() { return 1 }
+export function Main() { return 2 }
+writeFileSync("out.ts", \`
+export default App
+\`)
+export class Emitter {
+  sample = \`
+export default App
+\`
+}
+export default Main
+`,
+  // A template's anonymous default made the expression default below it
+  // anonymous too, which keeps every guess away.
+  'src/gen/model.ts': `export class Model {
+  save() {
+    return 1
+  }
+}
+export const usage = \`
+export default class extends Model {}
+\`
+export default observable(Model)
+function observable<T>(target: T): T {
+  return target
+}
+`,
+  // No template text: a regex and a string that hold a backtick, and a
+  // division after a parenthesis.
+  'src/gen/plain.ts': `export function App() { return 1 }
+export function Main() { return 2 }
+const tick = /[\`]/g
+const half = (App() + Main()) / 2 + "\`"
+export default Main
+`,
+  // A regex right after `if (…)` reads as a division, so its backtick opens a
+  // literal the scan never closes: then the scan vouches for nothing, and the
+  // statement still counts.
+  'src/gen/unbalanced.ts': `export function App() { return 1 }
+export function Main() { return 2 }
+export function check(s: string, ok: boolean) {
+  if (ok) /\`/.test(s)
+  return s
+}
+export default Main
+`,
+  'src/gen/multi.ts': `export function helper() { return 1; }
+export default (
+  value
+) => value;
+`,
+  'src/gen/use.ts': `import Issue from "./issue"
+import Render from "./render"
+import Write from "./write"
+import Persisted from "./model"
+import Plain from "./plain"
+import Unbalanced from "./unbalanced"
+import Multi from "./multi"
+
+export function generate() {
+  Issue()
+  Render()
+  Write()
+  new Persisted()
+  Plain()
+  Unbalanced()
+  Multi()
+}
 `,
   'src/use.tsx': `import handler from "./api/vans"
 import Store from "./store"
@@ -333,3 +424,40 @@ describe('a default import of a module that exports something above its default'
     expect(consumed()).toContain('src/service.ts:run');
   });
 });
+
+describe('an `export default` line inside a template literal', () => {
+  /** `file:name` of every node `generate` calls or instantiates. */
+  function generated(): string[] {
+    const generate = cg.getNodesInFile('src/gen/use.ts').find((n) => n.name === 'generate')!;
+    return cg
+      .getOutgoingEdges(generate.id)
+      .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+      .map((e) => cg.getNode(e.target)!)
+      .map((n) => `${n.filePath}:${n.name}`)
+      .sort();
+  }
+
+  it('is text, so the real statement below it names the default', () => {
+    const targets = generated();
+    for (const file of ['issue', 'render', 'write']) {
+      expect(targets).toContain(`src/gen/${file}.ts:Main`);
+      expect(targets).not.toContain(`src/gen/${file}.ts:App`);
+    }
+  });
+
+  it('does not make an expression default anonymous', () => {
+    expect(generated()).toContain('src/gen/model.ts:Model');
+  });
+
+  it('binds a multiline anonymous arrow default to nothing, not to a function beside it', () => {
+    expect(generated()).not.toContain('src/gen/multi.ts:helper');
+  });
+
+  it('leaves regexes, strings and division alone, and a scan it cannot finish', () => {
+    const targets = generated();
+    expect(targets).toContain('src/gen/plain.ts:Main');
+    expect(targets).toContain('src/gen/unbalanced.ts:Main');
+    expect(targets).not.toContain('src/gen/plain.ts:App');
+    expect(targets).not.toContain('src/gen/unbalanced.ts:App');
+  });
+});
diff --git a/__tests__/python-receiver-rebinding.test.ts b/__tests__/python-receiver-rebinding.test.ts
new file mode 100644
index 000000000..ca47d938e
--- /dev/null
+++ b/__tests__/python-receiver-rebinding.test.ts
@@ -0,0 +1,224 @@
+/**
+ * A Python call through a name the file imports as a module reads that module
+ * only where nothing nearer binds the name:
+ *
+ *   from pkg import other
+ *
+ *   def real():
+ *       other.update({})          # pkg/other.py's update
+ *
+ *   def by_param(other):
+ *       other.update({})          # dict.update, or whatever the caller passed
+ *
+ * The import resolver read the file's imports alone, so a parameter, a local,
+ * a `with … as` / `except … as` / loop target, a walrus, a `case` capture or a
+ * lambda or comprehension variable named like the module still linked the
+ * call to the module's function. A function-local `from pkg import third as
+ * other` linked to `pkg.other` too, and so did, from every other function of
+ * the file, though it binds the name only where it is written.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+
+const FILES: Record<string, string> = {
+  'pyproject.toml': '[project]\nname = "pkg"\n',
+  'src/pkg/__init__.py': '',
+  'src/pkg/other.py': [
+    'def update(x=None):',
+    '    return x',
+    '',
+    '',
+    'def persist(x=None):',
+    '    return x',
+    '',
+    '',
+    'def get(key=None):',
+    '    return key',
+    '',
+  ].join('\n'),
+  'src/pkg/third.py': ['def get(key=None):', '    return key', ''].join('\n'),
+  'tests/shadow.py': [
+    'from pkg import other',
+    '',
+    '',
+    'def real():',
+    '    other.update({"b": 2})',
+    '    return other.persist(1)',
+    '',
+    '',
+    'def by_param(other):',
+    '    other.update({"a": 1})',
+    '    return other.persist(2)',
+    '',
+    '',
+    'def by_with(path):',
+    '    with open(path, "w") as other:',
+    '        return other.persist(3)',
+    '',
+    '',
+    'def by_assign():',
+    '    other = {}',
+    '    other.update({"c": 3})',
+    '',
+    '',
+    'def by_for(items):',
+    '    for other in items:',
+    '        other.persist(4)',
+    '',
+    '',
+    'def by_except():',
+    '    try:',
+    '        pass',
+    '    except OSError as other:',
+    '        return other.persist(5)',
+    '',
+    '',
+    'def by_lambda():',
+    '    return lambda other: other.persist(6)',
+    '',
+    '',
+    'def by_comprehension(items):',
+    '    return [other.persist(7) for other in items]',
+    '',
+    '',
+    'def by_walrus(load):',
+    '    if (other := load()):',
+    '        return other.persist(8)',
+    '',
+    '',
+    'def by_closure(other):',
+    '    def inner():',
+    '        return other.persist(9)',
+    '    return inner',
+    '',
+    '',
+    'def by_capture(v):',
+    '    match v:',
+    '        case other:',
+    '            return other.persist(10)',
+    '',
+    '',
+    'def by_local_import():',
+    '    from pkg import third as other',
+    '    return other.get(11)',
+    '',
+    '',
+    // Each of these reads the module the file imports.
+    'def keyword_argument(run):',
+    '    run(',
+    '        other=1,',
+    '    )',
+    '    return other.persist(12)',
+    '',
+    '',
+    'def in_a_string():',
+    '    print("with x as other", "other = 1")  # other = 2',
+    '    return other.persist(13)',
+    '',
+    '',
+    'def comprehension_of_others(items):',
+    '    return [x for x in other.persist(items)]',
+    '',
+    '',
+    'def lambda_beside(run):',
+    '    return run(lambda other: 1, other.persist(14))',
+    '',
+    '',
+    'def declared_global():',
+    '    global other',
+    '    return other.persist(15)',
+    '',
+    '',
+    'def keyword_pattern(v):',
+    '    match v:',
+    '        case Point(other=1):',
+    '            return other.persist(16)',
+    '',
+    '',
+    'def same_module_again():',
+    '    from pkg import other',
+    '    return other.get(17)',
+    '',
+  ].join('\n'),
+  // The module binds `other` with a plain import, which the file's mappings
+  // list after every from-import, the function-local one included.
+  'tests/leak.py': [
+    'import pkg.other as other',
+    '',
+    '',
+    'def local_third():',
+    '    from pkg import third as other',
+    '    return other.get(1)',
+    '',
+    '',
+    'def untouched():',
+    '    return other.get(2)',
+    '',
+  ].join('\n'),
+};
+
+describe.each(['LF', 'CRLF'])('a Python receiver the function binds itself is not the module the file imports (%s)', (eol) => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-py-rebind-'));
+    for (const [rel, content] of Object.entries(FILES)) {
+      fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+      fs.writeFileSync(path.join(root, rel), eol === 'CRLF' ? content.replace(/\n/g, '\r\n') : content);
+    }
+    cg = await CodeGraph.init(root, { index: true });
+  }, 60_000);
+
+  afterAll(() => {
+    cg?.destroy();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  /** `file:name` of each project function `name` in `file` calls, sorted. */
+  const callsFrom = (file: string, name: string): string[] => {
+    const from = cg!.getNodesInFile(file).filter((n) => n.name === name && (n.kind === 'function' || n.kind === 'method'));
+    expect(from, `${name} in ${file}`).toHaveLength(1);
+    return cg!.getOutgoingEdgesFrom([from[0]!.id])
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg!.getNode(e.target)!)
+      .filter((t) => t.filePath.startsWith('src/'))
+      .map((t) => `${t.filePath}:${t.name}`)
+      .sort();
+  };
+
+  it('a call where nothing nearer binds the name reaches the module', () => {
+    expect(callsFrom('tests/shadow.py', 'real')).toEqual(['src/pkg/other.py:persist', 'src/pkg/other.py:update']);
+  });
+
+  it.each([
+    'by_param', 'by_with', 'by_assign', 'by_for', 'by_except', 'by_lambda',
+    'by_comprehension', 'by_walrus', 'inner', 'by_capture',
+  ])('%s: a name the code around the call binds links no module function', (fn) => {
+    expect(callsFrom('tests/shadow.py', fn)).toEqual([]);
+  });
+
+  it('a function-local `from pkg import third as other` is that module', () => {
+    expect(callsFrom('tests/shadow.py', 'by_local_import')).toEqual(['src/pkg/third.py:get']);
+    expect(callsFrom('tests/leak.py', 'local_third')).toEqual(['src/pkg/third.py:get']);
+  });
+
+  it('a function-local import binds the name in that function only', () => {
+    expect(callsFrom('tests/leak.py', 'untouched')).toEqual(['src/pkg/other.py:get']);
+  });
+
+  it.each([
+    ['keyword_argument', 'src/pkg/other.py:persist'],
+    ['in_a_string', 'src/pkg/other.py:persist'],
+    ['comprehension_of_others', 'src/pkg/other.py:persist'],
+    ['lambda_beside', 'src/pkg/other.py:persist'],
+    ['declared_global', 'src/pkg/other.py:persist'],
+    ['keyword_pattern', 'src/pkg/other.py:persist'],
+    ['same_module_again', 'src/pkg/other.py:get'],
+  ])('%s binds nothing of that name: the call reaches the module', (fn, target) => {
+    expect(callsFrom('tests/shadow.py', fn)).toEqual([target]);
+  });
+});
diff --git a/__tests__/python-supertype-type-arguments.test.ts b/__tests__/python-supertype-type-arguments.test.ts
new file mode 100644
index 000000000..510f5c043
--- /dev/null
+++ b/__tests__/python-supertype-type-arguments.test.ts
@@ -0,0 +1,136 @@
+/**
+ * A Python class's supertypes, as its head declares them, are the classes its
+ * bases name — not their type arguments. `class Repo(Base[User])` extends
+ * `Base`; reading every word of the base list also counted `User`, so a call on
+ * the class or on a receiver named after it, `Repo.save()` / `repo.save()`,
+ * reached `User.save` when `Base` declares no `save`.
+ */
+import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-py-supertype-type-args-'));
+  fs.mkdirSync(path.join(root, 'app'));
+  fs.writeFileSync(path.join(root, 'app/__init__.py'), '');
+  fs.writeFileSync(path.join(root, 'app/m.py'), `from typing import Generic, Optional, TypeVar
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+
+class Base(Generic[T]):
+    def load(self):
+        pass
+
+
+class Pair(Generic[T, U]):
+    def load(self):
+        pass
+
+
+class User:
+    def save(self):
+        pass
+
+
+class Other:
+    def save(self):
+        pass
+
+
+class Repo(Base[User]):
+    pass
+
+
+class Store(Pair[str, dict[str, User]]):
+    pass
+
+
+class Keyed(Base[User], metaclass=type):
+    pass
+
+
+class Forward(Base["Pair[str, User]"]):
+    pass
+
+
+class Mixin:
+    def save(self):
+        pass
+
+
+class Mixed(Base[Optional[User]], Mixin):
+    pass
+
+
+def save_by_class():
+    Repo.save()
+
+
+def save_by_receiver(repo):
+    repo.save()
+
+
+def save_nested():
+    Store.save()
+
+
+def save_keyed():
+    Keyed.save()
+
+
+def save_forward():
+    Forward.save()
+
+
+def save_mixed():
+    Mixed.save()
+
+
+def load_by_class():
+    Repo.load()
+
+
+def load_nested():
+    Store.load()
+`);
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** Qualified names of the methods `fn` calls. */
+const calls = (fn: string): string[] => {
+  const node = cg.getNodesInFile('app/m.py').find((n) => n.name === fn && n.kind === 'function')!;
+  expect(node, fn).toBeDefined();
+  return cg.getOutgoingEdges(node.id).filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!).filter((n) => n.kind === 'method').map((n) => n.qualifiedName);
+};
+
+describe('a Python type argument is no supertype', () => {
+  it('does not reach a method of the type argument', () => {
+    expect(calls('save_by_class')).not.toContain('User::save');
+    expect(calls('save_by_receiver')).not.toContain('User::save');
+    expect(calls('save_nested')).not.toContain('User::save');
+    expect(calls('save_keyed')).not.toContain('User::save');
+    expect(calls('save_forward')).not.toContain('User::save');
+  });
+
+  // The extractor emits an `extends` edge only for a plain or dotted base name,
+  // so a parameterized base like `Base[User]` links no inherited method at all.
+  // Upstream reads the class head's text and reaches `Base::load` here.
+  it.todo('reaches the method a parameterized base declares');
+
+  it('reaches a later base past the type argument that came first', () => {
+    expect(calls('save_mixed')).toEqual(['Mixin::save']);
+  });
+});
diff --git a/__tests__/ruby-constructed-receivers.test.ts b/__tests__/ruby-constructed-receivers.test.ts
new file mode 100644
index 000000000..55cd741c2
--- /dev/null
+++ b/__tests__/ruby-constructed-receivers.test.ts
@@ -0,0 +1,347 @@
+/**
+ * Ruby calls on a typed receiver whose method name ends in `!` or `?`, and
+ * calls on what `.new` made (#684).
+ *
+ * `writer.flush!` and `writer.ready?` after `writer = CacheWriter.new` linked
+ * nothing, while `writer.write_cache` linked: the method-call pattern took no
+ * `!` or `?`. `CacheWriter.create!` linked nothing where `CacheWriter.create`
+ * did, for the same reason.
+ *
+ * `CacheWriter.new(key).write_cache` was recorded with the receiver's text,
+ * arguments and all, so it never linked. It is now `new CacheWriter()
+ * .write_cache`, and links an instance method of the class Ruby's constant
+ * lookup finds for `CacheWriter` where the call is written, its own or one
+ * its ancestry declares. A class the project doesn't declare links nothing:
+ * rack-protection's `Request.new(env)` is rack's `Rack::Request`, not the
+ * project's `Sinatra::Request`.
+ *
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { extractFromSource } from '../src/extraction/tree-sitter';
+
+const FILES: Record<string, string> = {
+  'app/writer.rb': `class CacheWriter
+  def self.create(key)
+    new
+  end
+
+  def self.create!(key)
+    new
+  end
+
+  def write_cache(key)
+    key
+  end
+
+  def flush!
+    nil
+  end
+
+  def ready?
+    true
+  end
+end
+
+class OtherWriter
+  def write_cache(key)
+    key
+  end
+
+  def flush!
+    nil
+  end
+
+  def ready?
+    false
+  end
+end
+
+class ParentWriter
+  def flush
+    nil
+  end
+end
+
+class ChildWriter < ParentWriter
+  def self.flush
+    nil
+  end
+end
+`,
+  'app/billing.rb': `module Billing
+  class Card
+    def charge!(amount)
+      amount
+    end
+  end
+
+  class Ledger < Card
+    def post
+      Card.new.charge!(1)
+    end
+  end
+end
+
+module Admin
+  class Card
+    def charge!(amount)
+      amount
+    end
+  end
+end
+`,
+  'app/counter.rb': `class Counter
+  def bang
+    writer = CacheWriter.new
+    writer.flush!
+  end
+
+  def question
+    writer = CacheWriter.new
+    writer.ready?
+  end
+
+  def chained(key)
+    CacheWriter.new.write_cache(key)
+  end
+
+  def chained_args(key)
+    CacheWriter.new(key).write_cache(key)
+  end
+
+  def chained_bang
+    CacheWriter.new(1).flush!
+  end
+
+  def namespaced
+    Billing::Ledger.new.charge!(2)
+  end
+
+  def top_level
+    ::CacheWriter.new.ready?
+  end
+
+  def class_bang
+    CacheWriter.create!(1)
+  end
+
+  def outside(env)
+    Request.new(env).preferred_type
+  end
+
+  def inherited_flush
+    ChildWriter.new.flush
+  end
+end
+`,
+  'lib/rack/show_exceptions.rb': `module Rack
+  module Protection
+    class ShowExceptions
+      def call(env)
+        Request.new(env).preferred_type("text/html")
+      end
+    end
+  end
+end
+`,
+  'lib/sinatra/request.rb': `module Sinatra
+  class Request
+    def preferred_type(*types)
+      types.first
+    end
+  end
+end
+`,
+  // A module a call returns is no mixin of the constant the call starts at:
+  // UrlForHelper doesn't get RouteSet's methods (actionpack's url_for tests).
+  'app/url_helper.rb': `class RouteSet
+  def url_for(options)
+    options
+  end
+
+  def url_helpers
+    Module.new
+  end
+end
+
+class UrlForHelper
+  include RouteSet.new.url_helpers
+end
+
+class UrlForTest
+  def test_url
+    UrlForHelper.new.url_for(1)
+  end
+end
+`,
+  // Two project methods named `key?`: a `?` call on an untyped receiver is not
+  // guessed between them by the receiver's words.
+  'lib/options.rb': `class InheritableOptions
+  def key?(key)
+    true
+  end
+end
+
+class FlashHash
+  def key?(name)
+    false
+  end
+end
+
+class Store
+  def merged(options)
+    options.key?(:namespace)
+  end
+end
+`,
+};
+
+let root = '';
+let cg: CodeGraph | undefined;
+
+afterEach(() => {
+  cg?.close();
+  cg = undefined;
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+  root = '';
+});
+
+function write(files: Record<string, string>): void {
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+}
+
+async function index(files: Record<string, string> = FILES): Promise<CodeGraph> {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-ruby-made-'));
+  write(files);
+  cg = await CodeGraph.init(root, { index: true });
+  return cg;
+}
+
+/** `<qualified name>:<line>` of every `calls` edge written on `line` of `file`. */
+function callsAt(graph: CodeGraph, file: string, line: number): string[] {
+  const ids = graph.getNodesInFile(file).map((n) => n.id);
+  return graph
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls' && e.line === line)
+    .map((e) => {
+      const t = graph.getNode(e.target)!;
+      return `${t.qualifiedName}:${t.startLine}`;
+    })
+    .sort();
+}
+
+describe('Ruby bang and question methods, and calls on .new (#684)', () => {
+  it('links a `!` or `?` method called on a typed local', async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/counter.rb', 4)).toEqual(['CacheWriter::flush!:14']);
+    expect(callsAt(graph, 'app/counter.rb', 9)).toEqual(['CacheWriter::ready?:18']);
+  });
+
+  it('links a `!` class method', async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/counter.rb', 33)).toEqual(['CacheWriter::create!:6']);
+  });
+
+  it('links a call on what `.new` made, with or without arguments', async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/counter.rb', 13)).toEqual(['CacheWriter::write_cache:10']);
+    expect(callsAt(graph, 'app/counter.rb', 17)).toEqual(['CacheWriter::write_cache:10']);
+    expect(callsAt(graph, 'app/counter.rb', 21)).toEqual(['CacheWriter::flush!:14']);
+    expect(callsAt(graph, 'app/counter.rb', 29)).toEqual(['CacheWriter::ready?:18']);
+  });
+
+  it('finds the class by Ruby constant lookup, and the method in its ancestry', async () => {
+    const graph = await index();
+    // `Card` inside `Billing::Ledger` is Billing::Card, not Admin::Card.
+    expect(callsAt(graph, 'app/billing.rb', 10)).toEqual(['Billing::Card::charge!:3']);
+    // Billing::Ledger has no `charge!`; its superclass Billing::Card does.
+    expect(callsAt(graph, 'app/counter.rb', 25)).toEqual(['Billing::Card::charge!:3']);
+  });
+
+  it('links an instance method a superclass declares before a class method its child defines', async () => {
+    const graph = await index();
+    // `ChildWriter.new` is an instance: its own `self.flush` is a class
+    // method, so the call reaches `ParentWriter#flush` instead.
+    expect(callsAt(graph, 'app/counter.rb', 41)).toEqual(['ParentWriter::flush:38']);
+  });
+
+  it('links nothing for a class the project does not declare', async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/counter.rb', 37)).toEqual([]);
+    expect(callsAt(graph, 'lib/rack/show_exceptions.rb', 5)).toEqual([]);
+  });
+
+  it("finds no method in a module a call returns, which the class's ancestry doesn't name", async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/url_helper.rb', 17)).toEqual([]);
+  });
+
+  it('guesses no `?` method by the receiver word among several of the name', async () => {
+    const graph = await index();
+    // `options` shares a word with InheritableOptions, but a Hash answers `key?` too.
+    expect(callsAt(graph, 'lib/options.rb', 15)).toEqual([]);
+  });
+});
+
+describe('Ruby call on .new, after a sync (#684)', () => {
+  it('links the call once a sync adds the class it constructs', async () => {
+    const { 'app/writer.rb': writer, ...rest } = FILES;
+    const graph = await index(rest);
+    expect(callsAt(graph, 'app/counter.rb', 17)).toEqual([]);
+
+    write({ 'app/writer.rb': writer! });
+    expect((await graph.sync()).filesAdded).toBe(1);
+    // counter.rb did not change: only the retry of its parked refs links it.
+    expect(callsAt(graph, 'app/counter.rb', 17)).toEqual(['CacheWriter::write_cache:10']);
+  }, 60_000);
+});
+
+describe('Ruby extraction of a call on .new (#684)', () => {
+  // A call on what `.new` made is recorded as `new CacheWriter().write_cache`:
+  // the class as written, without the arguments the receiver's text carried. A
+  // `new` on a value (`klass.new.run`, `self.class.new`) or a later link of a
+  // chain keeps the receiver's text.
+  it('records the constructed class, not the receiver text', () => {
+    const src = [
+      'class Callers',
+      '  def a(key, klass)',
+      '    CacheWriter.new.write_cache(key)',
+      '    CacheWriter.new(key, ttl: 5).flush!',
+      '    Billing::Ledger.new { |l| l }.post',
+      '    ::CacheWriter.new.ready?',
+      '    CacheWriter.new&.write_cache(key)',
+      '    klass.new.run',
+      '    self.class.new(key).run',
+      '    Widget.create(key).save',
+      '    CacheWriter.new.first.second',
+      '  end',
+      'end',
+      '',
+    ].join('\n');
+    const calls = extractFromSource('src/callers.rb', src, 'ruby').unresolvedReferences
+      .filter((r) => r.referenceKind === 'calls' && /[.(]/.test(r.referenceName))
+      .map((r) => `${r.referenceName} ${r.line}`);
+    expect(calls.sort()).toEqual([
+      'CacheWriter.new.first.second 11',
+      'Widget.create 10',
+      'Widget.create(key).save 10',
+      'klass.new 8',
+      'klass.new.run 8',
+      'new ::CacheWriter().ready? 6',
+      'new Billing::Ledger().post 5',
+      'new CacheWriter().first 11',
+      'new CacheWriter().flush! 4',
+      'new CacheWriter().write_cache 3',
+      'new CacheWriter().write_cache 7',
+      'self.class.new 9',
+      'self.class.new(key).run 9',
+    ]);
+  });
+});
diff --git a/__tests__/ruby-ivar-receivers.test.ts b/__tests__/ruby-ivar-receivers.test.ts
new file mode 100644
index 000000000..e28c097e1
--- /dev/null
+++ b/__tests__/ruby-ivar-receivers.test.ts
@@ -0,0 +1,170 @@
+/**
+ * A Ruby call on an instance variable, like `@writer.flush`, links to the
+ * method of the class the class's `initialize` gives the variable:
+ * `@writer = CacheWriter.new` makes it a `CacheWriter`. Before, no call on an
+ * instance variable linked at all.
+ *
+ * Only `initialize` is read, and only a lone `Const.new(…)` types the
+ * variable there: one assigned two classes, a conditional, a value passed
+ * through `.tap`, or anything but `.new` leaves it untyped, and a class the
+ * project doesn't declare (`Logger.new($stdout)`) links nothing. A class
+ * method's `@x` is the class's own, and a module's methods run on whatever
+ * includes it, so neither is typed.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const FILES: Record<string, string> = {
+  'app/writer.rb': `class CacheWriter
+  def flush
+    nil
+  end
+
+  def ready?
+    true
+  end
+end
+
+class OtherWriter
+  def flush
+    nil
+  end
+end
+
+module Billing
+  class Card
+    def charge!(amount)
+      amount
+    end
+  end
+
+  class Ledger < Card
+  end
+end
+`,
+  'app/holder.rb': `class Holder
+  def initialize(key)
+    @writer = CacheWriter.new
+    @lazy ||= OtherWriter.new(
+      key
+    )
+    @either = key ? CacheWriter.new : OtherWriter.new
+    @twice = CacheWriter.new
+    @twice = OtherWriter.new if key
+    @ledger = Billing::Ledger.new key do |l|
+      l
+    end
+    @tapped = CacheWriter.new.tap { |w| w }
+    @outside = Logger.new($stdout)
+    @a, @b = CacheWriter.new, OtherWriter.new
+  end
+
+  def via_ivar
+    @writer.flush
+    @writer.ready?
+    @lazy.flush
+    @either.flush
+    @twice.flush
+    @ledger.charge!(1)
+    @tapped.flush
+    @outside.info("x")
+    @b.flush
+    @unset.flush
+  end
+
+  def self.klass
+    @writer.flush
+  end
+end
+
+module Mixin
+  def mixed
+    @writer.flush
+  end
+end
+`,
+  'app/wide.rb': `class WideHolder
+  def initialize
+    @wide = CacheWriter.new
+    @label = "${'x'.repeat(184)}é"
+  end
+
+  def via_wide
+    @wide.flush
+  end
+end
+`,
+};
+
+let root = '';
+let cg: CodeGraph | undefined;
+
+afterEach(() => {
+  cg?.close();
+  cg = undefined;
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+  root = '';
+});
+
+async function index(): Promise<CodeGraph> {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-ruby-ivar-'));
+  for (const [rel, content] of Object.entries(FILES)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+  return cg;
+}
+
+/** `<qualified name>:<line>` of every `calls` edge written on `line` of `file`. */
+function callsAt(graph: CodeGraph, file: string, line: number): string[] {
+  const ids = graph.getNodesInFile(file).map((n) => n.id);
+  return graph
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls' && e.line === line)
+    .map((e) => {
+      const t = graph.getNode(e.target)!;
+      return `${t.qualifiedName}:${t.startLine}`;
+    })
+    .sort();
+}
+
+describe('Ruby calls on an instance variable initialize types', () => {
+  it('links the method of the class initialize constructs', async () => {
+    const graph = await index();
+    const holder = 'app/holder.rb';
+    expect(callsAt(graph, holder, 19)).toEqual(['CacheWriter::flush:2']);
+    expect(callsAt(graph, holder, 20)).toEqual(['CacheWriter::ready?:6']);
+    // `||=` with its arguments over several lines.
+    expect(callsAt(graph, holder, 21)).toEqual(['OtherWriter::flush:12']);
+    // A namespaced class, built with a block: the method its superclass has.
+    expect(callsAt(graph, holder, 24)).toEqual(['Billing::Card::charge!:19']);
+  });
+
+  it('types nothing initialize leaves ambiguous', async () => {
+    const graph = await index();
+    const holder = 'app/holder.rb';
+    for (const line of [22, 23, 25, 27, 28]) expect(callsAt(graph, holder, line)).toEqual([]);
+  });
+
+  it('links nothing for a class the project does not declare', async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/holder.rb', 26)).toEqual([]);
+  });
+
+  it("leaves a class method's and a module's instance variables untyped", async () => {
+    const graph = await index();
+    expect(callsAt(graph, 'app/holder.rb', 32)).toEqual([]);
+    expect(callsAt(graph, 'app/holder.rb', 38)).toEqual([]);
+  });
+
+  it('still types an ivar when a multibyte character sits at the scan edge of its initializer', async () => {
+    const graph = await index();
+    // `@wide`'s tail crosses byte 200 inside `é`; a byte-indexed slice would
+    // panic (caught per-ref) and leave the call unresolved.
+    expect(callsAt(graph, 'app/wide.rb', 8)).toEqual(['CacheWriter::flush:2']);
+  });
+});
diff --git a/__tests__/rust-cross-crate.test.ts b/__tests__/rust-cross-crate.test.ts
new file mode 100644
index 000000000..685b76bae
--- /dev/null
+++ b/__tests__/rust-cross-crate.test.ts
@@ -0,0 +1,242 @@
+/**
+ * Cross-crate references in a Cargo workspace: a path written from one member
+ * crate into another (`sim::items::ItemPool::for_def(…)`), through a re-export
+ * (`pub use rng::Rng`), through a renamed or non-member path dependency, and
+ * the `crate::` / `super::` paths inside a member crate. Cases from PR #2631
+ * by @BGamboa13.
+ */
+import { afterEach, beforeEach, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { CodeGraph } from '../src';
+
+let root: string;
+let cg: CodeGraph | undefined;
+beforeEach(() => { root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-cross-crate-')); });
+afterEach(() => { cg?.close(); cg = undefined; fs.rmSync(root, { recursive: true, force: true }); });
+
+async function index(files: Record<string, string>) {
+  for (const [file, text] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
+    fs.writeFileSync(path.join(root, file), text);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+}
+
+/** `file:qualifiedName` of everything that has an edge of `kind` into the named symbol. */
+function sources(file: string, qualifiedName: string, kind = 'calls'): string[] {
+  const target = cg!.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName);
+  expect(target, `${file}:${qualifiedName}`).toBeDefined();
+  return cg!.getIncomingEdges(target!.id).filter((e) => e.kind === kind).map((e) => {
+    const src = cg!.getNode(e.source)!;
+    return `${src.filePath}:${src.qualifiedName}`;
+  }).sort();
+}
+
+const WORKSPACE = `[workspace]
+resolver = "2"
+members = ["crates/sim", "crates/server", "crates/client"]
+
+[workspace.dependencies]
+sim = { path = "crates/sim" }
+`;
+const SIM_TOML = '[package]\nname = "sim"\nversion = "0.1.0"\nedition = "2021"\n';
+const SIM_LIB = `pub mod items;
+mod rng;
+pub use rng::Rng;
+pub const RANK_COUNT: usize = 6;
+pub fn median_u32(v: &[u32]) -> u32 { v[0] }
+`;
+const SIM_ITEMS = `pub struct ItemPool { pub n: u32 }
+impl ItemPool {
+    pub fn for_def(def: u32) -> ItemPool { ItemPool { n: def } }
+}
+pub enum Drop { Gold(u32), Nothing }
+pub fn roll_item(p: &ItemPool) -> u32 { p.n }
+`;
+const SIM_RNG = 'pub struct Rng { s: u64 }\nimpl Rng {\n    pub fn new(s: u64) -> Rng { Rng { s } }\n}\n';
+
+const base = (server: Record<string, string>, serverToml = '[package]\nname = "server"\nversion = "0.1.0"\nedition = "2021"\n\n[dependencies]\nsim.workspace = true\n') => ({
+  'Cargo.toml': WORKSPACE,
+  'crates/sim/Cargo.toml': SIM_TOML,
+  'crates/sim/src/lib.rs': SIM_LIB,
+  'crates/sim/src/items.rs': SIM_ITEMS,
+  'crates/sim/src/rng.rs': SIM_RNG,
+  // A decoy: the same type and method names in another member crate.
+  'crates/client/Cargo.toml': '[package]\nname = "client"\nversion = "0.1.0"\nedition = "2021"\n',
+  'crates/client/src/lib.rs': 'pub mod items;\n',
+  'crates/client/src/items.rs': 'pub struct ItemPool;\nimpl ItemPool {\n    pub fn for_def(def: u32) -> ItemPool { ItemPool }\n}\npub fn roll_item() -> u32 { 0 }\n',
+  'crates/server/Cargo.toml': serverToml,
+  ...Object.fromEntries(Object.entries(server).map(([f, t]) => [`crates/server/src/${f}`, t])),
+});
+
+it('resolves a fully qualified call into another workspace crate to that crate', async () => {
+  await index(base({
+    'lib.rs': 'pub mod rift;\npub mod econ;\n',
+    'rift.rs': 'pub fn open() -> u32 {\n    let pool = sim::items::ItemPool::for_def(3);\n    sim::items::roll_item(&pool)\n}\n',
+    'econ/mod.rs': 'pub mod offline;\n',
+    'econ/offline.rs': 'pub fn tick() {\n    let _ = sim::items::ItemPool::for_def(\n        4,\n    );\n}\n',
+  }));
+  expect(sources('crates/sim/src/items.rs', 'ItemPool::for_def')).toEqual([
+    'crates/server/src/econ/offline.rs:tick',
+    'crates/server/src/rift.rs:open',
+  ]);
+  expect(sources('crates/sim/src/items.rs', 'roll_item')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/client/src/items.rs', 'ItemPool::for_def')).toEqual([]);
+});
+
+it('resolves a crate-root item, a re-export, a constant, and an enum variant across crates', async () => {
+  await index(base({
+    'lib.rs': 'pub mod rift;\n',
+    'rift.rs': `use sim::RANK_COUNT;
+pub fn open(v: &[u32]) -> usize {
+    let _r = sim::Rng::new(7);
+    let _m = sim::median_u32(v);
+    let _d = sim::items::Drop::Gold(3);
+    RANK_COUNT
+}
+`,
+  }));
+  expect(sources('crates/sim/src/rng.rs', 'Rng::new')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/sim/src/lib.rs', 'median_u32')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/sim/src/items.rs', 'Drop::Gold')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/sim/src/lib.rs', 'RANK_COUNT', 'imports')).toEqual(['crates/server/src/rift.rs:crates/server/src/rift.rs']);
+});
+
+it('resolves `use` imports of another crate and the calls through them', async () => {
+  await index(base({
+    'lib.rs': 'pub mod rift;\n',
+    'rift.rs': `use sim::items::{roll_item, ItemPool};
+use sim::Rng;
+pub fn open() -> u32 {
+    let _r = Rng::new(1);
+    roll_item(&ItemPool::for_def(2))
+}
+`,
+  }));
+  expect(sources('crates/sim/src/items.rs', 'ItemPool::for_def')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/sim/src/items.rs', 'roll_item')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/sim/src/rng.rs', 'Rng::new')).toEqual(['crates/server/src/rift.rs:open']);
+  expect(sources('crates/sim/src/items.rs', 'ItemPool', 'imports').length).toBeGreaterThan(0);
+  expect(sources('crates/sim/src/rng.rs', 'Rng', 'imports').length).toBeGreaterThan(0);
+});
+
+it('resolves a renamed path dependency and a path dependency outside the workspace members', async () => {
+  await index({
+    ...base(
+      { 'lib.rs': 'pub fn open() -> u32 {\n    let p = core_sim::items::ItemPool::for_def(1);\n    vendored::helper(p.n)\n}\n' },
+      '[package]\nname = "server"\nversion = "0.1.0"\nedition = "2021"\n\n[dependencies]\ncore_sim = { path = "../sim", package = "sim" }\nvendored = { path = "../../libs/vendored" }\n',
+    ),
+    'libs/vendored/Cargo.toml': '[package]\nname = "vendored"\nversion = "0.1.0"\nedition = "2021"\n',
+    'libs/vendored/src/lib.rs': 'pub fn helper(n: u32) -> u32 { n }\n',
+  });
+  expect(sources('crates/sim/src/items.rs', 'ItemPool::for_def')).toEqual(['crates/server/src/lib.rs:open']);
+  expect(sources('libs/vendored/src/lib.rs', 'helper')).toEqual(['crates/server/src/lib.rs:open']);
+});
+
+it('resolves `crate::` and `super::` paths inside a member crate, constants included', async () => {
+  await index(base({
+    'lib.rs': 'pub mod ledger;\npub mod econ;\n',
+    'ledger.rs': 'pub const KEY_RANK_COUNT: usize = 6;\npub static LIMIT: u32 = 9;\npub fn persist() {}\n',
+    'econ/mod.rs': 'pub mod sinks;\npub fn shared() {}\n',
+    'econ/sinks.rs': `use crate::ledger::{KEY_RANK_COUNT, LIMIT};
+pub fn drain() -> usize {
+    crate::ledger::persist();
+    super::shared();
+    KEY_RANK_COUNT + LIMIT as usize
+}
+`,
+  }));
+  expect(sources('crates/server/src/ledger.rs', 'persist')).toEqual(['crates/server/src/econ/sinks.rs:drain']);
+  expect(sources('crates/server/src/econ/mod.rs', 'shared')).toEqual(['crates/server/src/econ/sinks.rs:drain']);
+  expect(sources('crates/server/src/ledger.rs', 'KEY_RANK_COUNT', 'imports').length).toBeGreaterThan(0);
+  expect(sources('crates/server/src/ledger.rs', 'LIMIT', 'imports').length).toBeGreaterThan(0);
+});
+
+it('resolves a module-qualified type by its own path, not through a same-name `use` import', async () => {
+  // tokio shape: `scheduler::Handle` / `driver::Handle` in a file that also
+  // `use`s a third `Handle` — the qualifier decides, never the file-level binding.
+  await index(base({
+    'lib.rs': 'pub mod scheduler;\npub mod driver;\npub mod multi;\n',
+    'scheduler.rs': 'pub enum Handle { A, B }\n',
+    'driver.rs': 'pub struct Handle { pub n: u32 }\n',
+    'multi/mod.rs': 'mod handle;\npub(crate) use handle::Handle;\n',
+    'multi/handle.rs': 'pub struct Handle { pub n: u32 }\n',
+    'user.rs': `use crate::multi::Handle;
+use crate::{driver, scheduler};
+pub fn sched(h: &scheduler::Handle) -> u32 { match h { scheduler::Handle::A => 1, _ => 2 } }
+pub fn drv(h: &driver::Handle) -> u32 { h.n }
+pub fn own(h: &Handle) -> u32 { h.n }
+`,
+  }));
+  const refs = (file: string, qn: string) => sources(file, qn, 'references');
+  expect(refs('crates/server/src/scheduler.rs', 'Handle')).toContain('crates/server/src/user.rs:sched');
+  expect(refs('crates/server/src/driver.rs', 'Handle')).toEqual(['crates/server/src/user.rs:drv']);
+  expect(refs('crates/server/src/multi/handle.rs', 'Handle')).not.toContain('crates/server/src/user.rs:sched');
+  expect(refs('crates/server/src/multi/handle.rs', 'Handle')).not.toContain('crates/server/src/user.rs:drv');
+  expect(refs('crates/server/src/multi/handle.rs', 'Handle')).toContain('crates/server/src/user.rs:own');
+});
+
+it('reads a module qualifier written across lines, instead of falling back to the same-name `use` import', async () => {
+  await index(base({
+    'lib.rs': 'pub mod scheduler;\npub mod multi;\n',
+    'scheduler.rs': 'pub enum Handle { A, B }\n',
+    'multi/mod.rs': 'mod handle;\npub(crate) use handle::Handle;\n',
+    'multi/handle.rs': 'pub struct Handle { pub n: u32 }\n',
+    'user.rs': `use crate::multi::Handle;
+use crate::scheduler;
+pub fn sched(
+    h: &scheduler::
+        Handle,
+) -> u32 { 1 }
+`,
+  }));
+  expect(sources('crates/server/src/scheduler.rs', 'Handle', 'references')).toContain('crates/server/src/user.rs:sched');
+  expect(sources('crates/server/src/multi/handle.rs', 'Handle', 'references')).not.toContain('crates/server/src/user.rs:sched');
+});
+
+it('does not read a commented-out path above a leaf as its qualifier', async () => {
+  await index(base({
+    'lib.rs': 'pub mod scheduler;\npub mod multi;\n',
+    'scheduler.rs': 'pub struct Handle { pub n: u32 }\nimpl Handle { pub fn new() -> Handle { Handle { n: 0 } } }\n',
+    'multi/mod.rs': 'mod handle;\npub(crate) use handle::Handle;\n',
+    'multi/handle.rs': 'pub struct Handle { pub n: u32 }\nimpl Handle { pub fn new() -> Handle { Handle { n: 1 } } }\n',
+    'user.rs': `use crate::multi::Handle;
+pub fn make() -> Handle {
+    // crate::scheduler::
+    Handle { n: 3 }
+}
+pub fn make_block() -> Handle {
+    /* crate::scheduler:: */
+    Handle { n: 4 }
+}
+`,
+  }));
+  /** Every file:function with any edge into the file's `Handle` type or its `new`. */
+  const touches = (file: string) => cg!.getNodesInFile(file)
+    .filter((n) => n.name === 'Handle' || n.name === 'new')
+    .flatMap((n) => cg!.getIncomingEdges(n.id).map((e) => cg!.getNode(e.source)!))
+    .map((src) => `${src.filePath}:${src.qualifiedName}`);
+  for (const fn of ['make', 'make_block']) {
+    expect(touches('crates/server/src/scheduler.rs')).not.toContain(`crates/server/src/user.rs:${fn}`);
+    expect(touches('crates/server/src/multi/handle.rs')).toContain(`crates/server/src/user.rs:${fn}`);
+  }
+});
+
+it('leaves a path-dependency key unresolved when two crates bind it to different directories', async () => {
+  const pkg = (name: string, dep = '') => `[package]\nname = "${name}"\nversion = "0.1.0"\nedition = "2021"\n${dep}`;
+  await index({
+    'Cargo.toml': '[workspace]\nmembers = ["crates/server", "crates/client"]\n',
+    'crates/server/Cargo.toml': pkg('server', '\n[dependencies]\nutil = { path = "../../libs/util_a", package = "util_a" }\n'),
+    'crates/server/src/lib.rs': 'pub fn s() -> u32 { util::unique_a(1) }\n',
+    'crates/client/Cargo.toml': pkg('client', '\n[dependencies]\nutil = { path = "../../libs/util_b", package = "util_b" }\n'),
+    'crates/client/src/lib.rs': 'pub fn c() -> u32 { util::unique_b(2) }\n',
+    'libs/util_a/Cargo.toml': pkg('util_a'),
+    'libs/util_a/src/lib.rs': 'pub fn unique_a(n: u32) -> u32 { n }\npub fn unique_b(n: u32) -> u32 { n + 1 }\n',
+    'libs/util_b/Cargo.toml': pkg('util_b'),
+    'libs/util_b/src/lib.rs': 'pub fn unique_b(n: u32) -> u32 { n }\n',
+  });
+  // `client`'s `util` is util_b — it must never be answered with util_a's `unique_b`.
+  expect(sources('libs/util_a/src/lib.rs', 'unique_b')).not.toContain('crates/client/src/lib.rs:c');
+});
diff --git a/__tests__/rust-manifest-paths.test.ts b/__tests__/rust-manifest-paths.test.ts
new file mode 100644
index 000000000..c5535cc91
--- /dev/null
+++ b/__tests__/rust-manifest-paths.test.ts
@@ -0,0 +1,60 @@
+/**
+ * A Cargo workspace's members are read only inside the project: a member a
+ * manifest writes as `../sibling`, or as an absolute path, is neither read
+ * nor listed, so the cross-crate paths built on them stay in the project.
+ */
+import { describe, expect, it } from 'vitest';
+import * as path from 'node:path';
+import { getCargoWorkspaceCrateMap } from '../src/resolution/frameworks/cargo-workspace';
+import type { ResolutionContext } from '../src/resolution/types';
+import { escapesRoot } from '../src/utils';
+
+function stubContext(files: Record<string, string>, dirs: Record<string, string[]>) {
+  const read: string[] = [];
+  const listed: string[] = [];
+  const context = {
+    readFile: (p: string) => {
+      read.push(p);
+      return files[p] ?? null;
+    },
+    listDirectories: (p: string) => {
+      listed.push(p);
+      return dirs[p] ?? [];
+    },
+    fileExists: (p: string) => p in files,
+  } as unknown as ResolutionContext;
+  return { context, read, listed };
+}
+
+const outside = (p: string): boolean => escapesRoot(path.posix.normalize(p));
+
+describe('Cargo workspace members stay inside the project', () => {
+  it('reads and lists no member outside the project', () => {
+    const { context, read, listed } = stubContext(
+      {
+        'Cargo.toml': '[workspace]\nmembers = ["crates/*", "app", "../outside", "../vendor/*", "/abs/crate", "crates/../../escape"]\n',
+        'crates/core/Cargo.toml': '[package]\nname = "core-crate"\n',
+        'app/Cargo.toml': '[package]\nname = "app"\n',
+        '../outside/Cargo.toml': '[package]\nname = "outside"\n',
+        '/abs/crate/Cargo.toml': '[package]\nname = "abs"\n',
+      },
+      { crates: ['core'], '../vendor': ['x'] },
+    );
+    const map = getCargoWorkspaceCrateMap(context);
+    expect([...map.keys()].sort()).toEqual(['app', 'core-crate', 'core_crate']);
+    expect(read.filter(outside)).toEqual([]);
+    expect(listed.filter(outside)).toEqual([]);
+  });
+
+  it('reads a member whose folder only starts with two dots', () => {
+    const { context, read } = stubContext(
+      {
+        'Cargo.toml': '[workspace]\nmembers = ["..generated/crate"]\n',
+        '..generated/crate/Cargo.toml': '[package]\nname = "generated"\n',
+      },
+      {},
+    );
+    expect([...getCargoWorkspaceCrateMap(context).keys()]).toEqual(['generated']);
+    expect(read).toContain('..generated/crate/Cargo.toml');
+  });
+});
diff --git a/__tests__/rust-path-attribute-modules.test.ts b/__tests__/rust-path-attribute-modules.test.ts
new file mode 100644
index 000000000..617d7c515
--- /dev/null
+++ b/__tests__/rust-path-attribute-modules.test.ts
@@ -0,0 +1,148 @@
+/**
+ * A Rust module loaded with `#[path = "…"]` is the module that declares it
+ * (the Rust Reference, "The path attribute"): its `super` is the declaring
+ * module, wherever the file lies, so `use super::*` brings in that module's
+ * items, private ones included, and `crate::` is the declaring file's crate.
+ * The path is read from the declaring file's directory, or from an inline
+ * module's own directory. A module whose cfg alternatives each name a file,
+ * or whose path a `cfg_attr` sets, depends on the build and stays unread.
+ * A file several declarations load is each one's from its own side, and an
+ * example the manifest places at a path of its own is its own crate's root.
+ */
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-path-attr-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[workspace]\nmembers = ["crates/core", "crates/py"]\nresolver = "2"\n',
+    'crates/core/Cargo.toml': '[package]\nname = "core-crate"\nversion = "0.1.0"\nedition = "2021"\n\n[[example]]\nname = "demo"\npath = "examples/nested/demo.rs"\n',
+    'crates/core/src/lib.rs': 'pub mod scaling;\npub mod platform;\npub mod util;\n\npub fn root_helper() -> i32 {\n    0\n}\n\npub mod gen_user;\n',
+    'crates/core/src/util.rs': 'pub fn helper() -> i32 {\n    10\n}\n',
+    // A folder whose name only starts with two dots is inside the project.
+    'crates/core/src/gen_user.rs': '#[path = "..generated/gen.rs"]\nmod gen;\n\npub fn via_gen() -> i32 {\n    gen::make_gen()\n}\n',
+    'crates/core/src/..generated/gen.rs': 'pub fn make_gen() -> i32 {\n    13\n}\n',
+    // An example the manifest places at a path of its own: its own crate, whose `mod util;` is its sibling.
+    'crates/core/examples/nested/demo.rs': 'mod util;\n\nfn main() {\n    let _ = crate::util::helper();\n}\n',
+    'crates/core/examples/nested/util.rs': 'pub fn helper() -> i32 {\n    11\n}\n',
+    // Two tests load one helper: from each, `support` is that file.
+    'crates/core/tests/a.rs': '#[path = "support/helpers.rs"]\nmod support;\n\n#[test]\nfn uses_support() {\n    let _ = support::make();\n}\n',
+    'crates/core/tests/b.rs': '#[path = "support/helpers.rs"]\nmod support;\n\n#[test]\nfn uses_support_too() {\n    let _ = support::make();\n}\n',
+    'crates/core/tests/support/helpers.rs': 'pub fn make() -> i32 {\n    12\n}\n',
+    'crates/core/src/scaling.rs': `pub fn predict_rating_multi(x: i32) -> i32 {
+    x + 1
+}
+
+fn private_helper() -> i32 {
+    2
+}
+
+#[cfg(test)]
+#[path = "../../../tests/unit/scaling_tests.rs"]
+mod tests;
+`,
+    'crates/core/src/platform.rs': `#[cfg(unix)]
+#[path = "platform/unix_impl.rs"]
+mod imp;
+#[cfg(windows)]
+#[path = "platform/windows_impl.rs"]
+mod imp;
+
+pub fn open() -> i32 {
+    3
+}
+
+pub fn via_imp() -> i32 {
+    imp::open_impl()
+}
+
+mod inline {
+    #[path = "other.rs"]
+    mod inner;
+}
+
+#[cfg_attr(docsrs, path = "docs_impl.rs")]
+mod documented;
+
+pub fn via_documented() -> i32 {
+    documented::run()
+}
+`,
+    'crates/core/src/platform/unix_impl.rs': 'pub fn open_impl() -> i32 {\n    1\n}\n',
+    'crates/core/src/platform/windows_impl.rs': 'pub fn open_impl() -> i32 {\n    2\n}\n',
+    // In a non-mod-rs file's inline module, the path starts at that module's own directory.
+    'crates/core/src/platform/inline/other.rs': 'pub fn from_inner() -> i32 {\n    super::super::open()\n}\n',
+    'crates/core/src/platform/other.rs': 'pub fn decoy() -> i32 {\n    4\n}\n',
+    'crates/core/src/documented.rs': 'pub fn run() -> i32 {\n    5\n}\n',
+    'crates/core/src/platform/docs_impl.rs': 'pub fn run() -> i32 {\n    6\n}\n',
+    'crates/py/Cargo.toml': '[package]\nname = "py-crate"\nversion = "0.1.0"\nedition = "2021"\n',
+    'crates/py/src/lib.rs': 'pub fn predict_rating_multi(x: i32) -> i32 {\n    x + 99\n}\n\npub fn private_helper() -> i32 {\n    98\n}\n\npub fn root_helper() -> i32 {\n    97\n}\n\npub fn open() -> i32 {\n    96\n}\n\npub fn make() -> i32 {\n    95\n}\n',
+    'tests/unit/scaling_tests.rs': `use super::*;
+
+#[test]
+fn uses_private() {
+    let _ = private_helper();
+}
+
+#[test]
+fn uses_crate() {
+    let _ = crate::root_helper();
+}
+`,
+  };
+  for (const [relative, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, relative)), { recursive: true });
+    fs.writeFileSync(path.join(root, relative), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const calls = (file: string, name: string): string[] => {
+  const fn = cg.getNodesInFile(file).find((n) => n.name === name && n.kind === 'function');
+  expect(fn, `${file}:${name}`).toBeDefined();
+  return cg.getOutgoingEdgesFrom([fn!.id]).filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.qualifiedName} ${t.filePath}:${t.startLine}`).sort();
+};
+
+describe('Rust modules a #[path] attribute loads', () => {
+  it('see the declaring module\'s private items through `use super::*`', () => {
+    expect(calls('tests/unit/scaling_tests.rs', 'uses_private')).toEqual(['private_helper crates/core/src/scaling.rs:5']);
+  });
+
+  it('start `crate::` from the declaring file\'s crate', () => {
+    expect(calls('tests/unit/scaling_tests.rs', 'uses_crate')).toEqual(['root_helper crates/core/src/lib.rs:5']);
+  });
+
+  it('read the path from an inline module\'s own directory', () => {
+    expect(calls('crates/core/src/platform/inline/other.rs', 'from_inner')).toEqual(['open crates/core/src/platform.rs:8']);
+  });
+
+  it('follow each declaring file into a helper several tests load', () => {
+    expect(calls('crates/core/tests/a.rs', 'uses_support')).toEqual(['make crates/core/tests/support/helpers.rs:1']);
+    expect(calls('crates/core/tests/b.rs', 'uses_support_too')).toEqual(['make crates/core/tests/support/helpers.rs:1']);
+  });
+
+  it('read a path into a folder whose name only starts with two dots', () => {
+    expect(calls('crates/core/src/gen_user.rs', 'via_gen')).toEqual(['make_gen crates/core/src/..generated/gen.rs:1']);
+  });
+
+  it('start an example the manifest places at a path of its own from that example', () => {
+    expect(calls('crates/core/examples/nested/demo.rs', 'main')).toEqual(['helper crates/core/examples/nested/util.rs:1']);
+  });
+
+  it('leave a module whose cfg alternatives name a file each, or whose path a cfg_attr sets, unread', () => {
+    expect(calls('crates/core/src/platform.rs', 'via_imp')).toEqual([]);
+    expect(calls('crates/core/src/platform.rs', 'via_documented')).toEqual([]);
+  });
+});
diff --git a/__tests__/rust-path-super-glob.test.ts b/__tests__/rust-path-super-glob.test.ts
new file mode 100644
index 000000000..c24899486
--- /dev/null
+++ b/__tests__/rust-path-super-glob.test.ts
@@ -0,0 +1,86 @@
+/**
+ * Regression: #[path]-included test modules with `use super::*` must resolve
+ * bare callees through the declaring parent module, not a same-named symbol
+ * elsewhere in the workspace (ContextualWisdomLab/fast-mlsirm#1837). Case
+ * from PR #1892 by @seonghobae.
+ */
+import { afterEach, beforeEach, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { CodeGraph } from '../src';
+
+let root: string;
+let cg: CodeGraph | undefined;
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-path-super-'));
+});
+
+afterEach(() => {
+  cg?.close();
+  cg = undefined;
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+async function indexWorkspace(layout: Record<string, string>) {
+  fs.writeFileSync(
+    path.join(root, 'Cargo.toml'),
+    '[workspace]\nmembers = ["crates/core", "crates/py"]\nresolver = "2"\n'
+  );
+  fs.mkdirSync(path.join(root, 'crates/core/src'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'crates/py/src'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'tests/unit'), { recursive: true });
+  fs.writeFileSync(
+    path.join(root, 'crates/core/Cargo.toml'),
+    '[package]\nname = "core-crate"\nversion = "0.1.0"\nedition = "2021"\n'
+  );
+  fs.writeFileSync(
+    path.join(root, 'crates/py/Cargo.toml'),
+    '[package]\nname = "py-crate"\nversion = "0.1.0"\nedition = "2021"\n'
+  );
+  for (const [file, text] of Object.entries(layout)) {
+    const dest = path.join(root, file);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, text);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+}
+
+function callTargets(testFn: string): string[] {
+  const caller = cg!
+    .getNodesByKind('function')
+    .find((n) => n.filePath === 'tests/unit/scaling_tests.rs' && n.name === testFn);
+  expect(caller).toBeDefined();
+  return cg!
+    .getOutgoingEdges(caller!.id)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => {
+      const target = cg!.getNode(e.target)!;
+      return `${target.filePath}:${target.qualifiedName ?? target.name}`;
+    });
+}
+
+it('resolves use super::* callee through #[path] parent, not a same-named decoy (#1837)', async () => {
+  await indexWorkspace({
+    'crates/core/src/lib.rs': 'pub mod scaling;',
+    'crates/core/src/scaling.rs': `pub fn predict_rating_multi(x: i32) -> i32 { x + 1 }
+
+#[cfg(test)]
+#[path = "../../../tests/unit/scaling_tests.rs"]
+mod tests;
+`,
+    'crates/py/src/lib.rs': 'pub fn predict_rating_multi(x: i32) -> i32 { x + 99 }',
+    'tests/unit/scaling_tests.rs': `use super::*;
+
+#[test]
+fn pr_elom_rowmean() {
+    let _ = predict_rating_multi(1);
+}
+`,
+  });
+
+  expect(callTargets('pr_elom_rowmean')).toEqual([
+    'crates/core/src/scaling.rs:predict_rating_multi',
+  ]);
+});
diff --git a/__tests__/rust-type-member-paths.test.ts b/__tests__/rust-type-member-paths.test.ts
new file mode 100644
index 000000000..bde513053
--- /dev/null
+++ b/__tests__/rust-type-member-paths.test.ts
@@ -0,0 +1,91 @@
+/**
+ * A Rust call through a type a path or a `use` names — `Handle::current()`
+ * under `use crate::runtime::Handle;`, `crate::models::Mode::Fast(1)`,
+ * `Codec::encode(&x)` under `use crate::codec::Codec;` — is to that type's
+ * own associated function, variant, or (for a trait) declared method, never a
+ * namesake type's in another module. A type from the standard library or a
+ * dependency links nothing, and a type alias is left as it was.
+ */
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-type-member-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[package]\nname = "app"\nversion = "0.1.0"\nedition = "2021"\n\n[dependencies]\nserde_json = "1"\n',
+    'src/lib.rs': 'pub mod runtime;\npub mod driver;\npub mod models;\npub mod codec;\npub mod alias;\npub mod user;\n',
+    'src/runtime/mod.rs': 'mod handle;\npub use handle::Handle;\n',
+    'src/runtime/handle.rs': 'pub struct Handle;\n\nimpl Handle {\n    pub fn current() -> Handle {\n        Handle\n    }\n}\n',
+    'src/driver.rs': 'pub struct Handle;\n\nimpl Handle {\n    pub fn current() -> Handle {\n        Handle\n    }\n}\n',
+    'src/models.rs': 'pub enum Mode {\n    Fast(u8),\n    Slow,\n}\n\npub struct Fast(pub u8);\n',
+    'src/codec.rs': 'pub trait Codec {\n    fn encode(&self) -> u8;\n}\n\npub struct Bytes;\n\nimpl Codec for Bytes {\n    fn encode(&self) -> u8 {\n        1\n    }\n}\n',
+    'src/alias.rs': 'pub type Shortcut = crate::driver::Handle;\n',
+    'src/user.rs': `use std::collections::HashMap;
+use serde_json::Value;
+use crate::runtime::Handle;
+use crate::codec::{Bytes, Codec};
+use crate::alias::Shortcut;
+
+pub fn current() {
+    let _ = Handle::current();
+}
+
+pub fn variant() {
+    let _ = crate::models::Mode::Fast(1);
+}
+
+pub fn through_trait() {
+    let _ = Codec::encode(&Bytes);
+}
+
+pub fn outside() {
+    let _ = HashMap::<u8, u8>::new();
+    let _ = Value::from(1);
+}
+
+pub fn through_alias() {
+    let _ = Shortcut::current();
+}
+`,
+  };
+  for (const [relative, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, relative)), { recursive: true });
+    fs.writeFileSync(path.join(root, relative), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const calls = (name: string): string[] => {
+  const fn = cg.getNodesInFile('src/user.rs').find((n) => n.name === name && n.kind === 'function')!;
+  return cg.getOutgoingEdgesFrom([fn.id]).filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.kind} ${t.qualifiedName} ${t.filePath}:${t.startLine}`).sort();
+};
+
+describe('Rust calls through a type a path or a use names', () => {
+  it('reach that type\'s own function, not a namesake type\'s', () => {
+    expect(calls('current')).toEqual(['method Handle::current src/runtime/handle.rs:4']);
+  });
+
+  it('reach an enum\'s variant through a module path', () => {
+    expect(calls('variant')).toEqual(['enum_member Mode::Fast src/models.rs:2']);
+  });
+
+  it('reach a trait\'s own method through the trait', () => {
+    expect(calls('through_trait')).toEqual(['method Codec::encode src/codec.rs:2']);
+  });
+
+  it('link nothing for a standard library or dependency type', () => {
+    expect(calls('outside')).toEqual([]);
+  });
+});
diff --git a/__tests__/vue-self-closing-script.test.ts b/__tests__/vue-self-closing-script.test.ts
new file mode 100644
index 000000000..dfe2c1087
--- /dev/null
+++ b/__tests__/vue-self-closing-script.test.ts
@@ -0,0 +1,102 @@
+/**
+ * A self-closing `<script ... />` in a Vue single-file component, such as a
+ * `<script src="./legacy.js" />` block, has no body. Vue, Svelte and Astro
+ * shared one script pattern that read it as an opening tag running on to the
+ * next `</script>`: the `<script setup>` after it was parsed with whatever lay
+ * in between, failed, and contributed no symbols, and a template in between
+ * lost its calls and components too (#2989, #2995 and #2997 for Astro and
+ * Svelte). The three extractors now share one pattern pair, and a
+ * self-closing tag covers nothing a template scan should skip.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadAllGrammars } from '../src/extraction/grammars';
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadAllGrammars();
+});
+
+const calls = (result: ReturnType<typeof extractFromSource>, name: string, line: number) =>
+  result.unresolvedReferences.some((ref) => ref.referenceKind === 'calls' && ref.referenceName === name && ref.line === line);
+const renders = (result: ReturnType<typeof extractFromSource>, name: string, line: number) =>
+  result.unresolvedReferences.some((ref) => ref.referenceKind === 'references' && ref.referenceName === name && ref.line === line);
+
+describe('Vue self-closing <script />', () => {
+  it('does not swallow the <script setup> that follows it', () => {
+    const code = `<template>
+  <p>{{ formatDate(date) }}</p>
+  <Header />
+</template>
+<script src="./legacy.js" />
+<script setup>
+const ready = true;
+function go() { return helper(); }
+</script>
+`;
+    const result = extractFromSource('src/components/Page.vue', code);
+
+    expect(result.errors).toEqual([]);
+    expect(result.nodes.find((n) => n.name === 'ready')?.startLine).toBe(7);
+    expect(result.nodes.find((n) => n.name === 'go')?.startLine).toBe(8);
+    expect(calls(result, 'helper', 8)).toBe(true);
+    expect(calls(result, 'formatDate', 2)).toBe(true);
+    expect(renders(result, 'Header', 3)).toBe(true);
+  });
+
+  it('keeps the template it comes before', () => {
+    const code = `<script src="./legacy.js" />
+<template>
+  <p>{{ formatDate(date) }}</p>
+  <Header />
+</template>
+<script setup>
+const ready = true;
+</script>
+`;
+    const result = extractFromSource('src/components/First.vue', code);
+
+    expect(result.errors).toEqual([]);
+    expect(result.nodes.find((n) => n.name === 'ready')?.startLine).toBe(7);
+    expect(calls(result, 'formatDate', 3)).toBe(true);
+    expect(renders(result, 'Header', 4)).toBe(true);
+  });
+
+  it("still reads a call in a self-closing <script />'s attributes", () => {
+    const code = `<template>
+  <article>
+    <script type="application/ld+json" :innerHTML="toJsonLd(post)" />
+    <p>{{ formatDate(post.date) }}</p>
+    <Header />
+  </article>
+</template>
+<script setup>
+const ready = true;
+</script>
+`;
+    const result = extractFromSource('src/components/Post.vue', code);
+
+    expect(result.errors).toEqual([]);
+    expect(result.nodes.find((n) => n.name === 'ready')?.startLine).toBe(9);
+    expect(calls(result, 'toJsonLd', 3)).toBe(true);
+    expect(calls(result, 'formatDate', 4)).toBe(true);
+    expect(renders(result, 'Header', 5)).toBe(true);
+  });
+
+  // The template-call scan always took `</script >` as a closing tag; with one
+  // pattern for every site, the script reader does too.
+  it('ends a block at a closing tag written with a space, `</script >`', () => {
+    const code = `<template>
+  <p>{{ formatDate(date) }}</p>
+</template>
+<script setup>
+const ready = true;
+</script >
+`;
+    const result = extractFromSource('src/components/Spaced.vue', code);
+
+    expect(result.errors).toEqual([]);
+    expect(result.nodes.find((n) => n.name === 'ready')?.startLine).toBe(5);
+    expect(calls(result, 'formatDate', 2)).toBe(true);
+  });
+});
diff --git a/codegraph-kernel/src/python.rs b/codegraph-kernel/src/python.rs
index a65a26401..a0269f65d 100644
--- a/codegraph-kernel/src/python.rs
+++ b/codegraph-kernel/src/python.rs
@@ -72,6 +72,21 @@ fn body_docstring(node: Node, src: &str) -> Option<String> {
     if cleaned.is_empty() { None } else { Some(cleaned) }
 }
 
+/// The identifiers a Python assignment or loop target binds: a bare name, or
+/// the names inside tuple, list and star targets. An attribute or subscript
+/// store binds nothing.
+fn target_names<'t>(node: Node<'t>, out: &mut Vec<Node<'t>>) {
+    match node.kind() {
+        "identifier" => out.push(node),
+        "attribute" | "subscript" => {}
+        _ => {
+            for c in named_kids(node) {
+                target_names(c, out);
+            }
+        }
+    }
+}
+
 fn docstring_space(c: char) -> bool {
     // Match JavaScript trim, including BOM but excluding NEXT LINE.
     (c.is_whitespace() && c != '\u{85}') || c == '\u{feff}'
@@ -344,9 +359,7 @@ impl<'t> Walker<'t> {
         if kind == "call" {
             self.extract_call(node);
         }
-        if kind == "assignment" {
-            self.emit_local_assignment_binding(node);
-        }
+        self.emit_statement_bindings(node);
         // An import inside a function body binds a name for that body: a row
         // scoped to the function (no import node, no `imports` ref — the
         // module-level walk owns those, as before).
@@ -633,16 +646,51 @@ impl<'t> Walker<'t> {
         }
     }
 
-    /// `x = …` inside a function body: a nodeless `local` row for the name.
-    fn emit_local_assignment_binding(&mut self, node: Node<'t>) {
+    /// The names a function-body statement or pattern binds besides a
+    /// definition or import: assignment (augmented and tuple targets too),
+    /// `for` and `with`/`except … as` targets, a walrus, and a `case` capture.
+    /// Each is a nodeless `local` row scoped to the function. A comprehension
+    /// variable or lambda parameter binds in its own expression, narrower
+    /// than the line-granular scope a row carries; the resolver reads those
+    /// from the syntax tree (`python_expression_binds`).
+    fn emit_statement_bindings(&mut self, node: Node<'t>) {
+        let mut targets = Vec::new();
+        match node.kind() {
+            "assignment" | "augmented_assignment" | "for_statement" => {
+                if let Some(left) = node.child_by_field_name("left") {
+                    target_names(left, &mut targets);
+                }
+            }
+            "as_pattern" => {
+                if let Some(alias) = node.child_by_field_name("alias") {
+                    target_names(alias, &mut targets);
+                }
+            }
+            "except_clause" | "except_group_clause" => {
+                if let Some(alias) = node.child_by_field_name("alias") {
+                    target_names(alias, &mut targets);
+                }
+            }
+            "named_expression" => {
+                if let Some(name) = node.child_by_field_name("name") {
+                    targets.push(name);
+                }
+            }
+            // `case other:` and `case Point(x=other)` capture; `other.MODE` is a value.
+            "dotted_name" if matches!(node.parent().map(|p| p.kind()), Some("case_pattern" | "keyword_pattern")) => {
+                if node.named_child_count() == 1 {
+                    targets.extend(node.named_child(0));
+                }
+            }
+            "splat_pattern" => targets.extend(node.named_child(0).filter(|c| c.kind() == "identifier")),
+            _ => {}
+        }
         let Some(scope) = self.enclosing_scope() else { return };
-        let Some(left) = node.child_by_field_name("left") else { return };
-        if left.kind() != "identifier" {
-            return;
+        for name_node in targets {
+            let name = self.text(name_node).to_string();
+            let line = self.line_of(name_node);
+            self.push_binding_row(BINDING_LOCAL, &name, NONE, scope, line, None, false, None);
         }
-        let name = self.text(left).to_string();
-        let line = self.line_of(left);
-        self.push_binding_row(BINDING_LOCAL, &name, NONE, scope, line, None, false, None);
     }
 
     /// Rows for an import statement without the node and refs `extract_import`
diff --git a/codegraph-kernel/src/resolve/awaited.rs b/codegraph-kernel/src/resolve/awaited.rs
index 7797936bc..ef2b5145a 100644
--- a/codegraph-kernel/src/resolve/awaited.rs
+++ b/codegraph-kernel/src/resolve/awaited.rs
@@ -57,7 +57,7 @@ fn awaited_names(text: &str) -> HashSet<String> {
 }
 
 /// Push `c` blanked: one space per UTF-16 unit, a newline kept.
-fn push_blank(out: &mut String, c: char) {
+pub(super) fn push_blank(out: &mut String, c: char) {
     if c == '\n' {
         out.push('\n');
     } else {
diff --git a/codegraph-kernel/src/resolve/imports.rs b/codegraph-kernel/src/resolve/imports.rs
index 2cc103201..1459446fb 100644
--- a/codegraph-kernel/src/resolve/imports.rs
+++ b/codegraph-kernel/src/resolve/imports.rs
@@ -888,6 +888,9 @@ impl KernelResolver {
         }
         let imports = if r.language == "python" && r.reference_kind != "imports" {
             let root = r.reference_name.split('.').next().unwrap();
+            if self.python_expression_binds(root, r) {
+                return Ok(None);
+            }
             match self.receiver_binding(root, r)? {
                 Some(binding) if binding.kind == "import" => {
                     // Unaliased imports share the package object across scopes,
diff --git a/codegraph-kernel/src/resolve/lang_scope.rs b/codegraph-kernel/src/resolve/lang_scope.rs
index 25a8d5303..38657c514 100644
--- a/codegraph-kernel/src/resolve/lang_scope.rs
+++ b/codegraph-kernel/src/resolve/lang_scope.rs
@@ -598,11 +598,7 @@ impl KernelResolver {
                 let to = (decl.end_line.max(0) as usize).min(lines.len());
                 let mixes: Vec<String> = lines[from..to.max(from)]
                     .iter()
-                    .filter_map(|line| {
-                        re!(r"^\s*(?:include|extend|prepend)\s+([A-Z:][A-Za-z0-9_:]*(?:\s*,\s*[A-Z:][A-Za-z0-9_:]*)*)")
-                            .captures(line)
-                            .map(|m| m[1].to_string())
-                    })
+                    .filter_map(|line| ruby_mixin_list(line))
                     .collect();
                 for mix in mixes {
                     for name in re!(r"\s*,\s*").split(&mix) {
@@ -967,3 +963,20 @@ impl KernelResolver {
         }))
     }
 }
+
+/// The constants an `include` / `extend` / `prepend` line names, comma
+/// separated. A module a call returns (`include RouteSet.new.tap { … }.url_helpers`)
+/// is no mixin of the constant the call starts at: the list ends before a
+/// name that is followed by a `.` or `(`, as a name's own trailing word
+/// characters never do.
+fn ruby_mixin_list(line: &str) -> Option<String> {
+    let m = re!(r"^\s*(?:include|extend|prepend)\s+([A-Z:][A-Za-z0-9_:]*(?:\s*,\s*[A-Z:][A-Za-z0-9_:]*)*)").captures(line)?;
+    let whole = m.get(1)?;
+    let mut names: Vec<&str> = re!(r"\s*,\s*").split(whole.as_str()).collect();
+    let rest = line[whole.end()..].trim_start();
+    if rest.starts_with(['.', '(']) {
+        // Backtracking drops the last name; the one before it is followed by `,`.
+        names.pop();
+    }
+    (!names.is_empty()).then(|| names.join(","))
+}
diff --git a/codegraph-kernel/src/resolve/method_call.rs b/codegraph-kernel/src/resolve/method_call.rs
index 2ca88f29f..7a36ad352 100644
--- a/codegraph-kernel/src/resolve/method_call.rs
+++ b/codegraph-kernel/src/resolve/method_call.rs
@@ -660,6 +660,14 @@ impl KernelResolver {
         } else {
             None
         }
+        .or_else(|| {
+            // A Ruby method name may end in `!` or `?`: `writer.flush!`, `writer.ready?`.
+            if r.language == "ruby" {
+                re!(r"^([A-Za-z0-9_.]+)\.([A-Za-z0-9_]+[!?])$").captures(&r.reference_name)
+            } else {
+                None
+            }
+        })
         .or_else(|| dot_re.captures(&r.reference_name));
         if dot_match.is_none() && r.language == "cpp" {
             let op_re = re!(r"^([A-Za-z0-9_.]+)\.(operator[^A-Za-z0-9_\s.]+)$");
@@ -1490,7 +1498,16 @@ if inferred.is_none() && r.language == "dart" {
                     resolved_by: "instance-method",
                 }));
             }
-            if target.len() > 1 {
+            // Not for a Ruby name ending in `!` or `?` called on a value:
+            // `key?`, `empty?`, `respond_to?`, `is_a?` and `merge!` are what the
+            // core classes answer on nearly every receiver, and the receiver's
+            // words can't tell which project method of the name, if any, is
+            // meant. A constant receiver (`MarshalWithFallback.dumped?`) still
+            // names its owner.
+            let ruby_bang_or_predicate = r.language == "ruby"
+                && method_name.ends_with(['!', '?'])
+                && super::call_shape::receiver_link(&object_or_class).starts_with(|c: char| c.is_ascii_lowercase() || c == '_');
+            if target.len() > 1 && !ruby_bang_or_predicate {
                 let receiver_words = split_camel_case(super::call_shape::receiver_link(&object_or_class));
                 // Same-file candidates first, so a score tie resolves to the
                 // call site's own file (`score > bestScore` keeps first seen).
@@ -1663,7 +1680,7 @@ if inferred.is_none() && r.language == "dart" {
             // method (`def self.m`) when it and `def m` share the qualified
             // name, then the owner's Ruby ancestry (#2834).
             if c.language == "ruby" {
-                if let Some((found, own)) = self.ruby_method_of(&c.qualified_name, method, r)? {
+                if let Some((found, own)) = self.ruby_method_of(&c.qualified_name, method, r, "class")? {
                     return Ok(Some(KCand { node: found, confidence: if own { confidence } else { 0.8 }, resolved_by }));
                 }
                 continue;
diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index 60a12eb92..1e44aa08a 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -644,6 +644,7 @@ mod kotlin_receiver;
 mod this_member;
 mod member_fn_ref;
 mod python_globals;
+mod python_expression_scope;
 mod object_literal;
 mod cpp;
 mod cpp_types;
@@ -748,6 +749,9 @@ pub struct KernelResolver {
     rust_typed_refs: HashSet<i64>,
     /// rustTraitOf, by method id → the enclosing trait node's id.
     rust_trait_of_memo: HashMap<String, Option<String>>,
+    /// RUST_TYPE_MEMBERS (name-matcher.ts): a `Type::member` lookup, by
+    /// (type id, member) → the member node's id.
+    rust_type_member_memo: HashMap<String, Option<String>>,
     /// goDotImports, by file path.
     go_dot_imports_memo: HashMap<String, fields::GoDotImports>,
     /// A Go bound-receiver arm proved the receiver has no project method —
@@ -785,6 +789,10 @@ pub struct KernelResolver {
     dart_hierarchy_memo: HashMap<(String, i64), Rc<HashMap<String, u32>>>,
     /// Kotlin supertypes named in a type's head, by type name.
     kotlin_supers_memo: HashMap<String, Rc<Vec<String>>>,
+    /// rubyIvarClass (#3053): the class `initialize` gives an instance
+    /// variable, by `owner\0name`. `None` = untyped (left to the other
+    /// strategies); `Some(None)` = typed to a class the project lacks.
+    ruby_ivar_memo: HashMap<String, Option<Option<Arc<KNode>>>>,
     /// kotlinFileScope, by file.
     declared_member_memo: HashMap<(String, String), Option<String>>,
     declared_member_lines: HashMap<String, Rc<Vec<(String, usize)>>>,
@@ -914,6 +922,14 @@ pub struct KernelResolver {
     /// getRazorUsings memo, by file.
     razor_usings_memo: HashMap<String, Rc<Vec<String>>>,
     rust_crate_root_memo: HashMap<String, Option<String>>,
+    /// rustPathDeclsIn (name-matcher.ts): a file's `#[path]` module declarations, by file.
+    rust_path_decls_memo: HashMap<String, Rc<Vec<rust_modules::rust_paths::RustPathDecl>>>,
+    /// rustPathLoads (name-matcher.ts): each file a `#[path]` loads → its declarations, once.
+    rust_path_loads_memo: Option<Rc<HashMap<String, Vec<rust_modules::rust_paths::RustPathDecl>>>>,
+    /// rustPathLoaders (name-matcher.ts): the declarations loading a file the name rules don't place.
+    rust_path_loaders_memo: HashMap<String, Rc<Vec<rust_modules::rust_paths::RustPathDecl>>>,
+    /// A Rust file's `mod` layout: plain decls, `#[path]` decl names, inline chains, `fn main`.
+    rust_mod_facts_memo: HashMap<String, Option<Rc<rust_modules::rust_paths::RustModFacts>>>,
     /// factory_initializer memo: (file, binding line, root, binding node).
     factory_init_memo: HashMap<(String, i64, String, Option<String>), Rc<method_call::FactoryInit>>,
     /// C/C++ directive summaries and per-root macro timelines (#1838).
@@ -1081,6 +1097,7 @@ impl KernelResolver {
             rust_trait_memo: HashMap::new(),
             rust_typed_refs: HashSet::new(),
             rust_trait_of_memo: HashMap::new(),
+            rust_type_member_memo: HashMap::new(),
             go_dot_imports_memo: HashMap::new(),
             go_mc_terminal: false,
             go_mc_untyped_local: false,
@@ -1121,6 +1138,7 @@ impl KernelResolver {
             kotlin_receiver_types_memo: None,
             kotlin_scope_memo: HashMap::new(),
             kotlin_supers_memo: HashMap::new(),
+            ruby_ivar_memo: HashMap::new(),
             py_descendants_memo: HashMap::new(),
             py_bases_memo: HashMap::new(),
             cpp_visible_memo: None,
@@ -1171,6 +1189,10 @@ impl KernelResolver {
             cobol_copybooks: None,
             razor_usings_memo: HashMap::new(),
             rust_crate_root_memo: HashMap::new(),
+            rust_path_decls_memo: HashMap::new(),
+            rust_path_loads_memo: None,
+            rust_path_loaders_memo: HashMap::new(),
+            rust_mod_facts_memo: HashMap::new(),
             factory_init_memo: HashMap::new(),
             cpp_macros: cpp::MacroCache::default(),
             cpp_namespaces: cpp_namespace::NamespaceCache::default(),
diff --git a/codegraph-kernel/src/resolve/name_scope.rs b/codegraph-kernel/src/resolve/name_scope.rs
index b6ba8740e..dacff7074 100644
--- a/codegraph-kernel/src/resolve/name_scope.rs
+++ b/codegraph-kernel/src/resolve/name_scope.rs
@@ -199,17 +199,25 @@ pub(super) fn is_bare_rust_name(r: &ResolveRefIn) -> bool {
 /// any form — is named only in its own module and the modules inside it: a `type Result` in
 /// `src/build/patch.rs` is `build::patch`'s, seen in that file and under `src/build/patch/`, never
 /// through `use crate::Result` elsewhere, and no glob passes it on. A `mod.rs`, `lib.rs` or
-/// `main.rs` is the module of its whole directory. The same rule `is_visible_across_files` applies
-/// to the pipeline's pick, here ahead of the ranking, so the crate's own `pub(crate) type Result`
+/// `main.rs` is the module of its whole directory; a file a `#[path]` loads is inside the module
+/// that declares it, wherever it sits. The same rule `is_visible_across_files` applies to the
+/// pipeline's pick, here ahead of the ranking, so the crate's own `pub(crate) type Result`
 /// can win instead.
-fn rust_item_visible_from(candidate: &KNode, r: &ResolveRefIn) -> bool {
-    if candidate.language != "rust"
-        || candidate.visibility.as_deref() != Some("private")
-        || !super::resolver_upstream::RUST_MODULE_ITEM_KINDS.contains(&candidate.kind.as_str())
-    {
-        return true;
+impl KernelResolver {
+    fn rust_item_visible_from(&mut self, candidate: &KNode, r: &ResolveRefIn) -> bool {
+        if candidate.language != "rust"
+            || candidate.visibility.as_deref() != Some("private")
+            || !super::resolver_upstream::RUST_MODULE_ITEM_KINDS.contains(&candidate.kind.as_str())
+        {
+            return true;
+        }
+        candidate.file_path == r.file_path
+            || self.rust_file_under(
+                &r.file_path,
+                &super::names::rust_module_dir(&candidate.file_path),
+                &candidate.file_path,
+            )
     }
-    candidate.file_path == r.file_path || r.file_path.starts_with(&format!("{}/", super::names::rust_module_dir(&candidate.file_path)))
 }
 
 impl KernelResolver {
@@ -269,7 +277,7 @@ impl KernelResolver {
     /// the prelude's unless the file defines it or imports a project item of
     /// that name.
     pub(super) fn is_rust_name_in_scope(&mut self, candidate: &KNode, r: &ResolveRefIn) -> bool {
-        if !rust_item_visible_from(candidate, r) {
+        if !self.rust_item_visible_from(candidate, r) {
             return false;
         }
         if let Some(visible) = self.rust_precise_name_scope(candidate, r) {
diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 1414b0fa5..66661618c 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -482,7 +482,7 @@ impl KernelResolver {
                 return Ok(true);
             }
             let owner = rust_module_dir(&candidate.file_path);
-            return Ok(r.file_path.starts_with(&format!("{}/", owner)));
+            return Ok(self.rust_file_under(&r.file_path, &owner, &candidate.file_path));
         }
         if private_is_file_local(lang) {
             return Ok(candidate.visibility.as_deref() != Some("private"));
diff --git a/codegraph-kernel/src/resolve/node_table.rs b/codegraph-kernel/src/resolve/node_table.rs
index f2d73bed0..f9864f32c 100644
--- a/codegraph-kernel/src/resolve/node_table.rs
+++ b/codegraph-kernel/src/resolve/node_table.rs
@@ -547,6 +547,14 @@ pub(super) struct FileExportIndexK {
     pub(super) by_name: HashMap<String, Arc<KNode>>,
     pub(super) default_component: Option<Arc<KNode>>,
     pub(super) default_binding: Option<Arc<KNode>>,
+    /// import-resolver.ts `defaultFnClass`: the file's first exported function
+    /// or class, the guess for `export default <expression>` (`memo(Card)`),
+    /// which names no declaration.
+    pub(super) default_fn_class: Option<Arc<KNode>>,
+    /// The file states an `export default` naming no declaration that is not
+    /// an anonymous function, class or arrow (upstream's `'unstated'`, the
+    /// only case `default_fn_class` answers; `'anonymous'` binds nothing).
+    pub(super) default_expr: bool,
 }
 
 /// WorkspacePackages (workspace-packages.ts).
diff --git a/codegraph-kernel/src/resolve/python_expression_scope.rs b/codegraph-kernel/src/resolve/python_expression_scope.rs
new file mode 100644
index 000000000..034b6ddcc
--- /dev/null
+++ b/codegraph-kernel/src/resolve/python_expression_scope.rs
@@ -0,0 +1,78 @@
+//! A Python name bound by the expression around a reference: a lambda
+//! parameter or a comprehension variable. Binding rows are scoped to whole
+//! lines, so these single-expression scopes are read from the syntax tree.
+
+use super::iteration::{descendant_for_position, named_children};
+use super::*;
+
+/// Every identifier `node` names as a binding target, tuples and stars included.
+fn binds(node: tree_sitter::Node, text: &str, name: &str) -> bool {
+    match node.kind() {
+        "identifier" => &text[node.start_byte()..node.end_byte()] == name,
+        "attribute" | "subscript" => false,
+        _ => named_children(node).into_iter().any(|c| binds(c, text, name)),
+    }
+}
+
+impl KernelResolver {
+    /// Whether the lambda or comprehension the reference sits in binds `name`
+    /// there: `lambda other: other.f()`, `[other.f() for other in items]`.
+    /// A comprehension's first iterable is evaluated outside its scope.
+    pub(super) fn python_expression_binds(&mut self, name: &str, r: &ResolveRefIn) -> bool {
+        let Some(file) = self.read_file(&r.file_path) else { return false };
+        let text = file.text();
+        let Some(tree) = self.parsed_tree(&file, r) else { return false };
+        let leaf = descendant_for_position(
+            tree.root_node(),
+            text,
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let at = leaf.start_byte();
+        let inside = |n: tree_sitter::Node| n.start_byte() <= at && at < n.end_byte();
+        let mut current = Some(leaf);
+        while let Some(node) = current {
+            current = node.parent();
+            match node.kind() {
+                "lambda" => {
+                    let in_body = node.child_by_field_name("body").is_some_and(inside);
+                    let named = node.child_by_field_name("parameters").is_some_and(|params| {
+                        named_children(params).into_iter().any(|param| {
+                            let target = param
+                                .child_by_field_name("name")
+                                .or_else(|| {
+                                    matches!(param.kind(), "list_splat_pattern" | "dictionary_splat_pattern")
+                                        .then(|| param.named_child(0))
+                                        .flatten()
+                                })
+                                .unwrap_or(param);
+                            binds(target, text, name)
+                        })
+                    });
+                    if in_body && named {
+                        return true;
+                    }
+                }
+                "list_comprehension" | "set_comprehension" | "dictionary_comprehension" | "generator_expression" => {
+                    let clauses: Vec<_> = named_children(node)
+                        .into_iter()
+                        .filter(|c| c.kind() == "for_in_clause")
+                        .collect();
+                    let in_first_iterable = clauses
+                        .first()
+                        .and_then(|c| c.child_by_field_name("right"))
+                        .is_some_and(inside);
+                    if !in_first_iterable
+                        && clauses
+                            .iter()
+                            .filter_map(|c| c.child_by_field_name("left"))
+                            .any(|target| binds(target, text, name))
+                    {
+                        return true;
+                    }
+                }
+                _ => {}
+            }
+        }
+        false
+    }
+}
diff --git a/codegraph-kernel/src/resolve/query.rs b/codegraph-kernel/src/resolve/query.rs
index 82a26456a..8aca4ee6d 100644
--- a/codegraph-kernel/src/resolve/query.rs
+++ b/codegraph-kernel/src/resolve/query.rs
@@ -562,6 +562,7 @@ impl KernelResolver {
         let nodes = self.nodes_in_file_unfiltered(file_path)?;
         let mut by_name: HashMap<String, Arc<KNode>> = HashMap::new();
         let mut default_component: Option<Arc<KNode>> = None;
+        let mut default_fn_class: Option<Arc<KNode>> = None;
         for n in nodes.iter() {
             if !n.is_exported {
                 continue;
@@ -570,8 +571,37 @@ impl KernelResolver {
             if default_component.is_none() && n.kind == "component" && matches!(std::path::Path::new(file_path).extension().and_then(|s| s.to_str()), Some("svelte" | "vue" | "astro")) {
                 default_component = Some(n.clone());
             }
+            if default_fn_class.is_none() && (n.kind == "function" || n.kind == "class") {
+                default_fn_class = Some(n.clone());
+            }
         }
         let rows = self.bindings(file_path)?;
+        // `export default <expression>` leaves a nodeless `default` marker row
+        // (as does an anonymous function, class or arrow, which binds nothing).
+        let marker_lines: Vec<i64> = rows
+            .iter()
+            .filter(|r| r.exported_as.as_deref() == Some("default") && r.node_id.is_none())
+            .map(|r| r.line)
+            .collect();
+        let mut default_expr = false;
+        if !marker_lines.is_empty() {
+            if let Some(lines) = self.read_file(file_path) {
+                let text = lines.text();
+                let mut anonymous = false;
+                for &line in marker_lines.iter() {
+                    // A default's head may span lines (`export default (\n  x\n) => x`):
+                    // upstream's readDefaultExport scans the whole statement, so the
+                    // classifier gets the source from the marker's line to the end.
+                    let head = text.split('\n').skip(line.saturating_sub(1) as usize).collect::<Vec<_>>().join("\n");
+                    if export_default_head_is_anonymous(&head) {
+                        anonymous = true;
+                    } else {
+                        default_expr = true;
+                    }
+                }
+                default_expr &= !anonymous;
+            }
+        }
         let by_id: HashMap<&str, &Arc<KNode>> = nodes.iter().map(|n| (n.id.as_str(), n)).collect();
         let mut default_binding: Option<Arc<KNode>> = None;
         if let Some(bound) = default_export_binding(&rows) {
@@ -616,6 +646,8 @@ impl KernelResolver {
             by_name,
             default_component,
             default_binding,
+            default_fn_class,
+            default_expr,
         });
         self.export_index.insert(file_path.to_string(), idx.clone());
         Ok(idx)
@@ -667,7 +699,8 @@ impl KernelResolver {
         if want.is_default {
             let direct = export_index.by_name.get("default").cloned()
                 .or_else(|| export_index.default_binding.clone())
-                .or_else(|| export_index.default_component.clone());
+                .or_else(|| export_index.default_component.clone())
+                .or_else(|| export_index.default_fn_class.clone().filter(|_| export_index.default_expr));
             if let Some(d) = direct {
                 return self.memo_symbol_opt(memo_key, Some(d.clone()));
             }
@@ -763,6 +796,43 @@ pub(super) fn default_export_binding(rows: &[KBinding]) -> Option<&KBinding> {
     rows.iter().find(|r| r.exported_as.as_deref() == Some("default") && r.node_id.is_some())
 }
 
+/// readDefaultExport's `'anonymous'` (import-resolver.ts): the line a
+/// nodeless `default` binding row marks opens `export default` on a
+/// function, class or arrow with no name. `export default memo(Card)` or
+/// `new Service()` is an expression and answers `false`; a head the line
+/// doesn't begin conservatively answers `true`.
+fn export_default_head_is_anonymous(line: &str) -> bool {
+    let Some(m) = re!(r"^[ \t]*export[ \t]+default[ \t]+").find(line) else {
+        return true;
+    };
+    let mut rest = &line[m.end()..];
+    if let Some(after) = rest.strip_prefix("async") {
+        rest = after.trim_start();
+    }
+    if re!(r"^(?:function|class)").is_match(rest) {
+        return true;
+    }
+    // `x =>` is anonymous; `(…)` is an arrow's parameters when `=>` or a
+    // return type follows it, else a parenthesized expression.
+    if re!(r"^[A-Za-z_$][\w$]*[ \t]*=>").is_match(rest) {
+        return true;
+    }
+    if rest.starts_with('(') {
+        let mut depth = 0i32;
+        for (i, c) in rest.char_indices() {
+            if c == '(' {
+                depth += 1;
+            } else if c == ')' {
+                depth -= 1;
+                if depth == 0 {
+                    return re!(r"^[ \t]*(?:=>|:)").is_match(&rest[i + 1..]);
+                }
+            }
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/codegraph-kernel/src/resolve/ruby_paths.rs b/codegraph-kernel/src/resolve/ruby_paths.rs
index a1f1ce321..9af9ed228 100644
--- a/codegraph-kernel/src/resolve/ruby_paths.rs
+++ b/codegraph-kernel/src/resolve/ruby_paths.rs
@@ -45,6 +45,45 @@ impl KernelResolver {
             };
         }
         if r.reference_kind == "calls" {
+            // A call on an instance `Foo.new(…)` made, bare or namespaced
+            // (`new Foo().m`, `new A::B().m!`): an instance method of the class
+            // Ruby's lookup finds for `Foo` there, its own or one its ancestry
+            // declares — never a namesake's by the method name alone. A class
+            // the project doesn't declare (rack-protection's `Request.new(env)`
+            // is rack's) has no method here.
+            if let Some(c) = re!(r"^new (::)?([A-Z]\w*(?:::[A-Z]\w*)*)\(\)\.([A-Za-z_]\w*[?!=]?)$").captures(&r.reference_name) {
+                let class = self
+                    .ruby_constants_named(&c[2], r, c.get(1).is_some())?
+                    .into_iter()
+                    .next()
+                    .filter(|n| n.kind == "class");
+                let method = match class {
+                    Some(class) => self.ruby_method_of(&class.qualified_name, &c[3], r, "instance")?,
+                    None => None,
+                };
+                return Ok(Some(match method {
+                    Some((method, own)) => ResolveOutcome::resolved(&method, if own { 0.9 } else { 0.85 }, "instance-method", true, None),
+                    None => ResolveOutcome::unresolved(),
+                }));
+            }
+            // A call on an instance variable `@writer.flush`, typed by the
+            // class's `initialize`: an instance method of the class every
+            // assignment there gives the variable — or nothing when that
+            // class is not the project's. A variable `initialize` does not
+            // type is left to the other strategies, as before (#3053).
+            if let Some(c) = re!(r"^@(\w+)\.([A-Za-z_]\w*[?!=]?)$").captures(&r.reference_name) {
+                let Some(class) = self.ruby_ivar_class(&c[1], r)? else {
+                    return Ok(None);
+                };
+                let method = match class {
+                    Some(class) => self.ruby_method_of(&class.qualified_name, &c[2], r, "instance")?,
+                    None => None,
+                };
+                return Ok(Some(match method {
+                    Some((method, own)) => ResolveOutcome::resolved(&method, if own { 0.85 } else { 0.8 }, "instance-method", true, None),
+                    None => ResolveOutcome::unresolved(),
+                }));
+            }
             let Some(c) = re!(r"^(::)?([A-Z]\w*(?:::[A-Z]\w*)*)\.([A-Za-z_]\w*[?!=]?)$").captures(r.reference_name.trim_start_matches("()")) else {
                 return Ok(None);
             };
@@ -58,7 +97,7 @@ impl KernelResolver {
             let Some(owner) = owner else {
                 return Ok(Some(ResolveOutcome::unresolved()));
             };
-            return match self.ruby_method_of(&owner.qualified_name, &c[3], r)? {
+            return match self.ruby_method_of(&owner.qualified_name, &c[3], r, "class")? {
                 Some((method, own)) => Ok(Some(ResolveOutcome::resolved(
                     &method,
                     if own { 0.85 } else { 0.8 },
@@ -105,6 +144,11 @@ impl KernelResolver {
     /// lexicalScope: the qualified name of the innermost class or module
     /// around `r`, or empty at the top level of its file.
     fn ruby_lexical_scope(&mut self, r: &ResolveRefIn) -> Res<String> {
+        Ok(self.ruby_innermost_namespace(r)?.map(|i| i.qualified_name.clone()).unwrap_or_default())
+    }
+
+    /// innermostNamespace: the innermost class or module around `r`, if any.
+    fn ruby_innermost_namespace(&mut self, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
         let mut inner: Option<Arc<KNode>> = None;
         for n in self.nodes_in_file(&r.file_path)?.iter() {
             if n.language != "ruby" || !matches!(n.kind.as_str(), "class" | "module") || n.start_line > r.line || n.end_line < r.line {
@@ -114,22 +158,97 @@ impl KernelResolver {
                 inner = Some(n.clone());
             }
         }
-        Ok(inner.map(|i| i.qualified_name.clone()).unwrap_or_default())
+        Ok(inner)
+    }
+
+    /// ivarClass (#3053): `Some` the class of what `@name` holds where `r`
+    /// is written — `Some(None)` when that class is not the project's —
+    /// or `None` for the other strategies when `r` is not in an instance
+    /// method of a class, or `initialize` does not type the variable.
+    fn ruby_ivar_class(&mut self, name: &str, r: &ResolveRefIn) -> Res<Option<Option<Arc<KNode>>>> {
+        let caller = self.node_by_id(&r.from_node_id)?;
+        match &caller {
+            Some(c) if c.language == "ruby" && c.kind == "method" && !c.is_static => {}
+            _ => return Ok(None),
+        }
+        let Some(owner) = self.ruby_innermost_namespace(r)? else {
+            return Ok(None);
+        };
+        if owner.kind != "class" {
+            return Ok(None);
+        }
+        let key = format!("{}\0{}", owner.qualified_name, name);
+        if let Some(hit) = self.ruby_ivar_memo.get(&key) {
+            return Ok(hit.clone());
+        }
+        let found = self.ruby_ivar_class_from_initialize(name, &owner.qualified_name, r)?;
+        self.ruby_ivar_memo.insert(key, found.clone());
+        Ok(found)
+    }
+
+    /// ivarClassFromInitialize: every assignment to `@name` in the owner's
+    /// `initialize` must be at a statement's start and a lone `Const.new(…)`
+    /// of one constant — then the class Ruby's lookup finds for that
+    /// constant from there.
+    fn ruby_ivar_class_from_initialize(&mut self, name: &str, owner: &str, r: &ResolveRefIn) -> Res<Option<Option<Arc<KNode>>>> {
+        let mut written: Option<(String, bool, String, i64)> = None;
+        for init in self.nodes_by_qualified_name(&format!("{owner}::initialize"))?.iter() {
+            if init.kind != "method" || init.language != "ruby" || init.is_static {
+                continue;
+            }
+            let Some(lines) = self.read_file(&init.file_path) else {
+                return Ok(None);
+            };
+            let mut body = String::new();
+            for i in init.start_line - 1..init.end_line {
+                match lines.line(i as usize) {
+                    Some(l) => {
+                        body.push_str(l);
+                        body.push('\n');
+                    }
+                    None => break,
+                }
+            }
+            let body = strip_ruby_comments(&body);
+            let Some(assigned) = constructed_assignments(&body, name) else {
+                return Ok(None);
+            };
+            for (path, absolute, line) in assigned {
+                match &written {
+                    Some((p, a, _, _)) if *p != path || *a != absolute => return Ok(None),
+                    None => written = Some((path, absolute, init.file_path.clone(), init.start_line + line)),
+                    _ => {}
+                }
+            }
+        }
+        let Some((path, absolute, file, line)) = written else {
+            return Ok(None);
+        };
+        let mut at = r.clone();
+        at.file_path = file;
+        at.line = line;
+        at.reference_name = path.clone();
+        at.reference_kind = "references".to_string();
+        let class = self.ruby_constants_named(&path, &at, absolute)?.into_iter().next();
+        Ok(Some(class.filter(|n| n.kind == "class")))
     }
 
     /// methodOf: `name` declared on `owner_qn` itself (kind `class` first),
     /// else on the first ancestor in its Ruby ancestry that declares it.
     /// Returns the method and whether it is the owner's own. `r` is the call
     /// site: production code never reaches a method only a test declares.
-    pub(super) fn ruby_method_of(&mut self, owner_qn: &str, name: &str, r: &ResolveRefIn) -> Res<Option<(Arc<KNode>, bool)>> {
+    pub(super) fn ruby_method_of(&mut self, owner_qn: &str, name: &str, r: &ResolveRefIn, kind: &str) -> Res<Option<(Arc<KNode>, bool)>> {
         let production = !super::resolver_upstream::test_suite_path(&r.file_path);
         let own: Vec<Arc<KNode>> = self
             .nodes_by_qualified_name(&format!("{owner_qn}::{name}"))?
             .iter()
-            .filter(|n| n.language == "ruby" && n.kind == "method" && !(production && super::resolver_upstream::test_suite_path(&n.file_path)))
+            // A receiver bound to an instance (`new C().m`, a typed `@x`) can
+            // only reach instance methods: an own class method does not stand
+            // in for one an ancestor declares.
+            .filter(|n| n.language == "ruby" && n.kind == "method" && !(kind == "instance" && n.is_static) && !(production && super::resolver_upstream::test_suite_path(&n.file_path)))
             .cloned()
             .collect();
-        if let Some(m) = ruby_methods_of_kind_first(ruby_ordered(own, r), "class").into_iter().next() {
+        if let Some(m) = ruby_methods_of_kind_first(ruby_ordered(own, r), kind).into_iter().next() {
             return Ok(Some((m, true)));
         }
         let ancestry = self.ruby_ancestry(owner_qn)?;
@@ -139,10 +258,10 @@ impl KernelResolver {
             let found: Vec<Arc<KNode>> = self
                 .nodes_by_qualified_name(&format!("{qn}::{name}"))?
                 .iter()
-                .filter(|n| n.language == "ruby" && n.kind == "method" && !(production && super::resolver_upstream::test_suite_path(&n.file_path)))
+                .filter(|n| n.language == "ruby" && n.kind == "method" && !(kind == "instance" && n.is_static) && !(production && super::resolver_upstream::test_suite_path(&n.file_path)))
                 .cloned()
                 .collect();
-            if let Some(m) = ruby_methods_of_kind_first(ruby_ordered(found, r), "class").into_iter().next() {
+            if let Some(m) = ruby_methods_of_kind_first(ruby_ordered(found, r), kind).into_iter().next() {
                 return Ok(Some((m, false)));
             }
         }
@@ -204,3 +323,182 @@ pub(super) fn ruby_methods_of_kind_first(methods: Vec<Arc<KNode>>, kind: &str) -
     same.extend(other);
     same
 }
+
+/// constructedAssignments (#3053): each assignment to `@name` in `body`
+/// (an `initialize`, comments blanked): the constant whose `.new` it
+/// assigns, and the assignment's line within `body`. None when one of
+/// them is anything else: not at the start of a statement (`@a, @b = …`),
+/// or not a lone `Const.new(…)` (`Foo.new.tap {…}`, `writer || Foo.new`,
+/// `build_writer`).
+fn constructed_assignments(body: &str, name: &str) -> Option<Vec<(String, bool, i64)>> {
+    // Upstream's `/(?<![@\w])@name\s*(?:…)?=(?![=~>])/g`, minus the
+    // look-around Rust's regex lacks: the boundary char is captured and
+    // skipped, the `=~>` tail is checked by hand.
+    let target = super::cached_pattern(&format!(r"(^|[^@\w])@{}\s*(?:\|\||&&|\*\*|<<|>>|[-+*/%|&^])?=", regex::escape(name))).ok()?;
+    let mut out = Vec::new();
+    for m in target.captures_iter(body) {
+        let whole = m.get(0).unwrap();
+        let at = whole.start() + m.get(1).unwrap().as_str().len();
+        let after_eq = whole.end();
+        match body.as_bytes().get(after_eq) {
+            Some(b'=') | Some(b'~') | Some(b'>') => continue,
+            _ => {}
+        }
+        let statement_start = body[..at].rfind(['\n', ';']).map_or(0, |i| i + 1);
+        if !body[statement_start..at].trim().is_empty() {
+            return None;
+        }
+        let (path, absolute) = constructed_value(body, after_eq)?;
+        let line = body[..at].matches('\n').count() as i64;
+        out.push((path, absolute, line));
+    }
+    Some(out)
+}
+
+/// constructedValue: the constant a value written at `from` constructs
+/// when it is a lone `Const.new`, `A::B.new(…)` or `::Foo.new …`: its
+/// arguments in parentheses or without them, a block, or a statement
+/// modifier may follow, but nothing the value is passed through
+/// (`.tap`, `||`). None otherwise.
+fn constructed_value(s: &str, from: usize) -> Option<(String, bool)> {
+    let m = re!(r"^\s*(::)?([A-Z]\w*(?:::[A-Z]\w*)*)\s*\.\s*new").captures(&s[from..])?;
+    let mut i = from + m.get(0).unwrap().end();
+    // upstream's `new(?![\w?!])` (`\w` is ASCII): `new?`/`new!`/`newly`
+    // are method names.
+    match s[i..].chars().next() {
+        Some(c) if c.is_ascii_alphanumeric() || matches!(c, '_' | '?' | '!') => return None,
+        _ => {}
+    }
+    if s.as_bytes().get(i) == Some(&b'(') {
+        i = skip_parens(s, i)?;
+    }
+    // The end of the statement, a block, or (after a space) a modifier or
+    // arguments without parentheses: anything but a chain or an operator.
+    let tail = &s[i.min(s.len())..];
+    let ok = match tail.chars().next() {
+        None | Some('\n') | Some(';') | Some('{') => true,
+        _ => re!(r#"^[ \t]+(?:$|\n|;|\{|[\w:@$"'\[])"#).is_match(tail.get(..200).unwrap_or(tail)),
+    };
+    // A chain may go on at the start of the next line: `Foo.new\n  .tap {…}`.
+    let continued = re!(r"^[ \t]*\n\s*&?\.").is_match(tail.get(..200).unwrap_or(tail));
+    (ok && !continued).then(|| (m[2].to_string(), m.get(1).is_some()))
+}
+
+/// skipParens: the index past the parenthesized group opening at `i`,
+/// Ruby strings inside it skipped; None when it never closes.
+fn skip_parens(s: &str, i: usize) -> Option<usize> {
+    let b = s.as_bytes();
+    let mut depth = 0i32;
+    let mut j = i;
+    while j < b.len() {
+        let c = b[j];
+        if c == b'"' || c == b'\'' {
+            j += 1;
+            while j < b.len() && b[j] != c {
+                if b[j] == b'\\' {
+                    j += 1;
+                }
+                j += 1;
+            }
+            j += 1;
+            continue;
+        }
+        if c == b'(' {
+            depth += 1;
+        } else if c == b')' {
+            depth -= 1;
+            if depth == 0 {
+                return Some(j + 1);
+            }
+        }
+        j += 1;
+    }
+    None
+}
+
+/// stripCommentsForRegex(…, 'ruby') (upstream strip-comments.ts):
+/// `#` line comments and `=begin`/`=end` blocks blanked (newlines kept,
+/// so offsets still map); string literals skipped intact.
+fn strip_ruby_comments(src: &str) -> String {
+    let s: Vec<char> = src.chars().collect();
+    let n = s.len();
+    let mut out = String::with_capacity(src.len());
+    let mut i = 0;
+    let mut at_line_start = true;
+    while i < n {
+        let c = s[i];
+        // `=begin` opens a block comment only at a line's start (after
+        // optional whitespace); `=end` must sit at a line's start too.
+        if at_line_start && c == '=' && s[i..].iter().take(6).collect::<String>() == "=begin" {
+            let start = i;
+            i += 6;
+            while i < n {
+                if s[i] == '\n' {
+                    let mut j = i + 1;
+                    while j < n && (s[j] == ' ' || s[j] == '\t') {
+                        j += 1;
+                    }
+                    if s[j..].iter().take(4).collect::<String>() == "=end" {
+                        i = j + 4;
+                        while i < n && s[i] != '\n' {
+                            i += 1;
+                        }
+                        break;
+                    }
+                }
+                i += 1;
+            }
+            for &ch in &s[start..i.min(n)] {
+                super::awaited::push_blank(&mut out, ch);
+            }
+            at_line_start = i > 0 && s[i - 1] == '\n';
+            continue;
+        }
+        if c == '"' || c == '\'' {
+            let start = i;
+            i += 1;
+            while i < n && s[i] != c {
+                if s[i] == '\\' && i + 1 < n {
+                    i += 2;
+                    continue;
+                }
+                if s[i] == '\n' {
+                    break;
+                }
+                i += 1;
+            }
+            if i < n && s[i] == c {
+                i += 1;
+            }
+            out.extend(&s[start..i.min(n)]);
+            at_line_start = false;
+            continue;
+        }
+        if c == '#' {
+            let start = i;
+            while i < n && s[i] != '\n' {
+                i += 1;
+            }
+            for &ch in &s[start..i] {
+                super::awaited::push_blank(&mut out, ch);
+            }
+            at_line_start = false;
+            continue;
+        }
+        if c == '\n' {
+            at_line_start = true;
+            out.push(c);
+            i += 1;
+            continue;
+        }
+        if c == ' ' || c == '\t' {
+            out.push(c);
+            i += 1;
+            continue;
+        }
+        at_line_start = false;
+        out.push(c);
+        i += 1;
+    }
+    out
+}
diff --git a/codegraph-kernel/src/resolve/rust_crates.rs b/codegraph-kernel/src/resolve/rust_crates.rs
index dfb5fab8b..5e4edf58f 100644
--- a/codegraph-kernel/src/resolve/rust_crates.rs
+++ b/codegraph-kernel/src/resolve/rust_crates.rs
@@ -95,11 +95,53 @@ pub(super) fn rust_manifest_dependencies(text: &str) -> Vec<ManifestDep> {
     deps
 }
 
+/// parseTargetPaths (cargo-workspace.ts): the target roots a manifest names with a `path` of their
+/// own — `[lib] path = "…"`, each `[[bin]] path = "…"` (ripgrep's `crates/core/main.rs`), and each
+/// `[[example]]`, `[[test]]` and `[[bench]]` one (dioxus's
+/// `examples/07-fullstack/handling_errors.rs`), as written — relative to the manifest's directory.
+fn rust_manifest_target_paths(text: &str) -> (Option<String>, Vec<String>, Vec<String>) {
+    let mut lib = None;
+    let mut bins = Vec::new();
+    let mut others = Vec::new();
+    let mut table = "";
+    for raw in text.lines() {
+        let line = raw.split('#').next().unwrap_or("").trim();
+        if line.starts_with('[') {
+            table = match line {
+                "[lib]" => "lib",
+                "[[bin]]" => "bin",
+                _ if re!(r"^\[\[(?:example|test|bench)\]\]$").is_match(line) => "other",
+                _ => "",
+            };
+            continue;
+        }
+        let Some(at) = (!table.is_empty())
+            .then(|| re!(r#"^path\s*=\s*["']([^"'\n]+)["']"#).captures(line))
+            .flatten()
+            .map(|m| m[1].replace('\\', "/"))
+        else {
+            continue;
+        };
+        match table {
+            "lib" => lib = Some(at),
+            "bin" => bins.push(at),
+            _ => others.push(at),
+        }
+    }
+    (lib, bins, others)
+}
+
 pub(super) struct RustCrate {
     /// Its package name as code writes it (`tokio_test`).
     pub(super) name: String,
     /// Each dependency of any kind that is a project crate: the name code writes → that crate's directory.
     pub(super) keys: HashMap<String, String>,
+    /// The library root its manifest gives a `path` of its own, as a project file.
+    pub(super) lib: Option<String>,
+    /// The binaries' roots its manifest gives a `path` (ripgrep's `crates/core/main.rs`), as project files.
+    pub(super) bins: Vec<String>,
+    /// The examples', tests' and benches' roots its manifest gives a `path`, as project files: each its own crate.
+    pub(super) others: Vec<String>,
 }
 
 pub(super) struct RustCrateGraph {
@@ -110,7 +152,7 @@ pub(super) struct RustCrateGraph {
 }
 
 /// `rel` from the project directory `dir`, as a project directory; None when it leaves the project.
-fn join_project_dir(dir: &str, rel: &str) -> Option<String> {
+pub(super) fn join_project_dir(dir: &str, rel: &str) -> Option<String> {
     let mut parts: Vec<&str> = Vec::new();
     for segment in dir.split('/').chain(rel.split('/')) {
         match segment {
@@ -146,7 +188,22 @@ impl GraphBuilder {
         let path = if dir.is_empty() { "Cargo.toml".to_string() } else { format!("{dir}/Cargo.toml") };
         let Some(source) = resolver.read_file(&path) else { return false };
         let Some(name) = package_name(source.text()) else { return false };
-        self.crates.insert(dir.to_string(), RustCrate { name: name.clone(), keys: HashMap::new() });
+        let (lib, bins, others) = rust_manifest_target_paths(source.text());
+        let files = |rels: Vec<String>| {
+            rels.iter()
+                .filter_map(|rel| join_project_dir(dir, rel))
+                .collect()
+        };
+        self.crates.insert(
+            dir.to_string(),
+            RustCrate {
+                name: name.clone(),
+                keys: HashMap::new(),
+                lib: lib.and_then(|rel| join_project_dir(dir, &rel)),
+                bins: files(bins),
+                others: files(others),
+            },
+        );
         self.manifests.insert(dir.to_string(), source.text().to_string());
         self.by_name.entry(name).or_insert_with(|| dir.to_string());
         self.order.push(dir.to_string());
diff --git a/codegraph-kernel/src/resolve/rust_impls.rs b/codegraph-kernel/src/resolve/rust_impls.rs
index 5c1700915..b238d6f7c 100644
--- a/codegraph-kernel/src/resolve/rust_impls.rs
+++ b/codegraph-kernel/src/resolve/rust_impls.rs
@@ -134,7 +134,7 @@ impl KernelResolver {
 
     /// The crate dir a file belongs to: the longest crate dir prefixing it, or
     /// the root crate's "".
-    fn rust_crate_dir_of(file: &str, graph: &super::rust_crates::RustCrateGraph) -> Option<String> {
+    pub(super) fn rust_crate_dir_of(file: &str, graph: &super::rust_crates::RustCrateGraph) -> Option<String> {
         let mut best = graph.crates.contains_key("").then(String::new);
         for dir in graph.crates.keys() {
             if !dir.is_empty()
diff --git a/codegraph-kernel/src/resolve/rust_modules.rs b/codegraph-kernel/src/resolve/rust_modules.rs
index 8a60d8c8c..b8c674ee4 100644
--- a/codegraph-kernel/src/resolve/rust_modules.rs
+++ b/codegraph-kernel/src/resolve/rust_modules.rs
@@ -134,29 +134,82 @@ impl KernelResolver {
         }
         let first = segments[0];
         if first == "crate" {
+            // The crate root's own `#[path]` decls are the module's — a name
+            // one claims never reaches a namesake `head.rs`.
+            if let Some(head) = segments.get(1) {
+                if let Some(root) = self.rust_root_module(from_file) {
+                    if self
+                        .rust_mod_facts(&root.file)
+                        .is_some_and(|f| f.path_mods.contains(*head))
+                    {
+                        return Ok(None);
+                    }
+                }
+            }
             let root = self.rust_crate_root_dir(from_file)?;
             return Ok(self.rust_resolve_under(root, &segments[1..]));
         }
         if first == "self" {
-            return Ok(
-                self.rust_resolve_under(Some(rust_self_module_dir(from_file)), &segments[1..])
-            );
+            if segments.get(1).is_some_and(|h| {
+                self.rust_mod_facts(from_file)
+                    .is_some_and(|f| f.path_mods.contains(*h))
+            }) {
+                return Ok(None);
+            }
+            let dir = self.rust_module_dir_of(from_file);
+            return Ok(self.rust_resolve_under(Some(dir), &segments[1..]));
         }
         if first == "super" {
             let mut supers = 0usize;
             while segments.get(supers) == Some(&"super") {
                 supers += 1;
             }
-            let mut dir = Some(rust_self_module_dir(from_file));
+            // Walk `super` by the module rules: a `#[path]`-loaded file's
+            // `super` is the module that declares it, not a module of the
+            // directory it happens to sit in.
+            let mut scope = rust_paths::RustModule {
+                file: from_file.to_string(),
+                inline: Vec::new(),
+            };
             for _ in 0..supers {
-                dir = dir.map(|d| pos_dirname(&d).to_string());
+                let Some(s) = self.rust_super_module(&scope) else {
+                    return Ok(None);
+                };
+                scope = s;
             }
-            return Ok(self.rust_resolve_under(dir, &segments[supers..]));
+            if segments.get(supers).is_some_and(|h| {
+                self.rust_mod_facts(&scope.file)
+                    .is_some_and(|f| f.path_mods.contains(*h))
+            }) {
+                return Ok(None);
+            }
+            let mut dir = self.rust_module_dir_of(&scope.file);
+            for seg in &scope.inline {
+                dir = pos_join(&dir, seg);
+            }
+            return Ok(self.rust_resolve_under(Some(dir), &segments[supers..]));
+        }
+        // A `#[path]` decl of the head stays unknown; the name-only lookup
+        // below may not bypass it to a `head.rs` namesake (rustPathTarget).
+        if self
+            .rust_mod_facts(from_file)
+            .is_some_and(|f| f.path_mods.contains(segments[0]))
+        {
+            return Ok(None);
         }
-        let self_hit = self.rust_resolve_under(Some(rust_self_module_dir(from_file)), segments);
+        let dir = self.rust_module_dir_of(from_file);
+        let self_hit = self.rust_resolve_under(Some(dir), segments);
         if self_hit.is_some() {
             return Ok(self_hit);
         }
+        if let Some(root) = self.rust_root_module(from_file) {
+            if self
+                .rust_mod_facts(&root.file)
+                .is_some_and(|f| f.path_mods.contains(segments[0]))
+            {
+                return Ok(None);
+            }
+        }
         let root = self.rust_crate_root_dir(from_file)?;
         Ok(self.rust_resolve_under(root, segments))
     }
@@ -199,9 +252,38 @@ impl KernelResolver {
     /// named e.g. `rust_binder_main.rs` — falls back to climbing the `mod`
     /// declaration chain to the file no other file declares.
     pub(super) fn rust_crate_root_dir(&mut self, from_file: &str) -> Res<Option<String>> {
+        self.rust_crate_root_dir_at(from_file, 0)
+    }
+
+    fn rust_crate_root_dir_at(&mut self, from_file: &str, depth: usize) -> Res<Option<String>> {
         if let Some(v) = self.rust_crate_root_memo.get(from_file) {
             return Ok(v.clone());
         }
+        // A file a `#[path]` loads is in the crate of the file that declares
+        // it (rustCrateRootModule, claims chained ≤8); an example, test or
+        // bench its manifest gives a `path` of its own is its own crate's
+        // root, its directory the crate's.
+        if depth < 8 {
+            if let Some(claim) = self.rust_path_claim(from_file) {
+                let v = self.rust_crate_root_dir_at(&claim.file, depth + 1)?;
+                self.rust_crate_root_memo
+                    .insert(from_file.to_string(), v.clone());
+                return Ok(v);
+            }
+        }
+        if let Ok(graph) = self.rust_crate_graph() {
+            if Self::rust_crate_dir_of(from_file, &graph).is_some_and(|dir| {
+                graph
+                    .crates
+                    .get(&dir)
+                    .is_some_and(|c| c.others.iter().any(|o| o == from_file))
+            }) {
+                let v = Some(pos_dirname(from_file).to_string());
+                self.rust_crate_root_memo
+                    .insert(from_file.to_string(), v.clone());
+                return Ok(v);
+            }
+        }
         let mut dir = pos_dirname(from_file).to_string();
         let mut found = None;
         for _ in 0..64 {
diff --git a/codegraph-kernel/src/resolve/rust_paths.rs b/codegraph-kernel/src/resolve/rust_paths.rs
index df222d757..ea67e2faa 100644
--- a/codegraph-kernel/src/resolve/rust_paths.rs
+++ b/codegraph-kernel/src/resolve/rust_paths.rs
@@ -9,6 +9,55 @@ pub(in super::super) struct RustModule {
     pub(in super::super) inline: Vec<String>,
 }
 
+/// A `#[path = "…"] mod name;` declaration (name-matcher.ts's RustPathDecl).
+#[derive(Clone, Debug)]
+pub(in super::super) struct RustPathDecl {
+    /// The file it is written in, and the `mod` item's position: the module it
+    /// is declared in.
+    pub(in super::super) file: String,
+    pub(in super::super) line: i64,
+    pub(in super::super) col: i64,
+    /// The module name it declares.
+    pub(in super::super) name: String,
+    /// The inline modules around it (`[]` at the file's top level).
+    pub(in super::super) inline: Vec<String>,
+    /// The file it loads, from the project's root, read as the Rust Reference
+    /// reads the attribute; None for one a `cfg_attr` sets (the build's cfg
+    /// decides) or one that leaves the project.
+    pub(in super::super) target: Option<String>,
+}
+
+/// A `#[path]` declaration as the tree reads it, before its target is joined
+/// to the project: `None` where a `cfg_attr` sets the path.
+pub(in super::super) struct RustRawPathDecl {
+    name: String,
+    line: i64,
+    col: i64,
+    inline: Vec<String>,
+    target: Option<String>,
+}
+
+/// A Rust file's `mod` layout: plain decls, `#[path]` decl names, inline
+/// chains, `fn main` (the pieces of upstream's rustUsesOf the module rules
+/// read).
+#[derive(Default)]
+pub(in super::super) struct RustModFacts {
+    /// `mod name;` with no `#[path]` of its own: the name → the inline module
+    /// chains it is written in.
+    pub(in super::super) mods: HashMap<String, Vec<Vec<String>>>,
+    /// Modules declared with a `#[path]` of their own (a `cfg_attr`'s too),
+    /// whose file can't be told from their name.
+    pub(in super::super) path_mods: HashSet<String>,
+    /// The inline module chains the file's `mod name { … }` blocks open,
+    /// each ending at its own name.
+    pub(in super::super) inlines: HashSet<Vec<String>>,
+    /// Whether it starts a binary of its own: a top-level `fn main` or
+    /// `#![no_main]` (a trybuild case, a fuzz target).
+    pub(in super::super) main: bool,
+    /// The file's `#[path]` declarations, targets unresolved.
+    pub(in super::super) raw_decls: Vec<RustRawPathDecl>,
+}
+
 pub(in super::super) fn rust_children(n: tree_sitter::Node<'_>) -> Vec<tree_sitter::Node<'_>> {
     (0..n.named_child_count())
         .filter_map(|i| n.named_child(i))
@@ -266,6 +315,32 @@ impl KernelResolver {
         out
     }
     pub(in super::super) fn rust_root_module(&mut self, file: &str) -> Option<RustModule> {
+        self.rust_root_module_at(file, 0)
+    }
+
+    /// rustCrateRootModule (name-matcher.ts): a `#[path]`-loaded file's crate
+    /// is the one its declaring file is in (claims chained ≤8, as upstream);
+    /// an example, test or bench its manifest gives a `path` of its own is
+    /// its own crate's root.
+    fn rust_root_module_at(&mut self, file: &str, depth: usize) -> Option<RustModule> {
+        if depth < 8 {
+            if let Some(claim) = self.rust_path_claim(file) {
+                return self.rust_root_module_at(&claim.file, depth + 1);
+            }
+        }
+        if let Ok(graph) = self.rust_crate_graph() {
+            if Self::rust_crate_dir_of(file, &graph).is_some_and(|dir| {
+                graph
+                    .crates
+                    .get(&dir)
+                    .is_some_and(|c| c.others.iter().any(|o| o == file))
+            }) {
+                return Some(RustModule {
+                    file: file.into(),
+                    inline: Vec::new(),
+                });
+            }
+        }
         let dir = self.rust_crate_root_dir(file).ok()??;
         for name in ["lib.rs", "main.rs"] {
             let p = pos_join(&dir, name);
@@ -278,7 +353,410 @@ impl KernelResolver {
         }
         None
     }
+
+    /// The `#[path]` read of a `mod` item's attribute run, nearest first as
+    /// upstream's rustAttributesBefore scans: `.0` is whether a `#[path]`/
+    /// `cfg_attr`-`path` attribute is in the run at all (the name is a path
+    /// module's — a `#[path = <non-literal>]` counts for the name but
+    /// declares no file, as upstream's skipped decl does); `.1` is the
+    /// declared target — `Some` the literal, `None` where a `cfg_attr`
+    /// decides — or the outer `None` when only a non-literal `path =`
+    /// appears (upstream records no decl then).
+    fn rust_mod_path_attr(
+        n: tree_sitter::Node<'_>,
+        text: &str,
+    ) -> (bool, Option<Option<String>>) {
+        let mut pathish = false;
+        let mut target: Option<Option<String>> = None;
+        let mut sib = n;
+        // Upstream scans attributes over comment-blanked code, so a doc
+        // comment between an attribute and its `mod` is read as whitespace.
+        while let Some(attr) = sib.prev_named_sibling().filter(|a| {
+            a.kind() == "attribute_item"
+                || matches!(a.kind(), "line_comment" | "block_comment")
+        }) {
+            if attr.kind() != "attribute_item" {
+                sib = attr;
+                continue;
+            }
+            let raw = rust_text(attr, text);
+            let literal = re!(r#"^#\s*\[\s*path\s*=\s*"([^"]*)"\s*\]$"#)
+                .captures(raw)
+                .map(|m| m[1].replace('\\', "/"));
+            let cfg_path = re!(r"^#\s*\[\s*cfg_attr\b[\s\S]*\bpath\s*=").is_match(raw);
+            pathish = pathish
+                || literal.is_some()
+                || cfg_path
+                || re!(r"^#\s*\[\s*path\s*=").is_match(raw);
+            if let Some(literal) = literal {
+                target = Some(Some(literal));
+            } else if target.is_none() && cfg_path {
+                target = Some(None);
+            }
+            sib = attr;
+        }
+        (pathish, target)
+    }
+
+    /// rustUsesOf's mod layout (name-matcher.ts): one pass over the file's
+    /// tree — the plain `mod name;` decls by the inline chain that owns each,
+    /// the names declared with a `#[path]` of their own, the inline chains
+    /// `mod name { … }` blocks open, and a top-level `fn main`/`#![no_main]`.
+    /// Memoized per file for the resolver's lifetime, as upstream memos
+    /// RUST_USES per context.
+    pub(in super::super) fn rust_mod_facts(&mut self, file: &str) -> Option<Rc<RustModFacts>> {
+        if let Some(hit) = self.rust_mod_facts_memo.get(file) {
+            return hit.clone();
+        }
+        let facts = self.rust_read_mod_facts(file);
+        self.rust_mod_facts_memo.insert(file.into(), facts.clone());
+        facts
+    }
+
+    fn rust_read_mod_facts(&mut self, file: &str) -> Option<Rc<RustModFacts>> {
+        let (source, tree) = self.rust_tree_for(file)?;
+        let text = source.text();
+        let mut facts = RustModFacts::default();
+        let mut stack = vec![tree.root_node()];
+        while let Some(n) = stack.pop() {
+            match n.kind() {
+                "mod_item" => {
+                    if let Some(name_node) = n.child_by_field_name("name") {
+                        let name = rust_text(name_node, text)
+                            .trim_start_matches("r#")
+                            .to_string();
+                        let inline = rust_inline_at(n, text);
+                        let has_body = n.child_by_field_name("body").is_some();
+                        if has_body {
+                            facts.inlines.insert(inline.clone());
+                        }
+                        let (pathish, attr) = Self::rust_mod_path_attr(n, text);
+                        if pathish {
+                            facts.path_mods.insert(name.clone());
+                            if !has_body {
+                                if let Some(target) = attr {
+                                    facts.raw_decls.push(RustRawPathDecl {
+                                        name,
+                                        line: n.start_position().row as i64 + 1,
+                                        col: n.start_position().column as i64,
+                                        inline,
+                                        target,
+                                    });
+                                }
+                            }
+                        } else if !has_body {
+                            facts.mods.entry(name).or_default().push(inline);
+                        }
+                    }
+                }
+                "function_item" => {
+                    if n.child_by_field_name("name")
+                        .is_some_and(|x| rust_text(x, text) == "main")
+                        && n.start_position().column == 0
+                    {
+                        facts.main = true;
+                    }
+                }
+                "inner_attribute_item"
+                    if re!(r"^#!\s*\[\s*no_main\s*\]$")
+                        .is_match(rust_text(n, text).trim_end()) =>
+                {
+                    facts.main = true;
+                }
+                _ => {}
+            }
+            stack.extend(rust_children(n));
+        }
+        Some(Rc::new(facts))
+    }
+
+    /// rustPathDeclsIn (name-matcher.ts): the file's `#[path]` declarations
+    /// with their targets joined to project files. Both forms write `path =`
+    /// (`#[path = "…"]`, `#[cfg_attr(…, path = "…")]`); the bytes are checked
+    /// before the file is decoded, so a file without the word is never read.
+    fn rust_path_decls_in(&mut self, file: &str) -> Rc<Vec<RustPathDecl>> {
+        if let Some(hit) = self.rust_path_decls_memo.get(file) {
+            return hit.clone();
+        }
+        let decls = Rc::new(self.rust_read_path_decls(file));
+        self.rust_path_decls_memo.insert(file.into(), decls.clone());
+        decls
+    }
+
+    fn rust_read_path_decls(&mut self, file: &str) -> Vec<RustPathDecl> {
+        if !file.ends_with(".rs") {
+            return Vec::new();
+        }
+        let Some(source) = self.read_file_uncached(file) else {
+            return Vec::new();
+        };
+        if !source.text().contains("path") || !re!(r"\bpath\s*=").is_match(source.text()) {
+            return Vec::new();
+        }
+        let Some(facts) = self.rust_mod_facts(file) else {
+            return Vec::new();
+        };
+        let mut out = Vec::new();
+        for raw in &facts.raw_decls {
+            let target = raw.target.as_ref().and_then(|literal| {
+                if re!(r"^(?:/|[A-Za-z]:)").is_match(literal) {
+                    return None;
+                }
+                // A `#[path]` is read from the declaring file's directory —
+                // from the inline module's own directory when the decl sits
+                // inside `mod name { … }` (the Rust Reference's rule): the
+                // file's dir for a target root or a `mod.rs`, the file's
+                // `stem/` dir otherwise, then one step per inline name.
+                let mut base = pos_dirname(file).to_string();
+                if !raw.inline.is_empty() {
+                    base = if self.rust_is_target_root(file)
+                        || file == "mod.rs"
+                        || file.ends_with("/mod.rs")
+                    {
+                        base
+                    } else {
+                        file.strip_suffix(".rs").unwrap_or(file).to_string()
+                    };
+                    for name in &raw.inline {
+                        base = pos_join(&base, name);
+                    }
+                }
+                super::super::rust_crates::join_project_dir(&base, literal)
+            });
+            out.push(RustPathDecl {
+                file: file.into(),
+                line: raw.line,
+                col: raw.col,
+                name: raw.name.clone(),
+                inline: raw.inline.clone(),
+                target,
+            });
+        }
+        out
+    }
+
+    /// rustPathLoads (name-matcher.ts): every `#[path]` declaration in the
+    /// project by the file it loads — one sweep of the indexed files, each
+    /// byte-checked for `path` first, computed once per resolver.
+    fn rust_path_loads(&mut self) -> Option<Rc<HashMap<String, Vec<RustPathDecl>>>> {
+        if let Some(hit) = &self.rust_path_loads_memo {
+            return Some(hit.clone());
+        }
+        let files = match self.sorted_files() {
+            Some(files) => files,
+            None => Arc::new(self.table().ok()?.files.iter().cloned().collect::<Vec<_>>()),
+        };
+        let mut out: HashMap<String, Vec<RustPathDecl>> = HashMap::new();
+        for file in files.iter().filter(|f| f.ends_with(".rs")) {
+            for decl in self.rust_path_decls_in(file).iter() {
+                if let Some(target) = &decl.target {
+                    out.entry(target.clone()).or_default().push(decl.clone());
+                }
+            }
+        }
+        let map = Rc::new(out);
+        self.rust_path_loads_memo = Some(map.clone());
+        Some(map)
+    }
+
+    /// rustPathLoaders (name-matcher.ts): the `#[path]` declarations naming
+    /// this file — none when the regular rules already place it (a target
+    /// root, a file with its own `fn main`, a `name.rs`/`name/mod.rs` a plain
+    /// `mod name;` declares).
+    fn rust_path_loaders(&mut self, file: &str) -> Rc<Vec<RustPathDecl>> {
+        if let Some(hit) = self.rust_path_loaders_memo.get(file) {
+            return hit.clone();
+        }
+        let loaders: Rc<Vec<RustPathDecl>> =
+            if !file.ends_with(".rs") || self.rust_placed_by_name(file) {
+                Rc::new(Vec::new())
+            } else {
+                Rc::new(
+                    self.rust_path_loads()
+                        .map(|m| m.get(file).cloned().unwrap_or_default())
+                        .unwrap_or_default(),
+                )
+            };
+        self.rust_path_loaders_memo.insert(file.into(), loaders.clone());
+        loaders
+    }
+
+    /// rustPathClaim (name-matcher.ts): the `#[path]` declaration that loads
+    /// this file, when exactly one does. Two cfg alternatives' decls make
+    /// which file the module is a cfg question the resolver does not answer.
+    pub(in super::super) fn rust_path_claim(&mut self, file: &str) -> Option<RustPathDecl> {
+        let loaders = self.rust_path_loaders(file);
+        (loaders.len() == 1).then(|| loaders[0].clone())
+    }
+
+    /// isRustTargetRoot (name-matcher.ts): a file a manifest or the default
+    /// layout names a crate root — a `[lib]`/`[[bin]]`/`[[example]]`/
+    /// `[[test]]`/`[[bench]]` `path`, `src/lib.rs`, `src/main.rs`,
+    /// `src/bin/*.rs`, a `tests`/`examples`/`benches` target, `build.rs` —
+    /// and, for a file no crate covers, a `lib.rs`/`main.rs` wherever it sits.
+    pub(in super::super) fn rust_is_target_root(&mut self, file: &str) -> bool {
+        let Ok(graph) = self.rust_crate_graph() else {
+            return re!(r"(?:^|/)(?:lib|main)\.rs$").is_match(file);
+        };
+        let Some(dir) = Self::rust_crate_dir_of(file, &graph) else {
+            return re!(r"(?:^|/)(?:lib|main)\.rs$").is_match(file);
+        };
+        if let Some(c) = graph.crates.get(&dir) {
+            if c.lib.as_deref() == Some(file)
+                || c.bins.iter().any(|b| b == file)
+                || c.others.iter().any(|o| o == file)
+            {
+                return true;
+            }
+        }
+        let rel = if dir.is_empty() {
+            file
+        } else {
+            &file[dir.len() + 1..]
+        };
+        re!(r"^src/(?:lib|main)\.rs$|^src/bin/[^/]+(?:\.rs|/main\.rs)$|^(?:tests|examples|benches)/[^/]+(?:\.rs|/main\.rs)$|^build\.rs$").is_match(rel)
+    }
+
+    /// rustPlacedByName (name-matcher.ts): the regular rules already place
+    /// the file — a crate root (a target root, or one with a `fn main`/
+    /// `#![no_main]` of its own, as a trybuild case is), or a `name.rs`/
+    /// `name/mod.rs` a plain `mod name;` declares in the module owning its
+    /// directory or in an inline module of one above it (≤4 levels, as
+    /// upstream).
+    fn rust_placed_by_name(&mut self, file: &str) -> bool {
+        if self.rust_is_target_root(file)
+            || self.rust_mod_facts(file).is_some_and(|f| f.main)
+        {
+            return true;
+        }
+        let dir = pos_dirname(file);
+        let is_mod = file == "mod.rs" || file.ends_with("/mod.rs");
+        if is_mod && dir.is_empty() {
+            return false;
+        }
+        let base = if is_mod { dir } else { file };
+        let base = pos_basename(base);
+        let name = base.strip_suffix(".rs").unwrap_or(base).to_string();
+        let mut parent = if is_mod {
+            pos_dirname(dir).to_string()
+        } else {
+            dir.to_string()
+        };
+        let mut inline: Vec<String> = Vec::new();
+        for _ in 0..4 {
+            let mut owners = vec![pos_join(&parent, "mod.rs")];
+            if !parent.is_empty() {
+                owners.push(format!("{parent}.rs"));
+            }
+            for f in self.rust_rs_files_in_dir(&parent).iter() {
+                if self.rust_is_target_root(f) {
+                    owners.push(f.clone());
+                }
+            }
+            for owner in owners {
+                if owner == file || !self.file_exists(&owner) {
+                    continue;
+                }
+                if let Some(facts) = self.rust_mod_facts(&owner) {
+                    if facts.mods.contains_key(&name)
+                        && (inline.is_empty() || facts.inlines.contains(&inline))
+                    {
+                        return true;
+                    }
+                }
+            }
+            if parent.is_empty() {
+                break;
+            }
+            inline.insert(0, pos_basename(&parent).to_string());
+            parent = pos_dirname(&parent).to_string();
+        }
+        false
+    }
+
+    /// The directory under which the file's own submodules live — its own
+    /// directory when a `#[path]` loads it or the manifest layout makes it a
+    /// target root (rustc reads both like a `mod.rs`), else
+    /// `rust_self_module_dir`'s `<file-stem>/` (rustFileModule's `dir`,
+    /// name-matcher.ts).
+    pub(in super::super) fn rust_module_dir_of(&mut self, file: &str) -> String {
+        if self.rust_path_claim(file).is_some() || self.rust_is_target_root(file) {
+            return pos_dirname(file).to_string();
+        }
+        rust_self_module_dir(file)
+    }
+
+    /// rustModuleWithin (name-matcher.ts): `inner` is `outer` or a module it
+    /// declares, inline or in a file below its directory — and a file a
+    /// `#[path]` loads is inside the module that declares it (claims ≤8).
+    fn rust_module_within(&mut self, inner: &RustModule, outer: &RustModule, depth: usize) -> bool {
+        if inner.file == outer.file {
+            return inner.inline.starts_with(&outer.inline);
+        }
+        let mut dir = self.rust_module_dir_of(&outer.file);
+        for seg in &outer.inline {
+            dir = pos_join(&dir, seg);
+        }
+        if dir.is_empty() || inner.file.starts_with(&format!("{dir}/")) {
+            return true;
+        }
+        if depth < 8 && inner.inline.is_empty() {
+            if let Some(claim) = self.rust_path_claim(&inner.file) {
+                let at = self.rust_module_at(&claim.file, claim.line, claim.col);
+                return self.rust_module_within(&at, outer, depth + 1);
+            }
+        }
+        false
+    }
+
+    /// rustFileUnder (name-matcher.ts): `file` is inside `owner`'s module —
+    /// under its submodule dir, or is the owner itself once the `#[path]`
+    /// claim chain is followed from the ref's file to the declaring one
+    /// (≤8 hops, as upstream).
+    pub(in super::super) fn rust_file_under(
+        &mut self,
+        file: &str,
+        owner_dir: &str,
+        owner_file: &str,
+    ) -> bool {
+        let mut f = file.to_string();
+        for i in 0..8 {
+            if f.starts_with(&format!("{owner_dir}/")) || (i > 0 && f == owner_file) {
+                return true;
+            }
+            let Some(claim) = self.rust_path_claim(&f) else {
+                return false;
+            };
+            f = claim.file;
+        }
+        false
+    }
+
     fn rust_submodule(&mut self, m: &RustModule, name: &str) -> Option<RustModule> {
+        // A `#[path]` decl of the name in this scope is the file it names;
+        // two cfg alternatives (or a `cfg_attr`'s unknown target) leave the
+        // module unknown — never the `name.rs` a name-only lookup would find.
+        if self
+            .rust_mod_facts(&m.file)
+            .is_some_and(|f| f.path_mods.contains(name))
+        {
+            let decls = self.rust_path_decls_in(&m.file);
+            let decls: Vec<&RustPathDecl> = decls
+                .iter()
+                .filter(|d| d.name == name && d.inline == m.inline)
+                .collect();
+            return match decls.as_slice() {
+                [d] => d
+                    .target
+                    .clone()
+                    .filter(|t| self.file_exists(t))
+                    .map(|file| RustModule {
+                        file,
+                        inline: Vec::new(),
+                    }),
+                _ => None,
+            };
+        }
         if let Some((source, tree)) = self.rust_tree_for(&m.file) {
             let body = Self::rust_module_body(&tree, source.text(), &m.inline)?;
             if rust_children(body).iter().any(|n| {
@@ -292,7 +770,7 @@ impl KernelResolver {
                 return Some(sub);
             }
         }
-        let mut dir = rust_self_module_dir(&m.file);
+        let mut dir = self.rust_module_dir_of(&m.file);
         for seg in &m.inline {
             dir = pos_join(&dir, seg);
         }
@@ -309,12 +787,21 @@ impl KernelResolver {
         }
         None
     }
-    fn rust_super_module(&mut self, m: &RustModule) -> Option<RustModule> {
+    pub(in super::super) fn rust_super_module(&mut self, m: &RustModule) -> Option<RustModule> {
         let mut m = m.clone();
         if m.inline.pop().is_some() {
             return Some(m);
         }
-        let dir = pos_dirname(&rust_self_module_dir(&m.file)).to_string();
+        // A file a `#[path]` loads is declared in the module the attribute is
+        // in — not in a module of the directory it happens to sit in.
+        if let Some(claim) = self.rust_path_claim(&m.file) {
+            return Some(self.rust_module_at(&claim.file, claim.line, claim.col));
+        }
+        // Above a crate's root there is no module (upstream's m.root flag).
+        if self.rust_is_target_root(&m.file) {
+            return None;
+        }
+        let dir = pos_dirname(&self.rust_module_dir_of(&m.file)).to_string();
         for p in [
             pos_join(&dir, "mod.rs"),
             pos_join(&dir, "lib.rs"),
@@ -408,8 +895,16 @@ impl KernelResolver {
                 p.extend_from_slice(&path[i + 1..]);
                 return self.rust_walk_module(&p, &m, depth + 1);
             }
-            // Bare module names in Rust 2015 use paths may be crate-relative.
+            // Bare module names in Rust 2015 use paths may be crate-relative —
+            // but a `#[path]` decl of the head stays unknown; the fallback may
+            // not bypass it to a crate-root namesake (rustPathTarget's guard).
             if i == 0 {
+                if self
+                    .rust_mod_facts(&from.file)
+                    .is_some_and(|f| f.path_mods.contains(&path[0]))
+                {
+                    return None;
+                }
                 let root = self.rust_root_module(&from.file)?;
                 if root != m {
                     return self.rust_walk_module(path, &root, depth + 1);
@@ -536,12 +1031,6 @@ impl KernelResolver {
         let Some(m) = self.rust_walk_module(prefix, from, 0) else {
             return Ok(None);
         };
-        if self
-            .read_file(&m.file)
-            .is_some_and(|s| re!(r"#\s*\[\s*path\s*=").is_match(s.text()))
-        {
-            return Ok(None);
-        }
         self.rust_items_in_module(&m, leaf, public_only, seen)
             .map(Some)
     }
@@ -729,8 +1218,12 @@ impl KernelResolver {
                 }
                 if let Some(sub) = self.rust_walk_module(&p, &m, 0) {
                     seen_glob = true;
+                    // A glob's view from outside the module is its `pub`
+                    // surface; inside it (a `#[path]`-loaded file's
+                    // `use super::*` included) private items count too.
+                    let public_only = !self.rust_module_within(&m, &sub, 0);
                     for item in self
-                        .rust_items_in_module(&sub, name, false, &mut HashSet::new())
+                        .rust_items_in_module(&sub, name, public_only, &mut HashSet::new())
                         .ok()?
                     {
                         ids.insert(item.id.clone());
diff --git a/codegraph-kernel/src/resolve/rust_types.rs b/codegraph-kernel/src/resolve/rust_types.rs
index 75537086d..e1cb9714e 100644
--- a/codegraph-kernel/src/resolve/rust_types.rs
+++ b/codegraph-kernel/src/resolve/rust_types.rs
@@ -1693,6 +1693,118 @@ impl KernelResolver {
             None
         })
     }
+    /// The item `Type::member` names when `rust_method_on` finds no method:
+    /// the member of each type the written path or `use` resolves to
+    /// (rustTypeMember, #3025).
+    fn rust_path_type_member(&mut self, w: &Written, member: &str) -> Res<Option<Arc<KNode>>> {
+        for decl in self.rust_type_decls(w)? {
+            if let Some(hit) = self.rust_type_member(&decl, member)? {
+                return Ok(Some(hit));
+            }
+        }
+        Ok(None)
+    }
+
+    /// rustTypeMember (name-matcher.ts): the associated item `member` of the
+    /// Rust type `ty` — an enum's variant; else the type's own (inherent)
+    /// function or `const` in the type's crate, a trait impl's only when it
+    /// is the one item of that name; a trait's own declared method. An impl
+    /// of the type is written in the type's crate, so a namesake type's impl
+    /// in another crate is never it.
+    fn rust_type_member(&mut self, ty: &KNode, member: &str) -> Res<Option<Arc<KNode>>> {
+        if ty.language != "rust"
+            || !matches!(ty.kind.as_str(), "struct" | "enum" | "union" | "trait")
+        {
+            return Ok(None);
+        }
+        let key = format!("{}\0{}", ty.id, member);
+        if let Some(hit) = self.rust_type_member_memo.get(&key) {
+            return match hit {
+                Some(id) => self.node_by_id(id),
+                None => Ok(None),
+            };
+        }
+        let mut found: Option<Arc<KNode>> = None;
+        if ty.kind == "enum" {
+            let qualified = format!("{}::{}", ty.qualified_name, member);
+            found = self
+                .nodes_in_file(&ty.file_path)?
+                .iter()
+                .find(|n| {
+                    n.kind == "enum_member"
+                        && n.qualified_name == qualified
+                        && n.start_line >= ty.start_line
+                        && n.start_line <= ty.end_line
+                })
+                .cloned();
+        }
+        if found.is_none() {
+            let graph = self.rust_crate_graph()?;
+            let own = Self::rust_crate_dir_of(&ty.file_path, &graph);
+            let qualified = format!("{}::{}", ty.name, member);
+            let all: Vec<Arc<KNode>> = self
+                .nodes_by_name(member)?
+                .iter()
+                .filter(|n| {
+                    n.language == "rust"
+                        && matches!(
+                            n.kind.as_str(),
+                            "method" | "function" | "variable" | "constant" | "enum_member"
+                        )
+                        && n.qualified_name == qualified
+                        && Self::rust_crate_dir_of(&n.file_path, &graph) == own
+                        && (ty.kind != "trait"
+                            || (n.file_path == ty.file_path
+                                && n.start_line >= ty.start_line
+                                && n.start_line <= ty.end_line))
+                })
+                .cloned()
+                .collect();
+            let mut inherent = Vec::new();
+            for n in &all {
+                if !self.rust_is_trait_impl_member(n)? {
+                    inherent.push(n.clone());
+                }
+            }
+            let pool = if !inherent.is_empty() {
+                inherent
+            } else if all.len() == 1 {
+                all
+            } else {
+                Vec::new()
+            };
+            found = pool
+                .iter()
+                .find(|n| n.file_path == ty.file_path)
+                .cloned()
+                .or_else(|| pool.into_iter().next());
+        }
+        self.rust_type_member_memo
+            .insert(key, found.as_ref().map(|n| n.id.clone()));
+        Ok(found)
+    }
+
+    /// isRustTraitImplMethod (name-matcher.ts): `candidate` is a method
+    /// inside an `impl Trait for Type` block.
+    fn rust_is_trait_impl_member(&mut self, candidate: &KNode) -> Res<bool> {
+        if candidate.kind != "method" {
+            return Ok(false);
+        }
+        let Some((s, t)) = self.rust_tree_for(&candidate.file_path) else {
+            return Ok(false);
+        };
+        let Some(f) = self.rust_declaration_node(
+            candidate,
+            &t,
+            s.text(),
+            &["function_item", "function_signature_item"],
+        ) else {
+            return Ok(false);
+        };
+        Ok(rust_ancestor(f, &["impl_item"])
+            .is_some_and(|imp| imp.child_by_field_name("trait").is_some()))
+    }
+
     pub(super) fn rust_impl_start(&mut self, file: &str, line: i64, col: i64) -> Option<usize> {
         let (s, t) = self.rust_tree_for(file)?;
         rust_ancestor(
@@ -1922,6 +2034,11 @@ impl KernelResolver {
             None if function.kind() == "field_expression" => {
                 self.rust_derived_trait_method(&written, &method, r)?
             }
+            // `Type::member` — an enum's variant, a `const`, a trait's own
+            // declared method — of the type the path or `use` names (#3025).
+            None if function.kind() == "scoped_identifier" => {
+                self.rust_path_type_member(&written, &method)?
+            }
             None => None,
         };
         if node.is_some() {
diff --git a/codegraph-kernel/src/ruby.rs b/codegraph-kernel/src/ruby.rs
index bb239b341..2882ee15b 100644
--- a/codegraph-kernel/src/ruby.rs
+++ b/codegraph-kernel/src/ruby.rs
@@ -633,6 +633,22 @@ impl<'t> Walker<'t> {
         self.push_ref_at(parent, &ref_path, imports_kind, node);
     }
 
+    /// rubyConstructedClass (tree-sitter.ts): the class a call receiver
+    /// constructs, as written — `Foo` for `Foo.new(key)`, `Billing::Card` for
+    /// `Billing::Card.new`, `::Foo` for `::Foo.new`; None for any other
+    /// receiver, a `new` on a value (`klass.new`) among them.
+    fn constructed_class(&self, receiver: Node<'t>) -> Option<&'t str> {
+        if receiver.kind() != "call" {
+            return None;
+        }
+        let method = receiver.child_by_field_name("method")?;
+        let made = receiver.child_by_field_name("receiver")?;
+        if self.text(method) != "new" || !is_constant_path(made) {
+            return None;
+        }
+        Some(self.text(made))
+    }
+
     /// extractCall — the bespoke ruby branch (tree-sitter.ts:3905-3960),
     /// reached only from the body walker.
     fn extract_call(&mut self, node: Node<'t>) {
@@ -680,6 +696,10 @@ impl<'t> Walker<'t> {
         let skip = matches!(receiver_name, "self" | "super");
         let callee = if skip {
             method_name.to_string()
+        } else if let Some(class_name) = self.constructed_class(receiver) {
+            // A call on what `Foo.new(…)` made: `new Foo().m`, not the
+            // receiver's text with its arguments in it.
+            format!("new {class_name}().{method_name}")
         } else {
             format!("{receiver_name}.{method_name}")
         };
diff --git a/src/extraction/astro-extractor.ts b/src/extraction/astro-extractor.ts
index 0d048dae5..e6740cd49 100644
--- a/src/extraction/astro-extractor.ts
+++ b/src/extraction/astro-extractor.ts
@@ -2,7 +2,7 @@ import { Binding, Node, Edge, ExtractionResult, ExtractionError, UnresolvedRefer
 import { generateNodeId } from './tree-sitter-helpers';
 import { extractEmbeddedBlock } from './block-extract';
 import { isLanguageSupported } from './grammars';
-import { arrowScopes, declaredByArrow, foldScriptResult, sfcFileNode } from './sfc-script';
+import { arrowScopes, declaredByArrow, foldScriptResult, sfcFileNode, SFC_SCRIPT_ELEMENT, sfcBlockLineRanges } from './sfc-script';
 
 /**
  * Astro built-in components — compiler-provided (`<Fragment>`) or shipped by
@@ -163,7 +163,7 @@ export class AstroExtractor {
 
     // A self-closing `<script ... />` (e.g. `is:inline set:html={...}`) has no
     // body; match it on its own so it cannot run on to the next `</script>`.
-    const scriptRegex = /<script(\s[^>]*?)?(?:\/>|>(?<content>[\s\S]*?)<\/script>)/g;
+    const scriptRegex = new RegExp(SFC_SCRIPT_ELEMENT);
     let match;
 
     while ((match = scriptRegex.exec(this.source)) !== null) {
@@ -227,16 +227,9 @@ export class AstroExtractor {
       coveredRanges.push([frontmatter.startLine - 1, frontmatter.endLine]);
     }
 
-    const tagRegex = /<(script|style)(\s[^>]*?)?(?:\/>|>[\s\S]*?<\/\1>)/g;
-    let tagMatch;
-    while ((tagMatch = tagRegex.exec(this.source)) !== null) {
-      // A self-closing tag has no body to skip, and its attributes
-      // (`set:html={serializeJsonLd(schema)}`) are template expressions.
-      if (tagMatch[0].endsWith('/>')) continue;
-      const startLine = (this.source.substring(0, tagMatch.index).match(/\n/g) || []).length;
-      const endLine = startLine + (tagMatch[0].match(/\n/g) || []).length;
-      coveredRanges.push([startLine, endLine]);
-    }
+    // A self-closing tag covers nothing: its attributes
+    // (`set:html={serializeJsonLd(schema)}`) are template expressions.
+    coveredRanges.push(...sfcBlockLineRanges(this.source));
 
     return coveredRanges;
   }
diff --git a/src/extraction/sfc-script.ts b/src/extraction/sfc-script.ts
index eec289c40..83c100abd 100644
--- a/src/extraction/sfc-script.ts
+++ b/src/extraction/sfc-script.ts
@@ -42,6 +42,51 @@ export function sfcFileNode(filePath: string, source: string, language: Language
   };
 }
 
+/**
+ * A `<script>` element of a Vue, Svelte or Astro file: group 1 its opening
+ * tag's attributes, `content` its body. A self-closing tag — Astro's
+ * `<script is:inline set:html={code} />`, a third-party
+ * `<script src="/analytics.js" />` — is matched on its own, with no
+ * `content`: read as an opening tag it ran on to the next script's
+ * `</script>`, and that script was parsed with the markup in between and
+ * contributed nothing (#2989).
+ *
+ * Shared by the three extractors and the viewer's syntax regions. It carries
+ * the `g` flag, so each loop runs on its own copy (`new RegExp(...)`).
+ */
+export const SFC_SCRIPT_ELEMENT = /<script(\s[^>]*?)?(?:\/>|>(?<content>[\s\S]*?)<\/script\s*>)/g;
+
+/**
+ * A `<script>` or `<style>` element, which the template scans skip: what it
+ * holds is code or CSS, not markup. A self-closing one (see
+ * {@link SFC_SCRIPT_ELEMENT}) has no body to skip, and its attributes, like
+ * `set:html={serializeJsonLd(schema)}`, are template expressions like any
+ * other's: {@link sfcElementHasBody} says which a match is.
+ */
+export const SFC_SCRIPT_OR_STYLE_ELEMENT = /<(script|style)(\s[^>]*?)?(?:\/>|>[\s\S]*?<\/\1\s*>)/g;
+
+/** Whether a match of {@link SFC_SCRIPT_OR_STYLE_ELEMENT} has a body: false for a self-closing tag. */
+export function sfcElementHasBody(element: string): boolean {
+  return !element.endsWith('/>');
+}
+
+/**
+ * The lines (0-indexed, inclusive) of each `<script>` and `<style>` element
+ * with a body in `source`, which a template scan skips. A self-closing tag
+ * covers nothing.
+ */
+export function sfcBlockLineRanges(source: string): Array<[number, number]> {
+  const ranges: Array<[number, number]> = [];
+  const elements = new RegExp(SFC_SCRIPT_OR_STYLE_ELEMENT);
+  let match: RegExpExecArray | null;
+  while ((match = elements.exec(source)) !== null) {
+    if (!sfcElementHasBody(match[0])) continue;
+    const startLine = (source.substring(0, match.index).match(/\n/g) || []).length;
+    ranges.push([startLine, startLine + (match[0].match(/\n/g) || []).length]);
+  }
+  return ranges;
+}
+
 const NAME = /[A-Za-z_$][\w$]*/g;
 /** Quoted text and comments, which can hold arrow-like text that declares nothing. */
 const QUOTED_OR_COMMENT = /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`|\/\*[\s\S]*?\*\/|\/\/.*$/gm;
diff --git a/src/extraction/svelte-extractor.ts b/src/extraction/svelte-extractor.ts
index afacfb5cc..96e0a8fd8 100644
--- a/src/extraction/svelte-extractor.ts
+++ b/src/extraction/svelte-extractor.ts
@@ -2,7 +2,7 @@ import { Binding, Node, Edge, ExtractionResult, ExtractionError, UnresolvedRefer
 import { generateNodeId } from './tree-sitter-helpers';
 import { extractEmbeddedBlock } from './block-extract';
 import { isLanguageSupported } from './grammars';
-import { arrowScopes, declaredByArrow, foldScriptResult, sfcFileNode, sfcScriptLanguage } from './sfc-script';
+import { arrowScopes, declaredByArrow, foldScriptResult, sfcFileNode, sfcScriptLanguage, SFC_SCRIPT_ELEMENT, sfcBlockLineRanges } from './sfc-script';
 
 /** Svelte 5 rune names — compiler builtins, not real functions */
 const SVELTE_RUNES = new Set([
@@ -161,7 +161,7 @@ export class SvelteExtractor {
     // A self-closing `<script ... />` (e.g. a third-party script in
     // `<svelte:head>`) has no body; match it on its own so it cannot run on to
     // the next `</script>`.
-    const scriptRegex = /<script(\s[^>]*?)?(?:\/>|>(?<content>[\s\S]*?)<\/script>)/g;
+    const scriptRegex = new RegExp(SFC_SCRIPT_ELEMENT);
     let match;
 
     while ((match = scriptRegex.exec(this.source)) !== null) {
@@ -236,20 +236,10 @@ export class SvelteExtractor {
     componentNodeId: string,
     _scriptBlocks: Array<{ content: string; startLine: number }>
   ): void {
-    // Build a set of line ranges covered by <script> and <style> blocks so we skip them
-    const coveredRanges: Array<[number, number]> = [];
-
-    // Find all <script>...</script> and <style>...</style> ranges
-    const tagRegex = /<(script|style)(\s[^>]*?)?(?:\/>|>[\s\S]*?<\/\1>)/g;
-    let tagMatch;
-    while ((tagMatch = tagRegex.exec(this.source)) !== null) {
-      // A self-closing tag has no body to skip, and its attributes
-      // (`src={assetUrl('/analytics.js')}`) are template expressions.
-      if (tagMatch[0].endsWith('/>')) continue;
-      const startLine = (this.source.substring(0, tagMatch.index).match(/\n/g) || []).length;
-      const endLine = startLine + (tagMatch[0].match(/\n/g) || []).length;
-      coveredRanges.push([startLine, endLine]);
-    }
+    // Line ranges covered by <script> and <style> blocks, so we skip them. A
+    // self-closing tag covers nothing: its attributes
+    // (`src={assetUrl('/analytics.js')}`) are template expressions.
+    const coveredRanges = sfcBlockLineRanges(this.source);
 
     // Find template expressions: {...} outside of script/style blocks
     // Matches curly-brace expressions, excluding Svelte block syntax ({#if}, {:else}, {/if}, {@html}, {@render})
@@ -323,17 +313,9 @@ export class SvelteExtractor {
    * gives codegraph_explore anchor points in the template markup.
    */
   private extractTemplateComponents(componentNodeId: string): void {
-    // Build ranges covered by <script> and <style> blocks to skip them
-    const coveredRanges: Array<[number, number]> = [];
-    const tagRegex = /<(script|style)(\s[^>]*?)?(?:\/>|>[\s\S]*?<\/\1>)/g;
-    let tagMatch;
-    while ((tagMatch = tagRegex.exec(this.source)) !== null) {
-      // A self-closing tag has no body to skip.
-      if (tagMatch[0].endsWith('/>')) continue;
-      const startLine = (this.source.substring(0, tagMatch.index).match(/\n/g) || []).length;
-      const endLine = startLine + (tagMatch[0].match(/\n/g) || []).length;
-      coveredRanges.push([startLine, endLine]);
-    }
+    // Ranges covered by <script> and <style> blocks to skip them; a
+    // self-closing tag covers nothing.
+    const coveredRanges = sfcBlockLineRanges(this.source);
 
     const lines = this.source.split('\n');
     // Match PascalCase opening/self-closing tags (closing tags </Foo> start with </ so won't match)
diff --git a/src/extraction/syntax-tokens.ts b/src/extraction/syntax-tokens.ts
index ea15a4bdf..fcc16ab11 100644
--- a/src/extraction/syntax-tokens.ts
+++ b/src/extraction/syntax-tokens.ts
@@ -42,7 +42,7 @@ import { Language } from '../types';
 import { EXTRACTORS } from './languages';
 import type { TreeNode as SyntaxNode } from './parse-tree';
 import { parseWithinBudget } from './parse-budget';
-import { sfcScriptLanguage } from './sfc-script';
+import { sfcScriptLanguage, SFC_SCRIPT_ELEMENT } from './sfc-script';
 import type { LanguageExtractor } from './tree-sitter-types';
 
 /* ------------------------------------------------------------- the classes -- */
@@ -361,8 +361,9 @@ export interface SyntaxRegion {
   language: Language;
 }
 
-// A self-closing `<script ... />` has no body and must not run on to the next `</script>`.
-const SCRIPT_BLOCK = /<script(\s[^>]*?)?(?:\/>|>([\s\S]*?)<\/script>)/gi;
+// The extractors' own script element, read case-insensitively here. A
+// self-closing `<script ... />` has no body and must not run on to the next `</script>`.
+const SCRIPT_BLOCK = new RegExp(SFC_SCRIPT_ELEMENT.source, 'gi');
 /** Astro's frontmatter: a `---` fence at the very top of the file. */
 const ASTRO_FRONTMATTER = /^(---\r?\n)([\s\S]*?)\r?\n---/;
 
@@ -389,7 +390,8 @@ export function syntaxRegionsFor(source: string, language: Language): SyntaxRegi
   while ((match = SCRIPT_BLOCK.exec(source)) !== null) {
     const body = match[2] ?? '';
     if (body.trim() === '') continue;
-    const start = match.index + match[0].length - body.length - '</script>'.length;
+    // The body starts right after the opening tag, whose attributes hold no `>`.
+    const start = match.index + match[0].indexOf('>') + 1;
     regions.push({
       start,
       end: start + body.length,
diff --git a/src/extraction/vue-extractor.ts b/src/extraction/vue-extractor.ts
index 584631d02..a0415571c 100644
--- a/src/extraction/vue-extractor.ts
+++ b/src/extraction/vue-extractor.ts
@@ -2,7 +2,7 @@ import { Binding, Node, Edge, ExtractionResult, ExtractionError, UnresolvedRefer
 import { generateNodeId } from './tree-sitter-helpers';
 import { extractEmbeddedBlock } from './block-extract';
 import { isLanguageSupported } from './grammars';
-import { foldScriptResult, sfcFileNode, sfcScriptLanguage } from './sfc-script';
+import { foldScriptResult, sfcFileNode, sfcScriptLanguage, SFC_SCRIPT_ELEMENT, sfcBlockLineRanges } from './sfc-script';
 import { vueOptionsMembers } from './vue-options-api';
 import { vueTemplateCalls } from './vue-template-calls';
 
@@ -203,12 +203,15 @@ export class VueExtractor {
       language: Language;
     }> = [];
 
-    const scriptRegex = /<script(\s[^>]*)?>(?<content>[\s\S]*?)<\/script>/g;
+    // A self-closing `<script src="./legacy.js" />` has no body; match it on
+    // its own so it cannot run on to the next block's `</script>`.
+    const scriptRegex = new RegExp(SFC_SCRIPT_ELEMENT);
     let match;
 
     while ((match = scriptRegex.exec(this.source)) !== null) {
+      if (match.groups?.content === undefined) continue;
       const attrs = match[1] || '';
-      const content = match.groups?.content || match[2] || '';
+      const content = match.groups.content;
 
       // TypeScript, TSX or JavaScript, from the lang attribute
       const language = sfcScriptLanguage(attrs, 'vue');
@@ -289,15 +292,9 @@ export class VueExtractor {
     // Ranges covered by <script> / <style> blocks — skip them so script
     // identifiers and CSS selectors aren't mistaken for template tags. This
     // also correctly handles nested <template> tags (v-if / slots), which a
-    // single non-greedy <template>…</template> match would mis-bound.
-    const coveredRanges: Array<[number, number]> = [];
-    const blockRegex = /<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1>/g;
-    let blockMatch;
-    while ((blockMatch = blockRegex.exec(this.source)) !== null) {
-      const startLine = (this.source.substring(0, blockMatch.index).match(/\n/g) || []).length;
-      const endLine = startLine + (blockMatch[0].match(/\n/g) || []).length;
-      coveredRanges.push([startLine, endLine]);
-    }
+    // single non-greedy <template>…</template> match would mis-bound. A
+    // self-closing `<script ... />` covers nothing.
+    const coveredRanges = sfcBlockLineRanges(this.source);
 
     const lines = this.source.split('\n');
     // Opening / self-closing tags (closing `</Foo>` starts with `</`, so the
diff --git a/src/extraction/vue-template-calls.ts b/src/extraction/vue-template-calls.ts
index 4936c8b32..6de28bd7f 100644
--- a/src/extraction/vue-template-calls.ts
+++ b/src/extraction/vue-template-calls.ts
@@ -30,6 +30,7 @@
 
 import { parseSourceTreeSync, type TreeNode } from './parse-tree';
 import { DecodingMode, EntityDecoder, htmlDecodeTree } from 'entities/decode';
+import { SFC_SCRIPT_OR_STYLE_ELEMENT, sfcElementHasBody } from './sfc-script';
 
 export interface VueTemplateCall {
   /** The callee as a script-side call names it: `useBar`, `store.fetchUsers`. */
@@ -77,10 +78,11 @@ const FOR_ALIAS = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
 
 /** Every call written in the root `<template>` of a Vue SFC, in source order. */
 export function vueTemplateCalls(source: string): VueTemplateCall[] {
-  // Blank <script>/<style> blocks and HTML comments, keeping every offset.
+  // Blank <script>/<style> blocks and HTML comments, keeping every offset. A
+  // self-closing `<script ... />` has no body to blank: its attributes are markup.
   const blank = (m: string) => m.replace(/[^\n]/g, ' ');
   const masked = source
-    .replace(/<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1\s*>/g, blank)
+    .replace(new RegExp(SFC_SCRIPT_OR_STYLE_ELEMENT), (m) => (sfcElementHasBody(m) ? blank(m) : m))
     .replace(/<!--[\s\S]*?-->/g, blank);
   const root = rootTemplate(masked);
   if (!root) return [];
diff --git a/src/resolution/frameworks/cargo-workspace.ts b/src/resolution/frameworks/cargo-workspace.ts
index 2a81284bd..e4d1a020d 100644
--- a/src/resolution/frameworks/cargo-workspace.ts
+++ b/src/resolution/frameworks/cargo-workspace.ts
@@ -7,8 +7,10 @@
  * into workspace member crates.
  */
 
+import * as path from 'path';
 import picomatch from 'picomatch';
 import { ResolutionContext } from '../types';
+import { escapesRoot } from '../../utils';
 
 const GLOB_CHARS = /[*?[\]{}!]/;
 const SKIP_DIRS = new Set(['target', 'node_modules', '.git', 'dist', 'build']);
@@ -201,6 +203,8 @@ function expandMembers(members: string[], context: ResolutionContext): string[]
   const expanded: string[] = [];
   const seen = new Set<string>();
   for (const member of members) {
+    // A member outside the project (`../shared`, an absolute path) is neither read nor listed.
+    if (escapesRoot(path.posix.normalize(member.replace(/\\/g, '/')))) continue;
     const candidates = GLOB_CHARS.test(member)
       ? expandGlobMember(member, context)
       : [member];