diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d48973f50f..38b097e17a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -275,10 +275,12 @@ jobs:
           V="${{ steps.ver.outputs.version }}"
           # npm publish can print success without persisting; confirm against the
           # registry (with retries for propagation) so green means really shipped.
+          # Up to 5 minutes per package: 1.6.1's packages all published fine but
+          # took longer than the old 60 s to appear, which failed the run.
           for dir in release/npm/codegraph-* release/npm/main; do
             name=$(node -p "require('./$dir/package.json').name")
             ok=
-            for i in 1 2 3 4 5 6; do
+            for i in $(seq 1 30); do
               if npm view "$name@$V" version >/dev/null 2>&1; then ok=1; break; fi
               echo "waiting for $name@$V to appear ($i)…"; sleep 10
             done
diff --git a/.pinable/upstream.json b/.pinable/upstream.json
index c062f97db0..647f70ff2b 100644
--- a/.pinable/upstream.json
+++ b/.pinable/upstream.json
@@ -1,5 +1,5 @@
 {
   "repository": "colbymchenry/codegraph",
   "branch": "main",
-  "commit": "7639c787e48be92ea4ca83c5c014d8dd480de470"
+  "commit": "b635dd467f0578926a9c01a37b9d28d2b26689f1"
 }
diff --git a/AGENTS.md b/AGENTS.md
index 2abe06c4ad..fd5daee8ef 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -181,6 +181,8 @@ Tests live in `__tests__/` and mirror the module they cover. Notable ones beyond
 
 Tests create temp dirs with `fs.mkdtempSync` and clean up in `afterEach`. They write real files and exercise real SQLite — there is no DB mocking.
 
+Every engine test file runs in a throwaway home dir (`__tests__/setup-home-sandbox.ts`, a `setupFiles` entry): `HOME`/`USERPROFILE` (+ Windows vars), `XDG_CONFIG_HOME` and `GIT_CONFIG_GLOBAL` point into it, and `CLAUDE_CONFIG_DIR`/`CODEX_HOME`/… are cleared; spawned children inherit it. It's a backstop — still inject writes to global state (e.g. `UpgradeDeps.wirePromptHook`, #2275).
+
 ### Windows-gated tests
 
 Behavior that differs by platform (path resolution, drive letters, `SENSITIVE_PATHS`, `%APPDATA%` config dirs, CRLF) must be gated, not assumed. Use `it.runIf(process.platform === 'win32')(...)` for Windows-only assertions and `it.runIf(process.platform !== 'win32')(...)` for POSIX-only ones — e.g. `/etc` is sensitive on POSIX but resolves to `C:\etc` (non-existent) on Windows, so an ungated `/etc` assertion fails on Windows. Validate the Windows side for real (see below); don't merge a Windows-gated test you haven't seen run.
@@ -212,6 +214,7 @@ For any Windows-specific PR, bug, or implementation, validate it on the real Win
 - Guest toolchain (winget): Node LTS, Git, and the **VC++ ARM64 redistributable** (required by `@rollup/rollup-win32-arm64-msvc`, which vitest pulls in).
 - Fetch a contributor PR head straight from their fork to dodge `pull/<n>/head` lag: `git fetch <fork-url> <branch>` then `git checkout -f FETCH_HEAD`.
 - Windows baseline: as of #2053 the full suite passes on the Windows 11 (ARM64) VM. The only expected exception is `security.test.ts > Session marker symlink resistance > does not follow a pre-planted symlink`, which needs symlink privileges (Developer Mode) — confirm any other failure against `origin/main` before blaming your PR. The former `mcp-initialize.test.ts` / `mcp-roots.test.ts` `EPERM` teardown failures came from tests spawning `serve --mcp` without the runtime flags (its `--liftoff-only` re-exec grandchild kept the cwd / SQLite file open); spawn it with `WASM_RUNTIME_FLAGS` and await the child's exit before removing the temp dir. Windows checkouts may be CRLF — split source lines on `/\r?\n/` in tests.
+- Windows worker crashes: a worker thread that ends (`terminate()`, its own `process.exit()`, or the process exiting) while V8's concurrent marker is marking its heap kills the process with exit 3221225477 (0xC0000005) and leaves no error or dump. It's worst while the worker is still loading its modules. Owners must not terminate a worker before its first message (`workerStarted` / `terminateOnceStarted`, or the pool's own handshake), and a worker that exits itself calls `collectBeforeExit()` first — both in `src/worker-teardown.ts`. `--no-concurrent-marking` also stops it, but measured about a third slower indexing on the Windows VM, so it is not used.
 
 ## Releases
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e02a77eeb1..4c748563ff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,12 +14,311 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixes
 
+- In VB.NET, every member of a `Structure` is now indexed, including its fields, properties, methods, constructors and nested enums. Before, only the first member was, so the rest could not be found and their callers looked empty.
+- In VB.NET and C#, what a property's `Get` and `Set` code calls, creates and reads now belongs to that property, as do C#'s `get => …` accessors and `=> …` property bodies. Before, it was dropped, so a method used only from a property looked unused.
+- In VB.NET, a field or property initializer like `= Compute()` or `As New List(Of Order)` now links what it calls and creates, and so do a `Custom Event`'s `AddHandler`, `RemoveHandler` and `RaiseEvent` blocks. Re-index VB.NET and C# projects after upgrading.
+- In C#, a field or property initializer like `private readonly ILogger _log = LogManager.GetLogger(typeof(X));` or `public List<Foo> Items { get; } = new();` now links what it calls, creates and reads, including inside a lambda, and a target-typed `new()` there counts as creating the declared type. Before, initializers were skipped, so a method or class used only from one — like a converter created in a static list — looked unused, and a method passed as a value there was credited to the whole class instead of the field or property.
+- In C# and VB.NET, a constant no longer stands in for a type with the same name: `new Station { … }` links to class `Station` even when another class declares `private const string Station`, `new Version(…)` no longer links to a `const string Version`, and a field like `static readonly Meter Meter` no longer points at itself. Thanks @EvanYu1980 for the report and @drakeo338. (#2337)
+- In VB.NET, a call on a variable, parameter, field or property now reaches a method of the type it is declared with — one that type inherits, or an extension method written for it — and nothing when that type comes from outside your project, instead of any project method that merely shares the name.
+- In VB.NET, a call to one of .NET's own methods such as `Add`, `Contains`, `Clear` or `Dispose` on a value whose type isn't known is no longer linked to a project method of that name, unless the value is named after that method's class.
+- In VB.NET, a type name is looked up the way VB.NET does it — through the namespaces around it, the file's and project's `Imports` (aliases included), and the caller's own project — so a class declared in several namespaces or projects no longer draws every call to whichever copy was indexed first, and two candidates nothing tells apart get no link at all.
+- In VB.NET, a call with no receiver, or on `Me`, now reaches only a member of the class it is written in, of a class it inherits, or of a Module, and no longer a nearby class's member of the same name.
+- VB.NET designer code such as `New System.Drawing.Point(…)` or `Me.Size = New System.Drawing.Size(…)` is no longer linked to a project type or member that only shares the name, and a class nested inside another is matched by its bare name only from inside that class or one that inherits it.
+- Upgrading CodeGraph while an agent session is open no longer leaves the old version's background server in charge of your project: the first session started from the new install stops it and starts a current one in its place, even while sessions opened before the upgrade are still running. That old server could no longer load the language parsers the upgrade removed, so it saved every file it re-indexed with no symbols, while new sessions could only read the index beside it without keeping it up to date. A background server from a newer install is never stopped, and sessions opened before the upgrade keep the old version until you restart them. Thanks @lipchey for the report. (#2335)
+- A file is no longer saved with no symbols when its language parser can't be loaded, which is what happened to every file a background server re-indexed after an upgrade removed its install: the file keeps what it had and is indexed again once the parser loads, and files an earlier version emptied this way are re-indexed by the next sync. A background server also exits on its own once its install is upgraded or removed, so the next session starts one from the current install. Thanks @lipchey for the report. (#2335)
+- `codegraph status` no longer says the index is up to date while indexed files are missing their symbols: it now names files the parser couldn't read and files stored without their symbols (which `codegraph sync` repairs), `status --json` counts both, and `codegraph files --json` lists each file's recorded errors. Thanks @lipchey for the report. (#2336)
+- Indexing large Python projects is much faster again and needs less memory: since 1.6.2, resolving Python references re-read source files over and over, so a project the size of CPython took several times as long to index. The graph it builds is unchanged. Thanks @bompus for the report. (#2332)
+- In VB.NET, reading or setting a `Shared` field or property through its class or module name, like `AppSession.SessionId`, `AppSession.CurrentUser = "demo"` or `AppSession.Items(0)`, now counts as a use of that member and of the class, and so do reading an `Enum` value like `Mode.Fast` and calling a `Shared` function without parentheses. Before, only calls written with parentheses were linked, so `codegraph callers` on such a field, property or class came back empty and impact missed most of the code that depends on it. A local, parameter or field that only shares a class's name is not mistaken for the class. Thanks @serkanince for the report and @ChrisPrapas. (#2305)
+- In Vue and Nuxt components, calls written in the template (`{{ formatDate(post) }}`, `:to="getAccountRoute(account)"`, `@click="save(item)"`) and calls in a destructuring declaration at the top of `<script setup>` or of a TypeScript or JavaScript file (`const { t } = useI18n()`) now link to the function they call, so `callers` and impact for a composable or helper used this way are no longer mostly empty. A `v-for` item or slot prop is never taken for a project function, a handler like `@click="open = false"` no longer links to an unrelated function of the same name, and a component's own function named like a Nuxt helper, such as `clearError`, is now the one its calls reach. Thanks @deniskern for the report, and @drakeo338 and @L0garithmic. (#2340)
+- 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)
+- In Dart, a type is now linked from more of the places it is written, not only from parameters and return types: the type an `extension … on` targets, a field's type, a top-level variable's type, generic arguments such as `Future<Report?>.value(null)` or Riverpod's `final reportProvider = Family<Report?, String>()`, and a local variable's type, a cast or a type check inside a function. So `callers` and impact for a model class now reach the extensions, models and providers that use it. Thanks @mg-mg-mg for the report. (#2327)
+- In Go, calls through a method receiver or parameter of an unexported type, the usual shape of gRPC and HTTP handlers (`s.service.AddItem()` inside `func (s *server) Create()`), now resolve, and always within that type's own package: another package's `server` with a same-named method no longer takes the call, and a method the type gets from a struct or interface it embeds is found too. Re-index Go projects after upgrading. Thanks @GoDiao for the report and the fix. (#2323)
+- In Go, a call made through a type assertion, like `srv.(KVServer).Range(ctx, in)` in generated gRPC code, `c.Reader.(*pipe).Close()` or `v.(storage.Store).Fetch(key)`, now links to that method of the asserted type, including one the type gets from a struct or interface it embeds, and to nothing when the type comes from outside your project. Before, it linked to whichever method shared the name, so every gRPC handler pointed at the `Unimplemented…Server` stub instead of the server interface. Re-index Go projects after upgrading.
+- In Go, calls into a module whose `go.mod` is not at the project root now resolve, whether it is a `server/` backend next to a `web/` frontend or one of several modules side by side as in etcd, so calls like `store.New()` and `s.db.CreateItem()` find their targets instead of being treated as calls into a third-party package. A name written through a package, like a `job.OPCommand` result type or a field of type `artifact.Manager`, now links to that package's symbol rather than a same-named one elsewhere, which also corrects links in projects with a single `go.mod`. Re-index Go projects after upgrading. Thanks @GoDiao for the report and @danusha2345 for the fix. (#2322)
+- In Go, an exported type written without a package, like `Node` in `func Walk(v Visitor, node Node)`, now links to the type of that name in its own package, whether it is a struct, an interface or another kind of type. Before, it could link to a struct of the same name in an unrelated package, so prometheus's PromQL parser functions pointed at the Kubernetes discovery `Node` struct instead of the parser's own `Node` interface, or, for a result type like `Appender` in `func (f *fanout) Appender(…) Appender`, to the method itself. A type from a package outside your project, like `apiv1.Node` or `http.Handler`, no longer links to a struct of the same name in the file that uses it; a variadic parameter like `...storage.Filter` now links to that package's type; a route handler written as a method value, like `h.Follow` in an Echo or Gin app, links to that method rather than a model struct named `Follow`; and a method called on another call's result or on an indexed value, like `err[i].Error()` or a chained `.String()`, is no longer recorded as creating a struct of the same name. Re-index Go projects after upgrading.
+- In Go, a function or method passed as a value, like `sync.Pool{New: wm.new}`, now shows the function that passes it among its callers and impact even when it is named `new`, `nil`, `None`, `self` or a handful of similar words, or when a line break or comment sits beside the dot. Before, such a value was skipped, so a method used only that way looked unused. Re-index Go projects after upgrading.
+- In Go, a type in a parameter, a result or a composite literal now always links to a type, never to a method or function that shares its name. Before, an unexported type like `keyIndex` in etcd's `func (ti *treeIndex) KeyIndex(keyi *keyIndex) *keyIndex` linked to the `keyIndex` method declared beside it, prometheus's `samples{…}` literals to a `samples` method, and a type from a package outside your project, like `config.URL` in `&config.URL{…}`, to whatever project method had that name. A type written without a package, including an unexported one or one named like `AppenderV2` or `Histogram_CountInt`, now links to its own package's type when there is one, and a generic method's type parameter, like `T` in `func (p *Pool[T]) Get() T`, no longer links to an unrelated `T`. Re-index Go projects after upgrading.
+- In Go, a type declared on its own, like `type Point struct{…}` under a `// Point is …` comment, now keeps that comment as its documentation, as a type inside a `type ( … )` group already did, so searching for what a type does can find it. A comment at the end of a line of code, like `const sides = 4 // sides of a square.`, is no longer taken as the documentation of the declaration under it. Re-index Go projects after upgrading.
+- Indexing a project that includes large bundled JavaScript files, such as a copy of pdf.js or d3, is fast again: since 1.6.2, resolving the calls in a JavaScript or TypeScript file re-read the file's text above each call, so a single bundled library could add many seconds to an index. The graph it builds is unchanged. Thanks @bompus for the report. (#2334)
+- Indexing a project that ships a large minified JavaScript file, such as the GraphiQL bundle inside go-ethereum, no longer stalls at "Resolving refs" when CodeGraph runs on Node 22, and linking such a file is faster on any Node version. The graph it builds is unchanged.
+- The time `codegraph init` and `codegraph index` print beside the node and edge counts now covers the whole run, resolving references and linking included, and `codegraph sync` reports its whole run the same way. Before, it counted only reading and parsing the files, which can be a small part of an index, so a slow index looked fast. Thanks @bompus for the report. (#2334)
+- 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)
+- 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 JavaScript and TypeScript, the functions written inside a named object literal are now symbols of their own even when the object isn't exported: a plain `const api = { load() {…} }`, an object declared inside an IIFE or a function, and a namespace hung on the page or on another object, like `window.App = { init() {…} }`, `App.utils = {…}` or `dw_page = {…}`. Calls such as `api.load()`, `window.App.init()`, `App.utils.pad()`, a sibling's `this.render()`, and `App.init()` from another script on the page now reach them, the calls made inside a member belong to that member instead of the object, and a bare `init()` is no longer taken for `App.init`, so script-tag apps no longer lose most of their code from `callers` and impact. A member's qualified name now carries its object, exported or not (`api::load`, `window.App::init`), so asking for `App.init` finds it. Re-index JavaScript and TypeScript projects after upgrading. Thanks @tkhoaaa for the report and @danusha2345. (#2300)
+- In JavaScript and TypeScript files with Windows (CRLF) line endings, as a Windows checkout usually has them, a store exported on a later line, like `const useStore = create(…)` followed by `export default useStore;`, now has its actions indexed, as it already did with Unix line endings. Before, those actions were missing from the graph on Windows, so their callers and impact came back empty. Re-index JavaScript and TypeScript projects after upgrading.
+- In VB.NET, a name that begins with a keyword, like `SharedCache`, `Dimension`, `PublicKey` or `FriendlyName`, is now indexed whole, and a method like `Sub NewItem()` is no longer taken for a constructor. Before, the keyword was cut off (`Cache`, `ension`, `Key`) or the declaration was lost, and a line in a method that starts with such a name, like `Constants.Reload()` or `ConstVBV.Value = False`, was misread as a declaration, so reads of and calls to these names didn't link. A `Private Protected` member now counts as private instead of public. Re-index VB.NET projects after upgrading.
+- In JavaScript and TypeScript, a store whose name contains a `$`, like `const items$ = create(…)` exported on a later line with `export default items$;`, now has its actions indexed. Before, they could be missing from the graph, for example in a file that also had a syntax error. Re-index JavaScript and TypeScript projects after upgrading.
+- In Dart, what a top-level variable's or a field's initializer calls, creates and reads is now linked. In Riverpod apps, where most wiring lives in provider closures like `final repoProvider = Provider((ref) => Repository(ref.watch(dioProvider)));`, `callers`, impact and `codegraph_explore` now follow a provider to the code it builds instead of stopping at the provider. A `final` or `const` initializer belongs to its constant, and a `var`'s or a field's to its file or class. A call through a type's static constant, like `FutureProvider.autoDispose(…)`, now links to that constant instead of an unrelated method that shares its name. Re-index Dart projects after upgrading.
+- In Dart, a call further down a chain, like Riverpod's `FutureProvider.autoDispose.family(…)` or `events.map(mapper).transform(…)` on a stream, now links to the method of the type the chain before it produces, worked out from what each step is declared to return, and to nothing when that type can't be worked out. Before, it linked to whichever project method shared its name, so `X.autoDispose.family(…)` reached the same provider builder whatever `X` was, and a stream's `transform` reached an unrelated `transform` method. `super.` calls now reach the superclass's method, `context.read<CounterBloc>().add(…)` reaches the bloc's own `add`, and the members of an extension marked `@internal` are found too. Re-index Dart projects after upgrading. (#750)
+- In VB.NET, reading or setting a field or property through a variable, parameter, field, `Me` or `MyBase`, like `x.Normal = 3`, `Me._h.Title`, `.Value` inside a `With` block or `.Switch` in `New BoolParam With {…}`, now counts as a use of that member, and so do calls inside a `With` block, functions called without parentheses and reads through a class whose name starts in lower case. Before, `codegraph callers` on an instance field or property missed most of its uses. Only a member that the value's declared type has or inherits is linked, nothing when that type comes from outside your project, and a value named after its class, like `theme As Theme`, counts as a use of the class only when it reads a `Shared` member. Re-index VB.NET projects after upgrading.
+- In JavaScript and TypeScript, an import whose name contains a `$`, like `import items$ from './store'`, `import * as api$ from './api'` or `import { load as load$ } from './data'`, now links the calls made through it, such as `items$.getState().inc()`, to the code it imports, and so does a `$` name in a `require(…)` destructuring or an `export { … } from` barrel. Before, such an import was skipped or bound under a cut-off name (`load` for `load$`), so those calls reached nothing and the functions they call could look unused. A local variable or parameter that reuses an imported `$` name, like `const items$ = …` inside a function, is no longer mistaken for the import. Re-index JavaScript and TypeScript projects after upgrading.
+- In Dart, calling a parameter or a local variable, like `create(ref, arg)` inside `overrideWith(… create)`, a closure's parameter, a loop variable or a test's mock `listener(0, 1)`, no longer links the call to an unrelated function or constant of the same name in another file, or to a method the class inherits: a Bloc event handler's `emit(…)` is the handler's own `emit` parameter, not `Bloc.emit`. So `codegraph callers` and impact no longer list code that never calls them, while calls the parameter or variable doesn't cover, and calls to a local function, link as before. Re-index Dart projects after upgrading.
+- In Dart, `const` constructors and redirecting factories, like flutter_bloc's `const BlocProvider.value(…)` or freezed's `const factory LoginState.loading() = _Loading;`, are now indexed, so a call such as `BlocProvider.value(…)` or `BlocProvider<CounterCubit>.value(…)` links to that constructor instead of another class's member with the same name. A call through a class name now reaches only that class's own constructors and static members, never a look-alike class, a parent class, an instance getter of the same name, or a project method that merely shares its name with an SDK call like `Uri.parse(…)`, and a constructor is no longer linked from a bare name, the end of a call chain or an annotation like `@internal`. Re-index Dart projects after upgrading.
+- In Dart, a call that passes a type argument and arguments, like `ref.read<Repo>(repoProvider)`, `ref.watch<int>(counterProvider)`, `Provider<User>((ref) => …)`, `BlocProvider.of<CounterCubit>(context)` or `RepositoryProvider<Repo>(create: …)`, now links to the method or class it calls, and the type it passes counts as used there. Depending on the code around it, the parser often read such a call as two comparisons, so it linked nothing, and Riverpod providers, repository reads and bloc lookups were missing from `callers`, impact and `codegraph_explore`. A real comparison like `a < b` is still left alone. Re-index Dart projects after upgrading.
+- In Dart, a constructor or member written without a body, like flutter_bloc's `const BlocProvider.value(…)`, `Foo._();`, `Point.origin() : x = 0, y = 0;` or an abstract or `external` method, now keeps the `///` documentation and the annotations written above it, the way one with a body already did. Before, that documentation was lost, so searching for words in it didn't find the symbol, and an annotation like `@visibleForTesting` or `@protected` on it wasn't recorded. Re-index Dart projects after upgrading.
+- In Dart, a function or method now keeps the `///` documentation written above its annotations, like the doc on a widget's `@override Widget build(…)` or on a member marked `@protected`, `@mustCallSuper`, `@pragma(…)` or `@internal`. Before, the annotation between the documentation and the declaration hid it, so searching for words in it didn't find the symbol. Re-index Dart projects after upgrading.
+- In Dart, a call on what a generic lookup returns, like flutter_bloc's `BlocProvider.of<CounterCubit>(context, listen: false).increment()` or Provider's `Provider.of<CartModel>(context, listen: false).add(item)`, now links to that method of the type in the angle brackets, whether the lookup is declared in your project or comes from a package. Before, such a call often linked nothing — for example whenever the lookup passed `listen: false` — so `callers` and impact missed those methods. A lookup that names no type, like `BlocProvider.of(context)`, still links nothing. Re-index Dart projects after upgrading. (#750)
+- In JavaScript and TypeScript, a store whose name starts or ends with a `$`, like `const items$ = create(…)`, now has its actions indexed when an `export { … }` list on a later line exports it, as in `export { items$ };` or `export { $items as default };`. Before, those actions were missing from the graph, so their callers and impact came back empty. A store whose name only lacks the `$`, like `items`, is no longer treated as exported by that list. Re-index JavaScript and TypeScript projects after upgrading.
+- In Dart, a comment inside a chain of calls no longer loses part of it: a call with a comment before its arguments, like `box.grow /* by */ (3)`, now links to the method it calls, and a getter read or a static access written after a comment, like `Config //` followed by `.instance` on the next line (the empty `//` keeps `dart format` from joining the lines), now counts as a use. Re-index Dart projects after upgrading.
+- In Dart, a call, a constructor call or a type written without a receiver now links only to a declaration the file can see: one in its own library (the file and its `part` files) or one exported by a library it imports, with `export` chains, `show`, `hide` and `as` prefixes followed the way Dart follows them. So a generated `.g.dart` file reaches its own library's function or type instead of a same-named one in a neighbouring file, a call to a package function such as `fakeAsync`, `runApp` or `unawaited` no longer links to an unrelated project function of that name, and a bare call is never taken for another type's enum value or static constant. Re-index Dart projects after upgrading.
+- In Dart, an `import` or `export` now links to the file it names: `package:my_app/src/cart.dart` to that package's `lib/src/cart.dart`, and a relative path to the file it points to from the importing file. Before, only the file name at the end was matched, so `import 'package:flutter/widgets.dart'` linked to whichever project file was called `widgets.dart`, and most imports of your own files didn't link to the file at all, which threw off `codegraph affected` and the files listed as using a file. An import of a Dart SDK library or of a package from outside your project now links nothing, and when packages in one repository share a name, the one the importing app depends on by `path:` is used. Re-index Dart projects after upgrading.
+- In Dart, a `part` directive, like `part 'user.g.dart';` or `part 'src/widgets.dart';`, now links a library to the part's file the way an import does. A library and its parts are one library, so a change to a part, whether a generated `.g.dart` or `.freezed.dart` file or one you wrote, now reaches the library and the code that imports it in `codegraph affected` and in the files listed as using the part. Before, the two files were connected only when a call or a type happened to cross between them, which a library made only of `part` lines never has. A part your project doesn't have, like a generated file that isn't committed, links nothing. Re-index Dart projects after upgrading.
+- In Dart, an annotation now links to the constant or constructor it names, read the way it is written: `@riverpod` reaches Riverpod's `const riverpod = Riverpod();`, `@Riverpod(keepAlive: true)` the `Riverpod` class, an annotation written through a class, like `@SomeClass.value` or `@SomeClass.named(…)`, that class's own constant, enum value or constructor, and `@meta.immutable` only what the `meta` import brings in. Before, an annotation was matched like a function decorator, so a method, getter or function that only shared its name won: every `@riverpod` provider in Riverpod's own repository was linked to an unrelated getter called `riverpod`, and `callers` and impact for the real annotation missed them. Re-index Dart projects after upgrading.
+- In Dart, an annotation is no longer lost when a comment sits between it and the declaration, like `@override` followed by `// ignore: must_call_super`, a `///` comment written below the annotations, or `@riverpod` followed by an `// expect_lint: …` line. Before, the comment hid the annotation, so a provider written that way was missing from the annotation's `callers` and impact. Re-index Dart projects after upgrading.
+- In Dart, a call written through an import prefix, like `http.get(…)` after `import 'package:http/http.dart' as http;`, or `utils.Listener()` and `kit.Box.create()` through a prefix of your own, now links to what the library imported with that prefix exports, following its `export` chains, `show` and `hide`, and to nothing when that library is a package outside your project. Before, the prefix was taken for a variable, so `http.get(…)` could link to an unrelated `Http` class's `get` method, and calls made through a prefix into your own libraries were missing from `callers` and impact. Re-index Dart projects after upgrading.
+- `codegraph sync` and the file watcher now link an import to the file it names when that file is added after the importing file was indexed, or comes back after being deleted: `import 'package:app/b.dart';` in Dart, `import './side'` in JavaScript or TypeScript, `#include "net/socket.h"` in C and C++, `require 'inc/db.php'` in PHP, `import pkg.mod` in Python, a Lua `require`, or a C# `using` of a namespace declared later. Before, the import stayed unlinked until the importing file itself changed or the project was re-indexed, so `codegraph affected` and the files listed as using the new file missed it. Re-index after upgrading.
+- `codegraph sync` and the file watcher now link a navigation call to its page when the page or route is added after the call was indexed, or comes back after being removed: `history.push('/login')` and `navigate('/login')` with React Router, `router.push('/login')` and `redirect('/login')` in Next.js, Expo Router, Vue Router, TanStack Router and SvelteKit (`goto('/login')`), and `this.router.navigate(['/login'])` and `routerLink="/login"` in Angular. Before, the call stayed unlinked, or linked to a catch-all or `:id` page that answered it in the meantime, until its own file changed or the project was re-indexed, so the step from that call to the page it opens was missing or wrong. A route whose path changes without its own file changing, like one built from a path constant kept in another file, now also lets go of the calls that named its old path. Re-index after upgrading.
+- JSON files in a `templates` or `sections` folder are now read as Shopify Liquid only inside a Shopify theme, where the folder that contains `templates` or `sections` also has `layout/theme.liquid` or `config/settings_schema.json`. Before, all such JSON was, so a .NET project template's `template.json`, a schematic or a CMS's content showed up in the index as an empty Liquid file, and one that lists `sections` could be linked to an unrelated Liquid file of the same name. Shopify themes, including one kept in a subfolder of a repository, are indexed as before, and the next sync removes JSON that an earlier version indexed this way.
+- In a repository that holds more than one Shopify theme, a theme's `{% render %}`, `{% include %}` and `{% section %}` tags and the sections its JSON templates list now link only to that theme's own snippets and sections, which is where Shopify looks for them. Before, a section or snippet the theme doesn't have was linked to another theme's file of the same name, and a theme kept in a subfolder could link to the root theme's copy instead of its own. A reference the theme can't satisfy now links to nothing. Projects with a single theme are indexed as before. Re-index projects with several Shopify themes after upgrading.
+- `codegraph sync` and the file watcher now link a Shopify section or snippet to the files that name it when it is added after them, or comes back after being deleted, whether they name it in a `{% render %}`, `{% include %}` or `{% section %}` tag or as a section `type` in a JSON template. Before, the link appeared only once a file naming it changed or the project was re-indexed, even in a repository with a single theme, so the new section or snippet looked unused and `codegraph affected` missed the files that use it. Re-index Shopify themes after upgrading to pick up links an earlier version missed.
+- `codegraph sync` and the file watcher now link a route to the page or layout it loads lazily when that file is added after the router was indexed, comes back after being deleted, or gets the component the route renders in a later edit, whether or not the import names the file's extension: React Router's `lazy: () => import('./pages/Team')`, Vue Router's `component: () => import('@/views/Login')` and Angular's `loadComponent: () => import('./home/home.component')`. Before, the route stayed unlinked until the router file changed or the project was re-indexed, so the page looked unused and `codegraph affected` missed the tests that reach it through the router. Re-index after upgrading to pick up links an earlier version missed.
+- A file named the way Google names its tests, like `wire_format_unittest.cc` in protocolbuffers/protobuf, `logging_unittest.cc` in google/glog or a Python `foo_unittest.py`, now counts as a test, as `wire_format_test.cc` already did. Before, it was taken for production code: search and `codegraph_explore` ranked it alongside the code it tests, `codegraph affected` never listed it, and calls in production code could link to a class or type a unittest declares for itself, as google/breakpad's `stack_frame_entries_.size()` did to a unittest's `StackHelper`. Re-index projects that have such files after upgrading.
+- `codegraph sync` and the file watcher now link a file to a module it imports under a name of its own when the module is added after the file was indexed, comes back after being deleted, or gets the export in a later edit: a default import like `import tagsController from './tag/tag.controller'`, a namespace import like `import * as api from './api'`, or an aliased one like `import { Component as GroupsPageWrapper } from './groups_page'`, in JavaScript, TypeScript, Vue, Svelte and Astro. Before, the import and every use of the name, such as a call, `new`, a base class, a JSX or template tag or an Express `app.use` mount, stayed unlinked until the importing file changed or the project was re-indexed, so the module looked unused and `codegraph affected` missed the files that use it. Re-index after upgrading to pick up links an earlier version missed.
+- In C, C++ and Objective-C, a struct or class member declared as a pointer, reference, array or function, like `SharedState* shared;`, `jv elements[];` or `virtual Status Put(…) = 0;`, no longer makes the struct look like it inherits from the member's type. Before, `codegraph_explore` and impact listed those types as base classes, every struct holding a pointer to a type as one of its subclasses, and a method of that struct as an override of the type's method with the same name. Real base classes like `class Derived : public Base`, Objective-C superclasses and Go's embedded fields are unchanged. Re-index C, C++ and Objective-C projects after upgrading.
+- In C++, a call on a variable, parameter or member declared through a `typedef` or `using` alias now links to the method of the type the alias names, with the alias looked up the way C++ does it: in the calling function, its class and the classes that class inherits from, then the namespaces around it. In google/leveldb, `table_.Insert(buf)` on a `Table table_;` declared next to `typedef SkipList<const char*, KeyComparator> Table;` now reaches `SkipList::Insert` instead of the unrelated `HandleTable::Insert`, and `Table::Iterator iter(&table_);` reaches `SkipList::Iterator`'s constructor. A class that only shares the alias's name is no longer taken for it, and when the aliased type has no such method, as with an alias of `std::vector` or of a template parameter, no method is guessed from the receiver's name. Re-index C++ projects after upgrading.
+- In C++, a call on a variable, parameter or member declared with template arguments nested inside its template arguments, like `autovector<std::pair<int, FileMetaData*>>` or `Striped<CacheAlignedWrapper<port::Mutex>>`, now links to the method of the class it is declared as. Before, the nested arguments hid that class: in RocksDB, `files_marked_for_compaction_.clear()` on such an `autovector` linked to an unrelated `CompactionInputFiles::clear` that only shares words with the variable's name, and `mutex_.Get(key)` on a `Striped` linked to nothing. Re-index C++ projects after upgrading.
+- 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 C++, a header or source file named like a test, such as protocolbuffers/protobuf's `conformance_test.h` and `test_runner.h`, now counts as part of the code that `#include`s it, directly or through other headers. Before, calls from that code into it were dropped, so protobuf's conformance suites' `suite_.ReportFailure(…)` and `RunValidInputTest(…)` calls, and its unit tests' calls to the shared `TestUtil` helpers, linked to nothing. A test file that only tests include is still kept out of reach of the rest of your code. Re-index C and C++ projects after upgrading.
+- In C++, a class, struct or method now keeps the namespaces and the class it is declared in when the parser misreads something earlier in the file, such as an unknown macro in front of a member or in a class header. Before, everything after the misread code could lose them, or land inside a class it isn't in: in protocolbuffers/protobuf, `FieldDescriptor` was indexed without `google::protobuf::`, and in RocksDB, the `Opts` struct declared inside a cache table class was indexed outside it, so finding a class's base classes and the methods called on its objects fell back to guessing by name. Methods that had come loose from their class are its members again, and classes the misread code had hidden, like leveldb's POSIX file and environment classes, are now indexed. Re-index C++ projects after upgrading.
+- In C++, a call on a variable, parameter or member declared as a standard-library or other outside type with a lowercase name, like `std::string`, `std::vector`, `std::set` or `absl::flat_hash_set`, no longer links to a project method that only shares the method's name. In google/leveldb, `saved_key_.clear()` on a `std::string saved_key_;` reached `Slice::clear`, and in protocolbuffers/protobuf, `proto.append(…)` on a `std::string` reached an unrelated `LeftoverBuffer::append`. The same goes for `->` through a raw pointer like `std::string* out`, while `->` through a smart pointer, iterator or optional still links to the type it holds. Comments also no longer pass for a variable's declaration, so more calls now link to the method of the type the variable is really declared with. Re-index C++ projects after upgrading.
+- In C++, a class written with attribute macros the parser can't read now keeps its members. That covers several macros between `class` and the class name, like protocolbuffers/protobuf's generated `class PROTOBUF_EXPORT PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Any final`, a macro with arguments there, like RocksDB's `struct ALIGN_AS(64U) HandleImpl`, or one before a template specialization, and macros on a member: in front of it (`PROTOBUF_FUTURE_ADD_EARLY_NODISCARD`), between a pointer and its name (`PROTOBUF_NONNULL`), after its parameters or its name (`ABSL_ATTRIBUTE_LIFETIME_BOUND`, google/leveldb's `LOCKS_EXCLUDED(mu_)` and `GUARDED_BY(mu_)`), or alone on a line above a comment ({fmt}'s `FMT_BEGIN_EXPORT`). Before, protobuf's generated message classes were missing and their members, like `GetDescriptor`, `GetReflection` and `unknown_fields`, were indexed as functions outside any class, and leveldb's annotated methods were indexed under the annotation's name, so calls to them linked to nothing. Re-index C++ projects after upgrading.
+- Framework support now switches on when an app's `package.json` sits three or more folders deep, as with an ASP.NET solution's Angular or React app in `src/Web/ClientApp/`, or a React app in a workspace folder like `web/ui/mantine-ui/`. Before, only the project root and the first two folder levels were read, so frameworks such as Angular, React Router, Vue Router, SvelteKit and TanStack Router could go undetected there: an Angular app's routes, its `routerLink` and `router.navigate(…)` navigation and its template's event bindings were missing, so a handler used only from a `(click)` binding had no callers, and a React app's `navigate('/login')` calls didn't reach their route. Re-index projects laid out this way after upgrading.
+- In a repository that mixes languages, a web framework's naming conventions now link only code written in that framework's own languages. Before, Express's also linked Go and Python code: in etcd a Go method's `*zap.Logger` result type linked to the method itself, and in Harbor a Python `self.jaeger.validate()` call linked to another class's `validate`. Links that cross languages on purpose, like React Native and Expo native modules, Swift and Objective-C, Drupal's `routing.yml`, SvelteKit's `$lib/…` imports in `.ts` files and a Razor page's `@model`, are unchanged.
+- In C and C++, a call written from the global scope, like `::leveldb::RepairDB(…)` or `::hpb::CreateMessage(…)`, now links to the function of exactly that name, and one through a namespace alias, like protobuf's `::_pbi::…` calls, to the function in the aliased namespace. Before, these calls were dropped unless the repository also held Swift and Objective-C files, and even then a name spelled out in full, like `::google::protobuf::internal::TSanWrite(…)`, linked to nothing, while `::operator delete(…)` linked to one class's own `operator delete`. A global call never links to a function or method of the same name inside a namespace or class, such as a wrapper `open()` that calls the C library's `::open(…)`, and `::std::…` and `::testing::…` calls stay unlinked unless that library's source is part of your project. Re-index C and C++ projects after upgrading.
+- In Go, an interface that embeds another, like gin's `IRouter` embedding `IRoutes`, now links to it, so `codegraph_explore` and impact show the embedded interface as its base. Before, every embedded interface was dropped. An embedded field written through another package of your project, like `*refresh.Discovery` or `storage.Appender`, or with type arguments, like `List[int]`, now links too. One from the standard library or another module, like `io.Closer` or `sync.Mutex`, links to nothing rather than to a project type that shares its name, and a type-set constraint like `~int | ~float64` is not an embedding. An embedded type written without a package now always links to its own package's type: before, etcd's `Client`, which embeds its own `Lease` interface, was linked to a `Lease` struct in another package. Re-index Go projects after upgrading.
+- In Go, working out which structs implement an interface now counts the methods of the interfaces it embeds, and the methods a struct gets from the types it embeds. Before, only each type's own methods counted: etcd's `AuthReadTx`, which embeds `UnsafeAuthReader` and adds `RLock` and `RUnlock`, was listed as implemented by every read-write lock in the project, an interface that only embeds others had no implementations at all, and a struct that gets its methods from an embedded base, like prometheus's service discoveries embedding `refresh.Discovery` or gin's `Engine` embedding `RouterGroup`, was missing. `codegraph_explore`, impact and the type hierarchy now list the right implementations, and a call through the interface reaches a method the embedding struct overrides, like gin's `Engine.Use`. Re-index Go projects after upgrading.
+- In Go, a call through an interface now reaches a method that the implementing struct gets from a type it embeds: prometheus's `targetScraper` gets `Report` from the `*Target` it embeds, so a call through the `scraper` interface now reaches `Target.Report`, and etcd's `Hasher.MemberID` reaches `EtcdServer.MemberID` through `hasherAdapter`. Before, the call reached only structs that declare the method themselves, often just a test double, so `codegraph_explore`'s call path stopped at the interface. The method is picked the way Go picks it, from the nearest embedded type, and none is linked when two embedded types at the same depth both have it or it comes from an embedded interface. Re-index Go projects after upgrading.
+- In Go, a type defined over a slice, map, function or basic type now counts as implementing the interfaces its methods satisfy, just as a struct does: prometheus's `type staticDiscoverer []*targetgroup.Group` is a `Discoverer`, gin's `type formSource map[string][]string` a `setter`, etcd's `type Int64Comparable int64` a `Comparable`, and an adapter like `type HandlerFunc func(…)` a `Handler`. Before, only structs were considered, so these types were missing from an interface's implementations in `codegraph_explore`, impact and the type hierarchy, and a call through the interface, like `Discoverer.Run` or `setter.TrySet`, stopped there instead of reaching their methods. Re-index Go projects after upgrading.
+- In Go, a type alias like `type Event = mvccpb.Event`, alone or inside a `type ( … )` group, is now indexed and links to the type it names, so impact on that type reaches the code that uses the alias. Before, aliases were missing: a use written through the alias's package, like `clientv3.Event` or prometheus's `storage.AOptions{…}`, linked to nothing, and one inside the package, like `&PrometheusVersion{}` in prometheus's `web` package, linked to whichever type of that name the project had, there a test helper's struct. A method called on a value of an alias's type now reaches the aliased type's method rather than a namesake's, and a generic alias like `type Items[T any] = List[T]` links to `List`, so `xs.Len()` on one reaches `List.Len` instead of nothing. Re-index Go projects after upgrading.
+- In Go, a struct that embeds another is no longer treated as overriding the methods it redeclares. gin's `Engine` embeds `RouterGroup` and has a `Use` of its own, but calling `Use` on a `RouterGroup` only ever runs `RouterGroup.Use`; before, `codegraph_explore`'s call path and impact went on from it into `Engine.Use` and the code only the engine runs. The same held for every struct or defined type embedded in another that redeclares one of its methods, like etcd's `Mutex` inside `lockerMutex`. A call through an interface still reaches each type that implements it, the embedding struct included. Re-index Go projects after upgrading.
+- In Go, a type defined from other types, like etcd's `type WatchChan <-chan WatchResponse` or gin's `type HandlerFunc func(*Context)` and `type HandlersChain []HandlerFunc`, now links to the types it is built from, so impact on `WatchResponse` or gin's `Context` reaches these types and the code that uses them. Before, such a type linked to nothing. One written through another package, like etcd's `type PutResponse pb.PutResponse`, links to that package's type, and a recursive one like `type stateFn func(*Lexer) stateFn` doesn't link to itself. Re-index Go projects after upgrading.
+- In Go, a struct or defined type now counts as implementing an interface only when its methods take as many parameters and return as many results as the interface's. Before, matching method names was enough, so etcd's watch cache, whose `Get` takes a context, a key and options, was listed as a `peerGetter`, whose `Get` takes a peer ID, and a call through an interface could be shown reaching methods it can never reach. Look-alikes could also crowd out the real implementations, so `codegraph_explore` stopped at grpc-go's xDS `TransportBuilder` instead of reaching the transport it builds. A server still counts for the gRPC client interface of the service it serves, like etcd's `kvServer` for `KVClient`, so a client's call keeps leading to the handler that serves it. Re-index Go projects after upgrading.
+- In Angular templates, a property binding, an interpolation, a structural directive or a control-flow block that calls one of the component's own members, like `[name]="icon()"`, `{{ label() }}`, `*ngIf="isOpen()"` or `@if (loading()) {`, now links the component to that member, and so does reading a getter, like `[disabled]="!canSave"`, or handing a method to a child component, like `[displayWith]="displayFn"` or `trackBy: trackById`. Before, only event bindings such as `(click)="save()"` were read, so a signal, a `computed` value, a getter or a method used only from a template had no callers and looked unused. A pipe, a template variable, a call on another object such as `form.reset()`, and a plain field read like `[value]="title"` still link nothing. Re-index Angular projects after upgrading.
+- React Router routes kept in a table of their own are now indexed: the ASP.NET Core React template's `AppRoutes` array that `App.js` maps into `<Route {...rest}>`, a `routes` array imported into `useRoutes(routes)` or `createBrowserRouter(routes)` or returned by a function as in `useRoutes(routes(isLoggedIn))`, route objects kept one per file and listed in `createBrowserRouter([MainRoutes, LoginRoutes])`, and routes written in place in `useRoutes([…])`. Before, route objects were read only from a file that itself creates a data router, so these apps had no routes, and their `navigate('/login')` calls and `<Link to="/counter">` links led nowhere. Each route links to the page its `element` renders, past a guard like `<ProtectedRoute>` or `<AdminWrapper>`, and through `lazy(() => import(…))` to the page it loads rather than a same-named page elsewhere in the repository. An `index: true` route is the page at its parent's address, and a parent route around others counts as their layout. A `{ path, element }` list that nothing hands to the router, such as a menu, still makes no routes. Re-index React projects after upgrading.
+- In Go, a call or type written through an import whose path ends in a version, or in something other than the package's name, is now known to go through that import: `yaml.Unmarshal(…)` after `import "go.yaml.in/yaml/v3"` or `"gopkg.in/yaml.v3"`, `sqlite3.Error` after `import "github.com/mattn/go-sqlite3"`, `klog.V(2)` after `import "k8s.io/klog/v2"`. Before, only the last part of the path named such an import (`v3`, `yaml.v3`, `go-sqlite3`), so the name was matched on its own and could link to any project function, method or type that shared it: kubernetes' `klog.V(…)` calls were linked to a logging wrapper's `V` method, and etcd's `semver.Version` parameters to an unrelated `Version` function. A name from another module now links to nothing, and one through a package of your own project, like `kit.New()` after `import "example.com/kit/v2"`, links to that package's symbol. A comment in an import block is also no longer taken for the name of the import after it. Re-index Go projects after upgrading. Thanks @danusha2345 for the comment fix. (#2374)
+- In Go, a call is now matched to the package or variable it is actually made on. Before, a call through a package, like `klog.Infof("Log using Infof")` or `digest.Digest(dig)` inside `&distribution.Descriptor{Digest: …}`, could link to a project method of the same name when the name appeared again on the line, and in `klog.Error(err.Error())` the `err.Error()` call was taken for a call into `klog`. A parameter, receiver or local variable named like an import, like etcd's `jwt, err := newTokenProviderJWT(…)` or the `suite` receiver in a testify test suite, now counts as that variable, so calls on it link to the methods of the type it is declared as, and to nothing when that type comes from outside your project. Re-index Go projects after upgrading.
+- React Router routes written as JSX now read `<Route index>` the way route objects do: inside `<Route path="/" element={<Layout />}>`, `<Route index element={<Home />} />` is the page at `/`, and `Layout` counts as the layout of every route nested in it, as does a guard with no path of its own like `<Route element={<RequireAuth />}>`. Before, the index route was never read, so `/` led to the layout itself and a `<Route path="/dashboard">` holding only an index route led to nothing. A route's `element` written on lines of its own, the way Prettier formats a long one, or wrapped in `<Suspense fallback={<Loader />}>`, now links to the page it shows rather than to nothing or to the fallback, and a path written in braces, like `path={"agents"}`, is read like any other. Re-index React projects after upgrading.
+- In JavaScript and TypeScript, a module loaded with `require('./x').default` or `const { default: X } = require('./x')` now links to its default export when it is written as an ES module: bitwarden's desktop app loads `export default class OsBiometricsServiceMac` this way before calling `new OsBiometricsServiceMac(…)`, and React Native's own libraries load many of their modules like this. Before, `.default` was looked up only as an export named `default`, which `export default` is not, so the `new` and the calls made through it linked to nothing, to the local variable holding the module, or to a method of the same name somewhere else. A Svelte component loaded this way and created with `new App({ target })` now links to the component. A CommonJS module that sets `exports.default` itself, or both `module.exports` and `module.exports.default` as fastify does, still links to what it sets, and one that sets no `default` still links to nothing. Re-index JavaScript and TypeScript projects after upgrading.
+- A React Router route that lazily loads a folder, like `lazy: () => import('@/pages/invocation_page')`, now links to the page the folder's `index.ts` passes on, whether it writes `export * from './invocation_page'`, `export { default } from './page'` or `export { Page as Component } from './page'`, even through another `index.ts`. A route module that names its page with `export { Page as Component }` links to it as well, and so does a page loaded with `lazy(() => import(…))` through such an `index.ts`. Before, these routes linked to nothing, so their pages had no route leading to them. Re-index React projects after upgrading.
+- In JavaScript and TypeScript, an import written `import { default as AppRoot } from './routes/app/root'`, as in bulletproof-react's router, now counts as the module's default import, the same as `import AppRoot from './routes/app/root'`. Before, it was read as an import of an export named `default`, which no module has, so a call, a route or a JSX attribute that used `AppRoot` was matched by its name alone: it could link to another file's `AppRoot`, or to nothing when the default export has a name of its own. Svelte, Vue and Astro script blocks are read the same way.
+- In React, a component's JSX no longer links it to a class or component that only shares a name with one of its type arguments or with a variable of its own. A type in angle brackets, like `Document` in `<PaginatedList<Document> items={…} />`, `User` in `useState<User>()` or `Entry` in a generic `<Entry extends BaseEntity>(…) =>` component, is no longer read as a tag. A tag naming a variable or parameter the component sets itself, like `<Content>` after `const Content = isDropdown ? DropdownMenu.SubContent : ContextMenu.SubContent` or `<Widget>` in `widgets.map((Widget) => <Widget />)`, now links to nothing, unless the component declares a component of that name inside itself. Before, these linked to an unrelated class or component elsewhere in the repository: outline's document lists showed up among the callers of its `Document` model class, and its menus among the callers of the command bar's `Content`, so `codegraph_explore`, callers and impact followed renders that never happen. Re-index React projects after upgrading.
+- In JavaScript and TypeScript, a name imported from a package your `package.json` lists no longer links to a project symbol that only shares its name when `tsconfig.json` or `jsconfig.json` has a catch-all path alias, like `"*": ["./typings/*"]` or `"*": ["src/*", "node_modules/*"]`, or an alias that points the package at a file in `node_modules`, like `"lit/decorators": ["./node_modules/lit/decorators.js"]`. Such an alias made every package look like part of the project, so `import { Typography } from '@mui/material'` was linked to the project's own `Typography` and every lit `@property()` decorator to an unrelated class's `property` field, and `codegraph callers`, impact and `codegraph affected` listed code that never used them. An import the alias does map to a file of your project, like a `.d.ts` you keep for an untyped package or `components/Button` through `"*": ["src/*"]`, links as before. Re-index affected projects after upgrading.
+- `codegraph_explore`'s Flow now goes through the implementation your query names when an interface method has several that lead to the same place. Before, it took whichever one came first in the index: asking about prometheus's `Engine.execEvalStmt Queryable.Querier fanout.Querier NewMergeQuerier` traced the call through the TSDB's `DB.Querier` and left the `fanout.Querier` you named off the Flow. Any two routes of the same length are now settled this way, in favor of the one that passes through more of the symbols you named.
+- In C and C++, a struct, class, union or enum defined in a variable declaration, like `struct Foo { … } foo;`, is now indexed with its methods and enum values, next to the variable. Before, at most the variable was, so the type was missing from search and `codegraph_explore`, a class deriving from it had no base, and calls to its methods linked to nothing: in redis, the Sentinel's `sentinelState` and `redis-cli`'s `config` struct were missing. A struct, union or enum with no name of its own now takes the name of the variable it declares, so redis's `static struct { … } SPT;` is found as `SPT`, and one declared inside a function is named after its variable instead of `<anonymous>`. The comment above the declaration becomes the type's description. Re-index C and C++ projects after upgrading.
+- In TypeScript React code, a styled-components or emotion component declared with a type argument, like `const Wrapper = styled.div<WrapperProps>` followed by its CSS, or `styled(Base)<Props>`, is now indexed as a component, as one written without a type argument already was. Before, it was indexed as a plain constant, so `codegraph callers` and impact found none of the code that renders it, and its tags could link to another file's component of the same name instead: in outline/outline, `NudeButton` and `HStack` had no callers, and `<Text>` tags linked to a different `Text` than the one each file imports. Re-index TypeScript React projects after upgrading.
+
+## [1.6.2] - 2026-10-03
+
+### Highlights
+
+- **Far fewer wrong links, in every language.** A call, import or type now resolves the way its language scopes names — through imports, packages, namespaces and the class it is written in — so it stops landing on an unrelated symbol that only shares its name. This covers TypeScript and JavaScript, Python, Java, Kotlin, Scala, C#, VB.NET, Swift, Objective-C, Go, Rust, C and C++, PHP, Ruby, Dart, Lua, R and more, and makes callers, impact and `codegraph_explore` answers more trustworthy.
+- **Overloads, `super` and recursion resolve correctly.** A call reaches the overload its arguments fit, a `super` call reaches the parent's method, and a method that calls another overload, or another object's method of the same name, no longer looks like it calls itself.
+- **Routes for more frameworks.** Angular (including Nx libraries), Vue Router admin apps, Rails nested routes, Flask's `add_url_rule`, ASP.NET FastEndpoints, Play subprojects, Vapor closure routes and Expo Router API routes are found. NestJS and Laravel routes are named by the path a request actually takes, and a Spring or Laravel test that calls a route by URL counts as covering it.
+- **More of your code in the graph.** Vue Options API components, Java and Kotlin enum constants with bodies, Flow-typed JavaScript, Kotlin infix calls, React Native native views and events, Expo modules, tag-based CFML and Delphi `.inc` files are all indexed now.
+- **Windows: no flashing windows, no random crashes.** The background server no longer pops up console windows while it works, sporadic access-violation crashes (exit code 3221225477) while indexing or shutting down are fixed, and `codegraph upgrade` works while an agent session is using CodeGraph.
+- **A steadier background server.** Newer MCP clients such as Antigravity connect again, Claude Code sees the full text of `codegraph_status`, a session that lost the shared server reconnects by itself, and a project queried through `projectPath` is released after 10 idle minutes.
+- **Indexing that finishes.** Large C and C++ projects no longer run out of memory while resolving references, a COBOL file can no longer stall indexing, and `codegraph sync` keeps every caller of a name that is defined more than once.
+- **Upgrading:** re-index your projects after this release — most of these fixes are written while indexing.
+
+### New Features
+
+- In Nuxt and Astro projects, a file-routed page is now linked to the component its file defines. An Astro endpoint is linked to the HTTP-verb handlers it exports, like `export const GET`. Before, a page route like Nuxt's `pages/admin.vue` or Astro's `src/pages/about.astro` linked to nothing, so callers, impact and flows stopped at the route.
+- React Router links and `navigate(…)` calls written through a route-config object, like bulletproof-react's `paths.app.discussion.getHref(id)`, now reach the route they open. A `<Link>` with an arrow-function attribute before its `to`, such as `onMouseEnter={() => …}`, is read too.
+- React Router data-router routes are named by their full path: nested `children` paths are joined to their parent's, `path: paths.app.root.path` constants are read, and `lazy: () => import('./routes/x')` routes link to the module's component. A guard wrapper like `<ProtectedRoute>` no longer stands in for the page. On bulletproof-react, every route now has its real path and page.
+- Vapor routes whose handler is a trailing closure, like `app.get("hello") { req in … }`, WebSocket routes like `app.webSocket("chat") { req, ws in … }`, and `routes.on(.POST, "x", use: handler)` registrations are now found, and a closure route links to what the closure calls, the way an Express inline handler does. Before, only routes with a `use:` handler were read, and a closure route linked to nothing, so callers, impact and flows stopped at it.
+- Flow-typed JavaScript files (those with `@flow` in their header comment) are now parsed like TypeScript, so type annotations like `render(): React.Node` no longer cut classes short. This mostly affects React Native code: on React Native's own libraries the graph gained over 8,000 links, and component classes keep their methods. Files without the pragma are unchanged. Re-index after upgrading.
+- A link made by a framework or bridge resolver now records which one made it (`metadata.framework`, such as `swift-objc-bridge` or `react-native-bridge`), as the README describes. Before, only synthesized event and view channels were named.
+- ASP.NET apps built with FastEndpoints now have their routes: each endpoint class's `Get(…)` / `Post(…)` in `Configure()` becomes a route linked to its own `HandleAsync` / `ExecuteAsync`, including paths kept in a request class's `Route` constant. ardalis/CleanArchitecture went from no routes to 24. Minimal API routes written without a leading slash (`app.MapGet("api/todos", …)`) are now named `/api/todos`.
+- Play projects kept in subdirectories are recognized, so each one's `conf/routes` is read. A repository with no Play build at its root, like playframework's samples, went from no routes to over 130.
+- Rails routes are now read with their nesting: `namespace` and `scope` add their path and controller module, nested `resources` sit under their parent's `:id`, and `member` / `collection` blocks add their actions. A namespaced route now links to its own module's controller. Routes in a Rails engine's `config/routes.rb` are found too: solidus went from no routes to over 600, and mastodon's route-to-action links nearly tripled.
+- Flask routes registered with `add_url_rule(…)` are now found and linked to their view function or class-based view. So are routes registered through a project's own helper that passes a list of paths and a `view_func=`. flaskbb, which registers every view that way, went from no routes to over 100.
+- Vue components written with the Options API (`export default { methods: {…}, computed: {…}, watch: {…}, mounted() {…} }`), as every Vue 2 app is, now have their methods, computed properties, watchers and lifecycle hooks in the graph. Each one has its own callers and calls, and a template's `@click="handleLogin"` links to the method it runs. On vue-element-admin that's over 800 new links, where a component's calls used to belong to the whole file.
+- React Native events whose name is held in a constant now link native code to the JavaScript that listens for them, like NetInfo's `addListener(PrivateTypes.DEVICE_CONNECTIVITY_EVENT, …)` or a Java `.emit(PROGRESS_EVENT, …)`. The constant is read the way the language scopes it, from the same file, an import or its owning class, so a parameter that happens to share a constant's name is never mistaken for it.
+- React Native views declared with `requireNativeComponent('X')`, the older Paper style that react-native-maps and segmented-control use, now link from JavaScript to their native iOS and Android implementations, as Codegen specs already did, including in plain `.js` files. A JSX tag written under a different name than its component, like `<Autocomplete>` for `import Autocomplete from './autocomplete.vue'`, now links to the component it renders.
+- Expo Router API routes (`app/hello+api.ts`) are now endpoints, one per exported method, like `GET /hello`, bound to the function that handles them. They used to show up as a screen named `/hello+api`. In a repository whose root declares Expo Router for an example app, a Next.js app in its own folder, like react-native-true-sheet's `docs/`, no longer gets Expo screens made from its files.
+- Calls into an Expo module now reach the module's native functions even when the JavaScript names the module something else, like expo-camera's `CameraManager` for `requireNativeModule('ExpoCamera')`. Both the iOS and the Android implementations are linked. expo-camera's calls used to link back to the same-named method making the call, so a method looked like it called itself.
+- Angular apps split across Nx libraries, like angular-spotify, now have their routes and navigation. A lazily loaded route written `async () => (await import('@app/home')).HomeModule` is followed through the library's `index.ts` to the module it re-exports, and a `routerLink` in one library now reaches a screen declared in another. Route paths built from a class constant (`RouterUtil.Configuration.Lyrics`, `` `issue/:${ProjectConst.IssueId}` ``) or an enum are now read. A redirect in a routes file that only lazy-loads others now counts, and `router.navigate(['project', 'issue', id])` without `relativeTo` is read from the root, as Angular does. Re-index Angular projects after upgrading.
+- React Router apps now show navigation written as React Router v5's `<Redirect to="/login" />` and through a styled link, like react-boilerplate's `HeaderLink = styled(Link)` used as `<HeaderLink to="/features">`. Apps built this way had routes but no links between their screens.
+- SvelteKit routes are now named by the address a browser asks for. A `(group)` folder like `(app)` or `(marketing)` is no longer part of a route's path, and a parameter with a matcher, like `[id=integer]`, is just `:id`. So `goto('/blocks')` and `<a href="/blocks">` now reach a page that lives in `src/routes/(app)/blocks/`, where before they reached nothing and the app's screens showed no navigation. Re-index SvelteKit projects after upgrading.
+- Vue Router apps built like vue-element-admin, vue-admin-template or vben now have their routes and screens. Routes declared in a named table (`export const constantRoutes = [...]`, `const routes: RouteRecordRaw[] = [...]`), in per-module route files, or through `new Router(...)` are now read. Child routes are joined onto their parent's path, and the parent's component is the layout around them. A lazily loaded view (`() => import('@/views/dashboard/index')`) is bound to the file it names, and `this.$router.push(...)` counts as navigation. Nuxt's file-based routes now come only from a Nuxt app, so a plain Vue app's `pages/` folder no longer turns into made-up screens, and a Nuxt app at the root of its repository now gets its routes. Re-index Vue projects after upgrading.
+- NestJS routes are now named by the path a request takes: the global prefix from `app.setGlobalPrefix('api')` is applied, along with its `exclude` list, and so is URI versioning from `app.enableVersioning(...)`, with `@Version`, `VERSION_NEUTRAL` and a controller's own `version` taken into account. A route that used to appear as `GET /user` is now `GET /api/v1/user`, so a front end's `this.http.get('/api/v1/user')` or `fetch` call connects to the controller method that serves it. Re-index NestJS projects after upgrading.
 - Laravel routes are now named by the path a request takes: a leading `/` is added where the routes file leaves it out, `Route::prefix()` and `Route::group(['prefix' => …])` groups are applied, and routes in `routes/api.php` carry the `/api` prefix Laravel serves them under, read from your `RouteServiceProvider`, `bootstrap/app.php` or any file that mounts a routes file. A front-end `fetch('/api/…')` now connects to the Laravel route that serves it. Re-index Laravel projects after upgrading.
 - Controllers that Spring or Laravel tests exercise by URL now count as tested. That covers MockMvc's `perform(post("/owners/new"))`, WebTestClient, TestRestTemplate, RestAssured, Laravel's `$this->postJson('api/me')`, Pest's `get('/about')`, and a project's own request helpers built on them. `codegraph_explore` now names the test suite that reaches such an endpoint, where before every one of them looked untested. Re-index Spring and Laravel projects after upgrading.
+- In an Angular app, a method a template calls, like `(click)="toggleFavorite()"` or `(ngSubmit)="submitForm()"`, is now linked from its component. These methods used to show no callers at all, so impact and callers questions stopped at them, and dead-code checks could list them as unused. Re-index Angular projects after upgrading.
+- Angular apps now have routes and navigation in the graph. Each screen in a `Routes` array is a route named by its full path, including children, lazily loaded `loadChildren` files and NgModules, paths written as route constants or `$localize` strings, and redirects. Each route is linked to its component. `router.navigate([...])`, `navigateByUrl`, a guard's `createUrlTree` and every `routerLink` in a component's template link to the screen they open, and a template's child components (`<app-article-list>`) are linked to the component that renders them. Questions like "where does this button go" and "what renders this component" now have answers in `codegraph_explore`. Re-index Angular projects after upgrading.
+- Delphi and Free Pascal include files (`.inc`) are now indexed as Pascal. Before, they were read as PHP and came up empty. A `.inc` file with a `<?php` tag is still PHP, and a `codegraph.json` mapping for `.inc` still wins. Thanks @ijbranch for the report. (#2279)
+- In tag-based CFML, calls written in tags are now linked: in `<cfset>`, `<cfif>`/`<cfelseif>`, `<cfreturn>`, `<cfloop condition>` and `#…#` expressions. Before, only `<cfscript>` and `<cfquery>` code was read, so callers and impact found almost nothing in tag-based components. Functions wrapped in tags like `<cfprocessingdirective>` or `<cfsilent>` are now indexed too, and a `<cfinterface>` is indexed as an interface that `implements` links to. Re-index CFML projects after upgrading. Thanks @HarryMuc for the report. (#2091)
+- Java enum constants and Kotlin enum entries with a body of their own now have their methods in the graph. Examples are `PLUS { int apply(…) { … } }` and `NewBuffer { override fun pipe() … }`. Before, those methods were missing and every call inside them was dropped. jsoup's HTML tokenizer and tree builder are written this way, so over 2,000 of their calls were invisible. Re-index to pick this up.
+- Kotlin infix calls, like `Users.id eq id1` or koin's `single { … } bind MyApi::class`, are now recorded as calls to the infix function. Before, they had no callers at all. On Exposed, `eq` now shows over a thousand callers. Bit operations on numbers (`x and 0xff`, `h shr 8`) are left to Kotlin's own operators, even where the project defines a same-named extension. Re-index after upgrading.
+
+### Fixes
+
+#### Windows
+
+- On Windows, terminal windows no longer flash open and closed while CodeGraph runs in the background. Since 1.6.1, a background MCP server popped up a console window (a full Windows Terminal window when that is the default terminal) several times when it started and again every time it re-synced a changed file. All of CodeGraph's git calls now run hidden. Thanks @Suharaz, @23q3, @A-Van-Gestel, @HarryMuc and @MzaGuille. (#2094, #2096, #2312)
+- On Windows, a project opened with a different drive-letter or folder-name case, like `d:\work\app` and `D:\Work\App`, now joins the CodeGraph background server that is already running for it. Before, each spelling started a server of its own that exited at once, so the session quietly served the graph by itself with no shared file watching or auto-sync, and `codegraph list` showed the project twice. Thanks @greatjackzhou. (#2278)
+- On Windows, `codegraph upgrade` no longer breaks the install while an agent session is using CodeGraph. It used to stop partway and leave CodeGraph unable to start; it now swaps the new files in with CodeGraph running and puts the previous version back if anything fails, and re-running the PowerShell installer works the same way. If an earlier upgrade already broke your install, re-run `irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex` to repair it. Thanks @tippmar-nr for the report. (#2185)
+- On Windows, CodeGraph no longer sometimes crashes with exit code 3221225477 (an access violation) on a busy machine: right after parsing in `codegraph init`, `codegraph index` and background syncs, or as the background server shuts down. Stopping one of its helper threads (the ones that parse files, resolve references, write the index and count changes for `codegraph_status`) while it was still starting up, or before it had finished cleaning up its memory, took the whole process down. Threads now finish starting and clean up before they exit.
+
+#### The background server, sessions and the CLI
+
+- The Claude Code prompt hook no longer runs on the messages Claude Code uses to hand a subagent's report back to the main session. Before, such a long report could keep the hook busy past Claude Code's 30-second hook timeout and inject context unrelated to what you asked. Thanks @danusha2345, and @tippmar-nr for the report. (#2184)
+- Newer MCP clients such as Antigravity 2.5 connect again: the server now answers their `server/discover` probe right away with "method not found", so they go straight on to the regular handshake instead of waiting on a reply that could take seconds or never come. Thanks @danusha2345, and @samem26 for the report. (#2084)
+- A CodeGraph session that queried another project through `projectPath` no longer keeps that project locked for as long as it runs: after 10 minutes without a query it lets the project go, so the project's own session and `codegraph index` can take over again (tune with `CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS`, `0` keeps it open). Thanks @danusha2345, and @bompus for the report. (#2087)
+- Claude Code now shows the model the full text of `codegraph_status` and of explore's stale-index refusal. Both results also carried `structuredContent`, and Claude Code shows a result's `structuredContent` in place of its text, so the model saw only a freshness JSON object: no refusal message, no retry guidance and no status report. Both results are now text only. Thanks @bompus. (#2088)
+- When an agent asks CodeGraph about a separate git repository nested inside an indexed project, one the project's index leaves out (for example because the parent's `.gitignore` excludes it), it now gets the usual "isn't indexed" guidance instead of answers from the parent project's code. Nested repositories the parent does index, such as submodules, work as before. Thanks @wstczyw for the report. (#2110)
+- An agent session that lost its connection to CodeGraph's shared background server, or couldn't reach it at startup, no longer stops that server from running for the rest of the session. It reconnects on its own once the server can start, so other sessions on the same project get auto-sync back instead of running read-only. Thanks @ijbranch for the report. (#2277)
+- `codegraph index` no longer gives up with "Could not verify that the active CodeGraph daemon has stopped" while the background server is still finishing its shutdown, and `codegraph daemon` no longer reports such a server as one it could not stop; both now wait for it to exit, for up to about 20 seconds. An agent session that is serving CodeGraph by itself, because the background server was unavailable, now also waits for that work to stop before it exits instead of exiting partway through, which could crash on Windows. Thanks @bompus. (#2311)
+- Anonymous usage telemetry now sends one daily count per tool or command, as documented, instead of one per codegraph process. Before, every MCP server launch, CLI command and prompt hook queued its own entry, so a busy machine uploaded thousands of copies of the same count each day. If you have telemetry turned off, nothing changes.
+
+#### Indexing and sync
+
+- A COBOL file whose last line ends inside the sequence area (columns 1-6), such as a closing period indented only four spaces, no longer stalls indexing for over a minute and then ends up in the index with no symbols.
+- Editing a file that defines the same name more than once, like two classes that each have an `execute` method or a method's overloads, no longer moves every caller from other files onto one of them during `codegraph sync`. A sync interrupted partway through a file also no longer loses those callers until a full re-index. Thanks @ijbranch for the report. (#2276)
+- Indexing a large C or C++ project no longer runs out of memory partway through "Resolving refs". Headers whose include guard is written as `#define X_H 1`, as in OpenSceneGraph and osgEarth, or that are included under a build flag codegraph cannot know, used to be re-read on every include path, which grows exponentially with the depth of the include tree. Each is now read once per include state, and a hard limit stops the check on any include tree that is still too large. Thanks @danusha2345, and @coolhitmanleon for the report. (#2127)
+- On a busy machine, indexing or syncing a small project no longer starts extra background threads for resolving references that it can't use. Under heavy load the slower pace made a ten-file project look big enough to need them, which added seconds to the run and held extra memory.
+
+#### Across languages
+
+- A type that extends another type of the same name now links to that other type instead of to itself. When the source spells out the qualifier, that qualifier picks between same-named candidates. Before, cats' `trait BigDecimalInstances extends cats.kernel.instances.BigDecimalInstances` and every `trait AllOps … with Functor.AllOps[…]` pointed back at the declaring trait, and Newtonsoft.Json's `JsonConverter<T> : JsonConverter` extended itself.
+- Framework name conventions for Django, FastAPI, Flask, ASP.NET, Gin, SwiftUI and Vapor now only pick a class the reference can see. Examples of these conventions are "a `…View` is a view", "a `…Service` is a service" and "a capitalized name is a model". The pick starts from the reference's own file and then its package, and never takes a class declared inside some function or nested in another file's class. Before, Django REST framework's tests linked each file's own `MockView` and `Serializer` to another file's, and netbox's tests linked `TestForm()` to a form declared inside a different test function.
+- A method that calls a same-named method on another expression's result is no longer linked to itself in any language. Examples are Scala's `requestToArmeria(request).execute()` inside `execute()`, Rust's `self.0.into_route(state)` inside `into_route()`, and Kotlin's `this@Buffer.write(…)` from an inner object. A value whose initializer chain calls a same-named method, like sttp's `val response = basicRequest.get(…).response(…)`, no longer links to itself either.
+- A method that hands its call on to another object is no longer linked to itself. In TypeScript and JavaScript, a call through `this.<field>` or `window.<x>` counts as recursion only when the field is declared as the method's own class. A guess from a receiver's name alone never lands on the calling method. Before, BookStack's `toggle()` doing `this.container.classList.toggle('open')`, `listen()` doing `window.$events.listen(…)`, and `FileStorage::delete` doing `$storage->delete($path)` each pointed at themselves.
+- A function or name passed as a value now resolves to what is in scope where it's written. A function nested inside another function is only reachable from inside it. In Python, a parameter or local of the same name is that local. A pytest fixture is a test's parameter only in its own module or under its `conftest.py`. Before, httpx's `self._build_auth(auth)` linked to an `auth` a test defines inside another function, and `auth_flow(self, request)` handing `request` on linked to the package's `request()` function.
+- In Java, C#, Kotlin, Swift, Scala, Dart and VB.NET, a call now reaches the overload whose parameters fit its arguments, not whichever same-named overload was indexed first. For example, `HashCodeBuilder.reflectionHashCode(this)` now reaches the one-argument overload with varargs, not a three-parameter one. Each overload's callers are now its own.
+- A method that calls another overload of itself now links to that overload rather than to itself. An example is `toInstant(instant)` returning `toInstant(instant, Instant.EPOCH)`. The fuller overload now lists its convenience overloads among its callers, so its impact includes them. This applies to Java, C#, Kotlin, Swift, C++, Scala, Dart and VB.NET. Real recursion is unchanged.
+- Production code no longer links to a same-named symbol inside a test suite, since tests aren't built into the program. Before, typeorm's `Record<string, …>` types reached a test entity called `Record`, and okhttp's sample `@Override` annotations reached a test's nested `Override` class. Test-support code a project ships, such as a `testing/` folder or a `*-test` module, stays in reach.
+- A method call on a variable is no longer guessed to be a test double's method just because the double has the only method of that name. That covered classes named `Mocked…`, `Fake…`, `Stub…` or `Dummy…`: django-allauth's `resp.json()` calls had all gone to its `MockedResponse`. A test that names the double still calls it.
+- A call through a class name, like `THorse.Get(…)`, `MyView.as_view()` or `ColorChoices.values()`, now reaches the class method that class inherits. The inheritance is read from the class declarations themselves, in Pascal, Python, Ruby, PHP, TypeScript/JavaScript and the Java family. Before, such a call was resolved by guessing from the name. On Horse, `THorse.Get('/ping', …)` used to land on a route-group interface's `Get` 120 times. Re-index after upgrading.
+- A method guessed from a receiver's name no longer lands on a request handler the web framework dispatches to, such as a Django or DRF view's `post` / `get` or a controller's `update` / `destroy`. It also no longer lands on a test double the calling file never mentions. On django-allauth, tests' `client.post(…)` used to land on a `ClientRegistrationView` 425 times. On mealie, `response.json()` used to land on a test's `_FakeHTTPResponse` 424 times. In Python, `site = Site.objects.create(…)` now makes `site` a `Site`, so `site.save()` reaches the model's own `save`. Re-index after upgrading.
+- In C#, Java and Kotlin, a call through a field, property or parameter now lands on the method of the type it is declared with. That includes a type inherited from a base class with its type argument filled in, a generic or `for`-each declaration, a C# `using` alias, and a type parameter's bound. A call no longer falls back to a guess at some project class's same-named method, and a type from outside the project gives no link. On Newtonsoft.Json, `_innerWriter.WriteValue(…)` inside a writer wrapper used to land on the wrapper's own `WriteValue`, and a `TextWriter`'s `Write(…)` on a test writer's. On commons-lang, a `DateFormat` field's `parse(…)` used to land on the project's `DateParser` 284 times.
+- A call on a variable declared with a type from outside the project (`List<String> list`, `var sb = new StringBuilder()`, `signer = TimestampSigner()`) no longer lands on a project type's method with the same name. On gson, `list.add(…)` used to land on a project list wrapper; on commons-lang, `s.length()` and `buffer.append(…)` on project classes. In Python, a keyword argument inside a call (`prefix=IPNetwork(…)`) is no longer taken for an assignment to that name.
+- A call on a type from outside the project, like `Integer.valueOf(…)`, `Arrays.asList(…)`, `Object.assign(…)` or Delphi's `Exception.Create(…)`, no longer lands on the project's own method with that name. On commons-lang, `Integer.valueOf` used to land on `StringUtils.valueOf` over 800 times. Go's exported variables and Pascal's capitalized parameters and locals are not mistaken for type names.
+- In PHP, CFML, Pascal, COBOL and VB.NET, a call written in a different case than its definition now resolves, like `formatprice()` for `FormatPrice` or CFML's `ToMatchWithCase()` for `toMatchWithCase`. These languages ignore case in names, but such calls used to be dropped before resolution.
+- In Java, Kotlin, Swift, C#, C and C++, Go, Scala, Ruby, Dart and the other case-sensitive languages, a name no longer links to a symbol whose name differs only in case. On jsoup, JUnit's `@Test` had linked every test to a `test` method; `new CookieManager()` had linked to a `cookieManager()` getter, and a `Method` type to a `method()`. PHP, Pascal, CFML, COBOL and VB.NET, whose names really do ignore case, are unchanged.
+- A `super` call in an overriding method, like `super.viewDidLoad()`, `[super init]`, `base.Handle()`, `parent::setUp()` or `super().dispatch(…)`, no longer makes the method look like it calls itself. The call goes to the parent's version, so an override stops showing up as recursive and no longer lists itself among its own callers.
+- A generic type parameter, like `A` in `def zipWith[A, B](…)`, `T` in `<T> T max(…)` or `class Foo<T>`, no longer links to a project symbol that happens to share its name. On cats, one `implicit def A` had thousands of made-up dependents from every `A` in the library. The same goes for Rust, Dart, TypeScript, Java, Kotlin, Swift, Go, C# and C++. A class or other type declared inside a function is only linked from inside that function. In Scala, a `def`'s own parameter, like `f` in `(f: A => B)`, no longer links to a same-named field elsewhere. A bare name no longer reaches a type nested inside another type unless the code is inside that type, extends it or imports its members; the type in scope is linked instead, like cats' own `FlatMap` in place of `Eval`'s nested `FlatMap`. Re-index projects in these languages after upgrading.
+
+#### JavaScript and TypeScript, with Vue, Svelte, Astro, React, Express, NestJS and Hono
+
+- In Vue, Svelte and Astro files, a component now owns its script, and what a `<script setup>`, a Svelte instance script or Astro frontmatter does at its top level is the component's doing. That covers a Nuxt page's `useAsyncData(…)`, a Svelte page's `onMount(…)` and Astro's `await getCollection(…)`. Imports and a module-level script stay with the file. Before, those calls belonged to the file, so callers and flows from a component found nothing. The component was also recorded as containing its own file, and a file with no script had no file node at all.
+- In JavaScript and TypeScript, a CommonJS `require('./application')` now counts as an import of that file, the way an ESM `import` does. A module path also resolves the way Node and bundlers find it: extensions, `index` files and path aliases. Before, a CommonJS file depended on nothing at file level, so Express's own `lib/express.js` showed no imports and impact analysis missed the files it loads. An extensionless side-effect import like `import './polyfills'` also stopped at its own import statement instead of reaching the file.
+- An Express route whose handler is written inline as `function (req, res) {…}`, the form Express's own examples use, now links to what that handler calls, just like an arrow handler does. The handler is the route's last argument, so an inline middleware before a named handler no longer stands in for it, and a wrapper like `asyncHandler(async function (req, res) {…})` and a trailing comma both work. Before, a route such as `POST /login` linked to nothing.
+- In NestJS projects, the provider naming convention (`…Service`, `…Controller`, …) now picks a class only from the reference's own file. Another file's provider is reached through its import, or by ordinary name matching that prefers the nearest declaration. Before, the convention's preference for `*.service.ts` files sent Nest's own specs' `TransientService` and `TestService` to same-named classes in unrelated sample apps.
+- In Astro projects, the component-name convention now applies only inside `.astro` files, where components are used. Before, a TypeScript type with a component's name was linked to that component: astrowind's `image?: Image` and `callToAction?: CallToAction` in its type declarations, and starlight's Playwright `page: Page` in its tests.
+- In JavaScript and TypeScript, the Express conventions for middleware (`validate…`, `auth`, `logger`, …), controllers and services now pick only the calling file's own declaration. Another file's is reached only through an `import` or `require`. Before, SvelteKit's remote functions linked `validate(arg)` to its config loader's `validate` in another package, and Express's examples linked `logger('dev')` to one example's `logger`.
+- In JavaScript and TypeScript, the React conventions for hooks (`use…`) and contexts (`…Context`, `…Provider`) now pick only from the reference's own file. Another file's hook or context is reached only through an import. An optional call like `onSuccess?.(…)` now gets the same scope rules as a plain call. Before, trpc's WebSocket adapter's `createContext?.(…)` option linked to an example app's `createContext`, zod's `schemas.ParseContext` linked to the v3 copy instead of v4's, and bulletproof-react's apps linked `useUser()` to one another's.
+- What a Svelte component's instance `<script>` or a Vue component's `<script setup>` declares is now private to that component. Only a Svelte `<script module>`, a plain Vue `<script>`, or a type a `<script setup>` exports can be reached from another file. Before, shadcn-svelte's `<Item.Root>` linked to a `type Item` that one example component declares for itself, and halo's `isActive` imported from its editor core linked to a tab component's local value.
+- In JavaScript and TypeScript, a name the calling function binds itself, as a parameter or a plain `var`/`let`/`const` above the reference, now means that local instead of a same-named function elsewhere in the file. Before, every lodash helper's `object` parameter linked to a `function object() {}` declared inside `runInContext`, and zod's `new Class(…)` linked to an unrelated `Class` when `Class` was the function's parameter. Destructured hook results like `const { t } = useI18n()` still link to the function they come from.
+- In a project with a React front end, the React rules for hooks (`use…`) and contexts (`…Context`, `…Provider`) no longer apply to backend code. In halo, a Spring app with a React UI, Java imports such as `SecurityContext` and `ObjectProvider` had been handled as React contexts.
+- In a project with a Vue front end, the backend's calls no longer land on Vue components. mealie's Python `QueryFilterBuilder(…)` had been linking to the `QueryFilterBuilder.vue` component. The Vue rules (compiler macros, Nuxt auto-imports, components by name) now apply only to the app's scripts.
+- Calls in your own JavaScript no longer link to a same-named function inside a vendored minified script, like a `*.min.js` or a bundle made of a few enormous lines. Those names are mangled. In healthchecks, every jQuery `$(…)` call had gone to a one-letter helper inside `bootstrap-native.min.js`.
+- Calls inside an inline route handler now keep their receivers, so they resolve like any other method call. Before, Hono's `app.get('/', (c) => c.text('Hello'))` linked the route to the one other `text` method in the project, its client's `ClientResponse.text`; that happened in over 400 routes. A call like `userService.lookup(id)` reaches the service it names.
+- A barrel's `export * as core from './core'` now exports only `core`, not everything in `./core`. In zod, `z.string()` and `z.number()` had been landing on same-named regex constants deep in its core module instead of the schema functions. Calls through `import * as ns` also find members a barrel forwards by name (`export { safeParse } from '../core'`). They follow a namespace path like `z.coerce.number()` too.
+- JavaScript calls through CommonJS `require` bindings now reach the right function. `var express = require('../')` follows `module.exports` through an `index.js` to the function it exports, and every binding in a `var a = require('x'), b = require('y')` list is read. `require('./utils').setCharset` means that module's `setCharset` rather than its first export, and a call to a package from outside the project (`supertest`, `node:assert`) is no longer an edge to the local variable. On express, over 700 `express()` calls now reach `createApplication`.
+- Imports through a tsconfig or jsconfig path alias now use the config nearest the importing file, so each app in a monorepo resolves its own `@/…` or `~/…` alias. On bulletproof-react and trpc's examples, those imports used to fail or land in a different app.
+- In JavaScript, TypeScript and Vue, a call through a name destructured from a composable or custom hook, like `const { getDefaultActivityRoute } = useDefaultActivity()` or `const { t } = useI18n()`, now reaches the function the hook returns. These calls used to resolve to nothing. mealie, elk, halo and excalidraw each gained dozens to over a hundred such links.
+- In JavaScript and TypeScript, a module's top-level function, variable or type that the module doesn't export is no longer linked from other files. Every form of export still counts: the `export` keyword, `export { … }` lists, `export default`, and a default-exported object. On typeorm, test fixtures' local `ColumnMetadata` used to capture `import { ColumnMetadata } from "typeorm"`; on sveltekit, an unexported `resolve` collected other files' `resolve(…)` calls; on zod, a local `z` collected the `zod` package imports.
+- A JavaScript or TypeScript call on something the file imports, like `fireEvent.click(…)` or `util.omit(…)`, no longer links to a same-named method declared in the calling file itself.
+- TypeScript's `import type { X }` no longer reads as an import of something named `type`, and `import { a, type B }` binds `B`, not `type B`. So a type-only import now links to the module it names, where it used to link to whatever project symbol had that name. A type imported from a package, like `RsbuildConfig` from `@rsbuild/core`, no longer links to a project symbol, and JavaScript and TypeScript names no longer match a symbol whose name differs only in case (`Mock` is not `mock`).
+- In a monorepo with an Expo app next to a Next.js app, like create-t3-turbo or tamagui's starter, each router now reads only its own app. Expo Router used to read the Next.js app's files too, so `layout.tsx`, `page.tsx`, a `_components` folder and an API route showed up as screens named `/layout`, `/page` or `/_components/posts`, and a shared package's files became screens as well. Re-index such monorepos after upgrading.
+- Calls in Vue, Svelte and Astro components now follow the same rules as JavaScript and TypeScript. A `t('…')` from `useI18n()` or a `ref(…)` from `vue` used to link to an interface property or a local variable of the same name elsewhere in the project, so on halo two unrelated symbols had over a thousand made-up callers each. A call imported from a package is also no longer mistaken for a project symbol when the package is declared in a nested app's `package.json` or a Deno import map. An import through an alias CodeGraph can't follow, like SvelteKit's `$lib/…` or a nested Nuxt app's `~/…`, is still treated as project code. Re-index Vue, Svelte, Astro and JavaScript/TypeScript projects after upgrading.
+- A minified or bundled JavaScript file is now recognized as generated even when it isn't named `.min.js`, for example a docs site's `bundle.js`, a readable webpack build or a vendored `underscore-min.js`. Its one-letter functions now rank below your own code in search and `codegraph_explore` answers.
+- JavaScript and TypeScript calls are no longer linked to a class member that merely shares their name. A call on a namespace import, like zod's `z.string()` (`import * as z from 'zod'`), or on something imported from an npm package, used to link to whichever class in the project had a `string` member, and a bare call like mocha's `it(…)` or `describe(…)` to an interface's `it` property or a class's `describe` field. On zod one test helper's getter had thousands of made-up callers and topped the most-depended-on list. A React hook or component imported from a package, like `useQuery` from `@tanstack/react-query`, no longer links to a same-named one in the project, and a hook nested inside another function is no longer a target at all. Re-index JavaScript and TypeScript projects after upgrading.
+
+#### Python
+
+- A Python module member used through the imported module, like `generic.ObjectEditView` after `from netbox.views import generic`, `serializers.ValidationError` or `utils.assert_deserialize(…)`, now also follows the package's re-exports to its definition. Before, netbox's view classes lost their `generic.*` base classes, and mealie's test helpers called through `utils.` went unresolved.
+- A Python name imported from a package now follows the package's re-exports to where it's defined. That covers both `from .users import *` and `from .tokens import Token` in its `__init__.py`. Before, httpx's own tests' `httpx.Client(…)` and `httpx.URL(…)`, pytest's `pytest.raises(…)` and `pytest.param(…)`, and netbox's `from users.models import User` went unresolved or to a same-named class elsewhere, such as a test's `User` or an Alembic migration's copy of a model.
+- In pytest tests, a parameter now takes the class its fixture returns, so a call on it reaches that class's method. If the class comes from a library, the call no longer reaches the project's only method of that name. Fixtures a `conftest.py` pulls in with `from … import *` or `pytest_plugins` now count as in reach. Before, flask's `runner.invoke(…)` on click's `CliRunner()` linked to the project's `FlaskCliRunner.invoke`, and `@app.get(…)` on a `Flask(…)` fixture linked to an unrelated `get`.
+- In Python, an attribute passed as a value through an object nothing types, like netbox's `device=self.parent.device`, is no longer linked to the project's only method of that name when the object isn't named after the method's class. Before, netbox's model-field reads went to a GraphQL filter's `device` method, and healthchecks' `check.last_ping` went to a notification transport's.
+- A Python call to a name the function or module binds itself now means that local value, not a same-named function in another file. In Django REST Framework's tests, `view = SomeView.as_view()` followed by `view(request)` had pointed at one test file's `def view`. The same goes for a parameter or a `for`/`with … as` target. A pytest fixture a test takes as a parameter is still the fixture.
+- Python calls like `User.objects.get(…)`, `self.client.login(…)` or `request.POST.get(…)` no longer link to whichever class in the project has a method of that name. Such a call now links only to a member of what its receiver names, like `helpers.slugify()` to `slugify` in `helpers.py`, and a bare `get(1)` never links to a method. A name the file imports from a package outside the project, like `from django.shortcuts import render`, no longer links to a same-named project function. In Django projects these made-up links had given single test or serializer methods thousands of callers, for example netbox's `.all()` calls on one `UserConfig.all`. Re-index Python projects after upgrading.
+- In Python, a call written on the instance, like `self.get_breadcrumbs(...)`, now links to the class's own method even when the file also imports a function of the same name. Before, the import claimed it: Django REST Framework's renderers, netbox's change logging and django-allauth's account adapter all linked their own method calls to an imported helper.
+- In Python, a method passed as a value through a module-level variable that a setup function assigns, like `settings.docStoreConn.delete_payload_fields` after `global docStoreConn; docStoreConn = QdrantConnection()`, now links to that class's method. When several backend classes can be assigned, it links to the declaration they all inherit. Thanks @JosefAschauer. (#2074)
+- In Python, an import split over several lines in parentheses, `from x import (A, B)` written one name per line, is now read in full. Before, its names were invisible to resolution, so Django REST Framework's `serializers.CharField()` and netbox's model mixins linked to the wrong class or to nothing. Thanks @JosefAschauer.
+
+#### Java, Kotlin and Scala
+
+- In Java, a bare type name now resolves only to a type in reach. That is a type in the same package, one imported by name or with `.*`, or a nested type used from inside its owner, from a subclass (anonymous classes included), or written through its owner as in `Outer.Inner`. A constructor no longer stands in for its class, and an enum constant is reached by bare name only inside its enum, in a `case` label, or through a static import. Before, retrofit's `new Retrofit.Builder()` linked to `RequestFactory.Builder`, halo's micrometer `Counter` to its own `Counter` class, and jsoup's `java.lang.Class<?>` to a nested selector class.
+- Bare calls in Gradle Kotlin scripts (`build.gradle.kts`), like `plugins { }`, `dependencies { }` or `api(…)`, are no longer linked to a method or property of one of the project's own classes. Build logic's extension functions on Gradle's types still resolve. Before, nowinandroid's build scripts pointed every `plugins { }` and `dependencies { }` block at its build logic's `Graph` class, and every `api(…)` at a lint registry's `api` property.
+- In Scala, a package object's member now resolves only where it is in scope: in its own package, the packages under it, or a file that imports through that package. Before, cats' laws resolved `Eq`, `Order` and `Monoid` to the `algebra` package object's aliases rather than the `cats` package object's, and sttp's akka tests reached a zio package object's `whenRequestMatches`.
+- In Spring projects, a class name now resolves to the one in the reference's own file or package before any guess by folder convention. A class nested inside another file's class is never reached by its bare name. Before, every MyBatis `Example` class's `new Criteria()` in mall linked to the first `Example`'s nested `Criteria`, and halo's Lombok `@Builder` linked to a nested `Builder` class elsewhere.
+- In Scala, a kind-projector placeholder in a type, like `Align[Either[A, *]]`, is no longer linked to an operator method named `*`. A symbolic name in a type, like cats' `F ~> G`, now resolves only to a type.
+- Kotlin calls inside a DSL lambda now reach the lambda's own receiver. That receiver comes from the function the lambda is passed to, even through a typealias like koin's `Definition<T> = Scope.(…) -> T`. It also wins over other types the project uses as lambda receivers elsewhere. On koin, over 2,000 `get()` calls in `single { … }` now reach `Scope.get` instead of `Koin.get`; on Exposed, `varchar(…)` inside a table object reaches `Table.varchar`; on kotlinx.coroutines, `launch { }` reaches `CoroutineScope.launch`.
+- A Scala chained call like `xs.map { … }` no longer lands on an object that happens to be named `map`, as with cats' `alleycats.std.map` and its `syntax`/`instances` objects. A type or object in a chain is only matched when the receiver names what holds it, as in `sttp.client4.Response(…)`.
+- Kotlin imports now decide what a name means, as Java imports already do. `import java.net.Proxy` or `import org.mockito.Mockito.mock` no longer links to a same-named project symbol, and a member the file declares itself still comes first. An `import x.Foo` picks the right one of several same-named classes: on okhttp, `MockResponse.Builder()` and `Request.Builder()` now reach their classes. A renaming import like `import …internal.unsafeFlow as flow` means the function it names.
+- In Java, a class you import from outside your project now owns its name. After `import java.lang.reflect.Field;` the file's `Field` no longer links to a project class that happens to share the name. In gson that was a test's nested `Field` class; in jsoup's W3C converter it was jsoup's own `Document` and `Element`. A static import like `import static org.mockito.Mockito.verify;` is covered the same way.
+- Scala calls no longer land on another test's local value. A `val f` written inside one `test("…") { }` block was being picked for a lambda parameter `f` in another suite, and even for `f(…)` in cats' core library. A package import like `import cats.syntax.all._` no longer puts every class's members in scope. Members that really are in scope now resolve: those of an imported package object's parent types (`import sttp.client4._` gives `SttpApi`'s `multipart`), and of the file's own package object.
+- Kotlin files using newer syntax now keep their classes intact. That covers `when` guard conditions (`is X if cond ->`), `..<` ranges, multi-dollar strings (`$$"…"`) and nullable receivers in function types (`T?.() -> R`). Before, the class around such code could come out as a scatter of loose functions. On Exposed, files with a parse error dropped from 65 to 43, and on kotlinx.coroutines from 50 to 46. Re-index after upgrading.
+- Kotlin code using an infix function whose name starts with `e`, like Exposed's `Users.id eq id1`, now parses cleanly. Before, the rest of such a line was a parse error, and in a file with many of them the whole class around it could be lost. On Exposed, files with a parse error dropped from 229 to 71. Re-index after upgrading.
+- In Kotlin, a call with no receiver now reaches a method of another class only when that class is in reach. That means a class, an anonymous `object : Base()` or an extension function's receiver around the call, what those inherit, or the receiver of a DSL lambda (koin's `single { get() }` runs on a `Scope`, Exposed's `withTables { … }` on a transaction). An object member the file imports is in reach too. Kotlin's own `error(…)`, `require(x >= 0) { … }` and `check(…)` no longer land on a project class's method of that name. On koin, `module { … }` in one test used to land on another test class's private `module` over 260 times, and inside a lambda `get()` landed on the wrong class's `get`. Re-index after upgrading.
+- Kotlin classes whose primary constructor sits on the line after the class name, before a supertype list (`expect open class ByteString` / `internal constructor(…) : Comparable<ByteString>`, common in Kotlin Multiplatform code), no longer lose their members to loose functions. A call later in a chain to a Kotlin standard-library function (`apply`, `let`, `toString`, `map`, `contains`…) no longer lands on a project type's same-named method. On okhttp, `.apply { … }` used to land on `ConnectionSpec.apply`. Re-index after upgrading.
+- In Scala, a call reached by its name alone now stays in reach. A name that the enclosing function binds as a parameter or local (`f(true)` for `f: A => B`) is that local. A call later in a chain, like `fa.iterator.map(…)`, reaches only a member of what its receiver is named after. A plain call reaches only the enclosing class and its supertypes (an anonymous subclass's base included), a companion, or an imported object. On cats, parameter calls like `f(a)` used to land on a case class's field `f` over 400 times, and chained `.map(…)` on one ops class's `map`.
+- In Kotlin, a call to a top-level or extension function now resolves only to one the file can see: one in its own package, one it imports by name, or one from a package it imports with `*`. On Exposed, tests that imported kotlin.test's or JUnit's `assertEquals`, or the JDBC suite's helper, used to land on the R2DBC suite's helper over 3,000 times. On okhttp, tests that import `mockwebserver3.MockResponse` used to construct the deprecated class of the same name. A function type with a qualified receiver, like `(DatabaseConfig.Builder.() -> Unit)?`, no longer breaks the parse of the class around it. Re-index after upgrading.
+- A bare Java call like `verify(mock)`, `assertThat(x)` or `hashCode()` now links only to a method of the class it's in, of that class's parents, or one the file imports statically. It used to link to any class's method of that name: in halo, Mockito's `verify` and `eq` gave one service's `verify` over a thousand made-up callers, and in retrofit Truth's `assertThat` did the same to a test helper. Calls to inherited methods and static imports from the project now link to the right one, like jsoup's `attr(…)` through `LeafNode` or halo's `and(…)` / `equal(…)` through `import static …Queries.*`. Re-index Java projects after upgrading.
+
+#### C# and VB.NET
+
+- C# names now follow the language's scopes. A block `namespace X { … }` qualifies only the types inside it, so a type declared after the block, or in a file's second namespace, is no longer filed under the first. A namespace written inside another is `Outer.Inner`. A `using` links to the project's namespace instead of another file's `using` of the same name. A `global using` applies only within its own project. A nested type is reachable by bare name only from inside its owner or a type deriving from it, including through another partial part. Before, serilog's `Guard` was filed under `JetBrains.Annotations`, its tests' `Some.InformationEvent()` went to the performance tests' `Some`, and AutoMapper's same-file `new Source()` could reach another test class's nested `Source`.
+- C# type names now follow namespaces. A type is in reach from its own namespace or one nested inside it, or through a `using` of its namespace. Also counted: a project-wide `global using`, the project's `<Using>` entries, the SDK's implicit usings, or an alias that names it. Before, Newtonsoft's `async Task` tests linked `Task` to a test class of that name in another namespace, and AutoMapper's DTOs linked to another namespace's `BaseEntity`.
+- C# members of an interface are now public and types declared without a modifier are now internal, as the language defines. A call on an interface-typed field now reaches the interface's method, where it used to find nothing. A guess from a receiver's name now weighs only the owner type's own name, not its namespace. Standard .NET names like `ToString`, `Add` and `Write` need a receiver named after the owner. In every language, a guess from production code no longer lands on a mock or helper defined in a test suite. Re-index after upgrading.
+- In C#, a bare name like `TestContext`, `Easing` or `Helper()` now resolves only to a member of the class it's written in, its outer classes, their base classes, or a type brought in with `using static`. That includes a `global using static` and a project file's `<Using … Static="true"/>`. On eShop, test classes' `TestContext` used to land on one other test class's property; on Newtonsoft.Json, `TypeNameHandling.All` now reaches the enum rather than a same-named property.
+- In VB.NET, a call through a receiver like `Me.Panel.Controls.Add(…)` or `New System.Drawing.Size(…)` no longer lands on an unrelated class's member with the same name. It now resolves only through `Me`, `MyBase` or `MyClass`, through the member's own class or module (`Logger.Log(…)`), or through a service lookup's type (`GetService(Of Notifier).Notify()`). On SCrawler, the Windows Forms designer code used to link over 700 `Size` calls to a nested enum's case and over 500 `Controls.Add` calls to a collection class.
+- In C# and VB.NET, a type written in code, like `Type sourceType`, `List<int>`, `new TypeMap()` or `Dictionary<string, Type>`, now links to the type and no longer to a property, method or field that shares its name. `List<…>` used to link to some test class's `List` property, `Type` to an attribute's `Type` property, and a parameter of type `TypeMap` to a `TypeMap` property instead of the `TypeMap` class. Those members showed up with hundreds of made-up dependents. Reading a property or passing a method, like `Builder.Services` or `MapGet("/x", GetItems)`, still links as before. Re-index C# and VB.NET projects after upgrading.
+
+#### Swift and Objective-C
+
+- An Objective-C class that conforms to a protocol of its own name now links to that protocol instead of to itself. Swift's naming conventions for views, models and controllers also no longer apply to Objective-C code. Before, every one of SDWebImage's `@interface SDDiskCache : NSObject <SDDiskCache>`-style classes implemented itself.
+- In Swift, a call to an overloaded method now reaches the overload whose argument labels it spells, with defaulted parameters optional. Before, only the argument count was compared. Alamofire's `self.tableView(tableView, numberOfRowsInSection:)` inside another `tableView` overload linked to itself, and `cancel(optionallyProducingResumeData:)` linked to `cancel(producingResumeData:)`.
+- A Swift call on a property declared with a type, like Kingfisher's `var cache: ImageCache!` or `self.storage.write(…)`, now reaches that type's method or one it inherits. It no longer lands on a subclass override in a test, or on another type's method of the same name.
+- A Swift call on a value built on the spot, like `JSONDecoder().decode(…)` or `Realm().create(…)`, now resolves to that type's method, or to one it inherits. It no longer lands on some other type's method of the same name: Vapor's `JSONDecoder().decode` calls had gone to a request's private container.
+- In Objective-C, `[super init]` and other messages to `super` now reach the superclass's method, never the sending class's own override. This also works where the index lost the `@implementation`'s range. On SDWebImage, `NSObject` subclasses' `[super init]` used to land on `SDDiskCache`'s `init`, and `[self class]` in tests on a proxy class's `class`. On AFNetworking, a serializer's `[super encodeWithCoder:]` now reaches its superclass. Re-index after upgrading.
+- In Swift, a call written with no receiver, or through `self.` or `super.`, now reaches only a member of the type around it or of what that type inherits or conforms to, and the nearest override wins. A standard-library name later in a chain (`axis.entries.removeAll()`, `names.contains(x)`) no longer lands on a project type's method, unless the receiver or the call's argument label points to it. On Charts, `min(a, b)` and `max(a, b)` used to land on a range type's `min` field and a `Sequence` extension, and `super.init(…)` on an Objective-C demo's `init` over 170 times. A global in a playground or a test target is no longer linked from the main code. Re-index after upgrading.
+- In Objective-C, a message now reaches a method only when it could really be sent there. A message to `self` or `super` reaches only the sender's class and its superclasses, including categories on UIKit and AppKit views. A C-style call like `completionBlock()` is never taken for a method or property. A message to a local variable uses the variable's declared type (`FMResultSet *rs`). On SDWebImage, `[self class]`, `respondsToSelector:` and `isKindOfClass:` used to land on a proxy class's overrides over 150 times, and on fmdb `[rs close]` now reaches the result set.
+- A Swift call through a nested type, like `API.PackageController.GetRoute.query(on: db)`, now links to that type's method. Only `query` used to be kept, so the call linked to whichever type's `query` came first; in a Vapor app every route type has one, so callers, impact and `codegraph_explore` answers pointed at another endpoint's code. The same applies to nested types' initializers (`API.PackageController.Model(name:)`), to enum cases (`Gitlab.Error.requestFailed(status:)`), to types declared in an `extension API.PackageController { … }`, and to The Composable Architecture's `Path.State.detail(…)`. A call on a type path that names no type in the project, such as an SDK's `Plot.Node.footer(…)`, is left unlinked. Re-index Swift projects after upgrading.
 - A SwiftUI view, a `@main` app, a view controller and a UIView subclass are now indexed once. Each used to get a second, one-line copy with no callers or calls, which showed up next to the real type in search and `codegraph_explore` answers as a dead end. Re-index Swift projects after upgrading.
 - A Swift class or struct that declares a protocol composition across lines, like `typealias Client = AutocompleteService.Client` followed by `& PostingService.Client` on the next line, is now indexed whole. That line used to break the parse of the entire enclosing type, so its methods, initializer and properties went missing, and calls into them landed on same-named methods elsewhere. Re-index Swift projects after upgrading.
 - A Swift reference to a type now links to the type's own declaration, not to a file that extends it. An `extension View { … }` or `extension Text { … }` used to stand in for SwiftUI's type, so every view, every `Text("…")` and every `Color.red` in an app linked to whichever file happened to extend it. Those files topped the most-depended-on lists and their impact reached the whole app. A bare name like `@State`, `@Test` or `Result<…>` no longer links to some other type's nested `State` or `Result`, and a qualified name like `Build.Id` links to the `Id` it names. Methods declared in an extension of an SDK type still resolve on the types that conform to it, and a protocol's methods declared in any of its extensions now connect to each conforming type's own implementation. Re-index Swift projects after upgrading.
 - A Vapor route now links to the handler it names. `use: SearchController.show` used to link to whichever controller's `show` came first, so routes with a common handler name, like `show`, `index` or `get`, pointed at another endpoint's code in callers, impact and `codegraph_explore` answers. Nested types like `API.PackageController.get` and handlers declared in an extension of the controller now resolve too, and `use: self.index` resolves to the collection's own `index`. Re-index Vapor projects after upgrading.
+
+#### C, C++, Go and Rust
+
+- A call in C code is no longer linked to a C++ class's method, since C has no methods and can't call one. Before, redis's POSIX `read(fd, buf, n)` calls and hiredis's `c->funcs->read(…)` function pointer pointed at a Qt adapter's `read` method.
+- In Go, a name written through an imported package from outside the module, like `context.Context`, `http.ResponseWriter` or testify's `require.Contains`, is no longer linked to a project symbol of that name. Before, fiber's `context.Context` parameters pointed at a method `Stream.Context`, its `require.Contains(…)` assertions at an extractor's `Contains`, and gin's `http.ResponseWriter` at its own `ResponseWriter` interface.
+- In Rust, `Self::Error` in a signature now resolves to the enclosing impl's or trait's own associated type. A path through a generic parameter, like `V::Value`, no longer resolves to an unrelated struct of that name. Before, serde's `Self::Error` signatures pointed at its one `struct Error`, and axum's `Self::Error` at `axum-core`'s error type.
+- In Rust projects, a struct, handler or service name no longer resolves to an item declared inside some function body, and a file's own item comes before any other crate's. Before, axum's examples' `Uri` linked to a `struct Uri` declared inside a routing test, tokio's runtime `Handle` linked to `tokio-test`'s, and ripgrep's `Glob { … }` in globset linked to the CLI flags' `Glob`.
+- Rust type and function names now follow Rust's scoping. A name from another file counts only when a `use` brings it in (or a `*` glob over its module). One imported from outside the project, like `use std::task::{Context, Poll}` or `use futures::Stream`, means that outside item. A path names its module: `io::Result` isn't an unrelated `Result` alias elsewhere, and `std::io::Error` is std's. On tokio, over 1,200 `io::Result` and 600 `Context` references had been landing on private project types.
+- A C++ call into a macro-opened namespace, like `fmt::format("{}", x)`, now picks the overload its arguments fit. Before, the first overload indexed won: fmt's 1,400 `fmt::format` calls all reached the `text_style` overload in `color.h`. A narrow string literal now fits a narrow format string, a wide `L"…"` fits the wide overload, and the argument count has to fit too.
+- C++ classes written around macros and preprocessor conditionals now keep their members. These include an access specifier spelled as a macro (`JSON_PRIVATE_UNLESS_TESTED:`), an attribute macro after a template head or a doc comment, and an `#if` in the middle of a declaration, such as inside a constructor's initializer list. The first branch of a mid-declaration `#if` is the one indexed. nlohmann/json's `basic_json` class used to be lost whole and now has its roughly 390 members. Files with a parse error dropped on redis, curl, pybind11 and leveldb, and no file got worse. Re-index after upgrading.
+- Calls on a library's own types and modules no longer land on a project method that happens to share the name. In Rust, `Vec::new()`, `String::from(…)` and module paths like `task::spawn(…)` stay the standard library's. A later link of a multi-line Rust or Go chain now counts as a chained call, named after the chain's first line. In Go, `w.Header().Get(…)` is net/http's. In R, a plain call like `range(x)` is a function, not an object's method. In JavaScript, `response.text()` / `.json()` is fetch's. On tokio, `task::spawn(…)` used to land on `TaskTracker::spawn` 300 times. On ggplot2, `range(…)` used to land on a coordinate system's `range` method. Re-index after upgrading.
+- In C and C++, a qualified name like `fmt::format` now reaches a declaration inside a namespace the library opens with a macro, like fmt's `FMT_BEGIN_NAMESPACE`, pybind11's `PYBIND11_NAMESPACE_BEGIN(…)` or rapidjson's and spdlog's `…_NAMESPACE_BEGIN`. It also works through a namespace alias like `namespace py = pybind11;`. On fmt, 1,728 `fmt::format(…)` calls used to link to nothing, and so did about 1,400 `py::…` calls on pybind11.
+- In Rust and Go, a call later in a chain, like `sym.filename().map(…)` or `c.Flags().String(…)`, no longer lands on the project's own method of that name when the name is a standard-library one (`unwrap`, `clone`, `map`, `iter`, Go's `String` or `Error`). A plain call like `get(handler)` or `drop(x)` never lands on a method. On tokio, `.map(…)` on an `Option` used to land on `MutexGuard::map`; on axum, the router's `get(handler)` on a cookie jar's `get`; on ripgrep, `.clone()` on an error type.
+- In Rust, a bare `Ok(…)`, `Some(…)`, `Err(…)`, `Result<…>`, `Option<…>`, `Vec<…>` or `drop(…)` now means the standard library's, unless the file defines or imports a project item of that name. These used to link to any same-named enum variant or struct in the project: every `Some(x)` in ripgrep to one enum's `Some` variant, and every `Ok` and `Result` in serde to structs its macro-hygiene tests declare. An enum variant is now reached by a bare name only where the file `use`s it or its enum's `*`, and a variant never stands for a type. Re-index Rust projects after upgrading.
+
+#### PHP, Ruby, Dart, Lua, R, Solidity, Erlang and CFML
+
+- In Laravel apps, a route whose controller is named by string now links to its handler, without needing a `Controller` suffix and keeping the namespace it's written with: `'Common\Uploads@inline'`, and `Route::resource('companies', 'Common\Companies', [...])` with an options array. Two same-named controllers in different namespaces are told apart by that namespace. Before, akaunting linked 304 of its 313 routes to nothing.
+- In Rails apps, a `resources` line's `only:` and `except:` are now read in every form Rails accepts: `%i[new create index]`, `%w(index show)`, a quoted name, and the older `:only => [...]`. Before, only a bracketed list was read, so maybe's `resources :family_exports, only: %i[new create index]` became all seven routes, four of them to actions the controller doesn't have.
+- In PHP, a class written with a namespace in its name now links to that class. After `use App\Fields as Field;`, `new Field\FirstName()`, `extends Field\Base` and `Field\FirstName::make()` all name `App\Fields\FirstName`, as do `Fields\FirstName` written inside `namespace App;` and a fully qualified `\App\Fields\FirstName`. Before, none of these had a link, so callers and impact missed every class reached that way. Thanks @drakeo338. (#2256)
+- In Solidity, a call to an overloaded function now reaches the overload whose parameter count it fits, as in the other languages with overloading. Before, OpenZeppelin's `_checkRole(role, _msgSender())` inside the one-argument `_checkRole(bytes32 role)` was linked to itself.
+- In R, a call like `c(1, 2)` is no longer linked to a data variable that happens to share a base function's name, since R skips non-function bindings when it looks up a call. Before, ggplot2's facet tests bound `c <- data_frame(b = 3)`, and every `c(…)` call in those files pointed at that data frame. Functions built by a factory, like ggplot2's `geom_point <- make_constructor(…)`, still resolve.
+- A Dart `extension on X { … }` with no name is no longer mistaken for the type `X`, and its members are reachable only inside the file that declares it, as in Dart. Before, bloc's linter linked analyzer's `Token` and Dart's `Uri` to small extension blocks, and every flutter_test `find.text(…)` call linked to a `text` getter on another example's `TaskStatus`.
+- In PHP, an unqualified class name now resolves to the current namespace's class or the one a `use` imports, as PHP does. If the imported class comes from a library, it resolves to nothing in the project. Before, koel's form requests linked `extends Request` to whichever `Request` class was indexed first, and BookStack's controllers linked `Request $request` (Laravel's, by import) to BookStack's own `Request` subclass.
+- A Dart call like `ext.endsWith(".avi")` or `map.putIfAbsent(…)` on a value whose type isn't known now counts as Dart's own String, List or Map method. It no longer lands on a project method of the same name. A Dart extension is also matched by the type it extends, not by its own name, so getx's `ext.endsWith` on a String stopped reaching `extension RxStringExt on Rx<String>`.
+- A bare Lua call like `ipairs(t)`, `error("…")` or busted's `setup()` now means Lua's own function unless the file defines one. It no longer lands on a table method of the same name: telescope's `ipairs` calls had gone to a linked list's `ipairs`, and kong's `error` calls to its response module. A function's own alias of a host table member, like `local get_query = kong.request.get_query`, is now followed as well.
+- Lua calls made through a `local` alias now reach the function it names. That covers `local splitn = require("kong.tools.string").splitn`, a module member such as `utils.select_listener`, and a function a module exports under another name (`return { check = check_phase }`). Aliases of Lua's own functions, such as `local type = type` or `local fmt = string.format`, no longer show up as calls into your project. On Kong that is over 1,000 calls that now reach their real function, and about 5,000 fewer dead-end edges.
+- In Solidity, a call with no receiver now reaches a function of the contract around it or of one it inherits. On OpenZeppelin, `_msgSender()` in contracts built on `Context` used to land on `ERC2771Context`'s override 83 times. In Erlang, a call to another module's function now follows the file's `-import(Mod, [f/N])`. On cowboy, `-import(req_SUITE, [do_get/3])` calls used to land on another suite's `do_get/3`. A bare call with no such import no longer links to some other module. Re-index after upgrading.
+- In Lua and Luau, a call through a standard or host library table (`string`, `table`, `io`, `vim`, `ngx`, busted's `assert`…) or a string method like `line:find(…)` no longer lands on the one project method with the same name. Functions the project itself defines on those tables still link. On kong, the specs' `assert.truthy(…)` and `assert.falsy(…)` used to land on a condition helper over 1,700 times; on telescope, `line:find(…)` on the picker's `find`.
+- In PHP, a call through a variable nothing types no longer lands on an unrelated class's method just because it's the only method with that name. The variable now needs to be named after the method's class, or after a class that inherits it (`$page->save()` where `Page` extends `Entity`). On guzzle, the tests' `$response->getHeaderLine()` used to land on a test double; on symfony/console, `$e->getMessage()` on a progress bar.
+- In CFML, a call no longer lands on an unrelated component's method just because the name matches. A call with no receiver inside a component now reaches only that component's methods and those of the components it extends, so built-ins like `now()` stay built-ins. A call on an untyped variable now needs the variable to be named after the component, so `server.keyExists(…)` is no longer taken for some component's `keyExists`. On coldbox, `now()` used to land on a date helper over 200 times, and TestBox's `fail(…)` in specs now reaches the spec base class.
+- In Ruby, a call no longer lands on an unrelated class's method just because it's the only method with that name. A call on an untyped receiver now needs the receiver to be named after the method's class, like `web_push_request.legacy_encrypt`. A call with no receiver inside a class now reaches only that class's methods, its superclasses' methods, and those of the modules it includes, extends or prepends. On rubocop, `node.loc` on a syntax node used to land on the project's one `loc` method over 1,200 times, and Kernel's `format(…)` on the language server's `format`. On mastodon, `render` in controllers used to land on an inline renderer, and `authorize` now reaches the authorization concern.
+- In Dart, a call written without a receiver now reaches only a method of the class it's written in, of a class it extends, mixes in or implements, or of an extension on one of those types, and picks the nearest one. On riverpod, package:test's `test(…)` in the test files used to land on a container class's `test` method over 1,100 times, shelf's and getx's `expect(…)` on unrelated classes' `expect`, and bloc's `emit(…)` in a Cubit on the wrong base class. Classes declared as `class A = B with C;` are now indexed under their name, with what they extend and mix in. Re-index after upgrading.
+- In R, a variable assigned at the top of a test file is no longer linked from the package or from other tests, because testthat runs each test file in its own environment. On ggplot2, a test's `c <- ggplot(…)` used to collect 2,455 of the package's `c(…)` calls. Variables in `helper-*.R` and `setup-*.R`, which testthat loads for every test, are still shared.
+- In Lua and Luau, a `local` variable or function is no longer linked from other files, since it's only visible in the file that declares it. On kong, a spec helper's `local it = it` used to collect every other spec file's `it(…)` (over 4,000 links), and one module's `local ipairs = ipairs` took the whole project's `ipairs(…)`. Global functions are still linked across files.
+- PHP calls on `$this`, `self`, `static` and `parent` now reach the method of the class they're written in, a class it extends, or a trait any of them uses, with parent classes and traits found through the file's `namespace` and `use` imports. On Drupal core, `$this->assertEquals()` (PHPUnit's) used to link to an unrelated comparator class 8,832 times, `$this->assertSession()` to a JavaScript-test base class, and `$this->t()` to `Views::t`. They now reach `UiHelperTrait` and `StringTranslationTrait`, or nothing when the method lives in a package outside the repository. A call inside a trait, and a base class calling a method its subclass defines, keep their links. Re-index PHP projects after upgrading.
+- A PHP function call written after `=>` in an array, like `'count' => count($items)`, `'by' => user()->id` or `'label' => trans('…')`, is now read as a plain function call. It used to be taken for a method call and linked to whichever class had a method of that name. On BookStack, that meant 166 wrong links.
 - A PHP call written without a receiver, such as `redirect($url)`, `view('books.show')`, `auth()` or `basename($path)`, is a function call, and no longer links to a same-named method, field or class elsewhere in the project. These wrong links showed up in callers, impact and `codegraph_explore` answers wherever a Laravel helper or PHP built-in shared its name with a project member. Re-index PHP projects after upgrading.
 
 ## [1.6.1] - 2026-09-29
@@ -1112,3 +1411,4 @@ Thanks @andreinknv for the substantive draft this release was based on.
 [1.5.0]: https://github.com/colbymchenry/codegraph/releases/tag/v1.5.0
 [1.6.0]: https://github.com/colbymchenry/codegraph/releases/tag/v1.6.0
 [1.6.1]: https://github.com/colbymchenry/codegraph/releases/tag/v1.6.1
+[1.6.2]: https://github.com/colbymchenry/codegraph/releases/tag/v1.6.2
diff --git a/FORK.md b/FORK.md
index a44a477ce0..86216e9ff7 100644
--- a/FORK.md
+++ b/FORK.md
@@ -63,3 +63,9 @@ node scripts/pinable/sync-upstream.mjs --check
 ```
 
 `build:lib` 单独构建 UI 组件包，不会发布 npm 包。本次同步不改变包名、版本、发布凭据、已有 Release 工作流或主分支保护规则。
+
+## 历史索引升级兼容
+
+本 fork 从上游 1.6.2 同步起沿用上游 schema v15。旧 Pinable 数据库曾使用 v10/v12 记录工作台相关迁移，与上游后续编号冲突；升级时按实际表和索引补齐缺失的 synthesis 与失败导入重试能力，保留原迁移历史、图数据和游标分页索引。只读连接不会执行修复，已正常升级的数据库重复打开不会重复写入修复数据。
+
+后续 fork 专属修复统一放在 `src/db/pinable-schema.ts`，通过特征检测和事务执行，不再占用上游数字迁移编号；上游迁移体复用原实现，避免两份 SQL 漂移。源码同步与运行时 Release 发布仍是分开的步骤。
diff --git a/README.md b/README.md
index 17efcad3d5..ae3750c3ba 100644
--- a/README.md
+++ b/README.md
@@ -322,7 +322,7 @@ CodeGraph detects web-framework routing files and emits `route` nodes linked by
 | **Flask** | `@app.route('/path', methods=[...])`, blueprint routes |
 | **FastAPI** | `@app.get(...)`, `@router.post(...)`, all standard methods |
 | **Express** | `app.get(...)`, `router.post(...)` with middleware chains |
-| **NestJS** | `@Controller` + `@Get/@Post/...`, GraphQL `@Resolver` + `@Query/@Mutation`, `@MessagePattern`/`@EventPattern`, `@SubscribeMessage` |
+| **NestJS** | `@Controller` + `@Get/@Post/...` (with `RouterModule` prefixes, `setGlobalPrefix` and URI versioning), GraphQL `@Resolver` + `@Query/@Mutation`, `@MessagePattern`/`@EventPattern`, `@SubscribeMessage` |
 | **Laravel** | `Route::get()`, `Route::resource()`, `Controller@action`, tuple syntax |
 | **Drupal** | `*.routing.yml` routes (`_controller`, `_form`, entity handlers); `hook_*` implementations in `.module`/`.theme`/`.install`/`.inc` |
 | **Rails** | `get '/x', to: 'users#index'`, hash-rocket `=>` syntax |
@@ -340,12 +340,13 @@ These frameworks additionally emit **`navigates`** edges: the function that send
 
 | Router | Routes from | Navigation from |
 |---|---|---|
-| **Expo Router** | Every screen file under `app/` (`app/item/[id].tsx` → `/item/[id]`, groups stripped), bound to its default-export component | `router.push` / `replace` / `navigate`, template hrefs, `{ pathname }` objects, and a helper's returned href |
+| **Expo Router** | Every screen file under `app/` (`app/item/[id].tsx` → `/item/[id]`, groups stripped), bound to its default-export component; `+api` files are endpoints (`GET /hello`) bound to their handlers | `router.push` / `replace` / `navigate`, template hrefs, `{ pathname }` objects, and a helper's returned href |
 | **Next.js** | App Router `app/**/page.tsx` and Pages Router pages (`(group)` stripped, `[slug]` → `:slug`); `app/api/**/route.ts` exports and `pages/api/*` are endpoints, not screens | `router.push` / `replace` / `prefetch`, `redirect()` / `permanentRedirect()` in a server action or page, `NextResponse.redirect(new URL(…))` in middleware, `<Link href>` and internal `<a href>` |
-| **React Router** | `<Route path component/element>` (v5 and v6) and `createBrowserRouter([{ path, element }])` | `history.push` / `replace`, `useNavigate`'s `navigate`, a loader's `redirect`, `<Link to>` / `<NavLink to>` / `<Navigate to>` / react-router-bootstrap's `<LinkContainer to>` |
+| **React Router** | `<Route path component/element>` (v5 and v6) and `createBrowserRouter([{ path, element }])` | `history.push` / `replace`, `useNavigate`'s `navigate`, a loader's `redirect`, `<Link to>` / `<NavLink to>` / `<Navigate to>` / v5's `<Redirect to>` / react-router-bootstrap's `<LinkContainer to>`, and a `styled(Link)` wrapper |
 | **TanStack Router** | `createFileRoute('/posts/$postId')` (file-based) and `createRoute({ path, getParentRoute })` composed up its parent chain (code-based); `_pathless` segments, `(group)` folders, `__root` and `<Outlet/>` layouts are not addresses | `navigate({ to })`, a thrown `redirect({ to })`, `<Link to>` / `<Navigate to>` — where `to` is the route PATTERN and the values ride beside it in `params` |
-| **Vue Router** / **Nuxt** | `createRouter({ routes: [...] })` with the view each entry names, plus Nuxt `pages/` file-based routes, `server/api/` endpoints and route middleware | `router.push` / `replace`, `$router.push`, Nuxt's `navigateTo`, `<router-link>` / `<RouterLink>` / `<NuxtLink>` — **by route name** (`push({ name: 'profile' })`) as well as by path |
-| **SvelteKit** | `src/routes/**/+page.svelte` (`[slug]` → `:slug`, `[[opt]]` → `:opt?`), joined to the `+page.server.js` beside it so a loader's guard belongs to its page | `goto('/x')`, `redirect(status, '/x')` from a load or form action, and the plain `<a href>` that is a link in a SvelteKit app |
+| **Vue Router** / **Nuxt** | `createRouter({ routes: [...] })` / `new Router(...)` and the route tables it's given (`export const constantRoutes = [...]`, per-module route files), with the view each entry names — a lazy `() => import(…)` bound to its file — and `children` joined onto their parent's path, the parent being the layout around them; plus Nuxt `pages/` file-based routes, `server/api/` endpoints and route middleware | `router.push` / `replace`, `this.$router.push`, Nuxt's `navigateTo`, `<router-link>` / `<RouterLink>` / `<NuxtLink>` — **by route name** (`push({ name: 'profile' })`) as well as by path |
+| **SvelteKit** | `src/routes/**/+page.svelte` (`[slug]` → `:slug`, `[[opt]]` → `:opt?`, `[id=matcher]` → `:id`, `(group)` folders stripped), joined to the `+page.server.js` beside it so a loader's guard belongs to its page | `goto('/x')`, `redirect(status, '/x')` from a load or form action, and the plain `<a href>` that is a link in a SvelteKit app |
+| **Angular** | `Routes` arrays (`RouterModule.forRoot` / `forChild`, `provideRouter`, a routes file's default export) with `component` or a lazy `loadComponent`; `children` and lazy `loadChildren` (an NgModule's through its routing module) joined into full paths; paths written as route constants or `$localize` strings; a route with children is a layout around the screens inside it | `router.navigate([...])`, `navigateByUrl`, a guard's `createUrlTree` / `parseUrl` — a command array, a route constant, or a component property holding one — `routerLink` / `[routerLink]` in the component's template, and `redirectTo`. Each template's child components (`<app-foo>`) are linked to the component that renders them |
 
 In a repository holding several apps, each app's routes are matched only against navigation written inside that app.
 
@@ -362,9 +363,9 @@ Real iOS and React Native codebases live across multiple languages — a Swift c
 | **React Native legacy bridge** | JS `NativeModules.X.fn(...)` | ObjC `RCT_EXPORT_METHOD` / `RCT_REMAP_METHOD` · Java/Kotlin `@ReactMethod` | Parses macro/annotation declarations to build a JS-name → native-method map |
 | **React Native TurboModules** | JS `import M from './NativeM'; M.fn(...)` | Native impl matching the Codegen spec | Treats the `Native<X>.ts` spec interface as ground truth |
 | **RN native → JS events** | JS `new NativeEventEmitter(...).addListener('e', cb)` | ObjC `[self sendEventWithName:@"e" body:...]` · Swift `sendEvent(withName: "e", ...)` · Java/Kotlin `.emit("e", ...)` | Synthesized cross-language event channel keyed by literal event name |
-| **Expo Modules** | JS `requireNativeModule('X').fn(...)` | Swift / Kotlin `Module { Name("X"); AsyncFunction("fn") { ... } }` | Parses the Expo DSL literals; synthetic method nodes resolve via existing name-match |
+| **Expo Modules** | JS `requireNativeModule('X').fn(...)`, directly or through a binding (`export default requireNativeModule<T>('X')`) | Swift / Kotlin `Module { Name("X"); AsyncFunction("fn") { ... } }` | Parses the Expo DSL literals into method nodes; a call on a binding resolves to module `X`'s `fn` on both platforms, else to the method on the binding's declared type |
 | **Fabric view components** | JSX `<MyView prop={v}/>` | TS Codegen spec + native impl class | Spec → `component` node; convention-based name+suffix lookup (`View`/`ComponentView`/`Manager`/`ViewManager`) bridges to native |
-| **Legacy Paper view managers** | JSX `<MyView prop={v}/>` | ObjC `RCT_EXPORT_VIEW_PROPERTY` · Java/Kotlin `@ReactProp` | Same as Fabric — Paper-era declarations also produce `component` + `property` nodes |
+| **Legacy Paper view managers** | JSX `<MyView prop={v}/>`, through a `requireNativeComponent('X')` module | ObjC `RCT_EXPORT_VIEW_PROPERTY` · Java/Kotlin `@ReactProp` | Same as Fabric — `requireNativeComponent('X')` is a JS `component` node, and Paper-era declarations also produce `component` + `property` nodes |
 
 **Validated on real codebases** (small + medium + large for each bridge):
 
@@ -376,7 +377,7 @@ Real iOS and React Native codebases live across multiple languages — a Swift c
 | Expo Modules | expo-haptics | expo-camera | expo SDK sweep (7 packages) |
 | Fabric / Paper views | [react-native-segmented-control](https://github.com/react-native-segmented-control/segmented-control) | [react-native-screens](https://github.com/software-mansion/react-native-screens) | [react-native-skia](https://github.com/Shopify/react-native-skia) |
 
-Each bridge emits edges tagged `provenance:'heuristic'` with `metadata.synthesizedBy:` set to a stable channel name (e.g. `swift-objc-bridge`, `rn-event-channel`, `fabric-native-impl`, `expo-module-extract`), so the agent can tell at a glance how a hop got into the graph.
+Every bridge hop says how it got into the graph. A hop matched by a bridge resolver carries `metadata.resolvedBy: 'framework'` and `metadata.framework` naming the resolver (`swift-objc-bridge`, `react-native-bridge`, `expo-modules-js`, `fabric-view`). A synthesized channel is tagged `provenance:'heuristic'` with `metadata.synthesizedBy` (`rn-event-channel`, `fabric-native-impl`).
 
 ---
 
diff --git a/TELEMETRY.md b/TELEMETRY.md
index 89dd67f4dd..10f7a0ec0d 100644
--- a/TELEMETRY.md
+++ b/TELEMETRY.md
@@ -115,9 +115,9 @@ take, and there is nothing after it. This is a stronger guarantee than a promise
 share: there is no second party to share with.
 
 What is kept is checkable rather than asserted. The storage schema —
-[`telemetry-worker/migrations/0001_init.sql`](telemetry-worker/migrations/0001_init.sql),
-checked in beside the endpoint that writes it — is the complete list of what a row can
-hold, with a comment on every column.
+[`telemetry-worker/migrations/`](telemetry-worker/migrations/), checked in beside the
+endpoint that writes it — is the complete list of what a row can hold, with a comment on
+every column.
 
 Individual events are **deleted after 90 days**. What outlives them is anonymous daily
 totals: counts per day of things like operating system, version, and language, plus which
diff --git a/__tests__/angular-router.test.ts b/__tests__/angular-router.test.ts
new file mode 100644
index 0000000000..20f9e236aa
--- /dev/null
+++ b/__tests__/angular-router.test.ts
@@ -0,0 +1,717 @@
+/**
+ * Angular Router: screens from `Routes` arrays, navigation from command
+ * arrays and `routerLink`, the component tree from templates.
+ *
+ * Validated on angular-realworld-example-app (standalone components, lazy
+ * `loadComponent`, a `loadChildren` routes file), ngx-admin (NgModule
+ * `loadChildren` through a routing module, layouts, redirects) and Ghostfolio
+ * (route constants with `$localize` paths, destructured locals, function
+ * constants, a `**` redirect home).
+ */
+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';
+import { commandsHref, localizeDefault, parseAngularRoutes, staticString } from '../src/resolution/frameworks/angular-router';
+import { readMicrosyntax, templateMemberUses } from '../src/resolution/angular-template-synthesizer';
+import { buildDeadCodeReport } from '../src/graph/dead-code';
+import { buildScreens } from '../src/ui-server/api/screens';
+import { buildSteps } from '../src/ui-server/api/steps';
+
+describe('parseAngularRoutes', () => {
+  const file = (body: string) => `import { Routes } from '@angular/router';\n${body}`;
+
+  it('reads screens, joining children to their parents, and skips what is not a screen', () => {
+    const { routes, mounts, redirects } = parseAngularRoutes(
+      file(`export const routes: Routes = [
+  { path: '', loadComponent: () => import('./home/home.component') },
+  { path: 'login', component: AuthComponent, canActivate: [guard] },
+  { path: 'editor', children: [
+      { path: '', loadComponent: () => import('./editor.component').then((m) => m.EditorComponent) },
+      { path: ':slug', loadComponent: () => import('./editor.component').then((m) => m.EditorComponent) },
+  ] },
+  { path: 'profile', loadChildren: () => import('./profile/profile.routes') },
+  { path: 'users', matcher: usersMatcher, component: UsersComponent },
+  { path: 'old', redirectTo: 'login' },
+  { path: '**', component: NotFoundComponent },
+];`)
+    );
+    expect(routes.map((r) => [r.path, r.component])).toEqual([
+      ['/', { name: null, spec: './home/home.component' }],
+      ['/login', { name: 'AuthComponent', spec: null }],
+      ['/editor', { name: 'EditorComponent', spec: './editor.component' }],
+      ['/editor/:slug', { name: 'EditorComponent', spec: './editor.component' }],
+    ]);
+    expect(mounts.map((m) => [m.prefix, m.spec])).toEqual([['/profile', './profile/profile.routes']]);
+    expect(redirects).toEqual([{ from: '/old', to: '/login', absolute: false }]);
+  });
+
+  it('treats a route with children as a layout: a screen only where no child claims its address', () => {
+    const { routes } = parseAngularRoutes(
+      file(`const routes: Routes = [
+  { path: ':username', component: ProfileComponent, children: [
+      { path: '', loadComponent: () => import('./articles.component') },
+      { path: 'favorites', loadComponent: () => import('./favorites.component') },
+  ] },
+  { path: 'pages', component: PagesComponent, children: [{ path: 'dashboard', component: DashboardComponent }] },
+];
+export default routes;`)
+    );
+    expect(routes.map((r) => [r.path, r.component?.spec ?? r.component?.name, r.layouts.map((l) => l.name)])).toEqual([
+      ['/:username', './articles.component', ['ProfileComponent']],
+      ['/:username/favorites', './favorites.component', ['ProfileComponent']],
+      ['/pages/dashboard', 'DashboardComponent', ['PagesComponent']],
+      ['/pages', 'PagesComponent', []],
+    ]);
+  });
+
+  it('finds the arrays forRoot, forChild, provideRouter and a typed default export hold', () => {
+    for (const body of [
+      `RouterModule.forRoot([{ path: 'a', component: A }])`,
+      `RouterModule.forChild([{ path: 'a', component: A }])`,
+      `bootstrapApplication(App, { providers: [provideRouter([{ path: 'a', component: A }])] })`,
+      `export default [{ path: 'a', component: A }] satisfies Routes;`,
+      `const table = [{ path: 'a', component: A }] as Routes;`,
+    ]) {
+      expect(parseAngularRoutes(file(body)).routes.map((r) => r.path)).toEqual(['/a']);
+    }
+    // An array that is not a routes array, in a file that imports the router.
+    expect(parseAngularRoutes(file(`const tabs = [{ path: 'a', component: A }];`)).routes).toEqual([]);
+    // No router import, no routes.
+    expect(parseAngularRoutes(`export const routes = [{ path: 'a', component: A }];`).routes).toEqual([]);
+  });
+
+  it('keeps a constant path as a placeholder for the cross-file pass, and reads $localize defaults', () => {
+    const { routes, redirects } = parseAngularRoutes(
+      file(`export const routes: Routes = [
+  { path: internalRoutes.account.path, component: AccountComponent },
+  { path: $localize\`:kebab-case@@routes.about:about\`, component: AboutComponent },
+  { path: '**', redirectTo: 'home', pathMatch: 'full' },
+];`)
+    );
+    expect(routes.map((r) => r.path)).toEqual(['/{internalRoutes.account.path}', '/about']);
+    expect(redirects).toEqual([{ from: '/**', to: '/home', absolute: false }]);
+  });
+});
+
+describe('Angular destinations', () => {
+  it('reads a static string: literals, $localize defaults and + between them', () => {
+    expect(staticString(`'/' + $localize\`:kebab-case@@routes.about:about\``)).toBe('/about');
+    expect(staticString(`'/editor/' + slug`)).toBeNull();
+    expect(localizeDefault('$localize`Access`')).toBe('Access');
+  });
+
+  it('reads an absolute command array, holes for what is computed, and nothing for a relative or all-hole one', () => {
+    expect(commandsHref(`['/article', article.slug]`)?.display).toBe('/article/${…}');
+    expect(commandsHref(`['/profile', p.username, 'favorites']`)?.display).toBe('/profile/${…}/favorites');
+    expect(commandsHref(`['/']`)?.display).toBe('/');
+    expect(commandsHref(`['../', id]`)).toBeNull();
+    expect(commandsHref(`['edit']`)).toBeNull();
+    // Nothing static: it would match any route of its length.
+    expect(commandsHref('[`/${a}`, b, c]')).toBeNull();
+  });
+});
+
+describe('what a template reads at render', () => {
+  const uses = (template: string) => templateMemberUses(template).map((u) => `${u.name}${u.call ? '()' : ''} ${u.via}`);
+
+  it('reads property bindings, interpolations, structural directives, control flow and @let', () => {
+    expect(uses(`<button (click)="cycle()" [attr.aria-label]="label()"><i [name]="icon()"></i></button>`)).toEqual([
+      'label() [attr.aria-label]',
+      'icon() [name]',
+    ]);
+    expect(uses(`<p *ngIf="isOpen(); else closed">{{ count() }} {{ total }}</p><ng-template #closed></ng-template>`)).toEqual([
+      'isOpen() *ngIf',
+      'count() {{ }}',
+      'total {{ }}',
+    ]);
+    expect(uses(`@if (loading()) { x } @else if (failed()) { y } @switch (mode()) { @case (Mode.A) { a } }`)).toEqual([
+      'loading() @if',
+      'failed() @else if',
+      'mode() @switch',
+      'Mode @case',
+    ]);
+    // `on timer(5s)` is a trigger, not a call.
+    expect(uses(`@defer (on viewport; when ready(); prefetch on timer(5s)) { x }`)).toEqual(['ready() @defer']);
+    expect(uses(`@let total = price() * quantity; <input [(ngModel)]="title">`)).toEqual(['price() @let', 'quantity @let', 'title [(ngModel)]']);
+  });
+
+  it("leaves out a pipe, an object key, another object's member, a string, a comment and an event binding", () => {
+    expect(uses(`{{ total | currency: code() }} <i [ngClass]="{ active: isActive() }" [x]="form.reset() || this.own()"></i>`)).toEqual([
+      'total {{ }}',
+      'code() {{ }}',
+      'isActive() [ngClass]',
+      'form [x]',
+      'own() [x]',
+    ]);
+    expect(uses(`<!-- {{ legacy() }} <b [x]="old()"></b> --> {{ 'quoted()' }} <b (click)="save()"></b>`)).toEqual([]);
+    // A template literal's text is a string; its holes are expressions.
+    expect(uses('<td [class.today]="isToday(`${key}-${formatDay(day)}`)" [title]="`quoted()`"></td>')).toEqual([
+      'isToday() [class.today]',
+      'key [class.today]',
+      'formatDay() [class.today]',
+      'day [class.today]',
+    ]);
+  });
+
+  it('leaves out the names the template declares, where they are visible', () => {
+    // A microsyntax's locals, keys and context names belong to the directive.
+    expect(uses(`<li *ngFor="let item of items(); let i = index; trackBy: trackById" [title]="item.name">{{ i }}</li>`)).toEqual([
+      'items() *ngFor',
+      'trackById *ngFor',
+    ]);
+    // An alias belongs to the body, not to the condition that names it.
+    expect(uses(`@if (user(); as user) { {{ user.name }} }`)).toEqual(['user() @if']);
+    expect(uses(`<div *ngIf="user() as user">{{ user.name }}</div>`)).toEqual(['user() *ngIf']);
+    // `track` sees the loop's own names.
+    expect(uses(`@for (item of items(); track item.id; let odd = $odd) { {{ item.name }} {{ odd }} }`)).toEqual(['items() @for']);
+    expect(uses(`@let total = price(); {{ total }}`)).toEqual(['price() @let']);
+    // A reference variable is seen across the template, even before it is declared.
+    expect(uses(`<b [x]="input.value"></b><input #input>`)).toEqual([]);
+    expect(uses(`<ng-template let-row let-i="index">{{ row.name }} {{ i }}</ng-template>`)).toEqual([]);
+  });
+
+  it('splits a microsyntax into its expressions and its locals', () => {
+    expect(readMicrosyntax('let item of items | async; index as i; trackBy: trackFn')).toEqual({
+      expressions: [
+        { at: 12, text: 'items | async' },
+        { at: 48, text: 'trackFn' },
+      ],
+      locals: ['item', 'i'],
+    });
+    expect(readMicrosyntax('user$ | async as user; else loading')).toEqual({
+      expressions: [
+        { at: 0, text: 'user$ | async ' },
+        { at: 28, text: 'loading' },
+      ],
+      locals: ['user'],
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// End to end
+// ---------------------------------------------------------------------------
+
+const projects: string[] = [];
+afterAll(() => {
+  for (const p of projects.splice(0)) fs.rmSync(p, { recursive: true, force: true });
+});
+
+const component = (name: string, selector: string, template: string, body = '') => `import { Component } from '@angular/core';
+import { Router } from '@angular/router';
+@Component({
+  selector: '${selector}',
+  ${template.startsWith('./') ? `templateUrl: '${template}'` : `template: \`${template}\``},
+})
+export class ${name} {
+  constructor(private readonly router: Router) {}
+${body}
+}
+`;
+
+describe('an Angular app, indexed', () => {
+  let cg: CodeGraph;
+  let root: string;
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-angular-'));
+    projects.push(root);
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ dependencies: { '@angular/core': '^19.0.0', '@angular/router': '^19.0.0' } }),
+      'src/app/routes.constants.ts': `export const internalRoutes = {
+  account: { path: 'account', routerLink: ['/account'], subRoutes: { access: { path: 'access', routerLink: (id: string) => ['/account', 'access', id] } } },
+  about: { path: $localize\`:kebab-case@@routes.about:about\`, routerLink: ['/' + $localize\`:kebab-case@@routes.about:about\`] },
+};
+`,
+      'src/app/app.routes.ts': `import { Routes } from '@angular/router';
+import { AuthComponent } from './auth/auth.component';
+import { internalRoutes } from './routes.constants';
+const { about } = internalRoutes;
+export const routes: Routes = [
+  { path: 'home', loadComponent: () => import('./home/home.component') },
+  { path: 'login', component: AuthComponent },
+  { path: about.path, loadComponent: () => import('./about/about.component').then((m) => m.AboutComponent) },
+  { path: internalRoutes.account.path, loadChildren: () => import('./account/account.routes') },
+  { path: 'admin', loadChildren: () => import('./admin/admin.module').then((m) => m.AdminModule) },
+  { path: '**', redirectTo: 'home' },
+];
+`,
+      'src/app/account/account.routes.ts': `import { Routes } from '@angular/router';
+import { AccountComponent } from './account.component';
+import { AccessComponent } from './access.component';
+import { internalRoutes } from '../routes.constants';
+export default [
+  { path: '', component: AccountComponent, children: [
+      { path: '', loadComponent: () => import('./overview.component') },
+      { path: internalRoutes.account.subRoutes.access.path + '/:id', component: AccessComponent },
+  ] },
+] satisfies Routes;
+`,
+      // An NgModule's routes live in the routing module it imports.
+      'src/app/admin/admin.module.ts': `import { NgModule } from '@angular/core';
+import { AdminRoutingModule } from './admin-routing.module';
+@NgModule({ imports: [AdminRoutingModule] })
+export class AdminModule {}
+`,
+      'src/app/admin/admin-routing.module.ts': `import { NgModule } from '@angular/core';
+import { RouterModule, Routes } from '@angular/router';
+import { AdminUsersComponent } from './admin-users.component';
+const routes: Routes = [{ path: '', redirectTo: 'users', pathMatch: 'full' }, { path: 'users', component: AdminUsersComponent }];
+@NgModule({ imports: [RouterModule.forChild(routes)], exports: [RouterModule] })
+export class AdminRoutingModule {}
+`,
+      'src/app/home/home.component.ts': component('HomeComponent', 'app-home', './home.component.html', `  open(slug: string) { this.router.navigate(['/login']); }
+  more() { this.router.navigate([], { queryParams: { page: 2 } }); }`).replace('export class', 'export default class'),
+      'src/app/home/home.component.html': `<app-card></app-card>
+<a routerLink="/login">Sign in</a>
+<a [routerLink]="routerLinkAbout">About</a>
+<a [routerLink]="['/account', 'access', 7]">Access</a>
+<a routerLink="relative">Relative</a>
+`,
+      'src/app/shared/card.component.ts': component(
+        'CardComponent',
+        'app-card',
+        `<button (click)="save()">Save</button><input [(ngModel)]="name" /><a (click)="closed.emit(true)">x</a>`,
+        `  name = '';
+  save() { this.router.navigate(internalRoutes.account.subRoutes.access.routerLink('me')); }`
+      ).replace(
+        "import { Router } from '@angular/router';",
+        "import { Router } from '@angular/router';\nimport { internalRoutes } from '../routes.constants';"
+      ),
+      'src/app/auth/auth.component.ts': component('AuthComponent', 'app-auth', `<a routerLink="/home">Home</a>`, `  done() { this.router.navigate(['/']); }`),
+      'src/app/about/about.component.ts': component('AboutComponent', 'app-about', `<p>About</p>`),
+      // A tab bar built in the class, handed to a tabs component that binds each `tab.routerLink`.
+      'src/app/account/account.component.ts': component(
+        'AccountComponent',
+        'app-account',
+        `<a [routerLink]="['/login']">Log out</a><app-tabs [tabs]="tabs"></app-tabs><router-outlet></router-outlet>`,
+        `  tabs = [{ label: 'Access', routerLink: internalRoutes.account.subRoutes.access.routerLink('me') }];`
+      ).replace("import { Router } from '@angular/router';", "import { Router } from '@angular/router';\nimport { internalRoutes } from '../routes.constants';"),
+      'src/app/account/overview.component.ts': component('OverviewComponent', 'app-overview', `<p>Overview</p>`).replace('export class', 'export default class'),
+      'src/app/account/access.component.ts': component('AccessComponent', 'app-access', `<p>Access</p>`),
+      'src/app/admin/admin-users.component.ts': component('AdminUsersComponent', 'app-admin-users', `<p>Users</p>`),
+    };
+    files['src/app/home/home.component.ts'] = files['src/app/home/home.component.ts']!.replace(
+      "import { Router } from '@angular/router';",
+      "import { Router } from '@angular/router';\nimport { internalRoutes } from '../routes.constants';"
+    ).replace('  constructor(', '  protected readonly routerLinkAbout = internalRoutes.about.routerLink;\n  constructor(');
+    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 });
+  });
+  afterAll(() => cg.close());
+
+  const routeOf = (id: string) => cg.getNode(id)?.name;
+
+  it('names each screen by the path a user takes to it, bound to its component', () => {
+    const routes = cg
+      .getNodesByKind('route')
+      .map((r) => {
+        const bound = cg.getOutgoingEdgesFrom([r.id], ['references']).map((e) => `${(e.metadata as Record<string, unknown>)?.layout ? 'layout ' : ''}${cg.getNode(e.target)?.name}`);
+        return `${r.name} -> ${bound.sort().join(', ')}`;
+      })
+      .sort();
+    expect(routes).toEqual([
+      '/about -> AboutComponent',
+      '/account -> OverviewComponent, layout AccountComponent',
+      '/account/access/:id -> AccessComponent, layout AccountComponent',
+      '/admin/users -> AdminUsersComponent',
+      '/home -> HomeComponent',
+      '/login -> AuthComponent',
+    ]);
+  });
+
+  it('draws navigation from calls and routerLink, through constants, properties and redirects', () => {
+    const navigations = cg
+      .getNodesByKind('route')
+      .flatMap((r) => cg.getIncomingEdgesTo([r.id], ['navigates']).map((e) => `${cg.getNode(e.source)?.name} -> ${r.name} (${(e.metadata as Record<string, unknown>).navMethod})`))
+      .sort();
+    expect(navigations).toEqual([
+      // `navigate(['/'])`: `/` matches no route, and the root `**` redirect sends it home.
+      'AccountComponent -> /account/access/:id (routerLink)',
+      'AccountComponent -> /login (routerLink)',
+      'AuthComponent -> /home (routerLink)',
+      'HomeComponent -> /about (routerLink)',
+      'HomeComponent -> /account/access/:id (routerLink)',
+      'HomeComponent -> /login (routerLink)',
+      'done -> /home (navigate)',
+      'open -> /login (navigate)',
+      // A route constant that builds its commands: `access.routerLink('me')`.
+      'save -> /account/access/:id (navigate)',
+    ]);
+  });
+
+  it('links a template to the components it renders', () => {
+    const renders = cg
+      .getNodesByKind('class')
+      .flatMap((c) =>
+        cg
+          .getOutgoingEdgesFrom([c.id], ['calls'])
+          .filter((e) => (e.metadata as Record<string, unknown> | undefined)?.synthesizedBy === 'angular-template')
+          .map((e) => `${c.name} -> ${cg.getNode(e.target)?.name} <${(e.metadata as Record<string, unknown>).via}>`)
+      );
+    expect(renders).toEqual(['HomeComponent -> CardComponent <app-card>']);
+  });
+
+  it("links a template's event bindings to the component's own methods, the binding as the trigger", async () => {
+    const bindings = cg
+      .getNodesByKind('class')
+      .flatMap((c) =>
+        cg
+          .getOutgoingEdgesFrom([c.id], ['calls'])
+          .filter((e) => (e.metadata as Record<string, unknown> | undefined)?.synthesizedBy === 'angular-event')
+          .map((e) => {
+            const meta = e.metadata as Record<string, unknown>;
+            return `${c.name} -> ${cg.getNode(e.target)?.name} ${JSON.stringify(meta.trigger)}`;
+          })
+      );
+    // `[(ngModel)]` is a two-way binding and `closed.emit()` raises the component's own output: neither calls a method.
+    expect(bindings).toEqual(['CardComponent -> save {"kind":"prop","name":"(click)","of":"button"}']);
+
+    const home = cg.getNodesByKind('route').find((r) => r.name === '/home')!;
+    const payload = await buildSteps(cg, root, new URLSearchParams({ anchor: home.id }));
+    const save = payload.steps.find((st) => st.label === 'save');
+    expect(save?.trigger).toMatchObject({ kind: 'prop', name: '(click)', of: 'button', in: 'CardComponent' });
+  });
+
+  it("draws the Screens picture: a child component's navigation on its screen, a layout's on each screen inside it", async () => {
+    const payload = await buildScreens(cg, root);
+    expect(payload.routed).toBe(true);
+    const links = payload.links.map((l) => `${routeOf(l.from) ?? cg.getNode(l.from)?.name} -> ${routeOf(l.to)}${l.via.length ? ` via ${l.via.map((v) => v.name).join('>')}` : ''}`).sort();
+    expect(links).toEqual([
+      '/account -> /account/access/:id',
+      '/account -> /login',
+      '/account/access/:id -> /account/access/:id',
+      '/account/access/:id -> /login',
+      '/home -> /about',
+      '/home -> /account/access/:id',
+      '/home -> /account/access/:id via CardComponent>save',
+      '/home -> /login',
+      '/home -> /login via open',
+      '/login -> /home',
+      '/login -> /home via done',
+    ]);
+  });
+});
+
+describe("an Angular template's bindings, indexed", () => {
+  let cg: CodeGraph;
+  let root: string;
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-angular-bindings-'));
+    projects.push(root);
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ dependencies: { '@angular/core': '^19.0.0', '@angular/router': '^19.0.0' } }),
+      'src/app/app.routes.ts': `import { Routes } from '@angular/router';
+import { TasksComponent } from './tasks/tasks.component';
+export const routes: Routes = [{ path: 'tasks', component: TasksComponent }];
+`,
+      // An inline template: its bindings are written in the class's own file.
+      'src/app/nav/nav.component.ts': `import { Component, signal } from '@angular/core';
+@Component({
+  selector: 'app-nav',
+  template: \`<nav>
+    <app-theme-toggle [class.open]="isOpen()" />
+  </nav>\`,
+})
+export class NavComponent {
+  isOpen = signal(false);
+}
+`,
+      'src/app/theme-toggle/theme-toggle.component.ts': `import { Component, computed, signal } from '@angular/core';
+@Component({ selector: 'app-theme-toggle', templateUrl: './theme-toggle.component.html' })
+export class ThemeToggleComponent {
+  private readonly theme = signal<'light' | 'dark'>('light');
+  icon = computed(() => (this.theme() === 'dark' ? 'moon' : 'sun'));
+  label = computed(() => (this.theme() === 'dark' ? 'Dark' : 'Light'));
+  cycle(): void {
+    this.theme.set(this.theme() === 'dark' ? 'light' : 'dark');
+  }
+  unused(): void {}
+}
+`,
+      'src/app/theme-toggle/theme-toggle.component.html': `<button (click)="cycle()" [attr.aria-label]="label()">
+  <lucide-icon [name]="icon()"></lucide-icon>
+</button>
+`,
+      'src/app/tasks/tasks.component.ts': `import { Component, computed, signal } from '@angular/core';
+@Component({ selector: 'app-tasks', templateUrl: './tasks.component.html' })
+export class TasksComponent {
+  lists = signal<{ id: number; title: string; items: { done: boolean }[] }[]>([]);
+  selectedListId = signal<number | null>(null);
+  selected = computed(() => this.lists().find((l) => l.id === this.selectedListId()));
+  editing = signal(false);
+  title = 'Tasks';
+  form = { reset() {} };
+  days = Array.from({ length: 3 }, (_, i) => i + 1);
+  row = computed(() => 0);
+  nameInput = (value: string) => value;
+
+  get canSave(): boolean {
+    return this.lists().length > 0;
+  }
+  remainingItems(list: { items: { done: boolean }[] }): number {
+    return list.items.filter((i) => !i.done).length;
+  }
+  trackById(index: number, list: { id: number }): number {
+    return list.id;
+  }
+  displayFn(list: { title: string }): string {
+    return list.title;
+  }
+  format(value: string): string {
+    return value;
+  }
+  reset(): void {}
+  set(): void {}
+  legacy(): string {
+    return '';
+  }
+  quoted(): string {
+    return '';
+  }
+  save(): void {}
+}
+`,
+      'src/app/tasks/tasks.component.html': `<!-- {{ legacy() }} -->
+<h1 [title]="title">{{ 'quoted()' }}</h1>
+<input #nameInput [value]="nameInput.value" (blur)="selected() && save()" />
+@if (editing()) {
+  <span>editing</span>
+}
+<ul>
+  @for (list of lists(); track trackById($index, list)) {
+    <li [class.active]="list.id === selectedListId()" (click)="selectedListId.set(list.id)">
+      {{ list.title | format }} <small>{{ remainingItems(list) }}</small>
+    </li>
+  }
+</ul>
+@for (row of [selected()]; track row) {
+  <b>{{ row?.title }}</b>
+}
+@for (day of days; track day) {
+  <i>{{ day }}</i>
+}
+<mat-autocomplete [displayWith]="displayFn"></mat-autocomplete>
+<button [disabled]="!canSave" (click)="form.reset()">Reset</button>
+`,
+    };
+    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 });
+  });
+  afterAll(() => cg.close());
+
+  /** `Source -> target [kind] via @ file:line` for every template edge of one mechanism. */
+  const templateEdges = (synthesizedBy: string) =>
+    cg
+      .getNodesByKind('class')
+      .flatMap((c) =>
+        cg
+          .getOutgoingEdgesFrom([c.id], ['calls', 'references'])
+          .filter((e) => (e.metadata as Record<string, unknown> | undefined)?.synthesizedBy === synthesizedBy)
+          .map((e) => {
+            const meta = e.metadata as Record<string, unknown>;
+            const target = cg.getNode(e.target)!;
+            return `${c.name} -> ${target.kind} ${target.name} [${e.kind}${meta.fnRef ? ' fnRef' : ''}] ${String(meta.via)} @ ${String(meta.registeredAt)}`;
+          })
+      )
+      .sort();
+
+  it("links each binding's own-member call — and a callable it only reads — to the component, at the binding's line", () => {
+    expect(templateEdges('angular-binding')).toEqual([
+      'NavComponent -> property isOpen [calls] [class.open] @ src/app/nav/nav.component.ts:5',
+      // A getter runs when it is read.
+      'TasksComponent -> method canSave [calls] [disabled] @ src/app/tasks/tasks.component.html:21',
+      // A field a call filled is read, not called.
+      'TasksComponent -> method days [references] @for @ src/app/tasks/tasks.component.html:17',
+      // A function handed to a child is a function reference.
+      'TasksComponent -> method displayFn [references fnRef] [displayWith] @ src/app/tasks/tasks.component.html:20',
+      'TasksComponent -> method remainingItems [calls] {{ }} @ src/app/tasks/tasks.component.html:10',
+      'TasksComponent -> method trackById [calls] @for @ src/app/tasks/tasks.component.html:8',
+      // A signal is a field, and calling it reads it.
+      'TasksComponent -> property editing [calls] @if @ src/app/tasks/tasks.component.html:4',
+      'TasksComponent -> property lists [calls] @for @ src/app/tasks/tasks.component.html:8',
+      'TasksComponent -> property selectedListId [calls] [class.active] @ src/app/tasks/tasks.component.html:9',
+      'ThemeToggleComponent -> method icon [calls] [name] @ src/app/theme-toggle/theme-toggle.component.html:2',
+      'ThemeToggleComponent -> method label [calls] [attr.aria-label] @ src/app/theme-toggle/theme-toggle.component.html:1',
+    ]);
+    // An inline template's edge sits on its own line of the class's file.
+    const nav = cg.getNodesByKind('class').find((c) => c.name === 'NavComponent')!;
+    expect(cg.getOutgoingEdgesFrom([nav.id], ['calls']).find((e) => cg.getNode(e.target)?.name === 'isOpen')?.line).toBe(5);
+  });
+
+  it('links nothing for a field read, a pipe, a member of another object, a comment, a string or a name the template declares', () => {
+    const tasks = cg.getNodesByKind('class').find((c) => c.name === 'TasksComponent')!;
+    const linked = cg.getOutgoingEdgesFrom([tasks.id], ['calls', 'references']).map((e) => cg.getNode(e.target)?.name);
+    for (const name of ['title', 'format', 'reset', 'set', 'legacy', 'quoted', 'row', 'nameInput']) expect(linked).not.toContain(name);
+    // A member the event bindings already link keeps that edge: `selected()` is both.
+    expect(templateEdges('angular-event')).toEqual([
+      'TasksComponent -> method save [calls] (blur) @ src/app/tasks/tasks.component.html:3',
+      'TasksComponent -> method selected [calls] (blur) @ src/app/tasks/tasks.component.html:3',
+      'ThemeToggleComponent -> method cycle [calls] (click) @ src/app/theme-toggle/theme-toggle.component.html:1',
+    ]);
+  });
+
+  it('takes members a template uses off the dead-code list, and keeps the ones it does not', () => {
+    const listed = buildDeadCodeReport(cg, { limit: 100 }).entries.map((e) => e.node.name);
+    expect(listed).toContain('unused');
+    expect(listed).not.toContain('icon');
+    expect(listed).not.toContain('label');
+    expect(listed).not.toContain('remainingItems');
+    expect(listed).not.toContain('canSave');
+  });
+
+  it('draws a binding as render-time work in Steps, not as something the user triggers', async () => {
+    const screen = cg.getNodesByKind('route').find((r) => r.name === '/tasks')!;
+    const payload = await buildSteps(cg, root, new URLSearchParams({ anchor: screen.id }));
+    const labels = payload.steps.map((s) => s.label);
+    expect(payload.steps.find((s) => s.label === 'save')?.trigger).toMatchObject({ kind: 'prop', name: '(blur)', of: 'input' });
+    for (const name of ['remainingItems', 'canSave', 'trackById', 'lists']) expect(labels).not.toContain(name);
+  });
+});
+
+describe('an Angular workspace split across libraries', () => {
+  const roots: string[] = [];
+  afterAll(() => {
+    for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+  });
+
+  async function project(files: Record<string, string>): Promise<CodeGraph> {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-angular-ws-'));
+    roots.push(root);
+    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);
+    }
+    return CodeGraph.init(root, { index: true });
+  }
+  const routeNames = (cg: CodeGraph) => cg.getNodesByKind('route').map((n) => n.name).sort();
+  const navs = (cg: CodeGraph) =>
+    cg
+      .getNodesByKind('route')
+      .flatMap((r) => cg.getIncomingEdges(r.id).filter((e) => e.kind === 'navigates').map((e) => `${cg.getNode(e.source)!.name} -> ${r.name}`))
+      .sort();
+  const component = (name: string, selector: string, template: string) => `import { Component } from '@angular/core';
+@Component({ selector: '${selector}', template: \`${template}\` })
+export class ${name} {}
+`;
+
+  it('angular-spotify: Nx libraries behind barrels, `(await import(…)).M`, a class-static path constant', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'ws', dependencies: { '@angular/core': '*', '@angular/router': '*' } }),
+      'nx.json': '{}',
+      'tsconfig.base.json': JSON.stringify({
+        compilerOptions: {
+          paths: {
+            '@ws/home': ['libs/home/src/index.ts'],
+            '@ws/lyrics': ['libs/lyrics/src/index.ts'],
+            '@ws/utils': ['libs/utils/src/index.ts'],
+          },
+        },
+      }),
+      'libs/utils/src/index.ts': `export * from './lib/router-util';\n`,
+      'libs/utils/src/lib/router-util.ts': `export class RouterUtil {
+  static Configuration = { Lyrics: 'lyrics' };
+}
+`,
+      'libs/shell/src/lib/shell.routes.ts': `import { Route } from '@angular/router';
+import { RouterUtil } from '@ws/utils';
+
+export const shellRoutes: Route[] = [
+  { path: '', loadChildren: async () => (await import('@ws/home')).HomeModule },
+  { path: RouterUtil.Configuration.Lyrics, loadChildren: async () => (await import('@ws/lyrics')).LyricsModule },
+];
+`,
+      'libs/home/src/index.ts': `export * from './lib/home.module';\n`,
+      'libs/home/src/lib/home.module.ts': `import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { HomeComponent } from './home.component';
+@NgModule({ imports: [RouterModule.forChild([{ path: '', component: HomeComponent }])] })
+export class HomeModule {}
+`,
+      'libs/home/src/lib/home.component.ts': component('HomeComponent', 'as-home', '<a routerLink="/lyrics">Lyrics</a>'),
+      'libs/lyrics/src/index.ts': `export * from './lib/lyrics.module';\n`,
+      'libs/lyrics/src/lib/lyrics.module.ts': `import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { LyricsComponent } from './lyrics.component';
+@NgModule({ imports: [RouterModule.forChild([{ path: '', component: LyricsComponent }])] })
+export class LyricsModule {}
+`,
+      'libs/lyrics/src/lib/lyrics.component.ts': component('LyricsComponent', 'as-lyrics', '<a routerLink="/">Home</a>'),
+    });
+    try {
+      expect(routeNames(cg)).toEqual(['/', '/lyrics']);
+      // A template in one library links to a screen another library declares.
+      expect(navs(cg)).toEqual(['HomeComponent -> /lyrics', 'LyricsComponent -> /']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('jira-clone: a template-literal path, a redirect in a file that only mounts, navigate() from the root', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'jira', dependencies: { '@angular/core': '*', '@angular/router': '*' } }),
+      'angular.json': '{}',
+      'src/app/app.routes.ts': `import { Routes } from '@angular/router';
+export const appRoutes: Routes = [
+  { path: 'project', loadChildren: () => import('./project/project.routes').then((m) => m.PROJECT_ROUTES) },
+  { path: '', redirectTo: 'project', pathMatch: 'full' },
+];
+`,
+      'src/app/project/config/const.ts': `export class ProjectConst {
+  static readonly IssueId = 'issueId';
+}
+`,
+      'src/app/project/project.routes.ts': `import { Routes } from '@angular/router';
+import { ProjectComponent } from './project.component';
+import { BoardComponent } from './board.component';
+import { IssueComponent } from './issue.component';
+import { ProjectConst } from './config/const';
+export const PROJECT_ROUTES: Routes = [
+  {
+    path: '',
+    component: ProjectComponent,
+    children: [
+      { path: 'board', component: BoardComponent },
+      { path: \`issue/:\${ProjectConst.IssueId}\`, component: IssueComponent },
+      { path: '', redirectTo: 'board', pathMatch: 'full' },
+    ],
+  },
+];
+`,
+      'src/app/project/project.component.ts': component('ProjectComponent', 'j-project', '<router-outlet></router-outlet>'),
+      'src/app/project/board.component.ts': `import { Component } from '@angular/core';
+import { Router } from '@angular/router';
+@Component({ selector: 'j-board', template: '<div></div>' })
+export class BoardComponent {
+  constructor(private _router: Router) {}
+  openIssuePage(issueId: string) {
+    this._router.navigate(['project', 'issue', issueId]);
+  }
+}
+`,
+      'src/app/project/issue.component.ts': `import { Component } from '@angular/core';
+import { Router } from '@angular/router';
+@Component({ selector: 'j-issue', template: '<div></div>' })
+export class IssueComponent {
+  constructor(private _router: Router) {}
+  backHome() {
+    this._router.navigate(['/']);
+  }
+}
+`,
+    });
+    try {
+      expect(routeNames(cg)).toEqual(['/project/board', '/project/issue/:issueId']);
+      expect(navs(cg)).toEqual(['backHome -> /project/board', 'openIssuePage -> /project/issue/:issueId']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/astro-component-markup-only.test.ts b/__tests__/astro-component-markup-only.test.ts
new file mode 100644
index 0000000000..117041c2ed
--- /dev/null
+++ b/__tests__/astro-component-markup-only.test.ts
@@ -0,0 +1,55 @@
+/**
+ * An Astro component is used in Astro markup, so the component name
+ * heuristic applies to `.astro` files only: astrowind's `types.d.ts`
+ * (`image?: Image`, `callToAction?: CallToAction`) and starlight's
+ * Playwright `page: Page` went to `Image.astro`, `CallToAction.astro` and
+ * `Page.astro`.
+ */
+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-astro-markup-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'site', private: true, dependencies: { astro: '^5.0.0' }, devDependencies: { '@playwright/test': '^1.0.0' } }),
+    'astro.config.mjs': 'export default {};\n',
+    'src/components/Page.astro': `---
+const { title } = Astro.props;
+---
+<main>{title}</main>
+`,
+    'tests/test-utils.ts': `import { type Page } from '@playwright/test';
+
+export class StarlightPage {
+  private readonly page: Page;
+  constructor(page: Page) {
+    this.page = page;
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Astro components', () => {
+  it('are never what a TypeScript type name means', () => {
+    const ids = cg.getNodesInFile('tests/test-utils.ts').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.filePath);
+    expect(targets).not.toContain('src/components/Page.astro');
+  });
+});
diff --git a/__tests__/c-calls-never-methods.test.ts b/__tests__/c-calls-never-methods.test.ts
new file mode 100644
index 0000000000..1e87966fdb
--- /dev/null
+++ b/__tests__/c-calls-never-methods.test.ts
@@ -0,0 +1,48 @@
+/**
+ * C has no methods and cannot call a C++ one: redis' POSIX `read(fd, buf, n)`
+ * calls and hiredis' function pointer `c->funcs->read(c, buf, …)` all went to
+ * the Qt adapter's `RedisQtAdapter::read` in a C++ header.
+ */
+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-c-methods-'));
+  const files: Record<string, string> = {
+    'deps/hiredis/adapters/qt.hpp': `class RedisQtAdapter {
+public:
+    void read() { }
+};
+`,
+    'src/util.c': `#include <unistd.h>
+
+long slurp(int fd, char *buf, long n) {
+    return read(fd, buf, n);
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('C calls', () => {
+  it('never reach a C++ method', () => {
+    const ids = cg.getNodesInFile('src/util.c').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(targets).not.toContain('RedisQtAdapter::read');
+  });
+});
diff --git a/__tests__/c-cpp-declaration-types.test.ts b/__tests__/c-cpp-declaration-types.test.ts
new file mode 100644
index 0000000000..4ae348593e
--- /dev/null
+++ b/__tests__/c-cpp-declaration-types.test.ts
@@ -0,0 +1,261 @@
+/**
+ * A class, struct, union or enum DEFINED in the type of a C or C++ variable
+ * declaration was never indexed:
+ *
+ *   namespace n { struct Foo { int a; void f() {} } foo; }   // only n::foo
+ *   static struct { int argc; char **argv; } SPT;             // nothing at all
+ *   enum { MODE_IDLE, MODE_BUSY } current_mode;               // no enumerators
+ *
+ * Both extractors handed such a declaration to the variable extractor and
+ * skipped its children, so the type, its methods and its enumerators never
+ * became nodes, a base class defined this way had nothing to resolve to, and
+ * calls on its methods linked to nothing.
+ *
+ * The type is now walked like one written on its own, beside the variables
+ * (which keep their nodes), and the comment above the declaration documents
+ * it. An unnamed one takes the name of the first variable its declaration
+ * declares, as `typedef struct { … } Name;` takes the typedef name: no code
+ * can name the type of `SPT`, only `SPT`. In a C++ file whose tree has errors
+ * the type is walked in the scopes the file's braces open (#2426), and not at
+ * all when the braces don't balance. Runs against the native kernel (when
+ * built) and the wasm extractor, which must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult, Language } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS', 'CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT'] as const;
+
+/** `<kind> <qualifiedName>` for every symbol, file and imports aside. */
+function symbols(result: ExtractionResult): string[] {
+  return result.nodes
+    .filter((n) => n.kind !== 'file' && n.kind !== 'import')
+    .map((n) => `${n.kind} ${n.qualifiedName}`);
+}
+
+/** `<parent> > <child>` for every containment edge below the file. */
+function containment(result: ExtractionResult): string[] {
+  const byId = new Map(result.nodes.map((n) => [n.id, n]));
+  return result.edges
+    .filter((e) => e.kind === 'contains' && byId.get(e.source)?.kind !== 'file')
+    .map((e) => `${byId.get(e.source)?.qualifiedName} > ${byId.get(e.target)?.qualifiedName}`);
+}
+
+describe('a type defined in a C/C++ declaration', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['c', 'cpp']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', file: string, source: string, language: Language): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource(file, source, language);
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract(file, source, language);
+    expect(result, `kernel extraction of ${file}`).not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const eol = (s: string) => (crlf ? s.replace(/\n/g, '\r\n') : s);
+    const label = crlf ? ' (CRLF)' : '';
+
+    it.each(backends)(`C++ classes and structs beside their variables: %s${label}`, (backend) => {
+      const source = [
+        'namespace n {',
+        'struct Foo { int a; void f() {} } foo;',
+        'class Bar { void g() {} } bar, *pbar;',
+        '}',
+        '',
+      ].join('\n');
+      const result = extract(backend, 'src/decl.cpp', eol(source), 'cpp');
+      expect(symbols(result)).toEqual([
+        'struct n::Foo',
+        'method n::Foo::f',
+        'variable n::foo',
+        'class n::Bar',
+        'method n::Bar::g',
+        'variable n::bar',
+      ]);
+      expect(containment(result)).toEqual(['n::Foo > n::Foo::f', 'n::Bar > n::Bar::g']);
+    });
+
+    it.each(backends)(`C structs, unions and enums; an unnamed one takes its variable's name: %s${label}`, (backend) => {
+      const source = [
+        'struct Foo { int a; } foo;',
+        'static struct { int argc; char **argv; } SPT;',
+        'static const struct { const char *name; int code; } errors[] = { { "none", 0 } };',
+        'struct { int x; } *first_point, second_point;',
+        'union { int i; float f; } scratch = { 0 };',
+        'enum { MODE_IDLE, MODE_BUSY } current_mode;',
+        'typedef struct Bar { int c; } Bar;',
+        '',
+      ].join('\n');
+      const result = extract(backend, 'src/decl.c', eol(source), 'c');
+      expect(symbols(result)).toEqual([
+        'struct Foo',
+        'struct SPT',
+        'struct errors',
+        'constant errors',
+        'struct first_point',
+        'variable first_point',
+        'union scratch',
+        'variable scratch',
+        'enum current_mode',
+        'enum_member current_mode::MODE_IDLE',
+        'enum_member current_mode::MODE_BUSY',
+        'struct Bar',
+      ]);
+    });
+
+    it.each(backends)(`a type whose declaration declares no variable stays unnamed: %s${label}`, (backend) => {
+      // A function's return type: naming it after the function would be wrong.
+      const result = extract(backend, 'src/proto.c', eol('struct { int unused; } make_unnamed(void);\n'), 'c');
+      expect(symbols(result)).toEqual(['struct <anonymous>']);
+    });
+
+    it.each(backends)(`the comment above the declaration documents the type: %s${label}`, (backend) => {
+      const source = [
+        'namespace app {',
+        '/** The handler registry. */',
+        'struct Registry { int size() const { return 2; } } registry;',
+        '}',
+        '',
+      ].join('\n');
+      const result = extract(backend, 'src/registry.cc', eol(source), 'cpp');
+      const docs = result.nodes
+        .filter((n) => n.name === 'Registry' || n.name === 'registry')
+        .map((n) => `${n.kind} ${n.docstring}`);
+      expect(docs).toEqual(['struct The handler registry.', 'variable The handler registry.']);
+    });
+
+    it.each(backends)(`an unnamed type in a function body takes its variable's name too: %s${label}`, (backend) => {
+      const source = 'int hits(void) {\n  static struct { int count; } local_stats;\n  return ++local_stats.count;\n}\n';
+      const result = extract(backend, 'src/stats.c', eol(source), 'c');
+      expect(symbols(result)).toEqual(['function hits', 'struct hits::local_stats']);
+    });
+
+    it.each(backends)(`a file the parser misreads: C keeps the type, C++ needs balanced braces: %s${label}`, (backend) => {
+      // The kernel defers a file whose tree has errors to wasm; its
+      // error-extract hatch walks one anyway, and must agree.
+      process.env.CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT = '1';
+      const c = extract(backend, 'src/spt.c', eol('static struct { int argc; } SPT;\nint broken( { return 1; }\n'), 'c');
+      expect(symbols(c)).toContain('struct SPT');
+      // A C++ file with errors is walked in the scopes its braces open, so the
+      // class lands in its namespace. When the braces don't balance there are
+      // no scopes to trust, and error recovery can close a namespace or a
+      // class at the wrong `}`: the variable is kept and the class not walked.
+      const config = 'namespace n {\nstruct Config { int retries; void apply() {} } config;\n}\n';
+      const balanced = extract(backend, 'src/config.cc', eol(`${config}int broken( { return 1; }\n`), 'cpp');
+      expect(symbols(balanced)).toEqual(['struct n::Config', 'method n::Config::apply', 'variable n::config']);
+      const unbalanced = extract(backend, 'src/config2.cc', eol(`${config}int broken() { return 1;\n`), 'cpp');
+      expect(symbols(unbalanced)).toEqual(['variable n::config', 'function broken']);
+    });
+
+    it.each(backends)(`a function value in the type's body is captured once, by the type: %s${label}`, (backend) => {
+      const source = [
+        'void on_open() {}',
+        'struct Handlers { void (*all[1])() = {&on_open}; } handlers;',
+        '',
+      ].join('\n');
+      const result = extract(backend, 'src/handlers.cc', eol(source), 'cpp');
+      const byId = new Map(result.nodes.map((n) => [n.id, n]));
+      const refs = result.unresolvedReferences
+        .filter((r) => r.referenceKind === 'function_ref')
+        .map((r) => `${byId.get(r.fromNodeId)?.name} ${r.referenceName}`);
+      expect(refs).toEqual(['Handlers on_open']);
+    });
+  }
+});
+
+describe('an indexed C/C++ project with types defined in declarations', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    cg?.destroy();
+    cg = undefined;
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+    root = '';
+  });
+
+  it('links base classes and calls to them, and finds an unnamed struct by its variable', async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-declaration-types-'));
+    const files: Record<string, string> = {
+      'src/registry.cc': [
+        'namespace app {',
+        'struct Registry { int size() const { return 2; } } registry;',
+        'class Base { public: virtual int run() { return 1; } } base_instance;',
+        'class Worker : public Base { public: int run() override { return registry.size(); } };',
+        'int tick() { Worker w; return w.run() + registry.size(); }',
+        '}',
+        '',
+      ].join('\n'),
+      'src/setproctitle.c': [
+        '/* Saved argv. */',
+        'static struct { int argc; char **argv; } SPT;',
+        'int spt_init(int argc) { SPT.argc = argc; return SPT.argc; }',
+        '',
+      ].join('\n'),
+    };
+    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 });
+    const graph = cg;
+    const one = (qualifiedName: string) => {
+      const found = graph.getNodesByName(qualifiedName.split('::').pop()!).filter((n) => n.qualifiedName === qualifiedName);
+      expect(found, qualifiedName).toHaveLength(1);
+      return found[0]!;
+    };
+    const edges = (id: string, kind: 'calls' | 'extends') =>
+      graph
+        .getIncomingEdgesTo([id], [kind])
+        .map((e) => graph.getNode(e.source)?.qualifiedName)
+        .sort();
+
+    expect(edges(one('app::Registry::size').id, 'calls')).toEqual(['app::Worker::run', 'app::tick']);
+    expect(edges(one('app::Base').id, 'extends')).toEqual(['app::Worker']);
+
+    const spt = graph.searchNodes('SPT', { limit: 5 }).map((r) => `${r.node.kind} ${r.node.name}`);
+    expect(spt).toContain('struct SPT');
+    expect(one('SPT').docstring).toBe('Saved argv.');
+  }, 60_000);
+});
diff --git a/__tests__/c-cpp-member-supertypes.test.ts b/__tests__/c-cpp-member-supertypes.test.ts
new file mode 100644
index 0000000000..4321ded4cf
--- /dev/null
+++ b/__tests__/c-cpp-member-supertypes.test.ts
@@ -0,0 +1,273 @@
+/**
+ * A C or C++ struct/class member whose declarator is a pointer, reference,
+ * array or function was recorded as an `extends` edge to the member's type:
+ *
+ *   struct ThreadState { SharedState* shared; };    // ThreadState extends SharedState
+ *   typedef struct { int length; jv elements[]; } jvp_array;   // jvp_array extends jv
+ *   class DB { virtual Status Put(const Slice& k) = 0; };      // DB extends Status
+ *
+ * Both extractors carried Go's struct-embedding check (`type DB struct { *Head }`
+ * — a `field_declaration` with no `field_identifier` names an embedded type)
+ * and ran it for every grammar with a `field_declaration_list`. tree-sitter-c
+ * and -cpp, and the C structs of Objective-C, nest the member's name inside
+ * its declarator, so every such member looked embedded and its type showed up
+ * as a supertype: in the type hierarchy, the "extends" chips, blast radius
+ * and codegraph_explore. google/leveldb had 246 of its 302 `extends` edges
+ * from members.
+ *
+ * Embedding is Go's alone, so the check now runs for Go only. C++ base
+ * classes and Objective-C superclasses come from their own clauses and are
+ * untouched. Runs against the native kernel (when built) and the wasm
+ * extractor, which must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import { buildTypeHierarchy } from '../src/graph/type-hierarchy';
+import type { ExtractionResult, Language, Node } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** jqlang/jq's shapes: flexible and fixed arrays, pointers, function pointers in a union. */
+const C_SOURCE = `typedef struct { int refcnt; } jv;
+typedef struct jq_state jq_state;
+typedef struct { int length; jv elements[]; } jvp_array;
+struct jv_parser {
+  jv* stack;
+  jv next[2];
+  jv value;
+  int stackpos;
+};
+union cfunction {
+  jv (*a1)(jq_state *, jv);
+  jv (*a2)(jq_state *, jv, jv);
+};
+struct node {
+  struct node *next;
+  const jv *const *table;
+};
+`;
+
+/** google/leveldb's shapes, plus base classes that must survive, one on a later line. */
+const CPP_SOURCE = `class Cache {};
+class DB {};
+class Status {};
+class Slice {};
+struct SharedState { int total; };
+struct ThreadState {
+  SharedState* shared;
+  const Cache& cache;
+  Cache shards[4];
+  Status (*hook)(int);
+};
+class Benchmark {
+ public:
+  Status Open(int k);
+  virtual Status Put(const Slice& key) = 0;
+  Slice operator[](int n) const;
+ private:
+  DB* db_;
+  Cache* cache_;
+};
+class Base {};
+namespace ns { template <typename T> class Tpl {}; }
+class Derived : public Base, private ns::Tpl<int> {
+  Base* parent;
+};
+struct Plain : Base { Base* next; };
+class Wrapped
+    : public Base {
+  Base* other;
+};
+`;
+
+/** Go embedding is real inheritance-by-composition and keeps its edges. */
+const GO_SOURCE = `package store
+
+type Engine struct{}
+
+type Reader interface{ Read() }
+
+type Store struct {
+	*Engine
+	Reader
+	name   string
+	engine *Engine
+}
+`;
+
+/** Objective-C reuses the C struct grammar; its superclass comes from @interface. */
+const OBJC_SOURCE = `#import <Foundation/Foundation.h>
+typedef struct { int width; } Size;
+struct Frame {
+  Size *size;
+  Size corners[4];
+  Size origin;
+};
+@interface Image : NSObject <NSCopying> {
+  Size *cached;
+}
+@end
+@implementation Image
+@end
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+/** `<source> <kind> <name>` for every extends/implements ref, sorted. */
+function supertypeRefs(result: ExtractionResult): string[] {
+  const byId = new Map(result.nodes.map((n) => [n.id, n]));
+  return result.unresolvedReferences
+    .filter((r) => r.referenceKind === 'extends' || r.referenceKind === 'implements')
+    .map((r) => `${byId.get(r.fromNodeId)?.name ?? r.fromNodeId} ${r.referenceKind} ${r.referenceName}`)
+    .sort();
+}
+
+describe('a C/C++ member is not a supertype of its struct', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['c', 'cpp', 'go', 'objc']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', file: string, source: string, language: Language): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource(file, source, language);
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract(file, source, language);
+    expect(result, `kernel extraction of ${file}`).not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const eol = (s: string) => (crlf ? s.replace(/\n/g, '\r\n') : s);
+    const label = crlf ? ' (CRLF)' : '';
+
+    it.each(backends)(`C pointer, array and function-pointer members: %s${label}`, (backend) => {
+      const result = extract(backend, 'src/jv.c', eol(C_SOURCE), 'c');
+      expect(result.nodes.map((n) => n.name)).toEqual(
+        expect.arrayContaining(['jvp_array', 'jv_parser', 'cfunction', 'node'])
+      );
+      expect(supertypeRefs(result)).toEqual([]);
+    });
+
+    it.each(backends)(`C++ members, methods and operators; base classes kept: %s${label}`, (backend) => {
+      const result = extract(backend, 'benchmarks/db_bench.cc', eol(CPP_SOURCE), 'cpp');
+      expect(supertypeRefs(result)).toEqual([
+        'Derived extends Base',
+        'Derived extends ns::Tpl',
+        'Plain extends Base',
+        'Wrapped extends Base',
+      ]);
+    });
+
+    it.each(backends)(`Go embedded fields still extend: %s${label}`, (backend) => {
+      const result = extract(backend, 'store/store.go', eol(GO_SOURCE), 'go');
+      expect(supertypeRefs(result)).toEqual(['Store extends Engine', 'Store extends Reader']);
+    });
+
+    // Objective-C has no kernel walker; the wasm extractor is its only path.
+    it(`Objective-C C-struct members; @interface superclass kept: wasm${label}`, () => {
+      const result = extractFromSource('Image.m', eol(OBJC_SOURCE), 'objc');
+      expect(supertypeRefs(result)).toEqual(['Image extends NSObject', 'Image implements NSCopying']);
+    });
+  }
+});
+
+describe('the type hierarchy of an indexed C/C++ project', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    cg?.destroy();
+    cg = undefined;
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+    root = '';
+  });
+
+  it('holds only declared bases and Go embeddings', async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-member-supertypes-'));
+    const files: Record<string, string> = {
+      'include/db.h': 'class Cache {};\nclass DB {\n public:\n  virtual ~DB();\n};\n',
+      'benchmarks/db_bench.cc': [
+        '#include "db.h"',
+        'struct SharedState { int total; };',
+        'struct ThreadState {',
+        '  SharedState* shared;',
+        '};',
+        'class Benchmark {',
+        '  Cache* cache_;',
+        '  DB* db_;',
+        '};',
+        'class MemDB : public DB {',
+        '  Cache* cache_;',
+        '};',
+        '',
+      ].join('\n'),
+      'src/jv.c': C_SOURCE,
+      'store/store.go': GO_SOURCE,
+    };
+    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 });
+    const graph = cg;
+
+    const one = (name: string): Node => {
+      const found = graph.getNodesByName(name).filter((n) => n.kind !== 'file' && n.kind !== 'import');
+      expect(found, name).toHaveLength(1);
+      return found[0]!;
+    };
+
+    const ids = ['ThreadState', 'Benchmark', 'MemDB', 'jvp_array', 'jv_parser', 'cfunction', 'node', 'Store'].map(
+      (name) => one(name).id
+    );
+    const supertypes = graph
+      .getOutgoingEdgesFrom(ids, ['extends', 'implements'])
+      .map((e) => `${graph.getNode(e.source)?.name} ${e.kind} ${graph.getNode(e.target)?.name}`)
+      .sort();
+    // An embedded interface resolves as `implements`.
+    expect(supertypes).toEqual(['MemDB extends DB', 'Store extends Engine', 'Store implements Reader']);
+
+    // What the viewer's Type hierarchy and the "extends" chips are built from.
+    expect(buildTypeHierarchy(graph, one('ThreadState'))).toBeNull();
+    expect(buildTypeHierarchy(graph, one('SharedState'))).toBeNull();
+    expect(buildTypeHierarchy(graph, one('jv'))).toBeNull();
+    expect(buildTypeHierarchy(graph, one('DB'))?.descendants.map((d) => d.node.name)).toEqual(['MemDB']);
+    expect(buildTypeHierarchy(graph, one('Cache'))).toBeNull();
+    expect(buildTypeHierarchy(graph, one('Engine'))?.descendants.map((d) => d.node.name)).toEqual(['Store']);
+  }, 60_000);
+});
diff --git a/__tests__/catch-all-path-alias.test.ts b/__tests__/catch-all-path-alias.test.ts
new file mode 100644
index 0000000000..7f41631519
--- /dev/null
+++ b/__tests__/catch-all-path-alias.test.ts
@@ -0,0 +1,184 @@
+/**
+ * A tsconfig `paths` entry keyed `"*"` matches every specifier, so treating
+ * "an alias pattern matches" as "the import is the project's" made every
+ * package import in such a project look local. The out-of-repo guard never
+ * fired there: on cord-field (`"baseUrl": "src"`, `"*": ["./typings/*"]`),
+ * 169 imports of `Typography` from `@mui/material` landed on a project
+ * `Typography`, and `Form` from `react-final-form` on the project's form.
+ *
+ * An alias counts only when it maps the specifier to a project file. A
+ * package the importing file's package.json declares, which no alias maps to
+ * a file, is outside the repository, catch-all or not. A catch-all that does
+ * find a file (a local `.d.ts` for an untyped package, or `"*": ["src/*"]`
+ * for the project's own folders) still makes that import the project's.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+async function indexProject(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-catch-all-alias-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+/**
+ * `<kind> <target file>:<target qualified name>` for every edge leaving
+ * `file`'s nodes. JSX tags are left out: a separate pass links `<Button>` by
+ * name without reading the file's imports, alias or not.
+ */
+function edgesFrom(cg: CodeGraph, file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.metadata?.synthesizedBy !== 'jsx-render')
+    .map((e) => {
+      const target = cg.getNode(e.target);
+      return `${e.kind} ${target?.filePath}:${target?.qualifiedName}`;
+    })
+    .sort();
+}
+
+describe('a catch-all tsconfig path alias', () => {
+  it('leaves a declared package outside the repository when it names no project file', async () => {
+    const cg = await indexProject({
+      'package.json': JSON.stringify({
+        name: 'portal',
+        dependencies: {
+          '@mui/material': '^5.15.0',
+          'react-final-form': '^6.5.9',
+          luxon: '^3.4.3',
+          'legacy-widgets': '^1.0.0',
+          react: '^18.2.0',
+        },
+      }),
+      // cord-field's shape: `~/…` for the project's own files, `*` for local
+      // type declarations of untyped packages.
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: { baseUrl: 'src', jsx: 'react-jsx', paths: { '~/*': ['./*'], '*': ['./typings/*'] } },
+      }),
+      'src/components/Button.tsx': `export interface ButtonProps { label: string }
+export function Button(props: ButtonProps) { return <button>{props.label}</button>; }
+`,
+      'src/components/Card.tsx': `export function Card(props: { children?: unknown }) { return <div>{String(props.children)}</div>; }
+`,
+      'src/components/form/Form.tsx': `export function Form() { return <form />; }
+export function useForm() { return { valid: true }; }
+`,
+      'src/common/DateTime.ts': `export class DateTime {
+  static now(): DateTime { return new DateTime(); }
+}
+`,
+      // The catch-all does answer this package: its types live in the project.
+      'src/typings/legacy-widgets.d.ts': `export interface WidgetOptions { name: string }
+export declare class Widget {
+  constructor(options: WidgetOptions);
+  render(): void;
+}
+`,
+      'src/scenes/Page.tsx': `import { Button, type ButtonProps } from '@mui/material';
+import { Form, useForm } from 'react-final-form';
+import { DateTime } from 'luxon';
+import { Widget, type WidgetOptions } from 'legacy-widgets';
+import { Card } from '~/components/Card';
+
+const options: WidgetOptions = { name: 'page' };
+
+export function Page(props: ButtonProps) {
+  const form = useForm();
+  const when = DateTime.now();
+  new Widget(options).render();
+  return <Card><Button>{props.label}{String(form.valid)}{String(when)}</Button><Form /></Card>;
+}
+`,
+    });
+    try {
+      const fromPage = edgesFrom(cg, 'src/scenes/Page.tsx');
+      // No name the page imports from a package lands on a project namesake.
+      expect(fromPage.filter((e) => /src\/components\/(?:Button|form\/Form)\.tsx|src\/common\/DateTime\.ts/.test(e))).toEqual([]);
+      // `~/…` still reaches the project, and so does a package whose types the
+      // catch-all finds in the project.
+      expect(fromPage).toContain('imports src/components/Card.tsx:Card');
+      expect(fromPage).toContain('imports src/typings/legacy-widgets.d.ts:Widget');
+      expect(fromPage).toContain('imports src/typings/legacy-widgets.d.ts:WidgetOptions');
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('still makes an import the project’s when it maps the import to a project file', async () => {
+    const cg = await indexProject({
+      'package.json': JSON.stringify({ name: 'shop', dependencies: { '@mui/material': '^5.15.0', react: '^18.2.0' } }),
+      'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.', jsx: 'react-jsx', paths: { '*': ['src/*'] } } }),
+      'src/components/Button.tsx': `export function Button() { return <button />; }
+`,
+      'src/pages/Home.tsx': `import { Button } from 'components/Button';
+export function Home() { return <Button />; }
+`,
+      'src/pages/Checkout.tsx': `import { Button } from '@mui/material';
+export function Checkout() { return <Button />; }
+`,
+    });
+    try {
+      expect(edgesFrom(cg, 'src/pages/Home.tsx')).toContain('imports src/components/Button.tsx:Button');
+      expect(edgesFrom(cg, 'src/pages/Checkout.tsx').filter((e) => e.includes('src/components/Button.tsx'))).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('leaves a declared package outside the repository when its alias lands outside the index', async () => {
+    const cg = await indexProject({
+      'package.json': JSON.stringify({ name: 'panel', dependencies: { lit: '^3.0.0', 'date-fns': '^3.0.0', config: '^3.3.0' } }),
+      // home-assistant pins lit's entry points to files in node_modules, and
+      // topcoder's catch-all ends in `node_modules/*`.
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          baseUrl: '.',
+          experimentalDecorators: true,
+          paths: { 'lit/decorators': ['./node_modules/lit/decorators.js'], '*': ['src/*', 'node_modules/*'] },
+        },
+      }),
+      // Installed packages: on disk, never indexed.
+      'node_modules/lit/decorators.js': `export function property() { return () => {}; }
+`,
+      'node_modules/date-fns/index.js': `export function format(value) { return String(value); }
+`,
+      'src/data/zwave.ts': `export interface ConfigParam {
+  property: string;
+}
+`,
+      'src/format.ts': `export function format(value: number) { return value.toFixed(2); }
+`,
+      // The `config` package reads this folder at run time.
+      'config/default.js': `const config = { port: 3000 };
+module.exports = config;
+`,
+      'src/panel.ts': `import { property } from 'lit/decorators';
+import { format } from 'date-fns';
+import config from 'config';
+
+export class Panel {
+  @property() label = '';
+  render() { return format(config.port); }
+}
+`,
+    });
+    try {
+      expect(edgesFrom(cg, 'src/panel.ts').filter((e) => /src\/data\/zwave\.ts|src\/format\.ts|config\/default\.js/.test(e))).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/cfml-call-scope.test.ts b/__tests__/cfml-call-scope.test.ts
new file mode 100644
index 0000000000..320f6a0048
--- /dev/null
+++ b/__tests__/cfml-call-scope.test.ts
@@ -0,0 +1,82 @@
+/**
+ * CFML types no receiver, so a component method reached by name alone must
+ * be in reach:
+ *
+ * - a bare call inside a component (`.cfc`) is the component's own method or
+ *   one of a component it `extends` — else a built-in: coldbox's `now()` went
+ *   to a date helper's `now` 228 times;
+ * - `receiver.m()` through an untyped receiver takes the one method named
+ *   `m` only when the receiver is named after its component:
+ *   `server.keyExists(…)` is the struct member function, not an interceptor
+ *   buffer's `keyExists` (168 times).
+ */
+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-cfml-scope-'));
+  const files: Record<string, string> = {
+    'system/core/DateTimeHelper.cfc': `component {
+  function now() {
+    return createObject( "java", "java.time.LocalDateTime" ).now();
+  }
+}
+`,
+    'system/core/InterceptorBuffer.cfc': `component {
+  function keyExists( required key ) {
+    return false;
+  }
+}
+`,
+    'system/Base.cfc': `component {
+  function getSetting( required name ) {
+    return "";
+  }
+}
+`,
+    'system/models/UserService.cfc': `component {
+  function list() {
+    return [];
+  }
+}
+`,
+    'system/Handler.cfc': `component extends="app.system.Base" {
+  function index( event, rc, prc, userService ) {
+    var stamp = now();
+    var lucee = server.keyExists( "lucee" );
+    var name = getSetting( "appName" );
+    var users = userService.list();
+    return stamp;
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('CFML calls reached by name alone', () => {
+  it('keep the inherited method and the receiver named after its component; drop the built-ins', () => {
+    const ids = cg.getNodesInFile('system/Handler.cfc').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName)
+      .sort();
+    expect(targets).toEqual(['Base::getSetting', 'UserService::list']);
+  });
+});
diff --git a/__tests__/cfml-tag-calls.test.ts b/__tests__/cfml-tag-calls.test.ts
new file mode 100644
index 0000000000..f2741ed2d7
--- /dev/null
+++ b/__tests__/cfml-tag-calls.test.ts
@@ -0,0 +1,85 @@
+/**
+ * Tag-based CFML end to end (#2091). Most calls in a tag-based component sit
+ * in `<cfset>`/`<cfif>`/`<cfreturn>` and `#hash#` expressions, not in
+ * `<cfscript>`; on a 6,000-file tag-based codebase only 6.4% of methods had a
+ * caller in the graph. Functions wrapped in `<cfprocessingdirective>` (the
+ * Application.cfc shape) and `<cfinterface>` components were missing as well,
+ * so their callers and implementers had nothing to land on.
+ */
+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-cfml-tag-calls-'));
+  const files: Record<string, string> = {
+    'model/Svc.cfc': `<cfcomponent>
+\t<cffunction name="a">
+\t\t<cfset x = b(1)>
+\t\t<cfif c(2)></cfif>
+\t\t<cfreturn d()>
+\t</cffunction>
+\t<cffunction name="b"></cffunction>
+\t<cffunction name="c"></cffunction>
+\t<cffunction name="d"></cffunction>
+</cfcomponent>
+`,
+    'Application.cfc': `<cfcomponent>
+\t<cfprocessingdirective suppresswhitespace="true">
+\t\t<cffunction name="onRequestStart">
+\t\t\t<cfset loadConfig()>
+\t\t</cffunction>
+\t\t<cffunction name="loadConfig"></cffunction>
+\t</cfprocessingdirective>
+</cfcomponent>
+`,
+    'model/ISearchable.cfc': `<cfinterface>
+\t<cffunction name="search" access="public"></cffunction>
+</cfinterface>
+`,
+    'model/Catalog.cfc': `<cfcomponent implements="ISearchable">
+\t<cffunction name="search" access="public"></cffunction>
+</cfcomponent>
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const edgesFrom = (file: string, kind: string): string[] => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === kind)
+    .map((e) => `${cg.getNode(e.source)!.qualifiedName} -> ${cg.getNode(e.target)!.qualifiedName}`)
+    .sort();
+};
+
+describe('tag-based CFML (#2091)', () => {
+  it('links calls written in <cfset>, <cfif> and <cfreturn> to the methods they call', () => {
+    expect(edgesFrom('model/Svc.cfc', 'calls')).toEqual(['Svc::a -> Svc::b', 'Svc::a -> Svc::c', 'Svc::a -> Svc::d']);
+  });
+
+  it('indexes a method wrapped in <cfprocessingdirective> and the calls it makes', () => {
+    expect(edgesFrom('Application.cfc', 'calls')).toEqual(['Application::onRequestStart -> Application::loadConfig']);
+  });
+
+  it('resolves <cfcomponent implements="…"> to a <cfinterface> component', () => {
+    const iface = cg.getNodesInFile('model/ISearchable.cfc').find((n) => n.kind === 'interface');
+    expect(iface?.name).toBe('ISearchable');
+    expect(edgesFrom('model/Catalog.cfc', 'implements')).toEqual(['model/Catalog.cfc::Catalog -> model/ISearchable.cfc::ISearchable']);
+  });
+});
diff --git a/__tests__/child-process-windows-hide.test.ts b/__tests__/child-process-windows-hide.test.ts
new file mode 100644
index 0000000000..0e969934b4
--- /dev/null
+++ b/__tests__/child-process-windows-hide.test.ts
@@ -0,0 +1,390 @@
+/**
+ * Static source guard (all platforms): every child process spawned from `src/`
+ * sets `windowsHide: true`.
+ *
+ * The MCP daemon is spawned detached and has no console of its own. On
+ * Windows, a console program (git, …) it starts without windowsHide gets a
+ * brand-new visible console, so a terminal window flashes on screen and closes
+ * once per call: on daemon start and again on every auto-sync (#485, #928,
+ * #1092, #2094, #2096, #2312). With Windows Terminal set as the default
+ * terminal, each flash is a full Windows Terminal window.
+ *
+ * windowsHide is Windows-only behavior the POSIX test runs can't observe, so it
+ * is asserted on the TypeScript AST. Options passed through a variable or a
+ * function parameter are traced back to the object literal that defines them
+ * (for a parameter: through every call site of that function in the file).
+ *
+ * The guard fails closed: a spawn it can't trace is an offender, not a pass.
+ * That covers child_process reached any way other than a static import
+ * (`require`, `import()`, a re-export), a spawner used as a value instead of
+ * called (`const run = execFileSync`, `promisify(execFile)`, `const { spawn } =
+ * cp`), options in a `let`, and an options parameter of an exported function
+ * (its callers in other files are out of sight). The second `describe` pins
+ * each of those shapes so the guard itself can't silently go blind.
+ */
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import ts from 'typescript';
+
+const SRC_DIR = path.join(__dirname, '..', 'src');
+
+/**
+ * child_process functions that start a process and accept `windowsHide`, by
+ * argument shape: `file` is `(file, args?, options?)`, `command` is
+ * `(command, options?)`.
+ */
+const SPAWNERS: Record<string, 'file' | 'command'> = {
+  exec: 'command',
+  execSync: 'command',
+  execFile: 'file',
+  execFileSync: 'file',
+  spawn: 'file',
+  spawnSync: 'file',
+  fork: 'file',
+};
+
+const CHILD_PROCESS_MODULES = new Set(['child_process', 'node:child_process']);
+
+/**
+ * Spawns that intentionally run without windowsHide, keyed by
+ * `<path relative to src>:<spawner>(<command>)`, valued by the reason.
+ */
+const ALLOWED: Record<string, string> = {
+  "resolution/memory-budget.ts:execFileSync('/usr/bin/vm_stat')": 'macOS only: guarded by process.platform === darwin',
+  'ui-server/open-browser.ts:spawn(open.command)':
+    'detached: true maps to DETACHED_PROCESS on Windows, so `cmd /c start` gets no console to show',
+};
+
+function listSourceFiles(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...listSourceFiles(p));
+    else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) out.push(p);
+  }
+  return out;
+}
+
+function isChildProcessModule(node: ts.Node | undefined): boolean {
+  return node !== undefined && ts.isStringLiteralLike(node) && CHILD_PROCESS_MODULES.has(node.text);
+}
+
+/** Local names bound to child_process exports in one file. */
+interface ChildProcessBindings {
+  /** Local name → imported child_process export (`import { spawn as s }`). */
+  named: Map<string, string>;
+  /**
+   * Names bound to the module object: `import * as cp`, `import cp` (with
+   * esModuleInterop) and `import cp = require(…)`.
+   */
+  namespaces: Set<string>;
+}
+
+function childProcessBindings(sf: ts.SourceFile): ChildProcessBindings {
+  const named = new Map<string, string>();
+  const namespaces = new Set<string>();
+  for (const stmt of sf.statements) {
+    if (ts.isImportEqualsDeclaration(stmt)) {
+      const ref = stmt.moduleReference;
+      if (ts.isExternalModuleReference(ref) && isChildProcessModule(ref.expression)) namespaces.add(stmt.name.text);
+      continue;
+    }
+    if (!ts.isImportDeclaration(stmt) || !isChildProcessModule(stmt.moduleSpecifier)) continue;
+    const clause = stmt.importClause;
+    if (!clause) continue; // bare `import 'child_process'` binds nothing
+    if (clause.name) namespaces.add(clause.name.text);
+    const bindings = clause.namedBindings;
+    if (!bindings) continue;
+    if (ts.isNamespaceImport(bindings)) namespaces.add(bindings.name.text);
+    else for (const el of bindings.elements) named.set(el.name.text, (el.propertyName ?? el.name).text);
+  }
+  return { named, namespaces };
+}
+
+/** The child_process function a call invokes, or null when it isn't one. */
+function spawnerOf(call: ts.CallExpression, b: ChildProcessBindings): string | null {
+  const callee = call.expression;
+  const name = ts.isIdentifier(callee)
+    ? b.named.get(callee.text)
+    : ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && b.namespaces.has(callee.expression.text)
+      ? callee.name.text
+      : undefined;
+  return name !== undefined && Object.hasOwn(SPAWNERS, name) ? name : null;
+}
+
+/** The options argument of a spawner call, or undefined when none is passed. */
+function optionsArg(call: ts.CallExpression, spawner: string): ts.Expression | undefined {
+  const [, second, third] = call.arguments;
+  if (SPAWNERS[spawner] === 'command') return second;
+  // (file, options) is allowed when the args array is omitted.
+  if (second && ts.isObjectLiteralExpression(second)) return second;
+  return third;
+}
+
+function unwrap(expr: ts.Expression): ts.Expression {
+  let e = expr;
+  while (ts.isAsExpression(e) || ts.isParenthesizedExpression(e) || ts.isSatisfiesExpression(e) || ts.isTypeAssertionExpression(e)) e = e.expression;
+  return e;
+}
+
+function isCallee(node: ts.Node): boolean {
+  return ts.isCallExpression(node.parent) && node.parent.expression === node;
+}
+
+/**
+ * True when `id` reads the binding it names as a value. False for a type
+ * position (`typeof execFileSync`), and for an identifier that only names a
+ * declaration or a member: `x.exec`, `{ exec: … }`, `const spawn = …`, the
+ * import specifier itself. A re-export (`export { spawn }`) and a shorthand
+ * property (`{ spawn }`) DO read the value.
+ */
+function isValueReference(id: ts.Identifier): boolean {
+  for (let n: ts.Node | undefined = id.parent; n; n = n.parent) if (ts.isTypeNode(n)) return false;
+  const p = id.parent as ts.Node & { name?: ts.Node; propertyName?: ts.Node };
+  if (ts.isShorthandPropertyAssignment(p) || ts.isExportSpecifier(p)) return true;
+  if (p.name === id || p.propertyName === id) return false;
+  if (ts.isQualifiedName(p) && p.right === id) return false;
+  return true;
+}
+
+/** Variable initializer or function parameter that `name` refers to at `from`. */
+function resolveBinding(name: string, from: ts.Node): ts.VariableDeclaration | ts.ParameterDeclaration | null {
+  for (let scope: ts.Node | undefined = from.parent; scope; scope = scope.parent) {
+    if (ts.isFunctionLike(scope)) {
+      const param = scope.parameters.find((p) => ts.isIdentifier(p.name) && p.name.text === name);
+      if (param) return param;
+    }
+    if (ts.isBlock(scope) || ts.isSourceFile(scope) || ts.isModuleBlock(scope)) {
+      for (const stmt of scope.statements) {
+        if (!ts.isVariableStatement(stmt)) continue;
+        const decl = stmt.declarationList.declarations.find((d) => ts.isIdentifier(d.name) && d.name.text === name);
+        if (decl) return decl;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * The argument every call of the function that declares `param` passes for it
+ * (undefined where a call omits it), found by name in the same file. Null when
+ * the callers can't all be seen: the function is unnamed, exported (callers in
+ * other files), or used as a value (a callback receives whatever its caller
+ * passes).
+ */
+function callSitesOf(param: ts.ParameterDeclaration, sf: ts.SourceFile): (ts.Expression | undefined)[] | null {
+  const fn = param.parent;
+  if (!ts.isFunctionDeclaration(fn) || !fn.name) return null;
+  if (fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) return null;
+  const fnName = fn.name.text;
+  const index = fn.parameters.indexOf(param);
+  const args: (ts.Expression | undefined)[] = [];
+  let usedAsValue = false;
+  const visit = (node: ts.Node): void => {
+    if (ts.isIdentifier(node) && node.text === fnName && node !== fn.name && isValueReference(node)) {
+      if (!isCallee(node)) usedAsValue = true;
+      else {
+        const call = node.parent as ts.CallExpression;
+        // A spread before the parameter's slot hides which value lands in it.
+        if (call.arguments.slice(0, index + 1).some(ts.isSpreadElement)) usedAsValue = true;
+        else args.push(call.arguments[index]);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return usedAsValue || args.length === 0 ? null : args;
+}
+
+/**
+ * What options `expr` evaluates to do with windowsHide: provably set to true
+ * (`hidden`), provably not set at all (`absent`, e.g. no options passed, or a
+ * spread of `{ cwd }`), or anything else (`unhidden`: false, a non-literal, or
+ * unknowable). `absent` matters for spreads: `{ windowsHide: true, ...extra }`
+ * stays hidden only when `extra` provably doesn't set it back.
+ */
+type HideState = 'hidden' | 'absent' | 'unhidden';
+
+function hideState(expr: ts.Expression | undefined, sf: ts.SourceFile, seen = new Set<ts.Node>()): HideState {
+  if (!expr) return 'absent';
+  const e = unwrap(expr);
+  if (seen.has(e)) return 'unhidden'; // a cycle proves nothing
+  // Path-local: two call sites passing the same options object both resolve.
+  const trail = new Set(seen).add(e);
+  if (ts.isObjectLiteralExpression(e)) {
+    let state: HideState = 'absent';
+    for (const prop of e.properties) {
+      if (ts.isPropertyAssignment(prop) && prop.name.getText(sf) === 'windowsHide') {
+        state = unwrap(prop.initializer).kind === ts.SyntaxKind.TrueKeyword ? 'hidden' : 'unhidden';
+      } else if (ts.isShorthandPropertyAssignment(prop) && prop.name.text === 'windowsHide') {
+        state = 'unhidden'; // not provable statically
+      } else if (ts.isSpreadAssignment(prop)) {
+        const spread = hideState(prop.expression, sf, trail);
+        if (spread !== 'absent') state = spread;
+      }
+    }
+    return state; // last write wins, matching object-literal semantics
+  }
+  if (ts.isIdentifier(e)) {
+    const binding = resolveBinding(e.text, e);
+    if (!binding) return 'unhidden';
+    if (ts.isVariableDeclaration(binding)) {
+      // A `let` or `var` can be reassigned after its initializer.
+      const list = binding.parent;
+      if (!ts.isVariableDeclarationList(list) || !(list.flags & ts.NodeFlags.Const)) return 'unhidden';
+      return binding.initializer ? hideState(binding.initializer, sf, trail) : 'unhidden';
+    }
+    const sites = callSitesOf(binding, sf);
+    if (sites === null) return 'unhidden';
+    const states = new Set(sites.map((arg) => hideState(arg, sf, trail)));
+    return states.size === 1 ? [...states][0] : 'unhidden';
+  }
+  return 'unhidden';
+}
+
+/** True when `expr` provably evaluates to options with `windowsHide: true`. */
+function hidesWindow(expr: ts.Expression | undefined, sf: ts.SourceFile): boolean {
+  return hideState(expr, sf) === 'hidden';
+}
+
+function commandLabel(call: ts.CallExpression, sf: ts.SourceFile): string {
+  const first = call.arguments[0];
+  if (!first) return '';
+  if (ts.isStringLiteralLike(first)) return `'${first.text}'`;
+  return first.getText(sf);
+}
+
+/** Every spawn in one file, and each one that isn't provably hidden. */
+function scanSource(rel: string, text: string): { seen: number; offenders: string[] } {
+  const sf = ts.createSourceFile(rel, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const bindings = childProcessBindings(sf);
+  const offenders: string[] = [];
+  let seen = 0;
+  const flag = (node: ts.Node, what: string): void => {
+    const { line } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+    offenders.push(`${rel}:${line + 1} ${what}`);
+  };
+  const visit = (node: ts.Node): void => {
+    if (ts.isExportDeclaration(node) && isChildProcessModule(node.moduleSpecifier)) {
+      flag(node, 're-exports child_process: spawns through the re-export are out of sight');
+    }
+    if (ts.isCallExpression(node)) {
+      const callee = node.expression;
+      const loads =
+        (ts.isIdentifier(callee) && callee.text === 'require') || callee.kind === ts.SyntaxKind.ImportKeyword;
+      if (loads && isChildProcessModule(node.arguments[0])) {
+        flag(node, `${callee.getText(sf)}(child_process): import it statically so its spawns can be checked`);
+      }
+      const spawner = spawnerOf(node, bindings);
+      if (spawner) {
+        seen++;
+        const key = `${rel}:${spawner}(${commandLabel(node, sf)})`;
+        if (!Object.hasOwn(ALLOWED, key) && !hidesWindow(optionsArg(node, spawner), sf)) flag(node, key);
+      }
+    }
+    const bound = ts.isIdentifier(node) && (bindings.named.has(node.text) || bindings.namespaces.has(node.text));
+    if (bound && isValueReference(node)) {
+      const imported = bindings.named.get(node.text);
+      if (imported !== undefined && Object.hasOwn(SPAWNERS, imported) && !isCallee(node)) {
+        flag(node, `${node.text} used as a value: call it directly so its options can be checked`);
+      } else if (bindings.namespaces.has(node.text)) {
+        const member = node.parent;
+        const direct =
+          ts.isPropertyAccessExpression(member) &&
+          member.expression === node &&
+          (!Object.hasOwn(SPAWNERS, member.name.text) || isCallee(member));
+        if (!direct) flag(node, `${node.getText(sf)} used as a value: call its spawners directly so their options can be checked`);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return { seen, offenders };
+}
+
+describe('child processes set windowsHide (#1092, #2094, #2312)', () => {
+  it('every child_process spawn under src/ sets windowsHide: true', () => {
+    const offenders: string[] = [];
+    let seen = 0;
+    for (const file of listSourceFiles(SRC_DIR)) {
+      const rel = path.relative(SRC_DIR, file).split(path.sep).join('/');
+      const result = scanSource(rel, fs.readFileSync(file, 'utf8'));
+      seen += result.seen;
+      offenders.push(...result.offenders);
+    }
+    expect(seen).toBeGreaterThan(0); // guard against a false pass if the imports move
+    expect(offenders, `spawned without windowsHide:\n${offenders.join('\n')}`).toEqual([]);
+  });
+});
+
+describe('the windowsHide guard fails closed', () => {
+  const scan = (text: string) => scanSource('fixture.ts', text);
+
+  it.each([
+    [
+      'the core.excludesFile read the watcher repeats (#2312)',
+      `import { execFileSync } from 'child_process';
+       execFileSync('git', ['-C', root, 'config', '--get', 'core.excludesFile'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });`,
+    ],
+    ['windowsHide: false', `import { spawn } from 'child_process'; spawn('git', [], { windowsHide: false });`],
+    ['a later spread overriding it', `import { spawn } from 'child_process'; spawn('git', [], { windowsHide: true, ...{ windowsHide: false } });`],
+    ['a later spread that might override it', `import { spawn } from 'child_process'; spawn('git', [], { windowsHide: true, ...extra() });`],
+    ['a default import', `import cp from 'child_process'; cp.execFileSync('git', ['status'], { encoding: 'utf8' });`],
+    ['an import-equals', `import cp = require('child_process'); cp.spawnSync('git', ['status']);`],
+    ['a require()', `const { execFileSync } = require('child_process'); execFileSync('git', ['status'], { windowsHide: true });`],
+    ['a dynamic import()', `async function f() { const cp = await import('node:child_process'); }`],
+    ['a re-export', `export { spawn } from 'child_process';`],
+    ['a re-export of the import', `import { spawn } from 'child_process'; export { spawn };`],
+    ['an alias', `import { execFileSync } from 'child_process'; const run = execFileSync; run('git', ['status']);`],
+    ['promisify', `import { execFile } from 'child_process'; import { promisify } from 'util'; const run = promisify(execFile);`],
+    ['a shorthand property', `import { spawn } from 'child_process'; const deps = { spawn };`],
+    ['a destructured namespace', `import * as cp from 'child_process'; const { spawn } = cp; spawn('git', []);`],
+    ['a namespace spawner as a value', `import * as cp from 'child_process'; [].forEach(cp.spawn);`],
+    [
+      'options in a let',
+      `import { execFileSync } from 'child_process';
+       let opts = { windowsHide: true }; opts = {}; execFileSync('git', [], opts);`,
+    ],
+    [
+      'an exported wrapper (its callers elsewhere are out of sight)',
+      `import { execFileSync } from 'child_process';
+       export function git(args: string[], opts: object) { return execFileSync('git', args, opts); }
+       git(['status'], { windowsHide: true });`,
+    ],
+    [
+      'a wrapper call that omits the options',
+      `import { execFileSync } from 'child_process';
+       function git(args: string[], opts?: object) { return execFileSync('git', args, opts); }
+       git(['status'], { windowsHide: true }); git(['log']);`,
+    ],
+    [
+      'a wrapper passed as a callback',
+      `import { execFileSync } from 'child_process';
+       function git(opts: object) { return execFileSync('git', [], opts); }
+       git({ windowsHide: true }); [{}].map(git);`,
+    ],
+  ])('flags %s', (_label, text) => {
+    expect(scan(text).offenders).not.toEqual([]);
+  });
+
+  it.each([
+    ['a literal', `import { execFileSync } from 'child_process'; execFileSync('git', ['status'], { windowsHide: true });`],
+    ['(file, options)', `import { execFileSync } from 'child_process'; execFileSync('git', { windowsHide: true });`],
+    ['a command spawner', `import { exec } from 'child_process'; exec('git status', { windowsHide: true }); /a/.exec('a');`],
+    ['a const', `import { spawn } from 'child_process'; const o = { windowsHide: true }; spawn('git', [], o);`],
+    ['a spread const', `import { spawn } from 'child_process'; const base = { windowsHide: true }; spawn('git', [], { ...base, cwd: '.' });`],
+    ['a later spread that leaves it alone', `import { spawn } from 'child_process'; const extra = { cwd: '.' }; spawn('git', [], { windowsHide: true, ...extra });`],
+    ['a namespace', `import * as cp from 'node:child_process'; let c: cp.ChildProcess | undefined; cp.spawn('git', [], { windowsHide: true });`],
+    [
+      'a wrapper whose every call passes the same hidden options',
+      `import { execFileSync } from 'child_process';
+       function git(opts: Parameters<typeof execFileSync>[2]) { return execFileSync('git', [], opts); }
+       const gitOpts = { cwd: '.', windowsHide: true };
+       git(gitOpts); git(gitOpts);`,
+    ],
+    ['types only', `import type { ChildProcess } from 'child_process'; let c: ChildProcess | undefined;`],
+  ])('passes %s', (_label, text) => {
+    expect(scan(text).offenders).toEqual([]);
+  });
+});
diff --git a/__tests__/cli-affected-test-conventions.test.ts b/__tests__/cli-affected-test-conventions.test.ts
index 1887e934f6..7418fde255 100644
--- a/__tests__/cli-affected-test-conventions.test.ts
+++ b/__tests__/cli-affected-test-conventions.test.ts
@@ -41,10 +41,13 @@ describe('codegraph affected — test-file conventions (#1507)', () => {
     w('pkg/test_calc.py', 'from pkg.calc import add\n\ndef test_add():\n    assert add(1, 2) == 3\n');
     w('src/main/kotlin/app/Calc.kt', 'package app\n\nclass Calc {\n    fun add(a: Int, b: Int): Int = a + b\n}\n');
     w('src/test/kotlin/app/CalcTest.kt', 'package app\n\nclass CalcTest {\n    fun addsNumbers() { Calc().add(1, 2) }\n}\n');
+    w('src/wire_format.h', '#pragma once\n\nint ByteSize(int value);\n');
+    w('src/wire_format.cc', '#include "wire_format.h"\n\nint ByteSize(int value) { return value; }\n');
+    w('src/wire_format_unittest.cc', '#include "wire_format.h"\n\nvoid ComputesByteSize() { ByteSize(1); }\n');
     const cg = CodeGraph.initSync(dir);
     await cg.indexAll();
     cg.close();
-  });
+  }, 60_000);
 
   afterAll(() => {
     fs.rmSync(dir, { recursive: true, force: true });
@@ -59,6 +62,10 @@ describe('codegraph affected — test-file conventions (#1507)', () => {
     expect(affected(dir, ['src/main/kotlin/app/Calc.kt'])).toEqual(['src/test/kotlin/app/CalcTest.kt']);
   });
 
+  it("reports Google's C++ _unittest.cc beside the code it tests", () => {
+    expect(affected(dir, ['src/wire_format.h', 'src/wire_format.cc'])).toEqual(['src/wire_format_unittest.cc']);
+  });
+
   it('still honours an explicit --filter glob', () => {
     expect(affected(dir, ['math.go', '--filter', '*_test.go'])).toEqual(['math_test.go']);
     expect(affected(dir, ['math.go', '--filter', '*.spec.ts'])).toEqual([]);
diff --git a/__tests__/cli-ui-command.test.ts b/__tests__/cli-ui-command.test.ts
index c419b50d13..3b4dfac5cb 100644
--- a/__tests__/cli-ui-command.test.ts
+++ b/__tests__/cli-ui-command.test.ts
@@ -342,6 +342,29 @@ describe('codegraph ui — serving', () => {
     }
   }, 60_000);
 
+  // `codegraph ui` re-execs itself with `--liftoff-only`, and the command the
+  // user started blocks in spawnSync, unable to forward a signal: killing it by
+  // pid (a process manager, an IDE task, `kill`) used to leave the server
+  // serving the port forever. POSIX-only: it relies on reparenting.
+  it.runIf(process.platform !== 'win32')('stops serving when the command it was started as is killed', async () => {
+    const viewer = await startViewer(['--no-open', '--port', '0', projectDir], {
+      CODEGRAPH_WASM_RELAUNCHED: '',
+      CODEGRAPH_PPID_POLL_MS: '200',
+    });
+    expect((await get(viewer.port, '/api/stats')).status).toBe(200);
+    viewer.child.kill('SIGKILL');
+    const deadline = Date.now() + 15_000;
+    let serving = true;
+    while (serving && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 200));
+      serving = await get(viewer.port, '/api/stats').then(
+        () => true,
+        () => false
+      );
+    }
+    expect(serving).toBe(false);
+  }, 60_000);
+
   it('refuses a foreign Host end-to-end', async () => {
     const viewer = await startViewer(['--no-open', '--port', '0', projectDir], {});
     try {
diff --git a/__tests__/cobol-sequence-area-period.test.ts b/__tests__/cobol-sequence-area-period.test.ts
new file mode 100644
index 0000000000..79985c0f41
--- /dev/null
+++ b/__tests__/cobol-sequence-area-period.test.ts
@@ -0,0 +1,119 @@
+/**
+ * COBOL: a file that ends inside the sequence area must parse, not hang.
+ *
+ * The vendored COBOL grammar's external scanner skips the fixed-format
+ * sequence area (columns 1-6) by advancing until the lexer reaches column 7.
+ * At end of input `advance()` is a no-op, so a file whose last line stops
+ * inside that area — `    .` (four spaces and a period: the period lands in
+ * column 5), `X\n    .`, a paragraph closed by a short `    .` line — never
+ * reached column 7 and the scanner spun forever inside WebAssembly. Indexing
+ * such a file ran into the parse worker's timeout (about a minute and a half
+ * with the retries) and stored it with zero symbols; the viewer's highlighter
+ * froze on the same text. The scanner now stops at end of input.
+ *
+ * Both checks run against the built engine in a child process under a hard
+ * timeout: a regression is an infinite loop inside wasm that no in-process
+ * timer can interrupt, so parsing in this worker would hang the suite instead
+ * of failing the test.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { WASM_RUNTIME_FLAGS } from '../src/extraction/wasm-runtime-flags';
+
+const DIST = path.resolve(__dirname, '../dist');
+
+/** A fixed-format program whose last line is a lone period in column 5. */
+const HANGY = [
+  '       IDENTIFICATION DIVISION.',
+  '       PROGRAM-ID. HANGY.',
+  '       PROCEDURE DIVISION.',
+  '       MAIN-PARA.',
+  '           DISPLAY "X"',
+  '    .',
+  '',
+].join('\n');
+
+/** Under the parse worker's 30 s hard per-file timeout a hang would run into. */
+const DEADLINE_MS = 20_000;
+
+function runChild(script: string, args: string[]) {
+  return spawnSync(process.execPath, [...WASM_RUNTIME_FLAGS, '-e', script, DIST, ...args], {
+    encoding: 'utf8',
+    timeout: DEADLINE_MS,
+    env: { ...process.env, CODEGRAPH_TELEMETRY: '0' },
+  });
+}
+
+describe('COBOL sequence-area period at end of file', () => {
+  it('extracts every source that ends inside the sequence area', () => {
+    const sources: Record<string, string> = {
+      'hangy.cob': HANGY,
+      'hangy-no-newline.cob': HANGY.trimEnd(),
+      'period-only.cob': '    .',
+      'after-statement.cob': '    PERFORM AssertOk\n    .',
+      'after-word.cob': 'X\n    .',
+    };
+    const script = `
+const path = require('path');
+const { initGrammars, loadGrammarsForLanguages } = require(path.join(process.argv[1], 'extraction/grammars.js'));
+const { extractFromSource } = require(path.join(process.argv[1], 'extraction/index.js'));
+(async () => {
+  await initGrammars();
+  await loadGrammarsForLanguages(['cobol']);
+  const out = {};
+  for (const [file, source] of Object.entries(JSON.parse(process.argv[2]))) {
+    const result = extractFromSource(file, source);
+    out[file] = result.nodes.map((n) => n.kind + ':' + n.name);
+  }
+  process.stdout.write(JSON.stringify(out));
+})();
+`;
+    const child = runChild(script, [JSON.stringify(sources)]);
+    expect(child.signal, `COBOL parse did not finish within ${DEADLINE_MS}ms: ${child.stderr}`).toBeNull();
+    expect(child.status, child.stderr).toBe(0);
+
+    const nodes = JSON.parse(child.stdout) as Record<string, string[]>;
+    expect(Object.keys(nodes).sort()).toEqual(Object.keys(sources).sort());
+    for (const file of ['hangy.cob', 'hangy-no-newline.cob']) {
+      expect(nodes[file]).toContain('module:HANGY');
+      expect(nodes[file]).toContain('function:MAIN-PARA');
+    }
+  }, DEADLINE_MS + 10_000);
+
+  describe('indexing a project', () => {
+    let root: string;
+
+    beforeEach(() => {
+      root = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cobol-seq-period-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(root, { recursive: true, force: true });
+    });
+
+    it('indexes the file with its symbols instead of timing it out', () => {
+      fs.writeFileSync(path.join(root, 'hangy.cob'), HANGY);
+      const script = `
+const path = require('path');
+const { default: CodeGraph } = require(path.join(process.argv[1], 'index.js'));
+const cg = CodeGraph.initSync(process.argv[2]);
+cg.indexAll().then((result) => {
+  const nodes = cg.getNodesInFile('hangy.cob').map((n) => n.kind + ':' + n.name);
+  process.stdout.write(JSON.stringify({ errored: result.filesErrored, indexed: result.filesIndexed, nodes }));
+}).finally(() => cg.close());
+`;
+      const child = runChild(script, [root]);
+      expect(child.signal, `indexing did not finish within ${DEADLINE_MS}ms: ${child.stderr}`).toBeNull();
+      expect(child.status, child.stderr).toBe(0);
+
+      const result = JSON.parse(child.stdout) as { errored: number; indexed: number; nodes: string[] };
+      expect(result.errored).toBe(0);
+      expect(result.indexed).toBe(1);
+      expect(result.nodes).toContain('module:HANGY');
+      expect(result.nodes).toContain('function:MAIN-PARA');
+    }, DEADLINE_MS + 10_000);
+  });
+});
diff --git a/__tests__/commonjs-require-calls.test.ts b/__tests__/commonjs-require-calls.test.ts
new file mode 100644
index 0000000000..a131d329ef
--- /dev/null
+++ b/__tests__/commonjs-require-calls.test.ts
@@ -0,0 +1,104 @@
+/**
+ * Calls through CommonJS `require` bindings (express's shape):
+ * - `var express = require('../')` from `test/` is the project root's
+ *   `index.js`, whose `module.exports = require('./lib/express')` forwards to
+ *   `exports = module.exports = createApplication` — `express()` is that call;
+ * - each declarator of a list is a binding: `var express = require('../'),
+ *   request = require('supertest')` — `request(app)` is the package's, no edge;
+ * - `require('./utils').setCharset` is the module's `setCharset`, written
+ *   `exports.setCharset = function setCharset(…)`, not the module's first
+ *   export (every such alias in express went to `normalizeType`).
+ */
+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-cjs-require-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'web', main: 'index.js', devDependencies: { supertest: '^6' } }),
+    'index.js': `'use strict';
+
+module.exports = require('./lib/express');
+`,
+    'lib/express.js': `'use strict';
+
+exports = module.exports = createApplication;
+
+function createApplication() {
+  return {};
+}
+`,
+    'lib/utils.js': `'use strict';
+
+exports.normalizeType = function (type) {
+  return type;
+};
+
+exports.setCharset = function setCharset(type, charset) {
+  return type + charset;
+};
+`,
+    'lib/response.js': `'use strict';
+
+var normalizeType = require('./utils').normalizeType;
+var setCharset = require('./utils').setCharset;
+
+function send(body) {
+  return setCharset(normalizeType(body), 'utf-8');
+}
+
+module.exports = { send };
+`,
+    'test/app.js': `'use strict';
+
+var express = require('../')
+  , request = require('supertest');
+
+describe('app', function () {
+  it('responds', function () {
+    var app = express();
+    request(app);
+  });
+});
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `file: qualified name` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${t.filePath}: ${t.qualifiedName}`;
+    })
+    .sort();
+}
+
+describe('calls through CommonJS require bindings', () => {
+  it('follow `module.exports` through the root index to the exported function; an outside package is no edge', () => {
+    expect(callsFrom('test/app.js')).toEqual(['lib/express.js: createApplication']);
+  });
+
+  it('read a `require(…).member` alias as that member', () => {
+    expect(callsFrom('lib/response.js')).toEqual(['lib/utils.js: normalizeType', 'lib/utils.js: setCharset']);
+  });
+});
diff --git a/__tests__/commonjs-require-imports.test.ts b/__tests__/commonjs-require-imports.test.ts
new file mode 100644
index 0000000000..f09f325289
--- /dev/null
+++ b/__tests__/commonjs-require-imports.test.ts
@@ -0,0 +1,103 @@
+/**
+ * A CommonJS `require('./x')` is a file import, as ESM's `import` is: Express's
+ * `lib/express.js` requires `./application`, `./request` and `./response`, and
+ * the index said it imported nothing — an empty Imports rail in the viewer and
+ * no file dependency — because those bindings are used as values, never
+ * called. A module path also resolves the way the runtime finds it, so an
+ * extensionless ESM side-effect import (`import './polyfills'`) reaches its
+ * file instead of stopping at its own import statement. A package
+ * (`require('express')`) stays outside the index.
+ */
+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-cjs-require-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'web', main: 'index.js' }),
+    'index.js': `module.exports = require('./lib/express');
+`,
+    'lib/express.js': `var EventEmitter = require('events').EventEmitter;
+var mixin = require('merge-descriptors');
+var proto = require('./application');
+var req = require('./request');
+
+function createApplication() {
+  var app = function () {};
+  mixin(app, EventEmitter.prototype, false);
+  mixin(app, proto, false);
+  app.request = Object.create(req);
+  return app;
+}
+
+module.exports = createApplication;
+`,
+    'lib/application.js': `var app = exports = module.exports = {};
+app.init = function init() {};
+`,
+    'lib/request.js': `var req = Object.create({});
+module.exports = req;
+`,
+    'test/app.js': `var express = require('..');
+var assert = require("assert");
+`,
+    'src/main.ts': `import './polyfills';
+import helper = require('./helper');
+export const value = helper.run();
+`,
+    'src/polyfills.ts': `export {};
+`,
+    'src/helper.ts': `export function run(): number {
+  return 1;
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const importedFiles = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return [...new Set(cg.getOutgoingEdgesFrom(ids, ['imports'])
+    .map((e) => cg.getNode(e.target)!.filePath)
+    .filter((p) => p !== file))].sort();
+};
+
+describe('CommonJS require', () => {
+  it('imports the files a module requires, used as values or not, and no package', () => {
+    expect(importedFiles('lib/express.js')).toEqual(['lib/application.js', 'lib/request.js']);
+    expect(cg.getFileDependencies('lib/express.js')).toEqual(expect.arrayContaining(['lib/application.js', 'lib/request.js']));
+  });
+
+  it('follows a directory require to its package entry', () => {
+    expect(importedFiles('index.js')).toEqual(['lib/express.js']);
+    expect(importedFiles('test/app.js')).toEqual(['index.js']);
+  });
+});
+
+describe('a module path', () => {
+  it('reaches an extensionless side-effect import’s file', () => {
+    expect(importedFiles('src/main.ts')).toContain('src/polyfills.ts');
+  });
+
+  it('reaches a TypeScript import-equals file once', () => {
+    const ids = cg.getNodesInFile('src/main.ts').map((n) => n.id);
+    const toHelper = cg.getOutgoingEdgesFrom(ids, ['imports'])
+      .filter((e) => cg.getNode(e.target)!.filePath === 'src/helper.ts' && cg.getNode(e.target)!.kind === 'file');
+    expect(toHelper.length).toBeLessThanOrEqual(1);
+  });
+});
diff --git a/__tests__/cpp-attribute-macros.test.ts b/__tests__/cpp-attribute-macros.test.ts
new file mode 100644
index 0000000000..af90c4a299
--- /dev/null
+++ b/__tests__/cpp-attribute-macros.test.ts
@@ -0,0 +1,536 @@
+/**
+ * Attribute macros tree-sitter-cpp can't read, in the places the C++ preParse
+ * did not yet blank them:
+ *
+ * - several macros, or one with arguments, between `class` and the name
+ *   (protobuf's generated `class PROTOBUF_EXPORT
+ *   PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Any final : public Message`,
+ *   rocksdb's `struct ALIGN_AS(64U) HandleImpl`), and one before a partial
+ *   specialization's name;
+ * - a macro between a pointer and the declared name (`const Descriptor*
+ *   PROTOBUF_NONNULL descriptor()`), after a parameter list
+ *   (`unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND {`, leveldb's
+ *   `LOCKS_EXCLUDED(mu_) {`), after a declared name (`int count_
+ *   GUARDED_BY(mu_);`), or opening a declaration
+ *   (`PROTOBUF_FUTURE_ADD_EARLY_NODISCARD absl::string_view name() const`);
+ * - a lone macro line with a comment under it ({fmt}'s `FMT_BEGIN_EXPORT`).
+ *
+ * Each misparsed the class around it: protobuf's generated messages had their
+ * members indexed as namespace-level functions, and leveldb's annotated
+ * methods became phantoms named after the annotation.
+ */
+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';
+import {
+  blankCppExportMacros,
+  blankCppPointerAnnotationMacros,
+  blankCppTrailingAttributeMacros,
+  blankCppDeclaratorAttributeMacros,
+  blankCppLeadingAttributeMacros,
+  blankLoneMacroLines,
+  cppExtractor,
+} from '../src/extraction/languages/c-cpp';
+
+/** Assert `blank` removes exactly `macros` from `input` and nothing else, offsets kept. */
+function expectBlanked(blank: (s: string) => string, input: string, macros: string[]): void {
+  const out = blank(input);
+  expect(out.length).toBe(input.length);
+  let expected = input;
+  for (const macro of macros) {
+    const at = expected.indexOf(macro);
+    expect(at, `${macro} in ${input}`).toBeGreaterThanOrEqual(0);
+    expected = expected.slice(0, at) + macro.replace(/[^\r\n]/g, ' ') + expected.slice(at + macro.length);
+  }
+  expect(out).toBe(expected);
+}
+
+describe('C++ attribute-macro blanks', () => {
+  it('blanks every macro between class and the name, and before a specialization', () => {
+    expectBlanked(
+      blankCppExportMacros,
+      'class PROTOBUF_EXPORT  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Any final : public ::google::protobuf::Message {};',
+      ['PROTOBUF_EXPORT  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED']
+    );
+    expectBlanked(
+      blankCppExportMacros,
+      'template <typename Element>\nclass ABSL_ATTRIBUTE_WARN_UNUSED PROTOBUF_DECLSPEC_EMPTY_BASES\n    RepeatedField final\n    : private internal::RepeatedFieldBase {};',
+      ['ABSL_ATTRIBUTE_WARN_UNUSED', 'PROTOBUF_DECLSPEC_EMPTY_BASES']
+    );
+    expectBlanked(
+      blankCppExportMacros,
+      'template <typename T, bool kOrProxy>\nclass PROTOBUF_DECLSPEC_EMPTY_BASES RepeatedFieldProxyWithSet<\n    T, kOrProxy,\n    std::enable_if_t<IsMessage<T>>> {};',
+      ['PROTOBUF_DECLSPEC_EMPTY_BASES']
+    );
+    expectBlanked(blankCppExportMacros, 'struct ALIGN_AS(64U) HandleImpl : public ClockHandle {};', ['ALIGN_AS(64U)']);
+    // An all-caps class name after a macro is the name, `final` included.
+    expectBlanked(blankCppExportMacros, 'class FOO_API BAR_IMPL final : public X {};', ['FOO_API']);
+  });
+
+  it('leaves class heads alone when nothing is defined there', () => {
+    for (const c of [
+      'class FOO_API Name;',
+      'class FOO_API Name<int> var;',
+      'struct STAT_T st = {0};',
+      'class GTEST_1_TUPLE_(T) {',
+      '// class PROTOBUF_EXPORT Any final : public Message {',
+      'const char* s = "class FOO Bar {";',
+    ]) {
+      expect(blankCppExportMacros(c)).toBe(c);
+    }
+  });
+
+  it('blanks annotations between a pointer or reference and the declared name', () => {
+    expectBlanked(
+      blankCppPointerAnnotationMacros,
+      'static const Descriptor* PROTOBUF_NONNULL descriptor() { return d; }',
+      ['PROTOBUF_NONNULL']
+    );
+    expectBlanked(
+      blankCppPointerAnnotationMacros,
+      'void Any::InternalSwap(Any* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {}',
+      ['PROTOBUF_RESTRICT PROTOBUF_NONNULL']
+    );
+    expectBlanked(
+      blankCppPointerAnnotationMacros,
+      'void f(const FieldDescriptor * PROTOBUF_NULLABLE *\n    PROTOBUF_NONNULL field, const T& ABSL_ATTRIBUTE_LIFETIME_BOUND v);',
+      ['PROTOBUF_NULLABLE', 'PROTOBUF_NONNULL', 'ABSL_ATTRIBUTE_LIFETIME_BOUND']
+    );
+    expectBlanked(
+      blankCppPointerAnnotationMacros,
+      'static constexpr const EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE\n    file_level_enum_descriptors = nullptr;',
+      ['PROTOBUF_NONNULL', 'PROTOBUF_NULLABLE']
+    );
+  });
+
+  it('leaves products, bit tests, unnamed parameters and comments alone', () => {
+    for (const c of [
+      'int n = count * MAX_LEN + 1;',
+      'bool b = (flags & FOO_BIT) != 0;',
+      'bool b = flags & FOO_BIT\n    && enabled;',
+      'bool b = flags & FOO_BIT and enabled;',
+      'void f(Foo* PROTOBUF_NONNULL);',
+      '/**\n * NOTE_THIS applies\n * TODO_LATER fix it\n */',
+      'const char* s = "a * PROTOBUF_NONNULL b";',
+      'int digits10 = int(sizeof(int) * CHAR_BIT * 3 / 10);',
+      'int n = 2 * PAGE_SIZE * pages;',
+      '#define PTR_T int *\nFOO_BAR name;',
+    ]) {
+      expect(blankCppPointerAnnotationMacros(c)).toBe(c);
+    }
+  });
+
+  it('blanks attribute macros after a parameter list', () => {
+    expectBlanked(
+      blankCppTrailingAttributeMacros,
+      'const UnknownFieldSet& unknown_fields() const\n      ABSL_ATTRIBUTE_LIFETIME_BOUND {\n  return f;\n}',
+      ['ABSL_ATTRIBUTE_LIFETIME_BOUND']
+    );
+    expectBlanked(blankCppTrailingAttributeMacros, '~Any() PROTOBUF_FINAL;', ['PROTOBUF_FINAL']);
+    expectBlanked(
+      blankCppTrailingAttributeMacros,
+      'void Lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.lock(); }\nvoid Wait() LOCKS_EXCLUDED(mu_);',
+      ['EXCLUSIVE_LOCK_FUNCTION()', 'LOCKS_EXCLUDED(mu_)']
+    );
+    expectBlanked(
+      blankCppTrailingAttributeMacros,
+      'explicit MutexLock(port::Mutex* mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {}',
+      ['EXCLUSIVE_LOCK_FUNCTION(mu)']
+    );
+    expectBlanked(
+      blankCppTrailingAttributeMacros,
+      'bool operator==(const A& a) const ABSL_MUST_USE_RESULT;',
+      ['ABSL_MUST_USE_RESULT']
+    );
+  });
+
+  it('leaves statements, casts and macro calls followed by macros alone', () => {
+    for (const c of [
+      'if (x) RETURN_FALSE;',
+      'while (busy) SPIN_PAUSE;',
+      'int v = (int) MAX_VALUE;',
+      'FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension")\n\nTEST(std_test, bitint) {\n}',
+      'DECLARE_FOO(a) DECLARE_BAR(b);',
+      'void f()\n\nBAR_BAZ;',
+      'bool b = f(x) == FOO_BAR;',
+      // A directive's `)` closes no parameter list.
+      '#  if FMT_USE_FCNTL && !defined(__MINGW32__)\nTEST(file_test, open_windows_file) {\n}',
+      'if constexpr (POS + 1 == str.size())\n  FMT_THROW(format_error("unmatched brace"));',
+    ]) {
+      expect(blankCppTrailingAttributeMacros(c)).toBe(c);
+    }
+  });
+
+  it('blanks attribute macros after a declared name or its brackets', () => {
+    expectBlanked(blankCppDeclaratorAttributeMacros, 'port::CondVar cv GUARDED_BY(mu);', ['GUARDED_BY(mu)']);
+    expectBlanked(blankCppDeclaratorAttributeMacros, 'int refs_ GUARDED_BY(refs_mutex_);', ['GUARDED_BY(refs_mutex_)']);
+    expectBlanked(blankCppDeclaratorAttributeMacros, 'Version* const version GUARDED_BY(mu);', ['GUARDED_BY(mu)']);
+    expectBlanked(
+      blankCppDeclaratorAttributeMacros,
+      'std::map<int, int> cache_ ABSL_GUARDED_BY(mutex_) = {};',
+      ['ABSL_GUARDED_BY(mutex_)']
+    );
+    expectBlanked(
+      blankCppDeclaratorAttributeMacros,
+      'const AnyGlobalsTypeInternal Any_globals_\n    PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);',
+      ['PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro)']
+    );
+    expectBlanked(
+      blankCppDeclaratorAttributeMacros,
+      'const ::uint32_t Table::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(\n    protodesc_cold) = {1, 2};',
+      ['ABSL_ATTRIBUTE_SECTION_VARIABLE(\n    protodesc_cold)']
+    );
+    expectBlanked(
+      blankCppDeclaratorAttributeMacros,
+      'explicit CordInputStream(const absl::Cord* cord ABSL_ATTRIBUTE_LIFETIME_BOUND);',
+      ['ABSL_ATTRIBUTE_LIFETIME_BOUND']
+    );
+  });
+
+  it('leaves variables named in capitals and names without a type before them alone', () => {
+    for (const c of [
+      'Foo DEFAULT_OPTIONS;',
+      'static Foo DEFAULT_OPTIONS;',
+      'const Foo DEFAULT_OPTIONS = Make();',
+      'ns::Foo DEFAULT_OPTIONS;',
+      'typedef Foo BAR_T;',
+      'template <typename T> T MAX_VALUE;',
+      'return x FOO_SUFFIX;',
+      'f(a, b FOO_FLAG);',
+      'x = rate FOO_UNITS;',
+      'EXPECT_EQ(2 SECS_X, d);',
+    ]) {
+      expect(blankCppDeclaratorAttributeMacros(c)).toBe(c);
+    }
+  });
+
+  it('blanks attribute macros that open a declaration', () => {
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      '  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD absl::string_view name() const { return n; }',
+      ['PROTOBUF_FUTURE_ADD_EARLY_NODISCARD']
+    );
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      '  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD static constexpr size_t\n  kMax = 3;',
+      ['PROTOBUF_FUTURE_ADD_EARLY_NODISCARD']
+    );
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      '  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;',
+      ['ABSL_ATTRIBUTE_REINITIALIZES']
+    );
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      '  [[nodiscard]] PROTOBUF_NDEBUG_INLINE Ptr<T> Make(Args&&... args) {}',
+      ['PROTOBUF_NDEBUG_INLINE']
+    );
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      'GTEST_API_ std::string JoinAsTuple(const Strings& fields);',
+      ['GTEST_API_']
+    );
+    expectBlanked(blankCppLeadingAttributeMacros, 'FMT_EXPORT struct as_identifiers_t {};', ['FMT_EXPORT']);
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      'PROTOBUF_NDEBUG_INLINE Any::Impl_::Impl_(Arena* arena) : x_(arena) {}',
+      ['PROTOBUF_NDEBUG_INLINE']
+    );
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      'PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT\n    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const AnyGlobals Any_globals_;',
+      ['PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT\n    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1']
+    );
+  });
+
+  it('leaves a type in capitals alone', () => {
+    for (const c of [
+      'DWORD_PTR value = 0;',
+      'SIZE_T const n = 3;',
+      'UINT_PTR const* p = q;',
+      'HANDLE_T Open(int flags);',
+      'UINT_PTR Foo::Bar() { return 0; }',
+      'RESULT_T operator==(const A& a);',
+      'RESULT_T\nGnuStyle(int x) {}',
+      'int x = a |\n    SOME_CONST\n    | OTHER;',
+      '// PROTOBUF_FUTURE_ADD_EARLY_NODISCARD absl::string_view name() const;',
+      // A macro inside a string concatenation, with a declaration after it.
+      'static const char kHelp[] =\n    "using " GTEST_NAME_\n    ". You can use the\\n"\n    "  --" GTEST_FLAG_PREFIX_\n    "list_tests\\n";\nstatic bool g_help = false;',
+    ]) {
+      expect(blankCppLeadingAttributeMacros(c)).toBe(c);
+    }
+  });
+
+  it('blanks only the macros of a run, not a comment between them', () => {
+    expectBlanked(
+      blankCppLeadingAttributeMacros,
+      'PROTOBUF_ATTRIBUTE_NO_DESTROY /* keep */ PROTOBUF_CONSTINIT const Foo kFoo;',
+      ['PROTOBUF_ATTRIBUTE_NO_DESTROY', 'PROTOBUF_CONSTINIT']
+    );
+  });
+
+  it('blanks a lone macro line with comments under it, but not an operand', () => {
+    const fmt = 'FMT_BEGIN_EXPORT\n\n// A generic formatting context with custom output iterator and character\n/* (code unit) support. */\ntemplate <typename OutputIt, typename Char> class generic_context {};\n';
+    expectBlanked(blankLoneMacroLines, fmt, ['FMT_BEGIN_EXPORT']);
+    // A string literal continues the expression, comment or not.
+    const operand = 'const char* s =\n  "x"\n  FOO_PREFIX\n  // comment\n  "y";\n';
+    expect(blankLoneMacroLines(operand)).toBe(operand);
+  });
+
+  it('keeps every offset through the whole C++ preParse', () => {
+    const src = 'class PROTOBUF_EXPORT X final : public Y {\n  const D* PROTOBUF_NONNULL d() const ABSL_ATTRIBUTE_LIFETIME_BOUND;\n  int n_ GUARDED_BY(mu_);\n};\r\n';
+    const out = cppExtractor.preParse!(src, 'x.h');
+    expect(out.length).toBe(src.length);
+    expect(out.split(/\r?\n/).map((l) => l.length)).toEqual(src.split(/\r?\n/).map((l) => l.length));
+    expect(out).not.toMatch(/PROTOBUF_|ABSL_|GUARDED_BY/);
+  });
+});
+
+const PB_H = `// Generated by the protocol buffer compiler.  DO NOT EDIT!
+#ifndef GOOGLE_PROTOBUF_INCLUDED_any_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_any_2eproto
+
+#include "google/protobuf/message.h"
+
+namespace google {
+namespace protobuf {
+
+class PROTOBUF_EXPORT  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Any final : public ::google::protobuf::Message
+/* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {
+ public:
+  Any() : Any(nullptr) {}
+  ~Any() PROTOBUF_FINAL;
+
+  [[nodiscard]] const ::google::protobuf::UnknownFieldSet& unknown_fields() const
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return _internal_metadata_.unknown_fields();
+  }
+  [[nodiscard]] ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
+    return GetDescriptor();
+  }
+  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
+  GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  void Swap(Any* PROTOBUF_NONNULL other) {
+    InternalSwap(other);
+  }
+  [[nodiscard]] ::std::string* PROTOBUF_NONNULL mutable_type_url();
+
+ private:
+  void InternalSwap(Any* PROTOBUF_NONNULL other);
+};
+
+inline ::std::string* PROTOBUF_NONNULL Any::mutable_type_url() {
+  return _impl_.type_url_.Mutable();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_INCLUDED_any_2eproto
+`;
+
+const MESSAGE_H = `namespace google {
+namespace protobuf {
+
+class Message {
+ public:
+  virtual ~Message();
+};
+
+}  // namespace protobuf
+}  // namespace google
+`;
+
+const PB_CC = `#include "google/protobuf/any.pb.h"
+
+namespace google {
+namespace protobuf {
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const AnyGlobalsTypeInternal Any_globals_
+        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
+
+void Any::InternalSwap(Any* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
+  _impl_.type_url_.InternalSwap(&other->_impl_.type_url_);
+}
+
+}  // namespace protobuf
+}  // namespace google
+`;
+
+const REPEATED_H = `#include <cstddef>
+
+namespace google {
+namespace protobuf {
+
+template <typename Element>
+class ABSL_ATTRIBUTE_WARN_UNUSED PROTOBUF_DECLSPEC_EMPTY_BASES
+    RepeatedField final
+    : private internal::RepeatedFieldBase {
+ public:
+  int size() const { return size_; }
+
+ private:
+  int size_;
+};
+
+}  // namespace protobuf
+}  // namespace google
+`;
+
+const DESCRIPTOR_H = `#include <string>
+
+namespace google {
+namespace protobuf {
+
+class PROTOBUF_EXPORT Descriptor : private internal::SymbolBase {
+ public:
+  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD absl::string_view name() const {
+    return all_names_[0];
+  }
+  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD absl::string_view full_name() const {
+    return all_names_[1];
+  }
+  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD const FileDescriptor* file() const;
+};
+
+}  // namespace protobuf
+}  // namespace google
+`;
+
+const FMT_H = `#include <string>
+
+#define FMT_BEGIN_EXPORT
+FMT_BEGIN_NAMESPACE
+
+FMT_BEGIN_EXPORT
+
+// A generic formatting context with custom output iterator and character
+// (code unit) support.
+template <typename OutputIt, typename Char> class generic_context {
+ private:
+  OutputIt out_;
+
+ public:
+  constexpr auto out() -> OutputIt { return out_; }
+};
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+`;
+
+const LEVELDB_CC = `#include "port/port.h"
+
+namespace leveldb {
+
+class Counter {
+ public:
+  void IncrementBy(int count) LOCKS_EXCLUDED(mu_) {
+    MutexLock l(&mu_);
+    count_ += count;
+  }
+  void Lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.Lock(); }
+
+ private:
+  port::Mutex mu_;
+  int count_ GUARDED_BY(mu_);
+};
+
+}  // namespace leveldb
+`;
+
+describe('C++ classes written around attribute macros', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cpp-attr-macros-'));
+    const files: Record<string, string> = {
+      'src/google/protobuf/message.h': MESSAGE_H,
+      'src/google/protobuf/any.pb.h': PB_H,
+      'src/google/protobuf/any.pb.cc': PB_CC,
+      'src/google/protobuf/repeated_field.h': REPEATED_H,
+      'src/google/protobuf/descriptor.h': DESCRIPTOR_H,
+      'include/fmt/format.h': FMT_H,
+      'db/counter.cc': LEVELDB_CC,
+    };
+    for (const [rel, text] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+      fs.writeFileSync(path.join(root, rel), text);
+    }
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const nodes = (file: string) => cg.getNodesInFile(file);
+  const qualified = (file: string, kind: string) =>
+    nodes(file).filter((n) => n.kind === kind).map((n) => n.qualifiedName).sort();
+
+  it('indexes a generated message class with its members as methods', () => {
+    const file = 'src/google/protobuf/any.pb.h';
+    expect(qualified(file, 'class')).toEqual(['google::protobuf::Any']);
+    expect(qualified(file, 'method')).toEqual(
+      expect.arrayContaining([
+        'google::protobuf::Any::Any',
+        'google::protobuf::Any::GetDescriptor',
+        'google::protobuf::Any::GetReflection',
+        'google::protobuf::Any::Swap',
+        'google::protobuf::Any::descriptor',
+        'google::protobuf::Any::mutable_type_url',
+        'google::protobuf::Any::mutable_unknown_fields',
+        'google::protobuf::Any::unknown_fields',
+      ])
+    );
+    // No member is left at namespace level, and no node is named after a macro.
+    expect(qualified(file, 'function')).toEqual([]);
+    expect(nodes(file).filter((n) => /PROTOBUF_|ABSL_/.test(n.qualifiedName))).toEqual([]);
+    const any = nodes(file).find((n) => n.kind === 'class')!;
+    const bases = cg.getOutgoingEdges(any.id).filter((e) => e.kind === 'extends');
+    expect(bases.map((e) => cg.getNode(e.target)?.qualifiedName)).toEqual(['google::protobuf::Message']);
+  });
+
+  it('indexes an out-of-line definition whose parameter carries an annotation', () => {
+    expect(qualified('src/google/protobuf/any.pb.cc', 'method')).toEqual(['google::protobuf::Any::InternalSwap']);
+  });
+
+  it('indexes a class whose head stacks macros over several lines', () => {
+    const file = 'src/google/protobuf/repeated_field.h';
+    expect(qualified(file, 'class')).toEqual(['google::protobuf::RepeatedField']);
+    expect(qualified(file, 'method')).toEqual(['google::protobuf::RepeatedField::size']);
+  });
+
+  it('indexes members that open with an attribute macro', () => {
+    const file = 'src/google/protobuf/descriptor.h';
+    expect(qualified(file, 'method')).toEqual([
+      'google::protobuf::Descriptor::full_name',
+      'google::protobuf::Descriptor::name',
+    ]);
+  });
+
+  it('indexes a class under a lone macro line and a comment', () => {
+    expect(qualified('include/fmt/format.h', 'method')).toEqual(['generic_context::out']);
+    expect(qualified('include/fmt/format.h', 'function')).toEqual([]);
+  });
+
+  it('keeps annotated methods instead of phantoms named after the annotation', () => {
+    const file = 'db/counter.cc';
+    expect(qualified(file, 'method')).toEqual(['leveldb::Counter::IncrementBy', 'leveldb::Counter::Lock']);
+    expect(nodes(file).filter((n) => /LOCKS|GUARDED/.test(n.name))).toEqual([]);
+  });
+});
diff --git a/__tests__/cpp-base-class-lookup.test.ts b/__tests__/cpp-base-class-lookup.test.ts
new file mode 100644
index 0000000000..5774eb6ba9
--- /dev/null
+++ b/__tests__/cpp-base-class-lookup.test.ts
@@ -0,0 +1,513 @@
+/**
+ * A C++ base class — `class DynamicMessage final : public Message` — is the
+ * class C++ name lookup finds from where the deriving class is declared.
+ *
+ * The base was matched by its name alone, so one named like a class of
+ * another namespace bound to whichever namesake ranked first.
+ * protocolbuffers/protobuf's `google::protobuf::DynamicMessage` derived from
+ * `json_internal::ResolverPool::Message` (and, before #2397, from the PHP
+ * extension's C struct `Message`); google/leveldb's iterators derived from
+ * `SkipList::Iterator`, and its test comparators from a struct
+ * `skiplist_test.cc` declares for itself. The wrong supertype then fed the
+ * type hierarchy, the cpp-override edges from a base method to its overrides,
+ * and the supertype walk that resolves a call to an inherited method.
+ *
+ * The lookup goes outwards from the scope the class is declared in: a class
+ * scope with its bases, a qualified name a segment at a time, an alias
+ * followed to the class it names, `::Base` from the global scope. Then
+ * through what the file writes before the class: a namespace alias, a
+ * using-declaration, a using-directive. A class a source file defines is that
+ * translation unit's own. A template parameter names no class. When none of
+ * that finds it, a class of that name the file can see is taken only when it
+ * is the only one.
+ */
+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';
+import { buildTypeHierarchy } from '../src/graph/type-hierarchy';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  // protocolbuffers/protobuf: the real `Message`, a nested namesake in
+  // json_internal, and the PHP extension's C struct.
+  'src/google/protobuf/message_lite.h': [
+    'namespace google {',
+    'namespace protobuf {',
+    'namespace internal {',
+    'class MessageGlobalsBase {',
+    ' public:',
+    '  int default_instance() const { return 0; }',
+    '};',
+    '}  // namespace internal',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  'src/google/protobuf/message.h': [
+    '#include "google/protobuf/message_lite.h"',
+    'namespace google {',
+    'namespace protobuf {',
+    'class Message {',
+    ' public:',
+    '  virtual ~Message();',
+    '  virtual int ByteSizeLong() const = 0;',
+    '};',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  'src/google/protobuf/json/internal/untyped_message.h': [
+    'namespace google {',
+    'namespace protobuf {',
+    'namespace json_internal {',
+    'class ResolverPool {',
+    ' public:',
+    '  class Message {',
+    '   public:',
+    '    int ByteSizeLong() const { return 0; }',
+    '  };',
+    '};',
+    '}  // namespace json_internal',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  'php/ext/google/protobuf/message.c': [
+    'typedef struct {',
+    '  int std;',
+    '} Message;',
+    '',
+  ].join('\n'),
+  'src/google/protobuf/dynamic_message.cc': [
+    '#include "google/protobuf/message.h"',
+    'namespace google {',
+    'namespace protobuf {',
+    'class DynamicMessage final : public Message {',
+    ' public:',
+    '  int ByteSizeLong() const override { return 1; }',
+    '};',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  'src/google/protobuf/generated_message_bases.h': [
+    '#include "google/protobuf/message.h"',
+    'namespace google {',
+    'namespace protobuf {',
+    'namespace internal {',
+    'class ZeroFieldsBase : public Message {',
+    ' public:',
+    '  int ByteSizeLong() const override { return 0; }',
+    '};',
+    '}  // namespace internal',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  // Generated code names its bases through a namespace alias.
+  'src/google/protobuf/any.pb.cc': [
+    '#include "google/protobuf/message_lite.h"',
+    'namespace _pbi = ::google::protobuf::internal;',
+    'namespace google {',
+    'namespace protobuf {',
+    'struct AnyGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {',
+    '  int x;',
+    '};',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+
+  // google/leveldb: the public iterator, the skip list's nested one, a test's
+  // own `Comparator`, and the C API's using-declarations.
+  'include/leveldb/iterator.h': [
+    'namespace leveldb {',
+    'class Iterator {',
+    ' public:',
+    '  virtual ~Iterator();',
+    '  virtual bool Valid() const = 0;',
+    '  virtual void Next() = 0;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/skiplist.h': [
+    'namespace leveldb {',
+    'template <typename Key, class Comparator>',
+    'class SkipList {',
+    ' public:',
+    '  class Iterator {',
+    '   public:',
+    '    bool Valid() const { return node_ != nullptr; }',
+    '    void Next() { node_ = nullptr; }',
+    '    void SeekToFirst() { node_ = nullptr; }',
+    '   private:',
+    '    const char* node_;',
+    '  };',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/db_iter.cc': [
+    '#include "include/leveldb/iterator.h"',
+    'namespace leveldb {',
+    'class DBIter : public Iterator {',
+    ' public:',
+    '  bool Valid() const override { return valid_; }',
+    '  void Next() override { valid_ = false; }',
+    ' private:',
+    '  bool valid_;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'include/leveldb/comparator.h': [
+    'namespace leveldb {',
+    'class Comparator {',
+    ' public:',
+    '  virtual int Compare(const char* a, const char* b) const = 0;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/skiplist_test.cc': [
+    'namespace leveldb {',
+    'struct Comparator {',
+    '  int operator()(const int& a, const int& b) const { return a - b; }',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/db_test.cc': [
+    '#include "include/leveldb/comparator.h"',
+    'namespace leveldb {',
+    'class NumberComparator : public Comparator {',
+    ' public:',
+    '  int Compare(const char* a, const char* b) const override { return 0; }',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'include/leveldb/filter_policy.h': [
+    'namespace leveldb {',
+    'class FilterPolicy {',
+    ' public:',
+    '  virtual const char* Name() const = 0;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/c.cc': [
+    '#include "include/leveldb/filter_policy.h"',
+    'using leveldb::FilterPolicy;',
+    'struct leveldb_filterpolicy_t : public FilterPolicy {',
+    '  const char* Name() const override { return "c"; }',
+    '};',
+    '',
+  ].join('\n'),
+
+  // facebook/rocksdb: a nested class's base is a member its outer class
+  // inherits; a base named through an alias; a using-directive.
+  'cache/clock_cache.h': [
+    'namespace rocksdb {',
+    'namespace clock_cache {',
+    'class BaseClockTable {',
+    ' public:',
+    '  struct BaseOpts {',
+    '    int eviction_effort_cap;',
+    '  };',
+    '};',
+    'class AutoHyperClockTable : public BaseClockTable {',
+    ' public:',
+    '  struct Opts : public BaseOpts {',
+    '    int min_avg_value_size;',
+    '  };',
+    '};',
+    '}  // namespace clock_cache',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'cache/lru_cache.h': [
+    'namespace rocksdb {',
+    'namespace lru_cache {',
+    'struct BaseOpts {',
+    '  int capacity;',
+    '};',
+    '}  // namespace lru_cache',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'table/internal_iterator.h': [
+    'namespace rocksdb {',
+    'class Slice {};',
+    'template <class TValue>',
+    'class InternalIteratorBase {',
+    ' public:',
+    '  virtual void Next() = 0;',
+    '  void SeekToFirst() {}',
+    '};',
+    'using InternalIterator = InternalIteratorBase<Slice>;',
+    'template <bool B> using bool_constant = std::integral_constant<bool, B>;',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'table/merging_iterator.cc': [
+    '#include "table/internal_iterator.h"',
+    'namespace rocksdb {',
+    'class MergingIterator : public InternalIterator {',
+    ' public:',
+    '  void Next() override {}',
+    '};',
+    'void Rewind(MergingIterator* iter) {',
+    '  iter->SeekToFirst();',
+    '}',
+    'template <typename T>',
+    'struct is_fast_float : bool_constant<sizeof(T) <= sizeof(double)> {};',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'include/rocksdb/listener.h': [
+    'namespace rocksdb {',
+    'class EventListener {',
+    ' public:',
+    '  virtual void OnFlushCompleted() {}',
+    '};',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'examples/compact_files_example.cc': [
+    '#include "include/rocksdb/listener.h"',
+    'using namespace rocksdb;',
+    'class Compactor : public EventListener {',
+    ' public:',
+    '  void OnFlushCompleted() override {}',
+    '};',
+    '',
+  ].join('\n'),
+
+  // googletest: a base named from the global scope.
+  'test/gtest/gtest.h': [
+    'namespace testing {',
+    'class Test {',
+    ' public:',
+    '  virtual void TestBody() = 0;',
+    '};',
+    'namespace internal {',
+    'class SuiteApiResolver {',
+    ' public:',
+    '  typedef int Test;',
+    '};',
+    '}  // namespace internal',
+    '}  // namespace testing',
+    '',
+  ].join('\n'),
+  'test/gtest-extra-test.cc': [
+    '#include "test/gtest/gtest.h"',
+    'class single_evaluation_test : public ::testing::Test {',
+    ' protected:',
+    '  void TestBody() override {}',
+    '};',
+    '',
+  ].join('\n'),
+
+  // A template parameter names no class, whatever the project declares.
+  'util/mixin.h': [
+    'class Base {',
+    ' public:',
+    '  void Run() {}',
+    '};',
+    'template <class Base>',
+    'class Logged : public Base {',
+    ' public:',
+    '  void Log() {}',
+    '};',
+    '',
+  ].join('\n'),
+
+  // A header's using-directive the file itself does not repeat.
+  'util/testharness.h': [
+    '#include "include/leveldb/env.h"',
+    'using namespace leveldb;',
+    '',
+  ].join('\n'),
+  'include/leveldb/env.h': [
+    'namespace leveldb {',
+    'class EnvWrapper {',
+    ' public:',
+    '  virtual int NowMicros() { return 0; }',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'util/env_test.cc': [
+    '#include "util/testharness.h"',
+    'class SleepingEnv : public EnvWrapper {',
+    ' public:',
+    '  int NowMicros() override { return 1; }',
+    '};',
+    '',
+  ].join('\n'),
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cpp-bases-'));
+  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 });
+}, 60_000);
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function node(qualifiedName: string, file: string): Node {
+  const name = qualifiedName.split('::').pop()!;
+  const found = cg.getNodesByName(name).filter((n) => n.qualifiedName === qualifiedName && n.filePath === file && n.kind !== 'import');
+  expect(found, `${qualifiedName} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** The supertypes of a class, as `kind qualifiedName (file) resolvedBy`. */
+function supertypes(qualifiedName: string, file: string): string[] {
+  return cg
+    .getOutgoingEdgesFrom([node(qualifiedName, file).id], ['extends', 'implements'])
+    .map((e) => {
+      const target = cg.getNode(e.target);
+      return `${e.kind} ${target?.qualifiedName} (${target?.filePath}) ${String(e.metadata?.resolvedBy)}`;
+    })
+    .sort();
+}
+
+/** The base names a class's file names that stay unresolved. */
+function unresolved(qualifiedName: string, file: string): string[] {
+  return cg
+    .getUnresolvedReferencesFrom(node(qualifiedName, file).id)
+    .filter((r) => r.referenceKind === 'extends' || r.referenceKind === 'implements')
+    .map((r) => r.referenceName)
+    .sort();
+}
+
+describe('a C++ base class is the one name lookup finds from the deriving class', () => {
+  it('finds the base in the namespaces around the class, not a namesake elsewhere', () => {
+    expect(supertypes('google::protobuf::DynamicMessage', 'src/google/protobuf/dynamic_message.cc')).toEqual([
+      'extends google::protobuf::Message (src/google/protobuf/message.h) qualified-name',
+    ]);
+    expect(supertypes('google::protobuf::internal::ZeroFieldsBase', 'src/google/protobuf/generated_message_bases.h')).toEqual([
+      'extends google::protobuf::Message (src/google/protobuf/message.h) qualified-name',
+    ]);
+    expect(supertypes('leveldb::DBIter', 'db/db_iter.cc')).toEqual([
+      'extends leveldb::Iterator (include/leveldb/iterator.h) qualified-name',
+    ]);
+  });
+
+  it('never takes a class another source file defines for its own translation unit', () => {
+    expect(supertypes('leveldb::NumberComparator', 'db/db_test.cc')).toEqual([
+      'extends leveldb::Comparator (include/leveldb/comparator.h) qualified-name',
+    ]);
+  });
+
+  it('looks a nested class base up in its outer class and the classes that one inherits', () => {
+    expect(supertypes('rocksdb::clock_cache::AutoHyperClockTable::Opts', 'cache/clock_cache.h')).toEqual([
+      'extends rocksdb::clock_cache::BaseClockTable::BaseOpts (cache/clock_cache.h) qualified-name',
+    ]);
+  });
+
+  it('reads the namespace aliases, using-declarations and using-directives the file writes', () => {
+    expect(supertypes('google::protobuf::AnyGlobalsTypeInternal', 'src/google/protobuf/any.pb.cc')).toEqual([
+      'extends google::protobuf::internal::MessageGlobalsBase (src/google/protobuf/message_lite.h) qualified-name',
+    ]);
+    expect(supertypes('leveldb_filterpolicy_t', 'db/c.cc')).toEqual([
+      'extends leveldb::FilterPolicy (include/leveldb/filter_policy.h) qualified-name',
+    ]);
+    expect(supertypes('Compactor', 'examples/compact_files_example.cc')).toEqual([
+      'extends rocksdb::EventListener (include/rocksdb/listener.h) qualified-name',
+    ]);
+  });
+
+  it('finds `::testing::Test` from the global scope, not a nested `Test` typedef', () => {
+    expect(supertypes('single_evaluation_test', 'test/gtest-extra-test.cc')).toEqual([
+      'extends testing::Test (test/gtest/gtest.h) qualified-name',
+    ]);
+  });
+
+  it('follows an alias to the class it names, and links an alias of an outside type itself', () => {
+    expect(supertypes('rocksdb::MergingIterator', 'table/merging_iterator.cc')).toEqual([
+      'extends rocksdb::InternalIteratorBase (table/internal_iterator.h) qualified-name',
+    ]);
+    // `bool_constant<sizeof(T) <= sizeof(double)>`: the comparison is no template bracket.
+    expect(supertypes('rocksdb::is_fast_float', 'table/merging_iterator.cc')).toEqual([
+      'extends rocksdb::bool_constant (table/internal_iterator.h) qualified-name',
+    ]);
+  });
+
+  it('leaves a template parameter unresolved', () => {
+    expect(supertypes('Logged', 'util/mixin.h')).toEqual([]);
+    expect(unresolved('Logged', 'util/mixin.h')).toEqual(['Base']);
+  });
+
+  it('takes the only class of that name the file can see when the lookup finds none', () => {
+    // `using namespace leveldb;` is in a header the file includes.
+    expect(supertypes('SleepingEnv', 'util/env_test.cc')).toEqual([
+      'extends leveldb::EnvWrapper (include/leveldb/env.h) exact-match',
+    ]);
+  });
+
+  it('never resolves a C or C++ base through a framework resolver or to another language', () => {
+    const bases = cg
+      .getNodesByKind('class')
+      .concat(cg.getNodesByKind('struct'))
+      .filter((n) => n.language === 'cpp' || n.language === 'c');
+    const edges = cg.getOutgoingEdgesFrom(bases.map((n) => n.id), ['extends', 'implements']);
+    expect(edges.length).toBeGreaterThan(0);
+    for (const e of edges) {
+      const target = cg.getNode(e.target);
+      expect(e.metadata?.resolvedBy, `${cg.getNode(e.source)?.qualifiedName} → ${target?.qualifiedName}`).not.toBe('framework');
+      expect(['c', 'cpp']).toContain(target?.language);
+    }
+    expect(cg.getIncomingEdgesTo([node('Message', 'php/ext/google/protobuf/message.c').id], ['extends'])).toEqual([]);
+  });
+});
+
+describe('what the hierarchy feeds', () => {
+  it('links each base method to the overrides of the right subclasses', () => {
+    const overrides = (qualifiedName: string, file: string): string[] =>
+      cg
+        .getOutgoingEdgesFrom([node(qualifiedName, file).id], ['calls'])
+        .filter((e) => e.metadata?.synthesizedBy === 'cpp-override')
+        .map((e) => cg.getNode(e.target)?.qualifiedName ?? '')
+        .sort();
+    expect(overrides('leveldb::Iterator::Next', 'include/leveldb/iterator.h')).toEqual(['leveldb::DBIter::Next']);
+    expect(overrides('leveldb::SkipList::Iterator::Next', 'db/skiplist.h')).toEqual([]);
+    expect(overrides('google::protobuf::Message::ByteSizeLong', 'src/google/protobuf/message.h')).toEqual([
+      'google::protobuf::DynamicMessage::ByteSizeLong',
+      'google::protobuf::internal::ZeroFieldsBase::ByteSizeLong',
+    ]);
+    expect(overrides('google::protobuf::json_internal::ResolverPool::Message::ByteSizeLong', 'src/google/protobuf/json/internal/untyped_message.h')).toEqual([]);
+    // Through the alias: InternalIterator is InternalIteratorBase.
+    expect(overrides('rocksdb::InternalIteratorBase::Next', 'table/internal_iterator.h')).toEqual(['rocksdb::MergingIterator::Next']);
+  });
+
+  it('resolves a call to an inherited method on the base an alias names', () => {
+    const callees = cg
+      .getOutgoingEdgesFrom([node('rocksdb::Rewind', 'table/merging_iterator.cc').id], ['calls'])
+      .map((e) => `${cg.getNode(e.target)?.qualifiedName} (${cg.getNode(e.target)?.filePath})`);
+    expect(callees).toEqual(['rocksdb::InternalIteratorBase::SeekToFirst (table/internal_iterator.h)']);
+  });
+
+  it('shows the real ancestors in the type hierarchy', () => {
+    const ancestors = (qualifiedName: string, file: string): string[] =>
+      (buildTypeHierarchy(cg, node(qualifiedName, file))?.ancestors ?? []).map((a) => `${a.relation} ${a.node.qualifiedName} (${a.node.filePath})`);
+    expect(ancestors('google::protobuf::DynamicMessage', 'src/google/protobuf/dynamic_message.cc')).toEqual([
+      'extends google::protobuf::Message (src/google/protobuf/message.h)',
+    ]);
+    expect(ancestors('leveldb::DBIter', 'db/db_iter.cc')).toEqual(['extends leveldb::Iterator (include/leveldb/iterator.h)']);
+  });
+});
diff --git a/__tests__/cpp-brace-scopes.test.ts b/__tests__/cpp-brace-scopes.test.ts
new file mode 100644
index 0000000000..f29c76b099
--- /dev/null
+++ b/__tests__/cpp-brace-scopes.test.ts
@@ -0,0 +1,386 @@
+/**
+ * A C++ class keeps the namespaces and enclosing classes it is declared in
+ * when tree-sitter's error recovery closes one of them at the wrong `}`.
+ *
+ * tree-sitter recovers from a construct it can't parse by inserting the token
+ * it expected, and inside a class that is often a `}`. An unknown macro in
+ * front of a member (protobuf's `PROTOBUF_FUTURE_ADD_EARLY_NODISCARD
+ * absl::string_view name() const`) or in a class head (rocksdb's `struct
+ * ALIGN_AS(64U) HandleImpl`) closed the class there, and every `}` after it
+ * then closed the scope one level out. The rest of the class parsed as
+ * declarations of its namespace, and the rest of each namespace as
+ * declarations of the one around it:
+ *  - protobuf's `FieldDescriptor` was indexed as `FieldDescriptor`, not
+ *    `google::protobuf::FieldDescriptor`;
+ *  - rocksdb's `struct Opts` lost the class it is declared in, and
+ *    `AutoHyperClockTable` lost `clock_cache::`;
+ *  - a scope could also stay open past its own `}`, putting the next class
+ *    inside the previous one.
+ * Lookups that start from a declaration's scope (base classes, alias
+ * receivers, constructors) then had only a unique-name guess left.
+ *
+ * The C++ preParse now blanks both of those macros, so the fixtures below
+ * keep the shapes with macros it doesn't know: a one-word attribute macro
+ * (`NODISCARD`) and a lowercase one in a class head (`cacheline_aligned(64U)`).
+ *
+ * For a file whose tree has errors, the walker now takes each declaration's
+ * namespaces and enclosing classes from the source's braces, which the
+ * parser rarely misreads; a class the tree glued into a declaration's type is
+ * still walked as a class. Files that parse cleanly keep the tree's scopes.
+ * The native kernel defers erroring files to this walker; under its
+ * error-extract sweep hatch it must produce the same result.
+ */
+import { describe, it, expect, beforeAll, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages, getParser } from '../src/extraction/grammars';
+import { cppExtractor } from '../src/extraction/languages/c-cpp';
+import { scanCppBraceScopes } from '../src/extraction/languages/cpp-brace-scopes';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult, Node } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** protocolbuffers/protobuf descriptor.h: an unknown attribute macro in front of a member. */
+const PROTOBUF_SHAPE = `namespace google {
+namespace protobuf {
+
+class Names {
+ public:
+  NODISCARD absl::string_view name() const {
+    return absl::string_view(payload_);
+  }
+
+ private:
+  const char* payload_;
+};
+
+class FieldDescriptor : private internal::SymbolBase {
+ public:
+  int index() const;
+};
+
+}  // namespace protobuf
+}  // namespace google
+`;
+
+/** facebook/rocksdb cache/clock_cache.h: a macro call in a nested struct's head. */
+const ROCKSDB_SHAPE = `namespace rocksdb {
+namespace clock_cache {
+
+class FixedTable : public BaseTable {
+ public:
+  struct cacheline_aligned(64U) HandleImpl : public ClockHandle {
+    RelaxedAtomic<uint32_t> displacements{};
+    bool standalone = false;
+  };
+
+  struct Opts : public BaseOpts {
+    explicit Opts(size_t size) : BaseOpts(0), size(size) {}
+    size_t size;
+  };
+
+  void Insert(const Opts& opts);
+};
+
+class AutoTable : public BaseTable {
+ public:
+  void Erase();
+};
+
+}  // namespace clock_cache
+}  // namespace rocksdb
+`;
+
+/** A function head per #if branch: recovery keeps the class open past its own `}`. */
+const BRANCHES_SHAPE = `namespace net {
+
+class Socket {
+ public:
+#ifdef _WIN32
+  int Open(SOCKET handle) {
+#else
+  int Open(int fd) {
+#endif
+    return Bind();
+  }
+
+  int Bind();
+};
+
+class Listener {
+ public:
+  void Accept() {}
+};
+
+}  // namespace net
+`;
+
+/** fmtlib/fmt core.h: \`unsigned(id) < unsigned(…)\` read as a template turns the namespaces into an ERROR. */
+const FMT_SHAPE = `namespace fmt {
+namespace detail {
+
+template <typename Context> class basic_format_args {
+ public:
+  FMT_CONSTEXPR auto get(int id) const -> format_arg {
+    auto arg = format_arg();
+    if (!is_packed()) {
+      if (unsigned(id) < unsigned(max_size())) arg = args_[id];
+      return arg;
+    }
+    if (unsigned(id) >= detail::max_packed_args) return arg;
+    return arg;
+  }
+
+  auto max_size() const -> int { return 0; }
+};
+
+class context {
+ public:
+  void advance_to(int it) {}
+};
+
+}  // namespace detail
+}  // namespace fmt
+`;
+
+const SHAPES: Record<string, string> = {
+  'descriptor.h': PROTOBUF_SHAPE,
+  'clock_cache.h': ROCKSDB_SHAPE,
+  'socket.h': BRANCHES_SHAPE,
+  'core.h': FMT_SHAPE,
+};
+
+function wasmExtract(file: string, source: string): ExtractionResult {
+  const saved = process.env.CODEGRAPH_KERNEL;
+  process.env.CODEGRAPH_KERNEL = '0';
+  try {
+    return extractFromSource(file, source, 'cpp');
+  } finally {
+    if (saved === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = saved;
+  }
+}
+
+const named = (result: ExtractionResult, kind: string): string[] =>
+  result.nodes.filter((n) => n.kind === kind).map((n) => n.qualifiedName);
+
+const nodeAt = (result: ExtractionResult, qualifiedName: string): Node | undefined =>
+  result.nodes.find((n) => n.qualifiedName === qualifiedName);
+
+describe('C++ scopes from the source braces of a file whose tree has errors', () => {
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['cpp']);
+  });
+
+  it('every fixture still misparses (else the cases below prove nothing)', () => {
+    for (const [file, source] of Object.entries(SHAPES)) {
+      const tree = getParser('cpp')!.parse(cppExtractor.preParse!(source, file))!;
+      expect(tree.rootNode.hasError, file).toBe(true);
+      tree.delete();
+    }
+  });
+
+  it('a class after one closed early keeps its namespaces (protobuf FieldDescriptor)', () => {
+    const result = wasmExtract('src/google/protobuf/descriptor.h', PROTOBUF_SHAPE);
+    expect(named(result, 'class')).toEqual(['google::protobuf::Names', 'google::protobuf::FieldDescriptor']);
+    // `Names` is the one recovery glued to the tokens after it: it ends at its own `};`.
+    expect(nodeAt(result, 'google::protobuf::Names')!.endLine).toBe(12);
+  });
+
+  it('a nested struct keeps its class and the next class its namespaces (rocksdb clock_cache)', () => {
+    const result = wasmExtract('cache/clock_cache.h', ROCKSDB_SHAPE);
+    expect(named(result, 'class')).toEqual(['rocksdb::clock_cache::FixedTable', 'rocksdb::clock_cache::AutoTable']);
+    expect(named(result, 'struct')).toEqual(['rocksdb::clock_cache::FixedTable::Opts']);
+    expect(named(result, 'method')).toEqual(['rocksdb::clock_cache::FixedTable::Opts::Opts']);
+    // The class spans its whole body, so the struct it holds lies inside it.
+    const fixed = nodeAt(result, 'rocksdb::clock_cache::FixedTable')!;
+    expect([fixed.startLine, fixed.endLine]).toEqual([4, 17]);
+    const contains = result.edges.find(
+      (e) => e.kind === 'contains' && e.target === nodeAt(result, 'rocksdb::clock_cache::FixedTable::Opts')!.id
+    );
+    expect(contains?.source).toBe(fixed.id);
+  });
+
+  it('a class the tree kept open past its `}` lets go of the next class', () => {
+    const result = wasmExtract('net/socket.h', BRANCHES_SHAPE);
+    expect(named(result, 'class')).toEqual(['net::Socket', 'net::Listener']);
+    expect(named(result, 'method')).toContain('net::Listener::Accept');
+    expect(nodeAt(result, 'net::Socket')!.endLine).toBe(14);
+  });
+
+  it('namespaces the tree swallowed into an ERROR still prefix what they hold (fmt core.h)', () => {
+    const result = wasmExtract('include/fmt/core.h', FMT_SHAPE);
+    expect(named(result, 'class')).toEqual(['fmt::detail::context']);
+    expect(named(result, 'method')).toEqual(['fmt::detail::context::advance_to']);
+  });
+
+  it('a file that parses cleanly keeps the tree scopes', () => {
+    const clean = PROTOBUF_SHAPE.replace('NODISCARD ', '');
+    const tree = getParser('cpp')!.parse(cppExtractor.preParse!(clean, 'descriptor.h'))!;
+    expect(tree.rootNode.hasError).toBe(false);
+    tree.delete();
+    const result = wasmExtract('src/google/protobuf/descriptor.h', clean);
+    expect(named(result, 'class')).toEqual(['google::protobuf::Names', 'google::protobuf::FieldDescriptor']);
+    expect(named(result, 'method')).toEqual(['google::protobuf::Names::name']);
+  });
+
+  it('the base class of a class that lost its namespace resolves by scope lookup', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cpp-brace-scopes-'));
+    try {
+      fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+      fs.writeFileSync(path.join(dir, 'src', 'descriptor.h'), PROTOBUF_SHAPE);
+      // The base, and a namesake in another namespace: with the namespace
+      // lost, neither a scope lookup nor the only-candidate guess finds it.
+      fs.writeFileSync(
+        path.join(dir, 'src', 'symbol_base.h'),
+        'namespace google {\nnamespace protobuf {\nnamespace internal {\nclass SymbolBase {\n public:\n  int kind() const;\n};\n}  // namespace internal\n}  // namespace protobuf\n}  // namespace google\n'
+      );
+      fs.writeFileSync(
+        path.join(dir, 'src', 'other.h'),
+        'namespace other {\nnamespace internal {\nclass SymbolBase {\n public:\n  int kind() const;\n};\n}  // namespace internal\n}  // namespace other\n'
+      );
+      const cg = await CodeGraph.init(dir);
+      try {
+        await cg.indexAll();
+        const derived = cg.searchNodes('FieldDescriptor').map((r) => r.node).find((n) => n.kind === 'class')!;
+        expect(derived.qualifiedName).toBe('google::protobuf::FieldDescriptor');
+        const bases = cg
+          .getOutgoingEdges(derived.id)
+          .filter((e) => e.kind === 'extends')
+          .map((e) => cg.getNode(e.target)?.qualifiedName);
+        expect(bases).toEqual(['google::protobuf::internal::SymbolBase']);
+      } finally {
+        cg.close();
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('scanCppBraceScopes', () => {
+  it('matches braces past comments, literals and preprocessor lines', () => {
+    const source = [
+      'namespace a {',
+      '// } a comment',
+      '/* { */ const char* s = "}{";',
+      "char c = '}'; int n = 1'000'000;",
+      'auto r = R"x(})x";',
+      '#define OPEN {',
+      'struct S { int x; };',
+      '}',
+      '',
+    ].join('\n');
+    const scopes = scanCppBraceScopes(source)!;
+    expect(scopes).not.toBeNull();
+    const open = source.indexOf('{');
+    expect(scopes.closeOf(open)).toBe(source.lastIndexOf('}'));
+    const struct = source.indexOf('S {') + 2;
+    expect(source.slice(struct, scopes.closeOf(struct)! + 1)).toBe('{ int x; }');
+    expect(scopes.namespacesAt(struct)).toEqual(['a']);
+  });
+
+  it('reads each #if branch from the braces open at the #if', () => {
+    const source = [
+      'namespace a {',
+      '#if defined(X)',
+      'struct S : Base {',
+      '#else',
+      'struct S {',
+      '#endif',
+      '  int x;',
+      '};',
+      'struct T {};',
+      '}',
+      '',
+    ].join('\n');
+    const scopes = scanCppBraceScopes(source)!;
+    expect(scopes).not.toBeNull();
+    const first = source.indexOf('Base {') + 5;
+    expect(scopes.closeOf(first)).toBe(source.indexOf('};'));
+    expect(scopes.namespacesAt(source.indexOf('struct T'))).toEqual(['a']);
+  });
+
+  it('names namespaces as written and skips what declares none', () => {
+    const source = [
+      'namespace a::b {',
+      'namespace [[deprecated]] c {',
+      'inline namespace v1 {',
+      'namespace {',
+      'using namespace std;',
+      'namespace fs = std::filesystem;',
+      'int here;',
+      '}',
+      '}',
+      '}',
+      '}',
+      'namespace std _GLIBCXX_VISIBILITY(default) {',
+      'int there;',
+      '}',
+      '',
+    ].join('\n');
+    const scopes = scanCppBraceScopes(source)!;
+    expect(scopes.namespacesAt(source.indexOf('int here'))).toEqual(['a::b', 'c', 'v1']);
+    expect(scopes.namespacesAt(source.indexOf('int there'))).toEqual(['std']);
+  });
+
+  it('gives up on braces that do not balance', () => {
+    expect(scanCppBraceScopes('namespace a {\nint x;\n')).toBeNull();
+    expect(scanCppBraceScopes('int x;\n}\n')).toBeNull();
+  });
+
+  it('places offsets in UTF-16 columns, as the parser does', () => {
+    const source = 'namespace n {\n/* é😀 */ class C { int x; };\n}\n';
+    const scopes = scanCppBraceScopes(source)!;
+    const close = scopes.closeOf(source.indexOf('{ int'))!;
+    expect(scopes.positionOf(close + 1)).toEqual({ line: 2, column: 28 });
+  });
+});
+
+describe.skipIf(!kernelAvailable)('C++ brace scopes: native kernel parity (error-extract hatch)', () => {
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['cpp']);
+  });
+
+  afterEach(() => {
+    delete process.env.CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT;
+    delete process.env.CODEGRAPH_KERNEL_LANGS;
+    resetKernelForTests();
+  });
+
+  const canon = (result: ExtractionResult) => ({
+    nodes: result.nodes.map(({ updatedAt: _u, ...n }) => JSON.stringify(n, Object.keys(n).sort())).sort(),
+    edges: result.edges.map((e) => JSON.stringify(e, Object.keys(e).sort())).sort(),
+    refs: result.unresolvedReferences.map((r) => JSON.stringify(r, Object.keys(r).sort())).sort(),
+  });
+
+  it.each(Object.keys(SHAPES))('%s: the kernel walks the same scopes as the wasm walker', (file) => {
+    for (const eol of ['\n', '\r\n']) {
+      const source = SHAPES[file]!.replace(/\n/g, eol);
+      process.env.CODEGRAPH_KERNEL_LANGS = 'cpp';
+      process.env.CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT = '1';
+      const viaKernel = tryKernelExtract(file, source, 'cpp');
+      delete process.env.CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT;
+      expect(viaKernel).not.toBeNull();
+      // Without the hatch a file with parse errors defers to wasm. (Asked
+      // second: a deferral is memoized for the same file and source.)
+      expect(tryKernelExtract(file, source, 'cpp')).toBeNull();
+      const viaWasm = wasmExtract(file, source);
+      expect(canon(viaKernel!)).toEqual(canon(viaWasm));
+    }
+  });
+});
diff --git a/__tests__/cpp-conditional-class.test.ts b/__tests__/cpp-conditional-class.test.ts
new file mode 100644
index 0000000000..69c690b62a
--- /dev/null
+++ b/__tests__/cpp-conditional-class.test.ts
@@ -0,0 +1,118 @@
+/**
+ * nlohmann/json's `basic_json` — the class most C++ projects vendor — was lost
+ * whole: tree-sitter-cpp cannot read
+ *
+ * - an access specifier spelled as a macro (`JSON_PRIVATE_UNLESS_TESTED:`),
+ * - a lone attribute macro after a template head or after a `/// @sa
+ *   https://…/` doc comment (both ends looked like an operator continuing the
+ *   line, so the macro wasn't blanked),
+ * - a preprocessor conditional in the middle of a declaration: inside a
+ *   member-initializer list, or between a template head and its function.
+ *
+ * The macros are rewritten or blanked, and a mid-declaration conditional keeps
+ * its first branch (directives and later branches blanked, offsets intact).
+ * An enum member after `A, /* comment *\/` is still an enum member.
+ */
+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';
+import { blankLoneMacroLines, flattenMidStatementConditionals } from '../src/extraction/languages/c-cpp';
+
+const HEADER = `#pragma once
+#define JSON_PRIVATE_UNLESS_TESTED private
+#define JSON_HEDLEY_RETURNS_NON_NULL
+#define JSON_HEDLEY_WARN_UNUSED_RESULT
+
+template<typename T>
+class basic_json
+{
+  JSON_PRIVATE_UNLESS_TESTED:
+    using lexer = int;
+
+    template<typename U, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static U* create(Args&& ... args)
+    {
+        return nullptr;
+    }
+
+    class nesting_depth_guard
+    {
+      public:
+        nesting_depth_guard() noexcept
+#ifdef JSON_NO_THREAD_LOCAL
+            : m_okay(false)
+#else
+            : m_okay(depth() < 10)
+#endif
+        {
+        }
+      private:
+        bool m_okay;
+    };
+
+  public:
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        return basic_json();
+    }
+
+    template < typename ValueType >
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const -> ValueType
+    {
+        return ValueType();
+    }
+
+    void dump() const {}
+};
+`;
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cpp-conditional-'));
+  fs.mkdirSync(path.join(root, 'include'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'include/json.hpp'), HEADER);
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('a C++ class written around macros and conditionals', () => {
+  it('keeps its members', () => {
+    const members = cg.getNodesInFile('include/json.hpp')
+      .filter((n) => n.qualifiedName.startsWith('basic_json::') && (n.kind === 'method' || n.kind === 'class'))
+      .map((n) => n.name)
+      .sort();
+    expect(members).toEqual(expect.arrayContaining(['create', 'dump', 'get', 'meta', 'nesting_depth_guard']));
+  });
+
+  it('keeps the first branch of a mid-declaration conditional, offsets intact', () => {
+    const src = 'A() noexcept\n#ifdef X\n  : a(1)\n#else\n  : a(2)\n#endif\n{}\n';
+    const out = flattenMidStatementConditionals(src);
+    expect(out.length).toBe(src.length);
+    expect(out).toContain('  : a(1)');
+    expect(out).not.toContain('a(2)');
+    expect(out).not.toContain('#');
+    // Between whole declarations a conditional stays.
+    const top = 'int a;\n#ifdef X\nint b;\n#endif\n';
+    expect(flattenMidStatementConditionals(top)).toBe(top);
+  });
+
+  it('does not blank an enum member after a commented line', () => {
+    const src = 'typedef enum {\n  CURLE_OK,\n  CURLE_TOO_LARGE, /* 100 */\n  CURL_LAST /* never use! */\n} CURLcode;\n';
+    expect(blankLoneMacroLines(src)).toBe(src);
+  });
+});
diff --git a/__tests__/cpp-global-scope-names.test.ts b/__tests__/cpp-global-scope-names.test.ts
new file mode 100644
index 0000000000..b995732330
--- /dev/null
+++ b/__tests__/cpp-global-scope-names.test.ts
@@ -0,0 +1,197 @@
+/**
+ * A C or C++ name written from the global scope — `::store::Repair(…)`,
+ * protobuf's `::_pbi::PrivateAccess::GenerateParseTable(…)` through
+ * `namespace _pbi = ::google::protobuf::internal;` — never got past the
+ * resolver's name-existence pre-filter, which read no leading `::`. protobuf's
+ * calls resolved only because it ships a few Swift and Objective-C files, and
+ * the Swift ↔ Objective-C bridge claimed every name with a `:` in it; C++-only
+ * rocksdb, leveldb and fmt dropped theirs. Past the pre-filter, the name is the
+ * declaration of exactly that qualified name: never one nested in another
+ * namespace or class, as the wrapper `int open(…) { return ::open(…); }` and an
+ * external `::testing::` call show.
+ */
+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';
+
+function writeProject(prefix: string, files: Record<string, string>): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  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);
+  }
+  return root;
+}
+
+/**
+ * `name -> target qualified name` for every reference the named function or
+ * method in `file` resolves — a call to a struct is an `instantiates` edge.
+ */
+function callsFrom(cg: CodeGraph, file: string, name: string): string[] {
+  const from = cg.getNodesInFile(file).filter((n) => n.name === name && (n.kind === 'function' || n.kind === 'method'));
+  expect(from.length).toBeGreaterThan(0);
+  return cg
+    .getOutgoingEdgesFrom(from.map((n) => n.id))
+    .flatMap((e) => {
+      const refName = (e.metadata as { refName?: string } | undefined)?.refName;
+      return refName ? [`${refName} -> ${cg.getNode(e.target)!.qualifiedName}`] : [];
+    })
+    .sort();
+}
+
+const PB_INTERNAL = `#pragma once
+namespace pb {
+namespace internal {
+inline int Prefetch(const void* ptr) { return ptr != nullptr; }
+}  // namespace internal
+}  // namespace pb
+
+namespace _pbi = ::pb::internal;
+`;
+
+describe('C++ names written from the global scope', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = writeProject('cg-cpp-global-', {
+      'src/store/repair.cc': `namespace store {
+int Repair(const char* name) { return name != nullptr; }
+int move(int value) { return value; }
+
+namespace testing {
+const char* TempDir() { return "/tmp/store"; }
+}  // namespace testing
+}  // namespace store
+`,
+      'src/pb/internal.h': PB_INTERNAL,
+      'src/store/posix.cc': `#include <unistd.h>
+
+namespace store {
+namespace posix {
+int close(int fd) { return ::close(fd); }
+}  // namespace posix
+}  // namespace store
+`,
+      'tools/repair_tool.cc': `#include <utility>
+#include "pb/internal.h"
+
+namespace tools {
+namespace store {
+int Repair(const char* name) { return 0; }
+}  // namespace store
+
+int Run(const char* name) {
+  int fixed = ::store::Repair(name);
+  int warmed = ::_pbi::Prefetch(name);
+  return ::std::move(fixed) + warmed;
+}
+}  // namespace tools
+`,
+      'include/lib/os.h': `#pragma once
+#define LIB_BEGIN_NAMESPACE \\
+  namespace lib {           \\
+  inline namespace v1 {
+#define LIB_END_NAMESPACE \\
+  }                       \\
+  }
+
+LIB_BEGIN_NAMESPACE
+struct pipe {
+  int read_end;
+  int write_end;
+};
+LIB_END_NAMESPACE
+`,
+      'tests/posix-mock.cc': `#include <unistd.h>
+#include "lib/os.h"
+
+namespace test {
+int pipe(int fds[2]) { return ::pipe(fds); }
+}  // namespace test
+`,
+      'tests/repair_test.cc': `#include <gtest/gtest.h>
+
+class RepairTest : public ::testing::Test {};
+
+int RunAll(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return ::testing::TempDir() != nullptr;
+}
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  }, 60_000);
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('links `::ns::f()` to the global namespace’s f, and an alias’s call to the aliased namespace', () => {
+    // Inside `namespace tools`, `store::Repair` would be tools' own; `::store::Repair` is the global one.
+    expect(callsFrom(cg, 'tools/repair_tool.cc', 'Run')).toEqual([
+      '::_pbi::Prefetch -> pb::internal::Prefetch',
+      '::store::Repair -> store::Repair',
+    ]);
+  });
+
+  it('never links a global name to a namesake nested in a namespace or class', () => {
+    // The wrapper calls the C library's `close`, not itself.
+    expect(callsFrom(cg, 'src/store/posix.cc', 'close')).toEqual([]);
+    // Nor `lib::pipe`, whose namespace a macro opens (fmt's FMT_BEGIN_NAMESPACE):
+    // the index cannot see it, so the struct only looks global there.
+    expect(callsFrom(cg, 'tests/posix-mock.cc', 'pipe')).toEqual([]);
+    // gtest is not in the project: `::testing::TempDir` is not `store::testing::TempDir`.
+    expect(callsFrom(cg, 'tests/repair_test.cc', 'RunAll')).toEqual([]);
+  });
+
+  it('leaves an external `::testing::Test` base unresolved', () => {
+    const test = cg.getNodesInFile('tests/repair_test.cc').find((n) => n.name === 'RepairTest')!;
+    expect(test).toBeDefined();
+    expect(cg.getOutgoingEdges(test.id).filter((e) => e.kind === 'extends' || e.kind === 'implements')).toEqual([]);
+  });
+});
+
+describe('C++ global names beside Swift and Objective-C (protobuf)', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = writeProject('cg-cpp-global-objc-', {
+      'objectivec/GPBLegacy.m': `#import <Foundation/Foundation.h>
+
+@interface GPBLegacy : NSObject
+- (void)start;
+@end
+
+@implementation GPBLegacy
+- (void)start {}
+@end
+`,
+      'swift/Bridge.swift': `import Foundation
+
+final class Bridge: NSObject {
+  func run() {}
+}
+`,
+      'src/pb/internal.h': PB_INTERNAL,
+      'src/message.cc': `#include "pb/internal.h"
+
+int Parse(const void* data) { return ::_pbi::Prefetch(data); }
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  }, 60_000);
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('still links a C++ `::_pbi::` call, which no longer rides the Swift ↔ Objective-C bridge’s claim', () => {
+    expect(callsFrom(cg, 'src/message.cc', 'Parse')).toEqual(['::_pbi::Prefetch -> pb::internal::Prefetch']);
+  });
+});
diff --git a/__tests__/cpp-included-test-suite.test.ts b/__tests__/cpp-included-test-suite.test.ts
new file mode 100644
index 0000000000..19efb98f0e
--- /dev/null
+++ b/__tests__/cpp-included-test-suite.test.ts
@@ -0,0 +1,259 @@
+/**
+ * A C or C++ file is part of every translation unit that includes it, whatever
+ * its name says. protobuf's conformance framework lives in
+ * `conformance/conformance_test.h` / `.cc` (`ConformanceTestSuite`) and
+ * `conformance/test_runner.h`, named like test suites, and the suites and
+ * runners that use it include them: `suite_.ReportFailure(…)` in
+ * binary_json_conformance_suite.cc is `ConformanceTestSuite::ReportFailure`.
+ * The test-suite rule ("production code never names a test suite's symbol")
+ * dropped that edge. A test-named file no production file includes stays out
+ * of reach, and so does a test that only includes the header it tests.
+ */
+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-cpp-included-test-'));
+  const files: Record<string, string> = {
+    'conformance/test_runner.h': `#ifndef CONFORMANCE_TEST_RUNNER_H
+#define CONFORMANCE_TEST_RUNNER_H
+
+#include <string>
+
+namespace conformance {
+
+class ConformanceTestRunner {
+ public:
+  virtual ~ConformanceTestRunner() = default;
+  virtual void RunTest(const std::string& test_name, const std::string& input, std::string* output) = 0;
+};
+
+}  // namespace conformance
+
+#endif
+`,
+    'conformance/conformance_test.h': `#ifndef CONFORMANCE_CONFORMANCE_TEST_H
+#define CONFORMANCE_CONFORMANCE_TEST_H
+
+#include <string>
+
+#include "conformance/test_runner.h"
+
+namespace conformance {
+
+class ConformanceTestSuite {
+ public:
+  virtual ~ConformanceTestSuite() = default;
+  bool RunSuite(ConformanceTestRunner* runner, std::string* output);
+  void ReportFailure(int test, int level);
+
+ protected:
+  virtual void RunSuiteImpl() = 0;
+  int failures_ = 0;
+};
+
+int FailureCount(const ConformanceTestSuite& suite);
+
+}  // namespace conformance
+
+#endif
+`,
+    'conformance/conformance_test.cc': `#include "conformance/conformance_test.h"
+
+namespace conformance {
+
+bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner, std::string* output) {
+  RunSuiteImpl();
+  return failures_ == 0;
+}
+
+void ConformanceTestSuite::ReportFailure(int test, int level) {
+  failures_ += test + level;
+}
+
+int FailureCount(const ConformanceTestSuite& suite) {
+  return 0;
+}
+
+}  // namespace conformance
+`,
+    // Another class's ReportFailure: where the call went by guess before.
+    'conformance/fork_pipe_runner.h': `#include <string>
+
+#include "conformance/test_runner.h"
+
+namespace conformance {
+
+class ForkPipeRunner : public ConformanceTestRunner {
+ public:
+  void RunTest(const std::string& test_name, const std::string& input, std::string* output) override;
+
+ private:
+  std::string ReportFailure(bool timed_out, const std::string& what_failed);
+};
+
+}  // namespace conformance
+`,
+    'conformance/fork_pipe_runner.cc': `#include "conformance/fork_pipe_runner.h"
+
+namespace conformance {
+
+void ForkPipeRunner::RunTest(const std::string& test_name, const std::string& input, std::string* output) {
+  *output = ReportFailure(false, test_name);
+}
+
+std::string ForkPipeRunner::ReportFailure(bool timed_out, const std::string& what_failed) {
+  return what_failed;
+}
+
+}  // namespace conformance
+`,
+    'conformance/binary_json_conformance_suite.h': `#include "conformance/conformance_test.h"
+
+namespace conformance {
+
+class BinaryAndJsonConformanceSuite : public ConformanceTestSuite {
+ private:
+  void RunSuiteImpl() override;
+};
+
+class BinaryAndJsonConformanceSuiteImpl {
+ public:
+  explicit BinaryAndJsonConformanceSuiteImpl(BinaryAndJsonConformanceSuite* suite);
+  void RunValidBinaryInputTest(int test);
+
+ private:
+  BinaryAndJsonConformanceSuite& suite_;
+};
+
+}  // namespace conformance
+`,
+    'conformance/binary_json_conformance_suite.cc': `#include "conformance/binary_json_conformance_suite.h"
+
+namespace conformance {
+
+void BinaryAndJsonConformanceSuite::RunSuiteImpl() {
+  BinaryAndJsonConformanceSuiteImpl impl(this);
+  impl.RunValidBinaryInputTest(1);
+}
+
+void BinaryAndJsonConformanceSuiteImpl::RunValidBinaryInputTest(int test) {
+  suite_.ReportFailure(test, 0);
+}
+
+}  // namespace conformance
+`,
+    'conformance/conformance_test_main.cc': `#include "conformance/binary_json_conformance_suite.h"
+#include "conformance/conformance_test.h"
+
+int RunConformance(const conformance::BinaryAndJsonConformanceSuite& suite) {
+  return FailureCount(suite);
+}
+`,
+    // Production code that does not include conformance_test.h.
+    'tools/report.cc': `int Summarize(int suite) {
+  return FailureCount(suite);
+}
+`,
+    // A C test-named file a production file includes (redis' expr.c includes
+    // fastjson_test.c for its test build).
+    'modules/fastjson_test.c': `int run_fastjson_test(void) {
+  return 0;
+}
+`,
+    'modules/expr.c': `#include "fastjson_test.c"
+
+int expr_selftest(void) {
+  return run_fastjson_test();
+}
+`,
+    // A real test suite nothing includes: its helper is not production's.
+    'src/db.h': `int open_db(void);
+`,
+    'src/db.c': `#include "db.h"
+
+int open_db(void) {
+  return make_options();
+}
+`,
+    'src/db_test.c': `#include "db.h"
+
+int make_options(void) {
+  return 1;
+}
+`,
+    // A test that includes the header it tests, named like it, does not
+    // implement it: jemalloc's test/unit/hash.c and its hash.h.
+    'include/hash.h': `unsigned hash(const char* key);
+`,
+    'src/hash.c': `#include "hash.h"
+
+unsigned hash(const char* key) {
+  return hash_selftest();
+}
+`,
+    'test/unit/hash.c': `#include "hash.h"
+
+unsigned hash_selftest(void) {
+  return hash("abc");
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `qualifiedName (file)` of every call the file's symbols make. */
+const callsFrom = (file: string): string[] => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => {
+    const target = cg.getNode(e.target)!;
+    return `${target.qualifiedName} (${target.filePath})`;
+  });
+};
+
+describe('a C/C++ file named like a test that the program includes', () => {
+  it('links a call through the base class its suite derives from', () => {
+    const calls = callsFrom('conformance/binary_json_conformance_suite.cc');
+    expect(calls).toContain('conformance::ConformanceTestSuite::ReportFailure (conformance/conformance_test.cc)');
+    expect(calls).not.toContain('conformance::ForkPipeRunner::ReportFailure (conformance/fork_pipe_runner.cc)');
+  });
+
+  it('links a free function the included header declares', () => {
+    expect(callsFrom('conformance/conformance_test_main.cc')).toContain('conformance::FailureCount (conformance/conformance_test.cc)');
+  });
+
+  it('links a test-named source file that a production file includes', () => {
+    expect(callsFrom('modules/expr.c')).toContain('run_fastjson_test (modules/fastjson_test.c)');
+  });
+
+  it('keeps it out of reach of a file that does not include it', () => {
+    expect(callsFrom('tools/report.cc').some((c) => c.includes('conformance_test.cc'))).toBe(false);
+  });
+});
+
+describe('a C/C++ test suite nothing in the program includes', () => {
+  it('is still out of reach of production code', () => {
+    expect(callsFrom('src/db.c').some((c) => c.includes('src/db_test.c'))).toBe(false);
+  });
+
+  it('does not implement the production header it includes to test', () => {
+    expect(callsFrom('src/hash.c').some((c) => c.includes('test/unit/hash.c'))).toBe(false);
+    // The test still reaches the code it tests.
+    expect(callsFrom('test/unit/hash.c')).toContain('hash (src/hash.c)');
+  });
+});
diff --git a/__tests__/cpp-library-type-receiver.test.ts b/__tests__/cpp-library-type-receiver.test.ts
new file mode 100644
index 0000000000..70d368dcd1
--- /dev/null
+++ b/__tests__/cpp-library-type-receiver.test.ts
@@ -0,0 +1,522 @@
+/**
+ * A C++ receiver declared as a type from outside the project with a lowercase
+ * name — `std::string`, `std::vector<…>`, `absl::flat_hash_set<…>` — calls
+ * that type's own member, not a project method.
+ *
+ * google/leveldb's `DBIter` declares `std::string saved_key_;` and calls
+ * `saved_key_.clear()`. Receiver inference read the type as `string`, which
+ * names no project class, and the check for a type from outside the project
+ * only caught capitalized names (`List`, `String`), so the call fell through
+ * to a guess by the method's name: `Slice::clear`, the one project `clear`.
+ * protocolbuffers/protobuf had about 900 such edges (`std::string proto;
+ * proto.append(…)` reached `LeftoverBuffer::append`).
+ *
+ * When the calling function or its class declares the receiver that way, a
+ * `.` call — or a `->` through a raw pointer, `std::string* out` — gets no
+ * project edge. A `->` on a smart pointer, iterator or optional still goes to
+ * the element type, and a call that contradicts its declaration (`.` on a
+ * pointer) keeps its guess, since that declaration is another variable's.
+ * Comments no longer pass for declarations in the scan: `// … non-null imm_`
+ * read as `imm_`'s declaration, with the type `null`.
+ */
+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 type { Node } from '../src/types';
+
+const roots: string[] = [];
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+async function indexed(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cpp-library-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+function callable(cg: CodeGraph, qualifiedName: string): Node {
+  const node = [...cg.getNodesByKind('method'), ...cg.getNodesByKind('function')].find((n) => n.qualifiedName === qualifiedName);
+  if (!node) throw new Error(`no function or method ${qualifiedName}`);
+  return node;
+}
+
+/** `calls` callees of a function or method, as `qualifiedName`. */
+function calls(cg: CodeGraph, caller: string): string[] {
+  return cg
+    .getCallees(callable(cg, caller).id)
+    .filter((r) => r.edge.kind === 'calls')
+    .map((r) => r.node.qualifiedName)
+    .sort();
+}
+
+const lines = (...l: string[]): string => [...l, ''].join('\n');
+
+/** leveldb's Slice and its namesakes elsewhere: every method a library type's call could be mistaken for. */
+const PROJECT = {
+  'include/leveldb/slice.h': lines(
+    'namespace leveldb {',
+    'class Slice {',
+    ' public:',
+    '  const char* data() const { return data_; }',
+    '  unsigned size() const { return size_; }',
+    '  void clear() { size_ = 0; }',
+    '  const char* begin() const { return data_; }',
+    '  void remove_prefix(unsigned n) { size_ -= n; }',
+    ' private:',
+    '  const char* data_;',
+    '  unsigned size_;',
+    '};',
+    '}  // namespace leveldb',
+  ),
+  'util/buffers.h': lines(
+    'namespace leveldb {',
+    'class LeftoverBuffer {',
+    ' public:',
+    '  void append(const char* s, unsigned n) {}',
+    '};',
+    'class Arena {',
+    ' public:',
+    '  void insert(int block) {}',
+    '};',
+    'class Cache {',
+    ' public:',
+    '  void reset() {}',
+    '};',
+    'class Iterator {',
+    ' public:',
+    '  void SeekToFirst() {}',
+    '};',
+    '}  // namespace leveldb',
+  ),
+};
+
+describe('a C++ receiver declared as a library type with a lowercase name', () => {
+  it('reproduction: `std::string saved_key_; saved_key_.clear()` is not Slice::clear', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'db/db_iter.cc': lines(
+        '#include <string>',
+        '#include "include/leveldb/slice.h"',
+        'namespace leveldb {',
+        'class DBIter {',
+        ' public:',
+        '  void Next();',
+        ' private:',
+        '  std::string saved_key_;    // == current key when direction_==kReverse',
+        '};',
+        'void DBIter::Next() {',
+        '  saved_key_.clear();',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::DBIter::Next')).toEqual([]);
+      expect(cg.getCallers(callable(cg, 'leveldb::Slice::clear').id).filter((r) => r.edge.kind === 'calls')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a local, a parameter, a raw pointer, nested template arguments and an abseil container', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'db/encode.cc': lines(
+        '#include <string>',
+        '#include <vector>',
+        '#include "absl/container/flat_hash_set.h"',
+        '#include "include/leveldb/slice.h"',
+        '#include "util/buffers.h"',
+        'namespace leveldb {',
+        'void Encode(std::string* dst, const Slice& value) {',
+        '  dst->clear();',
+        '  dst->append(value.data(), value.size());',
+        '}',
+        'std::string Render(const std::vector<std::pair<int, Slice>>& files) {',
+        '  std::string proto;',
+        '  proto.append("x", 1);',
+        '  absl::flat_hash_set<int> seen;',
+        '  seen.insert(1);',
+        '  const char* first = proto.data();',
+        '  return files.begin() == files.end() ? proto : std::string(first);',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      // `value` is a Slice; `dst`, `proto`, `seen` and `files` are not.
+      expect(calls(cg, 'leveldb::Encode')).toEqual(['leveldb::Slice::data', 'leveldb::Slice::size']);
+      expect(calls(cg, 'leveldb::Render')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a `std::` name beside a project alias of the same name elsewhere', async () => {
+    // facebook/rocksdb vendors googletest, whose `typedef ::std::string
+    // string;` in `testing::internal` is a project type named `string`.
+    const cg = await indexed({
+      ...PROJECT,
+      'third_party/gtest.h': lines(
+        '#include <string>',
+        'namespace testing {',
+        'namespace internal {',
+        'typedef ::std::string string;',
+        '}  // namespace internal',
+        '}  // namespace testing',
+      ),
+      'tools/trim.cc': lines(
+        '#include <string>',
+        '#include "include/leveldb/slice.h"',
+        'void Trim(std::string& text) {',
+        '  text.clear();',
+        '}',
+      ),
+    });
+    try {
+      expect(calls(cg, 'Trim')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a smart pointer: `.` is its own member, `->` reaches the element type', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'db/scan.cc': lines(
+        '#include <memory>',
+        '#include "util/buffers.h"',
+        'namespace leveldb {',
+        'void Scan(Iterator* raw) {',
+        '  std::unique_ptr<Iterator> iter(raw);',
+        '  iter->SeekToFirst();',
+        '  iter.reset();',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      // `iter.reset()` is unique_ptr's, not Cache::reset.
+      expect(calls(cg, 'leveldb::Scan')).toEqual(['leveldb::Iterator::SeekToFirst']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a std trait or member type names another type, maybe the project\'s', async () => {
+    // facebook/rocksdb's compression.cc: `std::conditional_t<kIsDigestedDict,
+    // void*, Slice> dict` is a Slice when the flag is off.
+    const cg = await indexed({
+      ...PROJECT,
+      'util/compression.cc': lines(
+        '#include <type_traits>',
+        '#include <vector>',
+        '#include "include/leveldb/slice.h"',
+        'namespace leveldb {',
+        'template <bool kIsDigestedDict>',
+        'unsigned DictSize(std::conditional_t<kIsDigestedDict, void*, Slice> dict) {',
+        '  return dict.size();',
+        '}',
+        'void Drop(const std::vector<Slice>& slices) {',
+        '  std::vector<Slice>::value_type first = slices[0];',
+        '  first.remove_prefix(1);',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::DictSize')).toEqual(['leveldb::Slice::size']);
+      expect(calls(cg, 'leveldb::Drop')).toEqual(['leveldb::Slice::remove_prefix']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a project type with a lowercase name is still the project\'s', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'util/arena.h': lines(
+        'namespace util {',
+        'class arena {',
+        ' public:',
+        '  void* allocate(unsigned n) { return 0; }',
+        '};',
+        '}  // namespace util',
+      ),
+      'util/use.cc': lines(
+        '#include "util/arena.h"',
+        'void Use(util::arena& a) {',
+        '  a.allocate(8);',
+        '}',
+      ),
+    });
+    try {
+      expect(calls(cg, 'Use')).toEqual(['util::arena::allocate']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('a declaration that is not the receiver\'s does not rule a guess out', () => {
+  it('a range-for variable, or an `auto` one, hides an earlier library-typed one of the same name', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'db/shadow.cc': lines(
+        '#include <string>',
+        '#include <vector>',
+        '#include "include/leveldb/slice.h"',
+        '#include "util/buffers.h"',
+        'namespace leveldb {',
+        'void Trim(const std::vector<Slice>& slices) {',
+        '  std::string key;',
+        '  for (const Slice& key : slices) {',
+        '    key.remove_prefix(1);',
+        '  }',
+        '}',
+        'void Flush(Cache* caches) {',
+        '  { std::string buf; buf.clear(); }',
+        '  auto buf = caches[0];',
+        '  buf.reset();',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::Trim')).toEqual(['leveldb::Slice::remove_prefix']);
+      // The block's `buf.clear()` is the string's; the `auto` one's `reset` is a guess left alone.
+      expect(calls(cg, 'leveldb::Flush')).toEqual(['leveldb::Cache::reset']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a call that contradicts the declaration it found: `.` on what reads as a pointer', async () => {
+    // As in fmtlib/fmt's bigint, where `carry = (upper * bigits_[i] …` reads
+    // as a declaration `upper* bigits_[…]`: the product here reads as
+    // `absl::kWeightScale* key[…]`, but `key.size()` is a `.` call.
+    const cg = await indexed({
+      ...PROJECT,
+      'util/weight.cc': lines(
+        '#include "include/leveldb/slice.h"',
+        'namespace leveldb {',
+        'unsigned Weight(const Slice& key) {',
+        '  unsigned w = absl::kWeightScale * key[0];',
+        '  return w + key.size();',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::Weight')).toEqual(['leveldb::Slice::size']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a constant of a project class read as a type, and a scalar', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'util/mask.cc': lines(
+        '#include <cstddef>',
+        '#include "include/leveldb/slice.h"',
+        '#define SLICE_AT(var, list, i) const Slice& var = list[i]',
+        'namespace leveldb {',
+        'unsigned Mask(const Slice& key) {',
+        // reads like `Slice::kMask& key[…]`
+        '  unsigned m = Slice::kMask & key[0];',
+        '  return m + key.size();',
+        '}',
+        'void Visit(const Slice* slices) {',
+        '  std::size_t key = 0;',
+        '  {',
+        // the macro declares the `key` the call is made on
+        '    SLICE_AT(key, slices, 0);',
+        '    key.remove_prefix(1);',
+        '  }',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::Mask')).toEqual(['leveldb::Slice::size']);
+      expect(calls(cg, 'leveldb::Visit')).toEqual(['leveldb::Slice::remove_prefix']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a member of another class in the file', async () => {
+    // google/leveldb's db/log_test.cc: StringDest's `std::string contents_`
+    // sits above StringSource, whose own `Slice contents_` comes after its methods.
+    const cg = await indexed({
+      ...PROJECT,
+      'db/log_test.cc': lines(
+        '#include <string>',
+        '#include "include/leveldb/slice.h"',
+        'namespace leveldb {',
+        'class StringDest {',
+        ' public:',
+        '  std::string contents_;',
+        '};',
+        'class StringSource {',
+        ' public:',
+        '  void Skip(unsigned n) { contents_.remove_prefix(n); }',
+        ' private:',
+        '  Slice contents_;',
+        '};',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::StringSource::Skip')).toEqual(['leveldb::Slice::remove_prefix']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('the last line of a declaration that starts on an earlier one', async () => {
+    // facebook/rocksdb's BlobFileReader: `autovector<std::pair<…,` ends one
+    // line and `std::unique_ptr<BlobContents>>>& blob_reqs` starts the next.
+    const cg = await indexed({
+      'util/autovector.h': lines(
+        'namespace rocksdb {',
+        'template <class T>',
+        'class autovector {',
+        ' public:',
+        '  unsigned size() const { return 0; }',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+      'db/blob/blob_file_reader.cc': lines(
+        '#include <memory>',
+        '#include "util/autovector.h"',
+        'namespace rocksdb {',
+        'class BlobFileReader {',
+        ' public:',
+        '  unsigned MultiGetBlob(autovector<std::pair<int*,',
+        '                                 std::unique_ptr<int>>>& blob_reqs);',
+        '};',
+        'unsigned BlobFileReader::MultiGetBlob(autovector<std::pair<int*,',
+        '                                      std::unique_ptr<int>>>& blob_reqs) {',
+        '  return blob_reqs.size();',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::BlobFileReader::MultiGetBlob')).toEqual(['rocksdb::autovector::size']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a member of a class nested in the caller\'s', async () => {
+    // facebook/rocksdb's MultiScan: its nested MultiScanIterator declares a
+    // `scan_opts_` of its own, above MultiScan's.
+    const cg = await indexed({
+      'include/rocksdb/multi_scan.h': lines(
+        '#include <vector>',
+        'namespace rocksdb {',
+        'struct ScanOptions {};',
+        'class MultiScanArgs {',
+        ' public:',
+        '  int GetScanRanges() const { return 0; }',
+        '};',
+        'class MultiScan {',
+        ' public:',
+        '  class MultiScanIterator {',
+        '   private:',
+        '    const std::vector<ScanOptions>& scan_opts_;',
+        '  };',
+        '  int begin() { return scan_opts_.GetScanRanges(); }',
+        ' private:',
+        '  const MultiScanArgs scan_opts_;',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::MultiScan::begin')).toEqual(['rocksdb::MultiScanArgs::GetScanRanges']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('comments in the declaration scan', () => {
+  it('a comment that mentions the receiver is not its declaration', async () => {
+    // google/leveldb's db_impl.cc: `// … since there is a non-null imm_`
+    // above `imm_->…` read as `imm_`'s declaration, with the type `null`.
+    const cg = await indexed({
+      'db/memtable.h': lines(
+        'namespace leveldb {',
+        'class MemTable {',
+        ' public:',
+        '  unsigned ApproximateMemoryUsage() { return 0; }',
+        '};',
+        'class Arena {',
+        ' public:',
+        '  unsigned ApproximateMemoryUsage() { return 0; }',
+        '};',
+        '}  // namespace leveldb',
+      ),
+      'db/db_impl.h': lines(
+        '#include "db/memtable.h"',
+        'namespace leveldb {',
+        'class DBImpl {',
+        ' public:',
+        '  unsigned MemoryUsage();',
+        ' private:',
+        '  MemTable* imm_;',
+        '};',
+        '}  // namespace leveldb',
+      ),
+      'db/db_impl.cc': lines(
+        '#include "db/db_impl.h"',
+        'namespace leveldb {',
+        'unsigned DBImpl::MemoryUsage() {',
+        '  // Count the memtable being compacted, since there is a non-null imm_',
+        '  return imm_->ApproximateMemoryUsage();',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::DBImpl::MemoryUsage')).toEqual(['leveldb::MemTable::ApproximateMemoryUsage']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a parameter after a leading `/* static */` is the caller\'s own', async () => {
+    const cg = await indexed({
+      ...PROJECT,
+      'util/status.cc': lines(
+        '#include <string>',
+        '#include "include/leveldb/slice.h"',
+        'namespace leveldb {',
+        'class Status {',
+        ' public:',
+        '  static bool Check(const std::string& msg);',
+        '};',
+        '/* static */ bool Status::Check(const std::string& msg) {',
+        '  return msg.begin() != nullptr;',
+        '}',
+        '}  // namespace leveldb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'leveldb::Status::Check')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/cpp-macro-include-walk.test.ts b/__tests__/cpp-macro-include-walk.test.ts
new file mode 100644
index 0000000000..acaf9c0d0f
--- /dev/null
+++ b/__tests__/cpp-macro-include-walk.test.ts
@@ -0,0 +1,125 @@
+/**
+ * #2127 — the C/C++ macro-visibility walk must stay bounded on deep include
+ * graphs.
+ *
+ * A header whose guard the walk cannot decide — `#define X_H 1` (the OSG /
+ * osgEarth idiom, which the guard reader does not take for a guard), or any
+ * header reached under an unknown `#if` — used to be re-scanned on every
+ * inclusion path: a layered include graph where each header includes the two
+ * of the next layer cost 2^depth header scans and grew the timeline with
+ * every one of them, which is how "Resolving refs" ran out of heap on
+ * osgEarth. The answers must not change: a macro definitely visible at the
+ * call site is still a macro, and an unknown one still is not.
+ */
+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 { isVisibleCppMacro } from '../src/resolution/cpp-macro-visibility';
+import type { ResolutionContext, UnresolvedRef } from '../src/resolution/types';
+
+type Guard = 'value' | 'bare' | 'unknown-flag';
+
+/** `depth` layers of two headers; each includes both headers of the next layer. */
+function layeredHeaders(depth: number, guard: Guard): Record<string, string> {
+  const files: Record<string, string> = {};
+  for (let d = 0; d < depth; d++) {
+    for (const side of ['a', 'b']) {
+      const g = `H_${d}_${side}`;
+      const open =
+        guard === 'value' ? `#ifndef ${g}\n#define ${g} 1\n` :
+        guard === 'bare' ? `#ifndef ${g}\n#define ${g}\n` :
+        `#ifdef USE_${d}\n`;
+      const next = d + 1 < depth ? `#include "h${d + 1}_a.h"\n#include "h${d + 1}_b.h"\n` : '';
+      files[`h${d}_${side}.h`] = `${open}${next}#define M_${d}_${side}(x) (x)\nint f_${d}_${side}(int);\n#endif\n`;
+    }
+  }
+  return files;
+}
+
+/** A context over in-memory files where every name is both a macro and a function. */
+function contextOver(files: Record<string, string>): ResolutionContext {
+  return {
+    getNodesByName: (name: string) => [
+      { kind: 'constant', signature: `#define ${name}(v) (v)` },
+      { kind: 'function' },
+    ],
+    readFile: (f: string) => files[f] ?? null,
+    fileExists: (f: string) => f in files,
+    getAllFiles: () => Object.keys(files),
+  } as unknown as ResolutionContext;
+}
+
+const call = (name: string, line: number): UnresolvedRef =>
+  ({ language: 'cpp', referenceKind: 'calls', referenceName: name, filePath: 'unit.cpp', line }) as UnresolvedRef;
+
+describe('#2127 — the macro-visibility include walk is bounded', () => {
+  it.each(['value', 'bare', 'unknown-flag'] as const)(
+    'a 40-layer include graph (2^40 inclusion paths) is walked in well under a second (%s guards)',
+    (guard) => {
+      const files = {
+        ...layeredHeaders(40, guard),
+        'trace.h': '#define TRACE(v) ((void)(v))\n',
+        'unit.cpp': '#include "h0_a.h"\n#include "h0_b.h"\n#include "trace.h"\nvoid unit() { TRACE(1); }\n',
+      };
+      const context = contextOver(files);
+      const started = performance.now();
+      // Before the fix this walk never finished (2^40 header scans).
+      expect(isVisibleCppMacro(call('TRACE', 4), context)).toBe(true);
+      expect(performance.now() - started).toBeLessThan(1000);
+      // A header macro under an undecidable guard is not definitely visible,
+      // and a call above the include that defines TRACE is still a call.
+      expect(isVisibleCppMacro(call('M_39_a', 4), context)).toBe(guard === 'bare');
+      expect(isVisibleCppMacro(call('TRACE', 2), context)).toBe(false);
+    },
+  );
+
+  it('a walk that cannot be shortened stops at its budget and suppresses nothing past it', () => {
+    // No guards and a known flag toggled on every inclusion: each visit
+    // changes the state, so no re-entry repeats an earlier one and the real
+    // preprocessor would expand all 2^22 paths too. The walk gives up instead:
+    // before the exploding include the macro is still known, after it nothing is.
+    const files: Record<string, string> = {
+      'toggle.h': '#ifdef T\n#undef T\n#else\n#define T\n#endif\n',
+      'unit.cpp': '#define T\n#define TRACE(v) ((void)(v))\nvoid before() { TRACE(1); }\n#include "h0.h"\nvoid after() { TRACE(2); }\n',
+    };
+    for (let d = 0; d < 22; d++) {
+      files[`h${d}.h`] = d + 1 < 22 ? `#include "toggle.h"\n#include "h${d + 1}.h"\n#include "h${d + 1}.h"\n` : '#include "toggle.h"\n';
+    }
+    const context = contextOver(files);
+    const started = performance.now();
+    expect(isVisibleCppMacro(call('TRACE', 3), context)).toBe(true);
+    expect(isVisibleCppMacro(call('TRACE', 5), context)).toBe(false);
+    expect(performance.now() - started).toBeLessThan(10_000);
+  });
+});
+
+describe('#2127 — indexing a deep include graph keeps #1838 macro suppression', () => {
+  const roots: string[] = [];
+  afterEach(() => {
+    for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('the macro reached through value-guarded headers still does not bind to the decoy function', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cpp-walk-'));
+    roots.push(root);
+    const files = {
+      ...layeredHeaders(24, 'value'),
+      'trace.h': '#define TRACE(v) ((void)(v))\n',
+      'unit.cpp': '#include "h0_a.h"\n#include "h0_b.h"\n#include "trace.h"\nvoid unit() { TRACE(1); }\n',
+      'decoy.cpp': 'void TRACE(int v) {}\nvoid caller() { TRACE(2); }\n',
+    };
+    for (const [rel, content] of Object.entries(files)) fs.writeFileSync(path.join(root, rel), content);
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const fn = (name: string) => cg.getNodesByKind('function').find((n) => n.name === name)!;
+      const callees = (name: string) =>
+        cg.getCallees(fn(name).id).filter((r) => r.edge.kind === 'calls').map((r) => r.node.filePath);
+      expect(callees('unit')).toEqual([]);
+      expect(callees('caller')).toEqual(['decoy.cpp']);
+    } finally {
+      cg.close();
+    }
+  }, 60_000);
+});
diff --git a/__tests__/cpp-macro-namespace.test.ts b/__tests__/cpp-macro-namespace.test.ts
new file mode 100644
index 0000000000..675766ec3a
--- /dev/null
+++ b/__tests__/cpp-macro-namespace.test.ts
@@ -0,0 +1,90 @@
+/**
+ * A C++ library that opens its namespace with a macro — fmt's
+ * `FMT_BEGIN_NAMESPACE` (`namespace fmt { inline namespace v12 {`),
+ * pybind11's `PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)` — has its
+ * declarations indexed without that namespace, so `fmt::format(…)` found
+ * nothing: 1,728 calls on fmt. A qualified name now reaches a declaration the
+ * project's own namespace macros put there, through a namespace alias
+ * (`namespace py = pybind11;`) too.
+ */
+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-cpp-macro-ns-'));
+  const files: Record<string, string> = {
+    'include/fmt/base.h': `#pragma once
+#define FMT_BEGIN_NAMESPACE \\
+  namespace fmt {           \\
+  inline namespace v12 {
+#define FMT_END_NAMESPACE \\
+  }                       \\
+  }
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+inline int to_unsigned(int value) { return value; }
+}
+
+inline int format(const char* spec) { return detail::to_unsigned(0); }
+FMT_END_NAMESPACE
+`,
+    'include/pybind11/detail/macros.h': `#pragma once
+#define PYBIND11_NAMESPACE pybind11
+#define PYBIND11_NAMESPACE_BEGIN(name) \\
+    namespace name {                   \\
+    PYBIND11_WARNING_PUSH
+#define PYBIND11_NAMESPACE_END(name) \\
+    PYBIND11_WARNING_POP             \\
+    }
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+inline void print(const char* text) {}
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+`,
+    'test/format-test.cc': `#include "fmt/base.h"
+#include "pybind11/detail/macros.h"
+
+namespace py = pybind11;
+
+int main() {
+  fmt::format("{}");
+  fmt::detail::to_unsigned(1);
+  py::print("hi");
+  return 0;
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('C++ namespaces opened by a macro', () => {
+  it('put their declarations under the qualified names callers use', () => {
+    const ids = cg.getNodesInFile('test/format-test.cc').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => `${cg.getNode(e.target)!.filePath}:${cg.getNode(e.target)!.name}`)
+      .sort();
+    expect(targets).toEqual([
+      'include/fmt/base.h:format',
+      'include/fmt/base.h:to_unsigned',
+      'include/pybind11/detail/macros.h:print',
+    ]);
+  });
+});
diff --git a/__tests__/cpp-nested-template-receiver.test.ts b/__tests__/cpp-nested-template-receiver.test.ts
new file mode 100644
index 0000000000..b6e3e9ac96
--- /dev/null
+++ b/__tests__/cpp-nested-template-receiver.test.ts
@@ -0,0 +1,278 @@
+/**
+ * A C++ receiver declared with template arguments nested in its template
+ * arguments calls its own class's method.
+ *
+ * Receiver inference reduced a declared type to its last name by cutting each
+ * `<…>` at its first `>`, so `autovector<std::pair<int, FileMetaData*>>` came
+ * out as `autovector >` and `Striped<CacheAlignedWrapper<port::Mutex>>` as
+ * `Striped >` — names no class has. facebook/rocksdb's
+ * `files_marked_for_compaction_.clear()` on such an `autovector` was then
+ * guessed by the receiver's words to be `CompactionInputFiles::clear`, and
+ * `mutex_.Get(key)` on a `Striped` got no edge at all: a capitalized type no
+ * class declares is taken to be from outside the project. Template arguments
+ * now go with the ones nested in them, so both calls reach their own class.
+ */
+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 { stripCppTemplateArguments } from '../src/resolution/cpp-type-aliases';
+import type { Node } from '../src/types';
+
+const roots: string[] = [];
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+async function indexed(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cpp-nested-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+function callable(cg: CodeGraph, qualifiedName: string): Node {
+  const node = [...cg.getNodesByKind('method'), ...cg.getNodesByKind('function')].find((n) => n.qualifiedName === qualifiedName);
+  if (!node) throw new Error(`no function or method ${qualifiedName}`);
+  return node;
+}
+
+/** `calls` callees of a function or method, as `qualifiedName (file)`. */
+function calls(cg: CodeGraph, caller: string): string[] {
+  return cg
+    .getCallees(callable(cg, caller).id)
+    .filter((r) => r.edge.kind === 'calls')
+    .map((r) => `${r.node.qualifiedName} (${r.node.filePath})`)
+    .sort();
+}
+
+/** `calls` callees with how each was resolved: `qualifiedName resolvedBy@confidence`. */
+function resolvedCalls(cg: CodeGraph, caller: string): string[] {
+  return cg
+    .getCallees(callable(cg, caller).id)
+    .filter((r) => r.edge.kind === 'calls')
+    .map((r) => `${r.node.qualifiedName} ${String(r.edge.metadata?.resolvedBy)}@${String(r.edge.metadata?.confidence)}`)
+    .sort();
+}
+
+/** facebook/rocksdb's shapes, trimmed: the small vector, and the class whose words the receivers share. */
+const ROCKSDB = {
+  'util/autovector.h': [
+    'namespace rocksdb {',
+    'template <class T, size_t kSize = 8>',
+    'class autovector {',
+    ' public:',
+    '  size_t size() const { return 0; }',
+    '  void clear() {}',
+    '  void push_back(const T& item) {}',
+    '};',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'db/compaction/compaction.h': [
+    'namespace rocksdb {',
+    'struct FileMetaData {};',
+    'struct CompactionInputFiles {',
+    '  size_t size() const { return 0; }',
+    '  void clear() {}',
+    '};',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'db/version_set.h': [
+    '#include "util/autovector.h"',
+    '#include "db/compaction/compaction.h"',
+    'namespace rocksdb {',
+    'class VersionEdit {};',
+    'class VersionStorageInfo {',
+    ' public:',
+    '  void ComputeFilesMarkedForCompaction();',
+    '  size_t CountEditLists(VersionEdit* edit);',
+    ' private:',
+    '  autovector<std::pair<int, FileMetaData*>> files_marked_for_compaction_;',
+    '};',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+  'db/version_set.cc': [
+    '#include "db/version_set.h"',
+    'namespace rocksdb {',
+    'void VersionStorageInfo::ComputeFilesMarkedForCompaction() {',
+    '  files_marked_for_compaction_.clear();',
+    '}',
+    'size_t VersionStorageInfo::CountEditLists(VersionEdit* edit) {',
+    '  autovector<autovector<VersionEdit*>> edit_lists;',
+    '  edit_lists.push_back(autovector<VersionEdit*>());',
+    '  return edit_lists.size();',
+    '}',
+    '}  // namespace rocksdb',
+    '',
+  ].join('\n'),
+};
+
+describe('a C++ receiver declared with nested template arguments', () => {
+  it('reproduction: a member of the class reaches the class\'s own method, not one named after the receiver\'s words', async () => {
+    const cg = await indexed(ROCKSDB);
+    try {
+      expect(calls(cg, 'rocksdb::VersionStorageInfo::ComputeFilesMarkedForCompaction')).toEqual([
+        'rocksdb::autovector::clear (util/autovector.h)',
+      ]);
+      expect(cg.getCallers(callable(cg, 'rocksdb::CompactionInputFiles::clear').id).filter((r) => r.edge.kind === 'calls')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a local of a class template nested in its own template arguments', async () => {
+    const cg = await indexed(ROCKSDB);
+    try {
+      // Both calls are the declared type's. `size` has two owners and the
+      // receiver's words name neither, so no guess reached it; the one
+      // `push_back` was a guess for being the only method of its name.
+      expect(resolvedCalls(cg, 'rocksdb::VersionStorageInfo::CountEditLists')).toEqual([
+        'rocksdb::autovector::push_back instance-method@0.9',
+        'rocksdb::autovector::size instance-method@0.9',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a capitalized class template is the project\'s own, not a type from outside it', async () => {
+    const cg = await indexed({
+      'util/mutexlock.h': [
+        'namespace rocksdb {',
+        'namespace port {',
+        'class Mutex {',
+        ' public:',
+        '  void Lock() {}',
+        '};',
+        '}  // namespace port',
+        'template <class T>',
+        'struct CacheAlignedWrapper {',
+        '  T obj_;',
+        '};',
+        'template <class T, class Key = int>',
+        'class Striped {',
+        ' public:',
+        '  T& Get(const Key& key) { return *data_; }',
+        ' private:',
+        '  T* data_;',
+        '};',
+        '}  // namespace rocksdb',
+        '',
+      ].join('\n'),
+      'db/blob/blob_file_cache.h': [
+        '#include "util/mutexlock.h"',
+        'namespace rocksdb {',
+        'class BlobFileCache {',
+        ' public:',
+        '  void Evict(int key);',
+        ' private:',
+        '  Striped<CacheAlignedWrapper<port::Mutex>> mutex_;',
+        '};',
+        '}  // namespace rocksdb',
+        '',
+      ].join('\n'),
+      'db/blob/blob_file_cache.cc': [
+        '#include "db/blob/blob_file_cache.h"',
+        'namespace rocksdb {',
+        'void BlobFileCache::Evict(int key) {',
+        '  mutex_.Get(key);',
+        '}',
+        '}  // namespace rocksdb',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::BlobFileCache::Evict')).toEqual(['rocksdb::Striped::Get (util/mutexlock.h)']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('the end of a declaration begun on the line above names no type, not even its template argument\'s', async () => {
+    // rocksdb's blob_file_reader.h breaks `autovector<std::pair<…,` and
+    // `std::unique_ptr<BlobContents>>>& blob_reqs` over two lines. The second
+    // line alone, read as a type, is a `CachableEntry` here: the receiver's
+    // type is the `autovector` on the line above.
+    const cg = await indexed({
+      ...ROCKSDB,
+      'table/block_based/cachable_entry.h': [
+        'namespace rocksdb {',
+        'template <class T>',
+        'class CachableEntry {',
+        ' public:',
+        '  size_t size() const { return 0; }',
+        '};',
+        '}  // namespace rocksdb',
+        '',
+      ].join('\n'),
+      'db/blob/blob_file_reader.cc': [
+        '#include "util/autovector.h"',
+        '#include "table/block_based/cachable_entry.h"',
+        'namespace rocksdb {',
+        'struct BlobContents {};',
+        'struct BlobReadRequest {};',
+        'size_t MultiGetBlob(',
+        '    autovector<std::pair<BlobReadRequest*,',
+        '                         CachableEntry<BlobContents>>>& blob_reqs) {',
+        '  return blob_reqs.size();',
+        '}',
+        '}  // namespace rocksdb',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::MultiGetBlob')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a declaration begun on the line above still hides a member of the same name', async () => {
+    // The parameter's type is not on the line that names it, but the
+    // parameter is still what the call is on: the class's `std::string
+    // blob_reqs` member it hides says nothing about the call.
+    const cg = await indexed({
+      'util/autovector.h': ROCKSDB['util/autovector.h'],
+      'db/blob/blob_file_reader.cc': [
+        '#include <string>',
+        '#include "util/autovector.h"',
+        'namespace rocksdb {',
+        'struct BlobContents {};',
+        'class BlobFileReader {',
+        ' public:',
+        '  size_t MultiGetBlob(autovector<std::pair<int*,',
+        '                                           std::unique_ptr<BlobContents>>>& blob_reqs) const;',
+        ' private:',
+        '  std::string blob_reqs;',
+        '};',
+        'size_t BlobFileReader::MultiGetBlob(autovector<std::pair<int*,',
+        '                                           std::unique_ptr<BlobContents>>>& blob_reqs) const {',
+        '  return blob_reqs.size();',
+        '}',
+        '}  // namespace rocksdb',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::BlobFileReader::MultiGetBlob')).toEqual(['rocksdb::autovector::size (util/autovector.h)']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('stripCppTemplateArguments', () => {
+  it('drops template arguments together with the ones nested in them', () => {
+    expect(stripCppTemplateArguments('autovector<std::pair<int, FileMetaData*>>')).toBe('autovector');
+    expect(stripCppTemplateArguments('Striped<CacheAlignedWrapper<port::Mutex>>')).toBe('Striped');
+    expect(stripCppTemplateArguments('const std::map<int, std::vector<int> >&')).toBe('const std::map&');
+    expect(stripCppTemplateArguments('SkipList<const char*, Cmp<int>>::Iterator')).toBe('SkipList::Iterator');
+  });
+});
diff --git a/__tests__/cpp-overload-choice.test.ts b/__tests__/cpp-overload-choice.test.ts
new file mode 100644
index 0000000000..b69a1007d9
--- /dev/null
+++ b/__tests__/cpp-overload-choice.test.ts
@@ -0,0 +1,100 @@
+/**
+ * `lib::format("{}", x)` among overloads opened by a namespace macro picks the
+ * one the arguments fit: fmt's 1,400 `fmt::format("{}", …)` calls all went to
+ * color.h's `format(const text_style&, …)` — the first of the set indexed.
+ * A narrow literal fits a `format_string`, a wide one (`L"{}"`) the
+ * `wformat_string` overload, and a style argument the style overload.
+ */
+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-cpp-overload-'));
+  const files: Record<string, string> = {
+    'include/lib/base.h': `#pragma once
+#define LIB_BEGIN_NAMESPACE namespace lib {
+#define LIB_END_NAMESPACE }
+
+LIB_BEGIN_NAMESPACE
+template <typename... T> struct format_string {};
+template <typename... T> struct wformat_string {};
+LIB_END_NAMESPACE
+`,
+    'include/lib/color.h': `#pragma once
+#include "base.h"
+
+LIB_BEGIN_NAMESPACE
+struct text_style {};
+
+template <typename... T>
+inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args) -> int {
+  return 0;
+}
+LIB_END_NAMESPACE
+`,
+    'include/lib/format.h': `#pragma once
+#include "base.h"
+
+LIB_BEGIN_NAMESPACE
+template <typename... T>
+inline auto format(format_string<T...> fmt, T&&... args) -> int {
+  return 1;
+}
+LIB_END_NAMESPACE
+`,
+    'include/lib/xchar.h': `#pragma once
+#include "base.h"
+
+LIB_BEGIN_NAMESPACE
+template <typename... T>
+inline auto format(wformat_string<T...> fmt, T&&... args) -> int {
+  return 2;
+}
+LIB_END_NAMESPACE
+`,
+    'test/use.cc': `#include "lib/color.h"
+#include "lib/format.h"
+#include "lib/xchar.h"
+
+int narrow() { return lib::format("{}", 1); }
+int wide() { return lib::format(L"{}", 2); }
+int styled() { return lib::format(lib::text_style{}, "{}", 3); }
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const formatFileCalledBy = (fn: string): string[] => {
+  const node = cg.getNodesInFile('test/use.cc').find((n) => n.name === fn)!;
+  return cg.getOutgoingEdges(node.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!)
+    .filter((t) => t.name === 'format').map((t) => t.filePath);
+};
+
+describe('C++ overloads in a macro-opened namespace', () => {
+  it('a narrow literal picks the format_string overload', () => {
+    expect(formatFileCalledBy('narrow')).toEqual(['include/lib/format.h']);
+  });
+
+  it('a wide literal picks the wformat_string overload', () => {
+    expect(formatFileCalledBy('wide')).toEqual(['include/lib/xchar.h']);
+  });
+
+  it('a style argument picks the style overload', () => {
+    expect(formatFileCalledBy('styled')).toEqual(['include/lib/color.h']);
+  });
+});
diff --git a/__tests__/cpp-type-alias-receiver.test.ts b/__tests__/cpp-type-alias-receiver.test.ts
new file mode 100644
index 0000000000..835b20361a
--- /dev/null
+++ b/__tests__/cpp-type-alias-receiver.test.ts
@@ -0,0 +1,555 @@
+/**
+ * A C++ receiver declared through a `typedef` / `using` alias calls the type
+ * the alias names.
+ *
+ * google/leveldb's `MemTable::Add` calls `table_.Insert(buf)` on a member
+ * declared `Table table_;`, beside `typedef SkipList<const char*,
+ * KeyComparator> Table;` in the same class. Receiver inference read the
+ * declared type as `Table`; no class `Table` has an `Insert` (the one class
+ * `Table` is the unrelated `leveldb::Table`), and the C/C++ extractors record
+ * no aliased type on a `type_alias` node, so the call fell through to a guess
+ * by the receiver's name: `HandleTable::Insert` in util/cache.cc.
+ *
+ * The alias is now looked up the way C++ looks a name up: an alias declared
+ * earlier in the calling function, then the caller's class and the classes it
+ * inherits from, then the namespaces around it, innermost first, where a
+ * class of that name stops the search. The alias's declaration is read and
+ * its type followed, so the call reaches `SkipList::Insert`, a
+ * `Table::Iterator` declaration constructs `SkipList::Iterator`, and its
+ * methods resolve there. When the aliased type has no such method (an alias
+ * of `std::vector`, say) or the alias names a template parameter, no method
+ * is guessed by the receiver's name — unless the call goes through `->` on an
+ * iterator or smart pointer, which reaches a type the alias doesn't name, or
+ * the declaration was read from outside the calling function and its class.
+ */
+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 { cppTypeSegments } from '../src/resolution/cpp-type-aliases';
+import type { Node } from '../src/types';
+
+const roots: string[] = [];
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+async function indexed(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cpp-alias-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+function callable(cg: CodeGraph, qualifiedName: string): Node {
+  const node = [...cg.getNodesByKind('method'), ...cg.getNodesByKind('function')].find((n) => n.qualifiedName === qualifiedName);
+  if (!node) throw new Error(`no function or method ${qualifiedName}`);
+  return node;
+}
+
+/** `calls` callees of a function or method, as `qualifiedName (file)`. */
+function calls(cg: CodeGraph, caller: string): string[] {
+  return cg
+    .getCallees(callable(cg, caller).id)
+    .filter((r) => r.edge.kind === 'calls')
+    .map((r) => `${r.node.qualifiedName} (${r.node.filePath})`)
+    .sort();
+}
+
+/** google/leveldb's shapes, trimmed: the skip list, the unrelated `Table`, and the decoy `Insert`. */
+const LEVELDB = {
+  'include/leveldb/table.h': [
+    'namespace leveldb {',
+    'class Table {',
+    ' public:',
+    '  explicit Table(int* rep);',
+    '  int ApproximateOffsetOf(int key) const;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'util/cache.cc': [
+    'namespace leveldb {',
+    'class HandleTable {',
+    ' public:',
+    '  void Insert(int h) { last_ = h; }',
+    ' private:',
+    '  int last_;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/skiplist.h': [
+    'namespace leveldb {',
+    'template <typename Key, class Comparator>',
+    'class SkipList {',
+    ' public:',
+    '  explicit SkipList(Comparator cmp, int* arena);',
+    '  void Insert(const Key& key);',
+    '  class Iterator {',
+    '   public:',
+    '    explicit Iterator(const SkipList* list);',
+    '    void Seek(const Key& target);',
+    '  };',
+    '};',
+    'template <typename Key, class Comparator>',
+    'SkipList<Key, Comparator>::SkipList(Comparator cmp, int* arena) {}',
+    'template <typename Key, class Comparator>',
+    'void SkipList<Key, Comparator>::Insert(const Key& key) {}',
+    'template <typename Key, class Comparator>',
+    'SkipList<Key, Comparator>::Iterator::Iterator(const SkipList* list) {}',
+    'template <typename Key, class Comparator>',
+    'void SkipList<Key, Comparator>::Iterator::Seek(const Key& target) {}',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/memtable.h': [
+    '#include "db/skiplist.h"',
+    'namespace leveldb {',
+    'struct KeyComparator {',
+    '  int operator()(const char* a, const char* b) const;',
+    '};',
+    'class MemTable {',
+    ' public:',
+    '  void Add(const char* buf);',
+    '  bool Get(const char* key);',
+    '  void Rebuild(int* arena);',
+    '  void Index(const char* key);',
+    ' private:',
+    '  typedef SkipList<const char*, KeyComparator> Table;',
+    '  using Lookup = Table;',
+    '  Table table_;',
+    '  Lookup lookup_;',
+    '};',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+  'db/memtable.cc': [
+    '#include "db/memtable.h"',
+    'namespace leveldb {',
+    'void MemTable::Add(const char* buf) {',
+    '  table_.Insert(buf);',
+    '}',
+    'bool MemTable::Get(const char* key) {',
+    '  Table::Iterator iter(&table_);',
+    '  iter.Seek(key);',
+    '  return true;',
+    '}',
+    'void MemTable::Rebuild(int* arena) {',
+    '  KeyComparator cmp;',
+    '  Table fresh(cmp, &arena[0]);',
+    '  Table stale(&arena[1]);',
+    '}',
+    'void MemTable::Index(const char* key) {',
+    '  lookup_.Insert(key);',
+    '}',
+    '}  // namespace leveldb',
+    '',
+  ].join('\n'),
+};
+
+describe('a C++ receiver declared through an alias', () => {
+  it('reproduction: `table_.Insert` reaches SkipList::Insert, not a class named after the receiver', async () => {
+    const cg = await indexed(LEVELDB);
+    try {
+      expect(calls(cg, 'leveldb::MemTable::Add')).toEqual(['leveldb::SkipList::Insert (db/skiplist.h)']);
+      expect(cg.getCallers(callable(cg, 'leveldb::HandleTable::Insert').id).filter((r) => r.edge.kind === 'calls')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a nested type reached through the alias is constructed and called on the aliased type', async () => {
+    const cg = await indexed(LEVELDB);
+    try {
+      expect(calls(cg, 'leveldb::MemTable::Get')).toEqual([
+        'leveldb::SkipList::Iterator::Iterator (db/skiplist.h)',
+        'leveldb::SkipList::Iterator::Seek (db/skiplist.h)',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a local object of the alias type constructs the aliased type, never an outer class the alias hides', async () => {
+    const cg = await indexed(LEVELDB);
+    try {
+      // `Table fresh(cmp, &arena[0])` is SkipList's two-argument constructor;
+      // `Table stale(&arena[1])` fits no SkipList constructor, and
+      // `leveldb::Table(int*)` is not the `Table` this scope names.
+      expect(calls(cg, 'leveldb::MemTable::Rebuild')).toEqual(['leveldb::SkipList::SkipList (db/skiplist.h)']);
+      expect(cg.getCallers(callable(cg, 'leveldb::Table::Table').id).filter((r) => r.edge.kind === 'calls')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('follows an alias of an alias', async () => {
+    const cg = await indexed(LEVELDB);
+    try {
+      expect(calls(cg, 'leveldb::MemTable::Index')).toEqual(['leveldb::SkipList::Insert (db/skiplist.h)']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('an alias spelled from outside its class, and one declared in the calling function', async () => {
+    const cg = await indexed({
+      ...LEVELDB,
+      'db/builder.cc': [
+        '#include "db/memtable.h"',
+        'namespace leveldb {',
+        'void Fill(MemTable::Table* t) {',
+        '  t->Insert("k");',
+        '}',
+        'void Build(int* arena) {',
+        '  typedef SkipList<const char*, KeyComparator> List;',
+        '  KeyComparator cmp;',
+        '  List list(cmp, &arena[0]);',
+        '  list.Insert("k");',
+        '}',
+        '}  // namespace leveldb',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'leveldb::Fill')).toEqual(['leveldb::SkipList::Insert (db/skiplist.h)']);
+      expect(calls(cg, 'leveldb::Build')).toEqual([
+        'leveldb::SkipList::Insert (db/skiplist.h)',
+        'leveldb::SkipList::SkipList (db/skiplist.h)',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('no guess by the receiver\'s name when the aliased type lacks the method', async () => {
+    const cg = await indexed({
+      ...LEVELDB,
+      'include/leveldb/slice.h': [
+        'namespace leveldb {',
+        'class Slice {',
+        ' public:',
+        '  void clear() { size_ = 0; }',
+        ' private:',
+        '  int size_;',
+        '};',
+        '}  // namespace leveldb',
+        '',
+      ].join('\n'),
+      'db/version_set.h': [
+        '#include <vector>',
+        'namespace leveldb {',
+        'class VersionSet {',
+        ' public:',
+        '  void Clear();',
+        ' private:',
+        '  using Table = std::vector<int>;',
+        '  Table files_;',
+        '};',
+        '}  // namespace leveldb',
+        '',
+      ].join('\n'),
+      'db/version_set.cc': [
+        '#include "db/version_set.h"',
+        'namespace leveldb {',
+        'void VersionSet::Clear() {',
+        '  files_.clear();',
+        '}',
+        '}  // namespace leveldb',
+        '',
+      ].join('\n'),
+    });
+    try {
+      // `files_` is a std::vector: not Slice::clear, the one project `clear`.
+      expect(calls(cg, 'leveldb::VersionSet::Clear')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('nor when the call continues on the next line', async () => {
+    // protocolbuffers/protobuf's descriptor.cc writes `symbols_by_parent_`
+    // and `.insert(…)` on separate lines.
+    const cg = await indexed({
+      'src/descriptor.cc': [
+        '#include "absl/container/flat_hash_set.h"',
+        'namespace google { namespace protobuf {',
+        'class Arena {',
+        ' public:',
+        '  void insert(int block) {}',
+        '};',
+        'class FileDescriptorTables {',
+        ' public:',
+        '  bool AddAliasUnderParent(int symbol);',
+        ' private:',
+        '  typedef absl::flat_hash_set<int> SymbolsByParentSet;',
+        '  SymbolsByParentSet symbols_by_parent_;',
+        '};',
+        'bool FileDescriptorTables::AddAliasUnderParent(int symbol) {',
+        '  return symbols_by_parent_',
+        '      .insert(symbol)',
+        '      .second;',
+        '}',
+        '} }',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'google::protobuf::FileDescriptorTables::AddAliasUnderParent')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a class declared in an inner scope hides an outer alias of the same name; outside it the alias applies', async () => {
+    const cg = await indexed({
+      'app/holder.h': [
+        'namespace app {',
+        'class Gadget {',
+        ' public:',
+        '  void Spin();',
+        '};',
+        'using Widget = Gadget;',
+        'class Holder {',
+        ' public:',
+        '  class Widget {',
+        '   public:',
+        '    void Spin();',
+        '  };',
+        '  void Use();',
+        ' private:',
+        '  Widget w_;',
+        '};',
+        '}  // namespace app',
+        '',
+      ].join('\n'),
+      'app/holder.cc': [
+        '#include "app/holder.h"',
+        'namespace app {',
+        'void Gadget::Spin() {}',
+        'void Holder::Widget::Spin() {}',
+        'void Holder::Use() {',
+        '  w_.Spin();',
+        '}',
+        'void Twirl(Widget& w) {',
+        '  w.Spin();',
+        '}',
+        '}  // namespace app',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'app::Holder::Use')).toEqual(['app::Holder::Widget::Spin (app/holder.cc)']);
+      // Outside Holder, `Widget` is the namespace's alias of Gadget.
+      expect(calls(cg, 'app::Twirl')).toEqual(['app::Gadget::Spin (app/holder.cc)']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('an alias a class inherits', () => {
+  it('is found in the base class before an enclosing namespace, and a dependent alias is not followed', async () => {
+    // protocolbuffers/protobuf's json traits: `Field` in the derived traits is
+    // the base's `const FieldDescriptor*`, not the namespace's alias template.
+    const cg = await indexed({
+      'protobuf/descriptor.h': [
+        'namespace google { namespace protobuf {',
+        'class FieldDescriptor {',
+        ' public:',
+        '  bool is_repeated() const;',
+        '};',
+        'inline bool FieldDescriptor::is_repeated() const { return false; }',
+        'class OneofDescriptor {',
+        ' public:',
+        '  bool is_repeated() const { return false; }',
+        '};',
+        '} }',
+        '',
+      ].join('\n'),
+      'protobuf/json/traits.h': [
+        '#include "protobuf/descriptor.h"',
+        'namespace google { namespace protobuf { namespace json_internal {',
+        'template <typename Traits>',
+        'using Field = typename Traits::Field;',
+        'struct Proto2Descriptor {',
+        '  using Field = const FieldDescriptor*;',
+        '};',
+        'struct ParseProto2Descriptor : Proto2Descriptor {',
+        '  static bool NewMsg(Field f) { return f->is_repeated(); }',
+        '};',
+        '} } }',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'google::protobuf::json_internal::ParseProto2Descriptor::NewMsg')).toEqual([
+        'google::protobuf::FieldDescriptor::is_repeated (protobuf/descriptor.h)',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('an alias of a template parameter', () => {
+  it('names no type, so a class that shares the alias\'s name is not it', async () => {
+    // protocolbuffers/protobuf: `GenericTypeHandler<GenericType>` declares
+    // `using Type = GenericType;`, and the generated `google.protobuf.Type`
+    // message is a class named `Type` with a `Clear`.
+    const cg = await indexed({
+      'protobuf/type.pb.h': [
+        'namespace google { namespace protobuf {',
+        'class Type {',
+        ' public:',
+        '  void Clear();',
+        '};',
+        'inline void Type::Clear() {}',
+        '} }',
+        '',
+      ].join('\n'),
+      'protobuf/repeated_ptr_field.h': [
+        'namespace google { namespace protobuf { namespace internal {',
+        'template <typename GenericType>',
+        'class GenericTypeHandler {',
+        ' public:',
+        '  using Type = GenericType;',
+        '  static void Reset(Type* value) { value->Clear(); }',
+        '};',
+        '} } }',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'google::protobuf::internal::GenericTypeHandler::Reset')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('what does not rule a guess out', () => {
+  it('`->` through an alias of an iterator reaches the element type, which the alias does not name', async () => {
+    // google/googletest's gmock: `ExpectationSet::const_iterator` is a
+    // `std::set<Expectation>` iterator, and `it->` is an Expectation.
+    const cg = await indexed({
+      'gmock/expectation.h': [
+        '#include <set>',
+        'namespace testing {',
+        'class Expectation {',
+        ' public:',
+        '  int expectation_base() const { return 0; }',
+        '};',
+        'class ExpectationSet {',
+        ' public:',
+        '  typedef ::std::set<Expectation> Set;',
+        '  typedef Set::const_iterator const_iterator;',
+        '};',
+        'int Describe(const ExpectationSet& set) {',
+        '  ExpectationSet::const_iterator it;',
+        '  return it->expectation_base();',
+        '}',
+        '}  // namespace testing',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'testing::Describe')).toEqual(['testing::Expectation::expectation_base (gmock/expectation.h)']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a class template\'s specialization can declare a member the template itself does not', async () => {
+    // facebook/rocksdb's toku order-maintenance tree: `get_marked` is a member
+    // of `omt_node_templated<omtdata_t, true>` only.
+    const cg = await indexed({
+      'util/omt.h': [
+        'namespace toku {',
+        'namespace omt_internal {',
+        'template <typename omtdata_t, bool subtree_supports_marks>',
+        'class omt_node_templated {',
+        ' public:',
+        '  void clear_stolen_bits() {}',
+        '};',
+        'template <typename omtdata_t>',
+        'class omt_node_templated<omtdata_t, true> {',
+        ' public:',
+        '  bool get_marked() const { return false; }',
+        '};',
+        '}  // namespace omt_internal',
+        'template <typename omtdata_t, bool supports_marks = false>',
+        'class omt {',
+        ' public:',
+        '  bool has_marks() const;',
+        ' private:',
+        '  typedef omt_internal::omt_node_templated<omtdata_t, supports_marks> omt_node;',
+        '  omt_node root_;',
+        '};',
+        'template <typename omtdata_t, bool supports_marks>',
+        'bool omt<omtdata_t, supports_marks>::has_marks() const {',
+        '  const omt_node &node = root_;',
+        '  return node.get_marked();',
+        '}',
+        '}  // namespace toku',
+        '',
+      ].join('\n'),
+    });
+    try {
+      const callees = cg.getCallees(callable(cg, 'toku::omt::has_marks').id).filter((r) => r.edge.kind === 'calls').map((r) => r.node.name);
+      expect(callees).toEqual(['get_marked']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a declaration read from another class is not known to be the receiver\'s', async () => {
+    // fmtlib/fmt's scan.h: `auto data = scan_data<T...>()` deduces nothing
+    // the reader can see, and the `data` it then finds is another class's
+    // `const scan_arg* data;`.
+    const cg = await indexed({
+      'test/scan.h': [
+        'namespace fmt {',
+        'class basic_scan_arg {',
+        ' public:',
+        '  int type() const { return 0; }',
+        '};',
+        'using scan_arg = basic_scan_arg;',
+        'class scan_args {',
+        '  const scan_arg* data;',
+        '};',
+        'template <typename... T> class scan_data {',
+        ' public:',
+        '  int make_args() { return 0; }',
+        '};',
+        'template <typename... T> int scan() {',
+        '  auto data = scan_data<T...>();',
+        '  return data.make_args();',
+        '}',
+        '}  // namespace fmt',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'fmt::scan')).toEqual(['fmt::scan_data::make_args (test/scan.h)']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('cppTypeSegments', () => {
+  it('reads a written type as its `::` segments, without qualifiers or template arguments', () => {
+    expect(cppTypeSegments('SkipList<const char*, KeyComparator>')).toEqual(['SkipList']);
+    expect(cppTypeSegments('const ::leveldb::SkipList<Key, Cmp<int>>::Iterator&')).toEqual(['leveldb', 'SkipList', 'Iterator']);
+    expect(cppTypeSegments('typename Base<T>::Iter')).toEqual(['Base', 'Iter']);
+    expect(cppTypeSegments('struct Node*')).toEqual(['Node']);
+    expect(cppTypeSegments('unsigned int')).toBeNull();
+    expect(cppTypeSegments('void (*)(int)')).toBeNull();
+  });
+});
diff --git a/__tests__/cross-language-resolution.test.ts b/__tests__/cross-language-resolution.test.ts
index bfd40dbbde..9fd5925a46 100644
--- a/__tests__/cross-language-resolution.test.ts
+++ b/__tests__/cross-language-resolution.test.ts
@@ -132,8 +132,11 @@ describe('cross-language name resolution (#1986)', () => {
     expect(matchByQualifiedName(ref(method.qualifiedName), context)?.targetNodeId).toBe(method.id);
     expect(matchReference(ref(method.qualifiedName), context)).toBeNull();
     expect(matchReference(ref('Foreign.act'), context)).toBeNull();
-    expect(matchFuzzy(ref('FUZZYNAME'), context)).not.toBeNull();
-    expect(matchReference(ref('FUZZYNAME'), context)).toBeNull();
+    // Fuzzy is case-sensitive outside PHP/Pascal/CFML/COBOL/VB.NET, so the
+    // fuzzy winner here shares the exact name; the language gate still rejects it.
+    expect(matchFuzzy(ref('fuzzyName'), context)).not.toBeNull();
+    expect(matchReference(ref('fuzzyName'), context)).toBeNull();
+    expect(matchFuzzy(ref('FUZZYNAME'), context)).toBeNull();
     // Exact qualified match selects Python even though a Swift type has the
     // same bare name. Rejection must not fall through to that Swift type.
     const foreign = graph.getNodesByName('Winner').find((n) => n.language === 'python')!;
diff --git a/__tests__/csharp-bare-member-scope.test.ts b/__tests__/csharp-bare-member-scope.test.ts
new file mode 100644
index 0000000000..ed604d12a2
--- /dev/null
+++ b/__tests__/csharp-bare-member-scope.test.ts
@@ -0,0 +1,93 @@
+/**
+ * A bare C# name — `TestContext`, `Easing`, `Helper()` — is a member of the
+ * types around it, of their base types, or of a type a static using brings in
+ * (in the file, as `global using static`, or as a project file's
+ * `<Using … Static="true"/>`). eShop's `TestContext.Current` in one test class
+ * went to another test class's `TestContext` property; MAUI's `Easing.Linear`
+ * to an animation class's `Easing` property.
+ */
+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-csharp-scope-'));
+  const files: Record<string, string> = {
+    'tests/OrderProcessorTests.cs': `namespace App.Tests;
+
+public class OrderProcessorTests
+{
+    public TestContext TestContext { get; set; } = null!;
+}
+`,
+    'src/Animations/AnimationBase.cs': `namespace App.Animations;
+
+public abstract class AnimationBase
+{
+    public EasingType Easing { get; set; }
+}
+`,
+    'src/Execution/ExpressionBuilder.cs': `namespace App.Execution;
+
+public static class ExpressionBuilder
+{
+    public static object Call(object target) => target;
+}
+`,
+    'src/App.csproj': `<Project Sdk="Microsoft.NET.Sdk">
+  <ItemGroup>
+    <Using Include="App.Execution.ExpressionBuilder" Static="true"/>
+  </ItemGroup>
+</Project>
+`,
+    'src/Specs/SpecBase.cs': `namespace App.Specs;
+
+public abstract class SpecBase
+{
+    protected void AssertValid() { }
+}
+`,
+    'src/Specs/CatalogSpec.cs': `namespace App.Specs;
+
+public class CatalogSpec : SpecBase
+{
+    public void Runs()
+    {
+        var token = TestContext.Current.CancellationToken;
+        var easing = Easing.Linear;
+        AssertValid();
+        Call(token);
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('bare C# names', () => {
+  it('reach the base class and a project-wide static using, never another class’s property', () => {
+    const ids = cg.getNodesInFile('src/Specs/CatalogSpec.cs').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls' || e.kind === 'references')
+      .map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(targets).not.toContain('App.Tests::OrderProcessorTests::TestContext');
+    expect(targets).not.toContain('App.Animations::AnimationBase::Easing');
+    expect(targets).toContain('App.Specs::SpecBase::AssertValid');
+    expect(targets).toContain('App.Execution::ExpressionBuilder::Call');
+  });
+});
diff --git a/__tests__/csharp-member-initializers.test.ts b/__tests__/csharp-member-initializers.test.ts
new file mode 100644
index 0000000000..f5125b8321
--- /dev/null
+++ b/__tests__/csharp-member-initializers.test.ts
@@ -0,0 +1,155 @@
+/**
+ * C# field and property initializers belong to the member they initialize.
+ * `private readonly ILogger _log = LogManager.GetLogger(typeof(X));` and
+ * `public List<Foo> Items { get; } = new List<Foo>();` used to be skipped by
+ * both extractors, so the calls, instantiations and static reads written
+ * there were lost, and a method passed as a value there was the class's
+ * reference rather than the member's.
+ *
+ * A target-typed `new()` names no type of its own; as an initializer it
+ * constructs the member's declared type.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'Lib.cs': `namespace Lib
+{
+    public class Crate { }
+}
+public interface ILogger { }
+public static class LogManager
+{
+    public static ILogger GetLogger(System.Type t) => null;
+}
+public static class Helper
+{
+    public static int Compute(int n) => n;
+    public static int Seed() => 1;
+    public static void Register(System.Action a) { }
+    public static System.Action Wrap(System.Action a) => a;
+}
+public class Widget
+{
+    public Widget() { }
+    public Widget(int n) { }
+    public int Size { get; set; }
+}
+public class Bag<T> { }
+public static class Defaults
+{
+    public const string Name = "x";
+    public static readonly Widget Empty = new Widget();
+}
+`,
+  'Box.cs': `using Lib;
+
+public class Box
+{
+    private readonly ILogger _log = LogManager.GetLogger(typeof(Box));
+    private int _a = 1, _b = Helper.Compute(2);
+    private static readonly int Max = Helper.Seed();
+    private readonly Widget _made = new Widget(3);
+    private readonly Widget _typed = new() { Size = Helper.Seed() };
+    private Widget? _maybe = new();
+    private readonly Bag<Widget> _bag = new();
+    private readonly Lib.Crate _crate = new();
+    private readonly string _label = Defaults.Name;
+    private readonly System.Func<int, int> _square = x => Helper.Compute(x * x);
+    private readonly System.Action _later = () => Helper.Register(Handle);
+    private readonly System.Action _direct = Handle;
+    [System.Obsolete("use Helper.Seed()")] private int _flagged;
+    public Bag<Widget> Items { get; } = new Bag<Widget>();
+    public Widget Made { get; set; } = new();
+    public Widget Copy { get; } = Defaults.Empty;
+    public System.Action Wrapped { get; } = Helper.Wrap(Handle);
+    public int Seeded { get; } = Helper.Seed();
+    private static void Handle() { }
+}
+`,
+};
+
+describe('C# field and property initializers', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cs-initializers-'));
+    for (const [rel, content] of Object.entries(FILES)) fs.writeFileSync(path.join(root, rel), content);
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('are walked as the member they initialize (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const member = (qualifiedName: string): Node => {
+      const node = graph.getNodesInFile('Box.cs').find((n) => n.qualifiedName === qualifiedName);
+      expect(node, qualifiedName).toBeDefined();
+      return node!;
+    };
+    const targets = (node: Node, kind: string): string[] =>
+      graph
+        .getOutgoingEdgesFrom([node.id])
+        .filter((e) => e.kind === kind)
+        .map((e) => graph.getNode(e.target)!.qualifiedName)
+        .sort();
+
+    // Calls, per declarator.
+    expect(targets(member('Box::_log'), 'calls')).toEqual(['LogManager::GetLogger']);
+    expect(targets(member('Box::_a'), 'calls')).toEqual([]);
+    expect(targets(member('Box::_b'), 'calls')).toEqual(['Helper::Compute']);
+    expect(member('Box::Max').kind).toBe('constant');
+    expect(targets(member('Box::Max'), 'calls')).toEqual(['Helper::Seed']);
+    expect(targets(member('Box::Seeded'), 'calls')).toEqual(['Helper::Seed']);
+
+    // Instantiations, including a target-typed `new()` of the declared type.
+    expect(targets(member('Box::_made'), 'instantiates')).toEqual(['Widget']);
+    expect(targets(member('Box::_typed'), 'instantiates')).toEqual(['Widget']);
+    expect(targets(member('Box::_typed'), 'calls')).toEqual(['Helper::Seed']);
+    expect(targets(member('Box::_maybe'), 'instantiates')).toEqual(['Widget']);
+    expect(targets(member('Box::_bag'), 'instantiates')).toEqual(['Bag']);
+    expect(targets(member('Box::_crate'), 'instantiates')).toEqual(['Lib::Crate']);
+    expect(targets(member('Box::Items'), 'instantiates')).toEqual(['Bag']);
+    expect(targets(member('Box::Made'), 'instantiates')).toEqual(['Widget']);
+
+    // Static reads.
+    expect(targets(member('Box::_label'), 'references')).toContain('Defaults');
+    expect(targets(member('Box::Copy'), 'references')).toContain('Defaults');
+
+    // Lambda bodies belong to the member the lambda initializes.
+    expect(targets(member('Box::_square'), 'calls')).toEqual(['Helper::Compute']);
+    expect(targets(member('Box::_later'), 'calls')).toEqual(['Helper::Register']);
+
+    // A method passed as a value is the member's reference, captured once —
+    // not the class's as well.
+    expect(targets(member('Box::_later'), 'references')).toContain('Box::Handle');
+    expect(targets(member('Box::_direct'), 'references')).toContain('Box::Handle');
+    expect(targets(member('Box::Wrapped'), 'calls')).toEqual(['Helper::Wrap']);
+    expect(targets(member('Box::Wrapped'), 'references')).toContain('Box::Handle');
+    expect(targets(member('Box'), 'references')).not.toContain('Box::Handle');
+
+    // Attribute arguments are not an initializer, and the class itself
+    // calls and creates nothing.
+    expect(targets(member('Box::_flagged'), 'calls')).toEqual([]);
+    expect(targets(member('Box'), 'calls')).toEqual([]);
+    expect(targets(member('Box'), 'instantiates')).toEqual([]);
+  });
+});
diff --git a/__tests__/csharp-namespace-scope.test.ts b/__tests__/csharp-namespace-scope.test.ts
new file mode 100644
index 0000000000..b185d3f33d
--- /dev/null
+++ b/__tests__/csharp-namespace-scope.test.ts
@@ -0,0 +1,172 @@
+/**
+ * C# names follow the scopes the language gives them:
+ * - a block `namespace X { … }` holds only its body — serilog's Guard.cs
+ *   declares `static class Guard` after a `namespace JetBrains.Annotations`
+ *   block, and a file's second namespace (or one nested inside another,
+ *   `Outer.Inner`) is its own;
+ * - `using X;` names the project's namespace X, never another file's using;
+ * - a `global using` is its own project's — serilog's two test projects each
+ *   `global using` their own `Support` namespace, and both define `Some`;
+ * - a nested type is reached by bare name only from inside its owner or a
+ *   type deriving from it, through any partial part.
+ */
+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-csharp-ns-'));
+  const files: Record<string, string> = {
+    'src/Lib/Lib.csproj': '<Project Sdk="Microsoft.NET.Sdk"></Project>\n',
+    'src/Lib/Guard.cs': `using JetBrains.Annotations;
+
+namespace JetBrains.Annotations
+{
+    sealed class NoEnumerationAttribute : System.Attribute { }
+}
+
+static class Guard
+{
+    public static T AgainstNull<T>(T value) where T : class => value;
+}
+`,
+    'src/Lib/Multi.cs': `namespace Alpha
+{
+    class X { }
+}
+
+namespace Beta
+{
+    class Y { }
+
+    namespace Inner
+    {
+        class Z { }
+    }
+}
+`,
+    'src/Lib/Uses.cs': `using Beta;
+
+namespace Gamma
+{
+    class Consumer { }
+}
+`,
+    'src/Lib/Reader.cs': `namespace Lib
+{
+    public abstract class Reader
+    {
+        internal enum State { Start, Done }
+    }
+
+    public partial class TextReader : Reader
+    {
+    }
+}
+`,
+    'src/Lib/TextReader.Async.cs': `namespace Lib
+{
+    public partial class TextReader
+    {
+        object Peek() => State.Start;
+    }
+}
+`,
+    'src/Lib/Writer.cs': `namespace Lib
+{
+    public abstract class Writer
+    {
+        internal enum State { Start, Done }
+
+        object Current() => State.Done;
+    }
+}
+`,
+    'test/Unit/Unit.csproj': '<Project Sdk="Microsoft.NET.Sdk"></Project>\n',
+    'test/Unit/GlobalUsings.cs': 'global using Unit.Support;\n',
+    'test/Unit/Support/Some.cs': `namespace Unit.Support;
+
+static class Some
+{
+    public static int InformationEvent() => 1;
+}
+`,
+    'test/Unit/LogTests.cs': `namespace Unit.Context;
+
+class LogTests
+{
+    int Run() => Some.InformationEvent();
+}
+`,
+    'test/Unit/MappingTests.cs': `namespace Unit.Mapping;
+
+class FirstCase
+{
+    class Source { }
+    object Make() => new Source();
+}
+
+class SecondCase
+{
+    class Source { }
+    object Make() => new Source();
+}
+`,
+    'test/Perf/Perf.csproj': '<Project Sdk="Microsoft.NET.Sdk"></Project>\n',
+    'test/Perf/GlobalUsings.cs': 'global using Perf.Support;\n',
+    'test/Perf/Support/Some.cs': `namespace Perf.Support;
+
+static class Some
+{
+    public static int InformationEvent() => 2;
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const qualifiedNames = (file: string) => cg.getNodesInFile(file).filter((n) => n.kind !== 'file').map((n) => `${n.kind} ${n.qualifiedName}`);
+const targetsAt = (file: string, line: number, kind?: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.line === line && (!kind || e.kind === kind))
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.kind} ${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('C# namespaces, usings and nested types', () => {
+  it('a block namespace qualifies only its own body', () => {
+    expect(qualifiedNames('src/Lib/Guard.cs')).toEqual(expect.arrayContaining([
+      'class JetBrains.Annotations::NoEnumerationAttribute', 'class Guard', 'method Guard::AgainstNull',
+    ]));
+    expect(qualifiedNames('src/Lib/Multi.cs')).toEqual(expect.arrayContaining([
+      'class Alpha::X', 'class Beta::Y', 'class Beta.Inner::Z',
+    ]));
+  });
+
+  it('a using names the project’s namespace', () => {
+    expect(targetsAt('src/Lib/Uses.cs', 1, 'imports')).toEqual(['namespace src/Lib/Multi.cs:Beta']);
+  });
+
+  it('a global using is its own project’s', () => {
+    expect(targetsAt('test/Unit/LogTests.cs', 5, 'calls')).toEqual(['method test/Unit/Support/Some.cs:Unit.Support::Some::InformationEvent']);
+  });
+
+  it('a nested type is its owner’s, or a derived type’s through any partial part', () => {
+    expect(targetsAt('test/Unit/MappingTests.cs', 12, 'instantiates')).toEqual(['class test/Unit/MappingTests.cs:Unit.Mapping::SecondCase::Source']);
+    expect(targetsAt('src/Lib/TextReader.Async.cs', 5)).toContain('enum src/Lib/Reader.cs:Lib::Reader::State');
+    expect(targetsAt('src/Lib/Writer.cs', 7)).toContain('enum src/Lib/Writer.cs:Lib::Writer::State');
+  });
+});
diff --git a/__tests__/csharp-namespace-visibility.test.ts b/__tests__/csharp-namespace-visibility.test.ts
new file mode 100644
index 0000000000..8ffac2ff4d
--- /dev/null
+++ b/__tests__/csharp-namespace-visibility.test.ts
@@ -0,0 +1,86 @@
+/**
+ * A bare C# type name means a type its file can see: one in its own
+ * namespace or an enclosing one, or in a namespace it imports (`using`,
+ * `global using`, the project's `<Using>` / implicit usings), or the one an
+ * alias names. Newtonsoft's `async Task` tests (`using
+ * System.Threading.Tasks;`) bound `Task` to a test class of that name in
+ * `Newtonsoft.Json.Tests.Schema` 433 times.
+ */
+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-cs-ns-'));
+  const files: Record<string, string> = {
+    'src/App.Tests/Schema/Generator.cs': `namespace App.Tests.Schema
+{
+    public class Task
+    {
+    }
+}
+`,
+    'src/App.Tests/Reader/ReadTests.cs': `using System.Threading.Tasks;
+
+namespace App.Tests.Reader
+{
+    public class ReadTests
+    {
+        public async Task Read()
+        {
+            await System.Threading.Tasks.Task.Yield();
+        }
+    }
+}
+`,
+    'src/App.Tests/Schema/Planner.cs': `namespace App.Tests.Schema
+{
+    public class Planner
+    {
+        public Task Next() { return new Task(); }
+    }
+}
+`,
+    'src/App.Tests/Other/Aliased.cs': `using Task = App.Tests.Schema.Task;
+
+namespace App.Tests.Other
+{
+    public class Aliased
+    {
+        public Task Make() { return new Task(); }
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const reachesTask = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).some((e) => cg.getNode(e.target)!.qualifiedName === 'App.Tests.Schema::Task');
+};
+
+describe('C# type names and namespaces', () => {
+  it('a type another namespace does not import is not in reach', () => {
+    expect(reachesTask('src/App.Tests/Reader/ReadTests.cs')).toBe(false);
+  });
+
+  it('the same namespace, and an alias naming the type, reach it', () => {
+    expect(reachesTask('src/App.Tests/Schema/Planner.cs')).toBe(true);
+    expect(reachesTask('src/App.Tests/Other/Aliased.cs')).toBe(true);
+  });
+});
diff --git a/__tests__/csharp-property-accessors.test.ts b/__tests__/csharp-property-accessors.test.ts
new file mode 100644
index 0000000000..b77d8549d6
--- /dev/null
+++ b/__tests__/csharp-property-accessors.test.ts
@@ -0,0 +1,91 @@
+/**
+ * C# property accessor bodies belong to the property. `get { … }`,
+ * `set { … }`, `get => …` and an expression-bodied `=> …` property used to
+ * be skipped by both extractors, so the calls, instantiations and static
+ * reads written there were lost and a getter's callee looked unused.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'Helper.cs': `public static class Helper {
+    public static int Compute(int n) => n;
+    public static void Store(int n) {}
+    public static int Arrow() => 1;
+    public static int GetA() => 1;
+    public static void SetA(int v) {}
+}
+public class Widget {}
+public static class Defaults { public const string Name = "x"; }
+`,
+  'Box.cs': `public class Box {
+    private int _x;
+    public int Value {
+        get { return Helper.Compute(_x); }
+        set { Helper.Store(value); _x = value; }
+    }
+    public int Arrow => Helper.Arrow();
+    public int Both { get => Helper.GetA(); set => Helper.SetA(value); }
+    public Widget Made { get { return new Widget(); } }
+    public string Label { get { return Defaults.Name; } }
+    private void Handle(int v) { }
+    public System.Action<int> Handler { get { return Pick(Handle); } }
+}
+`,
+};
+
+describe('C# property accessor bodies', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cs-accessors-'));
+    for (const [rel, content] of Object.entries(FILES)) fs.writeFileSync(path.join(root, rel), content);
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('are walked as the property (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const member = (qualifiedName: string): Node => {
+      const node = graph.getNodesInFile('Box.cs').find((n) => n.qualifiedName === qualifiedName);
+      expect(node, qualifiedName).toBeDefined();
+      return node!;
+    };
+    const targets = (node: Node, kind: string): string[] =>
+      graph
+        .getOutgoingEdgesFrom([node.id])
+        .filter((e) => e.kind === kind)
+        .map((e) => graph.getNode(e.target)!.qualifiedName)
+        .sort();
+
+    expect(targets(member('Box::Value'), 'calls')).toEqual(['Helper::Compute', 'Helper::Store']);
+    expect(targets(member('Box::Arrow'), 'calls')).toEqual(['Helper::Arrow']);
+    expect(targets(member('Box::Both'), 'calls')).toEqual(['Helper::GetA', 'Helper::SetA']);
+    expect(targets(member('Box::Made'), 'instantiates')).toEqual(['Widget']);
+    expect(targets(member('Box::Label'), 'references')).toContain('Defaults');
+    // A method passed as a value inside an accessor is the property's
+    // reference, captured once — not the class's as well.
+    expect(targets(member('Box::Handler'), 'references')).toContain('Box::Handle');
+    expect(targets(member('Box'), 'references')).not.toContain('Box::Handle');
+    expect(targets(member('Box'), 'calls')).toEqual([]);
+  });
+});
diff --git a/__tests__/csharp-type-position-refs.test.ts b/__tests__/csharp-type-position-refs.test.ts
new file mode 100644
index 0000000000..ccfba566b9
--- /dev/null
+++ b/__tests__/csharp-type-position-refs.test.ts
@@ -0,0 +1,114 @@
+/**
+ * A C# type position names a type. `Type sourceType`, `List<int>`, `new
+ * TypeMap()` used to resolve to whichever same-named member was nearest: on
+ * AutoMapper `Type` bound to an attribute's `Type` property, `List<…>` to a
+ * test class's `List` property (519 dependents), and `TypeMap typeMap` to a
+ * `TypeMap` property sitting beside the `TypeMap` class.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+const FILES: Record<string, string> = {
+  'src/TypeMap.cs': `namespace App;
+public class TypeMap {
+    public string Name { get; set; }
+}
+public class MemberMap {
+    public MemberMap() { }
+}
+`,
+  'src/Attrs.cs': `namespace App;
+public class ValueConverterAttribute {
+    public System.Type Type { get; set; }
+}
+public class Source {
+    public System.Collections.Generic.List<int> List { get; set; }
+}
+`,
+  'src/Profile.cs': `namespace App;
+using System;
+using System.Collections.Generic;
+public class Profile {
+    public TypeMap TypeMap { get; set; }
+    public void Configure(TypeMap typeMap, MemberMap memberMap, Type sourceType) {
+        var items = new List<int>();
+        var copy = new TypeMap();
+    }
+}
+`,
+};
+
+describe('C#: a type position names a type', () => {
+  it('never a property, method or case that shares the name', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cs-type-refs-'));
+    roots.push(root);
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const configure = cg.getNodesByName('Configure').find((n) => n.kind === 'method')!;
+      const targets = cg
+        .getOutgoingEdgesFrom([configure.id], ['references', 'instantiates', 'type_of'])
+        .map((e) => cg.getNode(e.target))
+        .map((n) => `${n!.kind}:${n!.name}`);
+      expect(targets).toContain('class:TypeMap');
+      expect(targets).toContain('class:MemberMap');
+      // A property, a constructor, or a type the project only has a member named after.
+      expect(targets.filter((t) => t.startsWith('property:') || t.startsWith('method:'))).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('never a constant that shares the name', async () => {
+    // `const` and `static readonly` fields are constants: jellyfin's `new
+    // Version(5, 18)` (System.Version) bound to a `const string Version`
+    // claim name, and serilog's `static readonly Meter Meter = new(…)`
+    // instantiated itself.
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-cs-type-refs-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'src/Claims.cs': `namespace App;
+public static class ClaimTypes {
+    public const string Version = "v";
+}
+`,
+      'src/Encoder.cs': `namespace App;
+using System;
+public class ValueFormatter { }
+public class Encoder {
+    private static readonly Version MinVersion = new Version(5, 18);
+    private static readonly Meter Meter = new("app");
+    private static readonly ValueFormatter ValueFormatter = new();
+    public void Check() { var v = new Version(1, 0); }
+}
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const members = cg.getNodesInFile('src/Encoder.cs').filter((n) => n.kind !== 'file');
+      const targets = cg
+        .getOutgoingEdgesFrom(members.map((n) => n.id), ['references', 'instantiates', 'type_of'])
+        .map((e) => `${cg.getNode(e.source)!.name} ${e.kind} ${cg.getNode(e.target)!.kind}:${cg.getNode(e.target)!.qualifiedName}`)
+        .sort();
+      expect(targets.filter((t) => t.includes(' constant:'))).toEqual([]);
+      expect(targets).toContain('ValueFormatter instantiates class:App::ValueFormatter');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/daemon-install-check.test.ts b/__tests__/daemon-install-check.test.ts
new file mode 100644
index 0000000000..614afb6e4a
--- /dev/null
+++ b/__tests__/daemon-install-check.test.ts
@@ -0,0 +1,83 @@
+/**
+ * A daemon whose install was upgraded or deleted underneath it exits (#2335).
+ *
+ * The daemon loads grammars (and the native kernel, and worker scripts) lazily
+ * from the directory it was started from. An upgrade replaces or deletes that
+ * directory while the daemon keeps running, so every later load fails; the
+ * 1.6.1 daemon in #2335 went on re-indexing files as empty for as long as it
+ * lived. It now checks its own package.json periodically and makes way for a
+ * daemon started from the current install. The check is pure and the Daemon's
+ * reaction is tested with it injected; neither starts a real daemon.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { Daemon, installChangedReason } from '../src/mcp/daemon';
+
+describe('installChangedReason', () => {
+  let dir: string;
+  let pkg: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-install-check-'));
+    pkg = path.join(dir, 'package.json');
+    fs.writeFileSync(pkg, JSON.stringify({ name: '@colbymchenry/codegraph', version: '1.6.2' }));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('is null while the install still carries the running version', () => {
+    expect(installChangedReason(pkg, '1.6.2')).toBeNull();
+  });
+
+  it('reports an install upgraded in place', () => {
+    fs.writeFileSync(pkg, JSON.stringify({ version: '1.6.3' }));
+    expect(installChangedReason(pkg, '1.6.2')).toMatch(/replaced by v1\.6\.3/);
+  });
+
+  it('reports an install that was deleted, file or whole directory', () => {
+    fs.rmSync(pkg);
+    expect(installChangedReason(pkg, '1.6.2')).toMatch(/removed/);
+    fs.rmSync(dir, { recursive: true, force: true });
+    expect(installChangedReason(pkg, '1.6.2')).toMatch(/removed/);
+  });
+
+  it('waits for a package.json caught mid-write instead of exiting on it', () => {
+    fs.writeFileSync(pkg, '{"name": "@colbymchenry/codeg');
+    expect(installChangedReason(pkg, '1.6.2')).toBeNull();
+    fs.writeFileSync(pkg, '');
+    expect(installChangedReason(pkg, '1.6.2')).toBeNull();
+  });
+});
+
+describe('Daemon.checkInstall', () => {
+  // A Daemon is safe to construct (nothing binds until start()); stop() is
+  // replaced so a positive check can't tear down the test process.
+  const makeDaemon = () => {
+    const d = new Daemon('/tmp/codegraph-install-check-unit-test', { idleTimeoutMs: 0 }) as any;
+    d.stop = vi.fn(async () => {});
+    return d;
+  };
+
+  it('stops the daemon when its install changed', () => {
+    const d = makeDaemon();
+    expect(d.checkInstall(() => 'Install removed')).toBe(true);
+    expect(d.stop).toHaveBeenCalledWith('install changed');
+  });
+
+  it('keeps running while the install is unchanged', () => {
+    const d = makeDaemon();
+    expect(d.checkInstall(() => null)).toBe(false);
+    expect(d.stop).not.toHaveBeenCalled();
+  });
+
+  it('does nothing once the daemon is already stopping', () => {
+    const d = makeDaemon();
+    d.stopping = true;
+    expect(d.checkInstall(() => 'Install removed')).toBe(false);
+    expect(d.stop).not.toHaveBeenCalled();
+  });
+});
diff --git a/__tests__/daemon-older-version.test.ts b/__tests__/daemon-older-version.test.ts
new file mode 100644
index 0000000000..b29cbba3c6
--- /dev/null
+++ b/__tests__/daemon-older-version.test.ts
@@ -0,0 +1,761 @@
+/**
+ * A launcher replaces a daemon from an older install (#2335).
+ *
+ * A daemon keeps running the code it started with. The 1.6.1 daemon in #2335
+ * outlived an upgrade to 1.6.2, went on loading grammars from the install the
+ * upgrade removed, and wrote every file its watcher re-indexed as empty. A
+ * launcher that found it could only serve its own session in-process, read-only:
+ * the old daemon held the project's writer lock and file watcher, so no daemon
+ * from the new install could start. Daemons from before the fix cannot notice
+ * the upgrade themselves, so the launcher acts: a daemon of an OLDER release is
+ * stopped the way `codegraph daemon` stops one (identity-checked SIGTERM, a
+ * graceful shutdown on POSIX) and one from the launcher's own install takes its
+ * place. The launcher hears an older daemon's hello on its own socket, or —
+ * when it listens elsewhere (on Windows, daemons before #2278 named their pipe
+ * after the root as typed) — finds it by the project lock. A daemon of the
+ * same, a newer or an unknown version is never touched, so two installed
+ * versions cannot fight over the daemon.
+ *
+ * The end-to-end cases run real daemons of other versions: this build's dist/
+ * linked into a temp "install" whose package.json carries another version. A
+ * daemon resolves its version, and every grammar it loads, from its own files,
+ * so that install's daemon advertises that version in its lock and its hello.
+ */
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChildProcessWithoutNullStreams, execFileSync, spawn } from 'child_process';
+import { once } from 'events';
+import * as fs from 'fs';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { encodeLockInfo, getDaemonPidPath, getDaemonSocketPath } from '../src/mcp/daemon-paths';
+import { isProcessAlive, stopOlderDaemon } from '../src/mcp/daemon-registry';
+import { connectWithHello } from '../src/mcp/proxy';
+import { CodeGraphPackageVersion, isOlderRelease } from '../src/mcp/version';
+import { getWriterPidPath, readWriterLock, swapWriterLock } from '../src/mcp/writer-lock';
+import { WASM_RUNTIME_FLAGS } from '../src/extraction/wasm-runtime-flags';
+import { recordSpawns, removeSpawnLog, settleLosingCandidates } from './daemon-candidates';
+
+const BIN = path.resolve(__dirname, '../dist/bin/codegraph.js');
+const DIST = path.resolve(__dirname, '../dist');
+const NODE_MODULES = path.resolve(__dirname, '../node_modules');
+const OLDER_DAEMON = path.resolve(__dirname, 'fixtures/older-daemon.cjs');
+
+/** Plain releases always below / above any version this repo will carry. */
+const OLDER = '0.0.1';
+const NEWER = '999.0.0';
+
+describe('isOlderRelease', () => {
+  it('orders plain releases numerically', () => {
+    expect(isOlderRelease('1.6.1', '1.6.2')).toBe(true);
+    expect(isOlderRelease('1.6.9', '1.6.10')).toBe(true);
+    expect(isOlderRelease('1.9.0', '1.10.0')).toBe(true);
+    expect(isOlderRelease('0.99.99', '1.0.0')).toBe(true);
+    expect(isOlderRelease('1.6.2', '1.6.2')).toBe(false);
+    expect(isOlderRelease('1.6.3', '1.6.2')).toBe(false);
+    expect(isOlderRelease('2.0.0', '1.99.99')).toBe(false);
+  });
+
+  it('never calls a prerelease, a build or an unknown version older, in either position', () => {
+    for (const odd of ['0.0.0-unknown', '0.0.0-mismatch', '1.6.1-beta.1', '1.6.1+local', 'v1.6.1', 'unknown', 'test', '', '1.6']) {
+      expect(isOlderRelease(odd, '1.6.2'), odd).toBe(false);
+      expect(isOlderRelease('1.6.1', odd), odd).toBe(false);
+    }
+  });
+
+  it('lets at most one of two versions replace the other', () => {
+    const versions = ['0.9.0', '1.6.1', '1.6.2', '1.6.10', '1.7.0', '2.0.0', '1.6.2-rc.1', '0.0.0-unknown'];
+    for (const a of versions) {
+      for (const b of versions) {
+        expect(isOlderRelease(a, b) && isOlderRelease(b, a), `${a} / ${b}`).toBe(false);
+      }
+    }
+  });
+});
+
+/** A path a test server can listen on: a named pipe on Windows, a socket file elsewhere. */
+function listenPath(dir: string, name: string): string {
+  return process.platform === 'win32'
+    ? `\\\\.\\pipe\\${path.basename(dir)}-${name}`
+    : path.join(dir, `${name}.sock`);
+}
+
+async function listen(server: net.Server, socketPath: string): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(socketPath, resolve);
+  });
+}
+
+describe('connectWithHello', () => {
+  let dir: string;
+  let server: net.Server | null = null;
+
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-hello-')); });
+  afterEach(async () => {
+    if (server) await new Promise<void>((resolve) => server!.close(() => resolve()));
+    server = null;
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it.each([
+    [OLDER, 'older-version', false],
+    [NEWER, 'version-mismatch', true],
+    ['0.0.0-unknown', 'version-mismatch', true],
+  ])('reports a %s daemon as %s', async (version, expected, logged) => {
+    const socketPath = listenPath(dir, 'daemon');
+    server = net.createServer((socket) => {
+      socket.write(JSON.stringify({ codegraph: version, pid: process.pid, socketPath, protocol: 1 }) + '\n');
+    });
+    await listen(server, socketPath);
+    const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    try {
+      expect(await connectWithHello(socketPath, '1.6.2')).toBe(expected);
+      // An older daemon is the launcher's to report; it is not a mismatch to serve around.
+      expect(stderr.mock.calls.some(([line]) => String(line).includes('differs from ours'))).toBe(logged);
+    } finally {
+      stderr.mockRestore();
+    }
+  });
+});
+
+describe('swapWriterLock', () => {
+  let root: string;
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-writer-swap-'));
+    fs.mkdirSync(path.join(root, '.codegraph'));
+  });
+  afterEach(() => { fs.rmSync(root, { recursive: true, force: true }); });
+
+  const record = (pid: number, mode: string) => ({ pid, mode, startedAt: 1, ready: false });
+
+  it('replaces the record of the given pid, and only that record', () => {
+    const file = getWriterPidPath(root);
+    fs.writeFileSync(file, JSON.stringify(record(111, 'daemon')) + '\n');
+    expect(swapWriterLock(root, 222, record(333, 'handover'))).toBe(false);
+    expect(readWriterLock(root)).toMatchObject({ pid: 111, mode: 'daemon' });
+    expect(swapWriterLock(root, 111, record(333, 'handover'))).toBe(true);
+    expect(readWriterLock(root)).toMatchObject({ pid: 333, mode: 'handover' });
+    // A slot nobody holds is not handed over: it is acquired the usual way.
+    fs.rmSync(file);
+    expect(swapWriterLock(root, 333, record(444, 'daemon'))).toBe(false);
+    expect(fs.existsSync(file)).toBe(false);
+    expect(fs.readdirSync(path.join(root, '.codegraph'))).toEqual([]);
+  });
+});
+
+/** A live process to stand in for a daemon; signals reach it, never the test. */
+function startDetachedProcess(): number {
+  const source = [
+    "const { spawn } = require('child_process');",
+    "const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { detached: true, stdio: 'ignore' });",
+    'child.unref();',
+    'console.log(child.pid);',
+  ].join(' ');
+  const pid = Number(execFileSync(process.execPath, ['-e', source], { encoding: 'utf8' }).trim());
+  if (!Number.isInteger(pid) || pid <= 0) throw new Error('could not start daemon fixture');
+  return pid;
+}
+
+async function deadPid(): Promise<number> {
+  const child = spawn(process.execPath, ['-e', 'process.exit(0)']);
+  await once(child, 'exit');
+  await new Promise((r) => setTimeout(r, 50));
+  return child.pid!;
+}
+
+describe('stopOlderDaemon', () => {
+  let root: string;
+  let pidPath: string;
+  let socketPath: string;
+  let server: net.Server | null;
+  let pids: number[];
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-older-daemon-'));
+    fs.mkdirSync(path.join(root, '.codegraph'));
+    pidPath = getDaemonPidPath(root);
+    socketPath = getDaemonSocketPath(root);
+    server = null;
+    pids = [];
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    for (const pid of pids) if (isProcessAlive(pid)) process.kill(pid, 'SIGKILL');
+    if (server) await new Promise<void>((resolve) => server!.close(() => resolve()));
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  /** A daemon of `version`: its lock, and a socket answering the hello as `helloPid`. */
+  async function fakeDaemon(version: string, helloPid?: number): Promise<{ pid: number; lock: string }> {
+    const pid = startDetachedProcess();
+    pids.push(pid);
+    server = net.createServer((socket) => {
+      socket.end(JSON.stringify({ protocol: 1, codegraph: version, pid: helloPid ?? pid, socketPath }) + '\n');
+    });
+    await listen(server, socketPath);
+    const lock = encodeLockInfo({ pid, version, socketPath, startedAt: Date.now() });
+    fs.writeFileSync(pidPath, lock);
+    return { pid, lock };
+  }
+
+  /** Signals sent to `pid`, other than the signal-0 liveness probe. */
+  function signalsTo(kill: ReturnType<typeof vi.spyOn>, pid: number): unknown[] {
+    return kill.mock.calls.filter(([target, signal]) => target === pid && signal !== 0).map(([, signal]) => signal);
+  }
+
+  /** The writer record, decoded. */
+  const writerRecord = (): any => {
+    try { return JSON.parse(fs.readFileSync(getWriterPidPath(root), 'utf8')); } catch { return null; }
+  };
+
+  it('stops a verified daemon of an older release and clears its lock', async () => {
+    const { pid } = await fakeDaemon('1.6.1');
+    const result = await stopOlderDaemon(root, '1.6.2');
+    expect(result).toMatchObject({ pid, outcome: 'term', version: '1.6.1' });
+    expect(isProcessAlive(pid)).toBe(false);
+    expect(fs.existsSync(pidPath)).toBe(false);
+    // Kept for the daemon the caller starts next.
+    expect(writerRecord()).toMatchObject({ pid: process.pid, mode: 'handover' });
+  }, 15000);
+
+  it('holds the writer slot from before the signal, so it is never free or stale', async () => {
+    const { pid } = await fakeDaemon('1.6.1');
+    fs.writeFileSync(getWriterPidPath(root), JSON.stringify({ pid, mode: 'daemon', startedAt: 1, ready: true }) + '\n');
+    let atSignal: unknown = null;
+    const originalKill = process.kill.bind(process);
+    vi.spyOn(process, 'kill').mockImplementation((target, signal) => {
+      if (target === pid && signal === 'SIGTERM') atSignal = writerRecord();
+      return originalKill(target, signal);
+    });
+    expect(await stopOlderDaemon(root, '1.6.2')).toMatchObject({ pid, outcome: 'term' });
+    // A session of the old daemon serving itself the moment it went found the
+    // slot held, and so served reads only.
+    expect(atSignal).toMatchObject({ pid: process.pid, mode: 'handover' });
+    expect(writerRecord()).toMatchObject({ pid: process.pid, mode: 'handover' });
+    expect(fs.existsSync(pidPath)).toBe(false);
+  }, 15000);
+
+  it('gives the writer slot back to an older daemon that does not exit', async () => {
+    const { pid, lock } = await fakeDaemon('1.6.1');
+    const record = { pid, mode: 'daemon', startedAt: 1, ready: true };
+    fs.writeFileSync(getWriterPidPath(root), JSON.stringify(record) + '\n');
+    // The signal reaches nothing: the daemon closes its socket, as its own
+    // shutdown does first, and then never exits.
+    const originalKill = process.kill.bind(process);
+    vi.spyOn(process, 'kill').mockImplementation((target, signal) => {
+      if (target === pid && signal === 'SIGTERM') { server?.close(); return true; }
+      return originalKill(target, signal);
+    });
+    expect(await stopOlderDaemon(root, '1.6.2', { shutdownGraceMs: 300 })).toMatchObject({ pid, outcome: 'still-running' });
+    expect(writerRecord()).toEqual(record);
+    expect(fs.readFileSync(pidPath, 'utf8')).toBe(lock);
+    expect(isProcessAlive(pid)).toBe(true);
+  }, 15000);
+
+  it('leaves the daemon to another launcher already holding the slot to replace it', async () => {
+    const { pid, lock } = await fakeDaemon('1.6.1');
+    const other = startDetachedProcess();
+    pids.push(other);
+    const claim = { pid: other, mode: 'handover', startedAt: 1, ready: false };
+    fs.writeFileSync(getWriterPidPath(root), JSON.stringify(claim) + '\n');
+    const kill = vi.spyOn(process, 'kill');
+    expect(await stopOlderDaemon(root, '1.6.2')).toBeNull();
+    expect(signalsTo(kill, pid)).toEqual([]);
+    expect(writerRecord()).toEqual(claim);
+    expect(fs.readFileSync(pidPath, 'utf8')).toBe(lock);
+  });
+
+  it.each(['1.6.2', '1.6.3', '2.0.0', '1.6.1-beta.1', '0.0.0-unknown', 'test'])(
+    'never signals a daemon of version %s',
+    async (version) => {
+      const { pid, lock } = await fakeDaemon(version);
+      const kill = vi.spyOn(process, 'kill');
+      expect(await stopOlderDaemon(root, '1.6.2')).toBeNull();
+      expect(signalsTo(kill, pid)).toEqual([]);
+      expect(isProcessAlive(pid)).toBe(true);
+      expect(fs.readFileSync(pidPath, 'utf8')).toBe(lock);
+    },
+  );
+
+  it('leaves an older lock alone when its socket answers for another process (#1553)', async () => {
+    const { pid, lock } = await fakeDaemon('1.6.1', process.pid);
+    const kill = vi.spyOn(process, 'kill');
+    expect(await stopOlderDaemon(root, '1.6.2')).toMatchObject({ pid, outcome: 'unverified' });
+    expect(signalsTo(kill, pid)).toEqual([]);
+    expect(signalsTo(kill, process.pid)).toEqual([]);
+    expect(isProcessAlive(pid)).toBe(true);
+    expect(fs.readFileSync(pidPath, 'utf8')).toBe(lock);
+  });
+
+  it('reports an older daemon that already exited, leaving its lock to its successor', async () => {
+    const lock = encodeLockInfo({ pid: await deadPid(), version: '1.6.1', socketPath, startedAt: Date.now() });
+    fs.writeFileSync(pidPath, lock);
+    expect(await stopOlderDaemon(root, '1.6.2')).toMatchObject({ outcome: 'not-running', version: '1.6.1' });
+    expect(fs.readFileSync(pidPath, 'utf8')).toBe(lock);
+  });
+
+  it('has nothing to stop without a lock, and leaves a listening socket alone', async () => {
+    server = net.createServer((socket) => {
+      socket.end(JSON.stringify({ protocol: 1, codegraph: '1.6.1', pid: process.pid, socketPath }) + '\n');
+    });
+    await listen(server, socketPath);
+    expect(await stopOlderDaemon(root, '1.6.2')).toBeNull();
+    expect(await connectWithHello(socketPath, '1.6.2')).toBe('older-version');
+  });
+
+  it('does not act on an unreadable lock', async () => {
+    fs.mkdirSync(pidPath);
+    expect(await stopOlderDaemon(root, '1.6.2')).toEqual({ root, pid: null, outcome: 'unverified' });
+  });
+});
+
+/**
+ * A CodeGraph install of `version`: this build's dist/, hard-linked file by
+ * file (copied where a link is refused), next to a package.json of that version
+ * and a link to this checkout's node_modules.
+ */
+function makeInstall(version: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `cg-install-${version}-`));
+  const linkTree = (from: string, to: string): void => {
+    fs.mkdirSync(to, { recursive: true });
+    for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+      const source = path.join(from, entry.name);
+      const target = path.join(to, entry.name);
+      if (entry.isDirectory()) linkTree(source, target);
+      else {
+        try { fs.linkSync(source, target); } catch { fs.copyFileSync(source, target); }
+      }
+    }
+  };
+  linkTree(DIST, path.join(dir, 'dist'));
+  fs.symlinkSync(NODE_MODULES, path.join(dir, 'node_modules'), 'junction');
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: '@colbymchenry/codegraph', version }) + '\n');
+  return dir;
+}
+
+interface Session {
+  child: ChildProcessWithoutNullStreams;
+  stdout: string[];
+  stderr: string[];
+}
+
+function lines(stream: NodeJS.ReadableStream, into: string[]): void {
+  let buffer = '';
+  stream.on('data', (chunk: Buffer) => {
+    buffer += chunk.toString('utf8');
+    let idx: number;
+    while ((idx = buffer.indexOf('\n')) !== -1) {
+      into.push(buffer.slice(0, idx));
+      buffer = buffer.slice(idx + 1);
+    }
+  });
+}
+
+function findResponse(stdout: string[], id: number): any | null {
+  for (const line of stdout) {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && parsed.id === id && (parsed.result !== undefined || parsed.error !== undefined)) return parsed;
+    } catch { /* not JSON */ }
+  }
+  return null;
+}
+
+function waitFor<T>(predicate: () => T | undefined | null | false, timeoutMs: number, label: string): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const started = Date.now();
+    const tick = (): void => {
+      let value: T | undefined | null | false;
+      try { value = predicate(); } catch (e) { reject(e); return; }
+      if (value) { resolve(value as T); return; }
+      if (Date.now() - started > timeoutMs) { reject(new Error(`Timed out after ${timeoutMs}ms waiting for: ${label}`)); return; }
+      setTimeout(tick, 25);
+    };
+    tick();
+  });
+}
+
+function isAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+async function waitProcessExit(pid: number, timeoutMs: number): Promise<boolean> {
+  return waitFor(() => !isAlive(pid), timeoutMs, `pid ${pid} to exit`).then(() => true, () => false);
+}
+
+function readJson(file: string): any | null {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+describe('a launcher meeting a daemon of another version (#2335)', () => {
+  let olderInstall: string;
+  let newerInstall: string;
+  let tempDir: string;
+  let realRoot: string;
+  const sessions: Session[] = [];
+  const daemonPids = new Set<number>();
+
+  beforeAll(() => {
+    olderInstall = makeInstall(OLDER);
+    newerInstall = makeInstall(NEWER);
+  });
+
+  afterAll(async () => {
+    for (const dir of [olderInstall, newerInstall]) {
+      if (!dir) continue;
+      // The link first: removing an install must never reach this checkout's modules.
+      try { fs.unlinkSync(path.join(dir, 'node_modules')); } catch { /* not created */ }
+      await fs.promises.rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    }
+  });
+
+  beforeEach(async () => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-older-version-'));
+    fs.writeFileSync(path.join(tempDir, 'app.ts'), 'export function appMain() { return 1; }\n');
+    const cg = await CodeGraph.init(tempDir);
+    try { await cg.indexAll(); } finally { cg.close(); }
+    realRoot = fs.realpathSync(tempDir);
+  });
+
+  afterEach(async () => {
+    // Every launcher first (with the runtime flags there is no relaunch child),
+    // then the losing daemon candidates, then the daemons themselves — and only
+    // then the fixture: on Windows a live process inside it blocks the removal.
+    await Promise.all(sessions.map(async ({ child }) => {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      const exited = once(child, 'exit');
+      child.kill('SIGKILL');
+      await exited;
+    }));
+    sessions.length = 0;
+    const lockPid = (): number | null => readJson(path.join(realRoot, '.codegraph', 'daemon.pid'))?.pid ?? null;
+    await settleLosingCandidates(tempDir, lockPid);
+    const holder = lockPid();
+    if (holder) daemonPids.add(holder);
+    for (const pid of daemonPids) {
+      if (pid === process.pid || !isAlive(pid)) continue;
+      try { process.kill(pid, 'SIGKILL'); } catch { /* raced to exit */ }
+      await waitProcessExit(pid, 5000);
+    }
+    daemonPids.clear();
+    removeSpawnLog(tempDir);
+    await fs.promises.rm(tempDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+  }, 45_000);
+
+  /** An agent session: `install`'s launcher, `serve --mcp` in the project. */
+  function startSession(install: string | null, env: NodeJS.ProcessEnv = {}): Session {
+    const bin = install ? path.join(install, 'dist', 'bin', 'codegraph.js') : BIN;
+    const recorder = recordSpawns(tempDir);
+    const child = spawn(process.execPath, [...WASM_RUNTIME_FLAGS, ...recorder.args, bin, 'serve', '--mcp'], {
+      cwd: tempDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        CODEGRAPH_MCP_LOG_ATTACH: '1',
+        CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS: '30000',
+        ...recorder.env,
+        ...env,
+      },
+    }) as ChildProcessWithoutNullStreams;
+    child.on('error', () => { /* ignore */ });
+    child.stdin.on('error', () => { /* ignore */ });
+    const session: Session = { child, stdout: [], stderr: [] };
+    lines(child.stdout, session.stdout);
+    lines(child.stderr, session.stderr);
+    sessions.push(session);
+    send(session, {
+      jsonrpc: '2.0', id: 1, method: 'initialize',
+      params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'test', version: '0.0.0' }, rootUri: `file://${tempDir}` },
+    });
+    return session;
+  }
+
+  function send(session: Session, msg: unknown): void {
+    try { session.child.stdin.write(JSON.stringify(msg) + '\n'); } catch { /* gone */ }
+  }
+
+  async function status(session: Session, id: number, label: string): Promise<any> {
+    send(session, { jsonrpc: '2.0', id, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+    const reply = await waitFor(() => findResponse(session.stdout, id), 20000, label).catch((err: Error) => {
+      throw new Error(`${err.message}\n--- stderr ---\n${session.stderr.join('\n')}\n--- daemon.log ---\n${daemonLog()}`);
+    });
+    expect(reply.error, label).toBeUndefined();
+    expect(reply.result?.isError, label).not.toBe(true);
+    expect(JSON.stringify(reply.result), label).toContain('CodeGraph Status');
+    return reply;
+  }
+
+  const attachedLine = (session: Session): string | undefined =>
+    session.stderr.find((l) => l.includes('Attached to shared daemon'));
+  const daemonLock = (): any => readJson(path.join(realRoot, '.codegraph', 'daemon.pid'));
+  const writerLock = (): any => readJson(path.join(realRoot, '.codegraph', 'writer.pid'));
+  const daemonLog = (): string => {
+    try { return fs.readFileSync(path.join(realRoot, '.codegraph', 'daemon.log'), 'utf8'); } catch { return ''; }
+  };
+
+  /** A session of `install` attached to a daemon of its own, which owns the project. */
+  async function sessionWithDaemon(install: string, version: string, env: NodeJS.ProcessEnv = {}): Promise<{ session: Session; pid: number }> {
+    const session = startSession(install, env);
+    await waitFor(() => attachedLine(session), 20000, `the ${version} session to attach`);
+    // Attached means listening, not initialized: let the engine open the
+    // database before anything stops this daemon.
+    await status(session, 2, `a ${version} tool call`);
+    const lock = daemonLock();
+    expect(lock).toMatchObject({ version });
+    expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+    daemonPids.add(lock.pid);
+    return { session, pid: lock.pid };
+  }
+
+  /** A daemon process for the project, started the way a launcher starts one. */
+  function startDaemon(env: NodeJS.ProcessEnv): { child: ChildProcessWithoutNullStreams; log: string[] } {
+    const child = spawn(process.execPath, [...WASM_RUNTIME_FLAGS, BIN, 'serve', '--mcp', '--path', realRoot], {
+      cwd: tempDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, CODEGRAPH_DAEMON_INTERNAL: '1', CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS: '30000', ...env },
+    }) as ChildProcessWithoutNullStreams;
+    child.on('error', () => { /* ignore */ });
+    child.stdout.resume();
+    const log: string[] = [];
+    lines(child.stderr, log);
+    daemonPids.add(child.pid!);
+    return { child, log };
+  }
+
+  /** The slot as a launcher that just stopped an older daemon holds it: this test process stands in. */
+  function holdWriterSlotForSuccessor(): string {
+    const claim = JSON.stringify({ pid: process.pid, mode: 'handover', startedAt: Date.now(), ready: false }) + '\n';
+    fs.writeFileSync(path.join(realRoot, '.codegraph', 'writer.pid'), claim);
+    return claim;
+  }
+
+  it('a daemon takes over the writer slot held for it, and only that one', async () => {
+    const claim = holdWriterSlotForSuccessor();
+
+    // A daemon the slot is not held for finds it held, as by any live writer.
+    const stranger = startDaemon({});
+    const [strangerCode] = await once(stranger.child, 'exit');
+    expect(strangerCode).toBe(1);
+    expect(stranger.log.join('\n')).toContain(`writer lock held by PID ${process.pid} (handover mode)`);
+    expect(fs.readFileSync(path.join(realRoot, '.codegraph', 'writer.pid'), 'utf8')).toBe(claim);
+
+    const successor = startDaemon({ CODEGRAPH_DAEMON_HANDOVER: String(process.pid) });
+    await waitFor(
+      () => daemonLock()?.pid === successor.child.pid && successor.log.some((l) => l.includes('Listening on')),
+      20000, 'the successor to listen',
+    );
+    expect(writerLock()).toMatchObject({ pid: successor.child.pid, mode: 'daemon' });
+    expect(successor.log.join('\n')).toContain(`Took over the writer lock from launcher pid ${process.pid}`);
+  }, 60000);
+
+  it('a daemon the slot is held for outwaits a candidate still starting in its way', async () => {
+    holdWriterSlotForSuccessor();
+    // A racing launcher's candidate holds the daemon lock, still starting; it
+    // cannot get the writer slot, so it will give up.
+    const candidate = startDetachedProcess();
+    daemonPids.add(candidate);
+    const pidPath = path.join(realRoot, '.codegraph', 'daemon.pid');
+    const candidateLock = encodeLockInfo({
+      pid: candidate, version: CodeGraphPackageVersion, socketPath: getDaemonSocketPath(realRoot), startedAt: Date.now(),
+    });
+    fs.writeFileSync(pidPath, candidateLock);
+
+    // Any other daemon yields to it at once.
+    const yielding = startDaemon({});
+    const [yieldingCode] = await once(yielding.child, 'exit');
+    expect(yieldingCode).toBe(0);
+    expect(yielding.log.join('\n')).toContain(`Another daemon (pid ${candidate}) already holds the lock`);
+
+    const successor = startDaemon({ CODEGRAPH_DAEMON_HANDOVER: String(process.pid) });
+    await waitFor(
+      () => successor.log.some((l) => l.includes(`Waiting for daemon candidate pid ${candidate}`)),
+      20000, 'the successor to wait for the candidate',
+    );
+    expect(successor.child.exitCode).toBeNull();
+    expect(fs.readFileSync(pidPath, 'utf8')).toBe(candidateLock);
+    // The candidate gives up: its lock goes, then so does it.
+    fs.rmSync(pidPath);
+    process.kill(candidate, 'SIGKILL');
+    await waitFor(
+      () => daemonLock()?.pid === successor.child.pid && successor.log.some((l) => l.includes('Listening on')),
+      20000, 'the successor to listen',
+    );
+    expect(writerLock()).toMatchObject({ pid: successor.child.pid, mode: 'daemon' });
+  }, 60000);
+
+  it('keeps the older daemon\'s sessions read-only through the replacement, even mid-call', async () => {
+    const before = await sessionWithDaemon(olderInstall, OLDER);
+    // The older session calls every 20ms throughout, so it serves itself
+    // in-process the instant its daemon goes. Finding the writer slot free
+    // then, it would claim it — with the code of the install being replaced.
+    let next = 100;
+    const calling = setInterval(() => {
+      send(before.session, { jsonrpc: '2.0', id: next++, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+    }, 20);
+    let after: Session;
+    try {
+      after = startSession(null);
+      await waitFor(() => attachedLine(after), 30000, 'the new session to attach');
+      await new Promise((r) => setTimeout(r, 500));
+    } finally {
+      clearInterval(calling);
+    }
+    const lock = daemonLock();
+    daemonPids.add(lock.pid);
+    expect(lock.version).toBe(CodeGraphPackageVersion);
+    expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+    await status(after, 2, 'a tool call through the new daemon');
+
+    const last = next - 1;
+    await waitFor(() => findResponse(before.session.stdout, last), 20000, 'the older session to answer every call');
+    for (let id = 100; id <= last; id++) expect(findResponse(before.session.stdout, id), `call ${id}`).toBeTruthy();
+    const stderr = before.session.stderr.join('\n');
+    expect(stderr).toContain('Serving reads in-process without auto-sync');
+    expect(stderr).not.toContain('File watcher active');
+    expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+  }, 120000);
+
+  it('stops a daemon from an older install and starts one from its own', async () => {
+    const before = await sessionWithDaemon(olderInstall, OLDER);
+
+    const after = startSession(null);
+    const stopped = await waitFor(
+      () => after.stderr.find((l) => l.includes('[CodeGraph MCP] Stopped')),
+      30000, 'the older daemon to be stopped',
+    );
+    expect(stopped).toContain(`the CodeGraph ${OLDER} daemon (pid ${before.pid})`);
+    expect(stopped).toContain(`from this install (${CodeGraphPackageVersion})`);
+    expect(await waitProcessExit(before.pid, 10000)).toBe(true);
+
+    const attached = await waitFor(() => attachedLine(after), 20000, 'the new session to attach');
+    const lock = daemonLock();
+    daemonPids.add(lock.pid);
+    expect(lock.version).toBe(CodeGraphPackageVersion);
+    expect(lock.pid).not.toBe(before.pid);
+    expect(attached).toContain(`(pid ${lock.pid}, v${CodeGraphPackageVersion})`);
+    await status(after, 2, 'a tool call through the new daemon');
+    // The replacement owns updates for the project: writer lock and watcher,
+    // handed to it by the launcher that held the slot through the stop.
+    expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+    expect(daemonLog()).toContain(`Took over the writer lock from launcher pid ${after.child.pid}`);
+    if (process.platform !== 'win32') {
+      // SIGTERM ran the old daemon's own shutdown. (On Windows it is
+      // TerminateProcess, and the stop clears what is left.)
+      expect(daemonLog()).toContain(`Shutting down (SIGTERM`);
+    }
+
+    // The session from before the upgrade keeps answering, read-only, and
+    // leaves the new daemon its writer lock.
+    await waitFor(
+      () => before.session.stderr.some((l) => l.includes('Shared daemon connection lost')),
+      10000, 'the older session to lose its daemon',
+    );
+    await status(before.session, 3, 'a tool call in the older session');
+    expect(before.session.stderr.some((l) => l.includes('Serving reads in-process without auto-sync'))).toBe(true);
+    expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+    expect(daemonLock()).toEqual(lock);
+    expect(isAlive(lock.pid)).toBe(true);
+  }, 120000);
+
+  it('finds an older daemon its probe cannot reach by the project lock, and stops it', async () => {
+    // On Windows a 1.6.1 daemon named its pipe after the root as typed (#2278),
+    // so a newer launcher's probe never hears its hello; only its lock says
+    // where it listens. Stand one up on a socket no launcher probes.
+    const socketDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sock-'));
+    try {
+      const socketPath = listenPath(socketDir, 'older');
+      const older = spawn(process.execPath, [OLDER_DAEMON, realRoot, OLDER, socketPath], { detached: true, stdio: 'ignore' });
+      older.unref();
+      daemonPids.add(older.pid!);
+      await waitFor(() => daemonLock()?.pid === older.pid, 10000, 'the older daemon to hold the project');
+      expect(writerLock()).toMatchObject({ pid: older.pid, mode: 'daemon' });
+
+      const session = startSession(null);
+      const stopped = await waitFor(
+        () => session.stderr.find((l) => l.includes('[CodeGraph MCP] Stopped')),
+        30000, 'the older daemon to be stopped',
+      );
+      expect(stopped).toContain(`the CodeGraph ${OLDER} daemon (pid ${older.pid})`);
+      expect(await waitProcessExit(older.pid!, 10000)).toBe(true);
+      const attached = await waitFor(() => attachedLine(session), 20000, 'the session to attach');
+      const lock = daemonLock();
+      daemonPids.add(lock.pid);
+      expect(lock.version).toBe(CodeGraphPackageVersion);
+      expect(attached).toContain(`(pid ${lock.pid}, v${CodeGraphPackageVersion})`);
+      expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+      expect(daemonLog()).toContain(`Took over the writer lock from launcher pid ${session.child.pid}`);
+      await status(session, 2, 'a tool call through the new daemon');
+    } finally {
+      fs.rmSync(socketDir, { recursive: true, force: true });
+    }
+  }, 90000);
+
+  it('never stops a daemon from a newer install', async () => {
+    const retry = { CODEGRAPH_DAEMON_RETRY_MS: '300', CODEGRAPH_DAEMON_RETRY_MAX_MS: '600' };
+    const newer = await sessionWithDaemon(newerInstall, NEWER);
+    const lock = daemonLock();
+
+    const current = startSession(null, retry);
+    // The first probe and the retries that follow all find the newer daemon.
+    await waitFor(
+      () => current.stderr.filter((l) => l.includes(`version (${NEWER}) differs from ours`)).length >= 3,
+      20000, 'repeated probes of the newer daemon',
+    );
+    await status(current, 2, 'a tool call served in-process');
+    expect(current.stderr.some((l) => l.includes('Serving reads in-process without auto-sync'))).toBe(true);
+    expect(current.stderr.some((l) => l.includes('[CodeGraph MCP] Stopped'))).toBe(false);
+
+    expect(isAlive(newer.pid)).toBe(true);
+    expect(daemonLock()).toEqual(lock);
+    expect(writerLock()).toMatchObject({ pid: newer.pid, mode: 'daemon' });
+    await status(newer.session, 3, 'a tool call through the newer daemon');
+  }, 90000);
+
+  it('a session whose own install was upgraded serves reads only once its daemon exits', async () => {
+    // An upgrade in place: the daemon notices its package.json changed and
+    // exits (its install check), and its session falls back in-process. As
+    // the project's writer that session — running code the upgrade replaced —
+    // would only keep a daemon from the new install from starting.
+    const install = makeInstall('0.0.2');
+    try {
+      const before = await sessionWithDaemon(install, '0.0.2', {
+        CODEGRAPH_DAEMON_INSTALL_CHECK_MS: '200',
+        CODEGRAPH_DAEMON_RETRY_MS: '0',
+      });
+      fs.writeFileSync(path.join(install, 'package.json'), JSON.stringify({ name: '@colbymchenry/codegraph', version: '0.0.3' }) + '\n');
+      expect(await waitProcessExit(before.pid, 10000)).toBe(true);
+      expect(daemonLog()).toContain('Install replaced by v0.0.3');
+      await waitFor(
+        () => before.session.stderr.some((l) => l.includes('Shared daemon connection lost')),
+        10000, 'the session to lose its daemon',
+      );
+
+      await status(before.session, 3, 'a tool call after the daemon exited');
+      const stderr = before.session.stderr.join('\n');
+      expect(stderr).toContain("this session's CodeGraph install was upgraded or removed");
+      expect(stderr).not.toContain('File watcher active');
+      expect(writerLock()).toBeNull();
+
+      // So a session from the current install gets a daemon straight away.
+      const after = startSession(null);
+      await waitFor(() => attachedLine(after), 20000, 'the new session to attach');
+      const lock = daemonLock();
+      daemonPids.add(lock.pid);
+      expect(writerLock()).toMatchObject({ pid: lock.pid, mode: 'daemon' });
+    } finally {
+      // On Windows a process still running from the install blocks its removal.
+      for (const { child } of sessions) {
+        if (child.exitCode === null && child.signalCode === null) {
+          const exited = once(child, 'exit');
+          child.kill('SIGKILL');
+          await exited;
+        }
+      }
+      try { fs.unlinkSync(path.join(install, 'node_modules')); } catch { /* not created */ }
+      await fs.promises.rm(install, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    }
+  }, 90000);
+});
diff --git a/__tests__/daemon-pid-reuse.test.ts b/__tests__/daemon-pid-reuse.test.ts
index 48650ccdf5..8bb116a0ce 100644
--- a/__tests__/daemon-pid-reuse.test.ts
+++ b/__tests__/daemon-pid-reuse.test.ts
@@ -197,7 +197,9 @@ describe('Shared MCP daemon (issue #411)', () => {
     }
     await new Promise((r) => setTimeout(r, 50));
     servers.length = 0;
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    // A killed process releases its handles asynchronously on Windows; under
+    // full-suite load 50 ms is not always enough, so retry EPERM/EBUSY.
+    fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
   });
 
   it('takes over after SIGKILL even when the stale PID has been reused (#1553)', async () => {
diff --git a/__tests__/daemon-registry.test.ts b/__tests__/daemon-registry.test.ts
index 0ad4707df1..af8c46399d 100644
--- a/__tests__/daemon-registry.test.ts
+++ b/__tests__/daemon-registry.test.ts
@@ -143,6 +143,109 @@ describe('daemon-registry', () => {
     }
   }, 15000);
 
+  /**
+   * A daemon fixture whose SIGTERM (intercepted; nothing is delivered) runs
+   * `onTerm` — the shape of its graceful shutdown — instead of exiting.
+   * `exitAfter(ms)` ends the process for real, as the end of that shutdown.
+   */
+  async function stoppingDaemon(
+    root: string,
+    onTerm: (daemon: { server: net.Server; pidPath: string; exitAfter: (ms: number) => void }) => void,
+  ): Promise<{ root: string; pid: number; pidPath: string; signalled: (signal: string) => boolean; dispose: () => Promise<void> }> {
+    fs.mkdirSync(path.join(root, '.codegraph'));
+    const socketPath = getDaemonSocketPath(root);
+    const pidPath = getDaemonPidPath(root);
+    const pid = startDetachedProcess();
+    const server = net.createServer((socket) => {
+      socket.end(`${JSON.stringify({ protocol: 1, codegraph: 'test', pid, socketPath })}\n`);
+    });
+    await new Promise<void>((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(socketPath, resolve);
+    });
+    fs.writeFileSync(pidPath, encodeLockInfo({ pid, version: 'test', socketPath, startedAt: Date.now() }));
+    const originalKill = process.kill.bind(process);
+    let exitTimer: NodeJS.Timeout | undefined;
+    const exitAfter = (ms: number): void => { exitTimer = setTimeout(() => originalKill(pid, 'SIGKILL'), ms); };
+    const kill = vi.spyOn(process, 'kill').mockImplementation((target, signal) => {
+      if (target === pid && signal === 'SIGTERM') {
+        onTerm({ server, pidPath, exitAfter });
+        return true;
+      }
+      return originalKill(target, signal);
+    });
+    return {
+      root,
+      pid,
+      pidPath,
+      signalled: (signal) => kill.mock.calls.some(([target, sent]) => target === pid && sent === signal),
+      dispose: async () => {
+        clearTimeout(exitTimer);
+        kill.mockRestore();
+        if (isProcessAlive(pid)) process.kill(pid, 'SIGKILL');
+        if (server.listening) await new Promise<void>((resolve) => server.close(() => resolve()));
+        fs.rmSync(root, { recursive: true, force: true });
+      },
+    };
+  }
+
+  it('waits for a daemon that has closed its socket but is still shutting down', async () => {
+    // A daemon's shutdown closes its socket first, then waits up to 15 s for
+    // query workers still starting up before it exits. Past the first 3 s the
+    // identity probe fails; that is a daemon still stopping, not a stranger.
+    const daemon = await stoppingDaemon(fs.mkdtempSync(path.join(tmpHome, 'stop-slow-')), ({ server, exitAfter }) => {
+      server.close();
+      exitAfter(4000);
+    });
+    try {
+      const result = await stopDaemonAt(daemon.root);
+      expect(result.outcome).toBe('term');
+      expect(isProcessAlive(daemon.pid)).toBe(false);
+      expect(daemon.signalled('SIGKILL')).toBe(false);
+      expect(fs.existsSync(daemon.pidPath)).toBe(false);
+    } finally {
+      await daemon.dispose();
+    }
+  }, 15000);
+
+  it('waits for a daemon that has released its lock but not yet exited', async () => {
+    // The end of the same shutdown: the lock goes just before the process does.
+    // A stop that looks then must wait for the exit, not report it running.
+    const daemon = await stoppingDaemon(fs.mkdtempSync(path.join(tmpHome, 'stop-unlocked-')), ({ server, pidPath, exitAfter }) => {
+      server.close();
+      fs.unlinkSync(pidPath);
+      exitAfter(4000);
+    });
+    try {
+      const result = await stopDaemonAt(daemon.root);
+      expect(result.outcome).toBe('term');
+      expect(isProcessAlive(daemon.pid)).toBe(false);
+      expect(daemon.signalled('SIGKILL')).toBe(false);
+    } finally {
+      await daemon.dispose();
+    }
+  }, 15000);
+
+  it('still reports a daemon whose shutdown never finishes, without force-killing it', async () => {
+    // The wait is bounded: past it, a daemon that closed its socket and never
+    // exited is reported, and with no socket to re-prove its identity it is
+    // left alone rather than SIGKILLed.
+    const daemon = await stoppingDaemon(fs.mkdtempSync(path.join(tmpHome, 'stop-wedged-')), ({ server }) => {
+      server.close();
+    });
+    try {
+      const started = Date.now();
+      const result = await stopDaemonAt(daemon.root, { shutdownGraceMs: 300 });
+      expect(result.outcome).toBe('still-running');
+      expect(Date.now() - started).toBeLessThan(8000);
+      expect(isProcessAlive(daemon.pid)).toBe(true);
+      expect(daemon.signalled('SIGKILL')).toBe(false);
+      expect(fs.existsSync(daemon.pidPath)).toBe(true);
+    } finally {
+      await daemon.dispose();
+    }
+  }, 15000);
+
   it('preserves a newer lock installed during a successful stop identity probe', async () => {
     const root = fs.mkdtempSync(path.join(tmpHome, 'stop-race-'));
     fs.mkdirSync(path.join(root, '.codegraph'));
diff --git a/__tests__/daemon-rendezvous-case.test.ts b/__tests__/daemon-rendezvous-case.test.ts
new file mode 100644
index 0000000000..6c8a1a1a3e
--- /dev/null
+++ b/__tests__/daemon-rendezvous-case.test.ts
@@ -0,0 +1,123 @@
+/**
+ * One project must map to ONE daemon rendezvous key, however its root is
+ * spelled — the regression behind "the MCP server starts but never shares the
+ * daemon".
+ *
+ * The daemon's named pipe (Windows) / tmpdir socket (POSIX) is
+ * `…codegraph-<sha256(canonical root)>.slice(0,16)`, and the lockfile is shared
+ * while the SOCKET NAME is derived independently by each process. So the moment
+ * two processes hash the same directory differently they stop meeting: the
+ * proxy's probe finds nothing, it spawns a redundant daemon, and that daemon
+ * exits on the lock the first one holds
+ * (`Another daemon (pid N) already holds the lock; exiting.`) — the session then
+ * serves in-process, without the shared watcher or auto-sync.
+ *
+ * That is reachable on Windows because the root arrives two ways: a cwd-derived
+ * root is the on-disk casing (`D:\work\codegraph`), while a client-supplied
+ * `rootUri`/`workspaceFolders` path arrives as `file:///d%3A/…` → `d:\…`, and
+ * `path.resolve` preserves whichever it got (NTFS is case-insensitive, so both
+ * name one directory). Pinned here at the level that actually broke: the key,
+ * not the filename.
+ *
+ * The real-filesystem assertions are Windows-gated — on POSIX the two spellings
+ * are genuinely different directories, so only the Windows case has a
+ * case-insensitive filesystem to converge on.
+ */
+
+import { afterEach, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { canonicalProjectRoot } from '../src/directory';
+import { getDaemonSocketPath } from '../src/mcp/daemon-paths';
+import { acquireProject } from '../src/mcp/project-lifecycle';
+import type CodeGraph from '../src/index';
+
+const tmpDirs: string[] = [];
+function makeDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rendezvous-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+afterEach(() => {
+  while (tmpDirs.length) {
+    try {
+      fs.rmSync(tmpDirs.pop()!, { recursive: true, force: true });
+    } catch {
+      /* best-effort */
+    }
+  }
+});
+
+/** The same drive letter, forced to one case. No-op on a path without a drive. */
+function withDriveCase(p: string, upper: boolean): string {
+  return p.replace(/^[a-z]:/i, (drive) => (upper ? drive.toUpperCase() : drive.toLowerCase()));
+}
+
+describe('daemon rendezvous key', () => {
+  it('collapses redundant path segments to one socket name', () => {
+    const root = makeDir();
+    const indirect = path.join(root, 'a', '..', 'b', '.');
+    const direct = path.join(root, 'b');
+    // `.`, `..` and a trailing separator all name the same directory, so both
+    // spellings must resolve to the same socket — otherwise `--path` with a
+    // stray separator is enough to miss a running daemon.
+    expect(getDaemonSocketPath(indirect)).toBe(getDaemonSocketPath(direct));
+  });
+
+  it.runIf(process.platform === 'win32')(
+    'maps both drive-letter cases of one directory onto one pipe',
+    () => {
+      const root = makeDir();
+      const upper = withDriveCase(root, true);
+      const lower = withDriveCase(root, false);
+
+      expect(canonicalProjectRoot(upper)).toBe(canonicalProjectRoot(lower));
+      expect(getDaemonSocketPath(upper)).toBe(getDaemonSocketPath(lower));
+      // …and the converged key is the on-disk casing, lowercased, so it does not
+      // depend on which of the two the caller happened to hold.
+      expect(canonicalProjectRoot(upper)).toBe(fs.realpathSync.native(root).toLowerCase());
+    },
+  );
+
+  it.runIf(process.platform === 'win32')(
+    'converges case variants even when the root cannot be realpath’d',
+    () => {
+      // The `.codegraph/` root normally exists, so this is the fallback arm —
+      // but a divergence there would fail identically, so pin it.
+      const missing = path.join(os.tmpdir(), 'cg-rendezvous-absent', 'nested');
+      expect(canonicalProjectRoot(missing)).toBe(canonicalProjectRoot(missing.toUpperCase()));
+    },
+  );
+});
+
+/** True when the temp filesystem ignores case (default macOS APFS, NTFS). */
+function caseInsensitiveTmp(): boolean {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-CaseProbe-'));
+  try {
+    return fs.existsSync(dir.replace('cg-CaseProbe-', 'cg-caseprobe-'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe('in-process project sharing (#2278)', () => {
+  it.runIf(caseInsensitiveTmp())('opens one graph for two casings of one root', async () => {
+    const root = path.join(makeDir(), 'Repo');
+    fs.mkdirSync(root);
+    let opened = 0;
+    const open = () => {
+      opened++;
+      return { close() {}, isIndexing: () => false } as unknown as CodeGraph;
+    };
+    const a = acquireProject(root, open, {});
+    const b = acquireProject(path.join(path.dirname(root), 'REPO'), open, {});
+    try {
+      expect(opened).toBe(1);
+      expect(b.cg).toBe(a.cg);
+    } finally {
+      await a.release();
+      await b.release();
+    }
+  });
+});
diff --git a/__tests__/dart-annotated-member-docs.test.ts b/__tests__/dart-annotated-member-docs.test.ts
new file mode 100644
index 0000000000..c66d6480bc
--- /dev/null
+++ b/__tests__/dart-annotated-member-docs.test.ts
@@ -0,0 +1,247 @@
+/**
+ * A Dart member's annotations sit between it and the dartdoc written above
+ * them:
+ *
+ *   /// Builds the widget.
+ *   @override
+ *   Widget build(BuildContext context) { … }
+ *
+ * Both extractors read a docstring from the comments directly before the
+ * declaration and stopped at the first node that was not a comment, so the
+ * annotation ended the run before the `///` was reached and the member lost
+ * its documentation. `@override`, `@protected`, `@mustCallSuper`, `@pragma`,
+ * `@internal` and `@visibleForTesting` are everywhere in Flutter code.
+ *
+ * The walk now steps over annotations, stacked and multi-line ones included,
+ * and a comment between an annotation and the member joins the dartdoc above
+ * the way adjacent comments already did. Whatever else comes first (a field,
+ * the previous member's body, a top-level variable, an import) still ends it.
+ * A class, mixin, extension, enum or typedef kept its dartdoc already: its
+ * annotations open its own node, so the dartdoc above them is that node's
+ * previous sibling.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+const SOURCE = `// Copyright 2026 the authors.
+import 'package:meta/meta.dart';
+
+@visibleForTesting
+void afterImport() {}
+
+/// Runs at startup.
+@pragma('vm:entry-point')
+void main() {}
+
+/// Calls into the platform.
+@pragma('vm:external-name', 'version')
+external int platformVersion();
+
+/// Watches the counter.
+@riverpod
+@Deprecated('Use the generated provider')
+int counter(Ref ref) => 0;
+
+/// The answer.
+final answer = 42;
+
+@visibleForTesting
+void afterVariable() {}
+
+abstract class Repository {
+  /// Loads the user with [id].
+  @protected
+  Future<User> load(String id);
+}
+
+/// A counter.
+@immutable
+class Counter {
+  /// Starts at zero.
+  @literal
+  const Counter.zero() : value = 0;
+
+  /// Reads a counter from JSON.
+  @visibleForTesting
+  factory Counter.fromJson(Map<String, Object?> json) => const Counter.zero();
+
+  /// Builds the widget.
+  @override
+  Widget build(BuildContext context) => const Text('0');
+
+  /// Releases resources.
+  ///
+  /// Call it once.
+  @protected
+  @mustCallSuper
+  void dispose() {}
+
+  /// The current count.
+  @override
+  int get count => value;
+
+  /// Use [build] instead.
+  @Deprecated(
+    'Use build. '
+    'Removed in 2.0.',
+  )
+
+  Widget render() => const Text('');
+
+  /// Joined with the comment below the annotation.
+  @protected
+  // ignore: must_call_super
+  void joined() {}
+
+  /// The cached value.
+  @JsonKey(name: 'value')
+  final int value;
+
+  @override
+  void afterField() {}
+
+  void before() {}
+  @override
+  void afterBody() {}
+}
+
+/// A mixin.
+@internal
+mixin Logging on Counter {}
+
+/// An extension.
+@internal
+extension CounterX on Counter {}
+
+/// An enum.
+@JsonEnum()
+enum Mode { light, dark }
+
+/// A typedef.
+@internal
+typedef Callback = void Function();
+@visibleForTesting
+void afterTypedef() {}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+describe('Dart members keep the dartdoc written above their annotations', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['dart']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource('lib/counter.dart', source, 'dart');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract('lib/counter.dart', source, 'dart');
+    expect(result, 'kernel extraction').not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    it.each(backends)(`%s${crlf ? ' (CRLF)' : ''}`, (backend) => {
+      const result = extract(backend, crlf ? SOURCE.replace(/\n/g, '\r\n') : SOURCE);
+      const node = (qualifiedName: string) => {
+        const found = result.nodes.find((n) => n.qualifiedName === qualifiedName);
+        expect(found, qualifiedName).toBeDefined();
+        return found!;
+      };
+      const doc = (qualifiedName: string) => node(qualifiedName).docstring;
+      const decorators = (qualifiedName: string): string[] => {
+        const id = node(qualifiedName).id;
+        return result.unresolvedReferences
+          .filter((r) => r.referenceKind === 'decorates' && r.fromNodeId === id)
+          .map((r) => r.referenceName)
+          .sort();
+      };
+
+      // Top-level functions, an external one and stacked annotations.
+      expect(doc('main')).toBe('Runs at startup.');
+      expect(doc('platformVersion')).toBe('Calls into the platform.');
+      expect(doc('counter')).toBe('Watches the counter.');
+
+      // Members: methods, a getter, a factory, a member with no body and a
+      // `const` constructor (both read from before their `declaration`).
+      expect(doc('Counter::build')).toBe('Builds the widget.');
+      expect(doc('Counter::count')).toBe('The current count.');
+      expect(doc('Counter::fromJson')).toBe('Reads a counter from JSON.');
+      expect(doc('Repository::load')).toBe('Loads the user with [id].');
+      expect(doc('Counter::zero')).toBe('Starts at zero.');
+      expect(doc('Counter::dispose')).toBe('Releases resources.\n\nCall it once.');
+
+      // A multi-line annotation, with a blank line before the member.
+      expect(doc('Counter::render')).toBe('Use [build] instead.');
+
+      // A comment between the annotation and the member joins the dartdoc,
+      // as adjacent comments do.
+      expect(doc('Counter::joined')).toBe(
+        'Joined with the comment below the annotation.\nignore: must_call_super'
+      );
+
+      // What comes before the annotations still ends the walk: an import, a
+      // top-level variable, a field (whose dartdoc and annotation are its
+      // own), the previous member's body and another declaration.
+      expect(doc('afterImport')).toBeUndefined();
+      expect(doc('afterVariable')).toBeUndefined();
+      expect(doc('Counter::afterField')).toBeUndefined();
+      expect(doc('Counter::afterBody')).toBeUndefined();
+      expect(doc('afterTypedef')).toBeUndefined();
+
+      // Class-like declarations kept theirs already: the annotations open
+      // their own node.
+      expect(doc('Counter')).toBe('A counter.');
+      expect(doc('Logging')).toBe('A mixin.');
+      expect(doc('CounterX')).toBe('An extension.');
+      expect(doc('Mode')).toBe('An enum.');
+      expect(doc('Callback')).toBe('A typedef.');
+
+      // The annotations are still recorded where they were.
+      expect(decorators('counter')).toEqual(['Deprecated', 'riverpod']);
+      expect(decorators('Counter::build')).toEqual(['override']);
+      expect(decorators('Counter::dispose')).toEqual(['mustCallSuper', 'protected']);
+      expect(decorators('Counter::zero')).toEqual(['literal']);
+      expect(decorators('Counter::afterField')).toEqual(['override']);
+    });
+  }
+});
diff --git a/__tests__/dart-annotation-comments.test.ts b/__tests__/dart-annotation-comments.test.ts
new file mode 100644
index 0000000000..567678be07
--- /dev/null
+++ b/__tests__/dart-annotation-comments.test.ts
@@ -0,0 +1,167 @@
+/**
+ * A comment between a Dart annotation and the declaration it belongs to hid
+ * the annotation:
+ *
+ *   @override
+ *   // ignore: must_call_super
+ *   void dispose() { … }
+ *
+ * Both extractors look for a member's annotations among the siblings before
+ * it, and stopped at the first one that was not an annotation, so the comment
+ * ended the scan and `@override` was recorded nowhere. felangel/bloc hid 7
+ * annotations this way and rrousselGit/riverpod 55, among them its lint
+ * fixtures' `@riverpod` `// expect_lint: …` providers.
+ *
+ * An annotation always belongs to the declaration that follows it, so the
+ * scan now steps over line, block and doc comments of either form, wherever
+ * they sit among stacked annotations. Whatever else comes first (a field, the
+ * previous member's body, a top-level variable, an import) still ends it.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+const SOURCE = `import 'package:meta/meta.dart';
+// After the import.
+@visibleForTesting
+// Below the annotation.
+void afterImport() {}
+
+@override // On the annotation's line.
+void trailing() {}
+
+@riverpod
+// expect_lint: functional_ref
+int counter(Ref ref) => 0;
+
+@Deprecated('x')
+/// Doc below the annotation.
+/* And a block comment. */
+void docBelow() {}
+
+@a
+// one
+@b
+/** two */
+@c
+void stacked() {}
+
+@x
+final answer = 42;
+// After a variable.
+void afterVariable() {}
+
+class Counter {
+  @override
+  // ignore: must_call_super
+  void dispose() {}
+
+  @protected
+  // A comment.
+  void bodiless();
+
+  @literal
+  // A comment.
+  const Counter.zero();
+
+  @x /* inline */ void inline() {}
+
+  @JsonKey(name: 'value')
+  final int value = 0;
+  // After a field.
+  void afterField() {}
+
+  void before() {} // Trailing the previous member.
+  @override
+  void afterBody() {}
+}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+describe('Dart annotations behind a comment still decorate the declaration', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['dart']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource('lib/counter.dart', source, 'dart');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract('lib/counter.dart', source, 'dart');
+    expect(result, 'kernel extraction').not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    it.each(backends)(`%s${crlf ? ' (CRLF)' : ''}`, (backend) => {
+      const result = extract(backend, crlf ? SOURCE.replace(/\n/g, '\r\n') : SOURCE);
+      /** The annotation names recorded on a declaration, in the order they were emitted. */
+      const decorators = (qualifiedName: string): string[] => {
+        const node = result.nodes.find((n) => n.qualifiedName === qualifiedName);
+        expect(node, qualifiedName).toBeDefined();
+        return result.unresolvedReferences
+          .filter((r) => r.referenceKind === 'decorates' && r.fromNodeId === node!.id)
+          .map((r) => r.referenceName);
+      };
+
+      // Line, block and doc comments between an annotation and its declaration.
+      expect(decorators('afterImport')).toEqual(['visibleForTesting']);
+      expect(decorators('trailing')).toEqual(['override']);
+      expect(decorators('counter')).toEqual(['riverpod']);
+      expect(decorators('docBelow')).toEqual(['Deprecated']);
+      // Stacked ones still come in reverse source order.
+      expect(decorators('stacked')).toEqual(['c', 'b', 'a']);
+
+      // Members, one with no body and a `const` constructor (both read from
+      // before their `declaration`), and a comment on the member's line.
+      expect(decorators('Counter::dispose')).toEqual(['override']);
+      expect(decorators('Counter::bodiless')).toEqual(['protected']);
+      expect(decorators('Counter::zero')).toEqual(['literal']);
+      expect(decorators('Counter::inline')).toEqual(['x']);
+      expect(decorators('Counter::afterBody')).toEqual(['override']);
+
+      // An annotation before a top-level variable or a field is theirs.
+      expect(decorators('afterVariable')).toEqual([]);
+      expect(decorators('Counter::afterField')).toEqual([]);
+    });
+  }
+});
diff --git a/__tests__/dart-annotation-targets.test.ts b/__tests__/dart-annotation-targets.test.ts
new file mode 100644
index 0000000000..7d5640a1cd
--- /dev/null
+++ b/__tests__/dart-annotation-targets.test.ts
@@ -0,0 +1,167 @@
+/**
+ * A Dart annotation is a constant expression: a reference to a `const`
+ * variable (`@riverpod`, `@override`, `@meta.immutable`, a type's static
+ * constant `@Riverpod.scoped` or enum value) or a call of a `const`
+ * constructor (`@Riverpod(keepAlive: true)`, `@Riverpod.forever()`). It is
+ * never a method, a getter or a function.
+ *
+ * The extractor records only an annotation's last name, and `decorates`
+ * references were ranked like Python decorators, which are functions: a
+ * function or method of that name scored above a class, and a constant scored
+ * nothing. So riverpod's 506 `@riverpod` annotations went to
+ * riverpod_analyzer_utils' extension getter `riverpod` instead of
+ * riverpod_annotation's `const riverpod = Riverpod();`.
+ *
+ * An annotation now means what its library can see, read from how it is
+ * written: a constant or a class (through its import prefix, if it has one),
+ * a constant, enum value or named constructor of the type it is written
+ * through, or, on a member, a static constant of the type around it. A
+ * comment between it and the declaration (riverpod_lint's `@riverpod`
+ * `// expect_lint: …` fixtures) no longer hides it.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor.
+ */
+import { describe, it, expect, beforeEach, 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> = {
+  'packages/riverpod_annotation/pubspec.yaml': 'name: riverpod_annotation\n',
+  'packages/riverpod_annotation/lib/riverpod_annotation.dart': `export 'src/riverpod_annotation.dart';
+`,
+  'packages/riverpod_annotation/lib/src/riverpod_annotation.dart': `final class Riverpod {
+  const Riverpod({this.keepAlive = false});
+
+  const Riverpod.forever() : keepAlive = true;
+
+  static const scoped = Riverpod();
+
+  final bool keepAlive;
+}
+
+const riverpod = Riverpod();
+
+enum Retry { never, always }
+`,
+  // A getter and a function sharing annotation names, in a package the app
+  // does not import.
+  'packages/riverpod_analyzer_utils/pubspec.yaml': 'name: riverpod_analyzer_utils\n',
+  'packages/riverpod_analyzer_utils/lib/src/nodes.dart': `part 'nodes/annotation.dart';
+
+const _ast = Object();
+
+class AnnotatedNode {}
+
+bool protected(Object node) => true;
+`,
+  'packages/riverpod_analyzer_utils/lib/src/nodes/annotation.dart': `part of '../nodes.dart';
+
+@_ast
+extension RiverpodAnnotatedAnnotatedNodeOfX on AnnotatedNode {
+  Object? get riverpod => null;
+}
+`,
+  'examples/counter/pubspec.yaml': 'name: counter\n',
+  'examples/counter/lib/counter.dart': `import 'package:meta/meta.dart' as meta;
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+@riverpod
+int counter(Object ref) => 0;
+
+@riverpod
+// expect_lint: functional_ref
+int linted(Object ref) => 0;
+
+@Riverpod(keepAlive: true)
+class Todos {
+  static const marker = Riverpod();
+
+  @marker
+  void add() {}
+
+  @meta.protected
+  void reset() {}
+}
+
+@Riverpod.forever()
+int kept(Object ref) => 0;
+
+@Riverpod.scoped
+int scopedCounter(Object ref) => 0;
+
+@Retry.always
+int retried(Object ref) => 0;
+
+@meta.immutable
+class Frozen {}
+`,
+  // A constant of an annotation's name that counter.dart does not import.
+  'examples/counter/lib/immutable.dart': `const immutable = Object();
+`,
+};
+
+describe('Dart annotations name a constant or a constructor', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-annotations-'));
+    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);
+    }
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  /** `<decorated> @<refName> -> <target kind> <target file>:<target qualified name>` for each `decorates` edge. */
+  function decorations(graph: CodeGraph): string[] {
+    const files = Object.keys(FILES).filter((f) => f.endsWith('.dart'));
+    const ids = files.flatMap((f) => graph.getNodesInFile(f).map((n) => n.id));
+    return graph.getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'decorates')
+      .map((e) => {
+        const from = graph.getNode(e.source)!;
+        const to = graph.getNode(e.target)!;
+        return `${from.qualifiedName} @${String(e.metadata?.refName ?? '')} -> ${to.kind} ${to.filePath}:${to.qualifiedName}`;
+      })
+      .sort();
+  }
+
+  it.each(['default', 'wasm'])('link what the annotation is written as (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+
+    const annotation = 'packages/riverpod_annotation/lib/src/riverpod_annotation.dart';
+    const app = 'examples/counter/lib/counter.dart';
+    expect(decorations(cg)).toEqual([
+      // A private constant of the library, declared in the file the part belongs to.
+      `RiverpodAnnotatedAnnotatedNodeOfX @_ast -> constant packages/riverpod_analyzer_utils/lib/src/nodes.dart:_ast`,
+      // A constructor call names the class; a named one, its constructor.
+      `Todos @Riverpod -> class ${annotation}:Riverpod`,
+      // On a member, a static constant of the class around it.
+      `Todos::add @marker -> constant ${app}:Todos::marker`,
+      // The constant riverpod_annotation exports — not the analyzer's getter.
+      `counter @riverpod -> constant ${annotation}:riverpod`,
+      `kept @forever -> method ${annotation}:Riverpod::forever`,
+      // A comment between the annotation and the declaration hides nothing.
+      `linted @riverpod -> constant ${annotation}:riverpod`,
+      // An enum value and a static constant, written through their type.
+      `retried @always -> enum_member ${annotation}:Retry::always`,
+      `scopedCounter @scoped -> constant ${annotation}:Riverpod::scoped`,
+      // `@meta.protected` and `@meta.immutable` are package:meta's: not the
+      // project's function `protected`, nor a constant counter.dart cannot see.
+    ]);
+  });
+});
diff --git a/__tests__/dart-bare-call-scope.test.ts b/__tests__/dart-bare-call-scope.test.ts
new file mode 100644
index 0000000000..9bddb5527a
--- /dev/null
+++ b/__tests__/dart-bare-call-scope.test.ts
@@ -0,0 +1,162 @@
+/**
+ * A bare Dart call — `expect(…)`, `emit(…)`, `refresh()` — reaches a method
+ * only through the class it is written in: that class's own members, what it
+ * extends, mixes in or implements, or an extension on one of those types.
+ *
+ * Without the scope, riverpod's tests' `test(…)` (package:test's function)
+ * went to `ProviderContainer.test` 1,140 times, shelf's `expect(…)` to a test
+ * handler's `expect` method, getx's `expect(…)` to a header class's, and an
+ * extension on `List` calling `add(…)` to `HttpHeaders.add`. Of the in-scope
+ * members the nearest wins: bloc's `emit(…)` in a `Cubit` is `BlocBase.emit`,
+ * not the `Emittable` interface's.
+ */
+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-dart-scope-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: app\n',
+    'lib/handler.dart': `class TestHandler {
+  void expect(Object value) {}
+  void test(String name) {}
+}
+
+abstract class HttpHeaders {
+  void add(String name, Object value);
+  void clear();
+}
+`,
+    'lib/bloc.dart': `abstract class Emittable<S> {
+  void emit(S state);
+}
+
+abstract class BlocBase<S> implements Emittable<S> {
+  @override
+  void emit(S state) {}
+}
+
+abstract class Cubit<S> extends BlocBase<S> {}
+
+class CounterCubit extends Cubit<int> {
+  void increment() => emit(1);
+}
+`,
+    'lib/notifier.dart': `class Listenable {}
+
+mixin SingleMixin on Listenable {
+  void refresh() {}
+}
+
+class ListNotifier extends Listenable {}
+
+class ListNotifierSingle = ListNotifier with SingleMixin;
+
+class RxList extends ListNotifierSingle {
+  void add(Object item) {
+    refresh();
+  }
+}
+`,
+    'lib/element.dart': `abstract class AnyNotifier<S> {}
+
+extension NotifierX<S> on AnyNotifier<S> {
+  void requireElement() {}
+}
+
+class Notifier<
+  // the state
+  S
+> //
+    extends
+        AnyNotifier<
+          S
+        > {
+  void read() {
+    requireElement();
+  }
+}
+`,
+    'lib/list_ext.dart': `extension ListExtension<E> on List<E> {
+  void addIf(bool condition, E item) {
+    if (condition) add(item);
+  }
+}
+`,
+    'lib/login.dart': `class LoginState {
+  LoginState withEmail(String e) => this;
+  LoginState withPassword(String p) => this;
+}
+
+LoginState build() => LoginState().withEmail('a').withPassword('b');
+`,
+    'test/handler_test.dart': `import 'package:test/test.dart';
+
+void main() {
+  test('works', () {
+    expect(1, 1);
+  });
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `from -> Owner::name` for every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => `${cg.getNode(e.source)!.name} -> ${cg.getNode(e.target)!.qualifiedName}`)
+    .sort();
+}
+
+describe('bare Dart calls stay in the class hierarchy', () => {
+  it('a test file’s `test(…)` and `expect(…)` never reach some class’s method', () => {
+    expect(callsFrom('test/handler_test.dart')).toEqual([]);
+  });
+
+  it('an inherited method is the nearest one: the implementation, not the interface', () => {
+    expect(callsFrom('lib/bloc.dart')).toEqual(['increment -> BlocBase::emit']);
+  });
+
+  it('a mixin applied through `class A = B with M;` is in scope', () => {
+    expect(callsFrom('lib/notifier.dart')).toEqual(['add -> SingleMixin::refresh']);
+    const single = cg.getNodesByKind('class').find((n) => n.name === 'ListNotifierSingle');
+    expect(single).toBeDefined();
+    const supers = cg
+      .getOutgoingEdges(single!.id)
+      .filter((e) => e.kind === 'extends' || e.kind === 'implements')
+      .map((e) => `${e.kind}:${cg.getNode(e.target)!.name}`)
+      .sort();
+    expect(supers).toEqual(['extends:ListNotifier', 'implements:SingleMixin']);
+  });
+
+  it('an extension on the class’s supertype is in scope, even behind a commented multi-line header', () => {
+    expect(callsFrom('lib/element.dart')).toEqual(['read -> NotifierX::requireElement']);
+  });
+
+  it('an extension on `List` calling `add(…)` means the list’s, not an unrelated class’s bodiless member', () => {
+    expect(callsFrom('lib/list_ext.dart')).toEqual([]);
+  });
+
+  it('the later links of a call chain keep their method', () => {
+    expect(callsFrom('lib/login.dart')).toContain('build -> LoginState::withPassword');
+  });
+});
diff --git a/__tests__/dart-bodiless-member-docs.test.ts b/__tests__/dart-bodiless-member-docs.test.ts
new file mode 100644
index 0000000000..13b8757093
--- /dev/null
+++ b/__tests__/dart-bodiless-member-docs.test.ts
@@ -0,0 +1,134 @@
+/**
+ * A Dart member with no body — a constructor like `Foo._();` or `Foo.parts()
+ * : id = 0;`, an abstract `void m();`, an `external` one — parses as a
+ * `declaration` wrapping its signature, and the member's `///` dartdoc and
+ * `@annotation`s sit before that wrapper, not before the signature.
+ *
+ * Both extractors looked for them before the signature, inside the wrapper,
+ * where there is nothing. Such a member lost its documentation, and
+ * `@visibleForTesting Foo._();` emitted no `decorates` reference.
+ * (flutter_bloc's `const BlocProvider.value(…)`, with its long dartdoc, is one
+ * of these constructors.)
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+const SOURCE = `abstract class Repository {
+  /// Loads the user with [id].
+  Future<User> load(String id);
+
+  @visibleForTesting
+  void reset();
+
+  /// Calls into the platform.
+  external int platformVersion();
+}
+
+class User {
+  /// Creates a user from its parts.
+  User.parts(this.name) : id = 0;
+
+  @visibleForTesting
+  User.test(this.name) : id = 1;
+
+  @Deprecated('use parts')
+  @internal
+  User.old(this.name) : id = 2;
+
+  /// The user's name.
+  @deprecated
+  final String name;
+  User.afterField() : name = '', id = 3;
+
+  final int id;
+}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+describe('Dart members with no body keep their dartdoc and annotations', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['dart']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource('lib/user.dart', source, 'dart');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract('lib/user.dart', source, 'dart');
+    expect(result, 'kernel extraction').not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    it.each(backends)(`%s${crlf ? ' (CRLF)' : ''}`, (backend) => {
+      const result = extract(backend, crlf ? SOURCE.replace(/\n/g, '\r\n') : SOURCE);
+      const node = (qualifiedName: string) => {
+        const found = result.nodes.find((n) => n.qualifiedName === qualifiedName);
+        expect(found, qualifiedName).toBeDefined();
+        return found!;
+      };
+      const decorators = (qualifiedName: string): string[] => {
+        const id = node(qualifiedName).id;
+        return result.unresolvedReferences
+          .filter((r) => r.referenceKind === 'decorates' && r.fromNodeId === id)
+          .map((r) => r.referenceName)
+          .sort();
+      };
+
+      // The dartdoc before the declaration is the member's.
+      expect(node('Repository::load').docstring).toBe('Loads the user with [id].');
+      expect(node('Repository::platformVersion').docstring).toBe('Calls into the platform.');
+      expect(node('User::parts').docstring).toBe('Creates a user from its parts.');
+
+      // So are the annotations, stacked ones included.
+      expect(decorators('Repository::reset')).toEqual(['visibleForTesting']);
+      expect(decorators('User::test')).toEqual(['visibleForTesting']);
+      expect(decorators('User::old')).toEqual(['Deprecated', 'internal']);
+
+      // A field's dartdoc and annotations stay with the field, which mints no
+      // node, rather than moving on to the constructor after it.
+      expect(node('User::afterField').docstring).toBeUndefined();
+      expect(decorators('User::afterField')).toEqual([]);
+    });
+  }
+});
diff --git a/__tests__/dart-chain-links.test.ts b/__tests__/dart-chain-links.test.ts
new file mode 100644
index 0000000000..e5e24a7e95
--- /dev/null
+++ b/__tests__/dart-chain-links.test.ts
@@ -0,0 +1,242 @@
+/**
+ * A later link of a Dart call chain — `Provider.autoDispose.family(…)`,
+ * `events.map(mapper).transform(…)` — reaches the resolver by its bare name:
+ * the extractor keeps one receiver level. It calls a member of what the chain
+ * before it evaluates to, typed from the chain's head and each link's
+ * declared type, or nothing — never a member found by its name alone.
+ *
+ * Without that, bloc's `events.map(mapper).transform(…)` on a Stream went to
+ * angular_bloc's `BlocPipe.transform`, riverpod's `X.autoDispose.family(…)`
+ * went to one builder's `family` whatever X was, and a sign-up test's
+ * `SignUpState().withEmail(e).withPassword(p)` to the login form's state.
+ */
+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-dart-chain-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: app\n',
+    // angular_bloc's pipe: the one project `transform` a by-name guess finds.
+    'lib/pipe.dart': `class BlocPipe {
+  Object? transform(Object? value) => value;
+}
+`,
+    'lib/bloc.dart': `import 'dart:async';
+
+class Bloc<E> {
+  Stream<dynamic> transformEvents(Stream<E> events, Stream<dynamic> Function(E) mapper) {
+    return events
+        .map(mapper)
+        .transform<dynamic>(const _FlatMap<dynamic>());
+  }
+}
+
+class _FlatMap<T> {
+  const _FlatMap();
+}
+`,
+    'lib/builders.dart': `class FutureProviderBuilder {
+  const FutureProviderBuilder();
+
+  FutureProviderFamilyBuilder get family => const FutureProviderFamilyBuilder();
+}
+
+class FutureProviderFamilyBuilder {
+  const FutureProviderFamilyBuilder();
+
+  Object call(Object create) => create;
+}
+
+class StateProviderBuilder {
+  const StateProviderBuilder();
+
+  StateProviderFamilyBuilder get family => const StateProviderFamilyBuilder();
+}
+
+class StateProviderFamilyBuilder {
+  const StateProviderFamilyBuilder();
+
+  Object call(Object create) => create;
+}
+`,
+    'lib/providers.dart': `import 'builders.dart';
+
+class FutureProvider {
+  static const autoDispose = FutureProviderBuilder();
+}
+
+class StateProvider {
+  static const autoDispose = StateProviderBuilder();
+}
+`,
+    'lib/app.dart': `import 'providers.dart';
+
+final users = FutureProvider.autoDispose.family<int, String>((ref, id) => 0);
+final counts = StateProvider.autoDispose
+    .family<int, String>((ref, id) => 0);
+`,
+    'lib/sign_up/sign_up_state.dart': `class SignUpState {
+  const SignUpState();
+
+  SignUpState withEmail(String email) => this;
+  SignUpState withPassword(String password) => this;
+}
+`,
+    'test/sign_up/login_state.dart': `class LoginState {
+  const LoginState();
+
+  LoginState withEmail(String email) => this;
+  LoginState withPassword(String password) => this;
+}
+`,
+    'test/sign_up/sign_up_state_test.dart': `import 'package:app/sign_up/sign_up_state.dart';
+
+void main() {
+  final constructed = SignUpState().withEmail('a').withPassword('b');
+  final constant = const SignUpState().withEmail('a');
+}
+`,
+    'lib/counter.dart': `abstract class BlocEventSink<E> {
+  void add(E event);
+}
+
+abstract class BlocBase<S> {
+  Future<void> close() async {}
+}
+
+abstract class Bloc<E, S> extends BlocBase<S> implements BlocEventSink<E> {
+  @override
+  void add(E event) {}
+
+  @override
+  Future<void> close() async {
+    await super.close();
+  }
+}
+
+class CounterBloc extends Bloc<int, int> {
+  void increment() {}
+}
+`,
+    'lib/counter_view.dart': `import 'package:flutter/widgets.dart';
+import 'counter.dart';
+
+class CounterView {
+  void onTap(BuildContext context) {
+    context.read<CounterBloc>().add(1);
+  }
+}
+`,
+    'lib/todo.dart': `class Todo {
+  const Todo();
+
+  Todo copyWith({String? title}) => this;
+}
+`,
+    'lib/edit_todo.dart': `import 'todo.dart';
+
+class EditTodoState {
+  const EditTodoState({this.initialTodo});
+
+  final Todo? initialTodo;
+
+  EditTodoState copyWith({Todo? initialTodo}) => this;
+}
+
+class EditTodoBloc {
+  EditTodoState state = const EditTodoState();
+
+  void submit() {
+    final todo = (state.initialTodo ?? const Todo()).copyWith(title: 'x');
+  }
+}
+`,
+    'lib/container.dart': `import 'package:meta/meta.dart';
+
+class ProviderPointerManager {
+  void readPointer(Object provider) {}
+}
+
+class ProviderContainer {
+  final ProviderPointerManager _pointerManager = ProviderPointerManager();
+}
+
+@internal
+extension ProviderContainerTest on ProviderContainer {
+  ProviderPointerManager get pointerManager => _pointerManager;
+}
+
+void probe(ProviderContainer container) {
+  container.pointerManager.readPointer(1);
+}
+`,
+    'lib/other_manager.dart': `class OtherManager {
+  void readPointer(Object provider) {}
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `from -> Owner::name` for every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => `${cg.getNode(e.source)!.name} -> ${cg.getNode(e.target)!.qualifiedName}`)
+    .sort();
+}
+
+describe('Dart call chains link through their receiver’s declared types', () => {
+  it('a Stream’s `transform` is not a project method of that name', () => {
+    expect(callsFrom('lib/bloc.dart')).toEqual([]);
+  });
+
+  it('`X.autoDispose.family(…)` is the family getter of the builder X’s constant holds', () => {
+    expect(callsFrom('lib/app.dart')).toEqual([
+      'counts -> StateProviderBuilder::family',
+      'users -> FutureProviderBuilder::family',
+    ]);
+  });
+
+  it('every link of a fluent chain stays on the type each link returns', () => {
+    expect(callsFrom('test/sign_up/sign_up_state_test.dart')).toEqual([
+      'main -> SignUpState::withEmail',
+      'main -> SignUpState::withEmail',
+      'main -> SignUpState::withPassword',
+    ]);
+  });
+
+  it('`super.close()` is the superclass’s, and `context.read<T>()` hands back a T', () => {
+    expect(callsFrom('lib/counter.dart')).toEqual(['close -> BlocBase::close']);
+    expect(callsFrom('lib/counter_view.dart')).toEqual(['onTap -> Bloc::add']);
+  });
+
+  it('a parenthesized receiver is what its last operand is', () => {
+    expect(callsFrom('lib/edit_todo.dart')).toEqual(['submit -> Todo::copyWith']);
+  });
+
+  it('a getter an annotated extension adds is in the chain, and is called', () => {
+    expect(callsFrom('lib/container.dart')).toEqual([
+      'probe -> ProviderContainerTest::pointerManager',
+      'probe -> ProviderPointerManager::readPointer',
+    ]);
+  });
+});
diff --git a/__tests__/dart-comment-split-chains.test.ts b/__tests__/dart-comment-split-chains.test.ts
new file mode 100644
index 0000000000..e731d82e45
--- /dev/null
+++ b/__tests__/dart-comment-split-chains.test.ts
@@ -0,0 +1,147 @@
+/**
+ * A comment inside a Dart member chain hid what the chain's parts are.
+ *
+ * tree-sitter-dart keeps a comment as a named node wherever it is written, so
+ * in `tester //` + newline + `.state(…)` — the empty `//` keeps dart format
+ * from joining the lines, a common idiom in riverpod's tests — the comment,
+ * not `tester`, sat right before the `.state` selector. Both extractors took
+ * that node for the receiver:
+ *
+ * - a call with a block comment between the member and its arguments
+ *   (`box.grow`, the comment, `(3)`) was lost, and recorded as a read of
+ *   `box.grow`;
+ * - a getter read (`box //` + `.area`) and a static access (`Config //` +
+ *   `.instance`) written after a comment were lost;
+ * - a call after a comment kept only its bare name (`state`). The resolver now
+ *   reads a bare chain link back past comments, so that one already linked
+ *   right; it keeps doing so with the receiver in the name.
+ *
+ * Every sibling step along a chain now skips comments, so each line extracts
+ * what it would without the comment.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'pubspec.yaml': 'name: app\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+  'lib/model.dart': `class Counter {
+  int state(int x) => x;
+}
+
+class Box {
+  int get area => 1;
+  int grow(int by) => by;
+}
+
+class Config {
+  static final Config instance = Config();
+}
+
+class Foo {
+  static Foo create() => Foo();
+  void bar() {}
+}
+`,
+  'test/scope_test.dart': `import 'package:flutter_test/flutter_test.dart';
+import 'package:app/model.dart';
+
+// Same-named methods next to the calls, where a guess by name lands.
+class Other {
+  void bar() {}
+  int grow(int by) => by;
+}
+
+int inline(Box box) => box.grow /* by */ (3);
+
+int measure(Box box) {
+  return box //
+      .area;
+}
+
+void use() {
+  final config = Config //
+      .instance;
+}
+
+void scope(WidgetTester tester) {
+  tester //
+      .state(find.byType(Counter));
+}
+
+void run() {
+  Foo.create() //
+      .bar();
+}
+
+int widen(Box box) {
+  return box
+      // a whole-line comment
+      /// and a dartdoc one
+      .grow(2);
+}
+`,
+};
+
+describe('Dart member chains split by a comment', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-comment-chains-'));
+    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);
+    }
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('extract each part past the comment (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const node = (qualifiedName: string): Node => {
+      const found = graph.getNodesInFile('test/scope_test.dart').find((n) => n.qualifiedName === qualifiedName);
+      expect(found, qualifiedName).toBeDefined();
+      return found!;
+    };
+    const targets = (from: string, kind: string): string[] =>
+      [...new Set(graph
+        .getOutgoingEdgesFrom([node(from).id])
+        .filter((e) => e.kind === kind)
+        .map((e) => graph.getNode(e.target)!.qualifiedName))]
+        .sort();
+
+    // A comment between the member and its arguments: still a call of the
+    // receiver's method.
+    expect(targets('inline', 'calls')).toEqual(['Box::grow']);
+
+    // A getter read runs the getter; a static access references its type.
+    expect(targets('measure', 'calls')).toEqual(['Box::area']);
+    expect(targets('use', 'references')).toEqual(['Config']);
+
+    // Calls keep resolving with the receiver in the name: `tester.state(…)` is
+    // WidgetTester's, a type outside the project, not the one `state` the
+    // project declares; a chain off a factory goes through what `create`
+    // returns; the receiver's type picks the method past a run of comments.
+    expect(targets('scope', 'calls')).toEqual([]);
+    expect(targets('run', 'calls')).toEqual(['Foo::bar', 'Foo::create']);
+    expect(targets('widen', 'calls')).toEqual(['Box::grow']);
+  });
+});
diff --git a/__tests__/dart-const-constructors.test.ts b/__tests__/dart-const-constructors.test.ts
new file mode 100644
index 0000000000..438c84f3a3
--- /dev/null
+++ b/__tests__/dart-const-constructors.test.ts
@@ -0,0 +1,277 @@
+/**
+ * Dart `const` constructors and redirecting factories are methods, and a call
+ * through a type's name is to that type's own member or to nothing.
+ *
+ * `const Foo.bar(…)` and `const factory Foo.bar() = _Bar;` parse as signature
+ * kinds of their own, which neither extractor indexed. So flutter_bloc's
+ * `BlocProvider.value(…)` found no `value` on BlocProvider, and the resolver
+ * guessed the one other `value` — RepositoryProvider's non-const constructor —
+ * for all 89 calls in felangel/bloc.
+ *
+ * Dart inherits no static member and no constructor, so a call through a type
+ * the project declares never means another type's method: not a same-named
+ * one guessed by name, not a supertype's, not a same-file look-alike's. And
+ * the SDK's `Uri.parse(…)` is not a project `parse` because the project has an
+ * `extension on Uri`.
+ *
+ * A constructor is only ever called through its class. Written with type
+ * arguments — `BlocProvider<CounterCubit>.value(…)`, most of bloc's tests —
+ * the call still names the type, and a bare name or a chain's last link
+ * (`box.inner.value(1)`) never means a constructor.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'pubspec.yaml': 'name: app\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+  'lib/bloc_provider.dart': `class BlocProvider<T> {
+  const BlocProvider({required T Function() create}) : _create = create, _value = null;
+
+  const BlocProvider.value({required T value}) : this._(value: value);
+
+  const BlocProvider._({T? value}) : _create = null, _value = value;
+
+  final T Function()? _create;
+  final T? _value;
+
+  void handle(Object value) => accept(value);
+}
+
+void accept(Object o) {}
+`,
+  'lib/repository_provider.dart': `class RepositoryProvider<T> {
+  RepositoryProvider({required T Function() create});
+
+  RepositoryProvider.value({required T value});
+
+  static T of<T>(Object context) => throw 0;
+}
+`,
+  'lib/new_car_state.dart': `class NewCarState {
+  const NewCarState._({this.brands = const []});
+
+  const NewCarState.initial() : this._();
+
+  const factory NewCarState.loading() = _Loading;
+
+  const factory NewCarState() = _Loading.named;
+
+  const factory NewCarState.fromJson(Map<String, Object?> json) = _Loading.fromJson;
+
+  final List<String> brands;
+}
+
+class _Loading extends NewCarState {
+  const _Loading() : super._();
+
+  const _Loading.named() : super._();
+
+  const _Loading.fromJson(Map<String, Object?> json) : super._();
+}
+`,
+  'lib/profile_wizard_state.dart': `class ProfileWizardState {
+  ProfileWizardState.initial() : step = 0;
+
+  final int step;
+
+  Object fromJson(Object json) => json;
+}
+`,
+  // A look-alike declared first in the same file.
+  'lib/family.dart': `class EmptyFamily extends Family {
+  EmptyFamily._() : super._();
+}
+
+class Family {
+  const Family._();
+
+  static Family make() => Family._();
+}
+`,
+  'lib/sub.dart': `abstract class Base {
+  const Base();
+
+  factory Base.named() => const _BaseImpl();
+}
+
+class _BaseImpl extends Base {
+  const _BaseImpl();
+}
+
+class Sub extends Base {
+  const Sub();
+
+  const factory Sub.named() = _SubImpl;
+}
+
+class _SubImpl extends Sub {
+  const _SubImpl();
+}
+`,
+  'lib/analysis_options.dart': `class AnalysisOptions {
+  const AnalysisOptions(this.path);
+
+  factory AnalysisOptions.parse(String path) => AnalysisOptions(path);
+
+  final String path;
+}
+`,
+  'lib/linter.dart': `extension on Uri {
+  String get canonicalizedPath => path;
+}
+`,
+  // An instance getter declared before a constructor of the same name.
+  'lib/async_value.dart': `sealed class AsyncValue<T> {
+  const AsyncValue._();
+
+  Object? get error => null;
+
+  const factory AsyncValue.error(Object error) = AsyncError<T>;
+}
+
+class AsyncError<T> extends AsyncValue<T> {
+  const AsyncError(this.error) : super._();
+
+  @override
+  final Object error;
+}
+
+Object fail(Object e) => AsyncValue.error(e);
+`,
+  'lib/change_notifier_provider.dart': `class ChangeNotifierProvider {
+  const ChangeNotifierProvider.internal();
+}
+`,
+  // package:meta's `internal` annotation is a constant outside the project.
+  'lib/scope.dart': `import 'package:meta/meta.dart';
+
+@internal
+Object guarded() => 0;
+`,
+  'lib/app.dart': `import 'bloc_provider.dart';
+import 'repository_provider.dart';
+import 'new_car_state.dart';
+import 'sub.dart';
+
+Object build(Object counter) => BlocProvider.value(value: counter);
+Object typed(Object counter) => BlocProvider<Object>.value(value: counter);
+Object typedRepository(Object repository) => RepositoryProvider<Object>.value(value: repository);
+NewCarState start() => NewCarState.initial();
+NewCarState load() => NewCarState.loading();
+Sub sub() => Sub.named();
+Object find(Object context) => BlocProvider.of(context);
+Uri link() => Uri.parse('https://example.com');
+Object tail(dynamic box) => box.inner.value(1);
+`,
+};
+
+describe('Dart const constructors and redirecting factories', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-const-ctors-'));
+    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);
+    }
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('are indexed and called through their own type (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const find = (file: string, qualifiedName: string): Node | undefined =>
+      graph.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName);
+    const node = (file: string, qualifiedName: string): Node => {
+      const found = find(file, qualifiedName);
+      expect(found, `${file} ${qualifiedName}`).toBeDefined();
+      return found!;
+    };
+    const targets = (from: Node, kind: string): string[] =>
+      [...new Set(graph
+        .getOutgoingEdgesFrom([from.id])
+        .filter((e) => e.kind === kind)
+        .map((e) => graph.getNode(e.target)!.qualifiedName))]
+        .sort();
+    const sources = (to: Node): string[] =>
+      [...new Set(graph
+        .getIncomingEdgesTo([to.id])
+        .filter((e) => e.kind !== 'contains')
+        .map((e) => `${e.kind} ${graph.getNode(e.source)!.qualifiedName}`))]
+        .sort();
+
+    // Named `const` constructors and redirecting factories are methods named
+    // by the constructor, returning their class; the unnamed ones stay
+    // unindexed, as the unnamed generative constructor is, and a redirecting
+    // factory's target (`= _Loading.named`) names nothing.
+    const value = node('lib/bloc_provider.dart', 'BlocProvider::value');
+    expect(value.kind).toBe('method');
+    expect(value.returnType).toBe('BlocProvider');
+    expect(value.signature).toBe('({required T value})');
+    node('lib/bloc_provider.dart', 'BlocProvider::_');
+    expect(find('lib/bloc_provider.dart', 'BlocProvider::BlocProvider')).toBeUndefined();
+    node('lib/new_car_state.dart', 'NewCarState::initial');
+    const loading = node('lib/new_car_state.dart', 'NewCarState::loading');
+    expect(loading.signature).toBe('()');
+    expect(find('lib/new_car_state.dart', 'NewCarState::NewCarState')).toBeUndefined();
+    expect(find('lib/new_car_state.dart', 'NewCarState::named')).toBeUndefined();
+    node('lib/new_car_state.dart', '_Loading::named');
+    node('lib/sub.dart', 'Sub::named');
+    // A redirecting factory refers to the class it constructs, and not to
+    // that class's constructor as if it were a type (`= _Loading.fromJson`).
+    expect(targets(loading, 'references')).toEqual(['_Loading']);
+    expect(targets(node('lib/new_car_state.dart', 'NewCarState::fromJson'), 'references')).toEqual(['_Loading']);
+    expect(sources(node('lib/profile_wizard_state.dart', 'ProfileWizardState::fromJson'))).toEqual([]);
+
+    // Each call reaches the constructor of the type it names, type arguments
+    // or not...
+    expect(targets(node('lib/app.dart', 'build'), 'calls')).toEqual(['BlocProvider::value']);
+    expect(targets(node('lib/app.dart', 'typed'), 'calls')).toEqual(['BlocProvider::value']);
+    expect(targets(node('lib/app.dart', 'typedRepository'), 'calls')).toEqual(['RepositoryProvider::value']);
+    expect(targets(node('lib/app.dart', 'start'), 'calls')).toEqual(['NewCarState::initial']);
+    expect(targets(node('lib/app.dart', 'load'), 'calls')).toEqual(['NewCarState::loading']);
+    expect(targets(node('lib/app.dart', 'sub'), 'calls')).toEqual(['Sub::named']);
+    expect(targets(node('lib/family.dart', 'Family::make'), 'calls')).toEqual(['Family::_']);
+    // A constructor, not the instance getter that shares its name.
+    const errorFactory = graph.getNodesInFile('lib/async_value.dart')
+      .find((n) => n.qualifiedName === 'AsyncValue::error' && n.signature === '(Object error)');
+    expect(errorFactory).toBeDefined();
+    expect(graph.getOutgoingEdgesFrom([node('lib/async_value.dart', 'fail').id])
+      .filter((e) => e.kind === 'calls').map((e) => e.target)).toEqual([errorFactory!.id]);
+    // ...and never another type's member of that name.
+    expect(sources(node('lib/repository_provider.dart', 'RepositoryProvider::value'))).toEqual(['calls typedRepository']);
+    expect(sources(node('lib/profile_wizard_state.dart', 'ProfileWizardState::initial'))).toEqual([]);
+    expect(sources(node('lib/family.dart', 'EmptyFamily::_'))).toEqual([]);
+    expect(sources(node('lib/sub.dart', 'Base::named'))).toEqual([]);
+    // A member the named type does not declare is outside the project.
+    expect(targets(node('lib/app.dart', 'find'), 'calls')).toEqual([]);
+    expect(sources(node('lib/repository_provider.dart', 'RepositoryProvider::of'))).toEqual([]);
+    expect(targets(node('lib/app.dart', 'link'), 'calls')).toEqual([]);
+    expect(sources(node('lib/analysis_options.dart', 'AnalysisOptions::parse'))).toEqual([]);
+
+    // A constructor is only ever reached through its class: a parameter that
+    // shares its name, the last link of a chain, or an annotation is not it.
+    expect(targets(node('lib/app.dart', 'tail'), 'calls')).toEqual([]);
+    expect(sources(value)).toEqual(['calls build', 'calls typed']);
+    expect(sources(node('lib/change_notifier_provider.dart', 'ChangeNotifierProvider::internal'))).toEqual([]);
+  });
+});
diff --git a/__tests__/dart-extension-receiver.test.ts b/__tests__/dart-extension-receiver.test.ts
new file mode 100644
index 0000000000..ef0d199400
--- /dev/null
+++ b/__tests__/dart-extension-receiver.test.ts
@@ -0,0 +1,61 @@
+/**
+ * A Dart core method name (`endsWith`, `contains`, `forEach`, …) on an
+ * untyped receiver is the core type's, unless the receiver is named after
+ * the owner — and a Dart extension's owner is the type it is `on`, not the
+ * extension's own name: getx's `ext.endsWith(".avi")` on a String went to
+ * `extension RxStringExt on Rx<String>` because `ext` matched `…Ext`.
+ */
+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-dart-ext-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: app\n',
+    'lib/rx_string.dart': `class Rx<T> {
+  Rx(this.value);
+  T value;
+}
+
+extension RxStringExt on Rx<String> {
+  bool endsWith(String other) => value.endsWith(other);
+}
+
+extension RxnStringExt on Rx<String?> {
+  bool endsWith(String other) => false;
+}
+`,
+    'lib/get_utils.dart': `class GetUtils {
+  static bool isVideo(String filePath) {
+    var ext = filePath.toLowerCase();
+    return ext.endsWith(".avi");
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Dart core method names on untyped receivers', () => {
+  it('are not an extension’s method whose name the receiver happens to share', () => {
+    const ids = cg.getNodesInFile('lib/get_utils.dart').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(targets).not.toContain('RxStringExt::endsWith');
+    expect(targets).not.toContain('RxnStringExt::endsWith');
+  });
+});
diff --git a/__tests__/dart-generic-calls.test.ts b/__tests__/dart-generic-calls.test.ts
new file mode 100644
index 0000000000..d106b07748
--- /dev/null
+++ b/__tests__/dart-generic-calls.test.ts
@@ -0,0 +1,219 @@
+/**
+ * Dart generic calls that tree-sitter-dart parses as two comparisons.
+ *
+ * `ref.read<Repo>(repoProvider)` comes out of the grammar as
+ * `(ref.read < Repo) > (repoProvider)`, a relational expression inside
+ * another, about as often as it comes out as a call: which one depends on the
+ * code around it. `Provider<int>((ref) => 0)`, `int g(Ref ref) =>
+ * ref.read<int>(1);`, `RepositoryProvider<Repo>(create: …)` (named arguments
+ * parse as a record) and `await users.fetch<User>(1)` all can. Neither
+ * extractor recorded a call for that shape, only a member read of `ref.read`
+ * that links nothing, so providers, repository reads and bloc lookups written
+ * with a type argument had no callers. `context.read<CounterBloc>()`, with
+ * empty arguments, parses as a call and always worked.
+ *
+ * The nest is the call when its type argument names a type and it is laid
+ * out as a call is, `<` against the callee and `(` against the `>`; a
+ * comparison is written `a < b`.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, 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';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import type { Node } from '../src/types';
+
+const BACKENDS = ['default', 'wasm'] as const;
+
+let kernel: string | undefined;
+
+function useBackend(backend: (typeof BACKENDS)[number]): void {
+  if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+  else delete process.env.CODEGRAPH_KERNEL;
+}
+
+beforeEach(() => {
+  kernel = process.env.CODEGRAPH_KERNEL;
+});
+
+afterEach(() => {
+  if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+  else process.env.CODEGRAPH_KERNEL = kernel;
+});
+
+describe('Dart generic calls parsed as comparisons: extraction', () => {
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['dart']);
+  });
+
+  const SOURCE = [
+    'int g(Ref ref) => ref.read<int>(1);',
+    '',
+    'void f(Ref ref) {',
+    '  final a = ref.watch<int>(p);',
+    '  ref.read<Repo>(repoProvider);',
+    '  print(ref.watch<int>(p) + 1);',
+    '  final b = a < B > (c);',
+    '  final d = a<b>(c);',
+    '}',
+    '',
+  ].join('\n');
+
+  it.each(BACKENDS)('records the call a parsed one gets, at its `<` (%s)', (backend) => {
+    useBackend(backend);
+    const result = extractFromSource('lib/providers.dart', SOURCE, 'dart');
+    const names = new Map(result.nodes.map((n) => [n.id, n.name]));
+    const refs = result.unresolvedReferences
+      .filter((r) => r.referenceKind === 'calls' || r.referenceKind === 'references')
+      .map((r) => `${names.get(r.fromNodeId)} ${r.referenceKind} ${r.referenceName} ${r.line}:${r.column}`)
+      .sort();
+
+    expect(refs).toEqual([
+      'f calls print 6:7',
+      // Line 6 parses as a call: what the recovered calls must look like.
+      'f calls ref.read 5:10',
+      'f calls ref.watch 4:21',
+      'f calls ref.watch 6:17',
+      'f references Ref 3:7',
+      // The type argument is referenced as a parsed one is; `int` is built in.
+      'f references Repo 5:11',
+      'g calls ref.read 1:26',
+      'g references Ref 1:6',
+    ]);
+    // No member read of `ref.read` / `ref.watch`, and the comparisons on
+    // lines 7 and 8 stay comparisons.
+  });
+});
+
+describe('Dart generic calls parsed as comparisons: graph', () => {
+  const FILES: Record<string, string> = {
+    'pubspec.yaml': 'name: app\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+    'lib/riverpod.dart': `class Ref {
+  T watch<T>(Object provider) => throw 0;
+  T read<T>(Object provider) => throw 0;
+}
+
+class Provider<T> {
+  Provider(T Function(Ref ref) create);
+}
+`,
+    'lib/data.dart': `class User {}
+
+class Repo {
+  Repo();
+}
+
+class UserRepository {
+  Future<T> fetch<T>(int id) => throw 0;
+}
+`,
+    'lib/bloc.dart': `class BuildContext {}
+
+class BlocProvider {
+  static T of<T>(BuildContext context) => throw 0;
+}
+
+class CounterCubit {
+  void increment() {}
+}
+
+class RepositoryProvider<T> {
+  RepositoryProvider({required T Function(BuildContext context) create});
+}
+`,
+    // Every call below parses as two comparisons.
+    'lib/app.dart': `import 'bloc.dart';
+import 'data.dart';
+import 'riverpod.dart';
+
+final seedProvider = Provider<int>((ref) => 0);
+final repoProvider = Provider<Repo>((ref) => Repo());
+final countProvider = Provider<int>((Ref ref) => ref.watch<int>(seedProvider));
+
+int g(Ref ref) => ref.read<int>(countProvider);
+
+Repo readRepo(Ref ref) {
+  final repo = ref.read<Repo>(repoProvider);
+  return repo;
+}
+
+Future<User> loadUser(UserRepository users) async {
+  final user = await users.fetch<User>(1);
+  return user;
+}
+
+void tap(BuildContext context) {
+  BlocProvider.of<CounterCubit>(context).increment();
+}
+
+Object provide() => RepositoryProvider<Repo>(create: (_) => Repo());
+
+bool compare(int a, int b, int c) {
+  final spaced = a < b > (c);
+  final lower = a<b>(c);
+  return spaced && lower;
+}
+`,
+  };
+
+  let root = '';
+  let cg: CodeGraph | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-generic-calls-'));
+    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);
+    }
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it.each(BACKENDS)('link the calls, constructions and type arguments (%s)', async (backend) => {
+    useBackend(backend);
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const node = (qualifiedName: string): Node => {
+      const found = graph.getNodesInFile('lib/app.dart').find((n) => n.qualifiedName === qualifiedName);
+      expect(found, qualifiedName).toBeDefined();
+      return found!;
+    };
+    const targets = (from: string, kind: string): string[] =>
+      [...new Set(graph
+        .getOutgoingEdgesFrom([node(from).id])
+        .filter((e) => e.kind === kind)
+        .map((e) => graph.getNode(e.target)!.qualifiedName))]
+        .sort();
+
+    // The issue's shapes: a typed receiver's method, through `=>` and a block.
+    expect(targets('g', 'calls')).toEqual(['Ref::read']);
+    expect(targets('readRepo', 'calls')).toEqual(['Ref::read']);
+    expect(targets('readRepo', 'references')).toContain('Repo');
+
+    // Riverpod providers built with a type argument construct their provider,
+    // and a typed closure parameter still types the call written in it.
+    expect(targets('seedProvider', 'instantiates')).toEqual(['Provider']);
+    expect(targets('repoProvider', 'instantiates')).toEqual(['Provider', 'Repo']);
+    expect(targets('countProvider', 'instantiates')).toEqual(['Provider']);
+    expect(targets('countProvider', 'calls')).toEqual(['Ref::watch']);
+
+    // After `await`, with named arguments, and through a static method.
+    expect(targets('loadUser', 'calls')).toEqual(['UserRepository::fetch']);
+    expect(targets('provide', 'instantiates')).toEqual(['Repo', 'RepositoryProvider']);
+    expect(targets('tap', 'calls')).toEqual(['BlocProvider::of', 'CounterCubit::increment']);
+    expect(targets('tap', 'references')).toContain('CounterCubit');
+
+    // Comparisons are not calls.
+    expect(targets('compare', 'calls')).toEqual([]);
+  });
+});
diff --git a/__tests__/dart-generic-factory-chain.test.ts b/__tests__/dart-generic-factory-chain.test.ts
new file mode 100644
index 0000000000..4df0f4c032
--- /dev/null
+++ b/__tests__/dart-generic-factory-chain.test.ts
@@ -0,0 +1,228 @@
+/**
+ * A Dart call chained on a generic static factory — bloc's
+ * `BlocProvider.of<CounterCubit>(context, listen: false).increment()`,
+ * `RepositoryProvider.of<TodosRepository>(context).saveTodo(t)` — calls a
+ * member of the type the factory's type argument names.
+ *
+ * When the generic call parses as a call (tree-sitter-dart reads about half
+ * of them as two comparisons, but a named argument or a type argument like
+ * `<A?>` makes it a call), the extractor records the chain as
+ * `BlocProvider.of().increment`, and the resolver typed it by what
+ * `BlocProvider.of` is declared to return. That is `T` (`static T of<T>(…)`),
+ * which names no type, so the call linked nothing. In an app, where
+ * flutter_bloc is a dependency and not in the project, nothing typed it
+ * either. The chain read back from the call site is typed the way a later
+ * link of a chain is (#750): the factory's own type parameter is the type
+ * argument the call gives, and an outside lookup such as `of<T>(…)` hands
+ * back its T. A chain on a call read as two comparisons keeps its bare name
+ * (`increment`), and reaches the same method.
+ *
+ * It never falls back to a member found by its name: `StepCounter.increment`,
+ * next to the call site, is not what `of<CounterCubit>` returns, and a call
+ * with no type argument (`BlocProvider.of(context)`) links nothing.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const PUBSPEC = 'name: app\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n';
+
+// A method named like each chained call, nearer the call site than the type
+// that declares it: the one a guess by name would pick.
+const DECOY = `class StepCounter {
+  void increment() {}
+  void decrement() {}
+  void saveTodo(Object todo) {}
+}
+`;
+
+/** The bloc repo itself: BlocProvider is declared in the project. */
+const LIBRARY: Record<string, string> = {
+  'pubspec.yaml': PUBSPEC,
+  'lib/bloc_provider.dart': `class BlocProvider<T> {
+  const BlocProvider();
+
+  static T of<T>(Object context, {bool listen = false}) => throw 0;
+
+  static T? maybeOf<T>(Object context, {bool listen = false}) => null;
+}
+`,
+  'lib/bloc.dart': `abstract class Bloc<E, S> {
+  void add(E event) {}
+}
+`,
+  'lib/counter/counter_cubit.dart': `class CounterCubit {
+  void increment() {}
+}
+`,
+  'lib/counter/counter_bloc.dart': `import '../bloc.dart';
+
+class CounterBloc extends Bloc<int, int> {}
+`,
+  'lib/counter/step_counter.dart': DECOY,
+  'lib/counter/counter_page.dart': `import '../bloc_provider.dart';
+import 'counter_cubit.dart';
+import 'counter_cubit.dart' as cubits;
+import 'counter_bloc.dart';
+
+class Button {
+  const Button({Object? onPressed});
+}
+
+class CounterPage {
+  void tap(Object context) {
+    BlocProvider.of<CounterCubit>(context, listen: false).increment();
+  }
+
+  void tapWrapped(Object context) {
+    BlocProvider.of<CounterCubit>(context, listen: false)
+        .increment();
+  }
+
+  void tapPrefixed(Object context) {
+    BlocProvider.of<cubits.CounterCubit>(context, listen: false).increment();
+  }
+
+  void tapMaybe(Object context) {
+    BlocProvider.maybeOf<CounterCubit>(context, listen: false)?.increment();
+  }
+
+  void tapBloc(Object context) {
+    BlocProvider.of<CounterBloc>(context, listen: false).add(1);
+  }
+
+  void tapMissing(Object context) {
+    BlocProvider.of<CounterCubit>(context, listen: false).decrement();
+  }
+
+  void tapInferred(Object context) {
+    BlocProvider.of(context, listen: false).increment();
+  }
+
+  // Parsed as two comparisons, so increment arrives by its bare name.
+  void tapRecovered(Object context) {
+    BlocProvider.of<CounterCubit>(context).increment();
+  }
+
+  Object build(Object context) => Button(
+        onPressed: () => BlocProvider.of<CounterCubit>(context, listen: false).increment(),
+      );
+}
+`,
+};
+
+/** An app: flutter_bloc is a dependency, outside the project. */
+const APP: Record<string, string> = {
+  'pubspec.yaml': PUBSPEC,
+  'lib/counter/counter_cubit.dart': `class CounterCubit {
+  void increment() {}
+}
+`,
+  'lib/counter/step_counter.dart': DECOY,
+  'lib/todos/todos_repository.dart': `class TodosRepository {
+  void saveTodo(Object todo) {}
+}
+`,
+  'lib/counter/counter_page.dart': `import 'package:flutter_bloc/flutter_bloc.dart';
+import '../todos/todos_repository.dart';
+import 'counter_cubit.dart';
+
+class CounterPage {
+  void tap(Object context) {
+    BlocProvider.of<CounterCubit>(context, listen: false).increment();
+  }
+
+  void save(Object context, Object todo) {
+    RepositoryProvider.of<TodosRepository>(context, listen: false).saveTodo(todo);
+  }
+
+  void tapInferred(Object context) {
+    BlocProvider.of(context, listen: false).increment();
+  }
+
+  // Parsed as two comparisons, so increment arrives by its bare name.
+  void tapRecovered(Object context) {
+    BlocProvider.of<CounterCubit>(context).increment();
+  }
+}
+`,
+};
+
+describe('Dart chains on a generic static factory', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  const index = async (files: Record<string, string>, backend: string): Promise<CodeGraph> => {
+    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);
+    }
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    return cg;
+  };
+
+  /** `caller -> Owner::name` for every call edge out of a file. */
+  const callsFrom = (graph: CodeGraph, file: string): string[] => {
+    const ids = graph.getNodesInFile(file).map((n) => n.id);
+    return graph
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => `${graph.getNode(e.source)!.name} -> ${graph.getNode(e.target)!.qualifiedName}`)
+      .sort();
+  };
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-generic-factory-'));
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('call a member of the type argument a project factory is given (%s)', async (backend) => {
+    const graph = await index(LIBRARY, backend);
+    expect(callsFrom(graph, 'lib/counter/counter_page.dart')).toEqual([
+      'build -> BlocProvider::of',
+      'build -> CounterCubit::increment',
+      'tap -> BlocProvider::of',
+      'tap -> CounterCubit::increment',
+      // What CounterBloc inherits.
+      'tapBloc -> Bloc::add',
+      'tapBloc -> BlocProvider::of',
+      // No type argument says what `of` returns.
+      'tapInferred -> BlocProvider::of',
+      'tapMaybe -> BlocProvider::maybeOf',
+      'tapMaybe -> CounterCubit::increment',
+      // CounterCubit has no `decrement`; StepCounter's is not this one.
+      'tapMissing -> BlocProvider::of',
+      'tapPrefixed -> BlocProvider::of',
+      'tapPrefixed -> CounterCubit::increment',
+      'tapRecovered -> BlocProvider::of',
+      'tapRecovered -> CounterCubit::increment',
+      'tapWrapped -> BlocProvider::of',
+      'tapWrapped -> CounterCubit::increment',
+    ]);
+  });
+
+  it.each(['default', 'wasm'])('call a member of the type argument an outside lookup is given (%s)', async (backend) => {
+    const graph = await index(APP, backend);
+    expect(callsFrom(graph, 'lib/counter/counter_page.dart')).toEqual([
+      'save -> TodosRepository::saveTodo',
+      'tap -> CounterCubit::increment',
+      'tapRecovered -> CounterCubit::increment',
+    ]);
+  });
+});
diff --git a/__tests__/dart-getter-reads.test.ts b/__tests__/dart-getter-reads.test.ts
new file mode 100644
index 0000000000..ab6869858f
--- /dev/null
+++ b/__tests__/dart-getter-reads.test.ts
@@ -0,0 +1,165 @@
+/**
+ * Dart getter reads and extension members on enums (#2338).
+ *
+ * Reading a getter runs it: `x.area` calls `Box`'s `int get area`. A read
+ * linked to nothing, so `callers area` was empty while `x.grow()` worked. And
+ * a member an `extension … on` an ENUM adds (`s.shout()`) resolved nowhere,
+ * while the same extension on a class did.
+ *
+ * A read links only a getter the receiver's type reaches — never a field (they
+ * mint no nodes), a getter of a type outside the project, or a same-named
+ * getter guessed by name.
+ */
+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-dart-getters-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: repro\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+    // The issue's two files, verbatim.
+    'lib/shape.dart': `enum Shape { circle, square }
+
+extension ShapeInfo on Shape {
+  String get label => name.toUpperCase();
+  String shout() => name.toUpperCase();
+}
+
+class Box {
+  const Box(this.size);
+  final int size;
+  int get area => size * size;
+  int grow() => size + 1;
+}
+
+extension BoxActions on Box {
+  int twice() => size * 2;
+}
+`,
+    'lib/use.dart': `import 'shape.dart';
+
+String a(Shape s) => s.label;   // getter, extension on enum
+String b(Shape s) => s.shout(); // method, extension on enum
+int c(Box x) => x.area;         // getter, plain class
+int d(Box x) => x.grow();       // method, plain class
+int e(Box x) => x.twice();      // method, extension on class
+`,
+    // Block bodies and class methods, through a parameter, a local and a field.
+    'lib/render.dart': `import 'shape.dart';
+
+class Square extends Box {
+  const Square(int size) : super(size);
+  static Square get unit => const Square(1);
+}
+
+class Renderer {
+  final Box box;
+  final Shape shape;
+  Renderer(this.box, this.shape);
+
+  int paint(Box other) {
+    final local = Box(2);
+    return other.area + local.area;
+  }
+
+  int viaField() {
+    return box.area;
+  }
+
+  String tag() {
+    final text = shape.label;
+    return text + shape.shout();
+  }
+}
+
+int inherited(Square s) {
+  return s.area;
+}
+
+Square staticGetter() => Square.unit;
+`,
+    // Reads that must link nothing.
+    'lib/other.dart': `class Panel {
+  int get size => 0;
+  int get length => 0;
+}
+
+extension on Box {
+  int get hidden => 0;
+}
+`,
+    'lib/negatives.dart': `import 'shape.dart';
+
+int fieldRead(Box x) => x.size;           // a field, not Panel's getter
+int outside(List<int> xs) => xs.length;   // a getter of a type outside the project
+int untyped(dynamic d) => d.area;         // nothing says what d is
+int unnamed(Box x) => x.hidden;           // an unnamed extension in another library
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `kind name` of each caller of the node with qualified name `qn`, sorted. */
+function callersOf(qn: string): string[] {
+  const [target] = cg.getNodesByQualifiedName(qn);
+  expect(target, `no node ${qn}`).toBeDefined();
+  return cg.getCallers(target!.id).map(({ node, edge }) => `${edge.kind} ${node.qualifiedName}`).sort();
+}
+
+describe('Dart getter reads (#2338)', () => {
+  it('link a getter read on a plain class, as a call', () => {
+    expect(callersOf('Box::area')).toContain('calls c');
+  });
+
+  it('link a getter an extension on an enum adds', () => {
+    expect(callersOf('ShapeInfo::label')).toEqual(['calls Renderer::tag', 'calls a']);
+  });
+
+  it('link reads in block bodies and class methods, through parameters, locals and fields', () => {
+    expect(callersOf('Box::area')).toEqual([
+      'calls Renderer::paint',
+      'calls Renderer::viaField',
+      'calls c',
+      'calls inherited',
+    ]);
+  });
+
+  it('link a static getter read through its class', () => {
+    expect(callersOf('Square::unit')).toEqual(['calls staticGetter']);
+  });
+
+  it('link nothing for a field, an outside type, an untyped receiver or an out-of-library unnamed extension', () => {
+    const ids = cg.getNodesInFile('lib/negatives.dart').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids, ['calls'])
+      .map((edge) => cg.getNode(edge.target)!.qualifiedName);
+    expect(targets).toEqual([]);
+    expect(callersOf('Panel::size')).toEqual([]);
+    expect(callersOf('Panel::length')).toEqual([]);
+  });
+});
+
+describe('Dart extension members on an enum (#2338)', () => {
+  it('resolve a method an extension on an enum adds', () => {
+    expect(callersOf('ShapeInfo::shout')).toEqual(['calls Renderer::tag', 'calls b']);
+  });
+
+  it('still resolve methods on a class and its extensions', () => {
+    expect(callersOf('Box::grow')).toEqual(['calls d']);
+    expect(callersOf('BoxActions::twice')).toEqual(['calls e']);
+  });
+});
diff --git a/__tests__/dart-import-prefix-calls.test.ts b/__tests__/dart-import-prefix-calls.test.ts
new file mode 100644
index 0000000000..8c3b7cdb9f
--- /dev/null
+++ b/__tests__/dart-import-prefix-calls.test.ts
@@ -0,0 +1,200 @@
+/**
+ * A Dart call written through an import prefix — `http.get(uri)` after
+ * `import 'package:http/http.dart' as http;` — calls a top-level declaration
+ * the libraries imported with that prefix export, or nothing in the project.
+ * It is no method call on a receiver named `http`: riverpod's docs' 25
+ * `http.get(…)` / `http.post(…)` calls went to a docs example's `Http` class.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor.
+ */
+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';
+
+const FILES: Record<string, string> = {
+  'pubspec.yaml': 'name: app\n',
+  // Namesakes of everything the prefixes below name, in a library beside the
+  // callers — nearer than the libraries the prefixes import.
+  'lib/legacy.dart': `class Http {
+  Future<String> get(Uri url) async => '';
+}
+
+class Client {
+  Client();
+  static Client fromEnv() => Client();
+}
+
+class Formatter {
+  String describe(Object value) => '';
+}
+
+class Loader {
+  int load() => 0;
+}
+
+class Report {
+  Report.empty();
+  static Report blank() => Report.empty();
+}
+
+class Box<T> {
+  const Box.named();
+  static Box<int> create() => const Box.named();
+}
+
+String describe(Object value) => 'legacy';
+int shown() => 0;
+`,
+  'lib/src/format.dart': `String describe(Object value) => '$value';
+
+class Report {
+  Report();
+  Report.empty();
+  static Report blank() => Report();
+}
+`,
+  'lib/src/tools.dart': `int secret() => 1;
+int open() => 2;
+`,
+  'lib/lazy.dart': `int load() => 1;
+`,
+  'packages/kit/pubspec.yaml': 'name: kit\n',
+  'packages/kit/lib/kit.dart': `export 'src/impl.dart' show shown, Widget, Box, named;
+`,
+  'packages/kit/lib/src/impl.dart': `int shown() => 1;
+int notShown() => 2;
+int named() => 3;
+
+class Widget {
+  Widget();
+}
+
+class Box<T> {
+  const Box.named();
+  static Box<int> create() => const Box.named();
+}
+`,
+  // package:http is not in the repository.
+  'lib/net.dart': `import 'package:http/http.dart' as http;
+
+Future<void> fetch() async {
+  await http.get(Uri.parse('https://example.com'));
+  http.Client();
+  http.Client.fromEnv();
+}
+`,
+  'lib/app.dart': `import 'package:kit/kit.dart' as kit;
+import 'src/format.dart' as fmt;
+import 'src/tools.dart' as tools hide secret;
+import 'lazy.dart' deferred as lazy;
+
+part 'app_part.dart';
+
+String run(Object value) {
+  fmt.Report();
+  fmt.Report.empty();
+  fmt.Report.blank();
+  kit.shown();
+  kit.notShown();
+  kit.Widget();
+  tools.open();
+  tools.secret();
+  final box = kit.Box<int>.named();
+  kit.Box.create();
+  const kit.Box.named();
+  return fmt.describe(value);
+}
+
+Future<int> boot() async {
+  await lazy.loadLibrary();
+  return lazy.load();
+}
+`,
+  'lib/app_part.dart': `part of 'app.dart';
+
+String again(Object value) => fmt.describe(value);
+`,
+  // A parameter named like the prefix is the parameter, there.
+  'lib/shadow.dart': `import 'package:http/http.dart' as http;
+import 'legacy.dart';
+
+Future<String> viaParameter(Http http) => http.get(Uri());
+`,
+};
+
+/** `<kind> <line> <ref name> -> <target file>:<target qualified name>` for every call out of `file`. */
+function callsFrom(cg: CodeGraph, file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${e.kind} ${e.line} ${String(e.metadata?.refName ?? '')} -> ${t.filePath}:${t.qualifiedName}`;
+    });
+}
+
+describe.each(['default', 'wasm'])('Dart calls through an import prefix (%s)', (backend) => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+  const calls = (file: string): string[] => callsFrom(cg!, file);
+
+  beforeAll(async () => {
+    kernel = process.env.CODEGRAPH_KERNEL;
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-prefix-'));
+    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 });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it('links nothing for a call into a package outside the repository', () => {
+    expect(calls('lib/net.dart')).toEqual([]);
+  });
+
+  it("links a call to the prefixed library's function, not a namesake or a method", () => {
+    expect(calls('lib/app.dart')).toContain('calls 20 fmt.describe -> lib/src/format.dart:describe');
+    expect(calls('lib/app.dart')).toContain('calls 25 lazy.load -> lib/lazy.dart:load');
+    expect(calls('lib/app_part.dart')).toEqual(['calls 3 fmt.describe -> lib/src/format.dart:describe']);
+  });
+
+  it('follows the export chain, show and hide of the prefixed import', () => {
+    const edges = calls('lib/app.dart');
+    expect(edges).toContain('calls 12 kit.shown -> packages/kit/lib/src/impl.dart:shown');
+    expect(edges).toContain('instantiates 14 kit.Widget -> packages/kit/lib/src/impl.dart:Widget');
+    expect(edges).toContain('calls 15 tools.open -> lib/src/tools.dart:open');
+    // Not shown by kit.dart, hidden from `tools`, the deferred library's own `loadLibrary`.
+    expect(edges.filter((e) => / (?:kit\.notShown|tools\.secret|lazy\.loadLibrary) /.test(e))).toEqual([]);
+  });
+
+  it("constructs and calls through the prefixed library's type", () => {
+    const edges = calls('lib/app.dart');
+    expect(edges).toContain('instantiates 9 fmt.Report -> lib/src/format.dart:Report');
+    expect(edges).toContain('calls 10 empty -> lib/src/format.dart:Report::empty');
+    expect(edges).toContain('calls 11 blank -> lib/src/format.dart:Report::blank');
+    expect(edges).toContain('calls 17 Box.named -> packages/kit/lib/src/impl.dart:Box::named');
+    expect(edges).toContain('calls 18 create -> packages/kit/lib/src/impl.dart:Box::create');
+  });
+
+  it('never lands a prefixed call on another library', () => {
+    expect(calls('lib/app.dart').filter((e) => e.includes('lib/legacy.dart'))).toEqual([]);
+    // `const kit.Box.named()` is no call of kit's top-level `named`.
+    expect(calls('lib/app.dart').filter((e) => e.startsWith('calls 19 '))).toEqual([]);
+  });
+
+  it('leaves a name a parameter shadows to the parameter', () => {
+    expect(calls('lib/shadow.dart')).toEqual(['calls 4 http.get -> lib/legacy.dart:Http::get']);
+  });
+});
diff --git a/__tests__/dart-import-uris.test.ts b/__tests__/dart-import-uris.test.ts
new file mode 100644
index 0000000000..62ed0396ab
--- /dev/null
+++ b/__tests__/dart-import-uris.test.ts
@@ -0,0 +1,200 @@
+/**
+ * A Dart `import` / `export` names a library by URI, and links the file the
+ * URI names or nothing. `package:<name>/<path>` is `<root>/lib/<path>` of the
+ * project package whose pubspec.yaml says `name: <name>`; any other URI is a
+ * path from the importing file; `dart:` and a package from outside the project
+ * name no project file. The URI's last path segment is not a file name to
+ * match: riverpod's `import 'package:flutter/foundation.dart'` went to its own
+ * packages/riverpod/lib/src/core/foundation.dart, bloc_tools'
+ * `package:args/command_runner.dart` to the importing file itself, and the
+ * import of an indexed project file went to the importing file's own `import`
+ * node, which says nothing.
+ */
+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';
+
+function writeTree(root: string, 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);
+  }
+}
+
+/** `<line> -> <target>` for every `imports` edge out of `file`: a file by its path, anything else by kind, file and name. */
+function importsFrom(cg: CodeGraph, file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids, ['imports'])
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${e.line} -> ${t.kind === 'file' ? t.filePath : `${t.kind} ${t.filePath}#${t.name}`}`;
+    })
+    .sort();
+}
+
+/** The URIs of `file`'s imports left unresolved. */
+function unresolvedImportsOf(cg: CodeGraph, file: string): string[] {
+  const fileNode = cg.getNodesInFile(file).find((n) => n.kind === 'file')!;
+  return cg.getUnresolvedReferencesFrom(fileNode.id)
+    .filter((r) => r.referenceKind === 'imports')
+    .map((r) => r.referenceName)
+    .sort();
+}
+
+describe('Dart import and export URIs', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-uris-'));
+    writeTree(root, {
+      // riverpod: an example app imports flutter's foundation.dart and the
+      // project's own riverpod package; riverpod has a foundation.dart too.
+      'packages/riverpod/pubspec.yaml': 'name: riverpod\n',
+      'packages/riverpod/lib/riverpod.dart': `export 'src/core/foundation.dart';
+export 'package:meta/meta.dart' show internal;
+`,
+      'packages/riverpod/lib/src/core/foundation.dart': `class ProviderBase {}
+`,
+      'packages/riverpod/lib/src/core/container.dart': `import 'dart:async';
+
+import 'package:meta/meta.dart';
+
+import 'foundation.dart';
+
+class Container extends ProviderBase {}
+`,
+      'examples/pub/pubspec.yaml': 'name: pub\n',
+      'examples/pub/lib/pub_repository.dart': `import 'package:flutter/foundation.dart';
+import 'package:riverpod/riverpod.dart';
+import 'package:riverpod/src/core/foundation.dart' as core;
+
+class PubRepository {}
+`,
+      // bloc_tools imports package:args' command_runner.dart from its own command_runner.dart.
+      'packages/bloc_tools/pubspec.yaml': 'name: bloc_tools\n',
+      'packages/bloc_tools/lib/src/command_runner.dart': `import 'package:args/command_runner.dart';
+
+class BlocToolsCommandRunner {}
+`,
+      // An integration test imports package:integration_test; a driver beside it is named integration_test.dart.
+      'examples/flutter_counter/pubspec.yaml': 'name: flutter_counter\n',
+      'examples/flutter_counter/integration_test/app_test.dart': `import 'package:integration_test/integration_test.dart';
+
+void main() {}
+`,
+      'examples/flutter_counter/test_driver/integration_test.dart': `import 'package:integration_test/integration_test_driver.dart';
+
+Future<void> main() async {}
+`,
+      // A relative import, and an old file with the same name.
+      'pubspec.yaml': 'name: app\n',
+      'test/src/utils.dart': `int errorsOf() => 0;
+`,
+      'test/old/utils.dart': `int errorsOf() => 0;
+`,
+      'test/feature/uni_directional_test.dart': `import '../src/utils.dart';
+
+void main() {}
+`,
+      // A translated copy of a docs page whose sibling was never translated.
+      'website/docs/cancel/detail_screen/codegen.dart': `class DetailScreen {}
+`,
+      'website/i18n/it/cancel/home_screen.dart': `import 'detail_screen/codegen.dart';
+
+class HomeScreen {}
+`,
+      // Two apps each keep a package named auth_repo, and each app's pubspec says which by path.
+      'examples/login_a/pubspec.yaml': `name: login_a
+dependencies:
+  auth_repo:
+    # the app's own copy
+    path: packages/auth_repo
+  bloc: ^9.0.0
+`,
+      'examples/login_a/packages/auth_repo/pubspec.yaml': 'name: auth_repo\n',
+      'examples/login_a/packages/auth_repo/lib/auth_repo.dart': `class AuthRepo {}
+`,
+      'examples/login_a/lib/app.dart': `import 'package:auth_repo/auth_repo.dart';
+
+class AppA {}
+`,
+      'examples/login_b/pubspec.yaml': `name: login_b
+dependencies:
+  auth_repo: { path: "packages/auth_repo" }
+`,
+      'examples/login_b/packages/auth_repo/pubspec.yaml': 'name: auth_repo\n',
+      'examples/login_b/packages/auth_repo/lib/auth_repo.dart': `class AuthRepo {}
+`,
+      'examples/login_b/lib/app.dart': `import 'package:auth_repo/auth_repo.dart';
+
+class AppB {}
+`,
+      // A third app says nothing about which auth_repo it means.
+      'examples/login_c/pubspec.yaml': 'name: login_c\n',
+      'examples/login_c/lib/app.dart': `import 'package:auth_repo/auth_repo.dart';
+
+class AppC {}
+`,
+      // Packages named example: each one's own package: imports mean itself.
+      'packages/a/example/pubspec.yaml': 'name: example\n',
+      'packages/a/example/lib/main.dart': `import 'package:example/src/screen.dart';
+
+void main() {}
+`,
+      'packages/a/example/lib/src/screen.dart': `class ScreenA {}
+`,
+      'packages/b/example/pubspec.yaml': 'name: example\n',
+      'packages/b/example/lib/src/screen.dart': `class ScreenB {}
+`,
+      // A package import of a file the project doesn't have (a generated file nobody committed).
+      'packages/riverpod/lib/src/missing_user.dart': `import 'package:riverpod/src/core/foundation.g.dart';
+import 'package:riverpod/src/missing_user.dart';
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("links an outside package's import to no project file of the same name", () => {
+    expect(importsFrom(cg, 'examples/pub/lib/pub_repository.dart')).toEqual([
+      '2 -> packages/riverpod/lib/riverpod.dart',
+      '3 -> packages/riverpod/lib/src/core/foundation.dart',
+    ]);
+    expect(unresolvedImportsOf(cg, 'examples/pub/lib/pub_repository.dart')).toEqual(['package:flutter/foundation.dart']);
+  });
+
+  it('never links a file to itself or a namesake for an outside package', () => {
+    expect(importsFrom(cg, 'packages/bloc_tools/lib/src/command_runner.dart')).toEqual([]);
+    expect(importsFrom(cg, 'examples/flutter_counter/integration_test/app_test.dart')).toEqual([]);
+    expect(importsFrom(cg, 'examples/flutter_counter/test_driver/integration_test.dart')).toEqual([]);
+  });
+
+  it('links a relative import and an export to the file they name, and dart: or outside packages to nothing', () => {
+    expect(importsFrom(cg, 'packages/riverpod/lib/src/core/container.dart')).toEqual([
+      '5 -> packages/riverpod/lib/src/core/foundation.dart',
+    ]);
+    expect(unresolvedImportsOf(cg, 'packages/riverpod/lib/src/core/container.dart')).toEqual(['dart:async', 'package:meta/meta.dart']);
+    expect(importsFrom(cg, 'packages/riverpod/lib/riverpod.dart')).toEqual(['1 -> packages/riverpod/lib/src/core/foundation.dart']);
+    expect(importsFrom(cg, 'test/feature/uni_directional_test.dart')).toEqual(['1 -> test/src/utils.dart']);
+  });
+
+  it('links nothing when the file a URI names is not in the project', () => {
+    expect(importsFrom(cg, 'website/i18n/it/cancel/home_screen.dart')).toEqual([]);
+    // Nor does a file's import of itself say anything.
+    expect(importsFrom(cg, 'packages/riverpod/lib/src/missing_user.dart')).toEqual([]);
+  });
+
+  it("tells same-named packages apart by the importing package's own name or its path dependency", () => {
+    expect(importsFrom(cg, 'examples/login_a/lib/app.dart')).toEqual(['1 -> examples/login_a/packages/auth_repo/lib/auth_repo.dart']);
+    expect(importsFrom(cg, 'examples/login_b/lib/app.dart')).toEqual(['1 -> examples/login_b/packages/auth_repo/lib/auth_repo.dart']);
+    expect(importsFrom(cg, 'examples/login_c/lib/app.dart')).toEqual([]);
+    expect(importsFrom(cg, 'packages/a/example/lib/main.dart')).toEqual(['1 -> packages/a/example/lib/src/screen.dart']);
+  });
+});
diff --git a/__tests__/dart-initializer-calls.test.ts b/__tests__/dart-initializer-calls.test.ts
new file mode 100644
index 0000000000..74c532aa90
--- /dev/null
+++ b/__tests__/dart-initializer-calls.test.ts
@@ -0,0 +1,245 @@
+/**
+ * Dart initializers are code: calls written in a top-level variable's or a
+ * field's initializer belong to the declaration.
+ *
+ * Both extractors skipped them. A `final`/`const` declaration minted its
+ * constant and stopped, and a field's or a `var`'s initializer only had its
+ * types recorded (#2327). So in a Riverpod app, where most wiring is written
+ * in provider closures — `final repoProvider = Provider((ref) =>
+ * Repository(ref.watch(dioProvider)));` — `Repository` and every function a
+ * provider builds with had no callers, and impact and flows stopped at the
+ * provider.
+ *
+ * A `final`/`const` initializer belongs to its constant. A field's or a
+ * `var`'s initializer belongs to its class or to the file, because Dart mints
+ * no node for those declarations.
+ *
+ * A call through a type's static constant — `Provider.autoDispose(…)` on
+ * `static const autoDispose = AutoDisposeProviderBuilder();` — calls that
+ * constant, not a same-named method another type declares.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'pubspec.yaml': 'name: app\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+  'lib/riverpod.dart': `class Ref {
+  T watch<T>(Object provider) => throw 0;
+  T read<T>(Object provider) => throw 0;
+}
+
+class Provider<T> {
+  Provider(T Function(Ref ref) create);
+
+  static const autoDispose = AutoDisposeProviderBuilder();
+}
+
+class AutoDisposeProviderBuilder {
+  const AutoDisposeProviderBuilder();
+
+  Provider<T> call<T>(T Function(Ref ref) create) => Provider(create);
+}
+
+class ProviderFamilyBuilder {
+  Object autoDispose() => this;
+}
+
+class StateNotifierProvider<N, S> {
+  StateNotifierProvider(N Function(Ref ref) create);
+}
+
+class FutureProvider<T> {
+  FutureProvider(Future<T> Function(Ref ref) create);
+
+  static const family = FutureProviderFamilyBuilder();
+}
+
+class FutureProviderFamilyBuilder {
+  const FutureProviderFamilyBuilder();
+
+  FutureProvider<T> call<T, A>(Future<T> Function(Ref ref, A arg) create) => throw 0;
+}
+`,
+  // A method named like `FutureProvider.family`, on another type in another file.
+  'lib/builders.dart': `class AutoDisposeFutureProviderBuilder {
+  Object family() => this;
+}
+`,
+  'lib/data.dart': `class Dio {}
+
+class Api {
+  Api(Dio dio);
+}
+
+class Repository {
+  Repository(Dio dio);
+}
+
+class Counter {
+  Counter(Api api);
+}
+
+Dio createDio() => Dio();
+void register(void Function() cb) {}
+int start() => 0;
+`,
+  // The usual Riverpod provider shapes, and the providers they read.
+  'lib/providers.dart': `import 'riverpod.dart';
+import 'data.dart';
+
+final dioProvider = Provider((ref) => createDio());
+final apiProvider = Provider((ref) => Api(ref.watch(dioProvider)));
+final repoProvider = Provider((ref) => Repository(ref.watch(dioProvider)));
+final counterProvider = StateNotifierProvider<Counter, int>((ref) => Counter(ref.read(apiProvider)));
+`,
+  'lib/more.dart': `import 'riverpod.dart';
+import 'data.dart';
+import 'providers.dart';
+
+final typedProvider = Provider((Ref ref) => ref.read(dioProvider));
+final blockProvider = Provider((ref) {
+  final dio = createDio();
+  return Repository(dio);
+});
+void onTap() {}
+final wired = register(onTap);
+var cache = createDio();
+late final lazyRepo = Repository(createDio());
+final autoProvider = Provider.autoDispose((ref) => createDio());
+final userProvider = FutureProvider.family((ref, int id) async => Api(createDio()));
+
+Provider<Dio> makeAuto() => Provider.autoDispose((ref) => Dio());
+
+class Service {
+  static final instance = Service._(createDio());
+  static var shared = Api(createDio());
+  final repo = Repository(Dio());
+  final Dio dio;
+  Service._(this.dio);
+
+  int run() {
+    var total = 0;
+    for (var i = 0, j = start(); i < j; i++) {
+      total += i;
+    }
+    return total;
+  }
+}
+`,
+};
+
+describe('Dart initializer calls', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-initializers-'));
+    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);
+    }
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('belong to the constant, class or file they initialize (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const node = (file: string, qualifiedName: string): Node => {
+      const found = graph.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName);
+      expect(found, `${file} ${qualifiedName}`).toBeDefined();
+      return found!;
+    };
+    const targets = (from: Node, kind: string): string[] =>
+      [...new Set(graph
+        .getOutgoingEdgesFrom([from.id])
+        .filter((e) => e.kind === kind)
+        .map((e) => graph.getNode(e.target)!.qualifiedName))]
+        .sort();
+    const sources = (to: Node, kind: string): string[] =>
+      [...new Set(graph
+        .getIncomingEdgesTo([to.id], [kind])
+        .map((e) => graph.getNode(e.source)!)
+        .map((n) => `${n.kind} ${n.qualifiedName}`))]
+        .sort();
+
+    // The issue's providers construct what they build and call what they build it with.
+    expect(targets(node('lib/providers.dart', 'dioProvider'), 'calls')).toEqual(['createDio']);
+    expect(targets(node('lib/providers.dart', 'apiProvider'), 'instantiates')).toEqual(['Api', 'Provider']);
+    expect(targets(node('lib/providers.dart', 'repoProvider'), 'instantiates')).toEqual(['Provider', 'Repository']);
+    expect(targets(node('lib/providers.dart', 'counterProvider'), 'instantiates')).toEqual(['Counter', 'StateNotifierProvider']);
+
+    // A typed closure parameter types its receiver; a block-bodied closure is walked whole.
+    expect(targets(node('lib/more.dart', 'typedProvider'), 'calls')).toEqual(['Ref::read']);
+    expect(targets(node('lib/more.dart', 'blockProvider'), 'calls')).toEqual(['createDio']);
+    expect(targets(node('lib/more.dart', 'blockProvider'), 'instantiates')).toEqual(['Provider', 'Repository']);
+
+    // A function passed as a value is the constant's reference, captured once.
+    expect(targets(node('lib/more.dart', 'wired'), 'calls')).toEqual(['register']);
+    expect(sources(node('lib/more.dart', 'onTap'), 'references')).toEqual(['constant wired']);
+
+    // `var` and `late final` mint no node: the file runs them.
+    const file = node('lib/more.dart', 'lib/more.dart');
+    expect(targets(file, 'calls')).toEqual(['createDio']);
+    expect(targets(file, 'instantiates')).toEqual(['Repository']);
+
+    // A `static final` is the class's constant; a `static var` and an instance
+    // field mint no node, so they are the class's.
+    expect(targets(node('lib/more.dart', 'Service::instance'), 'calls')).toEqual(['Service::_', 'createDio']);
+    const service = node('lib/more.dart', 'Service');
+    expect(targets(service, 'calls')).toEqual(['createDio']);
+    expect(targets(service, 'instantiates')).toEqual(['Api', 'Dio', 'Repository']);
+
+    // `Provider.autoDispose(…)` calls the static constant, whose own
+    // initializer constructs the builder — from a provider and from a body
+    // alike — and not a same-named method of another type, in its file or not.
+    const autoDispose = node('lib/riverpod.dart', 'Provider::autoDispose');
+    expect(autoDispose.kind).toBe('constant');
+    expect(targets(node('lib/more.dart', 'autoProvider'), 'calls')).toEqual(['Provider::autoDispose', 'createDio']);
+    expect(targets(node('lib/more.dart', 'makeAuto'), 'calls')).toEqual(['Provider::autoDispose']);
+    expect(targets(autoDispose, 'instantiates')).toEqual(['AutoDisposeProviderBuilder']);
+    expect(sources(node('lib/riverpod.dart', 'ProviderFamilyBuilder::autoDispose'), 'calls')).toEqual([]);
+    expect(targets(node('lib/more.dart', 'userProvider'), 'calls')).toEqual(['FutureProvider::family', 'createDio']);
+    expect(sources(node('lib/builders.dart', 'AutoDisposeFutureProviderBuilder::family'), 'calls')).toEqual([]);
+
+    // Each provider and declaration above is a caller of what it builds.
+    expect(sources(node('lib/data.dart', 'createDio'), 'calls')).toEqual([
+      'class Service',
+      'constant Service::instance',
+      'constant autoProvider',
+      'constant blockProvider',
+      'constant dioProvider',
+      'constant userProvider',
+      'file lib/more.dart',
+    ]);
+    expect(sources(node('lib/data.dart', 'Repository'), 'instantiates')).toEqual([
+      'class Service',
+      'constant blockProvider',
+      'constant repoProvider',
+      'file lib/more.dart',
+    ]);
+
+    // A local declaration's second variable is its function's, once.
+    const run = node('lib/more.dart', 'Service::run');
+    expect(targets(run, 'calls')).toEqual(['start']);
+    expect(graph.getOutgoingEdgesFrom([run.id]).filter((e) => e.kind === 'calls')).toHaveLength(1);
+    expect(sources(node('lib/data.dart', 'start'), 'calls')).toEqual(['method Service::run']);
+  });
+});
diff --git a/__tests__/dart-library-visibility.test.ts b/__tests__/dart-library-visibility.test.ts
new file mode 100644
index 0000000000..f171430ce3
--- /dev/null
+++ b/__tests__/dart-library-visibility.test.ts
@@ -0,0 +1,344 @@
+/**
+ * A Dart name written without a receiver — a call, a type — means a
+ * declaration its library can see: its own (the file and its `part`s), or one
+ * a library it imports without a prefix exports, through `export` chains and
+ * `show` / `hide`. riverpod's generated `async.g.dart` (`part of
+ * 'async.dart'`) called the `family(…)` async.dart declares, and the call went
+ * to the `family` of annotated.dart beside it; a test's `fakeAsync(…)` from
+ * package:fake_async went to a vendored copy nobody imports.
+ */
+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';
+import { readDartDirectives } from '../src/resolution/dart-libraries';
+
+function writeTree(root: string, 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);
+  }
+}
+
+/** `<kind> <line> <name> -> <target file>:<target qualified name>` for every edge out of `file`. */
+function edgesFrom(cg: CodeGraph, file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind !== 'contains')
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${e.kind} ${e.line} ${String(e.metadata?.refName ?? '')} -> ${t.filePath}:${t.qualifiedName}`;
+    });
+}
+
+describe('Dart library visibility', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-libs-'));
+    writeTree(root, {
+      'pubspec.yaml': 'name: app\n',
+      // Generated parts call and name their own library's declarations; a
+      // library beside them declares the same names.
+      'test/integration/annotated.dart': `part 'annotated.g.dart';
+
+String family(Object ref, int id) => 'family $id';
+`,
+      'test/integration/annotated.g.dart': `part of 'annotated.dart';
+
+String annotatedGenerated(Object ref) => family(ref, 1);
+`,
+      'test/integration/async.dart': `import 'dart:async';
+
+part 'async.g.dart';
+
+Future<String> family(Object ref, int first) async => '$first';
+
+class GenericClass {}
+`,
+      'test/integration/async.g.dart': `part of 'async.dart';
+
+Future<String> asyncGenerated(Object ref) {
+  return family(ref, 2);
+}
+
+final GenericClass generic = GenericClass();
+`,
+      'test/integration/annotated_types.dart': `class GenericClass {}
+`,
+      // package:fake_async's function, and a vendored copy no file imports.
+      'test/third_party/fake_async.dart': `T fakeAsync<T>(T Function(Object async) callback) => callback(Object());
+`,
+      'test/src/core/devtool_test.dart': `import 'package:fake_async/fake_async.dart';
+
+void main() {
+  fakeAsync((async) {});
+}
+`,
+      // A test imports one utils library; an old copy declares the same function.
+      'test/old/utils.dart': `List<Object> errorsOf(void Function() cb) => [];
+`,
+      'test/src/utils.dart': `List<Object> errorsOf(void Function() cb) => [];
+`,
+      'test/feature/uni_directional_test.dart': `import '../src/utils.dart';
+
+void main() {
+  errorsOf(() {});
+}
+`,
+      // A package whose barrel exports with combinators; a prefixed import; a hidden name.
+      'packages/kit/pubspec.yaml': 'name: kit\n',
+      'packages/kit/lib/kit.dart': `export 'src/impl.dart'
+    show
+        // the public API
+        shown,
+        Widget;
+export 'src/cond_stub.dart' if (dart.library.io) 'src/cond_io.dart';
+`,
+      'packages/kit/lib/src/impl.dart': `int shown() => 1;
+int notShown() => 2;
+class Widget {}
+`,
+      'packages/kit/lib/src/cond_stub.dart': `int platformName() => 0;
+`,
+      'packages/kit/lib/src/cond_io.dart': `int platformName() => 1;
+`,
+      'packages/kit/lib/src/prefixed.dart': `int viaPrefix() => 3;
+class Report {}
+`,
+      'packages/kit/lib/src/hidden.dart': `int hiddenOne() => 4;
+int keptOne() => 5;
+`,
+      'lib/main.dart': `import 'package:kit/kit.dart';
+import 'package:kit/src/prefixed.dart' as p;
+import 'package:kit/src/hidden.dart' hide hiddenOne;
+
+void run(p.Report report) {
+  shown();
+  notShown();
+  platformName();
+  viaPrefix();
+  hiddenOne();
+  keptOne();
+  Widget();
+}
+`,
+      // Another library's Report, which main.dart does not import.
+      'lib/a_report.dart': `class Report {}
+`,
+      // A part declared by library name, and a namesake in another library.
+      'lib/named.dart': `library app.named;
+
+part 'named_part.dart';
+
+int namedHelper() => 6;
+`,
+      'lib/named_part.dart': `part of app.named;
+
+int usesNamed() => namedHelper();
+`,
+      'lib/other_named.dart': `int namedHelper() => 7;
+`,
+      // A library's own declaration shadows the one it imports.
+      'lib/a_util.dart': `int helper() => 1;
+`,
+      'lib/feature.dart': `import 'a_util.dart';
+
+part 'feature_part.dart';
+
+int runFeature() => helper();
+`,
+      'lib/feature_part.dart': `part of 'feature.dart';
+
+int helper() => 2;
+`,
+      // A bare call never reaches another type's enum constant or static constant.
+      'lib/kinds.dart': `enum Level { info, warning }
+
+class TypeChecker {
+  static const allOf = 'any';
+}
+`,
+      'lib/check.dart': `import 'package:mason_logger/mason_logger.dart';
+import 'package:matcher/matcher.dart';
+
+void check(Object value) {
+  info('checking');
+  expect(value, allOf([isNotNull]));
+}
+`,
+      // An unnamed extension on Color is no Color.
+      'lib/colors.dart': `import 'package:flutter/material.dart';
+
+extension on Color {
+  Color brighten() => this;
+}
+`,
+      // Nor is a generic one, beside the file that names the type.
+      'lib/models/box.dart': `class Box<T> {
+  T? value;
+}
+`,
+      'lib/widgets/box_ext.dart': `import '../models/box.dart';
+
+extension<T> on Box<T> {
+  bool get isEmpty => value == null;
+}
+`,
+      'lib/widgets/panel.dart': `import '../models/box.dart';
+import 'box_ext.dart';
+
+class Panel {
+  final Box<int> box;
+  Panel(this.box);
+}
+`,
+      // An unnamed extension applies in every file of its library.
+      'lib/shapes/shapes.dart': `part 'area_ext.dart';
+part 'use.dart';
+
+class Shape {}
+`,
+      'lib/shapes/area_ext.dart': `part of 'shapes.dart';
+
+extension on Shape {
+  int area() => 1;
+}
+`,
+      'lib/shapes/use.dart': `part of 'shapes.dart';
+
+int total(Shape s) => s.area();
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("links a generated part's call to its own library's function", () => {
+    const edges = edgesFrom(cg, 'test/integration/async.g.dart');
+    expect(edges).toContain('calls 4 family -> test/integration/async.dart:family');
+    expect(edges.filter((e) => e.includes('annotated'))).toEqual([]);
+  });
+
+  it("links a generated part's type to its own library's type", () => {
+    const edges = edgesFrom(cg, 'test/integration/async.g.dart').filter((e) => e.includes('GenericClass'));
+    expect(edges.length).toBeGreaterThan(0);
+    expect(edges.every((e) => e.endsWith('test/integration/async.dart:GenericClass'))).toBe(true);
+  });
+
+  it('links nothing for a function no imported library declares', () => {
+    expect(edgesFrom(cg, 'test/src/core/devtool_test.dart').filter((e) => e.includes('fakeAsync'))).toEqual([]);
+  });
+
+  it('links the imported library over a namesake no import names', () => {
+    expect(edgesFrom(cg, 'test/feature/uni_directional_test.dart')).toContain('calls 4 errorsOf -> test/src/utils.dart:errorsOf');
+  });
+
+  it('follows export chains, show, hide and import prefixes', () => {
+    const edges = edgesFrom(cg, 'lib/main.dart');
+    expect(edges).toContain('calls 6 shown -> packages/kit/lib/src/impl.dart:shown');
+    expect(edges).toContain('calls 11 keptOne -> packages/kit/lib/src/hidden.dart:keptOne');
+    expect(edges.some((e) => e.startsWith('instantiates 12 Widget -> packages/kit/lib/src/impl.dart:Widget'))).toBe(true);
+    expect(edges.some((e) => / platformName -> packages\/kit\/lib\/src\/cond_(?:stub|io)\.dart:platformName$/.test(e))).toBe(true);
+    // Not shown, only reachable through the prefix, hidden.
+    expect(edges.filter((e) => / (?:notShown|viaPrefix|hiddenOne) /.test(e))).toEqual([]);
+    // `p.Report` is the prefixed library's.
+    expect(edges.filter((e) => e.includes(' Report '))).toEqual(['references 5 Report -> packages/kit/lib/src/prefixed.dart:Report']);
+  });
+
+  it('finds the library a part names by library name', () => {
+    expect(edgesFrom(cg, 'lib/named_part.dart')).toContain('calls 3 namedHelper -> lib/named.dart:namedHelper');
+  });
+
+  it("prefers the library's own declaration to an imported one", () => {
+    expect(edgesFrom(cg, 'lib/feature.dart').filter((e) => e.includes('helper'))).toEqual(['calls 5 helper -> lib/feature_part.dart:helper']);
+  });
+
+  it("never reaches another type's enum constant or static constant by a bare call", () => {
+    expect(edgesFrom(cg, 'lib/check.dart').filter((e) => !e.startsWith('imports '))).toEqual([]);
+  });
+
+  it('never takes an unnamed extension for the type it extends', () => {
+    expect(edgesFrom(cg, 'lib/colors.dart').filter((e) => e.includes('Color'))).toEqual([]);
+    expect(edgesFrom(cg, 'lib/widgets/panel.dart').filter((e) => e.includes(' Box '))).toEqual(['references 5 Box -> lib/models/box.dart:Box']);
+  });
+
+  it("applies an unnamed extension in every file of its library", () => {
+    expect(edgesFrom(cg, 'lib/shapes/use.dart').some((e) => e.endsWith('-> lib/shapes/area_ext.dart:Shape::area'))).toBe(true);
+  });
+});
+
+describe('Dart files outside any package', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-nopkg-'));
+    // A mason brick's template: no pubspec.yaml says what its imports mean.
+    writeTree(root, {
+      'bricks/feature/__brick__/helper.dart': `int helper() => 1;
+`,
+      'bricks/feature/__brick__/page.dart': `import 'package:{{name}}/helper.dart';
+
+int page() => helper();
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('are resolved as before, by name', () => {
+    expect(edgesFrom(cg, 'bricks/feature/__brick__/page.dart')).toContain('calls 3 helper -> bricks/feature/__brick__/helper.dart:helper');
+  });
+});
+
+describe('readDartDirectives', () => {
+  it('reads every directive up to the first declaration', () => {
+    const d = readDartDirectives(`// Copyright
+@TestOn('vm')
+library app.main;
+
+import 'dart:async';
+import 'package:kit/kit.dart' show A, B hide B;
+import 'stub.dart' if (dart.library.io) 'io.dart' if (dart.library.js_interop == 'true') 'web.dart';
+import 'lazy.dart' deferred as lazy;
+export 'src/a.dart'
+    show
+        // one
+        One,
+        Two;
+part 'main.g.dart';
+
+void main() {}
+import 'late.dart';
+`);
+    expect(d.libraryName).toBe('app.main');
+    expect(d.partOf).toBeNull();
+    expect(d.parts).toEqual(['main.g.dart']);
+    expect(d.imports.map((i) => i.uris)).toEqual([['dart:async'], ['package:kit/kit.dart'], ['stub.dart', 'io.dart', 'web.dart'], ['lazy.dart']]);
+    expect(d.imports.map((i) => i.prefix)).toEqual([null, null, null, 'lazy']);
+    expect([...d.imports[1]!.filter.show!]).toEqual(['A', 'B']);
+    expect([...d.imports[1]!.filter.hide!]).toEqual(['B']);
+    expect(d.exports.map((e) => [e.uris, [...(e.filter.show ?? [])]])).toEqual([[['src/a.dart'], ['One', 'Two']]]);
+  });
+
+  it('reads `part of` by URI and by library name, and an unnamed library', () => {
+    expect(readDartDirectives(`part of 'async.dart';\n`).partOf).toEqual({ uri: 'async.dart' });
+    expect(readDartDirectives(`part of app.named;\n`).partOf).toEqual({ name: 'app.named' });
+    expect(readDartDirectives(`/// Docs\nlibrary;\n\nimport 'a.dart';\n`)).toMatchObject({ libraryName: '', imports: [{ uris: ['a.dart'] }] });
+  });
+
+  it('stops at a declaration that looks like a directive', () => {
+    expect(readDartDirectives(`import 'a.dart';\npart() => 1;\nimport 'b.dart';\n`).imports.map((i) => i.uris[0])).toEqual(['a.dart']);
+  });
+});
diff --git a/__tests__/dart-local-call-scope.test.ts b/__tests__/dart-local-call-scope.test.ts
new file mode 100644
index 0000000000..7dec2813ef
--- /dev/null
+++ b/__tests__/dart-local-call-scope.test.ts
@@ -0,0 +1,248 @@
+/**
+ * A bare Dart call to a name a parameter or local around it binds calls that
+ * parameter or local — never a same-named symbol elsewhere.
+ *
+ * riverpod's `overrideWith(CreatedT Function(Ref ref, ArgT arg) create)` calls
+ * its parameter (`create(ref, arg)`), as do its tests' provider factories and
+ * an analyzer cache's `upsert(key, create)`. All of them were linked to a docs
+ * example's top-level `final create = Mutation<…>()` that none of them import.
+ * Tests' mocks (`final listener = Listener<int>(); listener(0, 1)`) went to
+ * other test files' `listener` functions, and bloc's event handlers' `emit`
+ * parameter (`on<E>((event, emit) => emit(…))`) to `Bloc.emit`, which a
+ * handler never calls. None of those bindings is a node, so such a call links
+ * nothing. A call the binding does not cover still links.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'pubspec.yaml': 'name: app\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+  // The docs example nobody imports: the only top-level `create`.
+  'doc/mutation.dart': `class Mutation<T> {
+  Object call(String key) => key;
+}
+
+final create = Mutation<Object>();
+final createTodo = create('create_todo');
+`,
+  'lib/family.dart': `class Ref {}
+
+class Override {
+  Override(Object Function(Ref ref) build);
+}
+
+mixin FunctionalFamilyOverride<CreatedT, ArgT> {
+  ArgT get argument => throw 0;
+
+  Override overrideWith(CreatedT Function(Ref ref, ArgT arg) create) {
+    return Override((ref) => create(ref, argument) as Object);
+  }
+}
+
+class Cache<T> {
+  final _values = <Object, T>{};
+
+  T upsert(Object key, T Function() create) {
+    final existing = _values[key];
+    if (existing != null) return existing;
+    final created = create();
+    _values[key] = created;
+    return created;
+  }
+}
+
+class Holder {
+  void create() {}
+
+  void run(void Function() create) {
+    this.create();
+    create();
+  }
+}
+
+enum Kind { set, list }
+
+R pick<R>({required R Function() set, required R Function() list}) => set();
+
+class Box {}
+
+Box? find() => null;
+
+void check() {
+  final Box? box = find();
+  print(box);
+  Box();
+}
+`,
+  'test/matrix.dart': `typedef Factory = Object Function(Object Function(Object ref, Object? arg) create, {String? name});
+
+final factories = <Factory>[
+  (create, {name}) => create(Object(), name),
+];
+
+final generic = <T>(T Function() create) => create();
+`,
+  // Another test's function of the same name as the mock below.
+  'test/other_test.dart': `void listener() {}
+
+void fn() {}
+`,
+  'test/listener_test.dart': `class Listener<T> {
+  void call(T? previous, T next) {}
+}
+
+void main() {
+  final listener = Listener<int>();
+  listener(0, 1);
+
+  void Function() build = () {};
+  build();
+
+  for (final fn in <void Function()>[]) {
+    fn();
+  }
+
+  final (create, _) = (() => 0, 1);
+  create();
+}
+`,
+  'lib/bloc.dart': `abstract class Emitter<S> {
+  void call(S state);
+}
+
+class Bloc<S> {
+  void emit(S state) {}
+
+  void on<E>(void Function(E event, Emitter<S> emit) handler) {}
+}
+
+class CounterBloc extends Bloc<int> {
+  CounterBloc() {
+    on<String>((event, emit) => emit(1));
+  }
+
+  void onReset(String event, Emitter<int> emit) {
+    emit(0);
+  }
+
+  void bump() => emit(2);
+}
+`,
+  'lib/util.dart': `void notify(int value) {}
+`,
+  // Calls a closure parameter or a loop variable does not cover, and a local
+  // function nearer than the parameter it shadows.
+  'lib/wire.dart': `import 'util.dart';
+
+void wire(List<int> values) {
+  values.forEach((notify) => print(notify));
+  notify(1);
+  for (final notify in values) {
+    print(notify);
+  }
+  notify(2);
+}
+
+int outer(int Function() make) {
+  int helper() {
+    int make() => 2;
+    return make();
+  }
+
+  return helper() + make();
+}
+`,
+};
+
+describe('Dart calls to a parameter or local', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-local-calls-'));
+    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);
+    }
+    kernel = process.env.CODEGRAPH_KERNEL;
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  it.each(['default', 'wasm'])('link nothing, and leave the calls they do not cover alone (%s)', async (backend) => {
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    cg = await CodeGraph.init(root, { index: true });
+    const graph = cg;
+    const node = (file: string, qualifiedName: string): Node => {
+      const found = graph.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName);
+      expect(found, `${file} ${qualifiedName}`).toBeDefined();
+      return found!;
+    };
+    /** `qualifiedName:line` of each call (or construction) out of a node. */
+    const calls = (from: Node): string[] =>
+      graph
+        .getOutgoingEdgesFrom([from.id])
+        .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+        .map((e) => `${graph.getNode(e.target)!.qualifiedName}:${e.line}`)
+        .sort();
+    /** The line of `file` that holds `text`. */
+    const lineOf = (file: string, text: string): number => FILES[file]!.split('\n').findIndex((l) => l.includes(text)) + 1;
+
+    // Only the docs example's own file calls into it (a call through its
+    // `create` constant constructs the `Mutation` the constant holds).
+    const docs = graph.getNodesInFile('doc/mutation.dart').map((n) => n.id);
+    expect([...new Set(graph.getIncomingEdgesTo(docs, ['calls', 'instantiates']).map((e) => graph.getNode(e.source)!.filePath))])
+      .toEqual(['doc/mutation.dart']);
+
+    // A parameter: a method's, a function-typed one inside a closure, closures' in initializers.
+    expect(calls(node('lib/family.dart', 'FunctionalFamilyOverride::overrideWith')))
+      .toEqual([`Override:${lineOf('lib/family.dart', 'create(ref, argument)')}`]);
+    expect(calls(node('lib/family.dart', 'Cache::upsert'))).toEqual([]);
+    // (a parameter may be named `set`, which is no enum's member here)
+    expect(calls(node('lib/family.dart', 'pick'))).toEqual([]);
+    expect(calls(node('test/matrix.dart', 'factories'))).toEqual([]);
+    expect(calls(node('test/matrix.dart', 'generic'))).toEqual([]);
+
+    // A parameter shadows a method of the class, which `this.` still reaches.
+    expect(calls(node('lib/family.dart', 'Holder::run')))
+      .toEqual([`Holder::create:${lineOf('lib/family.dart', 'this.create();')}`]);
+
+    // A local: a mock, a function-typed variable, a loop variable, a destructured one.
+    expect(calls(node('test/listener_test.dart', 'main')))
+      .toEqual([`Listener:${lineOf('test/listener_test.dart', 'Listener<int>()')}`]);
+    const otherTest = graph.getNodesInFile('test/other_test.dart').map((n) => n.id);
+    expect(graph.getIncomingEdgesTo(otherTest, ['calls'])).toEqual([]);
+
+    // A handler's `Emitter` parameter is not `Bloc.emit`; a bare call of the inherited method is.
+    expect(calls(node('lib/bloc.dart', 'CounterBloc'))).toEqual([`Bloc::on:${lineOf('lib/bloc.dart', 'on<String>')}`]);
+    expect(calls(node('lib/bloc.dart', 'CounterBloc::onReset'))).toEqual([]);
+    expect(calls(node('lib/bloc.dart', 'CounterBloc::bump'))).toEqual([`Bloc::emit:${lineOf('lib/bloc.dart', 'emit(2)')}`]);
+
+    // A sibling closure's parameter and a finished loop's variable cover nothing after them.
+    expect(calls(node('lib/wire.dart', 'wire')))
+      .toEqual([`notify:${lineOf('lib/wire.dart', 'notify(1)')}`, `notify:${lineOf('lib/wire.dart', 'notify(2)')}`]);
+
+    // A local function is nearer than the parameter it shadows, inside its block only.
+    expect(calls(node('lib/wire.dart', 'helper'))).toEqual([`make:${lineOf('lib/wire.dart', 'return make()')}`]);
+    expect(calls(node('lib/wire.dart', 'outer'))).not.toContain(`make:${lineOf('lib/wire.dart', 'helper() + make()')}`);
+
+    // A nullable typed local's type is not a binding: `Box()` still constructs `Box`.
+    expect(calls(node('lib/family.dart', 'check')))
+      .toEqual([`Box:${lineOf('lib/family.dart', '  Box();')}`, `find:${lineOf('lib/family.dart', '= find()')}`]);
+  });
+});
diff --git a/__tests__/dart-part-directives.test.ts b/__tests__/dart-part-directives.test.ts
new file mode 100644
index 0000000000..66429f7f27
--- /dev/null
+++ b/__tests__/dart-part-directives.test.ts
@@ -0,0 +1,216 @@
+/**
+ * A Dart library names each of its parts with `part '<uri>';`, and that links
+ * the library's file to the part's: an `imports` edge, by the URI rules an
+ * import or export follows. A part and its library are one library, so a
+ * change to the part is a change to what every importer of the library sees.
+ * Before, neither `part` nor `part of` left a trace, and the two files were
+ * joined only by whatever symbol edges happened to cross between them —
+ * riverpod's framework.dart, which holds nothing but its parts, by none, so a
+ * change to one of them reached no test that imports riverpod. `part of`
+ * still adds nothing: the library's edge already joins the two files.
+ */
+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';
+import { buildFile } from '../src/ui-server/api/file';
+
+function writeTree(root: string, 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);
+  }
+}
+
+/** `<line> -> <target>` for every `imports` edge out of `file`: a file by its path, anything else by kind, file and name. */
+function importsFrom(cg: CodeGraph, file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids, ['imports'])
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${e.line} -> ${t.kind === 'file' ? t.filePath : `${t.kind} ${t.filePath}#${t.name}`}`;
+    })
+    .sort();
+}
+
+/** The URIs of `file`'s imports left unresolved. */
+function unresolvedImportsOf(cg: CodeGraph, file: string): string[] {
+  const fileNode = cg.getNodesInFile(file).find((n) => n.kind === 'file')!;
+  return cg.getUnresolvedReferencesFrom(fileNode.id)
+    .filter((r) => r.referenceKind === 'imports')
+    .map((r) => r.referenceName)
+    .sort();
+}
+
+/** `<name> | <signature>` of each `import` node in `file`. */
+function importNodesIn(cg: CodeGraph, file: string): string[] {
+  return cg.getNodesInFile(file)
+    .filter((n) => n.kind === 'import')
+    .map((n) => `${n.name} | ${n.signature}`)
+    .sort();
+}
+
+/** Every file a change to `file` reaches through its dependents, as `codegraph affected` walks them. */
+function reachedFrom(cg: CodeGraph, file: string): string[] {
+  const seen = new Set([file]);
+  const queue = [file];
+  while (queue.length > 0) {
+    for (const dependent of cg.getFileDependents(queue.shift()!)) {
+      if (seen.has(dependent)) continue;
+      seen.add(dependent);
+      queue.push(dependent);
+    }
+  }
+  seen.delete(file);
+  return [...seen].sort();
+}
+
+describe('Dart part directives', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-parts-'));
+    writeTree(root, {
+      // riverpod's framework.dart: a library made of nothing but its parts,
+      // one in a subdirectory, one generated; a barrel exports it and a test
+      // imports the barrel.
+      'pubspec.yaml': 'name: app\n',
+      'lib/src/framework.dart': `import 'dart:async';
+
+import 'package:meta/meta.dart';
+
+part 'core/element.dart';
+part "core/container.dart";
+part 'framework.g.dart';
+`,
+      'lib/src/core/element.dart': `part of '../framework.dart';
+
+class Element {}
+`,
+      'lib/src/core/container.dart': `part of '../framework.dart';
+
+class Container {}
+`,
+      'lib/src/framework.g.dart': `// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'framework.dart';
+
+String _$frameworkHash() => 'abc';
+`,
+      'lib/app.dart': `export 'src/framework.dart';
+`,
+      'test/framework_test.dart': `import 'package:app/app.dart';
+
+void main() {}
+`,
+      // A part named by a package: URI, and a part of a library named by its library name.
+      'packages/kit/pubspec.yaml': 'name: kit\n',
+      'packages/kit/lib/kit.dart': `part 'package:kit/src/widgets.dart';
+`,
+      'packages/kit/lib/src/widgets.dart': `part of 'package:kit/kit.dart';
+
+class Widget {}
+`,
+      'lib/legacy/models.dart': `library app.models;
+
+part 'user.dart';
+`,
+      'lib/legacy/user.dart': `part of app.models;
+
+class User {}
+`,
+      // A generated part nobody committed, and another app's file of that name.
+      'examples/a/pubspec.yaml': 'name: a\n',
+      'examples/a/lib/main.dart': `part 'main.g.dart';
+
+void main() {}
+`,
+      'examples/b/pubspec.yaml': 'name: b\n',
+      'examples/b/lib/main.dart': `part 'main.g.dart';
+
+void main() {}
+`,
+      'examples/b/lib/main.g.dart': `part of 'main.dart';
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('links a library to each part it names, as an import node and an imports edge', () => {
+    expect(importsFrom(cg, 'lib/src/framework.dart')).toEqual([
+      '5 -> lib/src/core/element.dart',
+      '6 -> lib/src/core/container.dart',
+      '7 -> lib/src/framework.g.dart',
+    ]);
+    expect(unresolvedImportsOf(cg, 'lib/src/framework.dart')).toEqual(['dart:async', 'package:meta/meta.dart']);
+    expect(importNodesIn(cg, 'lib/src/framework.dart')).toEqual([
+      'core/container.dart | part "core/container.dart";',
+      'core/element.dart | part \'core/element.dart\';',
+      'dart:async | import \'dart:async\';',
+      'framework.g.dart | part \'framework.g.dart\';',
+      'package:meta/meta.dart | import \'package:meta/meta.dart\';',
+    ]);
+  });
+
+  it('resolves a part named by a package: URI or under a library name', () => {
+    expect(importsFrom(cg, 'packages/kit/lib/kit.dart')).toEqual(['1 -> packages/kit/lib/src/widgets.dart']);
+    expect(importsFrom(cg, 'lib/legacy/models.dart')).toEqual(['3 -> lib/legacy/user.dart']);
+  });
+
+  it('records nothing for `part of`', () => {
+    for (const part of ['lib/src/core/element.dart', 'lib/src/framework.g.dart', 'packages/kit/lib/src/widgets.dart', 'lib/legacy/user.dart']) {
+      expect(importsFrom(cg, part), part).toEqual([]);
+      expect(unresolvedImportsOf(cg, part), part).toEqual([]);
+      expect(importNodesIn(cg, part), part).toEqual([]);
+    }
+  });
+
+  it("leaves a part the project doesn't have unresolved, never another file of its name", () => {
+    expect(importsFrom(cg, 'examples/a/lib/main.dart')).toEqual([]);
+    expect(unresolvedImportsOf(cg, 'examples/a/lib/main.dart')).toEqual(['main.g.dart']);
+    expect(importsFrom(cg, 'examples/b/lib/main.dart')).toEqual(['1 -> examples/b/lib/main.g.dart']);
+  });
+
+  it('makes a change to a part reach what depends on its library', () => {
+    expect(cg.getFileDependents('lib/src/core/element.dart')).toEqual(['lib/src/framework.dart']);
+    expect(cg.getFileDependencies('lib/src/framework.dart').sort()).toEqual([
+      'lib/src/core/container.dart',
+      'lib/src/core/element.dart',
+      'lib/src/framework.g.dart',
+    ]);
+    expect(reachedFrom(cg, 'lib/src/core/element.dart')).toEqual([
+      'lib/app.dart',
+      'lib/src/framework.dart',
+      'test/framework_test.dart',
+    ]);
+  });
+
+  it("shows the parts on the library's import rail and the library on each part's", () => {
+    const library = buildFile(cg, root, 'lib/src/framework.dart') as {
+      imports: { items: Array<{ file: string }> };
+      dependencies: string[];
+    };
+    expect(library.imports.items.map((row) => row.file).sort()).toEqual([
+      'lib/src/core/container.dart',
+      'lib/src/core/element.dart',
+      'lib/src/framework.g.dart',
+    ]);
+    const part = buildFile(cg, root, 'lib/src/framework.g.dart') as {
+      imports: { items: unknown[] };
+      importedBy: { items: Array<{ file: string }> };
+      unresolvedImports: unknown[];
+      dependents: string[];
+    };
+    expect(part.importedBy.items.map((row) => row.file)).toEqual(['lib/src/framework.dart']);
+    expect(part.imports.items).toEqual([]);
+    expect(part.unresolvedImports).toEqual([]);
+    expect(part.dependents).toEqual(['lib/src/framework.dart']);
+  });
+});
diff --git a/__tests__/dart-type-positions.test.ts b/__tests__/dart-type-positions.test.ts
new file mode 100644
index 0000000000..5eb6401c55
--- /dev/null
+++ b/__tests__/dart-type-positions.test.ts
@@ -0,0 +1,127 @@
+/**
+ * Dart type positions that recorded no reference (#2327).
+ *
+ * `callers` / impact for a Dart type only saw parameter and return types: the
+ * type an extension is `on`, a field's type, and a type named in a body or an
+ * initializer (`Future<Report?>.value(null)`, riverpod's `final p =
+ * Family<Report?, String>()`) linked nothing, so model-to-UI impact missed
+ * most uses of shared API types.
+ */
+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-dart-types-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: repro\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+    // The issue's six files, verbatim.
+    'lib/report.dart': 'class Report {\n  final int score;\n  const Report(this.score);\n}\n',
+    'lib/a_parameter.dart': "import 'report.dart';\n\nint score(Report r) => r.score;\n",
+    'lib/b_return_generic.dart': "import 'report.dart';\n\nFuture<Report?> load() async => null;\n",
+    'lib/c_extension_on.dart': "import 'report.dart';\n\nextension ReportX on Report {\n  bool get high => score > 5;\n}\n",
+    'lib/d_field_type.dart': "import 'report.dart';\n\nclass Holder {\n  final Report report;\n  const Holder(this.report);\n}\n",
+    'lib/e_toplevel_initializer_generic.dart': "import 'report.dart';\n\nclass Family<T, A> {\n  const Family();\n}\n\nfinal reportProvider = Family<Report?, String>();\n",
+    'lib/f_expression_generic.dart': "import 'report.dart';\n\nvoid run() {\n  Future<Report?>.value(null);\n}\n",
+    // The same gap's other shapes.
+    'lib/model.dart': `class Score {
+  const Score(this.value);
+  final int value;
+}
+
+class ScoreError implements Exception {}
+`,
+    'lib/more.dart': `import 'model.dart' as m;
+import 'model.dart';
+
+extension ScoresX on List<Score> {
+  int get total => length;
+}
+
+enum Grade {
+  a(null);
+  const Grade(this.best);
+  final Score? best;
+}
+
+class Board {
+  Score? top;
+  final List<Score> all = [];
+  static const Score zero = Score(0);
+  var cache = <String, Score>{};
+  late final m.Score prefixed;
+}
+
+Score? current;
+final scores = <Score>[];
+
+int body(Object o) {
+  final Score s = o as Score;
+  if (o is Score) {}
+  final made = Score(1);
+  final built = const Score(2);
+  try {} on ScoreError catch (_) {}
+  return s.value + made.value + built.value;
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `kind qualifiedName` of each node with an incoming `kind` edge to `qn`, sorted and de-duplicated. */
+function referrers(qn: string, kind: 'references' | 'instantiates' = 'references'): string[] {
+  const [target] = cg.getNodesByQualifiedName(qn);
+  expect(target, `no node ${qn}`).toBeDefined();
+  const edges = cg.getIncomingEdgesTo([target!.id], [kind]);
+  return [...new Set(edges.map((e) => cg.getNode(e.source)!).map((n) => `${n.kind} ${n.qualifiedName}`))].sort();
+}
+
+describe('Dart type positions (#2327)', () => {
+  it('reference the type from every position in the issue', () => {
+    expect(referrers('Report')).toEqual([
+      'class Holder',              // field type
+      'class ReportX',             // extension target
+      'constant reportProvider',   // generic argument in a top-level initializer
+      'function load',             // return type's generic argument (already linked)
+      'function run',              // generic argument in an expression
+      'function score',            // parameter type (already linked)
+    ]);
+  });
+
+  it('reference the type from fields, enum fields, initializers, locals, casts, type tests and the file', () => {
+    expect(referrers('Score')).toEqual([
+      'class Board',               // field types, `<String, Score>{}`, the prefixed `m.Score`
+      'class ScoresX',             // `on List<Score>`
+      'enum Grade',                // an enhanced enum's field
+      'file lib/more.dart',        // a top-level variable's type
+      'function body',             // a local's type, a cast, a type test
+      'constant scores',           // `<Score>[]`
+    ].sort());
+    expect(referrers('ScoreError')).toEqual(['function body']);
+  });
+
+  it('leave a constructor call to its instantiation, and an import prefix out', () => {
+    // `Score(1)` / `const Score(2)` instantiate; they add no reference of their own.
+    const body = cg.getNodesByQualifiedName('body')[0]!;
+    const refs = cg.getOutgoingEdgesFrom([body.id], ['references']).filter((e) => cg.getNode(e.target)!.name === 'Score');
+    expect([...new Set(refs.map((e) => e.line))].sort()).toEqual([26, 27]);
+    // `static const Score zero = Score(0);` constructs one too, from its constant.
+    expect(referrers('Score', 'instantiates')).toEqual(['constant Board::zero', 'function body']);
+    const prefixRefs = cg.getUnresolvedReferencesInFile('lib/more.dart').filter((r) => r.referenceName === 'm');
+    expect(prefixRefs).toEqual([]);
+  });
+});
diff --git a/__tests__/dart-unnamed-extension.test.ts b/__tests__/dart-unnamed-extension.test.ts
new file mode 100644
index 0000000000..6fd2700cb8
--- /dev/null
+++ b/__tests__/dart-unnamed-extension.test.ts
@@ -0,0 +1,75 @@
+/**
+ * A Dart `extension on X { … }` has no name — so `X` is never it — and
+ * applies only in its own library. bloc_lint's `extension on Token` took 79
+ * of analyzer's `Token` references, and a concurrency visualizer's
+ * `extension on TaskStatus { String get text }` took 133 flutter_test
+ * `find.text(…)` calls from other packages.
+ */
+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-dart-ext-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: bloc_lint\n',
+    'lib/src/rules/avoid_build_context_extensions.dart': `import 'package:analyzer/dart/ast/token.dart';
+
+extension on Token {
+  bool get isBlocType => lexeme.endsWith('Bloc');
+}
+`,
+    'lib/src/linter.dart': `import 'package:analyzer/dart/ast/token.dart';
+
+class Linter {
+  void visit(Token beginToken) {}
+}
+`,
+    'examples/visualizer/lib/timeline_page.dart': `enum TaskStatus { queued, done }
+
+extension on TaskStatus {
+  String get text => 'x';
+}
+
+String label(TaskStatus status) => status.text;
+`,
+    'examples/counter/test/counter_page_test.dart': `import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  testWidgets('shows', (tester) async {
+    expect(find.text('0'), findsOneWidget);
+  });
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('unnamed Dart extensions', () => {
+  it('are never the type they extend', () => {
+    expect(targetsFrom('lib/src/linter.dart')).not.toContain('lib/src/rules/avoid_build_context_extensions.dart:Token');
+  });
+
+  it('apply only in their own library', () => {
+    expect(targetsFrom('examples/counter/test/counter_page_test.dart').filter((t) => t.includes('TaskStatus'))).toEqual([]);
+  });
+});
diff --git a/__tests__/dead-code.test.ts b/__tests__/dead-code.test.ts
index c0fd98f817..b87ad8a466 100644
--- a/__tests__/dead-code.test.ts
+++ b/__tests__/dead-code.test.ts
@@ -532,3 +532,337 @@ function reallyUnused() {}
     expect(names(report)).toContain('neverCalledMember');
   });
 });
+
+describe('a framework that calls members by name', () => {
+  let root: string;
+  let graph: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-deadcode-by-name-'));
+    // Three components that write the interface out: together they are the
+    // index's own record of what Angular's `OnInit` carries. The third inherits
+    // `ngOnInit` rather than declaring it, and lacks the `refresh` the other
+    // two happen to share.
+    write(
+      root,
+      'src/app/first.component.ts',
+      `import { Component, OnInit } from '@angular/core';
+
+@Component({ selector: 'app-first', template: '' })
+export class FirstComponent implements OnInit {
+  ngOnInit(): void {}
+  refresh(): void {}
+}
+`
+    );
+    write(
+      root,
+      'src/app/second.component.ts',
+      `import { AfterViewInit, Component, OnInit } from '@angular/core';
+
+@Component({ selector: 'app-second', template: '' })
+export class SecondComponent implements OnInit, AfterViewInit {
+  ngOnInit(): void {}
+  ngAfterViewInit(): void {}
+  reload(): void {}
+  refresh(): void {}
+}
+`
+    );
+    write(
+      root,
+      'src/app/base-page.ts',
+      `import { Directive } from '@angular/core';
+
+@Directive()
+export abstract class BasePage {
+  ngOnInit(): void {
+    void 0;
+  }
+}
+`
+    );
+    write(
+      root,
+      'src/app/third.component.ts',
+      `import { Component, OnInit } from '@angular/core';
+import { BasePage } from './base-page';
+
+@Component({ selector: 'app-third', template: '' })
+export class ThirdComponent extends BasePage implements OnInit {}
+`
+    );
+    // Writes no `implements` clause. Angular calls `ngOnInit` all the same.
+    write(
+      root,
+      'src/app/demo.component.ts',
+      `import { Component, HostListener } from '@angular/core';
+
+@Component({ selector: 'app-demo', template: '' })
+export class DemoComponent {
+  ngOnInit(): void {
+    void 0;
+  }
+
+  @HostListener('window:keyup', ['$event'])
+  keyEvent(event: KeyboardEvent): void {
+    void event;
+  }
+
+  reload(): void {
+    void 0;
+  }
+
+  refresh(): void {
+    void 0;
+  }
+
+  unusedHelper(): number {
+    return 1;
+  }
+}
+`
+    );
+    // No decorator, so no framework registers it: the name alone is no evidence.
+    write(root, 'src/app/plain.ts', `export class Plain {\n  ngOnInit(): void {\n    void 0;\n  }\n}\n`);
+    write(
+      root,
+      'src/api/cron.service.ts',
+      `import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Cron } from '@nestjs/schedule';
+
+@Injectable()
+export class CronService {
+  @Cron('0 * * * *')
+  runEveryHour(): void {
+    void 0;
+  }
+
+  @OnEvent('portfolio.changed')
+  handlePortfolioChanged(): void {
+    void 0;
+  }
+
+  hasCurrencyPair(): boolean {
+    return false;
+  }
+}
+`
+    );
+    write(
+      root,
+      'src/main.ts',
+      `import { FirstComponent } from './app/first.component';
+import { SecondComponent } from './app/second.component';
+import { ThirdComponent } from './app/third.component';
+import { DemoComponent } from './app/demo.component';
+import { Plain } from './app/plain';
+import { CronService } from './api/cron.service';
+
+export const declarations = [FirstComponent, SecondComponent, ThirdComponent, DemoComponent, Plain, CronService];
+`
+    );
+    // Java checks the interface itself: Spring calls `afterPropertiesSet` on a
+    // bean that implements InitializingBean, never on one that only has the name.
+    for (const bean of ['FirstBean', 'SecondBean']) {
+      write(
+        root,
+        `src/main/java/demo/${bean}.java`,
+        `package demo;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ${bean} implements InitializingBean {
+  public void afterPropertiesSet() {}
+}
+`
+      );
+    }
+    write(
+      root,
+      'src/main/java/demo/LooseBean.java',
+      `package demo;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class LooseBean {
+  public void afterPropertiesSet() {}
+}
+`
+    );
+    write(
+      root,
+      'src/main/java/demo/App.java',
+      `package demo;
+
+public class App {
+  public static void main(String[] args) {
+    new FirstBean();
+    new SecondBean();
+    new LooseBean();
+  }
+}
+`
+    );
+    graph = CodeGraph.initSync(root, {
+      config: { include: ['src/**/*.ts', 'src/**/*.java'], exclude: [] },
+    });
+    await graph.indexAll();
+  }, 60_000);
+
+  afterAll(() => {
+    graph?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const listed = (report: ReturnType<typeof buildDeadCodeReport>, qualifiedName: string): boolean =>
+    report.entries.some((entry) => entry.node.qualifiedName === qualifiedName);
+
+  it('does not list a method whose decorator resolves outside the index', () => {
+    for (const readSource of [undefined, null] as const) {
+      const report = buildDeadCodeReport(graph, readSource === null ? { readSource } : {});
+      expect(listed(report, 'DemoComponent::keyEvent')).toBe(false);
+      expect(listed(report, 'CronService::runEveryHour')).toBe(false);
+      expect(listed(report, 'CronService::handlePortfolioChanged')).toBe(false);
+      expect(report.excluded.decorated).toBeGreaterThanOrEqual(3);
+    }
+  });
+
+  it('does not list a hook its class fills by name, without writing the interface', () => {
+    for (const readSource of [undefined, null] as const) {
+      const report = buildDeadCodeReport(graph, readSource === null ? { readSource } : {});
+      expect(listed(report, 'DemoComponent::ngOnInit')).toBe(false);
+      // The base a component inherits the hook from is reached the same way.
+      expect(listed(report, 'BasePage::ngOnInit')).toBe(false);
+      expect(report.excluded.hooks).toBe(2);
+    }
+  });
+
+  it('still lists what nothing reaches in a class a framework registers', () => {
+    const report = buildDeadCodeReport(graph);
+    // A decorator on the class is not evidence for each of its members.
+    expect(listed(report, 'DemoComponent::unusedHelper')).toBe(true);
+    expect(listed(report, 'CronService::hasCurrencyPair')).toBe(true);
+    // One implementer is not a contract: `reload` is only SecondComponent's.
+    expect(listed(report, 'DemoComponent::reload')).toBe(true);
+    // Two implementers sharing a method is no contract while a third lacks it.
+    expect(listed(report, 'DemoComponent::refresh')).toBe(true);
+    // Nothing registers an undecorated class.
+    expect(listed(report, 'Plain::ngOnInit')).toBe(true);
+  });
+
+  it('infers a contract only where the interface has no runtime effect', () => {
+    // Java has no export marker in the index, so ask for the exported list,
+    // where every other rule still runs.
+    const report = buildDeadCodeReport(graph, { includeExported: true });
+    expect(listed(report, 'demo::LooseBean::afterPropertiesSet')).toBe(true);
+    expect(listed(report, 'DemoComponent::ngOnInit')).toBe(false);
+  });
+});
+
+describe('a declaration that merges into a type outside the index', () => {
+  let root: string;
+  let graph: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-deadcode-ambient-'));
+    // ghostfolio's chart.registry.ts: chart.js reads both interfaces through
+    // the types they extend, and nothing in the repository names either.
+    write(
+      root,
+      'src/chart.registry.ts',
+      `import { Chart, Tooltip, type ChartType } from 'chart.js';
+
+interface VerticalHoverLinePluginOptions {
+  color?: string;
+}
+
+declare module 'chart.js' {
+  interface PluginOptionsByType<TType extends ChartType> {
+    verticalHoverLine: TType extends 'line' ? VerticalHoverLinePluginOptions : never;
+  }
+  interface TooltipPositionerMap {
+    top: (items: unknown[]) => { x: number; y: number };
+  }
+}
+
+export function registerChartConfiguration(): void {
+  Chart.register(Tooltip);
+}
+
+function unusedChartHelper(): void {}
+`
+    );
+    // angular-realworld's app.config.ts, with a Node.js augmentation beside it.
+    write(
+      root,
+      'src/app.config.ts',
+      `declare global {
+  interface Window {
+    __conduit_debug__?: { token(): string | null };
+  }
+  namespace NodeJS {
+    interface ProcessEnv {
+      API_URL?: string;
+    }
+  }
+}
+
+// In a module file this namespace is the file's own: it merges with nothing.
+declare namespace Settings {
+  interface NotMergedAnywhere {
+    retries: number;
+  }
+}
+
+export const appConfig = { providers: [] };
+`
+    );
+    write(
+      root,
+      'src/main.ts',
+      `import { registerChartConfiguration } from './chart.registry';
+import { appConfig } from './app.config';
+
+registerChartConfiguration();
+export const config = appConfig;
+`
+    );
+    graph = CodeGraph.initSync(root, { config: { include: ['src/**/*.ts'], exclude: [] } });
+    await graph.indexAll();
+  }, 60_000);
+
+  afterAll(() => {
+    graph?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const merged = ['PluginOptionsByType', 'TooltipPositionerMap', 'Window', 'ProcessEnv'];
+
+  it('does not list what a declare module or declare global block declares', () => {
+    for (const readSource of [undefined, null] as const) {
+      const report = buildDeadCodeReport(graph, readSource === null ? { readSource } : {});
+      for (const name of merged) expect(names(report)).not.toContain(name);
+      // TypeScript exports them without the keyword, so the exported rule
+      // takes them, and counts them.
+      expect(report.excluded.exported).toBe(merged.length);
+    }
+  });
+
+  it('lists them with the outside-reach caveat when exported symbols are asked for', () => {
+    const report = buildDeadCodeReport(graph, { includeExported: true });
+    for (const name of merged) {
+      expect(report.entries.find((entry) => entry.node.name === name)?.exported).toBe(true);
+    }
+  });
+
+  it('still lists what nothing reaches beside them', () => {
+    const report = buildDeadCodeReport(graph);
+    expect(names(report)).toContain('unusedChartHelper');
+    expect(names(report)).toContain('NotMergedAnywhere');
+  });
+});
diff --git a/__tests__/declared-member-receiver.test.ts b/__tests__/declared-member-receiver.test.ts
new file mode 100644
index 0000000000..2ffeeed914
--- /dev/null
+++ b/__tests__/declared-member-receiver.test.ts
@@ -0,0 +1,180 @@
+/**
+ * A C# / Java call through a field, property or parameter is a call on the
+ * type it is declared with — read from the class's own member declarations,
+ * those it inherits (with the type arguments the subclass gives), a using
+ * alias, or a generic or enhanced-for declaration — never a guess at a
+ * same-named method of some project class:
+ *
+ * - Newtonsoft's `_innerWriter.WriteValue(…)` inside TraceJsonWriter went to
+ *   TraceJsonWriter's own `WriteValue`, and `_textWriter.Write(…)` on a
+ *   `TextWriter` to a test's `ThrowingWriter.Write`;
+ * - a C# interface's members are public, so a call on an interface-typed
+ *   field reaches the interface's method (eShop's `_fixUriService.Fix…()`);
+ * - `using Assert = …XUnitAssert;` makes `Assert.AreEqual` XUnitAssert's;
+ * - a standard .NET name on an untyped receiver (`table.Columns.Add(…)`) is
+ *   not a project class's same-named method unless the receiver names it.
+ */
+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-member-receiver-'));
+  const files: Record<string, string> = {
+    'src/Json/JsonWriter.cs': `namespace App.Json;
+
+public abstract class JsonWriter
+{
+    public virtual void WriteValue(string value) { }
+}
+`,
+    'src/Json/TraceJsonWriter.cs': `using System.IO;
+
+namespace App.Json;
+
+internal class TraceJsonWriter : JsonWriter
+{
+    private readonly JsonWriter _innerWriter;
+    /* a block comment naming the _textWriter field */
+    private readonly TextWriter _textWriter;
+
+    public override void WriteValue(string value)
+    {
+        _innerWriter.WriteValue(value);
+        _textWriter.Write(value);
+    }
+}
+`,
+    'tests/ThrowingWriter.cs': `using System.IO;
+
+namespace App.Tests;
+
+public class ThrowingWriter : TextWriter
+{
+    public override void Write(string value) { }
+}
+`,
+    'tests/XUnitAssert.cs': `namespace App.Tests;
+
+public static class XUnitAssert
+{
+    public static void AreEqual(object a, object b) { }
+}
+`,
+    'src/DefaultJsonNameTable.cs': `namespace App;
+
+public class DefaultJsonNameTable
+{
+    public void Add(string key) { }
+}
+`,
+    'src/Services/IFixUriService.cs': `namespace App.Services;
+
+public interface IFixUriService
+{
+    void FixBasketItemPictureUri(string uri);
+}
+`,
+    'src/Services/FixUriService.cs': `namespace App.Services;
+
+public class FixUriService : IFixUriService
+{
+    public void FixBasketItemPictureUri(string uri) { }
+}
+`,
+    'src/Services/BasketService.cs': `namespace App.Services;
+
+public class BasketService
+{
+    private readonly IFixUriService _fixUriService;
+
+    public void Load(string uri)
+    {
+        _fixUriService.FixBasketItemPictureUri(uri);
+    }
+}
+`,
+    'tests/Integration/IntegrationTest.cs': `namespace App.Tests.Integration;
+
+public abstract class IntegrationTest<TFixture> where TFixture : new()
+{
+    protected TFixture Fixture { get; private set; }
+}
+
+public class DropCreateDatabaseAlways
+{
+    public object CreateContext() => null;
+}
+`,
+    'tests/Integration/QueryTests.cs': `using Assert = App.Tests.XUnitAssert;
+
+namespace App.Tests.Integration;
+
+public class QueryTests : IntegrationTest<QueryTests.DatabaseInitializer>
+{
+    public class DatabaseInitializer : DropCreateDatabaseAlways { }
+
+    public void Runs()
+    {
+        var context = Fixture.CreateContext();
+        Assert.AreEqual(1, 1);
+        var table = MakeTable();
+        table.Columns.Add("price");
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('C# calls through declared members', () => {
+  it('reach the field’s declared type, and nothing for an outside one', () => {
+    expect(callsFrom('src/Json/TraceJsonWriter.cs')).toEqual(['App.Json::JsonWriter::WriteValue']);
+  });
+
+  it('reach an interface’s method: interface members are public', () => {
+    expect(callsFrom('src/Services/BasketService.cs')).toEqual([
+      'App.Services::IFixUriService::FixBasketItemPictureUri',
+    ]);
+  });
+
+  it('follow an inherited property typed by the type argument, a using alias, and leave a .NET name alone', () => {
+    expect(callsFrom('tests/Integration/QueryTests.cs')).toEqual([
+      'App.Tests.Integration::DropCreateDatabaseAlways::CreateContext',
+      'App.Tests::XUnitAssert::AreEqual',
+    ]);
+  });
+});
+
+describe('C# default visibility', () => {
+  it('is public in an interface and internal for a type in a namespace', () => {
+    const method = cg.getNodesInFile('src/Services/IFixUriService.cs').find((n) => n.kind === 'method')!;
+    expect(method.visibility).toBe('public');
+    const cls = cg.getNodesInFile('src/Json/TraceJsonWriter.cs').find((n) => n.kind === 'class')!;
+    expect(cls.visibility).toBe('internal');
+  });
+});
diff --git a/__tests__/destructured-call-result.test.ts b/__tests__/destructured-call-result.test.ts
new file mode 100644
index 0000000000..02b50e22db
--- /dev/null
+++ b/__tests__/destructured-call-result.test.ts
@@ -0,0 +1,70 @@
+/**
+ * A call through a name destructured from a call's result — a composable or
+ * a custom hook — reaches the function that callee returns under that key:
+ * `const { getDefaultActivityRoute } = useDefaultActivity()` (mealie, where the
+ * function is a module-level one the composable returns), `const { t } =
+ * useI18n()`, `const { login } = useAuth()` (declared in the hook's body).
+ * The local binding used to rule out every cross-file candidate.
+ */
+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-destructured-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', dependencies: { vue: '^3' } }),
+    'src/composables/use-default-activity.ts': `function getDefaultActivityRoute(key?: string): string {
+  return key ?? '/';
+}
+export default function useDefaultActivity() {
+  return { getDefaultActivityRoute };
+}
+`,
+    'src/hooks/useAuth.ts': `export function useAuth() {
+  function login(user: string) {
+    return user;
+  }
+  const logout = () => null;
+  return { login, signOut: logout };
+}
+`,
+    'src/pages/index.ts': `import useDefaultActivity from '../composables/use-default-activity';
+import { useAuth } from '../hooks/useAuth';
+export function go() {
+  const { getDefaultActivityRoute } = useDefaultActivity();
+  const { login, signOut: leave } = useAuth();
+  login('ada');
+  leave();
+  return getDefaultActivityRoute('x');
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('names destructured from a call', () => {
+  it('reach what the callee returns under that key', () => {
+    const go = cg.getNodesInFile('src/pages/index.ts').find((n) => n.name === 'go')!;
+    const targets = cg
+      .getOutgoingEdges(go.id)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => `${cg.getNode(e.target)!.filePath}:${cg.getNode(e.target)!.name}`);
+    expect(targets).toContain('src/composables/use-default-activity.ts:getDefaultActivityRoute');
+    expect(targets).toContain('src/hooks/useAuth.ts:login');
+  });
+});
diff --git a/__tests__/enum-constant-bodies.test.ts b/__tests__/enum-constant-bodies.test.ts
new file mode 100644
index 0000000000..035648aecf
--- /dev/null
+++ b/__tests__/enum-constant-bodies.test.ts
@@ -0,0 +1,107 @@
+/**
+ * A Java enum constant or Kotlin enum entry with a body of its own
+ * (`PLUS { int apply(…) { … } }`, `NewBuffer { override fun pipe() … }`)
+ * declares members of its own, and the calls in them are calls. Neither
+ * extractor visited those bodies: jsoup's tokenizer — an enum whose every
+ * state implements `read` — was absent from the graph, 2,000 calls in all.
+ */
+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-enum-bodies-'));
+  const files: Record<string, string> = {
+    'src/main/java/app/Op.java': `package app;
+
+public enum Op {
+  PLUS {
+    @Override
+    int apply(int a, int b) {
+      return helper(a) + b;
+    }
+  },
+  MINUS {
+    @Override
+    int apply(int a, int b) { return a - b; }
+  };
+
+  abstract int apply(int a, int b);
+
+  static int helper(int x) { return x; }
+}
+`,
+    'src/main/kotlin/app/Factory.kt': `package app
+
+enum class Factory {
+  NewBuffer {
+    override val isOneByteAtATime: Boolean
+      get() = false
+
+    override fun pipe(): Int {
+      val buffer = 1
+      return helper(buffer)
+    }
+  },
+  Other {
+    override val isOneByteAtATime: Boolean = true
+    override fun pipe(): Int = 2
+  };
+
+  abstract val isOneByteAtATime: Boolean
+  abstract fun pipe(): Int
+
+  fun helper(x: Int): Int = x
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const methods = (file: string) =>
+  cg.getNodesInFile(file).filter((n) => n.kind === 'method').map((n) => n.qualifiedName).sort();
+
+const calls = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => `${cg.getNode(e.source)!.qualifiedName} -> ${cg.getNode(e.target)!.qualifiedName}`)
+    .sort();
+};
+
+describe('enum constants with bodies', () => {
+  it('Java: each constant’s methods are extracted and their calls resolved', () => {
+    expect(methods('src/main/java/app/Op.java')).toEqual([
+      'app::Op::MINUS::apply',
+      'app::Op::PLUS::apply',
+      'app::Op::apply',
+      'app::Op::helper',
+    ]);
+    expect(calls('src/main/java/app/Op.java')).toEqual(['app::Op::PLUS::apply -> app::Op::helper']);
+  });
+
+  it('Kotlin: each entry’s methods are extracted and their calls resolved', () => {
+    expect(methods('src/main/kotlin/app/Factory.kt')).toEqual([
+      'app::Factory::NewBuffer::pipe',
+      'app::Factory::Other::pipe',
+      'app::Factory::helper',
+      'app::Factory::pipe',
+    ]);
+    expect(calls('src/main/kotlin/app/Factory.kt')).toEqual(['app::Factory::NewBuffer::pipe -> app::Factory::helper']);
+  });
+});
diff --git a/__tests__/esm-unexported-binding.test.ts b/__tests__/esm-unexported-binding.test.ts
new file mode 100644
index 0000000000..05573340e7
--- /dev/null
+++ b/__tests__/esm-unexported-binding.test.ts
@@ -0,0 +1,77 @@
+/**
+ * A top-level binding an ES module doesn't export can't be named from another
+ * file. sveltekit's `generate_manifest.js` keeps an unexported `resolve` that
+ * other files' `resolve(…)` calls went to; typeorm's test inputs' local
+ * `ColumnMetadata` took `import { ColumnMetadata } from "typeorm"`. Exported
+ * forms all still count: the `export` keyword, `export { a as b }`,
+ * `export default x`, `export default { a, b }`; so do classic scripts,
+ * CommonJS files and functions assigned onto a prototype.
+ */
+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-esm-unexported-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', type: 'module' }),
+    'src/manifest.js': `import { join } from 'node:path';
+function resolve(event) { return join(event); }
+export function manifest() { return resolve('x'); }
+`,
+    'src/adapters.js': `import { a } from './a.js';
+function getAdapter(name) { return name; }
+export default { getAdapter };
+`,
+    'src/listed.js': `import { a } from './a.js';
+function helper() { return 1; }
+export { helper };
+`,
+    'src/proto.js': `import { a } from './a.js';
+function Params() {}
+const prototype = Params.prototype;
+prototype.render = function render() { return ''; };
+export default Params;
+`,
+    'src/a.js': `export const a = 1;
+`,
+    'src/use.js': `import { helper } from './listed.js';
+import Params from './proto.js';
+export async function handle(event) {
+  await resolve(event);
+  getAdapter('xhr');
+  helper();
+  new Params().render();
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('unexported ES module bindings', () => {
+  it('are not reached from another file; every export form still is', () => {
+    const handle = cg.getNodesInFile('src/use.js').find((n) => n.name === 'handle')!;
+    const targets = cg
+      .getOutgoingEdges(handle.id)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => `${cg.getNode(e.target)!.filePath}:${cg.getNode(e.target)!.name}`);
+    expect(targets).not.toContain('src/manifest.js:resolve');
+    expect(targets).toContain('src/adapters.js:getAdapter');
+    expect(targets).toContain('src/listed.js:helper');
+    expect(targets).toContain('src/proto.js:render');
+  });
+});
diff --git a/__tests__/explore-cobol-copybook.test.ts b/__tests__/explore-cobol-copybook.test.ts
new file mode 100644
index 0000000000..344e102008
--- /dev/null
+++ b/__tests__/explore-cobol-copybook.test.ts
@@ -0,0 +1,182 @@
+/**
+ * COBOL copybooks are findable by name in explore (#2342).
+ *
+ * `COPY X` and `EXEC SQL INCLUDE X` are indexed as `import` nodes, and the
+ * context builder's default kind filter drops imports (for JavaScript an
+ * import statement is noise). So `codegraph_explore "MYCOPYBOOK"` — and the
+ * CLI `explore`, which runs the same handler — answered "No relevant code
+ * found" while `query`/`node` found the include at once. A copybook name with
+ * a digit in it (`CVACT01Y`) fared worse: the text search fell through to its
+ * fuzzy fallback and answered with an unrelated program one edit away.
+ *
+ * Now a query that names a copybook gets the copybook's own source (pinned,
+ * first) and every statement that includes it; a member whose source is not
+ * indexed says so. Other languages' imports stay out of explore.
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { ToolHandler } from '../src/mcp/tools';
+
+let dir: string;
+let cg: CodeGraph;
+
+async function index(files: Record<string, string>): Promise<void> {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-cobol-copybook-'));
+  for (const [name, source] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(dir, name)), { recursive: true });
+    fs.writeFileSync(path.join(dir, name), source);
+  }
+  cg = CodeGraph.initSync(dir);
+  await cg.indexAll();
+}
+
+async function explore(query: string): Promise<string> {
+  const result = await new ToolHandler(cg).execute('codegraph_explore', { query });
+  expect(result.isError).toBeFalsy();
+  return result.content[0]!.text;
+}
+
+afterEach(() => {
+  cg?.destroy();
+  if (dir) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+const lines = (...l: string[]): string => l.join('\n') + '\n';
+
+/** The issue's reproduction, verbatim: an EXEC SQL INCLUDE whose member is not indexed. */
+const TESTPROG = lines(
+  '       IDENTIFICATION DIVISION.',
+  '       PROGRAM-ID. TESTPROG.',
+  '       PROCEDURE DIVISION.',
+  '       UP-INCLUDE-COPYBOOK SECTION.',
+  '       UP-INCLUDE-COPYBOOK-10.',
+  '           EXEC SQL INCLUDE MYCOPYBOOK END-EXEC.',
+);
+
+/** An indexed data copybook, COPY'd by two programs. */
+const COPYBOOK_PROJECT = {
+  'cpy/CVACT01Y.cpy': lines(
+    '       01  ACCOUNT-RECORD.',
+    '           05  ACCT-ID          PIC 9(11).',
+    '           05  ACCT-CURR-BAL    PIC S9(10)V99.',
+  ),
+  'cbl/ACCTUPDT.cbl': lines(
+    '       IDENTIFICATION DIVISION.',
+    '       PROGRAM-ID. ACCTUPDT.',
+    '       DATA DIVISION.',
+    '       WORKING-STORAGE SECTION.',
+    '       COPY CVACT01Y.',
+    '       01  WS-COUNT    PIC 9(4) VALUE 0.',
+    '       PROCEDURE DIVISION.',
+    '       MAIN-PARA.',
+    '           MOVE 1 TO ACCT-ID',
+    '           STOP RUN.',
+  ),
+  'cbl/ACCTVIEW.cbl': lines(
+    '       IDENTIFICATION DIVISION.',
+    '       PROGRAM-ID. ACCTVIEW.',
+    '       DATA DIVISION.',
+    '       WORKING-STORAGE SECTION.',
+    '       COPY CVACT01Y.',
+    '       PROCEDURE DIVISION.',
+    '       MAIN-PARA.',
+    '           DISPLAY ACCT-CURR-BAL',
+    '           STOP RUN.',
+  ),
+  // One edit away from the copybook's name, and includes nothing: the
+  // program the fuzzy fallback used to answer `CVACT01Y` with.
+  'cbl/CBACT01C.cbl': lines(
+    '       IDENTIFICATION DIVISION.',
+    '       PROGRAM-ID. CBACT01C.',
+    '       PROCEDURE DIVISION.',
+    '       MAIN-PARA.',
+    '           DISPLAY "BATCH"',
+    '           STOP RUN.',
+  ),
+};
+
+describe('explore finds COBOL copybooks by name (#2342)', () => {
+  it('surfaces an EXEC SQL INCLUDE whose copybook is not indexed (the issue repro)', async () => {
+    await index({ 'TESTPROG.cbl': TESTPROG });
+    const text = await explore('MYCOPYBOOK');
+    expect(text).not.toContain('No relevant code found');
+    // The include site, listed and rendered.
+    expect(text).toContain('`TESTPROG.cbl:6` — EXEC SQL INCLUDE');
+    expect(text).toMatch(/6\t\s+EXEC SQL INCLUDE MYCOPYBOOK END-EXEC\./);
+    // And the honest note that there is no copybook source here to look for.
+    expect(text).toContain('no indexed source');
+  });
+
+  it('pins an indexed copybook ahead of every include site, and lists all of them', async () => {
+    await index(COPYBOOK_PROJECT);
+    const text = await explore('CVACT01Y');
+    expect(text).not.toContain('No relevant code found');
+    expect(text).toContain('source `cpy/CVACT01Y.cpy`; included at 2 sites');
+    expect(text).toContain('`cbl/ACCTUPDT.cbl:5` — COPY');
+    expect(text).toContain('`cbl/ACCTVIEW.cbl:5` — COPY');
+    // The copybook's own source renders, before any including program.
+    const copybookAt = text.indexOf('**`cpy/CVACT01Y.cpy`**');
+    expect(copybookAt).toBeGreaterThan(-1);
+    expect(text).toContain('01  ACCOUNT-RECORD.');
+    for (const program of ['cbl/ACCTUPDT.cbl', 'cbl/ACCTVIEW.cbl']) {
+      const at = text.indexOf(`**\`${program}\`**`);
+      expect(at).toBeGreaterThan(copybookAt);
+    }
+    expect(text).toContain('COPY CVACT01Y.');
+    expect(text).toContain('1 file pinned from the query');
+    // Not the program one edit away from the copybook's name.
+    expect(text).not.toContain('CBACT01C');
+  });
+
+  it('feeds the same entry points to codegraph context (buildContext)', async () => {
+    await index({ 'TESTPROG.cbl': TESTPROG, ...COPYBOOK_PROJECT });
+    const missing = await cg.buildContext('MYCOPYBOOK', { format: 'markdown' });
+    expect(missing).toContain('EXEC SQL INCLUDE MYCOPYBOOK END-EXEC');
+    const indexed = await cg.buildContext('CVACT01Y', { format: 'markdown' });
+    expect(indexed).toContain('ACCOUNT-RECORD');
+    expect(indexed).toContain('COPY CVACT01Y.');
+    expect(indexed).not.toContain('CBACT01C');
+  });
+
+  it('leaves the copybook out when an explicit kind filter excludes imports', async () => {
+    await index({ 'TESTPROG.cbl': TESTPROG });
+    const subgraph = await cg.findRelevantContext('MYCOPYBOOK', { nodeKinds: ['function'] });
+    expect([...subgraph.nodes.values()].some((n) => n.kind === 'import')).toBe(false);
+  });
+
+  it('keeps imports of other languages out of explore', async () => {
+    await index({
+      'main.ts': "import { CVACT01Y } from './lib';\nexport function run() { return CVACT01Y; }\n",
+      'lib.ts': 'export const CVACT01Y = 1;\n',
+    });
+    const subgraph = await cg.findRelevantContext('CVACT01Y ./lib');
+    expect([...subgraph.nodes.values()].some((n) => n.kind === 'import')).toBe(false);
+    const text = await explore('CVACT01Y');
+    expect(text).not.toContain('COBOL copybook');
+    expect(text).toContain('export const CVACT01Y = 1;');
+  });
+});
+
+describe('copybook member tokens (#2342)', () => {
+  // Imported lazily so the behavioural cases above load (and fail) on a build
+  // that predates the module.
+  const tokens = async (query: string): Promise<string[]> =>
+    (await import('../src/graph/cobol-copybooks')).copybookMemberTokens(query);
+
+  it('keeps COBOL-shaped words and skips plain lowercase English', async () => {
+    expect(await tokens('where is CVACT01Y included from cust-rec and dfh$aid'))
+      .toEqual(['CVACT01Y', 'cust-rec', 'dfh$aid']);
+  });
+
+  it('dedupes case-insensitively and drops short or digit-only tokens', async () => {
+    expect(await tokens('SQLCA sqlca IO 0042 Sqlca')).toEqual(['SQLCA']);
+  });
+
+  it('takes a one-word query as a name whatever its case', async () => {
+    expect(await tokens('lgpolicy')).toEqual(['lgpolicy']);
+    expect(await tokens('the lgpolicy')).toEqual([]);
+  });
+});
diff --git a/__tests__/expo-modules.test.ts b/__tests__/expo-modules.test.ts
index eab16c1c33..4df758a2ea 100644
--- a/__tests__/expo-modules.test.ts
+++ b/__tests__/expo-modules.test.ts
@@ -205,3 +205,80 @@ class BatteryModule : Module() {
     expect(pair.c).toBeGreaterThanOrEqual(2); // swift->kotlin AND kotlin->swift
   });
 });
+
+describe('Expo Modules — a JS binding named for its role, not its module', () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'expo-modules-binding-'));
+  });
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('expo-camera: `CameraManager.fn()` on `export default requireNativeModule<T>("ExpoCamera")` reaches the module’s functions', async () => {
+    const write = (rel: string, content: string) => {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    };
+    write('package.json', '{"dependencies":{"expo-modules-core":"^1.0.0","expo":"*"}}');
+    write('ios/CameraViewModule.swift', `import ExpoModulesCore
+public final class CameraViewModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoCamera")
+    AsyncFunction("launchScanner") { (options: ScannerOptions) in }
+    AsyncFunction("dismissScanner") { }
+  }
+}
+`);
+    write('android/src/main/java/expo/modules/camera/CameraViewModule.kt', `package expo.modules.camera
+class CameraViewModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoCamera")
+    AsyncFunction("launchScanner") { options: ScannerOptions -> }
+    AsyncFunction("dismissScanner") { }
+  }
+}
+`);
+    write('src/Camera.types.ts', `import { NativeModule } from 'expo';
+export declare class CameraNativeModule extends NativeModule {
+  readonly isAvailableAsync: () => Promise<boolean>;
+}
+`);
+    write('src/ExpoCameraManager.ts', `import { requireNativeModule } from 'expo';
+import type { CameraNativeModule } from './Camera.types';
+
+export default requireNativeModule<CameraNativeModule>('ExpoCamera');
+`);
+    write('src/CameraView.tsx', `import CameraManager from './ExpoCameraManager';
+
+export default class CameraView {
+  static async isAvailableAsync(): Promise<boolean> {
+    return CameraManager.isAvailableAsync();
+  }
+  static async launchScanner(options: object): Promise<void> {
+    await CameraManager.launchScanner(options);
+  }
+}
+`);
+    const cg = await CodeGraph.init(dir, { index: true });
+    try {
+      const view = cg.getNodesInFile('src/CameraView.tsx');
+      const from = (name: string) => view.find((n) => n.name === name && n.kind === 'method')!;
+      const callees = (name: string) =>
+        cg
+          .getOutgoingEdges(from(name).id)
+          .filter((e) => e.kind === 'calls')
+          .map((e) => cg.getNode(e.target)!)
+          .map((n) => `${n.language}:${n.qualifiedName.split('::').pop()}`)
+          .sort();
+      // Both platforms' `launchScanner`, not CameraView's own.
+      expect(callees('launchScanner')).toEqual(['kotlin:ExpoCamera.launchScanner', 'swift:ExpoCamera.launchScanner']);
+      // Declared natively nowhere here: the type the binding is given, never the caller itself.
+      expect(callees('isAvailableAsync')).toEqual(['typescript:isAvailableAsync']);
+      const target = cg.getOutgoingEdges(from('isAvailableAsync').id).find((e) => e.kind === 'calls')!;
+      expect(cg.getNode(target.target)!.filePath).toBe('src/Camera.types.ts');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/express-heuristic-same-file.test.ts b/__tests__/express-heuristic-same-file.test.ts
new file mode 100644
index 0000000000..a02cf93884
--- /dev/null
+++ b/__tests__/express-heuristic-same-file.test.ts
@@ -0,0 +1,60 @@
+/**
+ * The Express resolver's middleware / controller / service name patterns pick
+ * only the calling file's own declaration — another file's comes through an
+ * `import` / `require`, the import resolver's. SvelteKit's remote functions'
+ * `validate(arg)` went to the config loader's `validate` in another package,
+ * and express' examples' `logger('dev')` to one example's `logger`.
+ */
+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-express-heur-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', private: true, dependencies: { express: '^4.0.0' } }),
+    'packages/kit/src/core/config/options.js': `export function validate(config) {
+  return config;
+}
+`,
+    'packages/kit/src/runtime/remote/query.js': `export function query(validate, arg) {
+  return () => validate(arg);
+}
+`,
+    'server/app.js': `const express = require('express');
+const app = express();
+
+function validateBody(req, res, next) {
+  next();
+}
+
+app.post('/items', validateBody, (req, res) => res.send('ok'));
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetFilesFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.filePath);
+};
+
+describe('Express name patterns', () => {
+  it('never reach another file’s declaration by name', () => {
+    expect(targetFilesFrom('packages/kit/src/runtime/remote/query.js')).not.toContain('packages/kit/src/core/config/options.js');
+  });
+});
diff --git a/__tests__/express-inline-function-handler.test.ts b/__tests__/express-inline-function-handler.test.ts
new file mode 100644
index 0000000000..eb7da99eab
--- /dev/null
+++ b/__tests__/express-inline-function-handler.test.ts
@@ -0,0 +1,106 @@
+/**
+ * An Express handler written inline as `function (req, res) {…}` — the form
+ * Express's own examples use — is the route's body just like an arrow is:
+ * its calls are the route's, so Steps draws what `POST /login` does instead
+ * of a lone box. The handler is the LAST argument; an inline middleware
+ * before a named handler is not it, and a trailing comma changes nothing.
+ */
+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-express-fnexpr-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', private: true, dependencies: { express: '^4.0.0' } }),
+    'app.js': `const express = require('express');
+const app = express();
+const router = express.Router();
+
+function authenticate(name, pass, fn) {
+  fn(null, { name });
+}
+
+function restrict(req, res, next) {
+  next();
+}
+
+function loadUser(id) {
+  return { id };
+}
+
+function listPosts() {
+  return [];
+}
+
+function wrap(fn) {
+  return fn;
+}
+
+function showPost(req, res) {
+  res.send('post');
+}
+
+app.post('/login', function (req, res, next) {
+  authenticate(req.body.username, req.body.password, function (err, user) {
+    res.redirect('/');
+  });
+});
+
+app.get('/restricted', restrict, function named(req, res) {
+  res.send(loadUser(req.params.id));
+});
+
+router.get(
+  '/posts',
+  wrap(async function (req, res) {
+    res.json(listPosts());
+  }),
+);
+
+app.get('/post/:id', (req, res, next) => next(), showPost);
+
+router.route('/users/:id').get(function (req, res) {
+  res.json(loadUser(req.params.id));
+});
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const fromRoute = (name: string, kind: string) => {
+  const route = cg.getNodesByKind('route').find((r) => r.name === name);
+  expect(route, name).toBeDefined();
+  return cg.getOutgoingEdgesFrom([route!.id]).filter((e) => e.kind === kind).map((e) => cg.getNode(e.target)!.name);
+};
+
+describe('Express function-expression handlers', () => {
+  it('lend the route their calls', () => {
+    expect(fromRoute('POST /login', 'calls')).toContain('authenticate');
+    expect(fromRoute('GET /restricted', 'calls')).toContain('loadUser');
+    expect(fromRoute('GET /users/:id', 'calls')).toContain('loadUser');
+  });
+
+  it('are found inside a wrapper call, past a trailing comma', () => {
+    expect(fromRoute('GET /posts', 'calls')).toContain('listPosts');
+  });
+
+  it('leave a named last argument the handler, even after an inline middleware', () => {
+    expect(fromRoute('GET /post/:id', 'references')).toContain('showPost');
+    expect(fromRoute('GET /post/:id', 'calls')).toEqual([]);
+  });
+});
diff --git a/__tests__/external-declared-receiver.test.ts b/__tests__/external-declared-receiver.test.ts
new file mode 100644
index 0000000000..b2f035f27e
--- /dev/null
+++ b/__tests__/external-declared-receiver.test.ts
@@ -0,0 +1,76 @@
+/**
+ * A receiver whose declared type is one the project doesn't declare —
+ * `List<String> list`, `var sb = new StringBuilder()` — calls that outside
+ * type's method, never a project type's same-named one: gson's `list.add(…)`
+ * went to a project list wrapper's `add`, commons-lang's `s.length()` to a
+ * writer's. A Python keyword argument (`prefix=IPNetwork(…),` inside a call)
+ * is not a binding of `prefix`.
+ */
+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-external-declared-'));
+  const files: Record<string, string> = {
+    'src/main/java/app/NonNullElementWrapperList.java': `package app;
+public class NonNullElementWrapperList {
+  public boolean add(Object o) { return true; }
+}
+`,
+    'src/main/java/app/Use.java': `package app;
+import java.util.ArrayList;
+import java.util.List;
+public class Use {
+  public void run() {
+    List<String> list = new ArrayList<>();
+    list.add("x");
+  }
+}
+`,
+    'app/models.py': `class Prefix:
+    def get_available_ip_count(self):
+        return 0
+`,
+    'app/tests.py': `from app.models import Prefix
+from netaddr import IPNetwork
+
+
+def test_count():
+    prefix = Prefix(
+        prefix=IPNetwork('192.0.2.0/24'),
+    )
+    return prefix.get_available_ip_count()
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const callsIn = (file: string, fn: string): string[] => {
+  const node = cg.getNodesInFile(file).find((n) => n.name === fn)!;
+  return cg.getOutgoingEdges(node.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('a receiver declared with an outside type', () => {
+  it('Java: `List<String> list` calls List.add, not a project class’s add', () => {
+    expect(callsIn('src/main/java/app/Use.java', 'run').some((t) => t.endsWith('NonNullElementWrapperList::add'))).toBe(false);
+  });
+
+  it('Python: a keyword argument is not the receiver’s binding', () => {
+    expect(callsIn('app/tests.py', 'test_count').some((t) => t.endsWith('Prefix::get_available_ip_count'))).toBe(true);
+  });
+});
diff --git a/__tests__/external-type-receiver.test.ts b/__tests__/external-type-receiver.test.ts
new file mode 100644
index 0000000000..a14db4904b
--- /dev/null
+++ b/__tests__/external-type-receiver.test.ts
@@ -0,0 +1,57 @@
+/**
+ * `Name.method()` where `Name` is a type the project doesn't declare —
+ * `Arrays.asList(…)`, `Object.assign(…)`, Delphi's `Exception.Create(…)` — is
+ * a call into that outside type, never the project's one same-named method.
+ * commons-lang's `Integer.valueOf(…)` went to `StringUtils.valueOf` 804
+ * times; horse's `Exception.Create` to its `EHorseException.Create`. Go's
+ * exported variables (`FormPost.Bind`) and Pascal's capitalized locals and
+ * parameters (`LRequest.GetValue`) are not type names.
+ */
+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-external-type-'));
+  const files: Record<string, string> = {
+    'src/main/java/app/StringUtils.java': `package app;
+public class StringUtils {
+  public static String valueOf(Object o) { return String.valueOf(o); }
+}
+`,
+    'src/main/java/app/Use.java': `package app;
+public class Use {
+  public int run() {
+    Integer.valueOf(1);
+    return StringUtils.valueOf(2).length();
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('a call on a type from outside the project', () => {
+  it('is not the project’s same-named method; the project’s own type still is', () => {
+    const run = cg.getNodesInFile('src/main/java/app/Use.java').find((n) => n.name === 'run')!;
+    const valueOf = cg
+      .getOutgoingEdges(run.id)
+      .filter((e) => e.kind === 'calls' && cg.getNode(e.target)!.name === 'valueOf');
+    // Exactly one: `StringUtils.valueOf(2)`, not `Integer.valueOf(1)`.
+    expect(valueOf.map((e) => e.line)).toEqual([5]);
+  });
+});
diff --git a/__tests__/extraction.test.ts b/__tests__/extraction.test.ts
index 46a3cc3d54..e84b7bf1b2 100644
--- a/__tests__/extraction.test.ts
+++ b/__tests__/extraction.test.ts
@@ -11,7 +11,7 @@ import * as os from 'os';
 import { execFileSync } from 'child_process';
 import { CodeGraph } from '../src';
 import { extractFromSource, scanDirectory, scanDirectoryAsync, buildDefaultIgnore, discoverEmbeddedRepoRoots, buildScopeIgnore, type ScanSkipStats } from '../src/extraction';
-import { detectLanguage, isLanguageSupported, getSupportedLanguages, initGrammars, loadAllGrammars, isSourceFile } from '../src/extraction/grammars';
+import { detectLanguage, isLanguageSupported, getSupportedLanguages, initGrammars, loadAllGrammars, isSourceFile, shopifyThemeRoot } from '../src/extraction/grammars';
 import { stripCppTemplateArgs, blankCppExportMacros, blankCppInlineMacros, blankMetalAttributes, blankCudaConstructs, blankCppAnnotationMacroCalls, blankCppApiPrefixMacros, blankCppInlineAnnotationMacros, blankCLeadingAttrMacros, recoverMangledCppName } from '../src/extraction/languages/c-cpp';
 import { normalizePath } from '../src/utils';
 import { generateNodeId } from '../src/extraction/tree-sitter-helpers';
@@ -1180,7 +1180,7 @@ export const exported = { handler: () => target() };
       return result.unresolvedReferences
         .filter((u) => u.referenceKind === 'calls' && u.referenceName === name)
         .map((u) => byId.get(u.fromNodeId))
-        .map((n) => (n ? `${n.kind}:${n.name}` : '?'))
+        .map((n) => (n ? `${n.kind}:${n.qualifiedName}` : '?'))
         .sort();
     };
 
@@ -1191,17 +1191,55 @@ export const exported = { handler: () => target() };
     });
 
     it('a non-exported object literal contributes calls (it was skipped outright)', () => {
-      // `exported`'s members are minted as their own function nodes, so its
-      // arrow's call comes from `handler`; the non-exported ones attribute to
-      // the declared constant.
+      // A named literal's function members are its own nodes, exported or not
+      // (#2300), so each arrow's call comes from its `handler`; the literal's
+      // eager value and the array's arrow attribute to the declared constant.
       expect(callersOf('target')).toEqual([
         'constant:list',
         'constant:obj',
-        'constant:obj',
-        'function:handler',
+        'function:exported::handler',
+        'function:obj::handler',
       ]);
     });
   });
+
+  // A destructuring declaration mints no symbol, so its initializer was never
+  // walked at module scope: `const { a } = useFoo(1)` recorded no call at all,
+  // where the same line inside a function did (#2340).
+  it.each(['ts', 'tsx', 'js', 'jsx'])('records the calls of a module-scope destructuring declaration (%s, #2340)', (ext) => {
+    const code = [
+      'const { a } = useFoo(1)',
+      'let [b, c] = pair()',
+      'var { d: { e } } = nested()',
+      'const { f = fallback() } = withDefault()',
+      'const [g = other(), ...rest] = list()',
+      'export const { h } = exported()',
+      'const { i } = await load(() => inArrow())',
+      'export function probe() { const { j } = inner(); return j }',
+      '',
+    ].join('\n');
+    const result = extractFromSource(`app.${ext}`, code);
+    const byId = new Map(result.nodes.map((n) => [n.id, n]));
+    const calls = result.unresolvedReferences
+      .filter((r) => r.referenceKind === 'calls')
+      .map((r) => `${byId.get(r.fromNodeId)?.kind}:${r.referenceName}@${r.line}`)
+      .sort();
+    expect(calls).toEqual([
+      'file:exported@6',
+      'file:fallback@4',
+      'file:inArrow@7',
+      'file:list@5',
+      'file:load@7',
+      'file:nested@3',
+      'file:other@5',
+      'file:pair@2',
+      'file:useFoo@1',
+      'file:withDefault@4',
+      'function:inner@8', // inside a function: the function's, as before
+    ]);
+    // Still no symbol for a destructured binding.
+    expect(result.nodes.filter((n) => n.kind === 'constant' || n.kind === 'variable')).toEqual([]);
+  });
 });
 
 describe('File Node Extraction', () => {
@@ -7389,6 +7427,9 @@ describe('Liquid Shopify JSON template section resolution', () => {
     // looked unused. The JSON is now indexed and its `type`s linked.
     fs.mkdirSync(path.join(tempDir, 'sections'), { recursive: true });
     fs.mkdirSync(path.join(tempDir, 'templates/customers'), { recursive: true });
+    fs.mkdirSync(path.join(tempDir, 'layout'), { recursive: true });
+    // Every Shopify theme has layout/theme.liquid beside templates/ and sections/.
+    fs.writeFileSync(path.join(tempDir, 'layout/theme.liquid'), `{{ content_for_layout }}\n`);
     fs.writeFileSync(path.join(tempDir, 'sections/main-product.liquid'), `<div>{{ product.title }}</div>\n`);
     fs.writeFileSync(path.join(tempDir, 'sections/main-login.liquid'), `<form>{{ 'customer.login' | t }}</form>\n`);
     fs.writeFileSync(path.join(tempDir, 'templates/product.json'), JSON.stringify({ sections: { main: { type: 'main-product' } }, order: ['main'] }));
@@ -7406,6 +7447,238 @@ describe('Liquid Shopify JSON template section resolution', () => {
     expect(cg.getFileDependents(product!.filePath).some((p) => p.endsWith('templates/product.json')), 'top-level JSON template links its section').toBe(true);
     expect(cg.getFileDependents(login!.filePath).some((p) => p.endsWith('customers/login.json')), 'nested JSON template links its section').toBe(true);
   });
+
+  const jsonTemplate = (type: string): string => JSON.stringify({ sections: { main: { type } }, order: ['main'] });
+  const indexedJson = (): string[] =>
+    cg.getNodesByKind('file').map((n) => n.filePath).filter((p) => p.endsWith('.json')).sort();
+
+  it('leaves JSON under templates/ or sections/ out when no Shopify theme holds it', async () => {
+    // jasontaylordev/CleanArchitecture ships a .NET project template under
+    // templates/, and a CMS keeps its content under sections/: JSON in folders
+    // with those names, but nothing beside them makes a Shopify theme, so it is
+    // not Liquid — even when a Liquid file is named like one of its "types".
+    fs.mkdirSync(path.join(tempDir, 'templates/ca-use-case/.template.config'), { recursive: true });
+    fs.mkdirSync(path.join(tempDir, 'sections'), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'templates/ca-use-case/.template.config/dotnetcli.host.json'), JSON.stringify({ symbolInfo: { UseCase: { longName: 'name' } } }));
+    fs.writeFileSync(path.join(tempDir, 'templates/ca-use-case/.template.config/template.json'), JSON.stringify({ identity: 'CleanArchitecture.UseCase', sections: { main: { type: 'hero' } } }));
+    fs.writeFileSync(path.join(tempDir, 'sections/home.json'), jsonTemplate('hero'));
+    fs.writeFileSync(path.join(tempDir, 'sections/hero.liquid'), `<h1>{{ page.title }}</h1>\n`);
+
+    cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    cg.resolveReferences();
+
+    expect(indexedJson()).toEqual([]);
+    const hero = cg.getNodesByKind('file').find((n) => n.filePath.endsWith('sections/hero.liquid'));
+    expect(hero, 'the Liquid file itself is still indexed').toBeDefined();
+    expect(cg.getFileDependents(hero!.filePath)).toEqual([]);
+  });
+
+  it('finds a Shopify theme in a subdirectory by its config/settings_schema.json', async () => {
+    // A theme under theme/ with no layout/theme.liquid committed: its settings
+    // schema marks it. The same JSON under tools/templates/ is in no theme.
+    for (const dir of ['theme/config', 'theme/sections', 'theme/templates', 'tools/templates']) {
+      fs.mkdirSync(path.join(tempDir, dir), { recursive: true });
+    }
+    fs.writeFileSync(path.join(tempDir, 'theme/config/settings_schema.json'), JSON.stringify([{ name: 'theme_info' }]));
+    fs.writeFileSync(path.join(tempDir, 'theme/sections/main-product.liquid'), `<div>{{ product.title }}</div>\n`);
+    fs.writeFileSync(path.join(tempDir, 'theme/templates/product.json'), jsonTemplate('main-product'));
+    fs.writeFileSync(path.join(tempDir, 'tools/templates/product.json'), jsonTemplate('main-product'));
+
+    cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    cg.resolveReferences();
+
+    expect(indexedJson()).toEqual(['theme/templates/product.json']);
+    expect(cg.getFileDependents('theme/sections/main-product.liquid')).toEqual(['theme/templates/product.json']);
+    // Extracting without storing tells them apart the same way.
+    const refsOf = (file: string) => cg.extractFromSource(file, jsonTemplate('main-product')).unresolvedReferences.map((r) => r.referenceName);
+    expect(refsOf('theme/templates/product.json')).toEqual(['sections/main-product.liquid']);
+    expect(refsOf('tools/templates/product.json')).toEqual([]);
+  });
+
+  it('drops JSON templates once their folder is no longer a theme, and takes them back when it is', async () => {
+    // The same path an index built before this check takes: JSON it stored as
+    // Liquid outside any theme leaves on the next sync, without a re-index.
+    for (const dir of ['layout', 'sections', 'templates']) fs.mkdirSync(path.join(tempDir, dir), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'layout/theme.liquid'), `{{ content_for_layout }}\n`);
+    fs.writeFileSync(path.join(tempDir, 'sections/main-product.liquid'), `<div>{{ product.title }}</div>\n`);
+    fs.writeFileSync(path.join(tempDir, 'templates/page.json'), jsonTemplate('main-product'));
+    fs.writeFileSync(path.join(tempDir, 'templates/product.json'), jsonTemplate('main-product'));
+    cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    expect(indexedJson()).toEqual(['templates/page.json', 'templates/product.json']);
+
+    fs.rmSync(path.join(tempDir, 'layout'), { recursive: true, force: true });
+    // A sync of only the reported paths (the watcher's) and a full sync agree.
+    await cg.sync({ paths: ['templates/product.json'] });
+    expect(indexedJson()).toEqual(['templates/page.json']);
+    await cg.sync();
+    expect(indexedJson()).toEqual([]);
+
+    fs.mkdirSync(path.join(tempDir, 'config'), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'config/settings_schema.json'), '[]');
+    await cg.sync();
+    expect(indexedJson()).toEqual(['templates/page.json', 'templates/product.json']);
+  });
+
+  it('reads JSON under templates/ or sections/ as Liquid only inside a theme under the project root', () => {
+    fs.mkdirSync(path.join(tempDir, 'shop/layout'), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'shop/layout/theme.liquid'), '');
+
+    for (const file of ['shop/templates/product.json', 'shop/templates/customers/login.json', 'shop/sections/header-group.json']) {
+      expect(isSourceFile(file, undefined, tempDir), file).toBe(true);
+      expect(detectLanguage(file, undefined, undefined, tempDir), file).toBe('liquid');
+      // Without the project root there is no theme to look for.
+      expect(isSourceFile(file), file).toBe(false);
+      expect(detectLanguage(file), file).toBe('unknown');
+    }
+    // Beside the theme, not in it; and the theme's other JSON was never a template.
+    for (const file of ['templates/product.json', 'other/sections/header-group.json', 'shop/config/settings_data.json']) {
+      expect(isSourceFile(file, undefined, tempDir), file).toBe(false);
+      expect(detectLanguage(file, undefined, undefined, tempDir), file).toBe('unknown');
+    }
+    // Outside a theme, JSON gets whatever the project maps `.json` to, as any other JSON does.
+    expect(detectLanguage('templates/product.json', undefined, { '.json': 'yaml' }, tempDir)).toBe('yaml');
+    expect(detectLanguage('shop/templates/product.json', undefined, { '.json': 'yaml' }, tempDir)).toBe('liquid');
+  });
+
+  const writeFiles = (files: Record<string, string>, root = tempDir): void => {
+    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);
+    }
+  };
+  // A theme at the project root, a theme in a folder marked only by its settings
+  // schema, and one in a folder with no 404 section and no price snippet of its
+  // own — the shape of panoply/syncify's example themes.
+  const severalThemes = {
+    'layout/theme.liquid': `{% section 'header' %}{{ content_for_layout }}\n`,
+    'sections/header.liquid': `{% render 'price' %}\n`,
+    'sections/main.liquid': `<main></main>\n`,
+    'snippets/price.liquid': `{{ product.price | money }}\n`,
+    'straps/dusk/config/settings_schema.json': '[]',
+    'straps/dusk/sections/404.liquid': `<h1>{{ 'templates.404.title' | t }}</h1>\n`,
+    'straps/dusk/templates/404.json': jsonTemplate('404'),
+    'examples/tailwind/layout/theme.liquid': `{% section 'header' %}{{ content_for_layout }}\n`,
+    'examples/tailwind/sections/header.liquid': `{% liquid\n  render 'price'\n  render 'icon'\n%}\n`,
+    'examples/tailwind/sections/main.liquid': `<main class="p-4"></main>\n`,
+    'examples/tailwind/snippets/icon.liquid': `<svg></svg>\n`,
+    'examples/tailwind/templates/index.json': jsonTemplate('main'),
+    'examples/tailwind/templates/404.json': jsonTemplate('404'),
+    // Liquid in no theme: an app's theme extension.
+    'extensions/reviews/blocks/stars.liquid': `{% render 'star' %}\n`,
+    'extensions/reviews/snippets/star.liquid': `<svg></svg>\n`,
+  };
+
+  it("links a theme's sections and snippets only inside that theme", async () => {
+    // Shopify looks a `{% render %}`, a `{% section %}` or a JSON template's
+    // section `type` up in the theme the file belongs to, never in another one.
+    // Matched by path tail, a theme without the 404 section linked to another
+    // theme's, and a theme in a folder even linked the project root's
+    // sections/header.liquid over its own.
+    writeFiles(severalThemes);
+    cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    cg.resolveReferences();
+
+    const linksOf = (file: string): string[] => cg.getFileDependencies(file).sort();
+    expect(linksOf('layout/theme.liquid')).toEqual(['sections/header.liquid']);
+    expect(linksOf('sections/header.liquid')).toEqual(['snippets/price.liquid']);
+    expect(linksOf('straps/dusk/templates/404.json')).toEqual(['straps/dusk/sections/404.liquid']);
+    expect(linksOf('examples/tailwind/layout/theme.liquid')).toEqual(['examples/tailwind/sections/header.liquid']);
+    expect(linksOf('examples/tailwind/templates/index.json')).toEqual(['examples/tailwind/sections/main.liquid']);
+    // What the theme lacks stays unlinked: no other theme's 404 section or price snippet.
+    expect(linksOf('examples/tailwind/templates/404.json')).toEqual([]);
+    expect(linksOf('examples/tailwind/sections/header.liquid')).toEqual(['examples/tailwind/snippets/icon.liquid']);
+    // Outside any theme, a path still resolves as before.
+    expect(linksOf('extensions/reviews/blocks/stars.liquid')).toEqual(['extensions/reviews/snippets/star.liquid']);
+  });
+
+  it("keeps a theme's references inside it when its own section is deleted", async () => {
+    // Sync resolves again what named a deleted file; another theme's 404
+    // section is no stand-in for the theme's own.
+    writeFiles({ ...severalThemes, 'examples/tailwind/sections/404.liquid': `<h1>404</h1>\n` });
+    cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    expect(cg.getFileDependencies('examples/tailwind/templates/404.json')).toEqual(['examples/tailwind/sections/404.liquid']);
+
+    fs.rmSync(path.join(tempDir, 'examples/tailwind/sections/404.liquid'));
+    await cg.sync();
+    expect(cg.getFileDependencies('examples/tailwind/templates/404.json')).toEqual([]);
+  });
+
+  it('links a section or snippet that appears after the files naming it', async () => {
+    // Sync retries a reference it could not resolve once a file it may name
+    // appears. A section or snippet reference was parked under its extension,
+    // `liquid`, which no file is named, so it stayed unlinked until the file
+    // naming it changed or the project was indexed again.
+    const later: Record<string, string> = {
+      'sections/404.liquid': `<h1>404</h1>\n`,
+      'snippets/price.liquid': severalThemes['snippets/price.liquid'],
+      // Only straps/dusk had a 404 section, which is no stand-in for this theme's own.
+      'examples/tailwind/sections/404.liquid': `<h1>404</h1>\n`,
+      'extensions/reviews/snippets/star.liquid': severalThemes['extensions/reviews/snippets/star.liquid'],
+    };
+    const initial = Object.fromEntries(Object.entries(severalThemes).filter(([file]) => !(file in later)));
+    writeFiles({ ...initial, 'templates/404.json': jsonTemplate('404') });
+    cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    const naming = ['templates/404.json', 'sections/header.liquid', 'examples/tailwind/templates/404.json',
+      'examples/tailwind/sections/header.liquid', 'extensions/reviews/blocks/stars.liquid'];
+    const links = (graph = cg) => Object.fromEntries(naming.map((file) => [file, graph.getFileDependencies(file).sort()]));
+    expect(links()).toEqual({
+      'templates/404.json': [],
+      'sections/header.liquid': [],
+      'examples/tailwind/templates/404.json': [],
+      'examples/tailwind/sections/header.liquid': ['examples/tailwind/snippets/icon.liquid'],
+      'extensions/reviews/blocks/stars.liquid': [],
+    });
+
+    writeFiles(later);
+    expect((await cg.sync()).filesAdded).toBe(4);
+    const synced = links();
+    expect(synced).toEqual({
+      'templates/404.json': ['sections/404.liquid'],
+      'sections/header.liquid': ['snippets/price.liquid'],
+      'examples/tailwind/templates/404.json': ['examples/tailwind/sections/404.liquid'],
+      // The root theme's new price snippet is not this theme's.
+      'examples/tailwind/sections/header.liquid': ['examples/tailwind/snippets/icon.liquid'],
+      'extensions/reviews/blocks/stars.liquid': ['extensions/reviews/snippets/star.liquid'],
+    });
+    expect(cg.getPendingReferenceCount()).toBe(0);
+    // A fresh index of the same files links the same. (Indexing again over
+    // this index would skip the unchanged files that name the new ones.)
+    const freshDir = createTempDir();
+    writeFiles({ ...severalThemes, 'templates/404.json': jsonTemplate('404'), ...later }, freshDir);
+    const fresh = CodeGraph.initSync(freshDir);
+    try {
+      await fresh.indexAll();
+      expect(links(fresh)).toEqual(synced);
+    } finally {
+      fresh.close();
+      fs.rmSync(freshDir, { recursive: true, force: true });
+    }
+
+    // A deleted snippet's references wait for it the same way.
+    fs.rmSync(path.join(tempDir, 'snippets/price.liquid'));
+    await cg.sync();
+    expect(cg.getFileDependencies('sections/header.liquid')).toEqual([]);
+    writeFiles({ 'snippets/price.liquid': later['snippets/price.liquid']! });
+    await cg.sync();
+    expect(cg.getFileDependencies('sections/header.liquid')).toEqual(['snippets/price.liquid']);
+  }, 60_000);
+
+  it('finds the theme a file is in from the theme folder it sits in', () => {
+    const markers = new Set(['layout/theme.liquid', 'examples/tailwind/config/settings_schema.json']);
+    const exists = (relativePath: string): boolean => markers.has(relativePath);
+    expect(shopifyThemeRoot('sections/header.liquid', exists)).toBe('');
+    expect(shopifyThemeRoot('templates/customers/login.json', exists)).toBe('');
+    expect(shopifyThemeRoot('examples/tailwind/snippets/icon.liquid', exists)).toBe('examples/tailwind');
+    // A copy kept elsewhere under the root theme is not part of it, nor is a file beside its folders.
+    expect(shopifyThemeRoot('vendor/legacy/snippets/icon.liquid', exists)).toBeUndefined();
+    expect(shopifyThemeRoot('theme.liquid', exists)).toBeUndefined();
+  });
 });
 
 describe('Lua/Luau require resolution', () => {
@@ -9165,6 +9438,33 @@ const token = getTokenMp();
     expect(call).toBeDefined();
   });
 
+  it.each(['LF', 'CRLF'])('should attribute calls in <script setup> destructuring and in the template to the component (%s, #2340)', (ending) => {
+    const lf = `<template>
+  <NuxtLink :to="useBar(link.location)">{{ useBar(link) }}</NuxtLink>
+  <li v-for="item in items" @click="item.open()">{{ label(item) }}</li>
+</template>
+
+<script setup lang="ts">
+const { a } = useFoo(1)
+const [b] = useFoo(2)
+</script>
+`;
+    const code = ending === 'CRLF' ? lf.replace(/\n/g, '\r\n') : lf;
+    const result = extractFromSource('Card.vue', code);
+    const component = result.nodes.find((n) => n.kind === 'component')!;
+    const calls = result.unresolvedReferences
+      .filter((r) => r.referenceKind === 'calls')
+      .map((r) => `${r.fromNodeId === component.id ? 'component' : r.fromNodeId}:${r.referenceName}@${r.line}`)
+      .sort();
+    expect(calls).toEqual([
+      'component:label@3',
+      'component:useBar@2',
+      'component:useBar@2',
+      'component:useFoo@7',
+      'component:useFoo@8',
+    ]);
+  });
+
   it('should extract calls from Vue Options API object methods', () => {
     const code = `<template>
   <button @click="save">Save</button>
@@ -9259,8 +9559,10 @@ function greet() {
     expect(componentNode?.name).toBe('Static');
     expect(componentNode?.language).toBe('vue');
 
-    // Only the component node should exist (no script nodes)
-    expect(result.nodes.length).toBe(1);
+    // The file and the component it is — no script nodes. (A file with no
+    // script used to have no file node at all.)
+    expect(result.nodes.map((n) => n.kind).sort()).toEqual(['component', 'file']);
+    expect(result.edges).toContainEqual(expect.objectContaining({ source: 'file:Static.vue', target: componentNode!.id, kind: 'contains' }));
   });
 
   it('should create containment edges from component to script nodes', () => {
@@ -11097,6 +11399,162 @@ import foo.cfm;
       expect(result.nodes.find((n) => n.name === 'innerHelper')?.kind).toBe('function');
     });
   });
+
+  describe('Calls in tag expressions outside <cfscript>/<cfquery> (#2091)', () => {
+    const callsFrom = (result: ReturnType<typeof extractFromSource>, fromId: string | undefined) =>
+      result.unresolvedReferences
+        .filter((r) => r.fromNodeId === fromId && (r.referenceKind === 'calls' || r.referenceKind === 'instantiates'))
+        .map((r) => `${r.referenceKind === 'instantiates' ? 'new ' : ''}${r.referenceName}@${r.line}`)
+        .sort();
+
+    it('should extract calls in <cfset>, <cfif>, <cfelseif> and <cfreturn>, attributed to the enclosing method', () => {
+      const code = `<cfcomponent>
+\t<cffunction name="a">
+\t\t<cfset x = b(1)>
+\t\t<cfif c(2)>
+\t\t<cfelseif e(3)>
+\t\t</cfif>
+\t\t<cfreturn d()>
+\t</cffunction>
+\t<cffunction name="b"></cffunction>
+</cfcomponent>
+`;
+      const result = extractFromSource('Svc.cfc', code);
+      const a = result.nodes.find((n) => n.kind === 'method' && n.name === 'a');
+      expect(a).toBeDefined();
+      expect(callsFrom(result, a?.id)).toEqual(['b@3', 'c@4', 'd@7', 'e@5']);
+    });
+
+    it('should extract #hash# expressions in output, strings and tag attributes — once each, alongside <cfquery> bodies', () => {
+      const code = `<cfcomponent>
+<cffunction name="render">
+  <cfset var y = svc.load(1)>
+  <cfset local.msg = "Hi #userName()#">
+  <cfoutput>#fmt(y)# and #variables.mailer.send()#</cfoutput>
+  <cfloop array="#getItems()#" index="i"></cfloop>
+  <cfquery name="q" datasource="#dsn()#">SELECT #col()# FROM t</cfquery>
+  <cfset obj = new Widget()>
+</cffunction>
+</cfcomponent>
+`;
+      const result = extractFromSource('View.cfc', code);
+      const render = result.nodes.find((n) => n.kind === 'method' && n.name === 'render');
+      expect(callsFrom(result, render?.id)).toEqual([
+        'col@7',
+        'dsn@7',
+        'fmt@5',
+        'getItems@6',
+        'new Widget@8',
+        'svc.load@3',
+        'userName@4',
+        'variables.mailer.send@5',
+      ]);
+      // `<cfset var y = …>` is a function local — no variable node for it.
+      expect(result.nodes.find((n) => n.name === 'y')).toBeUndefined();
+    });
+
+    it('should attribute component-scope and template-scope calls to the component and the file', () => {
+      const component = `<cfcomponent>\n<cfset setup()>\n<cffunction name="m"></cffunction>\n</cfcomponent>\n`;
+      const cfc = extractFromSource('Pseudo.cfc', component);
+      const cls = cfc.nodes.find((n) => n.kind === 'class');
+      expect(callsFrom(cfc, cls?.id)).toEqual(['setup@2']);
+
+      const template = `<cfset items = loadItems()>\n<cfoutput>#renderList(items)#</cfoutput>\n`;
+      const cfm = extractFromSource('index.cfm', template);
+      const file = cfm.nodes.find((n) => n.kind === 'file');
+      expect(callsFrom(cfm, file?.id)).toEqual(['loadItems@1', 'renderList@2']);
+    });
+
+    it("should keep each call's own line and column (several per line, and across lines)", () => {
+      const code = `<cfcomponent>
+<cffunction name="m"><cfset a()><cfif   b.c()><cfset d(e())></cfif>
+  <cfset total = sum(
+      count(), other.fetch())><cfoutput>#last()#</cfoutput>
+</cffunction>
+</cfcomponent>
+`;
+      const lines = code.split('\n');
+      const result = extractFromSource('Pos.cfc', code);
+      const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+      expect(calls.map((r) => r.referenceName).sort()).toEqual(['a', 'b.c', 'count', 'd', 'e', 'last', 'other.fetch', 'sum']);
+      for (const r of calls) {
+        expect(lines[r.line - 1]!.slice(r.column).startsWith(r.referenceName)).toBe(true);
+      }
+    });
+
+    it('should read a <cfloop condition="…"> attribute as an expression', () => {
+      const code = `<cfcomponent>\n<cffunction name="drain">\n<cfloop condition="hasNext()">\n</cfloop>\n</cffunction>\n</cfcomponent>\n`;
+      const result = extractFromSource('Queue.cfc', code);
+      const drain = result.nodes.find((n) => n.kind === 'method' && n.name === 'drain');
+      expect(callsFrom(result, drain?.id)).toEqual(['hasNext@3']);
+    });
+
+    it('should not read HTML <script> bodies or plain text as CFML calls', () => {
+      const code = `<cfcomponent>\n<cffunction name="page">\n<script>notACall();</script>\n<p>also(not)</p>\n</cffunction>\n</cfcomponent>\n`;
+      const result = extractFromSource('Page.cfc', code);
+      expect(result.unresolvedReferences.filter((r) => r.referenceKind === 'calls')).toEqual([]);
+    });
+  });
+
+  describe('<cffunction> inside a generic container tag (#2091)', () => {
+    it('should extract a method nested in <cfprocessingdirective> (the Application.cfc shape)', () => {
+      const code = `<cfcomponent>
+\t<cfprocessingdirective suppresswhitespace="true">
+\t\t<cffunction name="onRequestStart">
+\t\t\t<cfset loadConfig()>
+\t\t</cffunction>
+\t</cfprocessingdirective>
+</cfcomponent>
+`;
+      const result = extractFromSource('Application.cfc', code);
+      const cls = result.nodes.find((n) => n.kind === 'class');
+      const method = result.nodes.find((n) => n.kind === 'method' && n.name === 'onRequestStart');
+      expect(method).toBeDefined();
+      expect(method?.qualifiedName).toBe('Application::onRequestStart');
+      expect(result.edges.some((e) => e.kind === 'contains' && e.source === cls?.id && e.target === method?.id)).toBe(true);
+      const call = result.unresolvedReferences.find((r) => r.referenceName === 'loadConfig');
+      expect(call?.fromNodeId).toBe(method?.id);
+    });
+
+    it('should extract a top-level function nested in <cfsilent> in a template', () => {
+      const code = `<cfsilent>\n<cffunction name="helper"><cfreturn 1></cffunction>\n</cfsilent>\n`;
+      const result = extractFromSource('lib.cfm', code);
+      expect(result.nodes.find((n) => n.name === 'helper')?.kind).toBe('function');
+    });
+  });
+
+  describe('<cfinterface> (#2091)', () => {
+    const code = `<cfinterface extends="IBase, IOther">
+\t<cffunction name="search" access="public" returntype="any">
+\t\t<cfargument name="q" type="string">
+\t</cffunction>
+\t<cffunction name="count"></cffunction>
+</cfinterface>
+`;
+
+    it('should extract an interface node named from the file, with its functions as methods', () => {
+      const result = extractFromSource('ISearchable.cfc', code);
+      const iface = result.nodes.find((n) => n.kind === 'interface');
+      expect(iface?.name).toBe('ISearchable');
+      expect(iface?.startLine).toBe(1);
+      expect(iface?.endLine).toBe(6);
+      expect(result.nodes.filter((n) => n.kind === 'class')).toHaveLength(0);
+      const methods = result.nodes.filter((n) => n.kind === 'method');
+      expect(methods.map((m) => m.qualifiedName).sort()).toEqual(['ISearchable::count', 'ISearchable::search']);
+      for (const m of methods) {
+        expect(result.edges.some((e) => e.kind === 'contains' && e.source === iface?.id && e.target === m.id)).toBe(true);
+      }
+      expect(methods.find((m) => m.name === 'search')?.returnType).toBe('any');
+    });
+
+    it('should extract each interface it extends', () => {
+      const result = extractFromSource('ISearchable.cfc', code);
+      const iface = result.nodes.find((n) => n.kind === 'interface');
+      const ext = result.unresolvedReferences.filter((r) => r.referenceKind === 'extends');
+      expect(ext.map((r) => r.referenceName)).toEqual(['IBase', 'IOther']);
+      expect(ext.every((r) => r.fromNodeId === iface?.id)).toBe(true);
+    });
+  });
 });
 
 describe('COBOL Extraction', () => {
diff --git a/__tests__/fabric-view.test.ts b/__tests__/fabric-view.test.ts
index 84e6529404..857167d265 100644
--- a/__tests__/fabric-view.test.ts
+++ b/__tests__/fabric-view.test.ts
@@ -142,3 +142,55 @@ export function App() {
     // The full flow: App (TSX) → MyView (fabric-component) → MyViewView (ObjC native class)
   });
 });
+
+describe('Paper end-to-end: a requireNativeComponent module rendered under another name', () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'paper-fixture-'));
+  });
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('segmented-control: <RNCSegmentedControlNativeComponent> → requireNativeComponent("RNCSegmentedControl") → the native view', async () => {
+    const write = (rel: string, content: string) => {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    };
+    write('package.json', '{"dependencies":{"react-native":"^0.73"}}');
+    write('js/RNCSegmentedControlNativeComponent.js', `import { requireNativeComponent } from 'react-native';
+module.exports = requireNativeComponent('RNCSegmentedControl');
+`);
+    write('js/SegmentedControl.js', `import * as React from 'react';
+import RNCSegmentedControlNativeComponent from './RNCSegmentedControlNativeComponent';
+export default function SegmentedControl(props) {
+  return <RNCSegmentedControlNativeComponent {...props} />;
+}
+`);
+    write('ios/RNCSegmentedControl.m', `@implementation RNCSegmentedControl
+- (void)setValues:(NSArray *)values { }
+@end
+`);
+    write('ios/RNCSegmentedControlManager.m', `@implementation RNCSegmentedControlManager
+RCT_EXPORT_MODULE()
+RCT_EXPORT_VIEW_PROPERTY(values, NSArray)
+@end
+`);
+    const cg = await CodeGraph.init(dir, { index: true });
+    try {
+      const control = cg.getNodesByName('SegmentedControl').find((n) => n.filePath === 'js/SegmentedControl.js')!;
+      const rendered = cg.getOutgoingEdges(control.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!);
+      const component = rendered.find((n) => n.kind === 'component' && n.name === 'RNCSegmentedControl');
+      expect(component?.filePath).toBe('js/RNCSegmentedControlNativeComponent.js');
+      const native = cg
+        .getOutgoingEdges(component!.id)
+        .filter((e) => (e.metadata as Record<string, unknown> | undefined)?.synthesizedBy === 'fabric-native-impl')
+        .map((e) => cg.getNode(e.target)!)
+        .filter((n) => n.language === 'objc')
+        .map((n) => n.name);
+      expect(native).toContain('RNCSegmentedControl');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/fastendpoints-routes.test.ts b/__tests__/fastendpoints-routes.test.ts
new file mode 100644
index 0000000000..43ba746c1e
--- /dev/null
+++ b/__tests__/fastendpoints-routes.test.ts
@@ -0,0 +1,104 @@
+/**
+ * FastEndpoints routes: an endpoint class declares its verb and path in
+ * `Configure()` — `Get("/Contributors")`, `Post(CreateContributorRequest.Route)`
+ * with the constant in the request's own file — and handles the request in
+ * its own `HandleAsync` / `ExecuteAsync`. ardalis/CleanArchitecture had no
+ * routes at all. A minimal API's `app.MapGet("api/todos", …)` serves
+ * `/api/todos`.
+ */
+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-fastendpoints-'));
+  const files: Record<string, string> = {
+    'src/Web/Contributors/Create.CreateContributorRequest.cs': `namespace Web.Contributors;
+
+public class CreateContributorRequest
+{
+  public const string Route = "/Contributors";
+  public string Name { get; set; } = "";
+}
+`,
+    'src/Web/Contributors/Create.cs': `namespace Web.Contributors;
+
+public class Create : Endpoint<CreateContributorRequest, CreateContributorResponse>
+{
+  public override void Configure()
+  {
+    Post(CreateContributorRequest.Route);
+    AllowAnonymous();
+  }
+
+  public override async Task ExecuteAsync(CreateContributorRequest request, CancellationToken ct)
+  {
+  }
+}
+`,
+    'src/Web/Contributors/List.cs': `namespace Web.Contributors;
+
+public class List : EndpointWithoutRequest<ContributorListResponse>
+{
+  public override void Configure()
+  {
+    Get("/Contributors");
+    AllowAnonymous();
+  }
+
+  public override async Task HandleAsync(CancellationToken ct)
+  {
+  }
+}
+`,
+    'src/Web/Projects/List.cs': `namespace Web.Projects;
+
+public class List : EndpointWithoutRequest<ProjectListResponse>
+{
+  public override void Configure()
+  {
+    Get($"/{nameof(Project)}s");
+  }
+
+  public override async Task HandleAsync(CancellationToken ct)
+  {
+  }
+}
+`,
+    'src/Api/Program.cs': `var builder = WebApplication.CreateBuilder(args);
+var app = builder.Build();
+app.MapGet("api/todos", GetTodos);
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const handlerOf = (file: string): string[] => {
+  const route = cg.getNodesByKind('route').find((r) => r.filePath === file)!;
+  return cg.getOutgoingEdges(route.id).map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('FastEndpoints and minimal API routes', () => {
+  it('names each endpoint by its path, constant paths included, and links its own handler', () => {
+    const names = cg.getNodesByKind('route').map((r) => r.name).sort();
+    expect(names).toEqual(['GET /Contributors', 'GET /Projects', 'GET /api/todos', 'POST /Contributors']);
+    expect(handlerOf('src/Web/Contributors/Create.cs')).toEqual(['Web.Contributors::Create::ExecuteAsync']);
+    // Two classes named `List`: each route reaches its own class's handler.
+    expect(handlerOf('src/Web/Contributors/List.cs')).toEqual(['Web.Contributors::List::HandleAsync']);
+    expect(handlerOf('src/Web/Projects/List.cs')).toEqual(['Web.Projects::List::HandleAsync']);
+  });
+});
diff --git a/__tests__/file-routed-page-component.test.ts b/__tests__/file-routed-page-component.test.ts
new file mode 100644
index 0000000000..5f910756fa
--- /dev/null
+++ b/__tests__/file-routed-page-component.test.ts
@@ -0,0 +1,106 @@
+/**
+ * A file-routed page is served by the component its file is: Nuxt's
+ * `pages/admin.vue`, Astro's `src/pages/about.astro`. The route stood alone,
+ * so the viewer's Steps tab drew nothing for a page and the routes list never
+ * named what serves it — it did not list a component-served route at all,
+ * Vue Router's included. The link goes to the page file's OWN component,
+ * never a same-named one (every `index.vue` is a component named `index`),
+ * and an Astro endpoint is served by the verbs it exports.
+ */
+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';
+import { buildRoutes } from '../src/ui-server/api/routes';
+
+const projects: Record<string, Record<string, string>> = {
+  nuxt: {
+    'package.json': JSON.stringify({ name: 'shop', private: true, dependencies: { nuxt: '^3.0.0' } }),
+    'pages/index.vue': `<template><button @click="load">Load</button></template>
+<script setup lang="ts">
+function load() { return 1; }
+</script>
+`,
+    'pages/admin.vue': `<template><div>admin</div></template>
+`,
+    'pages/orders/index.vue': `<template><div>orders</div></template>
+`,
+    'components/index.vue': `<template><div>not a page</div></template>
+`,
+  },
+  astro: {
+    'package.json': JSON.stringify({ name: 'site', private: true, dependencies: { astro: '^4.0.0' } }),
+    'src/pages/index.astro': `---
+const title = 'Home';
+---
+<h1>{title}</h1>
+`,
+    'src/pages/about.astro': `<p>about</p>
+`,
+    'src/pages/blog/index.astro': `<p>blog</p>
+`,
+    'src/pages/api/hello.ts': `export const GET = async () => new Response('hi');
+export async function POST() { return new Response('ok'); }
+`,
+  },
+};
+
+const graphs: Record<string, { root: string; cg: CodeGraph }> = {};
+
+beforeAll(async () => {
+  for (const [name, files] of Object.entries(projects)) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `cg-page-${name}-`));
+    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);
+    }
+    graphs[name] = { root, cg: await CodeGraph.init(root, { index: true }) };
+  }
+});
+
+afterAll(() => {
+  for (const { root, cg } of Object.values(graphs)) {
+    cg.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+/** route name → the files of what it calls or references. */
+function served(cg: CodeGraph): Record<string, string[]> {
+  const out: Record<string, string[]> = {};
+  for (const route of cg.getNodesByKind('route')) {
+    out[route.name] = cg.getOutgoingEdgesFrom([route.id], ['calls', 'references'])
+      .map((e) => cg.getNode(e.target)!)
+      .map((n) => `${n.kind} ${n.filePath}`);
+  }
+  return out;
+}
+
+describe('a Nuxt page', () => {
+  it('is served by its own file’s component', () => {
+    const map = served(graphs.nuxt!.cg);
+    expect(map['/']).toEqual(['component pages/index.vue']);
+    expect(map['/admin']).toEqual(['component pages/admin.vue']);
+    expect(map['/orders']).toEqual(['component pages/orders/index.vue']);
+  });
+
+  it('is listed with the component that serves it', () => {
+    const { entries } = buildRoutes(graphs.nuxt!.cg, new URLSearchParams());
+    expect(entries.map((e) => `${e.url} ${e.handler} ${e.file}`).sort()).toEqual([
+      '/ index pages/index.vue',
+      '/admin admin pages/admin.vue',
+      '/orders index pages/orders/index.vue',
+    ]);
+  });
+});
+
+describe('an Astro page', () => {
+  it('is served by its own file’s component, and an endpoint by the verbs it exports', () => {
+    const map = served(graphs.astro!.cg);
+    expect(map['/']).toEqual(['component src/pages/index.astro']);
+    expect(map['/about']).toEqual(['component src/pages/about.astro']);
+    expect(map['/blog']).toEqual(['component src/pages/blog/index.astro']);
+    expect(map['/api/hello']).toEqual(['function src/pages/api/hello.ts', 'function src/pages/api/hello.ts']);
+  });
+});
diff --git a/__tests__/fixtures/kernel-parity/Torture.cs b/__tests__/fixtures/kernel-parity/Torture.cs
index 520b1d4e32..39e7743dbe 100644
--- a/__tests__/fixtures/kernel-parity/Torture.cs
+++ b/__tests__/fixtures/kernel-parity/Torture.cs
@@ -179,3 +179,8 @@ namespace Torture.Beta
 {
     public class Other { }
 }
+
+static class TopLevelGuard
+{
+    public static T AgainstNull<T>(T value) where T : class => value;
+}
diff --git a/__tests__/fixtures/kernel-parity/Torture.java b/__tests__/fixtures/kernel-parity/Torture.java
index 9ecb8d823b..d1e71cbd20 100644
--- a/__tests__/fixtures/kernel-parity/Torture.java
+++ b/__tests__/fixtures/kernel-parity/Torture.java
@@ -79,6 +79,27 @@ Direction opposite() {
     }
   }
 
+  enum Step {
+    NEXT(1) {
+      @Override
+      int apply(int at) {
+        return clamp(at + size);
+      }
+    },
+    BACK(-1) {
+      @Override
+      int apply(int at) { return at + size; }
+    };
+
+    final int size;
+
+    Step(int size) { this.size = size; }
+
+    abstract int apply(int at);
+
+    static int clamp(int at) { return Math.max(0, at); }
+  }
+
   interface Listener {
     void onChange(TortureService svc);
   }
diff --git a/__tests__/fixtures/kernel-parity/TortureAnnotatedComments.dart b/__tests__/fixtures/kernel-parity/TortureAnnotatedComments.dart
new file mode 100644
index 0000000000..87d32a23da
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureAnnotatedComments.dart
@@ -0,0 +1,175 @@
+// An annotation belongs to the declaration after it, whatever comments come
+// between them; the decorator scan steps over `//`, `/* */`, `///` and
+// `/** */` comments. Anything else before the annotations still ends it.
+
+import 'package:meta/meta.dart';
+// A comment after the import.
+@visibleForTesting
+// And one below the annotation.
+void afterImport() {}
+
+@x // A comment on the annotation's line.
+void trailing() {}
+
+@override
+// ignore: must_call_super
+void lineBelow() {}
+
+@x
+/// Doc below an annotation.
+void docBelow() {}
+
+@x
+/** Block doc below an annotation. */
+void blockDocBelow() {}
+
+@x
+/* A block comment. */
+void blockBelow() {}
+
+@a
+// one
+@b
+/// two
+/* three */
+@c
+// four
+void interleaved() {}
+
+@riverpod
+// expect_lint: functional_ref
+int counter(Ref ref) => 0;
+
+@x
+// A comment.
+
+void blankLines() {}
+
+@pragma('vm:external-name', 'f')
+// A comment.
+external int extTop();
+
+@x
+// A comment.
+int get topGetter => 1;
+
+@x
+final answer = 42;
+// A comment.
+void afterVariable() {}
+
+void before() {} // A trailing comment.
+@x
+void afterBody() {}
+
+class C {
+  @override
+  // ignore: must_call_super
+  void method() {}
+
+  @x /* inline */ void inline() {}
+
+  @override
+  // A comment.
+  void bodiless();
+
+  @x
+  // A comment.
+  C.named() {}
+
+  @literal
+  // A comment.
+  const C.c();
+
+  @x
+  /// Doc below.
+  factory C.make() => C._();
+
+  @x
+  // A comment.
+  const factory C.r() = C.c;
+
+  @x
+  // A comment.
+  static void s() {}
+
+  @override
+  // A comment.
+  bool operator ==(Object other) => true;
+
+  @override
+  // A comment.
+  int get value => 1;
+
+  @override
+  // A comment.
+  set value(int v) {}
+
+  @x
+  // A comment.
+  external void ext();
+
+  /// Doc above.
+  @a
+  // between
+  @b
+  void docAbove() {}
+
+  @JsonKey(name: 'f')
+  final int f = 0;
+  // A comment after a field.
+  @override
+  void afterField() {}
+
+  void prior() {} // A trailing comment.
+  @override
+  void afterMember() {}
+
+  C._();
+}
+
+@immutable
+// ignore: something
+class D {}
+
+@internal
+// A comment.
+mixin M on C {
+  @mustCallSuper
+  // A comment.
+  void m() {}
+}
+
+@internal
+// A comment.
+extension X on C {
+  @pragma('vm:prefer-inline')
+  // A comment.
+  void e() {}
+}
+
+@internal
+/// Doc below.
+extension type Meters(double value) {
+  @redeclare
+  // A comment.
+  double km() => value / 1000;
+}
+
+enum Mode {
+  @JsonValue('on')
+  // A comment.
+  on,
+  off;
+
+  @override
+  // A comment.
+  String toString() => name;
+}
+
+void outer() {
+  @pragma('vm:prefer-inline')
+  // A comment.
+  void local() {}
+  local();
+}
diff --git a/__tests__/fixtures/kernel-parity/TortureAnnotatedDocs.dart b/__tests__/fixtures/kernel-parity/TortureAnnotatedDocs.dart
new file mode 100644
index 0000000000..efd5b95621
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureAnnotatedDocs.dart
@@ -0,0 +1,193 @@
+// A member's annotations sit between it and the dartdoc written above them;
+// the docstring walk steps over them. A class-like declaration opens with its
+// annotations, so the dartdoc above them precedes its node.
+
+import 'package:meta/meta.dart';
+
+@visibleForTesting
+void afterImport() {}
+
+/// Top function doc.
+@pragma('vm:entry-point')
+void top() {}
+
+/// External top doc.
+@pragma('vm:external-name', 'f')
+external int extTop();
+
+/// Stacked, prefixed and generic annotations.
+@meta.immutable
+@JsonSerializable<Foo>(explicitToJson: true)
+@Deprecated('x')
+void stacked() {}
+
+/// Top getter doc (no node).
+@x
+int get topGetter => 1;
+
+/** Block dartdoc above an annotation. */
+@x
+void blockDoc() {}
+
+// Plain comment above an annotation.
+@x
+void plainAbove() {}
+
+/* Inline block */ @x void inlineBlock() {}
+
+/// a
+@x
+// b
+@y
+/* c */
+void interleaved() {}
+
+/// Doc, then blank lines.
+
+@x
+
+void blanks() {}
+
+/// A variable's doc.
+final answer = 42;
+@x
+void afterVariable() {}
+
+const kLimit = 3;
+@x
+void afterConst() {}
+
+class C {
+  /// Operator doc.
+  @override
+  bool operator ==(Object other) => true;
+
+  /// Factory doc.
+  @x
+  factory C.make() => C._();
+
+  /// Bodied constructor doc.
+  @x
+  C.named() {}
+
+  /// Static method doc.
+  @x
+  static void s() {}
+
+  /// External member doc.
+  @x
+  external void extMember();
+
+  /// Bodiless member doc.
+  @override
+  void bodiless();
+
+  /// Const constructor doc.
+  @literal
+  const C.c();
+
+  /// Redirecting factory doc.
+  @x
+  const factory C.r() = C.c;
+
+  /// Static field doc.
+  @x
+  static const int k = 1;
+  @x
+  void afterStaticField() {}
+
+  /// Multi-line annotation.
+  @Deprecated(
+    'Use other. '
+    'Removed in 3.0',
+  )
+  void multi() {}
+
+  @override // ignore: must_call_super
+  void trailingComment() {}
+
+  /// Doc above, ignore below.
+  @override
+  // ignore: invalid_use_of_protected_member
+  void ignoreBelow() {}
+
+  @x
+  /// Doc below an annotation.
+  void docBelow() {}
+
+  /// Field doc.
+  @JsonKey(name: 'x')
+  final int field = 0;
+  @override
+  void afterField() {}
+
+  void before() {} // trailing comment
+  @override
+  void afterBody() {}
+
+  /// Getter doc.
+  @override
+  int get value => 1;
+
+  /// Setter doc.
+  @override
+  set value(int v) {}
+
+  C._();
+}
+
+/// Class doc above a comment.
+@immutable
+// ignore: something
+class D {}
+
+@immutable
+/// Class doc below an annotation.
+class E {}
+
+/// Mixin doc.
+@internal
+mixin M on C {
+  /// Mixin member doc.
+  @mustCallSuper
+  void m() {}
+}
+
+/// Extension doc.
+@internal
+extension X on C {
+  /// Extension member doc.
+  @pragma('vm:prefer-inline')
+  void e() {}
+}
+
+/// Extension type doc.
+@internal
+extension type Meters(double value) {
+  /// Extension type member doc.
+  @redeclare
+  double km() => value / 1000;
+}
+
+/// Enum doc.
+@JsonEnum()
+enum Mode {
+  @JsonValue('on')
+  on,
+  off;
+
+  /// Enum member doc.
+  @override
+  String toString() => name;
+}
+
+/// Typedef doc.
+@internal
+typedef Cb = void Function();
+
+void outer() {
+  /// Local function doc.
+  @pragma('vm:prefer-inline')
+  void local() {}
+  local();
+}
diff --git a/__tests__/fixtures/kernel-parity/TortureCommentChains.dart b/__tests__/fixtures/kernel-parity/TortureCommentChains.dart
new file mode 100644
index 0000000000..f39d4eda8a
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureCommentChains.dart
@@ -0,0 +1,77 @@
+// Comments inside member chains. tree-sitter-dart keeps a comment as a named
+// sibling between a chain's parts; every sibling step skips it, so each line
+// emits what it would without the comment.
+import 'package:flutter_test/flutter_test.dart';
+
+class ConfigT {
+  static final ConfigT instance = ConfigT();
+  static ConfigT load() => ConfigT();
+  int setting = 0;
+}
+
+class FactoryT {
+  static FactoryT create() => FactoryT();
+  void run() {}
+}
+
+class Box {
+  int get area => 1;
+  int grow(int by) => by;
+}
+
+// An initializer, walked for its constant.
+final initialized = ConfigT //
+    .instance;
+
+class Chains extends Box {
+  void calls(WidgetTester tester, Box box, List<int> xs) {
+    // dart format's line-break idiom, a whole-line comment, dartdoc, a run of
+    // block comments.
+    tester //
+        .state(find.byType(Box));
+    tester
+        // a whole-line comment
+        .pump();
+    tester /// doc
+        .a();
+    tester /** doc */ .b();
+    tester /* c */ /* d */ .c();
+    // A comment between the member and its arguments.
+    tester.d // c
+        ();
+    box.grow /* by */ (3);
+    // Chains: re-encoded off a capitalized call, bare off a lowercase one.
+    FactoryT.create() //
+        .run();
+    FactoryT //
+        .create() //
+        .run();
+    xs //
+        .map((e) => e) //
+        .toList();
+    // `this` / `super` keep the bare name.
+    this //
+        .grow(1);
+    super //
+        .grow(2);
+  }
+
+  int reads(Box box, WidgetTester tester) {
+    final v = box //
+        .area;
+    final w = box.area /* c */ .isEven;
+    final s = ConfigT //
+        .instance;
+    ConfigT // static call: a call and a static reference
+        .load();
+    final t = ConfigT /* setting */ .instance.setting;
+    // A generic call the grammar reads as two comparisons.
+    final st = tester //
+        .state<ProviderScopeState>(find.byType(Box));
+    // A comment against the `<`: not laid out as a call, so a read and two
+    // comparisons, as written.
+    final cr = tester.read /* c */<Box>(box);
+    final dr = tester.read /** doc */<Box>(box);
+    return v + w.hashCode + s.setting + t + st.hashCode;
+  }
+}
diff --git a/__tests__/fixtures/kernel-parity/TortureConstCtors.dart b/__tests__/fixtures/kernel-parity/TortureConstCtors.dart
new file mode 100644
index 0000000000..3d23bce806
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureConstCtors.dart
@@ -0,0 +1,86 @@
+import 'package:meta/meta.dart';
+import 'package:other/other.dart' as p;
+
+const kDepth = 3;
+
+/// A provider with const constructors and redirecting factories.
+class ProviderT<T> {
+  /// The unnamed const constructor: no node.
+  const ProviderT({required this.create, this.lazy = true}) : _value = null;
+
+  /// A named const constructor that redirects.
+  const ProviderT.value({required T value, int depth = kDepth})
+      : this._(value: value);
+
+  @visibleForTesting
+  const ProviderT._({T? value})
+      : create = null,
+        lazy = false,
+        _value = value;
+
+  const factory ProviderT.redirect({int a}) = _ImplT<T>;
+
+  factory ProviderT.plain() = _ImplT<T>.named;
+
+  const factory ProviderT.json(Map<String, Object?> json) = _ImplT.fromJson;
+
+  const factory ProviderT.prefixed() = p.OtherT;
+
+  const factory ProviderT.prefixedNamed() = p.OtherT.named;
+
+  const factory ProviderT.unnamedTarget() = _ImplT;
+
+  const factory ProviderT() = _ImplT.named;
+
+  final Object? create;
+  final bool lazy;
+  final T? _value;
+
+  void handle(Object value) => accept(value);
+
+  static ProviderT<int> make() => ProviderT<int>.value(value: 1);
+
+  static Object typed(dynamic box) {
+    ProviderT<int>.value(value: 2);
+    final made = ProviderT<int>.value(value: 3);
+    accept(ProviderT<int>.value(value: 4));
+    wrap(child: ProviderT<int>.value(value: 5));
+    box.inner.value(6);
+    return p.OtherT<int>.named(made);
+  }
+}
+
+class _ImplT<T> extends ProviderT<T> {
+  const _ImplT({int a = 0}) : super._();
+
+  const _ImplT.named() : super._();
+
+  const _ImplT.fromJson(Map<String, Object?> json) : super._();
+}
+
+class _$GeneratedT {
+  const _$GeneratedT.create();
+}
+
+enum StatusT {
+  ok(200),
+  gone.named(410);
+
+  const StatusT(this.code);
+
+  const StatusT.named(this.code);
+
+  final int code;
+}
+
+extension type const MetersT(int value) {
+  const MetersT.zero() : this(0);
+}
+
+final topProvider = ProviderT<int>.value(value: 7);
+
+Object build() => ProviderT.value(value: 8);
+
+void accept(Object o) {}
+
+void wrap({required Object child}) {}
diff --git a/__tests__/fixtures/kernel-parity/TortureDeclarationDocs.dart b/__tests__/fixtures/kernel-parity/TortureDeclarationDocs.dart
new file mode 100644
index 0000000000..b93a0bdd5e
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureDeclarationDocs.dart
@@ -0,0 +1,112 @@
+// Members with no body are a `declaration` wrapping their signature; their
+// dartdoc and annotations sit before the wrapper.
+
+abstract class Store {
+  /// Abstract method doc.
+  Future<void> save(Object value);
+
+  /// Doc above an annotation.
+  @protected
+  void flush();
+
+  @mustCallSuper
+  @Deprecated('use flush')
+  void sync();
+
+  /// Abstract getter doc (no node).
+  int get size;
+
+  /// Abstract setter doc (no node).
+  set size(int v);
+
+  /// Abstract operator doc (no node).
+  Store operator +(Store other);
+
+  /** Block dartdoc on an external member. */
+  external int nativeCount();
+
+  /// Static external doc.
+  external static Store open();
+
+  // Plain comment on an abstract member.
+  bool isEmpty();
+}
+
+class Point {
+  /// Unnamed constructor doc (no node).
+  Point(this.x, this.y);
+
+  /// Named constructor doc.
+  /// Second line.
+  Point.origin() : x = 0, y = 0;
+
+  /// Redirecting constructor doc.
+  Point.onX(int x) : this(x, 0);
+
+  @visibleForTesting
+  Point.test(this.x, this.y);
+
+  /// Before annotation.
+  @Deprecated('use origin')
+  /// After annotation.
+  Point.zero() : x = 0, y = 0;
+
+  /* é */ @visibleForTesting Point.inline(this.x) : y = 0;
+
+  /// Field doc.
+  @observable
+  final int x;
+  Point.afterField(this.x, this.y);
+
+  @first
+  Point.prev(this.x, this.y);
+  Point.next(this.x, this.y);
+
+  final int y;
+
+  /// Const constructor doc.
+  @literal
+  const Point.c(this.x, this.y);
+
+  /// Redirecting factory doc.
+  const factory Point.r(int x, int y) = Point;
+
+  /// Bodied named constructor doc.
+  @visibleForTesting
+  Point.bodied(this.x, this.y) {
+    validate();
+  }
+
+  void validate() {}
+}
+
+mixin Walker {
+  /// Mixin abstract doc.
+
+  void walk();
+}
+
+extension Ext on String {
+  /// Extension external doc.
+  @pragma('vm:prefer-inline')
+  external String shout();
+}
+
+extension type Meters(double value) {
+  /// Extension type external doc.
+  external double km();
+}
+
+enum Mode {
+  on,
+  off;
+
+  /// Enum const constructor doc (no node).
+  const Mode();
+
+  /// Enum external doc.
+  external bool get isOn;
+
+  /// Enum external method doc.
+  external void toggle();
+}
diff --git a/__tests__/fixtures/kernel-parity/TortureDirectives.dart b/__tests__/fixtures/kernel-parity/TortureDirectives.dart
new file mode 100644
index 0000000000..242a7a8986
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureDirectives.dart
@@ -0,0 +1,43 @@
+/// A library's directives: imports and exports in every form, and its parts.
+library torture.directives;
+
+import 'dart:async';
+import 'package:torture/other.dart' as other show OtherClass, otherFn;
+import 'package:torture/hidden.dart' hide Hidden;
+import 'src/conditional_stub.dart'
+    if (dart.library.io) 'src/conditional_io.dart'
+    if (dart.library.js_interop) 'src/conditional_web.dart';
+import 'src/deferred.dart' deferred as lazy;
+
+@Tag(viaImport)
+import 'src/annotated.dart';
+
+export 'src/exported.dart' show Exported;
+@Tag(viaExport)
+export 'src/annotated_export.dart';
+
+// Parts: in a subdirectory, above this one, by package: URI, in each quote
+// style, with comments inside and around, and annotated.
+part 'directives.g.dart';
+part "src/directives_part.dart";
+part '../shared_part.dart';
+part 'package:torture/src/package_part.dart';
+part '''triple_part.dart''';
+part /* generated */ 'commented_part.dart'; // trailing
+part
+    'wrapped_part.dart';
+@Tag(viaPart)
+part 'annotated_part.dart';
+@Tag([viaPartList, viaPart])
+part 'annotated_list_part.dart';
+
+class Tag {
+  const Tag(Object value);
+}
+
+void viaImport() {}
+void viaExport() {}
+void viaPart() {}
+void viaPartList() {}
+
+String describe() => 'directives';
diff --git a/__tests__/fixtures/kernel-parity/TortureGenericCalls.dart b/__tests__/fixtures/kernel-parity/TortureGenericCalls.dart
new file mode 100644
index 0000000000..7c09f1b981
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureGenericCalls.dart
@@ -0,0 +1,62 @@
+// Generic calls tree-sitter-dart parses as two comparisons — `ref.read<Repo>(p)`
+// comes out as `(ref.read < Repo) > (p)` — recovered as calls, and the
+// comparisons that look like them.
+import 'package:app/app.dart' as p;
+
+// Initializers: a constant's, a top-level variable's, a field's.
+final counterProvider = Provider<int>((ref) => ref.watch<int>(seedProvider));
+final repoProvider = Provider<Repo>((ref) {
+  final dio = ref.read<Dio>(dioProvider);
+  return Repo(dio);
+});
+var cache = Cache<String>(capacity: 10);
+final routes = [MaterialPageRoute<void>(builder: (_) => const Home())];
+
+int g(Ref ref) => ref.read<int>(1);
+
+class Screen {
+  final notifier = ValueNotifier<int>(0);
+  static final route = MaterialPageRoute<void>(builder: (_) => const Screen());
+  static var shared = Notifier<Repo>(repoProvider);
+
+  const Screen();
+
+  Future<void> load(Ref ref, BuildContext context) async {
+    ref.read<Repo>(repoProvider);
+    final user = await ref.read<UserRepository>(userRepoProvider).fetch<User>(id);
+    final map = ref.read<Map<String, Repo>>(mapProvider);
+    final prefixed = ref.read<p.Repo>(repoProvider);
+    final generic = ref.read<p.Box<Repo>>(boxProvider);
+    BlocProvider.of<CounterCubit>(context).increment();
+    final state = BlocProvider.of<CounterCubit>(context).state;
+    final neg = -ref.read<int>(countProvider);
+    final not = !ref.read<bool>(flagProvider);
+    final nested = Wrapper<A>(Inner<B>(seed));
+    final bare = build<Repo>(seed);
+    final dyn = await box.openBox<dynamic>('box');
+    final chained = Factory.create<Repo>(seed).build();
+    final lower = repo.items.where<Item>(isDone).toList();
+    final self = this.read<Repo>(repoProvider);
+    final cascade = Builder<Repo>(seed)..name = 'x';
+    final templ = '${ref.read<Repo>(repoProvider)}';
+    final sum = ref.watch<int>(countProvider) + 1;
+    return show<void>(context: context, builder: (_) => const Screen());
+  }
+
+  void outer(Ref ref) {
+    int inner() => ref.watch<int>(innerProvider);
+    final cb = () => navigator.push<void>(any());
+    inner();
+  }
+
+  bool compare(int a, int b, int c, int d) {
+    // Comparisons, not calls.
+    final spaced = a < B > (c);
+    final lower = a<b>(c);
+    final left = a <B>(c);
+    final right = a<B> (c);
+    final expr = a < b + 1 > (c);
+    final record = a<(B, C)>(d);
+    return a < b && c > d;
+  }
+}
diff --git a/__tests__/fixtures/kernel-parity/TortureInitializers.dart b/__tests__/fixtures/kernel-parity/TortureInitializers.dart
new file mode 100644
index 0000000000..35d71ff68d
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureInitializers.dart
@@ -0,0 +1,89 @@
+// Calls, instantiations, reads and function values written in initializers:
+// top-level variables and constants, and fields of every member body kind.
+import 'package:app/model.dart';
+
+int compute(int n) => n;
+void onTap() {}
+void register(Object o) {}
+Widget build() => Widget(0);
+
+// final / const: the constant owns its initializer.
+final repoProvider = Provider((ref) => Repository(ref.watch(dioProvider)));
+final counterProvider = StateNotifierProvider<Counter, int>((ref) => Counter(ref.read(apiProvider)));
+final blockProvider = Provider((ref) {
+  final dio = Dio.create(compute(1));
+  void local(int x) {
+    register(x);
+  }
+  local(2);
+  return Repository(dio)..init()..start();
+});
+const shared = Widget.named(3);
+const made = const Pair<int, Widget>(1, Widget(2));
+final created = new Widget(compute(4));
+final chained = Widget.factory().configure().run();
+final reads = Config.instance.name;
+final label = 'total ${compute(5)} of $shared';
+final cb = onTap;
+final wired = register(onTap);
+final table = [onTap, build];
+final byName = {'tap': onTap, 'build': build};
+final first = compute(6), second = Widget(7);
+final Provider<Widget> typed = Provider((ref) => build());
+final asyncProvider = FutureProvider((ref) async => await load(ref));
+final viaTypedParam = Provider((Ref ref) => ref.watch(dioProvider).value);
+
+// var / typed / late: the file owns the initializer.
+var counter = compute(8);
+Widget top = build();
+late final lazy = Widget(compute(9));
+var list = <Widget>[Widget(10), build()], other = compute(11);
+int plain = 0;
+
+class Holder {
+  static final instance = Holder._(compute(12));
+  static const empty = Holder._(0);
+  static var cache = Widget(compute(13));
+  static Widget typedStatic = build();
+  final made = Widget(14);
+  late final lazyField = compute(size);
+  var callbacks = [onTap];
+  final Widget other = Widget.named(15), more = build();
+  final int size;
+  Holder._(this.size);
+
+  int run() {
+    var total = 0;
+    for (var i = 0, j = compute(16); i < j; i++) {
+      total += i;
+    }
+    final local = Widget(17), again = compute(18);
+    return total;
+  }
+}
+
+mixin Tracking {
+  static var tracker = Tracker.start();
+  final events = <Event>[Event('init')];
+}
+
+extension Formatting on String {
+  static final formatter = Formatter(compute(19));
+  static var counter = compute(20);
+}
+
+enum Mode {
+  fast,
+  slow;
+
+  static final byName = {for (final m in Mode.values) m.name: m};
+  static const fallback = Mode.fast;
+  final weight = 1;
+}
+
+extension type Meters(int value) {
+  static var unit = Unit.create('m');
+}
+
+// Positions after multi-byte text are UTF-16 columns on both arms.
+final emoji = 'é😀'; final afterEmoji = compute(21); var alsoAfter = Widget(22);
diff --git a/__tests__/fixtures/kernel-parity/TorturePartOfName.dart b/__tests__/fixtures/kernel-parity/TorturePartOfName.dart
new file mode 100644
index 0000000000..d7de73a40b
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TorturePartOfName.dart
@@ -0,0 +1,10 @@
+/// A part of a library it names by library name, not by URI: the `part of`
+/// directive records nothing.
+@Tag(helper)
+part of torture.directives;
+
+class PartOfName {
+  void run() => helper();
+}
+
+void helper() {}
diff --git a/__tests__/fixtures/kernel-parity/TortureReadsTypes.dart b/__tests__/fixtures/kernel-parity/TortureReadsTypes.dart
new file mode 100644
index 0000000000..c84e34e551
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureReadsTypes.dart
@@ -0,0 +1,131 @@
+// Getter reads (#2338) and type positions outside signatures (#2327).
+import 'package:app/model.dart' as m;
+import 'package:app/model.dart';
+
+// The type an extension is `on`: plain, generic, prefixed, nullable.
+extension ReportX on Report {
+  bool get high => score > 5;
+}
+
+extension ListX<T extends Report> on List<T> {
+  int get total => length;
+}
+
+extension PrefixedX on m.Report? {
+  bool get present => this != null;
+}
+
+extension on Map<String, Report> {
+  int get size2 => length;
+}
+
+mixin Scored on Report {
+  int bump() => score + 1;
+}
+
+// Field declarations: instance, nullable, generic, static, late, prefixed,
+// function-typed, record-typed, untyped with a generic initializer.
+class Holder {
+  final Report report;
+  Report? maybe;
+  final List<Report> all = [];
+  static final Report fallback = Report(0);
+  static const List<Report> none = <Report>[];
+  late final m.Report prefixed;
+  final void Function(Report r)? onTap = null;
+  (Report, int)? pair;
+  var untyped = Family<Report?, String>();
+  final Map<String, List<Report>> byKey = {};
+  int count = 0, other = 1;
+
+  Holder(this.report);
+
+  Report get first => all.first;
+
+  int read(Holder h, Report r) {
+    final local = Holder(r);
+    return h.report.score + local.all.length + r.score + h.maybe!.score;
+  }
+}
+
+enum Grade {
+  a(null),
+  b(null);
+
+  const Grade(this.best);
+  final Report? best;
+  static const Grade top = Grade.a;
+  String get label => name;
+}
+
+// Top-level variables: typed, generic, function-typed, record-typed,
+// untyped with generic initializers, constants.
+Report? current;
+List<Report> history = [];
+void Function(Report)? listener;
+(Report, String) tagged = (Report(1), 'x');
+var plain = <Report>[];
+var counts = Map<String, Report>();
+final reportProvider = Family<Report?, String>();
+const empty = <Report>[];
+final handler = (Report r) => r.score;
+
+class Family<T, A> {
+  const Family();
+}
+
+class Config {
+  static Config get instance => Config();
+  String get name => 'cfg';
+  void load() {}
+}
+
+int reads(Holder h, Grade g, Report? r) {
+  // Plain and conditional reads, a static getter, an enum value.
+  final a = h.first;
+  final b = r?.score;
+  final c = Config.instance;
+  final d = Grade.top;
+  final e = g.label;
+  // Calls are not reads; the head of a chain is.
+  h.read(h, h.report);
+  Config.instance.load();
+  final f = h.report.score;
+  // Cascades, assignments and compound assignments are not reads.
+  h..maybe;
+  h.maybe = null;
+  h.count += 1;
+  // Reads inside interpolation, arguments, closures and nested functions.
+  print('${h.count} ${g.label}');
+  final cb = (Holder x) => x.first;
+  int nested(Holder y) {
+    final List<Report> rs = y.all;
+    return y.count + rs.length;
+  }
+  return nested(h) + cb(h).score + (a.score) + (b ?? 0) + c.name.length + d.index + e.length + f;
+}
+
+Object types(Object o) {
+  // Local types, generic arguments, casts, type tests, catch types,
+  // collection literals; constructor calls stay calls.
+  final Report local = o as Report;
+  List<Report> xs = <Report>[local];
+  final Map<String, Report> byName = {'a': local};
+  final ys = <Report>{};
+  if (o is Report) {}
+  if (o is! Holder) {}
+  final f = Future<Report?>.value(null);
+  final g = Family<Report, m.Report>();
+  final made = Report(1);
+  final built = const Report(2);
+  final old = new Holder(local);
+  final generic = Family<Report, int>();
+  // Positions after multi-byte text are UTF-16 columns on both arms.
+  final label = 'é😀'; final Report? again = local; final n = again?.score;
+  try {
+    throw StateError('x');
+  } on StateError catch (_) {
+  } on FormatException {
+  }
+  return [xs, byName, ys, f, g, made, built, old, generic, label, n];
+}
diff --git a/__tests__/fixtures/kernel-parity/torture.c b/__tests__/fixtures/kernel-parity/torture.c
index 57e04a912c..a785980512 100644
--- a/__tests__/fixtures/kernel-parity/torture.c
+++ b/__tests__/fixtures/kernel-parity/torture.c
@@ -168,3 +168,23 @@ typedef union {
 } word_t;
 
 static unsigned int hdr_raw(union packet_hdr *h) { return h->raw; }
+
+/* struct, union and enum definitions in a declaration's type: each is a node
+   beside the declaration's variables, documented by the comment above the
+   declaration; an unnamed one takes the name of its first variable */
+static void noop_builtin(void) {}
+
+/* The parser's state. */
+static struct parse_state { int depth; const char *at; } parse_state, *active_state;
+static struct { int argc; char **argv; } SPT;
+static const struct { const char *name; void (*fn)(void); } builtin_table[] = {
+  { "noop", noop_builtin },
+};
+union { int i; float f; } scratch_word = { 0 };
+enum { MODE_IDLE, MODE_BUSY } current_mode;
+struct { int unused; } make_unnamed(void);
+
+static int declared_types_local(void) {
+  static struct { int hits; } local_stats;
+  return ++local_stats.hits + current_mode;
+}
diff --git a/__tests__/fixtures/kernel-parity/torture.cpp b/__tests__/fixtures/kernel-parity/torture.cpp
index b6b160f7ae..b2ba1ea089 100644
--- a/__tests__/fixtures/kernel-parity/torture.cpp
+++ b/__tests__/fixtures/kernel-parity/torture.cpp
@@ -108,6 +108,21 @@ void Widget::Tick(float Delta) { Health += Delta; }
 Config GlobalConfig;
 int build_number = 7;
 
+// class/struct/union/enum definitions in a declaration's type — nodes beside
+// the variables; an unnamed one takes its first variable's name
+void on_open() {}
+void on_close() {}
+namespace decl_types {
+/** The handler registry. */
+struct Registry {
+  int size() const { return 2; }
+  void (*handlers[2])() = {&on_open, &on_close};
+} registry;
+class Bar { void g() {} } bar, *pbar;
+static struct { int retries; } settings;
+enum { kIdle, kBusy } state;
+}  // namespace decl_types
+
 template <typename T>
 T compute_seed(T v) {
   return v + 1;
diff --git a/__tests__/fixtures/kernel-parity/torture.dart b/__tests__/fixtures/kernel-parity/torture.dart
index fa4f73b389..a76203e8ad 100644
--- a/__tests__/fixtures/kernel-parity/torture.dart
+++ b/__tests__/fixtures/kernel-parity/torture.dart
@@ -16,7 +16,7 @@ int blockDoc() => 1;
 // Plain comment doc.
 String plainDoc() => 'x';
 
-/// Broken by annotation.
+/// Kept past the annotation.
 @deprecated
 void annotated() {}
 
diff --git a/__tests__/fixtures/kernel-parity/torture.go b/__tests__/fixtures/kernel-parity/torture.go
index f89b8d429d..9bb6422bad 100644
--- a/__tests__/fixtures/kernel-parity/torture.go
+++ b/__tests__/fixtures/kernel-parity/torture.go
@@ -6,7 +6,7 @@ import (
 	pkga "example.com/other/pkga"
 )
 
-const MAX_ITEMS = 128
+const MAX_ITEMS = 128 // the line's own comment, not DefaultRegistry's doc
 
 var DefaultRegistry = NewRegistry()
 
@@ -14,9 +14,14 @@ var handlerTable = map[string]func(int){
 	"recv": TargetCb,
 }
 
+// Widget is documented above its own type declaration.
 type Widget struct {
 	*Base
 	Queryable
+	pkga.Embedded
+	*pkga.Pointer `json:"-"`
+	Stack[int]
+	error
 	name string
 }
 
@@ -24,14 +29,79 @@ type Stack[T any] struct {
 	items []T
 }
 
+// Units of time: the group's comment, no member's doc.
+type (
+	Seconds int
+	// Minutes is documented inside its group.
+	Minutes int
+)
+
 type Core interface {
 	Reader
+	pkga.Closer // qualified
+	Lister[int]
+	error
 	Marshal(v any) ([]byte, error)
 	Unmarshal(data []byte) error
 }
 
+type Number interface {
+	~int | ~float64
+}
+
+type Exact interface{ int64 }
+
 type Dur int
 
+// Aliases (`=`): the types they name are references; a literal makes a struct or interface.
+type Alias = pkga.Widget
+
+type (
+	LocalAlias = Widget
+	PtrAlias   = *Stack[int]
+	FnAlias    = func(w Widget) error
+	MapAlias   = map[string][]pkga.Item
+	Defined    Widget
+)
+
+type AnonAlias = struct {
+	*Base
+	n int
+}
+
+type IfaceAlias = interface {
+	Render() string
+}
+
+type WordAlias = uint
+
+// Defined types reference what they are defined from, but their own type
+// parameters, predeclared types and their own name written bare.
+type HandlerFunc func(*Widget, pkga.Item) error
+
+type HandlersChain []HandlerFunc
+
+type WatchChan <-chan *Stack[int]
+
+type (
+	Lookup  map[Dur][]*pkga.Widget
+	Grid    [MAX_ITEMS]Widget
+	Wrapped (Widget)
+	Item    pkga.Item
+	Nested  map[string]struct {
+		w Widget
+		*Base
+	}
+)
+
+type Tree[T any] []*Tree[T]
+
+type stateFn func(*Widget) stateFn
+
+func useAlias(a *Alias) LocalAlias {
+	return LocalAlias{}
+}
+
 func NewRegistry() *Registry {
 	w := Widget{name: "w"}
 	q := pkga.Widget{}
diff --git a/__tests__/fixtures/kernel-parity/torture.swift b/__tests__/fixtures/kernel-parity/torture.swift
index d0c4a3e06b..6cb31f010d 100644
--- a/__tests__/fixtures/kernel-parity/torture.swift
+++ b/__tests__/fixtures/kernel-parity/torture.swift
@@ -86,6 +86,13 @@ func freeFn(a: Int, cb: @escaping (Int) -> Void) -> Session? {
   x?.optCall()
   y!.forced()
   Foo.make().draw()
+  API.PackageController.GetRoute.query(on: db)
+  API.PackageController
+    .GetRoute.query(on: db)
+  API.Model(name: "x")
+  Self.Inner.make()
+  App.lower.call()
+  API.Ünicode.query()
   foo.bar().baz()
   "lit".upper()
   arr.map { $0.name }
diff --git a/__tests__/fixtures/older-daemon.cjs b/__tests__/fixtures/older-daemon.cjs
new file mode 100644
index 0000000000..a6535f4d9b
--- /dev/null
+++ b/__tests__/fixtures/older-daemon.cjs
@@ -0,0 +1,36 @@
+/**
+ * A daemon of an older release, listening where a current launcher does not
+ * look (#2335). On Windows, daemons before #2278 named their pipe after the
+ * project root as typed, so a newer launcher's probe never reaches them and
+ * only the project lock says where they are. Like a real daemon it holds the
+ * project's daemon and writer locks and answers the hello; on SIGTERM it lets
+ * go of whichever of the two locks still names it and exits, the shape of a
+ * real daemon's shutdown. (On Windows SIGTERM is TerminateProcess, and the
+ * stop clears what is left.)
+ *
+ *   node older-daemon.cjs <project root> <version> <socket path>
+ */
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+
+const [root, version, socketPath] = process.argv.slice(2);
+const dir = path.join(root, '.codegraph');
+const writeLock = (name, record) => fs.writeFileSync(path.join(dir, name), JSON.stringify(record) + '\n');
+
+const server = net.createServer((socket) => {
+  socket.end(JSON.stringify({ codegraph: version, pid: process.pid, socketPath, protocol: 1 }) + '\n');
+});
+server.listen(socketPath, () => {
+  writeLock('writer.pid', { pid: process.pid, mode: 'daemon', startedAt: Date.now(), ready: true });
+  writeLock('daemon.pid', { pid: process.pid, version, socketPath, startedAt: Date.now() });
+});
+process.on('SIGTERM', () => {
+  for (const name of ['writer.pid', 'daemon.pid']) {
+    const file = path.join(dir, name);
+    try {
+      if (JSON.parse(fs.readFileSync(file, 'utf8')).pid === process.pid) fs.unlinkSync(file);
+    } catch { /* already gone */ }
+  }
+  server.close(() => process.exit(0));
+});
diff --git a/__tests__/flask-url-rules.test.ts b/__tests__/flask-url-rules.test.ts
new file mode 100644
index 0000000000..b89b7b238f
--- /dev/null
+++ b/__tests__/flask-url-rules.test.ts
@@ -0,0 +1,74 @@
+/**
+ * Flask's imperative registration is a route too: `bp.add_url_rule(…)` with a
+ * `view_func=` (a function, or a class-based view's `X.as_view('name')`), and
+ * a project's own wrapper that hands a list of paths and a `view_func=` over
+ * — flaskbb registers every view through `register_view(bp, routes=[…],
+ * view_func=…)` and had no routes at all.
+ */
+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-flask-rules-'));
+  const files: Record<string, string> = {
+    'requirements.txt': 'flask\n',
+    'app/helpers.py': `def register_view(bp_or_app, routes, view_func, **kwargs):
+    for route in routes:
+        bp_or_app.add_url_rule(route, view_func=view_func, **kwargs)
+`,
+    'app/auth.py': `from flask import Blueprint
+from flask.views import MethodView
+from app.helpers import register_view
+
+auth = Blueprint("auth", __name__)
+
+
+class Login(MethodView):
+    def get(self):
+        return "form"
+
+    def post(self):
+        return "ok"
+
+
+def logout():
+    return "bye"
+
+
+register_view(auth, routes=["/login", "/signin"], view_func=Login.as_view("login"))
+auth.add_url_rule("/logout", "logout", logout, methods=["POST"])
+auth.add_url_rule("/health", view_func=logout)
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Flask add_url_rule routes', () => {
+  it('names each path and method, and links the view', () => {
+    const routes = cg.getNodesByKind('route').filter((r) => r.filePath === 'app/auth.py');
+    const handler = (name: string) => {
+      const route = routes.find((r) => r.name === name)!;
+      return cg.getOutgoingEdges(route.id).map((e) => cg.getNode(e.target)!.name);
+    };
+    expect(routes.map((r) => r.name).sort()).toEqual(['ANY /login', 'ANY /signin', 'GET /health', 'POST /logout']);
+    expect(handler('ANY /login')).toContain('Login');
+    expect(handler('POST /logout')).toContain('logout');
+    // The wrapper's own `add_url_rule(route, …)` names no path: no route there.
+    expect(cg.getNodesByKind('route').some((r) => r.filePath === 'app/helpers.py')).toBe(false);
+  });
+});
diff --git a/__tests__/flow-directed-exact-names.test.ts b/__tests__/flow-directed-exact-names.test.ts
new file mode 100644
index 0000000000..6636c837fa
--- /dev/null
+++ b/__tests__/flow-directed-exact-names.test.ts
@@ -0,0 +1,66 @@
+/**
+ * A directed Flow question ("how does X reach Y") names its two ends exactly,
+ * as the viewer's links write them — a symbol's own name. Names the free-text
+ * token filter drops were lost: an Objective-C selector (`initWithFrame:`), a
+ * Ruby predicate (`valid?`), a two-letter method (`ok`). The other end was
+ * then reported as naming nothing, though it was in the index.
+ */
+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';
+import { resolveNamedSymbolFlow } from '../src/graph/named-symbol-flow';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-flow-exact-'));
+  const files: Record<string, string> = {
+    'src/check.ts': `export function ok(): number {
+  return go();
+}
+
+export function go(): number {
+  return 1;
+}
+`,
+    'app/models/order.rb': `class Order
+  def save!
+    raise ArgumentError unless valid?
+  end
+
+  def valid?
+    true
+  end
+end
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const directed = (from: string, to: string) =>
+  resolveNamedSymbolFlow(cg, `${from} ${to}`, { mode: 'directed', from, to });
+
+describe('a directed flow question', () => {
+  it('reaches a two-letter name', () => {
+    const flow = directed('ok', 'go');
+    expect(flow.chains[0]?.steps.map((s) => s.node.name)).toEqual(['ok', 'go']);
+  });
+
+  it('reaches a name with punctuation', () => {
+    const flow = directed('save!', 'valid?');
+    expect(flow.tokens).toEqual(['save!', 'valid?']);
+    expect(flow.chains[0]?.steps.map((s) => s.node.name)).toEqual(['save!', 'valid?']);
+  });
+});
diff --git a/__tests__/flow-js.test.ts b/__tests__/flow-js.test.ts
new file mode 100644
index 0000000000..1c77e14797
--- /dev/null
+++ b/__tests__/flow-js.test.ts
@@ -0,0 +1,82 @@
+/**
+ * A Flow-typed `.js` file (`// @flow` in its leading comments) is read with the
+ * TSX grammar: the JavaScript grammar can't parse its annotations, and a
+ * `render(): React.Node` cut the class around it short — segmented-control's
+ * component came out with no methods. Flow's own syntax (`{| |}`, `?T`, an
+ * inexact object's `...`, `import typeof`, `opaque type`) is blanked first.
+ * A `.js` without the pragma is untouched.
+ */
+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';
+import { detectLanguage } from '../src/extraction/grammars';
+import { blankFlowSyntax } from '../src/extraction/languages/typescript';
+
+let root = '';
+let cg: CodeGraph;
+
+const FLOW = `/**
+ * @flow strict-local
+ * @format
+ */
+import typeof * as React from 'react';
+import * as React from 'react';
+
+type Props = $ReadOnly<{|
+  values: ?Array<string>,
+  onChange?: ?(event: {nativeEvent: {value: string}, ...}) => mixed,
+|}>;
+
+opaque type Token = string;
+
+class SegmentedControl extends React.Component<Props> {
+  render(): React.Node {
+    return this._renderItems();
+  }
+
+  _renderItems(): React.Node {
+    return null;
+  }
+}
+
+module.exports = SegmentedControl;
+`;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-flow-'));
+  fs.mkdirSync(path.join(root, 'js'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'js/SegmentedControl.js'), FLOW);
+  fs.writeFileSync(path.join(root, 'js/plain.js'), `function plain() { return 1; }\nmodule.exports = plain;\n`);
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Flow-typed JavaScript', () => {
+  it('is detected by its pragma, and only then', () => {
+    expect(detectLanguage('js/SegmentedControl.js', FLOW)).toBe('tsx');
+    expect(detectLanguage('js/plain.js', 'function plain() {}')).toBe('javascript');
+    expect(detectLanguage('js/x.js', '// @noflow\nconst a = 1;')).toBe('javascript');
+  });
+
+  it('keeps its class and methods', () => {
+    const nodes = cg.getNodesInFile('js/SegmentedControl.js');
+    const methods = nodes.filter((n) => n.kind === 'method').map((n) => n.name).sort();
+    expect(methods).toEqual(['_renderItems', 'render']);
+    const render = nodes.find((n) => n.name === 'render')!;
+    const calls = cg.getOutgoingEdges(render.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.name);
+    expect(calls).toContain('_renderItems');
+  });
+
+  it('blanks Flow-only syntax to spaces, keeping every offset', () => {
+    const out = blankFlowSyntax(FLOW, 'js/SegmentedControl.js');
+    expect(out.length).toBe(FLOW.length);
+    expect(out).not.toMatch(/\{\||\|\}|import\s+typeof|opaque\s+type|:\s*\?Array/);
+    expect(blankFlowSyntax('const a = {| b |};', 'plain.js')).toBe('const a = {| b |};');
+  });
+});
diff --git a/__tests__/flow-named-implementation.test.ts b/__tests__/flow-named-implementation.test.ts
new file mode 100644
index 0000000000..4f0560ff91
--- /dev/null
+++ b/__tests__/flow-named-implementation.test.ts
@@ -0,0 +1,228 @@
+/**
+ * When an interface method fans out to several implementations, the Flow goes
+ * through the one the query names.
+ *
+ * Explore's `named` walk is breadth-first, and an interface method calls every
+ * implementation at the same depth. Whichever implementation the index listed
+ * first used to claim everything reached after it, so on prometheus
+ *
+ *   Engine.execEvalStmt Queryable.Querier fanout.Querier NewMergeQuerier
+ *
+ * came back as `Queryable.Querier → DB.Querier → NewMergeQuerier`: a route
+ * through the TSDB's implementation, which nobody named, while
+ * `fanout.Querier`, which was named and calls `NewMergeQuerier` just as
+ * directly, was left off the Flow. gin's form binding did the same once its map
+ * types counted as implementations: `setter.TrySet` went through
+ * `headerSource.TrySet` when the query named `formSource.TrySet`.
+ *
+ * Every case is asked twice, naming one implementation and then the other, so
+ * it fails whichever one the index happens to list first.
+ */
+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';
+import { ToolHandler } from '../src/mcp/tools';
+import { resolveNamedSymbolFlow } from '../src/graph/named-symbol-flow';
+
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  // gin's binding package, with structs where gin has map types.
+  'binding/form_mapping.go': `package binding
+
+type setter interface {
+	TrySet(key string) (bool, error)
+}
+
+type formSource struct{ values map[string][]string }
+
+func (form formSource) TrySet(key string) (bool, error) {
+	return setByForm(form.values, key)
+}
+
+func tryToSetValue(s setter, key string) (bool, error) {
+	return s.TrySet(key)
+}
+
+func setByForm(values map[string][]string, key string) (bool, error) {
+	return len(values[key]) > 0, nil
+}
+`,
+  'binding/header.go': `package binding
+
+type headerSource struct{ values map[string][]string }
+
+func (hs headerSource) TrySet(key string) (bool, error) {
+	return setByForm(hs.values, key)
+}
+`,
+  // Both implementations call the same function.
+  'src/store.ts': `export interface Store {
+  save(key: string): boolean;
+}
+
+export function persist(store: Store, key: string): boolean {
+  return store.save(key);
+}
+
+export function writeEntry(key: string): boolean {
+  return key.length > 0;
+}
+`,
+  'src/memory-store.ts': `import { Store, writeEntry } from './store';
+
+export class MemoryStore implements Store {
+  save(key: string): boolean {
+    return writeEntry(key);
+  }
+}
+`,
+  'src/disk-store.ts': `import { Store, writeEntry } from './store';
+
+export class DiskStore implements Store {
+  save(key: string): boolean {
+    return writeEntry(key);
+  }
+}
+`,
+  // Each implementation calls its own function, and the query names both, so
+  // the two routes end at different symbols that are equally deep.
+  'src/cache.ts': `export interface Cache {
+  evict(key: string): void;
+}
+
+export function expire(cache: Cache, key: string): void {
+  cache.evict(key);
+}
+
+export function dropFromMemory(key: string): void {
+  console.log(key);
+}
+
+export function dropFromDisk(key: string): void {
+  console.log(key);
+}
+`,
+  'src/memory-cache.ts': `import { Cache, dropFromMemory } from './cache';
+
+export class MemoryCache implements Cache {
+  evict(key: string): void {
+    dropFromMemory(key);
+  }
+}
+`,
+  'src/disk-cache.ts': `import { Cache, dropFromDisk } from './cache';
+
+export class DiskCache implements Cache {
+  evict(key: string): void {
+    dropFromDisk(key);
+  }
+}
+`,
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-flow-named-impl-'));
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** The lead chain, each step as `qualifiedName@file`. */
+function leadChain(query: string): string[] {
+  const flow = resolveNamedSymbolFlow(cg, query);
+  return (flow.chains[0]?.steps ?? []).map((s) => `${s.node.qualifiedName}@${s.node.filePath}`);
+}
+
+/** The numbered lines of explore's Flow section. */
+async function exploreFlow(query: string): Promise<string[]> {
+  const res = await new ToolHandler(cg).execute('codegraph_explore', { query });
+  const text = res.content?.[0]?.text ?? '';
+  const start = text.indexOf('**Flow (call path among the symbols you queried)**');
+  if (start < 0) return [];
+  const section = text.slice(start).split(/\n\n(?=\*\*|>)/)[0] ?? '';
+  return section.split(/\r?\n/).filter((line) => /^\d+\. /.test(line));
+}
+
+describe('a Flow through an interface goes through the implementation the query names', () => {
+  it('Go: the route through formSource.TrySet when the query names it', () => {
+    expect(leadChain('tryToSetValue setter.TrySet formSource.TrySet setByForm')).toEqual([
+      'tryToSetValue@binding/form_mapping.go',
+      'setter::TrySet@binding/form_mapping.go',
+      'formSource::TrySet@binding/form_mapping.go',
+      'setByForm@binding/form_mapping.go',
+    ]);
+  });
+
+  it('Go: the route through headerSource.TrySet when the query names it', () => {
+    expect(leadChain('tryToSetValue setter.TrySet headerSource.TrySet setByForm')).toEqual([
+      'tryToSetValue@binding/form_mapping.go',
+      'setter::TrySet@binding/form_mapping.go',
+      'headerSource::TrySet@binding/header.go',
+      'setByForm@binding/form_mapping.go',
+    ]);
+  });
+
+  it('TypeScript: the route through the named class when two classes call the same function', () => {
+    expect(leadChain('persist Store.save MemoryStore.save writeEntry')).toEqual([
+      'persist@src/store.ts',
+      'Store::save@src/store.ts',
+      'MemoryStore::save@src/memory-store.ts',
+      'writeEntry@src/store.ts',
+    ]);
+    expect(leadChain('persist Store.save DiskStore.save writeEntry')).toEqual([
+      'persist@src/store.ts',
+      'Store::save@src/store.ts',
+      'DiskStore::save@src/disk-store.ts',
+      'writeEntry@src/store.ts',
+    ]);
+  });
+
+  it('TypeScript: of two equally deep ends, the one reached through the named class', () => {
+    expect(leadChain('expire Cache.evict MemoryCache.evict dropFromMemory dropFromDisk')).toEqual([
+      'expire@src/cache.ts',
+      'Cache::evict@src/cache.ts',
+      'MemoryCache::evict@src/memory-cache.ts',
+      'dropFromMemory@src/cache.ts',
+    ]);
+    expect(leadChain('expire Cache.evict DiskCache.evict dropFromMemory dropFromDisk')).toEqual([
+      'expire@src/cache.ts',
+      'Cache::evict@src/cache.ts',
+      'DiskCache::evict@src/disk-cache.ts',
+      'dropFromDisk@src/cache.ts',
+    ]);
+  });
+
+  it('still bridges through an implementation when the query names none', () => {
+    const chain = leadChain('tryToSetValue setter.TrySet setByForm');
+    expect(chain).toHaveLength(4);
+    expect(chain[0]).toBe('tryToSetValue@binding/form_mapping.go');
+    expect(chain[1]).toBe('setter::TrySet@binding/form_mapping.go');
+    expect(['formSource::TrySet@binding/form_mapping.go', 'headerSource::TrySet@binding/header.go']).toContain(chain[2]);
+    expect(chain[3]).toBe('setByForm@binding/form_mapping.go');
+  });
+
+  it("codegraph_explore's Flow section lists the named implementation", async () => {
+    const formLine = cg.getNodesByName('TrySet').find((n) => n.qualifiedName === 'formSource::TrySet')!.startLine;
+    const headerLine = cg.getNodesByName('TrySet').find((n) => n.qualifiedName === 'headerSource::TrySet')!.startLine;
+
+    const viaForm = await exploreFlow('tryToSetValue setter.TrySet formSource.TrySet setByForm');
+    expect(viaForm).toHaveLength(4);
+    expect(viaForm[2]).toBe(`3. TrySet (binding/form_mapping.go:${formLine})`);
+
+    const viaHeader = await exploreFlow('tryToSetValue setter.TrySet headerSource.TrySet setByForm');
+    expect(viaHeader).toHaveLength(4);
+    expect(viaHeader[2]).toBe(`3. TrySet (binding/header.go:${headerLine})`);
+  });
+});
diff --git a/__tests__/framework-edge-name.test.ts b/__tests__/framework-edge-name.test.ts
new file mode 100644
index 0000000000..b2081c82e6
--- /dev/null
+++ b/__tests__/framework-edge-name.test.ts
@@ -0,0 +1,57 @@
+/**
+ * A link a framework or bridge resolver made names that resolver on the edge
+ * (`metadata.framework`), as a synthesized channel names itself with
+ * `synthesizedBy`: a Swift → Objective-C hop says `swift-objc-bridge`.
+ */
+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-framework-edge-'));
+  const files: Record<string, string> = {
+    'Sources/Cache.h': `#import <Foundation/Foundation.h>
+@interface Cache : NSObject
+- (id)fetchEntryForKey:(NSString *)key;
+@end
+`,
+    'Sources/Cache.m': `#import "Cache.h"
+@implementation Cache
+- (id)fetchEntryForKey:(NSString *)key {
+    return nil;
+}
+@end
+`,
+    'Sources/Caller.swift': `import Foundation
+
+func load(cache: Cache) {
+    _ = cache.fetchEntry(forKey: "x")
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('framework-resolved edges', () => {
+  it('name the resolver that made them', () => {
+    const caller = cg.getNodesInFile('Sources/Caller.swift').find((n) => n.name === 'load')!;
+    const bridged = cg.getOutgoingEdges(caller.id).find((e) => cg.getNode(e.target)?.name === 'fetchEntryForKey:');
+    expect(bridged).toBeDefined();
+    expect(bridged!.metadata?.resolvedBy).toBe('framework');
+    expect(bridged!.metadata?.framework).toBe('swift-objc-bridge');
+  });
+});
diff --git a/__tests__/framework-name-heuristic-scope.test.ts b/__tests__/framework-name-heuristic-scope.test.ts
new file mode 100644
index 0000000000..7457c2ea71
--- /dev/null
+++ b/__tests__/framework-name-heuristic-scope.test.ts
@@ -0,0 +1,68 @@
+/**
+ * The framework resolvers' name heuristics ("a `…View` is a view under
+ * `/views/`", "a `…Form` is a form") pick only what the reference can see,
+ * starting from its own scope: never a class a test declares inside one of
+ * its functions (netbox's `TestForm`, DRF's `MockView`), its own file's
+ * first, then its package's, then a conventional folder's.
+ */
+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-fw-name-'));
+  const files: Record<string, string> = {
+    'manage.py': '',
+    'utilities/tests/test_forms.py': `class GetFieldValueTestCase:
+    def setUpTestData(self):
+        class TestForm:
+            pass
+        return TestForm()
+`,
+    'utilities/tests/test_templatetags.py': `def test_any_required():
+    return TestForm()
+`,
+    'tests/browsable_api/views.py': `class MockView:
+    pass
+`,
+    'tests/authentication/test_authentication.py': `class MockView:
+    pass
+
+
+def test_auth():
+    return MockView()
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'instantiates' || e.kind === 'calls' || e.kind === 'references')
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('framework name heuristics', () => {
+  it('never pick a class declared inside another file’s function', () => {
+    expect(targetsFrom('utilities/tests/test_templatetags.py').filter((t) => t.includes('TestForm'))).toEqual([]);
+  });
+
+  it('take the reference’s own file first', () => {
+    expect(targetsFrom('tests/authentication/test_authentication.py').filter((t) => t.includes('MockView')))
+      .toEqual(['tests/authentication/test_authentication.py:MockView']);
+  });
+});
diff --git a/__tests__/framework-resolve-language.test.ts b/__tests__/framework-resolve-language.test.ts
new file mode 100644
index 0000000000..5751ce1f2d
--- /dev/null
+++ b/__tests__/framework-resolve-language.test.ts
@@ -0,0 +1,190 @@
+/**
+ * A framework resolves only the references written in its own languages.
+ * Express is detected in etcd by a file-content scan, and its `logger`
+ * middleware rule (a same-file declaration named `logger`) took a Go method's
+ * `*zap.Logger` result type for the method itself. A resolver that reads more
+ * languages than it extracts from lists them: a SvelteKit `+page.server.ts`
+ * still resolves its `$lib/…` imports, and a Razor page's `@model` its
+ * PageModel.
+ */
+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';
+import { getResolvingFrameworks } from '../src/resolution/frameworks';
+import type { FrameworkResolver } from '../src/resolution/types';
+
+function writeProject(prefix: string, files: Record<string, string>): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  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);
+  }
+  return root;
+}
+
+describe('getResolvingFrameworks', () => {
+  const go: FrameworkResolver = { name: 'go', languages: ['go'], detect: () => true, resolve: () => null };
+  const svelte: FrameworkResolver = {
+    name: 'svelte', languages: ['svelte'], resolveLanguages: ['svelte', 'typescript'], detect: () => true, resolve: () => null,
+  };
+  const any: FrameworkResolver = { name: 'any', detect: () => true, resolve: () => null };
+
+  it('keeps the frameworks that list the language, and those that list none', () => {
+    expect(getResolvingFrameworks([go, svelte, any], 'go').map((f) => f.name)).toEqual(['go', 'any']);
+    expect(getResolvingFrameworks([go, svelte, any], 'python').map((f) => f.name)).toEqual(['any']);
+  });
+
+  it('reads resolveLanguages before languages', () => {
+    expect(getResolvingFrameworks([go, svelte, any], 'typescript').map((f) => f.name)).toEqual(['svelte', 'any']);
+    expect(getResolvingFrameworks([go, svelte, any], 'svelte').map((f) => f.name)).toEqual(['svelte', 'any']);
+  });
+});
+
+describe('Express beside Go code (etcd)', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = writeProject('cg-fw-lang-go-', {
+      'package.json': JSON.stringify({ name: 'dashboard', dependencies: { express: '^4.19.0' } }),
+      'web/server.js': `const express = require('express');
+const app = express();
+
+function logger(req, res, next) {
+  next();
+}
+
+app.use(logger);
+app.get('/health', (req, res) => res.json({ ok: true }));
+`,
+      'go.mod': 'module example.com/kv\n\ngo 1.22\n',
+      'server/read/read_test.go': `package read
+
+import "go.uber.org/zap"
+
+type mockServer struct {
+	lg *zap.Logger
+}
+
+func (s *mockServer) Logger() *zap.Logger { return s.lg }
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('resolves no Go reference', () => {
+    const ids = cg.getNodesInFile('server/read/read_test.go').map((n) => n.id);
+    const byExpress = cg.getOutgoingEdgesFrom(ids).filter((e) => (e.metadata as { framework?: string } | undefined)?.framework === 'express');
+    expect(byExpress).toEqual([]);
+  });
+
+  it('does not take a method’s `*zap.Logger` result for the method itself', () => {
+    const logger = cg.getNodesInFile('server/read/read_test.go').find((n) => n.kind === 'method' && n.name === 'Logger')!;
+    expect(logger).toBeDefined();
+    expect(cg.getOutgoingEdges(logger.id).map((e) => e.target)).not.toContain(logger.id);
+  });
+});
+
+describe('Svelte in a SvelteKit app', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = writeProject('cg-fw-lang-svelte-', {
+      'package.json': JSON.stringify({ name: 'web', devDependencies: { '@sveltejs/kit': '^2.0.0', svelte: '^5.0.0' } }),
+      'src/lib/api.ts': `export async function get(path: string) {
+  return fetch(path);
+}
+`,
+      'src/routes/+page.server.ts': `import * as api from '$lib/api';
+
+export async function load() {
+  return { articles: await api.get('/articles') };
+}
+`,
+      'src/routes/+page.svelte': `<script>
+  let { data } = $props();
+</script>
+
+<p>{data.articles}</p>
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('still resolves a `$lib/…` import written in a .ts module', () => {
+    const ids = cg.getNodesInFile('src/routes/+page.server.ts').map((n) => n.id);
+    const imported = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'imports').map((e) => cg.getNode(e.target)!);
+    expect(imported.map((n) => n.filePath)).toContain('src/lib/api.ts');
+  });
+});
+
+describe('ASP.NET in a Razor Pages app (eShopOnWeb)', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = writeProject('cg-fw-lang-razor-', {
+      'Program.cs': `var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddRazorPages();
+var app = builder.Build();
+app.MapRazorPages();
+app.Run();
+`,
+      'Pages/_ViewImports.cshtml': `@namespace Shop.Web.Pages
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+`,
+      'Pages/Index.cshtml': `@page
+@model IndexModel
+<h1>Catalog</h1>
+`,
+      'Pages/Index.cshtml.cs': `using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace Shop.Web.Pages;
+
+public class IndexModel : PageModel
+{
+}
+`,
+      'Pages/Basket/Index.cshtml': `@page
+@model IndexModel
+<h1>Basket</h1>
+`,
+      'Pages/Basket/Index.cshtml.cs': `using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace Shop.Web.Pages.Basket;
+
+public class IndexModel : PageModel
+{
+}
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('still links each page’s `@model` to the PageModel beside it', () => {
+    const modelOf = (page: string) => {
+      const ids = cg.getNodesInFile(page).map((n) => n.id);
+      return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references').map((e) => cg.getNode(e.target)!.filePath);
+    };
+    expect(modelOf('Pages/Index.cshtml')).toEqual(['Pages/Index.cshtml.cs']);
+    expect(modelOf('Pages/Basket/Index.cshtml')).toEqual(['Pages/Basket/Index.cshtml.cs']);
+  });
+});
diff --git a/__tests__/frameworks.test.ts b/__tests__/frameworks.test.ts
index cc03c7702b..940c5a0066 100644
--- a/__tests__/frameworks.test.ts
+++ b/__tests__/frameworks.test.ts
@@ -998,11 +998,11 @@ describe('springResolver.resolve — DI heuristics are gated to Java/Kotlin non-
   // hijack a Scala `extends X` to a same-named class found via directory
   // heuristics — inheritance must resolve through imports/name matching.
   const decoyNode: Node = {
-    id: 'class:src/test/model/ExtCustomer.java:ExtCustomer:3',
+    id: 'class:src/main/model/ExtCustomer.java:ExtCustomer:3',
     kind: 'class',
     name: 'ExtCustomer',
-    qualifiedName: 'src/test/model/ExtCustomer.java::ExtCustomer',
-    filePath: 'src/test/model/ExtCustomer.java',
+    qualifiedName: 'src/main/model/ExtCustomer.java::ExtCustomer',
+    filePath: 'src/main/model/ExtCustomer.java',
     language: 'java',
     startLine: 3,
     endLine: 10,
diff --git a/__tests__/frontload-hook.test.ts b/__tests__/frontload-hook.test.ts
index 3e81e6090e..c85700b9c0 100644
--- a/__tests__/frontload-hook.test.ts
+++ b/__tests__/frontload-hook.test.ts
@@ -13,7 +13,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { spawnSync } from 'node:child_process';
 import { CodeGraph } from '../src';
-import { planFrontload, isTaskNotification, findIndexedSubprojectRoots, unsafeIndexRootReason, isStructuralPrompt, hasStructuralKeyword, extractCodeTokens, PROMPT_HOOK_INJECTION_MAX, CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT, capPromptHookInjection } from '../src/directory';
+import { planFrontload, isTaskNotification, isAgentMessage, findIndexedSubprojectRoots, unsafeIndexRootReason, isStructuralPrompt, hasStructuralKeyword, extractCodeTokens, PROMPT_HOOK_INJECTION_MAX, CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT, capPromptHookInjection } from '../src/directory';
 
 // Make the built-in exports configurable so HOME can point at a real temp
 // fixture without changing the process environment or the user's home files.
@@ -374,6 +374,12 @@ export class OrderStateMachine {
     }
   });
 
+  it('stays silent on a subagent hand-back envelope, even one that names indexed symbols (#2184)', () => {
+    const report = 'how does OrderStateMachine work? submitOrder() calls into the state machine.';
+    expect(hook(report)).toContain('Structural context from CodeGraph');
+    expect(hook(`<agent-message from="agent-7f3e">\n[Subagent hand-back] ${report}\n</agent-message>`)).toBe('');
+  });
+
   it('uses MEDIUM for indexed prose segments without a strong keyword or verified token', () => {
     for (const prompt of ['como state machine?', 'wie state machine?']) {
       const output = hook(prompt);
@@ -471,3 +477,20 @@ describe('system task notifications (#1832)', () => {
     expect(isTaskNotification('trace AuthService login')).toBe(false);
   });
 });
+
+describe('subagent hand-backs (#2184)', () => {
+  const handBack = '<agent-message from="a1b2c3">\n[Subagent hand-back] Traced how AuthService.login calls TokenStore.save and which callers are affected.\n</agent-message>';
+
+  it('skips the complete hand-back envelope', () => {
+    expect(isAgentMessage(handBack)).toBe(true);
+    expect(isAgentMessage(` \n${handBack}\n`)).toBe(true);
+    expect(isAgentMessage('<agent-message>trace AuthService login flow</agent-message>')).toBe(true);
+  });
+  it('does not suppress a user question that mentions the marker', () => {
+    expect(isAgentMessage(`Why does ${handBack} trigger the hook?`)).toBe(false);
+    expect(isAgentMessage(`${handBack} Explain this.`)).toBe(false);
+    expect(isAgentMessage('<agent-messages>trace AuthService</agent-messages>')).toBe(false);
+    expect(isAgentMessage('<agent-message from="x">trace AuthService')).toBe(false);
+    expect(isAgentMessage('trace AuthService login')).toBe(false);
+  });
+});
diff --git a/__tests__/function-ref.test.ts b/__tests__/function-ref.test.ts
index a539f88235..664b407c7c 100644
--- a/__tests__/function-ref.test.ts
+++ b/__tests__/function-ref.test.ts
@@ -1227,6 +1227,311 @@ def direct(obj: Store):
     } finally { cg.close(); }
   });
 
+  it('#1820: a module global bound by its assignments resolves as a receiver', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-global-'));
+    fs.writeFileSync(path.join(tmpDir, 'store.py'), 'class Store:\n    def fetch(self, ids):\n        return ids\n');
+    fs.writeFileSync(path.join(tmpDir, 'decoy.py'), 'class Decoy:\n    def fetch(self, ids):\n        return []\n');
+    fs.writeFileSync(path.join(tmpDir, 'settings.py'), `from decoy import Decoy
+conn = None
+
+def init():
+    global conn
+    from store import Store
+    conn = Store()
+
+def shadow():
+    conn = Decoy()
+    return conn
+
+def same_file(pool):
+    pool.submit(conn.fetch, [])
+
+def param_shadow(pool, conn):
+    pool.submit(conn.fetch, [])
+
+def loop_shadow(pool, items):
+    for conn in items:
+        pool.submit(conn.fetch, [])
+`);
+    fs.writeFileSync(path.join(tmpDir, 'consumer.py'), `import settings
+from settings import conn
+
+def via_module(pool):
+    pool.submit(settings.conn.fetch, [])
+
+def via_name(pool):
+    pool.submit(conn.fetch, [])
+
+def import_shadow(pool, settings):
+    pool.submit(settings.conn.fetch, [])
+
+def local_import(pool):
+    from settings import conn
+    pool.submit(conn.fetch, [])
+`);
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      await cg.indexAll();
+      const store = cg.getNodesByName('fetch').find(n => n.qualifiedName.startsWith('Store::'))!;
+      const into = cg.getIncomingEdges(store.id).filter(e => e.kind === 'references' && e.metadata?.fnRef === true);
+      // A parameter or loop variable of the same name is not the global; a local import of it is.
+      expect(sourceNames(cg, into)).toEqual(['local_import', 'same_file', 'via_module', 'via_name']);
+      const decoy = cg.getNodesByName('fetch').find(n => n.qualifiedName.startsWith('Decoy::'))!;
+      expect(cg.getIncomingEdges(decoy.id).filter(e => e.metadata?.fnRef === true)).toHaveLength(0);
+    } finally { cg.close(); }
+  });
+
+  it('#1820: a module global with several backends binds to the declaration they share', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-global-many-'));
+    fs.mkdirSync(path.join(tmpDir, 'backends'));
+    fs.writeFileSync(path.join(tmpDir, 'backends', '__init__.py'), '');
+    fs.writeFileSync(path.join(tmpDir, 'backends', 'base.py'),
+      'class Base:\n    def fetch(self, ids):\n        raise NotImplementedError("backend")\n' +
+      '    def search(self):\n        raise NotImplementedError("backend")\n');
+    fs.writeFileSync(path.join(tmpDir, 'backends', 'es.py'),
+      'from backends.base import Base\nclass ES(Base):\n    def search(self):\n        return []\n');
+    fs.writeFileSync(path.join(tmpDir, 'backends', 'vec.py'),
+      'from backends.base import (\n    Base,\n)\nclass Vec(Base):\n    def fetch(self, ids):\n        return ids\n' +
+      '    def search(self):\n        return []\n');
+    fs.writeFileSync(path.join(tmpDir, 'other.py'), 'class Other:\n    def fetch(self, ids):\n        return ids\n');
+    fs.writeFileSync(path.join(tmpDir, 'settings.py'), `import backends.es
+conn = None
+
+def init(engine):
+    global conn
+    if engine == "es":
+        conn = backends.es.ES()
+    else:
+        from backends import vec as vec_module
+        conn = vec_module.Vec()
+`);
+    fs.writeFileSync(path.join(tmpDir, 'unknown.py'), `from other import Other
+conn = None
+mixed = None
+
+def init(flag):
+    global conn, mixed
+    conn = make_conn()
+    mixed = Other() if flag else None
+`);
+    fs.writeFileSync(path.join(tmpDir, 'consumer.py'), `import settings
+import unknown
+
+def gc(pool):
+    pool.submit(settings.conn.fetch, [])
+
+def find(pool):
+    pool.submit(settings.conn.search)
+
+def opaque(pool):
+    pool.submit(unknown.conn.fetch, [])
+    pool.submit(unknown.mixed.fetch, [])
+`);
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      await cg.indexAll();
+      const byOwner = (owner: string, name = 'fetch') => cg.getNodesByName(name).find(n => n.qualifiedName.startsWith(`${owner}::`))!;
+      const fnRefs = (owner: string, name = 'fetch') => cg.getIncomingEdges(byOwner(owner, name).id)
+        .filter(e => e.kind === 'references' && e.metadata?.fnRef === true);
+      // ES inherits Base.fetch and Vec overrides it: the shared declaration is Base.fetch.
+      expect(sourceNames(cg, fnRefs('Base'))).toEqual(['gc']);
+      expect(fnRefs('Vec')).toHaveLength(0);
+      // Both backends override search: the declaration they inherit is still Base.search.
+      expect(sourceNames(cg, fnRefs('Base', 'search'))).toEqual(['find']);
+      expect([...fnRefs('ES', 'search'), ...fnRefs('Vec', 'search')]).toHaveLength(0);
+      // An opaque initializer (`make_conn()`, a conditional) leaves the global's type unknown.
+      expect(fnRefs('Other')).toHaveLength(0);
+    } finally { cg.close(); }
+  });
+
+  // One index per adversarial case: several seconds on a loaded machine.
+  it('#1820: a module global never binds through a shadow, an unknown value or a deeper chain', async () => {
+    const header = `from store import Store
+from decoy import Decoy
+conn = None
+
+def init():
+    global conn
+    conn = Store()
+`;
+    // Each case: its files, and the fnRef edges into any `fetch` it must produce.
+    const cases: Record<string, [Record<string, string>, string[]]> = {
+      control: [{ 'm.py': header + 'def cb(pool):\n    pool.submit(conn.fetch)\n' }, ['cb -> Store::fetch']],
+      tuple_first: [{ 'm.py': header + 'def cb(pool):\n    conn, _ = (Decoy(), None)\n    pool.submit(conn.fetch)\n' }, []],
+      loop_and_nested_global: [{ 'm.py': header +
+        'def cb(pool, items):\n    for conn in items:\n        pass\n    def nested():\n        global conn\n    pool.submit(conn.fetch)\n' }, []],
+      multiline_conditional: [{ 'm.py': header.replace('conn = Store()', 'conn = Store(\n        x=1,\n    ) if flag else Decoy()') +
+        'def cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      multiline_constructor: [{ 'm.py': header.replace('conn = Store()', 'conn = Store(\n        x=1,\n    )') +
+        'def cb(pool):\n    pool.submit(conn.fetch)\n' }, ['cb -> Store::fetch']],
+      closure_param: [{ 'm.py': header + 'def outer(conn):\n    def cb(pool):\n        pool.submit(conn.fetch)\n    return cb\n' }, []],
+      closure_local: [{ 'm.py': header + 'def outer(pool):\n    conn = Decoy()\n    def cb():\n        pool.submit(conn.fetch)\n    return cb\n' }, []],
+      lambda_param: [{ 'm.py': header + 'def cb(pool):\n    pool.submit(lambda conn: pool.map(conn.fetch))\n' }, []],
+      comprehension: [{ 'm.py': header + 'def cb(pool, xs):\n    [pool.submit(conn.fetch) for conn in xs]\n' }, []],
+      except_as: [{ 'm.py': header + 'def cb(pool):\n    try:\n        pass\n    except Exception as conn:\n        pool.submit(conn.fetch)\n' }, []],
+      match_as: [{ 'm.py': header + 'def cb(pool, x):\n    match x:\n        case Decoy() as conn:\n            pool.submit(conn.fetch)\n' }, []],
+      global_in_nested_def: [{ 'm.py': 'from decoy import Decoy\nconn = None\n\ndef init():\n    def helper():\n        global conn\n    conn = Decoy()\n\n' +
+        'def cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      keyword_in_multiline_call: [{ 'm.py': 'from decoy import Decoy\nconn = None\napp = dict(\n    conn=Decoy()\n)\n\n' +
+        'def cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      tuple_rebind: [{ 'm.py': header + 'def reset():\n    global conn\n    conn, other = Decoy(), 1\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      with_rebind: [{ 'm.py': header + 'def reset():\n    global conn\n    with open_decoy() as conn:\n        pass\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      docstring: [{ 'm.py': 'from store import Store\nconn = None\n"""\nconn = Store()\n"""\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      deeper_chain: [{ 'settings.py': header, 'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.pool.fetch)\n' }, []],
+      importer_rebinds: [{ 'settings.py': header,
+        'c.py': 'from settings import conn\nfrom decoy import Decoy\n\ndef reset():\n    global conn\n    conn = Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      local_import_of_other_module: [{ 'settings.py': header, 'other_settings.py': 'from decoy import Decoy\nconn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    import other_settings as settings\n    pool.submit(settings.conn.fetch)\n' }, []],
+      local_from_import_of_other_module: [{ 'settings.py': header, 'other_settings.py': 'from decoy import Decoy\nconn = Decoy()\n',
+        'c.py': 'from settings import conn\n\ndef cb(pool):\n    from other_settings import conn\n    pool.submit(conn.fetch)\n' }, []],
+      comment_in_parenthesized_import: [{ 'settings.py': header + 'other = 1\n',
+        'c.py': 'from settings import (\n    other,  # see fetch()\n    conn,\n)\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, ['cb -> Store::fetch']],
+      star_import_override: [{ 'local.py': 'from decoy import Decoy\nconn = Decoy()\n', 'settings.py': header + 'from local import *\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      match_sequence_capture: [{ 'm.py': header + 'def cb(pool, x):\n    match x:\n        case [conn]:\n            pool.submit(conn.fetch)\n' }, []],
+      match_keyword_capture: [{ 'm.py': header + 'def cb(pool, x):\n    match x:\n        case Decoy(inner=conn):\n            pool.submit(conn.fetch)\n' }, []],
+      match_bare_capture: [{ 'm.py': header + 'def cb(pool, x):\n    match x:\n        case conn:\n            pool.submit(conn.fetch)\n' }, []],
+      multiline_loop_target: [{ 'm.py': header + 'def cb(pool, xs):\n    for (a,\n         conn) in xs:\n        pool.submit(conn.fetch)\n' }, []],
+      multiline_tuple_local: [{ 'm.py': header + 'def cb(pool):\n    (a,\n     conn) = 1, Decoy()\n    pool.submit(conn.fetch)\n' }, []],
+      multiline_tuple_rebind: [{ 'm.py': header + 'def reset():\n    global conn\n    (a,\n     conn) = 1, Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      annotation_contradicts_value: [{ 'm.py': 'from store import Store\nfrom decoy import Decoy\nconn: Store = Decoy()\n\n' +
+        'def cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      annotation_over_factory: [{ 'm.py': 'from store import Store\nconn: Store = make_store()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' },
+        ['cb -> Store::fetch']],
+      external_production_write: [{ 'settings.py': header,
+        'reset.py': 'import settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      external_aliased_write: [{ 'pkg/__init__.py': '', 'pkg/settings.py': header,
+        'reset.py': 'import pkg.settings as cfg\n\ndef reset():\n    cfg.conn = make_conn()\n',
+        'c.py': 'from pkg import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      external_relative_write: [{ 'pkg/__init__.py': '', 'pkg/settings.py': header,
+        'pkg/reset.py': 'from . import settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'c.py': 'from pkg import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      external_setattr: [{ 'settings.py': header,
+        'reset.py': 'import settings\nfrom decoy import Decoy\n\ndef reset():\n    setattr(settings, "conn", Decoy())\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      external_subclass_write: [{ 'settings.py': header,
+        'sub.py': 'from store import Store\nclass SubStore(Store):\n    def fetch(self, ids):\n        return ids\n',
+        'reset.py': 'import settings\nfrom sub import SubStore\n\ndef reset():\n    settings.conn = SubStore()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      test_double_write: [{ 'settings.py': header,
+        'tests/test_c.py': 'import settings\nfrom unittest.mock import MagicMock\n\ndef test_cb(pool):\n    settings.conn = MagicMock()\n    pool.submit(settings.conn.fetch)\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      test_monkeypatch: [{ 'settings.py': header,
+        'tests/test_c.py': 'import settings\n\ndef test_cb(monkeypatch, pool):\n    monkeypatch.setattr(settings, "conn", object())\n    pool.submit(settings.conn.fetch)\n' }, []],
+      globals_literal_write: [{ 'm.py': header + 'def reset():\n    globals()["conn"] = Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      globals_dynamic_write: [{ 'm.py': header + 'for name, obj in [("conn", Decoy())]:\n    globals()[name] = obj\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      unrelated_attribute_write: [{ 'settings.py': header,
+        'other.py': 'from decoy import Decoy\n\nclass Holder:\n    def __init__(self):\n        self.conn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      // A write lands on the module its import names, never on another module sharing its tail.
+      write_path_is_exact: [{ 'x/__init__.py': '', 'y/__init__.py': '', 'x/settings.py': header, 'y/settings.py': header,
+        'reset.py': 'from x import settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'cx.py': 'from x import settings\n\ndef cb_x(pool):\n    pool.submit(settings.conn.fetch)\n',
+        'cy.py': 'from y import settings\n\ndef cb_y(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb_y -> Store::fetch']],
+      ambiguous_write_target: [{ 'x/__init__.py': '', 'y/__init__.py': '', 'x/settings.py': header, 'y/settings.py': header,
+        'reset.py': 'import settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'cx.py': 'from x import settings\n\ndef cb_x(pool):\n    pool.submit(settings.conn.fetch)\n',
+        'cy.py': 'from y import settings\n\ndef cb_y(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      relative_write_is_exact: [{ 'pkg/__init__.py': '', 'pkg/sub/__init__.py': '', 'pkg/settings.py': header,
+        'other/__init__.py': '', 'other/pkg/__init__.py': '', 'other/pkg/settings.py': header,
+        'pkg/sub/reset.py': 'from .. import settings\n\ndef reset():\n    settings.conn = make_conn()\n',
+        'c2.py': 'from other.pkg import settings\n\ndef cb2(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb2 -> Store::fetch']],
+      namespace_import_binds_root: [{ 'pkg/__init__.py': '', 'pkg/settings.py': header,
+        'c.py': 'import pkg.settings\nfrom decoy import Decoy\n\nsettings = Bag()\nsettings.conn = Decoy()\n',
+        'd.py': 'from pkg import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      // `other.pkg.settings as settings` is not an explicit alias of `pkg.settings`: the
+      // write goes to the other module, so pkg's global keeps its type (the consumer's
+      // relative import names pkg/settings.py exactly).
+      alias_of_longer_module_is_not_explicit: [{ 'pkg/__init__.py': '', 'pkg/settings.py': header,
+        'other/__init__.py': '', 'other/pkg/__init__.py': '', 'other/pkg/settings.py': 'conn = None\n',
+        'reset.py': 'import pkg.settings\nimport other.pkg.settings as settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'pkg/d.py': 'from . import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      alias_in_string_is_not_explicit: [{ 'pkg/__init__.py': '', 'pkg/settings.py': 'conn = None\n',
+        'reset.py': 'import pkg.settings\nfrom decoy import Decoy\nnote = "import pkg.settings as settings"\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'd.py': 'from pkg import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      explicit_alias_equal_to_leaf: [{ 'pkg/__init__.py': '', 'pkg/settings.py': header,
+        'reset.py': 'import pkg.settings as settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.conn = Decoy()\n',
+        'd.py': 'from pkg import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      one_line_main_write: [{ 'settings.py': header,
+        'run.py': 'import settings\nfrom decoy import Decoy\n\nif __name__ == "__main__": settings.conn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      globals_in_main_block: [{ 'm.py': header + 'if __name__ == "__main__":\n    globals()["conn"] = Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' },
+        ['cb -> Store::fetch']],
+      vars_in_function_is_locals: [{ 'm.py': header + 'def dump():\n    return vars()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' },
+        ['cb -> Store::fetch']],
+      example_write_is_production: [{ 'settings.py': header,
+        'examples/wire.py': 'import settings\nfrom decoy import Decoy\n\ndef wire():\n    settings.conn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      conftest_write_is_test: [{ 'settings.py': header,
+        'pkg/conftest.py': 'import settings\nfrom decoy import Decoy\n\ndef fixture():\n    settings.conn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      main_block_write: [{ 'settings.py': header,
+        'run.py': 'import settings\nfrom decoy import Decoy\n\nif __name__ == "__main__":\n    settings.conn = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      own_main_block_write: [{ 'm.py': header + 'if __name__ == "__main__":\n    conn = Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' },
+        ['cb -> Store::fetch']],
+      globals_continued_key: [{ 'm.py': header + 'def reset():\n    globals()[\n        "conn"] = Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      globals_alias: [{ 'm.py': header + 'def reset():\n    g = globals()\n    g["conn"] = Decoy()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      globals_in_string: [{ 'm.py': header + 'NOTE = "globals().update(mapping)"\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' },
+        ['cb -> Store::fetch']],
+      external_dict_write: [{ 'settings.py': header,
+        'reset.py': 'import settings\nfrom decoy import Decoy\n\ndef reset():\n    settings.__dict__["conn"] = Decoy()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, []],
+      external_annotated_write: [{ 'settings.py': header,
+        'reset.py': 'import settings\nfrom store import Store\n\ndef reset():\n    settings.conn: Store = Store()\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      external_parenthesized_write: [{ 'settings.py': header,
+        'reset.py': 'import settings\nfrom store import Store\n\ndef reset():\n    settings.conn = (Store())\n',
+        'c.py': 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n' }, ['cb -> Store::fetch']],
+      dotted_import_collision: [{ 'alpha/__init__.py': '', 'beta/__init__.py': '',
+        'alpha/foo.py': 'class Client:\n    def fetch(self):\n        return 1\n', 'beta/foo.py': 'class Client:\n    def fetch(self):\n        return 2\n',
+        'm.py': 'import beta.foo\nimport alpha.foo\nconn = None\n\ndef init():\n    global conn\n    conn = alpha.foo.Client()\n\ndef cb(pool):\n    pool.submit(conn.fetch)\n' }, []],
+      dotted_base_collision: [{ 'alpha/__init__.py': '', 'beta/__init__.py': '',
+        'alpha/foo.py': 'class Client:\n    def fetch(self):\n        return 1\n', 'beta/foo.py': 'class Client:\n    def fetch(self):\n        return 2\n',
+        'm.py': 'import beta.foo\nimport alpha.foo\n\nclass Sub(alpha.foo.Client):\n    pass\n\ndef go(pool, s: Sub):\n    pool.submit(s.fetch)\n' }, []],
+    };
+    const got: Record<string, string[]> = {};
+    for (const [name, [files, _]] of Object.entries(cases)) {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `cg-fnref-global-${name}-`));
+      const all = { 'store.py': 'class Store:\n    def fetch(self, ids):\n        return ids\n',
+        'decoy.py': 'class Decoy:\n    def fetch(self, ids):\n        return []\n', ...files };
+      for (const [file, content] of Object.entries(all)) {
+        fs.mkdirSync(path.dirname(path.join(tmpDir, file)), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, file), content);
+      }
+      const cg = CodeGraph.initSync(tmpDir);
+      try {
+        await cg.indexAll();
+        got[name] = cg.getNodesByName('fetch').flatMap(t => cg.getIncomingEdges(t.id)
+          .filter(e => e.kind === 'references' && e.metadata?.fnRef === true)
+          .map(e => `${cg.getNode(e.source)?.name} -> ${t.qualifiedName}`)).sort();
+      } finally { cg.close(); fs.rmSync(tmpDir, { recursive: true, force: true }); tmpDir = undefined; }
+    }
+    expect(got).toEqual(Object.fromEntries(Object.entries(cases).map(([name, [, want]]) => [name, want])));
+  }, 60_000);
+
+  it('#1820: a module global re-resolves after its module changes (sync)', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-global-sync-'));
+    const settings = 'from store import Store\nfrom decoy import Decoy\nconn = None\n\ndef init():\n    global conn\n    conn = Store()\n';
+    const consumer = 'import settings\n\ndef cb(pool):\n    pool.submit(settings.conn.fetch)\n';
+    fs.writeFileSync(path.join(tmpDir, 'store.py'), 'class Store:\n    def fetch(self, ids):\n        return ids\n');
+    fs.writeFileSync(path.join(tmpDir, 'decoy.py'), 'class Decoy:\n    def fetch(self, ids):\n        return []\n');
+    fs.writeFileSync(path.join(tmpDir, 'settings.py'), settings);
+    fs.writeFileSync(path.join(tmpDir, 'consumer.py'), consumer);
+    const cg = CodeGraph.initSync(tmpDir);
+    const edges = () => cg.getNodesByName('fetch').flatMap(t => cg.getIncomingEdges(t.id)
+      .filter(e => e.metadata?.fnRef === true).map(e => `${cg.getNode(e.source)?.name} -> ${t.qualifiedName}`));
+    try {
+      await cg.indexAll();
+      expect(edges()).toEqual(['cb -> Store::fetch']);
+      fs.writeFileSync(path.join(tmpDir, 'settings.py'), settings.replace('conn = Store()', 'conn = Decoy()'));
+      fs.writeFileSync(path.join(tmpDir, 'consumer.py'), consumer + '\n# touched\n');
+      await cg.sync();
+      expect(edges()).toEqual(['cb -> Decoy::fetch']);
+    } finally { cg.close(); }
+  });
+
   it('#1820: Go receiver types disambiguate method values and reject external fields', async () => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-go-scope-'));
     fs.writeFileSync(path.join(tmpDir, 'main.go'), `package demo
diff --git a/__tests__/fuzzy-case-sensitivity.test.ts b/__tests__/fuzzy-case-sensitivity.test.ts
new file mode 100644
index 0000000000..eaeefc65ba
--- /dev/null
+++ b/__tests__/fuzzy-case-sensitivity.test.ts
@@ -0,0 +1,110 @@
+/**
+ * The last-resort fuzzy match compares names without regard to case. That
+ * is right for PHP, Pascal, CFML, COBOL and VB.NET, whose identifiers
+ * resolve that way, and wrong everywhere else: jsoup's 1,844 `@Test`
+ * annotations decorated a `CharPredicate.test` method, `new CookieManager()`
+ * instantiated a `cookieManager()` getter, gson's `Method` type referenced a
+ * test's `method()`.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+async function project(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fuzzy-case-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+const targetsFrom = (cg: CodeGraph, file: string): string[] =>
+  cg
+    .getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id))
+    .filter((e) => e.kind !== 'contains')
+    .map((e) => cg.getNode(e.target)!)
+    .map((n) => `${n.kind}:${n.name}`)
+    .sort();
+
+describe('fuzzy matching and case', () => {
+  it('Java: an annotation or a type is not a method whose name differs only in case', async () => {
+    const cg = await project({
+      'src/main/java/app/CharPredicate.java': `package app;
+public interface CharPredicate {
+  boolean test(char c);
+}
+`,
+      'src/main/java/app/Request.java': `package app;
+public class Request {
+  public Object cookieManager() { return null; }
+}
+`,
+      'src/test/java/app/ParserTest.java': `package app;
+import org.junit.jupiter.api.Test;
+import java.net.CookieManager;
+public class ParserTest {
+  @Test void parses() {
+    Object manager = new CookieManager();
+  }
+}
+`,
+    });
+    try {
+      const targets = targetsFrom(cg, 'src/test/java/app/ParserTest.java');
+      expect(targets).not.toContain('method:test');
+      expect(targets).not.toContain('method:cookieManager');
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('PHP still resolves a function whatever case the call is written in', async () => {
+    const cg = await project({
+      'src/helpers.php': `<?php
+function FormatPrice($amount) { return $amount; }
+`,
+      'src/view.php': `<?php
+function render() { return formatprice(10); }
+`,
+    });
+    try {
+      expect(targetsFrom(cg, 'src/view.php')).toContain('function:FormatPrice');
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('PHP: a call written after `=>` in an array is a function call, not some class’s method', async () => {
+    const cg = await project({
+      'app/CommentTree.php': `<?php
+class CommentTree {
+  public function count(): int { return 0; }
+}
+`,
+      'app/helpers.php': `<?php
+function user() { return null; }
+`,
+      'app/Controller.php': `<?php
+function summary($items) {
+  return ['total' => count($items), 'by' => user()];
+}
+`,
+    });
+    try {
+      const targets = targetsFrom(cg, 'app/Controller.php');
+      expect(targets).not.toContain('method:count');
+      expect(targets).toContain('function:user');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/generated-detection.test.ts b/__tests__/generated-detection.test.ts
index bd3a10c633..9269e771f4 100644
--- a/__tests__/generated-detection.test.ts
+++ b/__tests__/generated-detection.test.ts
@@ -20,6 +20,7 @@ import {
   isGeneratedFile,
   hasGeneratedHeader,
   detectGeneratedFile,
+  isMinifiedContent,
 } from '../src/extraction/generated-detection';
 
 describe('isGeneratedFile', () => {
@@ -220,3 +221,37 @@ describe('detectGeneratedFile — the union the indexer persists', () => {
     ).toBe(false);
   });
 });
+
+describe('isMinifiedContent — a bundle not named .min.js', () => {
+  const bundle = Array.from({ length: 300 }, (_, i) => `function f${i}(e){return n(e,${i})+t(e)}`).join(';');
+
+  it('recognizes a minified script by its enormous code lines', () => {
+    expect(isMinifiedContent('docs/assets/bundle.js', bundle)).toBe(true);
+    expect(isMinifiedContent('site/app.mjs', bundle)).toBe(true);
+    expect(detectGeneratedFile('docs/assets/bundle.js', bundle)).toBe(true);
+  });
+
+  it('recognizes a readable webpack build by its module loader, and `-min.js` by name', () => {
+    const webpack = `/*! lib */\n(function(modules) {\n  function __webpack_require__(moduleId) {\n    return modules[moduleId];\n  }\n${'  var x = 1;\n'.repeat(400)}})([]);\n`;
+    expect(isMinifiedContent('assets/js/syntaxhighlighter.js', webpack)).toBe(true);
+    expect(isGeneratedFile('vendor/underscore/underscore-min.js')).toBe(true);
+  });
+
+  it('leaves an ordinary file with one long string literal alone', () => {
+    const fixture = [
+      'export function decode(input) {',
+      '  return atob(input);',
+      '}',
+      `export const LOGO = "${'QUJD'.repeat(4000)}";`,
+      'export function size() { return LOGO.length; }',
+    ].join('\n');
+    expect(isMinifiedContent('src/logo.js', fixture)).toBe(false);
+  });
+
+  it('leaves hand-written code, TypeScript and short files alone', () => {
+    const code = Array.from({ length: 400 }, (_, i) => `export function f${i}(e) {\n  return e + ${i};\n}`).join('\n');
+    expect(isMinifiedContent('src/code.js', code)).toBe(false);
+    expect(isMinifiedContent('src/bundle.ts', bundle)).toBe(false);
+    expect(isMinifiedContent('src/tiny.js', 'function n(e){return e};function t(e){return n(e)}')).toBe(false);
+  });
+});
diff --git a/__tests__/go-defined-type-refs.test.ts b/__tests__/go-defined-type-refs.test.ts
new file mode 100644
index 0000000000..8d655a3b49
--- /dev/null
+++ b/__tests__/go-defined-type-refs.test.ts
@@ -0,0 +1,393 @@
+/**
+ * A Go defined type (`type WatchChan <-chan WatchResponse`, gin's `type
+ * HandlerFunc func(*Context)` and `type HandlersChain []HandlerFunc`) is a
+ * `type_alias` node, and it referenced nothing: only an alias (`type A = B`)
+ * named the types on its right-hand side. Impact on `WatchResponse` or gin's
+ * `Context` missed the declarations built from them, and everything that uses
+ * those.
+ *
+ * A defined type now references each type its right-hand side names, as an
+ * alias does: on the type's name, where resolution reads a package qualifier
+ * back, without its own type parameters or Go's predeclared types. Written
+ * bare, its own name is the declaration itself (`type stateFn func(*Lexer)
+ * stateFn`), which a recursive type names without depending on anything: no
+ * reference, so neither a self-edge nor an unresolved row for the name.
+ *
+ * Resolution reads the reference as any type position: a bare name is its own
+ * package's type, `pb.PutResponse` the import's, and a name written through a
+ * package the index doesn't know links to nothing. A defined type is a new
+ * type, though: unlike an alias, it does not have its underlying type's
+ * methods, so a method called on one is not looked up there.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** Every right-hand side a defined type can have, beside the types it names. */
+const DEFINED_SOURCE = `package gin
+
+import (
+	"context"
+
+	"github.com/gin-gonic/gin/render"
+)
+
+// HandlerFunc defines the handler used by gin middleware as return value.
+type HandlerFunc func(*Context)
+
+// HandlersChain defines a HandlerFunc slice.
+type HandlersChain []HandlerFunc
+
+type Context struct {
+	handlers HandlersChain
+}
+
+type WatchChan <-chan WatchResponse
+
+type WatchResponse struct{}
+
+type (
+	// Render names another package's type of its own name.
+	Render   render.Render
+	Lookup   map[Key]*WatchResponse
+	Grid     [4][4]Cell
+	Pipeline func(ctx context.Context, in <-chan Cell) (Key, error)
+	Wrapped  (Cell)
+	Named    Cell
+	Tables   map[string]struct {
+		cell Cell
+		*Key
+	}
+)
+
+type Generic[T any] List[T]
+
+type Pair[K comparable, V any] map[K]List[V]
+
+type stateFn func(*Lexer) stateFn
+
+type Tree []*Tree
+
+type List[T any] struct {
+	items []T
+}
+
+type Cell struct{}
+
+type Key string
+
+type Dur int
+
+type Mode uint8
+
+type Lexer struct{}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+/** `<kind> <name>` of every node but the file and its imports, in source order. */
+function declarations(result: ExtractionResult): string[] {
+  return result.nodes.filter((n) => n.kind !== 'file' && n.kind !== 'import').map((n) => `${n.kind} ${n.name}`);
+}
+
+/** `<source> <name>` for every `references` ref out of a type declaration, sorted. */
+function typeRefs(result: ExtractionResult): string[] {
+  const byId = new Map(result.nodes.map((n) => [n.id, n]));
+  return result.unresolvedReferences
+    .filter((r) => r.referenceKind === 'references' && ['type_alias', 'struct', 'interface'].includes(byId.get(r.fromNodeId)?.kind ?? ''))
+    .map((r) => `${byId.get(r.fromNodeId)!.name} ${r.referenceName}`)
+    .sort();
+}
+
+describe('a Go defined type references the types it is defined from', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['go']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', file: string, source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource(file, source, 'go');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract(file, source, 'go');
+    expect(result, `kernel extraction of ${file}`).not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const eol = (s: string) => (crlf ? s.replace(/\n/g, '\r\n') : s);
+    const label = crlf ? ' (CRLF)' : '';
+
+    it.each(backends)(`a defined type is still one type_alias node: %s${label}`, (backend) => {
+      const result = extract(backend, 'gin.go', eol(DEFINED_SOURCE));
+      expect(declarations(result)).toEqual([
+        'type_alias HandlerFunc',
+        'type_alias HandlersChain',
+        'struct Context',
+        'type_alias WatchChan',
+        'struct WatchResponse',
+        'type_alias Render',
+        'type_alias Lookup',
+        'type_alias Grid',
+        'type_alias Pipeline',
+        'type_alias Wrapped',
+        'type_alias Named',
+        'type_alias Tables',
+        'type_alias Generic',
+        'type_alias Pair',
+        'type_alias stateFn',
+        'type_alias Tree',
+        'struct List',
+        'struct Cell',
+        'type_alias Key',
+        'type_alias Dur',
+        'type_alias Mode',
+        'struct Lexer',
+      ]);
+    });
+
+    it.each(backends)(`a defined type references each type it names: %s${label}`, (backend) => {
+      const source = eol(DEFINED_SOURCE);
+      const result = extract(backend, 'gin.go', source);
+      // A qualified name keeps its package in the source (`render.Render`,
+      // `context.Context`). Not referenced: the predeclared types (string,
+      // int, uint8, error, comparable), the type parameters T, K and V, and a
+      // type's own name written bare (stateFn, Tree).
+      expect(typeRefs(result)).toEqual([
+        'Generic List',
+        'Grid Cell',
+        'HandlerFunc Context',
+        'HandlersChain HandlerFunc',
+        'Lookup Key',
+        'Lookup WatchResponse',
+        'Named Cell',
+        'Pair List',
+        'Pipeline Cell',
+        'Pipeline Context',
+        'Pipeline Key',
+        'Render Render',
+        'Tables Cell',
+        'Tables Key',
+        'WatchChan WatchResponse',
+        'Wrapped Cell',
+        'stateFn Lexer',
+      ]);
+      // Each sits on its name, where resolution reads the qualifier back.
+      const lines = source.split(/\r?\n/);
+      for (const r of result.unresolvedReferences.filter((u) => u.referenceKind === 'references')) {
+        expect(lines[r.line - 1]!.startsWith(r.referenceName, r.column), `${r.referenceName} at ${r.line}:${r.column}`).toBe(true);
+      }
+      const render = result.unresolvedReferences.find((r) => r.referenceName === 'Render')!;
+      expect(lines[render.line - 1]!.slice(0, render.column).trimStart()).toBe('Render   render.');
+    });
+  }
+});
+
+/** The module of the indexed tests: etcd's and gin's shapes, with namesakes in a package that sorts first. */
+const MODULE: Record<string, string> = {
+  'go.mod': 'module go.etcd.io/etcd\n\ngo 1.24\n',
+  'api/v3/etcdserverpb/rpc.pb.go': [
+    'package etcdserverpb',
+    '',
+    'type PutResponse struct {',
+    '\tHeader *ResponseHeader',
+    '}',
+    '',
+    'type ResponseHeader struct{}',
+    '',
+    'func (m *PutResponse) GetHeader() *ResponseHeader { return m.Header }',
+    '',
+  ].join('\n'),
+  // A lookup by name meets these first.
+  'alpha/names.go': [
+    'package alpha',
+    '',
+    'type PutResponse struct{}',
+    '',
+    'func (m *PutResponse) GetHeader() int { return 0 }',
+    '',
+    'type WatchResponse struct{}',
+    '',
+    'type Context struct{}',
+    '',
+    'type Op struct{}',
+    '',
+    'type watcher struct{}',
+    '',
+  ].join('\n'),
+  'client/v3/watch.go': [
+    'package clientv3',
+    '',
+    'import pb "go.etcd.io/etcd/api/v3/etcdserverpb"',
+    '',
+    'type PutResponse pb.PutResponse',
+    '',
+    'type WatchChan <-chan WatchResponse',
+    '',
+    'type WatchResponse struct {',
+    '\tCanceled bool',
+    '}',
+    '',
+    'type Op struct{}',
+    '',
+    'type watcher struct{}',
+    '',
+    'func (w *watcher) Watch() WatchChan { return nil }',
+    '',
+    'func header(r *PutResponse) { r.GetHeader() }',
+    '',
+    'type stateFn func(*watcher) stateFn',
+    '',
+  ].join('\n'),
+  // Package clientv3, known to the index by its path (`v3`, `client`) only.
+  'client/v3/ordering/util.go': [
+    'package ordering',
+    '',
+    'import "go.etcd.io/etcd/client/v3"',
+    '',
+    'type OrderViolationFunc func(op clientv3.Op) error',
+    '',
+  ].join('\n'),
+  'gin/gin.go': [
+    'package gin',
+    '',
+    'type HandlerFunc func(*Context)',
+    '',
+    'type HandlersChain []HandlerFunc',
+    '',
+    'type Context struct {',
+    '\thandlers HandlersChain',
+    '}',
+    '',
+    'type Engine struct{}',
+    '',
+    'func (engine *Engine) Use(middleware ...HandlerFunc) {}',
+    '',
+  ].join('\n'),
+};
+
+describe.each([
+  ['default', 'LF'],
+  ['wasm', 'LF'],
+  ['default', 'CRLF'],
+  ['wasm', 'CRLF'],
+])('an indexed Go module links its defined types (%s, %s)', (backend, eol) => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeAll(async () => {
+    kernel = process.env.CODEGRAPH_KERNEL;
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-defined-'));
+    for (const [rel, content] of Object.entries(MODULE)) {
+      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 });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  const nodeNamed = (file: string, name: string) => {
+    const nodes = cg!.getNodesInFile(file).filter((n) => n.name === name && n.kind !== 'import');
+    expect(nodes, `${name} in ${file}`).toHaveLength(1);
+    return nodes[0]!;
+  };
+
+  /** `kind file:qualifiedName` of each non-contains edge out of `name` in `file`, sorted. */
+  const linksFrom = (file: string, name: string) => {
+    const links = cg!.getOutgoingEdgesFrom([nodeNamed(file, name).id])
+      .filter((e) => e.kind !== 'contains')
+      .map((e) => ({ kind: e.kind, target: cg!.getNode(e.target)! }))
+      .map(({ kind, target }) => `${kind} ${target.filePath}:${target.qualifiedName}`);
+    return [...new Set(links)].sort();
+  };
+
+  /** `file:qualifiedName` of every node impact on `name` in `file` reaches, sorted. */
+  const impactOf = (file: string, name: string) =>
+    [...cg!.getImpactRadius(nodeNamed(file, name).id, 3).nodes.values()].map((n) => `${n.filePath}:${n.qualifiedName}`).sort();
+
+  it('a defined type references the types it names, each in its own package', () => {
+    expect(linksFrom('client/v3/watch.go', 'WatchChan')).toEqual(['references client/v3/watch.go:WatchResponse']);
+    expect(linksFrom('gin/gin.go', 'HandlerFunc')).toEqual(['references gin/gin.go:Context']);
+    expect(linksFrom('gin/gin.go', 'HandlersChain')).toEqual(['references gin/gin.go:HandlerFunc']);
+  });
+
+  it('a name written through an import is that package’s type, not the declaration of its name', () => {
+    expect(linksFrom('client/v3/watch.go', 'PutResponse')).toEqual(['references api/v3/etcdserverpb/rpc.pb.go:PutResponse']);
+  });
+
+  it('a recursive defined type has no edge to itself and no unresolved row for its name', () => {
+    expect(linksFrom('client/v3/watch.go', 'stateFn')).toEqual(['references client/v3/watch.go:watcher']);
+    expect(cg!.getUnresolvedReferencesFrom(nodeNamed('client/v3/watch.go', 'stateFn').id)).toEqual([]);
+  });
+
+  it('a name written through a package the index does not know links to nothing', () => {
+    expect(linksFrom('client/v3/ordering/util.go', 'OrderViolationFunc')).toEqual([]);
+    const refs = cg!.getUnresolvedReferencesFrom(nodeNamed('client/v3/ordering/util.go', 'OrderViolationFunc').id);
+    expect(refs.map((r) => `${r.referenceKind} ${r.referenceName}`)).toEqual(['references Op']);
+  });
+
+  it('a defined type does not have its underlying type’s methods', () => {
+    // `r.GetHeader()` on a PutResponse defined from pb.PutResponse: Go has no
+    // such method, so neither pb's nor alpha's is the callee.
+    expect(linksFrom('client/v3/watch.go', 'header')).toEqual(['references client/v3/watch.go:PutResponse']);
+  });
+
+  it('impact on a type reaches the defined types built from it, and their users', () => {
+    expect(impactOf('client/v3/watch.go', 'WatchResponse')).toEqual([
+      'client/v3/watch.go:WatchChan',
+      'client/v3/watch.go:WatchResponse',
+      'client/v3/watch.go:watcher::Watch',
+    ]);
+    expect(impactOf('gin/gin.go', 'Context')).toEqual([
+      'gin/gin.go:Context',
+      'gin/gin.go:Engine::Use',
+      'gin/gin.go:HandlerFunc',
+      'gin/gin.go:HandlersChain',
+    ]);
+  });
+});
diff --git a/__tests__/go-embedding-no-override.test.ts b/__tests__/go-embedding-no-override.test.ts
new file mode 100644
index 0000000000..d6d116634c
--- /dev/null
+++ b/__tests__/go-embedding-no-override.test.ts
@@ -0,0 +1,250 @@
+/**
+ * Go has no inheritance. gin's Engine embeds RouterGroup and declares a Use
+ * of its own:
+ *
+ *   type Engine struct {
+ *     RouterGroup
+ *     …
+ *   }
+ *
+ *   func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
+ *     engine.RouterGroup.Use(middleware...)
+ *     …
+ *   }
+ *
+ * The embedding is an `extends` edge (#2397), and the interface-dispatch
+ * bridge read every `extends` edge as an override, so it linked
+ * RouterGroup.Use → Engine.Use. But a call on a *RouterGroup only ever runs
+ * RouterGroup's own Use; nothing dispatches it to the embedder's. A flow or
+ * impact walk through RouterGroup.Use then went on into Engine.Use. Only an
+ * interface dispatches: a call through IRoutes still reaches both, through
+ * the implements edges go-implements adds, and so does a call through an
+ * interface a struct embeds. Java and TypeScript subclasses keep their
+ * overrides.
+ */
+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';
+import type { Edge, Node } from '../src/types';
+
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  'gin/gin.go': `package gin
+
+type HandlerFunc func()
+
+type HandlersChain []HandlerFunc
+
+func (c HandlersChain) Last() HandlerFunc { return nil }
+
+type IRoutes interface {
+	Use(...HandlerFunc) IRoutes
+}
+
+type RouterGroup struct{ Handlers HandlersChain }
+
+func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
+	group.Handlers = append(group.Handlers, middleware...)
+	return group
+}
+
+type Engine struct {
+	RouterGroup
+	trees []string
+}
+
+func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
+	engine.RouterGroup.Use(middleware...)
+	engine.rebuild404Handlers()
+	return engine
+}
+
+func (engine *Engine) rebuild404Handlers() {}
+
+// A Last of its own over the defined type it embeds.
+type routeInfo struct {
+	HandlersChain
+	path string
+}
+
+func (r routeInfo) Last() HandlerFunc { return nil }
+`,
+  // etcd's client/v3/concurrency: embedded through a pointer.
+  'concurrency/mutex.go': `package concurrency
+
+type Locker interface {
+	Lock()
+	Unlock()
+}
+
+type Mutex struct{ key string }
+
+func (m *Mutex) Lock()   {}
+func (m *Mutex) Unlock() {}
+
+type lockerMutex struct{ *Mutex }
+
+func (lm *lockerMutex) Lock()   { lm.Mutex.Lock() }
+func (lm *lockerMutex) Unlock() { lm.Mutex.Unlock() }
+`,
+  // etcd's generated gRPC stub, and a test server that overrides one RPC.
+  'api/auth.go': `package api
+
+type AuthServer interface {
+	Authenticate(name string) error
+	UserAdd(name string) error
+}
+
+type UnimplementedAuthServer struct{}
+
+func (UnimplementedAuthServer) Authenticate(name string) error { return nil }
+func (UnimplementedAuthServer) UserAdd(name string) error      { return nil }
+`,
+  'client/mock.go': `package client
+
+import "example.com/app/api"
+
+type mockAuthServer struct {
+	api.UnimplementedAuthServer
+}
+
+func (mockAuthServer) Authenticate(name string) error { return nil }
+`,
+  // A struct that embeds the interface it wraps does dispatch: a call
+  // through Appender on a limitAppender runs limitAppender's Append.
+  'storage/appender.go': `package storage
+
+type Appender interface {
+	Append(v float64) error
+	Commit() error
+}
+
+type limitAppender struct {
+	Appender
+	limit int
+}
+
+func (a *limitAppender) Append(v float64) error { return a.Appender.Append(v) }
+`,
+  'java/src/main/java/app/Base.java': 'package app;\n\npublic class Base {\n    public void run() {}\n}\n',
+  'java/src/main/java/app/Derived.java':
+    'package app;\n\npublic class Derived extends Base {\n    @Override\n    public void run() {}\n}\n',
+  'web/shapes.ts':
+    'export class Shape {\n  area(): number { return 0; }\n}\n\nexport class Square extends Shape {\n  area(): number { return 1; }\n}\n',
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-embedding-override-'));
+  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 });
+}, 120_000);
+
+afterAll(() => {
+  cg?.destroy();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const meta = (e: Edge): Record<string, unknown> => (e.metadata ?? {}) as Record<string, unknown>;
+
+/** The one non-import node with this name in this file. */
+function one(name: string, file: string): Node {
+  const found = cg.getNodesByName(name).filter((n) => n.filePath === file && n.kind !== 'import');
+  expect(found, `${name} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** The method `name` that the type `owner` in `file` contains. */
+function method(owner: string, name: string, file: string): Node {
+  const found = cg
+    .getOutgoingEdgesFrom([one(owner, file).id], ['contains'])
+    .map((e) => cg.getNode(e.target))
+    .filter((n): n is Node => n?.kind === 'method' && n.name === name);
+  expect(found, `${owner}.${name} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** Where the interface-dispatch bridge sends a call to this method. */
+function dispatchesTo(m: Node): string[] {
+  return cg
+    .getOutgoingEdgesFrom([m.id], ['calls'])
+    .filter((e) => meta(e).synthesizedBy === 'interface-impl')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+/** The type that contains a method. */
+function ownerOf(id: string): Node | undefined {
+  return cg
+    .getIncomingEdgesTo([id], ['contains'])
+    .map((e) => cg.getNode(e.source))
+    .find((n): n is Node => !!n && n.kind !== 'file');
+}
+
+describe('a Go embedding is not an override', () => {
+  it('embeds structs and a defined type through declared supertype edges', () => {
+    // The shapes the bridge used to read as inheritance.
+    const types = ['Engine', 'routeInfo', 'lockerMutex', 'mockAuthServer'].map((name) =>
+      cg.getNodesByName(name).find((n) => n.language === 'go' && n.kind === 'struct')!
+    );
+    const embeds = cg
+      .getOutgoingEdgesFrom(types.map((n) => n.id), ['extends'])
+      .filter((e) => e.provenance !== 'heuristic')
+      .map((e) => `${cg.getNode(e.source)!.name} -> ${cg.getNode(e.target)!.kind} ${cg.getNode(e.target)!.name}`)
+      .sort();
+    expect(embeds).toEqual([
+      'Engine -> struct RouterGroup',
+      'lockerMutex -> struct Mutex',
+      'mockAuthServer -> struct UnimplementedAuthServer',
+      'routeInfo -> type_alias HandlersChain',
+    ]);
+  });
+
+  it('links no method of an embedded struct or defined type to the embedder\'s method of that name', () => {
+    expect(dispatchesTo(method('RouterGroup', 'Use', 'gin/gin.go'))).toEqual([]);
+    expect(dispatchesTo(method('HandlersChain', 'Last', 'gin/gin.go'))).toEqual([]);
+    expect(dispatchesTo(method('Mutex', 'Lock', 'concurrency/mutex.go'))).toEqual([]);
+    expect(dispatchesTo(method('UnimplementedAuthServer', 'Authenticate', 'api/auth.go'))).toEqual([]);
+    // Nor anywhere else: every Go dispatch edge starts at an interface method.
+    const goMethods = cg.getNodesByKind('method').filter((n) => n.language === 'go');
+    const fromConcrete = cg
+      .getOutgoingEdgesFrom(goMethods.map((n) => n.id), ['calls'])
+      .filter((e) => meta(e).synthesizedBy === 'interface-impl' && ownerOf(e.source)?.kind !== 'interface')
+      .map((e) => `${cg.getNode(e.source)!.qualifiedName} -> ${cg.getNode(e.target)!.qualifiedName}`);
+    expect(fromConcrete).toEqual([]);
+  });
+
+  it('ends a walk through the embedded type\'s method at that method', () => {
+    const groupUse = method('RouterGroup', 'Use', 'gin/gin.go');
+    const engineUse = method('Engine', 'Use', 'gin/gin.go');
+    expect(cg.getCallees(groupUse.id).map((c) => c.node.qualifiedName)).not.toContain('Engine::Use');
+    expect(cg.getCallers(engineUse.id).map((c) => c.node.qualifiedName)).not.toContain('RouterGroup::Use');
+    expect([...cg.getImpactRadius(engineUse.id).nodes.values()].map((n) => n.qualifiedName)).not.toContain(
+      'RouterGroup::Use'
+    );
+  });
+
+  it('still dispatches a call through an interface to each type that implements it', () => {
+    expect(dispatchesTo(method('IRoutes', 'Use', 'gin/gin.go'))).toEqual(['Engine::Use', 'RouterGroup::Use']);
+    expect(dispatchesTo(method('Locker', 'Lock', 'concurrency/mutex.go'))).toEqual([
+      'Mutex::Lock',
+      'lockerMutex::Lock',
+    ]);
+    // limitAppender embeds Appender: a declared edge, not a synthesized one.
+    expect(dispatchesTo(method('Appender', 'Append', 'storage/appender.go'))).toEqual(['limitAppender::Append']);
+  });
+
+  it('keeps the overrides of languages with inheritance', () => {
+    const run = method('Base', 'run', 'java/src/main/java/app/Base.java');
+    expect(dispatchesTo(run).map((qn) => qn.replace(/^.*?(Derived)/, '$1'))).toEqual(['Derived::run']);
+    const area = method('Shape', 'area', 'web/shapes.ts');
+    expect(dispatchesTo(area).map((qn) => qn.replace(/^.*?(Square)/, '$1'))).toEqual(['Square::area']);
+  });
+});
diff --git a/__tests__/go-external-package-qualifier.test.ts b/__tests__/go-external-package-qualifier.test.ts
new file mode 100644
index 0000000000..5820e5ab0c
--- /dev/null
+++ b/__tests__/go-external-package-qualifier.test.ts
@@ -0,0 +1,85 @@
+/**
+ * A Go name written through an imported package from outside the module —
+ * `context.Context`, `http.ResponseWriter`, testify's `require.Contains` — is
+ * that package's, never a project symbol of the name: fiber's 85
+ * `context.Context` parameters went to a same-file method `Stream.Context`,
+ * and 403 `require.Contains(…)` to an extractor's `Contains`. A name through
+ * one of the module's own packages still resolves.
+ */
+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-go-ext-qual-'));
+  const files: Record<string, string> = {
+    'go.mod': 'module github.com/gofiber/fiber/v3\n\ngo 1.22\n',
+    'middleware/sse/sse.go': `package sse
+
+import (
+	"context"
+
+	"github.com/gofiber/fiber/v3/extractors"
+)
+
+type Stream struct{}
+
+func (s *Stream) Context() context.Context {
+	return nil
+}
+
+func run(ctx context.Context) bool {
+	return extractors.Contains("a", "b")
+}
+`,
+    'extractors/extractors.go': `package extractors
+
+func Contains(haystack, needle string) bool {
+	return true
+}
+`,
+    'middleware/sse/sse_test.go': `package sse
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestStream(t *testing.T) {
+	require.Contains(t, "abc", "a")
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('Go names through an outside package', () => {
+  it('are never a project symbol of that name', () => {
+    expect(targetsFrom('middleware/sse/sse.go')).not.toContain('Stream::Context');
+    expect(targetsFrom('middleware/sse/sse_test.go')).not.toContain('Contains');
+  });
+
+  it('while the module’s own packages still resolve', () => {
+    expect(targetsFrom('middleware/sse/sse.go')).toContain('Contains');
+  });
+});
diff --git a/__tests__/go-framework-own-package.test.ts b/__tests__/go-framework-own-package.test.ts
new file mode 100644
index 0000000000..137fa58804
--- /dev/null
+++ b/__tests__/go-framework-own-package.test.ts
@@ -0,0 +1,203 @@
+/**
+ * The Go framework resolver's name heuristics ("a `…Handler` is a handler
+ * function", "a PascalCase name is a model struct") outrank name matching on a
+ * tie, so where they guess wrong nothing corrects them. Go reads a name from
+ * one package only — one written bare from the reference's own, `pkg.Name`
+ * from that import's, `x[i].Name()` from whatever type `x[i]` has — so they
+ * guess only for a bare name, and only in its own package. Before, they took
+ * a struct of that name from any package: prometheus's promql/parser `Node`
+ * parameters went to discovery/kubernetes's struct `Node` instead of the
+ * package's own `Node` interface, and every `.String()` called through an
+ * expression became an instantiation of the struct `promql.String`.
+ */
+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-go-own-pkg-'));
+  const files: Record<string, string> = {
+    'go.mod': 'module example.com/app\n\ngo 1.22\n',
+    'promql/parser/ast.go': `package parser
+
+type Node interface {
+	String() string
+}
+
+type Visitor interface {
+	Visit(node Node, path []Node) (Visitor, error)
+}
+
+func Walk(v Visitor, node Node, path []Node) error {
+	return nil
+}
+`,
+    'discovery/kubernetes/node.go': `package kubernetes
+
+import apiv1 "k8s.io/api/core/v1"
+
+type Node struct {
+	name string
+}
+
+func nodeSource(n *apiv1.Node) string {
+	return n.Name
+}
+`,
+    'storage/interface.go': `package storage
+
+type Appender interface {
+	Append(ref uint64) error
+}
+
+type Filter interface {
+	Accept(value string) bool
+}
+`,
+    'storage/fanout.go': `package storage
+
+type fanout struct{}
+
+func (f *fanout) Appender() Appender {
+	return nil
+}
+`,
+    'discovery/aws/aws.go': `package aws
+
+type Filter struct {
+	Name string
+}
+`,
+    'web/api/v1/search.go': `package v1
+
+import "example.com/app/storage"
+
+type ChainFilter struct{}
+
+func NewChainFilter(filters ...storage.Filter) *ChainFilter {
+	return &ChainFilter{}
+}
+`,
+    'errors.go': `package gin
+
+type Error struct {
+	Err error
+}
+
+func (msg *Error) Error() string {
+	return msg.Err.Error()
+}
+
+var _ error = (*Error)(nil)
+
+func newError(err error) *Error {
+	return &Error{Err: err}
+}
+`,
+    'binding/validator.go': `package binding
+
+import "strings"
+
+type SliceValidationError []error
+
+func (err SliceValidationError) Error() string {
+	var b strings.Builder
+	for i := range err {
+		b.WriteString(err[i].Error())
+	}
+	return b.String()
+}
+`,
+    'handler/handler.go': `package handler
+
+type Handler struct{}
+
+func (h *Handler) Follow(c Context) error {
+	return nil
+}
+
+type Context interface{}
+`,
+    'handler/routes.go': `package handler
+
+type Group interface {
+	POST(path string, h func(Context) error)
+}
+
+func (h *Handler) Register(g Group) {
+	g.POST("/:username/follow", h.Follow)
+}
+`,
+    'model/user.go': `package model
+
+type Follow struct {
+	FollowerID uint
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/**
+ * `kind file:qualifiedName` of each edge out of `file`'s nodes (of one kind,
+ * or named `from`) whose target is named `name`, deduplicated and sorted.
+ */
+const linksFrom = (file: string, name: string, from?: { kind?: string; name?: string }) => {
+  const sources = cg.getNodesInFile(file).filter((n) => (!from?.kind || n.kind === from.kind) && (!from?.name || n.name === from.name));
+  const links = cg.getOutgoingEdgesFrom(sources.map((n) => n.id))
+    .filter((e) => e.kind !== 'contains')
+    .map((e) => ({ kind: e.kind, target: cg.getNode(e.target)! }))
+    .filter(({ target }) => target.name === name)
+    .map(({ kind, target }) => `${kind} ${target.filePath}:${target.qualifiedName}`);
+  return [...new Set(links)].sort();
+};
+
+describe('Go framework heuristics pick only in the package Go reads the name from', () => {
+  it('a bare type is its own package’s interface, not another package’s struct', () => {
+    expect(linksFrom('promql/parser/ast.go', 'Node')).toEqual(['references promql/parser/ast.go:Node']);
+  });
+
+  it('a type written through an outside import is not the same-named struct of its own file', () => {
+    expect(linksFrom('discovery/kubernetes/node.go', 'Node')).toEqual([]);
+  });
+
+  it('a method called through an expression is not an instantiation of a same-named struct', () => {
+    const links = linksFrom('binding/validator.go', 'Error');
+    expect(links.filter((l) => l.startsWith('instantiates'))).toEqual([]);
+    expect(links).not.toContain('calls errors.go:Error');
+  });
+
+  it('a result type is its own package’s type, not the method the line declares', () => {
+    expect(linksFrom('storage/fanout.go', 'Appender')).toEqual(['references storage/interface.go:Appender']);
+  });
+
+  it('a variadic `...pkg.T` is that import’s type', () => {
+    expect(linksFrom('web/api/v1/search.go', 'Filter')).toEqual(['references storage/interface.go:Filter']);
+  });
+
+  it('a conversion and a composite literal still reach their own package’s struct', () => {
+    expect(linksFrom('errors.go', 'Error', { name: '_' })).toEqual(['instantiates errors.go:Error']);
+    expect(linksFrom('errors.go', 'Error', { name: 'newError' })).toEqual([
+      'instantiates errors.go:Error',
+      'references errors.go:Error',
+    ]);
+  });
+
+  it('a route’s handler written through a value is that value’s method, not a model struct', () => {
+    expect(linksFrom('handler/routes.go', 'Follow', { kind: 'route' })).toEqual(['references handler/handler.go:Handler::Follow']);
+  });
+});
diff --git a/__tests__/go-implements-arity.test.ts b/__tests__/go-implements-arity.test.ts
new file mode 100644
index 0000000000..90903df2b8
--- /dev/null
+++ b/__tests__/go-implements-arity.test.ts
@@ -0,0 +1,432 @@
+/**
+ * Go's implicit interface satisfaction (#584) wants every method's signature
+ * identical, but goImplementsEdges matched method NAMES only:
+ *
+ *   type peerGetter interface { Get(id types.ID) Peer }      // etcd rafthttp
+ *   func (c *Cache) Get(ctx context.Context, key string,
+ *       opts ...clientv3.OpOption) (*clientv3.GetResponse, error)
+ *
+ * so etcd's watch cache "implemented" peerGetter, and every interface with a
+ * common method name (Get, Close, Build, Watch) collected structs that could
+ * never satisfy it — enough of them, at grpc-go's TransportBuilder, to fill
+ * the per-interface cap before the real implementer was reached. The pass now
+ * also wants each method's parameter and result counts, read off the stored
+ * signature text.
+ *
+ * One shape is kept on purpose: a server struct and the generated gRPC CLIENT
+ * interface of its service (`kvServer` and `KVClient`). That pair never
+ * satisfies Go, but its interface-impl edges are the bridge a client's call
+ * crosses to reach the handler serving it, so a client interface also takes
+ * its RPCs' server arities.
+ */
+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';
+import { goSignatureArity } from '../src/resolution/callback-synthesizer';
+import type { Edge, Node } from '../src/types';
+
+const BALANCERS = 45;
+
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  // etcd's rafthttp: one Get takes an ID, the cache's takes a context, a key
+  // and options.
+  'rafthttp/http.go': `package rafthttp
+
+import "context"
+
+type Peer interface{ attach() }
+
+type peerGetter interface {
+	Get(id uint64) Peer
+}
+
+type Transport struct{}
+
+func (t *Transport) Get(id uint64) Peer { return nil }
+
+type Cache struct{}
+
+func (c *Cache) Get(ctx context.Context, key string, opts ...string) (string, error) {
+	return "", nil
+}
+`,
+  // A result count differs: prometheus's test Closer returns nothing.
+  'testutil/closer.go': `package testutil
+
+type Closer interface {
+	Close()
+}
+
+type tmpDir struct{}
+
+func (d *tmpDir) Close() {}
+
+type Block struct{}
+
+func (b *Block) Close() error { return nil }
+
+// Close is promoted from Block, still returning an error.
+type wrapsBlock struct{ Block }
+`,
+  // Comments, a trailing comma and grouped names all count right.
+  'storage/storage.go': `package storage
+
+type Appender interface {
+	Append(
+		ref uint64, // the series, or 0 (new)
+		v float64, /* sample, value */
+	) (uint64, error)
+}
+
+type memAppender struct{}
+
+func (a *memAppender) Append(ref uint64, v float64) (uint64, error) { return ref, nil }
+
+type Putter interface {
+	Put(key, value []byte) error
+}
+
+type boltStore struct{}
+
+func (s *boltStore) Put(k []byte, v []byte) error { return nil }
+
+type Conn struct{}
+
+type Dialer interface {
+	Dial() (*Conn, error)
+}
+
+type bridgeDialer struct{}
+
+func (b *bridgeDialer) Dial() (*Conn, error) { return nil, nil }
+
+type rwTimeoutDialer struct{}
+
+func (d *rwTimeoutDialer) Dial(network, address string) (*Conn, error) { return nil, nil }
+`,
+  // Commas inside brackets, function types and struct tags are not parameters.
+  'generic/visit.go': `package generic
+
+type Pair[K comparable, V any] struct {
+	Key K
+	Val V
+}
+
+type Visitor interface {
+	Visit(fn func(key, value string) error, p Pair[string, int]) (n int, err error)
+}
+
+type walker struct{}
+
+func (w *walker) Visit(f func(k, v string) error, p Pair[string, int]) (int, error) { return 0, nil }
+
+type lister struct{}
+
+func (l *lister) Visit(f func(Pair[string, int]) bool) bool { return false }
+
+type Tagger interface {
+	Tag(v struct {
+		A, B int \`json:"a,omitempty" yaml:"(b)"\`
+	}) string
+}
+
+type tagger struct{}
+
+func (t tagger) Tag(v struct {
+	A, B int \`json:"a,omitempty" yaml:"(b)"\`
+}) string {
+	return ""
+}
+`,
+  // A generated gRPC service: the client interface, its stub, the server
+  // interface and the unimplemented server.
+  'api/kv_grpc.pb.go': `// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+
+package api
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+)
+
+type RangeRequest struct{}
+type RangeResponse struct{}
+type ListRequest struct{}
+type KV_ListClient struct{}
+type KV_ListServer struct{}
+type KV_WatchClient struct{}
+type KV_WatchServer struct{}
+
+type KVClient interface {
+	Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error)
+	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (KV_ListClient, error)
+	Watch(ctx context.Context, opts ...grpc.CallOption) (KV_WatchClient, error)
+}
+
+type kVClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func (c *kVClient) Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) {
+	return nil, nil
+}
+
+func (c *kVClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (KV_ListClient, error) {
+	return KV_ListClient{}, nil
+}
+
+func (c *kVClient) Watch(ctx context.Context, opts ...grpc.CallOption) (KV_WatchClient, error) {
+	return KV_WatchClient{}, nil
+}
+
+type KVServer interface {
+	Range(context.Context, *RangeRequest) (*RangeResponse, error)
+	List(*ListRequest, KV_ListServer) error
+	Watch(KV_WatchServer) error
+}
+
+type UnimplementedKVServer struct{}
+
+func (UnimplementedKVServer) Range(context.Context, *RangeRequest) (*RangeResponse, error) {
+	return nil, nil
+}
+func (UnimplementedKVServer) List(*ListRequest, KV_ListServer) error { return nil }
+func (UnimplementedKVServer) Watch(KV_WatchServer) error             { return nil }
+`,
+  'server/kv.go': `package server
+
+import (
+	"context"
+
+	"example.com/app/api"
+	"google.golang.org/grpc"
+)
+
+// Serves the KV service: a unary, a server-streaming and a bidi RPC.
+type kvServer struct{}
+
+func (s *kvServer) Range(ctx context.Context, r *api.RangeRequest) (*api.RangeResponse, error) {
+	return nil, nil
+}
+func (s *kvServer) List(r *api.ListRequest, stream api.KV_ListServer) error { return nil }
+func (s *kvServer) Watch(stream api.KV_WatchServer) error                   { return nil }
+
+// What the server ranges through. The generated client has a Range too, with
+// call options: it is no RaftKV.
+type RaftKV interface {
+	Range(ctx context.Context, r *api.RangeRequest) (*api.RangeResponse, error)
+}
+
+// An interface that mixes a client call with a method of its own is no
+// gRPC client: what it asks for is what it takes.
+type closingRanger interface {
+	Range(ctx context.Context, in *api.RangeRequest, opts ...grpc.CallOption) (*api.RangeResponse, error)
+	Close() error
+}
+
+type rangeCloser struct{}
+
+func (c *rangeCloser) Range(ctx context.Context, r *api.RangeRequest) (*api.RangeResponse, error) {
+	return nil, nil
+}
+func (c *rangeCloser) Close() error { return nil }
+`,
+  // A hand-written client wrapper with methods of the same names and its own
+  // shapes: neither a client stub nor a server.
+  'client/kv.go': `package client
+
+import (
+	"context"
+
+	"example.com/app/api"
+)
+
+type kv struct{ remote api.KVClient }
+
+func (k *kv) Range(key string) string          { return key }
+func (k *kv) List(prefix string) []string      { return nil }
+func (k *kv) Watch(key string) <-chan string   { return nil }
+
+func (k *kv) Get(ctx context.Context, key string) {
+	k.remote.Range(ctx, &api.RangeRequest{})
+}
+`,
+  // grpc-go's xDS TransportBuilder: more balancer builders with a Build of
+  // their own than the cap, sorted before the one real implementer.
+  'balancer/builders.go': [
+    'package balancer',
+    '',
+    'type ClientConn struct{}',
+    'type BuildOptions struct{}',
+    'type Balancer struct{}',
+    '',
+    ...Array.from({ length: BALANCERS }, (_, i) => {
+      const n = `builder${String(i).padStart(2, '0')}`;
+      return `type ${n} struct{}\n\nfunc (${n}) Build(cc ClientConn, opts BuildOptions) Balancer { return Balancer{} }\n`;
+    }),
+  ].join('\n'),
+  'xds/transport.go': `package xds
+
+type Transport struct{}
+
+type TransportBuilder interface {
+	Build(serverURI string) (*Transport, error)
+}
+
+type grpcTransportBuilder struct{}
+
+func (b *grpcTransportBuilder) Build(serverURI string) (*Transport, error) { return nil, nil }
+`,
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-implements-arity-'));
+  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 });
+}, 120_000);
+
+afterAll(() => {
+  cg?.destroy();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const meta = (e: Edge): Record<string, unknown> => (e.metadata ?? {}) as Record<string, unknown>;
+const pkg = (n: Node | null): string => `${path.posix.dirname(n?.filePath ?? '?')}.${n?.name}`;
+
+/** The one non-import node with this name in this file. */
+function one(name: string, file: string): Node {
+  const found = cg.getNodesByName(name).filter((n) => n.filePath === file && n.kind !== 'import');
+  expect(found, `${name} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** Every synthesized struct → interface edge, as `pkg.Struct -> pkg.Interface`. */
+function goImplements(): string[] {
+  const structs = cg.getNodesByKind('struct').filter((n) => n.language === 'go');
+  return cg
+    .getOutgoingEdgesFrom(structs.map((n) => n.id), ['implements'])
+    .filter((e) => meta(e).synthesizedBy === 'go-implements')
+    .map((e) => `${pkg(cg.getNode(e.source))} -> ${pkg(cg.getNode(e.target))}`)
+    .sort();
+}
+
+/** Where a call through an interface method lands: its interface-impl targets. */
+function dispatch(iface: string, file: string, method: string): string[] {
+  const m = cg
+    .getOutgoingEdgesFrom([one(iface, file).id], ['contains'])
+    .map((e) => cg.getNode(e.target))
+    .find((n) => n?.name === method)!;
+  return cg
+    .getOutgoingEdgesFrom([m.id], ['calls'])
+    .filter((e) => meta(e).synthesizedBy === 'interface-impl')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('Go implicit satisfaction checks parameter and result counts', () => {
+  it('links only the structs whose methods take and return as many values', () => {
+    expect(goImplements()).toEqual([
+      'api.UnimplementedKVServer -> api.KVClient',
+      'api.UnimplementedKVServer -> api.KVServer',
+      'api.UnimplementedKVServer -> server.RaftKV',
+      'api.kVClient -> api.KVClient',
+      'generic.tagger -> generic.Tagger',
+      'generic.walker -> generic.Visitor',
+      'rafthttp.Transport -> rafthttp.peerGetter',
+      'server.kvServer -> api.KVClient',
+      'server.kvServer -> api.KVServer',
+      'server.kvServer -> server.RaftKV',
+      'server.rangeCloser -> server.RaftKV',
+      'storage.boltStore -> storage.Putter',
+      'storage.bridgeDialer -> storage.Dialer',
+      'storage.memAppender -> storage.Appender',
+      'testutil.tmpDir -> testutil.Closer',
+      'xds.grpcTransportBuilder -> xds.TransportBuilder',
+    ]);
+  });
+
+  it('dispatches a call through an interface only to methods Go could reach', () => {
+    expect(dispatch('peerGetter', 'rafthttp/http.go', 'Get')).toEqual(['Transport::Get']);
+    expect(dispatch('Closer', 'testutil/closer.go', 'Close')).toEqual(['tmpDir::Close']);
+    // The generated client ranges with call options; RaftKV doesn't take them.
+    expect(dispatch('RaftKV', 'server/kv.go', 'Range')).toEqual([
+      'UnimplementedKVServer::Range',
+      'kvServer::Range',
+      'rangeCloser::Range',
+    ]);
+  });
+
+  it('keeps a struct that fails the counts out of the per-interface cap', () => {
+    const builders = cg
+      .getIncomingEdgesTo([one('TransportBuilder', 'xds/transport.go').id], ['implements'])
+      .filter((e) => meta(e).synthesizedBy === 'go-implements')
+      .map((e) => pkg(cg.getNode(e.source)));
+    expect(builders).toEqual(['xds.grpcTransportBuilder']);
+  });
+});
+
+describe('a gRPC client interface reaches the servers of its service', () => {
+  it('links the client stub and every server, unary and streaming RPCs alike', () => {
+    for (const rpc of ['Range', 'List', 'Watch']) {
+      expect(dispatch('KVClient', 'api/kv_grpc.pb.go', rpc), rpc).toEqual([
+        `UnimplementedKVServer::${rpc}`,
+        `kVClient::${rpc}`,
+        `kvServer::${rpc}`,
+      ]);
+    }
+    expect(
+      cg
+        .getIncomingEdgesTo([one('KVClient', 'api/kv_grpc.pb.go').id], ['implements'])
+        .map((e) => pkg(cg.getNode(e.source)))
+        .sort()
+    ).toEqual(['api.UnimplementedKVServer', 'api.kVClient', 'server.kvServer']);
+  });
+
+  it('leaves out a wrapper with methods of the same names and other shapes', () => {
+    const wrapper = cg
+      .getOutgoingEdgesFrom([one('kv', 'client/kv.go').id], ['implements'])
+      .map((e) => pkg(cg.getNode(e.target)));
+    expect(wrapper).toEqual([]);
+  });
+
+  it('takes server arities only for an interface whose every method is a client call', () => {
+    const rangers = cg
+      .getIncomingEdgesTo([one('closingRanger', 'server/kv.go').id], ['implements'])
+      .map((e) => pkg(cg.getNode(e.source)));
+    expect(rangers).toEqual([]);
+  });
+});
+
+describe('goSignatureArity', () => {
+  it.each([
+    ['()', '0/0'],
+    ['() error', '0/1'],
+    ['(s string) (int)', '1/1'],
+    ['(a, b int) (n int, err error)', '2/2'],
+    ['(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[WatchRequest, WatchResponse], error)', '2/2'],
+    ['(fn func(a, b int) (int, error), m map[string][]int)', '2/0'],
+    ['(p Pair[K, V]) func() (int, error)', '1/1'],
+    ['(\n\tref uint64, // the series, or 0 (new)\n\tv float64, /* sample, value */\n) (uint64, error)', '2/2'],
+    ['(v struct {\n\tA, B int `json:"a,omitempty" yaml:"(b)"`\n}) string', '1/1'],
+    ["(r rune) bool", '1/1'],
+  ])('reads %j as %s', (signature, arity) => {
+    expect(goSignatureArity(signature)).toBe(arity);
+  });
+
+  it.each([[undefined], [''], ['(a int'], ['[T any](x T)'], ['(a int) (b int'], ['(a int) (b int) c']])(
+    'gives up on %j',
+    (signature) => {
+      expect(goSignatureArity(signature)).toBeNull();
+    }
+  );
+});
diff --git a/__tests__/go-implements-defined-types.test.ts b/__tests__/go-implements-defined-types.test.ts
new file mode 100644
index 0000000000..66a2f30b28
--- /dev/null
+++ b/__tests__/go-implements-defined-types.test.ts
@@ -0,0 +1,315 @@
+/**
+ * Go's implicit interface satisfaction (#584) is not only for structs. Any
+ * defined type can declare methods, and plenty of real implementers are not
+ * structs at all:
+ *
+ *   type staticDiscoverer []*targetgroup.Group     // prometheus discovery
+ *   func (c staticDiscoverer) Run(ctx context.Context, up chan<- []*targetgroup.Group)
+ *
+ *   type formSource map[string][]string            // gin binding
+ *   func (form formSource) TrySet(…) (bool, error)
+ *
+ *   type Int64Comparable int64                     // etcd pkg/adt
+ *   func (v Int64Comparable) Compare(c Comparable) int
+ *
+ * Such a type is extracted as a `type_alias` that owns its methods through
+ * `contains` edges, but goImplementsEdges only ever offered structs as
+ * implementers, and the interface-dispatch bridge only walked class, struct and
+ * union. So `Discoverer` never listed the static discoverer, and a call
+ * through `Discoverer.Run` could not reach its `Run`.
+ */
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { buildTypeHierarchy } from '../src/graph/type-hierarchy';
+import type { Edge, Node } from '../src/types';
+
+const RING_STRUCTS = 40;
+
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  // prometheus's discovery package.
+  'discovery/discovery.go': `package discovery
+
+import "context"
+
+type Group struct{ Source string }
+
+type Discoverer interface {
+	Run(ctx context.Context, up chan<- []*Group)
+}
+
+type Config interface {
+	Name() string
+	NewDiscoverer() (Discoverer, error)
+}
+
+// A list of groups that is a Config, and hands out a Discoverer over itself.
+type StaticConfig []*Group
+
+func (StaticConfig) Name() string { return "static" }
+
+func (c StaticConfig) NewDiscoverer() (Discoverer, error) { return staticDiscoverer(c), nil }
+
+type staticDiscoverer []*Group
+
+func (c staticDiscoverer) Run(ctx context.Context, up chan<- []*Group) {
+	select {
+	case <-ctx.Done():
+	case up <- c:
+	}
+}
+
+// A true alias: the same type as staticDiscoverer, not a second one.
+type StaticDiscoverer = staticDiscoverer
+
+// A name but no NewDiscoverer: no Config.
+type namedGroups []*Group
+
+func (namedGroups) Name() string { return "named" }
+`,
+  // gin's binding package: two setters over a map and over a struct type, the
+  // second with its method in another file.
+  'binding/form_mapping.go': `package binding
+
+type setOptions struct{ isDefaultExists bool }
+
+type setter interface {
+	TrySet(key string, opt setOptions) (bool, error)
+}
+
+type formSource map[string][]string
+
+func (form formSource) TrySet(key string, opt setOptions) (bool, error) { return false, nil }
+
+// No method at all.
+type keys []string
+`,
+  'binding/multipart_form_mapping.go': `package binding
+
+import "net/http"
+
+type multipartRequest http.Request
+`,
+  'binding/multipart_set.go': `package binding
+
+func (r *multipartRequest) TrySet(key string, opt setOptions) (bool, error) { return false, nil }
+`,
+  // etcd's pkg/adt.
+  'adt/interval_tree.go': `package adt
+
+type Comparable interface {
+	Compare(c Comparable) int
+}
+
+type StringComparable string
+
+func (s StringComparable) Compare(c Comparable) int { return 0 }
+
+type Int64Comparable int64
+
+func (v Int64Comparable) Compare(c Comparable) int { return 0 }
+`,
+  // An adapter over a function type, a generic defined type, and a defined
+  // type whose underlying type is an interface.
+  'web/handler.go': `package web
+
+type Request struct{}
+
+type ResponseWriter interface {
+	Write(b []byte) (int, error)
+}
+
+type Handler interface {
+	ServeHTTP(w ResponseWriter, r *Request)
+}
+
+type HandlerFunc func(ResponseWriter, *Request)
+
+func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r) }
+
+type Lener interface {
+	Len() int
+}
+
+type Set[T comparable] map[T]struct{}
+
+func (s Set[T]) Len() int { return len(s) }
+
+// An interface type by another name: never an implementer itself.
+type Serving Handler
+`,
+  // More implementers that declare Tick than the cap: a defined type in the
+  // file listed first, then the structs.
+  'ring/a.go': 'package ring\n\ntype Ticker interface{ Tick() }\n\ntype alarm int\n\nfunc (alarm) Tick() {}\n',
+  'ring/b.go': [
+    'package ring',
+    '',
+    ...Array.from({ length: RING_STRUCTS }, (_, i) => {
+      const name = `tick${String(i).padStart(2, '0')}`;
+      return `type ${name} struct{}\n\nfunc (${name}) Tick() {}\n`;
+    }),
+  ].join('\n'),
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-defined-types-'));
+  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 });
+}, 120_000);
+
+afterAll(() => {
+  cg?.destroy();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const meta = (e: Edge): Record<string, unknown> => (e.metadata ?? {}) as Record<string, unknown>;
+const pkg = (n: Node | null): string => `${path.posix.dirname(n?.filePath ?? '?')}.${n?.name}`;
+
+/** The one non-import node with this name in this file. */
+function one(name: string, file: string): Node {
+  const found = cg.getNodesByName(name).filter((n) => n.filePath === file && n.kind !== 'import');
+  expect(found, `${name} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** Every Go type in the graph that could implement an interface. */
+function goTypes(g: CodeGraph): Node[] {
+  return [...g.getNodesByKind('struct'), ...g.getNodesByKind('type_alias')].filter((n) => n.language === 'go');
+}
+
+/** Every synthesized type → interface edge, as `pkg.Type -> pkg.Interface`. */
+function goImplements(): string[] {
+  return cg
+    .getOutgoingEdgesFrom(goTypes(cg).map((n) => n.id), ['implements'])
+    .filter((e) => meta(e).synthesizedBy === 'go-implements')
+    .map((e) => `${pkg(cg.getNode(e.source))} -> ${pkg(cg.getNode(e.target))}`)
+    .filter((e) => !e.startsWith('ring.'))
+    .sort();
+}
+
+/** Where a call through the interface's method is bridged to. */
+function dispatchTargets(iface: string, file: string, method: string): string[] {
+  const m = cg
+    .getOutgoingEdgesFrom([one(iface, file).id], ['contains'])
+    .map((e) => cg.getNode(e.target))
+    .find((n) => n?.name === method)!;
+  return cg
+    .getOutgoingEdgesFrom([m.id], ['calls'])
+    .filter((e) => meta(e).synthesizedBy === 'interface-impl')
+    .map((e) => cg.getNode(e.target)?.qualifiedName ?? '?')
+    .sort();
+}
+
+describe('Go implicit satisfaction counts defined types as implementers', () => {
+  it('links every defined type whose methods cover the interface', () => {
+    expect(goImplements()).toEqual([
+      'adt.Int64Comparable -> adt.Comparable',
+      'adt.StringComparable -> adt.Comparable',
+      'binding.formSource -> binding.setter',
+      'binding.multipartRequest -> binding.setter',
+      'discovery.StaticConfig -> discovery.Config',
+      'discovery.staticDiscoverer -> discovery.Discoverer',
+      'web.HandlerFunc -> web.Handler',
+      'web.Set -> web.Lener',
+    ]);
+  });
+
+  it('bridges a call through the interface to the defined type\'s method', () => {
+    expect(dispatchTargets('Discoverer', 'discovery/discovery.go', 'Run')).toEqual(['staticDiscoverer::Run']);
+    expect(dispatchTargets('Config', 'discovery/discovery.go', 'NewDiscoverer')).toEqual([
+      'StaticConfig::NewDiscoverer',
+    ]);
+    expect(dispatchTargets('setter', 'binding/form_mapping.go', 'TrySet')).toEqual([
+      'formSource::TrySet',
+      'multipartRequest::TrySet',
+    ]);
+    expect(dispatchTargets('Comparable', 'adt/interval_tree.go', 'Compare')).toEqual([
+      'Int64Comparable::Compare',
+      'StringComparable::Compare',
+    ]);
+    expect(dispatchTargets('Handler', 'web/handler.go', 'ServeHTTP')).toEqual(['HandlerFunc::ServeHTTP']);
+  });
+
+  it('shows them in the type hierarchy, both ways', () => {
+    const below = buildTypeHierarchy(cg, one('Comparable', 'adt/interval_tree.go'))?.descendants ?? [];
+    expect(below.map((d) => `${d.relation} ${pkg(d.node)}${d.synthesized ? ' (synthesized)' : ''}`).sort()).toEqual([
+      'implements adt.Int64Comparable (synthesized)',
+      'implements adt.StringComparable (synthesized)',
+    ]);
+    const above = buildTypeHierarchy(cg, one('staticDiscoverer', 'discovery/discovery.go'))?.ancestors ?? [];
+    expect(above.map((a) => `${a.relation} ${pkg(a.node)}`)).toEqual(['implements discovery.Discoverer']);
+  });
+
+  it('keeps a true alias and an interface by another name from implementing anything', () => {
+    const named = (name: string) =>
+      cg
+        .getNodesByName(name)
+        .filter((n) => n.language === 'go' && n.kind !== 'import')
+        .flatMap((n) => cg.getOutgoingEdgesFrom([n.id], ['implements']));
+    expect(named('StaticDiscoverer')).toEqual([]);
+    expect(named('Serving')).toEqual([]);
+    // The type the alias names is linked once.
+    expect(goImplements().filter((e) => e.includes('staticDiscoverer'))).toHaveLength(1);
+  });
+
+  it('caps an interface at 40 implementers, taking defined types in file order with the declaring structs', () => {
+    const linked = cg
+      .getIncomingEdgesTo([one('Ticker', 'ring/a.go').id], ['implements'])
+      .filter((e) => meta(e).synthesizedBy === 'go-implements')
+      .map((e) => cg.getNode(e.source)!.name);
+    // alarm and 40 structs declare Tick. alarm comes first in file order, so
+    // the last struct is the one the cap leaves out.
+    expect(linked).toHaveLength(40);
+    expect(linked).toContain('alarm');
+    expect(linked).not.toContain(`tick${RING_STRUCTS - 1}`);
+    expect(dispatchTargets('Ticker', 'ring/a.go', 'Tick')).toContain('alarm::Tick');
+  });
+});
+
+describe('a sync that edits a defined type\'s method', () => {
+  let dir = '';
+  let graph: CodeGraph | undefined;
+
+  afterEach(() => {
+    graph?.destroy();
+    graph = undefined;
+    if (dir) fs.rmSync(dir, { recursive: true, force: true });
+    dir = '';
+  });
+
+  it('re-derives what the defined type satisfies', async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-defined-types-sync-'));
+    const write = (rel: string, content: string) => {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    };
+    const int64 = 'package adt\n\ntype Int64Comparable int64\n\nfunc (v Int64Comparable) Compare(c Comparable) int { return 0 }\n';
+    write('go.mod', 'module example.com/app\n\ngo 1.22\n');
+    write('adt/comparable.go', 'package adt\n\ntype Comparable interface {\n\tCompare(c Comparable) int\n}\n');
+    write('adt/int64.go', int64);
+    graph = await CodeGraph.init(dir, { index: true });
+    const g = graph;
+    const linked = () =>
+      g
+        .getOutgoingEdgesFrom(goTypes(g).map((n) => n.id), ['implements'])
+        .filter((e) => meta(e).synthesizedBy === 'go-implements')
+        .map((e) => `${g.getNode(e.source)?.name} -> ${g.getNode(e.target)?.name}`);
+
+    expect(linked()).toEqual(['Int64Comparable -> Comparable']);
+    write('adt/int64.go', int64.replace('Compare(', 'Cmp('));
+    await g.sync({ paths: ['adt/int64.go'] });
+    expect(linked()).toEqual([]);
+    write('adt/int64.go', int64);
+    await g.sync({ paths: ['adt/int64.go'] });
+    expect(linked()).toEqual(['Int64Comparable -> Comparable']);
+  }, 60_000);
+});
diff --git a/__tests__/go-implements-embedding.test.ts b/__tests__/go-implements-embedding.test.ts
new file mode 100644
index 0000000000..702a52f634
--- /dev/null
+++ b/__tests__/go-implements-embedding.test.ts
@@ -0,0 +1,407 @@
+/**
+ * Go's implicit interface satisfaction (#584) compares method sets, and in Go
+ * both sides include what embedding brings in:
+ *
+ *   type AuthReadTx interface {   // etcd's server/auth/store.go
+ *     RLock()
+ *     RUnlock()
+ *     UnsafeAuthReader            // UnsafeReadAuthEnabled, UnsafeGetUser, …
+ *   }
+ *
+ *   type blockQuerier struct {    // Select of its own; LabelValues, LabelNames
+ *     *storage.BaseQuerier        // and Close promoted from BaseQuerier
+ *   }
+ *
+ * goImplementsEdges read each type's own methods only. AuthReadTx asked for
+ * RLock and RUnlock, so etcd's RWMutex "implemented" it, and an interface
+ * that only embeds others (`ChunkQuerier { LabelQuerier }`) asked for nothing
+ * and was skipped. Embedded interfaces are `extends` edges now, embedded
+ * structs `extends` and embedded interfaces of a struct `implements`, so both
+ * method sets follow those declared edges, however deep and around cycles.
+ * Reading only the interface side would have dropped every struct that
+ * satisfies an interface through promoted methods, like blockQuerier.
+ */
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { buildTypeHierarchy } from '../src/graph/type-hierarchy';
+import type { Edge, Node } from '../src/types';
+
+const FLEET_UNITS = 45;
+
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  // prometheus's storage interfaces.
+  'storage/storage.go': `package storage
+
+type LabelQuerier interface {
+	LabelValues(name string) []string
+	LabelNames() []string
+	Close() error
+}
+
+type Querier interface {
+	LabelQuerier
+	Select(sorted bool) int
+}
+
+// No method of its own.
+type ChunkQuerier interface {
+	LabelQuerier
+}
+
+// Promotes its methods into every struct that embeds it.
+type BaseQuerier struct{}
+
+func (b *BaseQuerier) LabelValues(name string) []string { return nil }
+func (b *BaseQuerier) LabelNames() []string            { return nil }
+func (b *BaseQuerier) Close() error                    { return nil }
+
+type Appender interface {
+	Append(ref uint64, v float64) (uint64, error)
+	Commit() error
+	Rollback() error
+}
+
+type Committer interface {
+	Commit() error
+	Rollback() error
+}
+`,
+  'tsdb/querier.go': `package tsdb
+
+import "example.com/app/storage"
+
+// A storage.Querier through BaseQuerier's promoted methods and its own Select.
+type blockQuerier struct {
+	*storage.BaseQuerier
+	mint, maxt int64
+}
+
+func (q *blockQuerier) Select(sorted bool) int { return 0 }
+
+// Select and nothing else: no Querier.
+type exemplarQuerier struct{}
+
+func (e *exemplarQuerier) Select(sorted bool) int { return 0 }
+
+// Embeds the interface it wraps, so it already declares that it is one.
+type limitAppender struct {
+	storage.Appender
+	limit int
+}
+
+func (a *limitAppender) Append(ref uint64, v float64) (uint64, error) {
+	return a.Appender.Append(ref, v)
+}
+`,
+  // etcd's server/auth/store.go.
+  'auth/store.go': `package auth
+
+type UnsafeAuthReader interface {
+	UnsafeReadAuthEnabled() bool
+	UnsafeGetUser(name string) string
+}
+
+type AuthReadTx interface {
+	RLock()
+	RUnlock()
+	UnsafeAuthReader
+}
+
+// A lock: no auth reader.
+type RWMutex struct{}
+
+func (m *RWMutex) Lock()    {}
+func (m *RWMutex) Unlock()  {}
+func (m *RWMutex) RLock()   {}
+func (m *RWMutex) RUnlock() {}
+
+type authReadTx struct{}
+
+func (t *authReadTx) RLock()                           {}
+func (t *authReadTx) RUnlock()                         {}
+func (t *authReadTx) UnsafeReadAuthEnabled() bool      { return false }
+func (t *authReadTx) UnsafeGetUser(name string) string { return name }
+`,
+  // gin's router: Engine overrides Use and gets the rest from RouterGroup.
+  'gin/gin.go': `package gin
+
+type HandlerFunc func()
+
+type HandlersChain []HandlerFunc
+
+func (c HandlersChain) Last() HandlerFunc { return nil }
+
+type IRoutes interface {
+	Use(...HandlerFunc) IRoutes
+	GET(string, ...HandlerFunc) IRoutes
+}
+
+type IRouter interface {
+	IRoutes
+	Group(string, ...HandlerFunc) *RouterGroup
+}
+
+type RouterGroup struct{ Handlers HandlersChain }
+
+func (g *RouterGroup) Use(...HandlerFunc) IRoutes                { return g }
+func (g *RouterGroup) GET(string, ...HandlerFunc) IRoutes        { return g }
+func (g *RouterGroup) Group(string, ...HandlerFunc) *RouterGroup { return g }
+
+type Engine struct {
+	RouterGroup
+	trees []string
+}
+
+func (e *Engine) Use(middleware ...HandlerFunc) IRoutes {
+	e.RouterGroup.Use(middleware...)
+	return e
+}
+
+type Chain interface {
+	Last() HandlerFunc
+	Reset()
+}
+
+// Last is promoted from the defined type it embeds.
+type routeInfo struct {
+	HandlersChain
+	path string
+}
+
+func (r *routeInfo) Reset() {}
+`,
+  'cycles/cycles.go': `package cycles
+
+type Walker interface{ Walk() }
+
+// A struct may embed a pointer to itself.
+type Node struct {
+	*Node
+	next *Node
+}
+
+func (n *Node) Walk() {}
+
+type Peer interface {
+	Send()
+	Reply()
+}
+
+// Each embeds the other through a pointer, so each has both methods.
+type Client struct{ *Server }
+
+type Server struct{ *Client }
+
+func (c *Client) Send()  {}
+func (s *Server) Reply() {}
+
+// Not valid Go, but a graph can hold it: each embeds the other.
+type Left interface {
+	Right
+	L()
+}
+
+type Right interface {
+	Left
+	R()
+}
+
+type both struct{}
+
+func (both) L() {}
+func (both) R() {}
+`,
+  'empty/empty.go': `package empty
+
+import "io"
+
+type Any interface{}
+
+// Embeds only what the project does not declare: nothing to match.
+type Closer interface{ io.Closer }
+`,
+  // More implementers than the cap: every unit through the base they all
+  // embed, and heart, declared after them, with a Beat of its own.
+  'fleet/fleet.go': [
+    'package fleet',
+    '',
+    'type Beater interface{ Beat() }',
+    '',
+    'type Base struct{}',
+    '',
+    'func (Base) Beat() {}',
+    '',
+    ...Array.from({ length: FLEET_UNITS }, (_, i) => `type unit${String(i).padStart(2, '0')} struct{ Base }`),
+    '',
+  ].join('\n'),
+  'fleet/heart.go': 'package fleet\n\ntype heart struct{}\n\nfunc (heart) Beat() {}\n',
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-implements-'));
+  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 });
+}, 120_000);
+
+afterAll(() => {
+  cg?.destroy();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const meta = (e: Edge): Record<string, unknown> => (e.metadata ?? {}) as Record<string, unknown>;
+const pkg = (n: Node | null): string => `${path.posix.dirname(n?.filePath ?? '?')}.${n?.name}`;
+
+/** The one non-import node with this name in this file. */
+function one(name: string, file: string): Node {
+  const found = cg.getNodesByName(name).filter((n) => n.filePath === file && n.kind !== 'import');
+  expect(found, `${name} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** Every synthesized struct → interface edge, as `pkg.Struct -> pkg.Interface`. */
+function goImplements(): string[] {
+  const structs = cg.getNodesByKind('struct').filter((n) => n.language === 'go');
+  return cg
+    .getOutgoingEdgesFrom(structs.map((n) => n.id), ['implements'])
+    .filter((e) => meta(e).synthesizedBy === 'go-implements')
+    .map((e) => `${pkg(cg.getNode(e.source))} -> ${pkg(cg.getNode(e.target))}`)
+    .filter((e) => !e.startsWith('fleet.'))
+    .sort();
+}
+
+describe('Go implicit satisfaction counts embedded methods on both sides', () => {
+  it('links exactly the structs whose method set, embeddings included, covers the interface', () => {
+    expect(goImplements()).toEqual([
+      'auth.authReadTx -> auth.AuthReadTx',
+      'auth.authReadTx -> auth.UnsafeAuthReader',
+      'cycles.Client -> cycles.Peer',
+      'cycles.Node -> cycles.Walker',
+      'cycles.Server -> cycles.Peer',
+      'cycles.both -> cycles.Left',
+      'cycles.both -> cycles.Right',
+      'gin.Engine -> gin.IRouter',
+      'gin.Engine -> gin.IRoutes',
+      'gin.RouterGroup -> gin.IRouter',
+      'gin.RouterGroup -> gin.IRoutes',
+      'gin.routeInfo -> gin.Chain',
+      'storage.BaseQuerier -> storage.ChunkQuerier',
+      'storage.BaseQuerier -> storage.LabelQuerier',
+      'tsdb.blockQuerier -> storage.ChunkQuerier',
+      'tsdb.blockQuerier -> storage.LabelQuerier',
+      'tsdb.blockQuerier -> storage.Querier',
+      'tsdb.limitAppender -> storage.Committer',
+    ]);
+  });
+
+  it('asks for an embedded interface\'s methods too, so a lock is no AuthReadTx', () => {
+    const implementers = (name: string, file: string) =>
+      (buildTypeHierarchy(cg, one(name, file))?.descendants ?? []).map((d) => `${d.relation} ${pkg(d.node)}`).sort();
+    expect(implementers('AuthReadTx', 'auth/store.go')).toEqual(['implements auth.authReadTx']);
+    expect(implementers('Querier', 'storage/storage.go')).toEqual(['implements tsdb.blockQuerier']);
+  });
+
+  it('keeps a struct that embeds the interface to its declared edge', () => {
+    const edges = cg
+      .getOutgoingEdgesFrom([one('limitAppender', 'tsdb/querier.go').id], ['implements', 'extends'])
+      .map((e) => `${e.kind} ${pkg(cg.getNode(e.target))}${e.provenance === 'heuristic' ? ' (synthesized)' : ''}`)
+      .sort();
+    expect(edges).toEqual(['implements storage.Appender', 'implements storage.Committer (synthesized)']);
+  });
+
+  it('bridges a call through the interface to an override on the embedding struct', () => {
+    const use = cg
+      .getOutgoingEdgesFrom([one('IRoutes', 'gin/gin.go').id], ['contains'])
+      .map((e) => cg.getNode(e.target))
+      .find((n) => n?.name === 'Use')!;
+    const targets = cg
+      .getOutgoingEdgesFrom([use.id], ['calls'])
+      .filter((e) => meta(e).synthesizedBy === 'interface-impl')
+      .map((e) => cg.getNode(e.target)?.qualifiedName)
+      .sort();
+    // RouterGroup was linked before. Engine satisfies IRoutes only with the
+    // GET that RouterGroup promotes into it.
+    expect(targets).toEqual(['Engine::Use', 'RouterGroup::Use']);
+  });
+
+  it('skips an interface it knows no method of', () => {
+    const into = (name: string, file: string) =>
+      cg.getIncomingEdgesTo([one(name, file).id], ['implements']).filter((e) => meta(e).synthesizedBy === 'go-implements');
+    expect(into('Any', 'empty/empty.go')).toEqual([]);
+    expect(into('Closer', 'empty/empty.go')).toEqual([]);
+  });
+
+  it('caps an interface at 40 implementers, keeping those that declare its methods', () => {
+    const beater = one('Beater', 'fleet/fleet.go');
+    const linked = cg
+      .getIncomingEdgesTo([beater.id], ['implements'])
+      .filter((e) => meta(e).synthesizedBy === 'go-implements')
+      .map((e) => cg.getNode(e.source)!.name);
+    // Base, heart and 45 units satisfy Beater. heart is declared after the
+    // units, but a call through Beater reaches its Beat, not theirs.
+    expect(linked).toHaveLength(40);
+    expect(linked).toEqual(expect.arrayContaining(['Base', 'heart']));
+    expect(linked.filter((n) => n.startsWith('unit'))).toHaveLength(38);
+    const beat = cg
+      .getOutgoingEdgesFrom([beater.id], ['contains'])
+      .map((e) => cg.getNode(e.target))
+      .find((n) => n?.name === 'Beat')!;
+    expect(
+      cg
+        .getOutgoingEdgesFrom([beat.id], ['calls'])
+        .filter((e) => meta(e).synthesizedBy === 'interface-impl')
+        .map((e) => cg.getNode(e.target)!.qualifiedName)
+        .sort()
+    ).toEqual(['Base::Beat', 'heart::Beat']);
+  });
+});
+
+describe('a sync that edits only the embedded type', () => {
+  let dir = '';
+  let graph: CodeGraph | undefined;
+
+  afterEach(() => {
+    graph?.destroy();
+    graph = undefined;
+    if (dir) fs.rmSync(dir, { recursive: true, force: true });
+    dir = '';
+  });
+
+  it('re-derives what the struct embedding it satisfies', async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-implements-sync-'));
+    const write = (rel: string, content: string) => {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    };
+    const base = 'package base\n\ntype Base struct{}\n\nfunc (Base) Close() error { return nil }\n';
+    write('go.mod', 'module example.com/app\n\ngo 1.22\n');
+    write('api/api.go', 'package api\n\ntype NamedCloser interface {\n\tClose() error\n\tName() string\n}\n');
+    write('base/base.go', base);
+    write('wrap/wrap.go', 'package wrap\n\nimport "example.com/app/base"\n\ntype Wrapper struct{ base.Base }\n\nfunc (Wrapper) Name() string { return "" }\n');
+    graph = await CodeGraph.init(dir, { index: true });
+    const g = graph;
+    const linked = () =>
+      g
+        .getOutgoingEdgesFrom(g.getNodesByKind('struct').map((n) => n.id), ['implements'])
+        .filter((e) => meta(e).synthesizedBy === 'go-implements')
+        .map((e) => `${g.getNode(e.source)?.name} -> ${g.getNode(e.target)?.name}`);
+
+    // Close comes from Base, in a file neither Wrapper's nor the interface's.
+    expect(linked()).toEqual(['Wrapper -> NamedCloser']);
+    write('base/base.go', base.replace('Close()', 'Shutdown()'));
+    await g.sync({ paths: ['base/base.go'] });
+    expect(linked()).toEqual([]);
+    write('base/base.go', base);
+    await g.sync({ paths: ['base/base.go'] });
+    expect(linked()).toEqual(['Wrapper -> NamedCloser']);
+  }, 60_000);
+});
diff --git a/__tests__/go-import-package-names.test.ts b/__tests__/go-import-package-names.test.ts
new file mode 100644
index 0000000000..14365910e5
--- /dev/null
+++ b/__tests__/go-import-package-names.test.ts
@@ -0,0 +1,249 @@
+/**
+ * A Go import without a name written before its path is bound to the name of
+ * the package it imports, and the resolver took that to be the path's last
+ * element. For a versioned path it isn't: `go.yaml.in/yaml/v3` and
+ * `gopkg.in/yaml.v3` are package `yaml`, `github.com/mattn/go-sqlite3` is
+ * `sqlite3`. So `yaml.Node`, `klog.V(2)` or `semver.Version` matched none of
+ * the file's imports, and resolved by the bare name to whatever project symbol
+ * shared it: kubernetes' 1,561 `klog.V(…)` calls went to an etcd3 logger
+ * wrapper's `V` method, etcd's `*semver.Version` parameters to client/v3's
+ * `Version` function. An unaliased import now also takes the name goimports
+ * assumes for its path, while keeping the last element:
+ * `k8s.io/api/core/v1` really is package `v1`.
+ *
+ * And a word in a comment is no import name: `"fmt" // for printing` used to
+ * name the next import `printing`.
+ */
+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';
+import { extractImportMappings } from '../src/resolution/import-resolver';
+
+/** The names a Go file's imports are bound to, as `name <- path`. */
+const names = (source: string): string[] =>
+  extractImportMappings('x.go', source, 'go').map((m) => `${m.localName} <- ${m.source}`).sort();
+
+describe('Go import names', () => {
+  it('bind an unaliased versioned or go- import to its package name as well as its last element', () => {
+    expect(names(`package p
+
+import (
+	"go.yaml.in/yaml/v3"
+	"github.com/mattn/go-sqlite3"
+	"k8s.io/api/core/v1"
+	"github.com/gin-gonic/gin"
+	"gopkg.in/natefinch/lumberjack.v2"
+)
+`)).toEqual([
+      'core <- k8s.io/api/core/v1',
+      'gin <- github.com/gin-gonic/gin',
+      'go-sqlite3 <- github.com/mattn/go-sqlite3',
+      'lumberjack <- gopkg.in/natefinch/lumberjack.v2',
+      'lumberjack.v2 <- gopkg.in/natefinch/lumberjack.v2',
+      'sqlite3 <- github.com/mattn/go-sqlite3',
+      'v1 <- k8s.io/api/core/v1',
+      'v3 <- go.yaml.in/yaml/v3',
+      'yaml <- go.yaml.in/yaml/v3',
+    ]);
+    expect(names('package p\n\nimport "gopkg.in/yaml.v3"\n')).toEqual(['yaml <- gopkg.in/yaml.v3', 'yaml.v3 <- gopkg.in/yaml.v3']);
+  });
+
+  it('take no assumed name another import holds, or two imports assume', () => {
+    // `core` is pkg/apis/core's own name, not the one assumed for api/core/v1.
+    expect(names(`package p
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/kubernetes/pkg/apis/core"
+	yaml "sigs.k8s.io/yaml"
+	"go.yaml.in/yaml/v3"
+	"github.com/a/semver/v3"
+	"github.com/b/go-semver"
+)
+`)).toEqual([
+      'core <- k8s.io/kubernetes/pkg/apis/core',
+      'go-semver <- github.com/b/go-semver',
+      'v1 <- k8s.io/api/core/v1',
+      'v3 <- github.com/a/semver/v3',
+      'v3 <- go.yaml.in/yaml/v3',
+      'yaml <- sigs.k8s.io/yaml',
+    ]);
+  });
+
+  it('keep a written name, assume none for a dot import, and read none from a comment', () => {
+    expect(names(`package p
+
+import (
+	"fmt" // for printing
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	_ "embed"
+	. "github.com/onsi/ginkgo/v2"
+
+	// yaml decoding
+	"gopkg.in/yaml.v3"
+	/* the store */ "example.com/app/store"
+)
+
+func run() {}
+`)).toEqual([
+      '_ <- embed',
+      'fmt <- fmt',
+      'metav1 <- k8s.io/apimachinery/pkg/apis/meta/v1',
+      'store <- example.com/app/store',
+      'v2 <- github.com/onsi/ginkgo/v2',
+      'yaml <- gopkg.in/yaml.v3',
+      'yaml.v3 <- gopkg.in/yaml.v3',
+    ]);
+  });
+
+  it('read only the import declarations, wherever a comment or a later string spells one', () => {
+    expect(names(`/*
+Package p is a code generator.
+
+func Example() {}
+*/
+package p
+
+// import "example.com/commented"
+import (
+	"text/template" // (for the body below)
+	"strings"
+)
+
+func run() string {
+	return strings.TrimSpace(\`
+import "example.com/generated"
+\`)
+}
+`)).toEqual(['strings <- strings', 'template <- text/template']);
+  });
+});
+
+describe('Go references through a versioned or go- import', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-import-names-'));
+    const files: Record<string, string> = {
+      'go.mod': 'module example.com/app\n\ngo 1.22\n',
+      // Project symbols named like what yaml, klog, semver and sqlite3 export.
+      'other/other.go': [
+        'package other',
+        '',
+        'type Node struct{}',
+        '',
+        'type Version struct{}',
+        '',
+        'type Error struct{}',
+        '',
+        'func Unmarshal(b []byte, v any) error { return nil }',
+        '',
+        'type klogWrapper struct{}',
+        '',
+        'func (k *klogWrapper) V(level int) bool { return true }',
+        '',
+        'func (k *klogWrapper) Infof(format string, args ...any) {}',
+        '',
+      ].join('\n'),
+      'store/store.go': [
+        'package store',
+        '',
+        'import (',
+        '\t"github.com/Masterminds/semver/v3"',
+        '\t"github.com/mattn/go-sqlite3"',
+        '\t"go.yaml.in/yaml/v3"',
+        '\t"k8s.io/klog/v2"',
+        ')',
+        '',
+        'func Load(b []byte, root *yaml.Node, min *semver.Version) error {',
+        '\tif klog.V(2) {',
+        '\t\tklog.Infof("loading %d bytes", len(b))',
+        '\t}',
+        '\tvar e sqlite3.Error',
+        '\t_ = e',
+        '\treturn yaml.Unmarshal(b, root)',
+        '}',
+        '',
+      ].join('\n'),
+      // A project module whose path ends in a major version: package kit.
+      'kit/go.mod': 'module example.com/kit/v2\n\ngo 1.22\n',
+      'kit/kit.go': [
+        'package kit',
+        '',
+        'type Kit struct{}',
+        '',
+        'func New() *Kit { return &Kit{} }',
+        '',
+      ].join('\n'),
+      'decoy/decoy.go': [
+        'package decoy',
+        '',
+        'type Kit struct{}',
+        '',
+        'func New() *Kit { return &Kit{} }',
+        '',
+        'func Find(id string) string { return id }',
+        '',
+      ].join('\n'),
+      // k8s.io/api/core/v1 is package v1, beside a package named core.
+      'api/core/v1/types.go': 'package v1\n\ntype Pod struct{}\n',
+      'pkg/apis/core/types.go': 'package core\n\ntype Pod struct{}\n',
+      'repo/repo.go': 'package repo\n\nfunc Find(id string) string { return id }\n',
+      'app/app.go': [
+        'package app',
+        '',
+        'import (',
+        '\t"fmt" // for printing',
+        '\t"example.com/app/repo"',
+        '\t"example.com/app/api/core/v1"',
+        '\t"example.com/app/pkg/apis/core"',
+        '\t"example.com/kit/v2"',
+        ')',
+        '',
+        'func Run(p *v1.Pod, q *core.Pod) *kit.Kit {',
+        '\tfmt.Println(repo.Find("x"))',
+        '\treturn kit.New()',
+        '}',
+        '',
+      ].join('\n'),
+    };
+    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 });
+  }, 60_000);
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const targetsFrom = (file: string) => {
+    const ids = cg.getNodesInFile(file).map((n) => n.id);
+    return cg.getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind !== 'contains')
+      .map((e) => {
+        const t = cg.getNode(e.target)!;
+        return `${e.kind} ${t.qualifiedName}@${t.filePath}`;
+      })
+      .sort();
+  };
+
+  it('never reach a project symbol that only shares the name', () => {
+    expect(targetsFrom('store/store.go').filter((t) => t.includes('@other/'))).toEqual([]);
+  });
+
+  it('reach the project package the import names', () => {
+    expect(targetsFrom('app/app.go')).toEqual([
+      'calls Find@repo/repo.go',
+      'calls New@kit/kit.go',
+      'references Kit@kit/kit.go',
+      'references Pod@api/core/v1/types.go',
+      'references Pod@pkg/apis/core/types.go',
+    ]);
+  });
+});
diff --git a/__tests__/go-interface-embedding.test.ts b/__tests__/go-interface-embedding.test.ts
new file mode 100644
index 0000000000..2883c6f50b
--- /dev/null
+++ b/__tests__/go-interface-embedding.test.ts
@@ -0,0 +1,440 @@
+/**
+ * Go interface embedding produced no supertype edge in either extractor:
+ *
+ *   type IRouter interface {     // gin-gonic/gin: IRouter never reached IRoutes
+ *     IRoutes
+ *     Group(string, ...HandlerFunc) *RouterGroup
+ *   }
+ *
+ * extractInheritance looked for a `constraint_elem`, a node type that neither
+ * the vendored tree-sitter-go wasm nor the kernel's grammar crate has. Both
+ * parse an embedded interface as a `type_elem` holding one type: a
+ * `type_identifier` for `IRoutes`, a `qualified_type` for `io.Closer`. A
+ * `type_elem` is also how a type-set constraint is written (`~int | ~string`,
+ * `float32 | float64`, a lone `int64`), and a constraint is no supertype.
+ *
+ * An embedded type is now read the same way in an interface and in a struct:
+ * `T`, `*T`, `pkg.T` and `T[X]` all embed `T`, recorded at the name itself so
+ * resolution reads the package back from the source. `storage.LabelQuerier`
+ * reaches that package's interface; `io.Closer` and `sync.Mutex` stay
+ * unresolved rather than landing on a project type that shares the name.
+ * Go's predeclared types are never recorded: `int64` is a constraint's term,
+ * and `error`, `any` and `comparable` exist in no graph. Runs against the
+ * native kernel (when built) and the wasm extractor, which must agree.
+ *
+ * Resolution keeps an embedded type in its package. A bare name is its own
+ * package's type, not another package's struct of that name, which the Go
+ * framework heuristics preferred (promql/parser's `Node` interface, etcd's
+ * `Lease`). A package that is none of the file's imports as indexed
+ * (`clientv3` under an unaliased `go.etcd.io/etcd/client/v3`, which goimports
+ * would call `client`) leaves the type unresolved.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import { buildTypeHierarchy } from '../src/graph/type-hierarchy';
+import type { ExtractionResult, Node } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** Embedded interfaces of every shape, beside constraints that embed nothing. */
+const INTERFACE_SOURCE = `package store
+
+import (
+	"io"
+
+	"example.com/app/storage"
+)
+
+type Queryable interface{ Q() }
+
+type Querier interface {
+	Queryable
+	io.Closer
+	storage.LabelQuerier // a project package's interface
+	Select(sorted bool) int
+}
+
+type Lister[T any] interface{ List() []T }
+
+type Pager interface {
+	Lister[int]
+	Page() int
+}
+
+type Timeout interface {
+	error
+	Timeout() bool
+}
+
+type Number interface {
+	~int | ~float64
+}
+
+type Float interface{ float32 | float64 }
+
+type Exact interface{ int64 }
+
+type Text interface{ ~string }
+
+type Ordered interface {
+	Number | Float | ~string
+}
+`;
+
+/** gin-gonic/gin's router interfaces. */
+const GIN_SOURCE = `package gin
+
+type HandlerFunc func(*Context)
+
+type IRoutes interface {
+	Use(...HandlerFunc) IRoutes
+	Handle(string, string, ...HandlerFunc) IRoutes
+}
+
+type IRouter interface {
+	IRoutes
+	Group(string, ...HandlerFunc) *RouterGroup
+}
+`;
+
+/** Struct embedding takes the same shapes, and keeps its named fields out. */
+const STRUCT_SOURCE = `package store
+
+import (
+	"sync"
+
+	"example.com/app/storage"
+)
+
+type Store struct {
+	*Engine
+	Reader
+	sync.Mutex
+	*storage.Base
+	List[int]
+	error
+	name   string
+	engine *Engine
+	items  []storage.Base
+}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+/** `<source> <kind> <name>` for every extends/implements ref, sorted. */
+function supertypeRefs(result: ExtractionResult): string[] {
+  const byId = new Map(result.nodes.map((n) => [n.id, n]));
+  return result.unresolvedReferences
+    .filter((r) => r.referenceKind === 'extends' || r.referenceKind === 'implements')
+    .map((r) => `${byId.get(r.fromNodeId)?.name ?? r.fromNodeId} ${r.referenceKind} ${r.referenceName}`)
+    .sort();
+}
+
+describe('Go embedded types are supertypes', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['go']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', file: string, source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource(file, source, 'go');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract(file, source, 'go');
+    expect(result, `kernel extraction of ${file}`).not.toBeNull();
+    return result!;
+  }
+
+  /** Every supertype ref sits on its name, where resolution reads a package qualifier back. */
+  function expectRefsOnTheirNames(result: ExtractionResult, source: string): void {
+    const lines = source.split(/\r?\n/);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'extends');
+    expect(refs.length).toBeGreaterThan(0);
+    for (const r of refs) {
+      expect(lines[r.line - 1]!.startsWith(r.referenceName, r.column), `${r.referenceName} at ${r.line}:${r.column}`).toBe(true);
+    }
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const eol = (s: string) => (crlf ? s.replace(/\n/g, '\r\n') : s);
+    const label = crlf ? ' (CRLF)' : '';
+
+    it.each(backends)(`an embedded interface extends; a constraint does not: %s${label}`, (backend) => {
+      const source = eol(INTERFACE_SOURCE);
+      const result = extract(backend, 'store/querier.go', source);
+      expect(result.nodes.filter((n) => n.kind === 'interface').map((n) => n.name).sort()).toEqual(
+        ['Exact', 'Float', 'Lister', 'Number', 'Ordered', 'Pager', 'Querier', 'Queryable', 'Text', 'Timeout']
+      );
+      expect(supertypeRefs(result)).toEqual([
+        'Pager extends Lister',
+        'Querier extends Closer',
+        'Querier extends LabelQuerier',
+        'Querier extends Queryable',
+      ]);
+      expectRefsOnTheirNames(result, source);
+      // The interfaces' own methods are still its members, the embeddings are not.
+      const querier = result.nodes.find((n) => n.name === 'Querier')!;
+      const members = result.edges
+        .filter((e) => e.kind === 'contains' && e.source === querier.id)
+        .map((e) => result.nodes.find((n) => n.id === e.target)?.name);
+      expect(members).toEqual(['Select']);
+    });
+
+    it.each(backends)(`gin's IRouter extends IRoutes: %s${label}`, (backend) => {
+      const result = extract(backend, 'routergroup.go', eol(GIN_SOURCE));
+      expect(supertypeRefs(result)).toEqual(['IRouter extends IRoutes']);
+    });
+
+    it.each(backends)(`an embedded struct field of any shape extends: %s${label}`, (backend) => {
+      const source = eol(STRUCT_SOURCE);
+      const result = extract(backend, 'store/store.go', source);
+      expect(supertypeRefs(result)).toEqual([
+        'Store extends Base',
+        'Store extends Engine',
+        'Store extends List',
+        'Store extends Mutex',
+        'Store extends Reader',
+      ]);
+      expectRefsOnTheirNames(result, source);
+    });
+  }
+});
+
+describe('the type hierarchy of an indexed Go module', () => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    cg?.destroy();
+    cg = undefined;
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+    root = '';
+  });
+
+  it('links embedded interfaces and structs to the package that declares them', async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-embedding-'));
+    const files: Record<string, string> = {
+      'go.mod': 'module example.com/app\n\ngo 1.22\n',
+      'storage/storage.go': [
+        'package storage',
+        '',
+        'type LabelQuerier interface {',
+        '\tLabelValues(name string) []string',
+        '}',
+        '',
+        'type Base struct{}',
+        '',
+        'func (b *Base) Close() error { return nil }',
+        '',
+      ].join('\n'),
+      // Named like io.Closer, io.Reader, sync.Mutex, yaml.Node and clientv3.KV: never what those name.
+      'other/other.go': [
+        'package other',
+        '',
+        'type Closer interface{ Close() error }',
+        '',
+        'type Mutex struct{}',
+        '',
+        'type Reader interface{ Read(p []byte) (int, error) }',
+        '',
+        'type Node struct{}',
+        '',
+        'type KV interface{ Get(key string) string }',
+        '',
+      ].join('\n'),
+      'store/store.go': [
+        'package store',
+        '',
+        'import (',
+        '\t"io"',
+        '\t"sync"',
+        '',
+        '\t"example.com/app/storage"',
+        '\t"go.etcd.io/etcd/client/v3"',
+        '\t"go.yaml.in/yaml/v3"',
+        ')',
+        '',
+        '// The package is yaml, though its import path ends in v3.',
+        'type RuleGroupNode struct {',
+        '\tyaml.Node',
+        '\tName string',
+        '}',
+        '',
+        '// The package is clientv3: not v3, nor the client goimports would assume.',
+        'type kvPrefix struct {',
+        '\tclientv3.KV',
+        '}',
+        '',
+        'type Queryable interface{ Q() }',
+        '',
+        'type Querier interface {',
+        '\tQueryable',
+        '\tio.Closer',
+        '\tstorage.LabelQuerier',
+        '\tSelect(sorted bool) int',
+        '}',
+        '',
+        'type Number interface {',
+        '\t~int | ~float64',
+        '}',
+        '',
+        'type Engine struct{}',
+        '',
+        'type Reader interface{ Read() }',
+        '',
+        'type List[T any] struct{ items []T }',
+        '',
+        'type Store struct {',
+        '\t*Engine',
+        '\tReader',
+        '\tsync.Mutex',
+        '\t*storage.Base',
+        '\tList[int]',
+        '}',
+        '',
+      ].join('\n'),
+      // Named like the io.Reader it embeds.
+      'wrap/wrap.go': [
+        'package wrap',
+        '',
+        'import "io"',
+        '',
+        'type Reader interface {',
+        '\tio.Reader',
+        '\tPeek() byte',
+        '}',
+        '',
+      ].join('\n'),
+      'gin/routergroup.go': GIN_SOURCE,
+      // prometheus's promql/parser: its own `Node` interface, while other/ has a `Node` struct.
+      'parser/ast.go': [
+        'package parser',
+        '',
+        'type Node interface{ String() string }',
+        '',
+        'type Expr interface {',
+        '\tNode',
+        '\tType() string',
+        '}',
+        '',
+        'type exprWrapper struct {',
+        '\tNode',
+        '}',
+        '',
+      ].join('\n'),
+    };
+    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 });
+    const graph = cg;
+
+    const one = (name: string, file: string): Node => {
+      const found = graph.getNodesByName(name).filter((n) => n.filePath === file && n.kind !== 'import');
+      expect(found, `${name} in ${file}`).toHaveLength(1);
+      return found[0]!;
+    };
+    const where = (n: Node | null) => `${n?.name}@${n?.filePath}`;
+
+    const sources = [
+      one('Querier', 'store/store.go'),
+      one('Number', 'store/store.go'),
+      one('Store', 'store/store.go'),
+      one('RuleGroupNode', 'store/store.go'),
+      one('kvPrefix', 'store/store.go'),
+      one('Reader', 'wrap/wrap.go'),
+      one('IRouter', 'gin/routergroup.go'),
+      one('Expr', 'parser/ast.go'),
+      one('exprWrapper', 'parser/ast.go'),
+    ];
+    // Declared edges only: Store also satisfies other.Closer with the Close
+    // that storage.Base promotes, which go-implements synthesizes from names.
+    const supertypes = graph
+      .getOutgoingEdgesFrom(sources.map((n) => n.id), ['extends', 'implements'])
+      .filter((e) => e.provenance !== 'heuristic')
+      .map((e) => `${graph.getNode(e.source)?.name} ${e.kind} ${where(graph.getNode(e.target))}`)
+      .sort();
+    // An embedded interface of a struct resolves as `implements`; one of an
+    // interface stays `extends`. io.Closer, sync.Mutex, io.Reader and yaml.Node
+    // are outside the project, and clientv3 is no import the index knows, so
+    // nothing named like them is linked. A bare name is its own package's
+    // type, whatever kind another package's is.
+    expect(supertypes).toEqual([
+      'Expr extends Node@parser/ast.go',
+      'IRouter extends IRoutes@gin/routergroup.go',
+      'Querier extends LabelQuerier@storage/storage.go',
+      'Querier extends Queryable@store/store.go',
+      'Store extends Base@storage/storage.go',
+      'Store extends Engine@store/store.go',
+      'Store extends List@store/store.go',
+      'Store implements Reader@store/store.go',
+      'exprWrapper implements Node@parser/ast.go',
+    ]);
+
+    // The outside supertypes are kept as unresolved references, not dropped.
+    const unresolved = (n: Node) =>
+      graph
+        .getUnresolvedReferencesFrom(n.id)
+        .filter((r) => r.referenceKind === 'extends')
+        .map((r) => r.referenceName)
+        .sort();
+    expect(unresolved(one('Querier', 'store/store.go'))).toEqual(['Closer']);
+    expect(unresolved(one('Store', 'store/store.go'))).toEqual(['Mutex']);
+    expect(unresolved(one('RuleGroupNode', 'store/store.go'))).toEqual(['Node']);
+    expect(unresolved(one('kvPrefix', 'store/store.go'))).toEqual(['KV']);
+    expect(unresolved(one('Reader', 'wrap/wrap.go'))).toEqual(['Reader']);
+
+    // What the viewer's Type hierarchy and codegraph_explore read. Declared
+    // subtypes only: Go's implicit-satisfaction edges are synthesized from
+    // method names (Base's Close() satisfies other.Closer) and drawn apart.
+    const subtypes = (n: Node) =>
+      (buildTypeHierarchy(graph, n)?.descendants ?? [])
+        .filter((d) => !d.synthesized)
+        .map((d) => `${d.relation} ${where(d.node)}`);
+    expect(subtypes(one('IRoutes', 'gin/routergroup.go'))).toEqual(['extends IRouter@gin/routergroup.go']);
+    expect(subtypes(one('LabelQuerier', 'storage/storage.go'))).toEqual(['extends Querier@store/store.go']);
+    expect(subtypes(one('Base', 'storage/storage.go'))).toEqual(['extends Store@store/store.go']);
+    const declaredInto = graph
+      .getIncomingEdgesTo(['Closer', 'Mutex', 'Reader', 'Node', 'KV'].map((name) => one(name, 'other/other.go').id), ['extends', 'implements'])
+      .filter((e) => e.provenance !== 'heuristic');
+    expect(declaredInto).toEqual([]);
+    expect(
+      (buildTypeHierarchy(graph, one('IRouter', 'gin/routergroup.go'))?.ancestors ?? []).map((a) => `${a.relation} ${where(a.node)}`)
+    ).toEqual(['extends IRoutes@gin/routergroup.go']);
+  }, 60_000);
+});
diff --git a/__tests__/go-nested-module.test.ts b/__tests__/go-nested-module.test.ts
new file mode 100644
index 0000000000..20c4b90f42
--- /dev/null
+++ b/__tests__/go-nested-module.test.ts
@@ -0,0 +1,331 @@
+/**
+ * Go modules whose `go.mod` is not at the project root (#2322).
+ *
+ * A Go backend kept next to a frontend (`server/go.mod`, `web/package.json`),
+ * or several modules side by side — etcd's root module beside `server/go.mod`
+ * and `client/v3/go.mod`: each module's import paths start with its own
+ * module path, and name a directory under that module's root. Only the
+ * project-root `go.mod` used to be read, so with the module in `svc/` both
+ * `store.New()` and `s.db.CreateItem()` lost their callers. An import path
+ * belongs to the module declaring the longest prefix of it, and a name
+ * written through a package is that package's — never a same-named symbol of
+ * another package. A root-level `go.mod` resolves exactly as before.
+ */
+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';
+
+const STORE = `package store
+
+type Manager struct{}
+
+func New() *Manager { return &Manager{} }
+
+func (m *Manager) CreateItem(name string) error { return nil }
+`;
+
+const CLOCK = `package clock
+
+func Now() int { return 0 }
+`;
+
+// The issue's service, plus a call into a package outside `internal/`.
+const service = (mod: string) => `package domain
+
+import (
+	"${mod}/internal/store"
+	"${mod}/pkg/clock"
+)
+
+type Service struct {
+	db *store.Manager
+}
+
+func NewService() *Service {
+	return &Service{db: store.New()}
+}
+
+func (s *Service) AddItem(name string) error {
+	return s.db.CreateItem(name)
+}
+
+func Stamp() int {
+	return clock.Now()
+}
+`;
+
+const projects: Array<{ root: string; cg: CodeGraph }> = [];
+
+async function indexProject(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-nested-mod-'));
+  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);
+  }
+  const cg = await CodeGraph.init(root, { index: true });
+  projects.push({ root, cg });
+  return cg;
+}
+
+afterAll(() => {
+  for (const { root, cg } of projects) {
+    cg.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+/** `file::qualifiedName` of every `kind` target of the symbol `name` in `file`. */
+function targets(cg: CodeGraph, file: string, name: string, kind = 'calls'): string[] {
+  const fn = cg.getNodesInFile(file).find((n) => n.name === name);
+  expect(fn, `${name} in ${file}`).toBeDefined();
+  return cg
+    .getOutgoingEdges(fn!.id)
+    .filter((e) => e.kind === kind)
+    .map((e) => cg.getNode(e.target)!)
+    .map((n) => `${n.filePath.replace(/\\/g, '/')}::${n.qualifiedName}`)
+    .sort();
+}
+
+describe('Go module in a subdirectory (#2322)', () => {
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    cg = await indexProject({
+      'svc/go.mod': 'module example.com/app/svc\n\ngo 1.22\n',
+      'svc/internal/store/store.go': STORE,
+      'svc/pkg/clock/clock.go': CLOCK,
+      'svc/internal/domain/service.go': service('example.com/app/svc'),
+      'web/package.json': '{ "name": "web" }\n',
+    });
+  });
+
+  it('resolves a package-qualified call into the module', () => {
+    expect(targets(cg, 'svc/internal/domain/service.go', 'NewService')).toEqual([
+      'svc/internal/store/store.go::New',
+    ]);
+    expect(targets(cg, 'svc/internal/domain/service.go', 'Stamp')).toEqual([
+      'svc/pkg/clock/clock.go::Now',
+    ]);
+  });
+
+  it('resolves a call through a struct field typed with a package of the module', () => {
+    expect(targets(cg, 'svc/internal/domain/service.go', 'AddItem')).toEqual([
+      'svc/internal/store/store.go::Manager::CreateItem',
+    ]);
+  });
+});
+
+describe('Go modules side by side (#2322)', () => {
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    cg = await indexProject({
+      // etcd's shape: a root module, and a sibling whose path is not under it.
+      'go.mod': 'module example.com/etcd/v3\n\ngo 1.22\n',
+      'etcdutl/main.go': `package main
+
+import "example.com/etcd/server/v3/storage/wal"
+
+func main() {
+	wal.OpenForRead("dir")
+}
+`,
+      'server/go.mod': 'module example.com/etcd/server/v3\n\ngo 1.22\n',
+      'server/storage/wal/wal.go': 'package wal\n\nfunc OpenForRead(dir string) error { return nil }\n',
+      'server/api/api.go': 'package api\n\nfunc Start() int { return 1 }\n',
+      'server/cmd/main.go': `package main
+
+import (
+	"example.com/etcd/server/v3/api"
+	"example.com/tools/lint"
+)
+
+type App struct {
+	linter *lint.Linter
+}
+
+func main() {
+	api.Start()
+	lint.Run()
+}
+
+func (a *App) check() {
+	a.linter.Check()
+}
+`,
+      'server/cmd/ext.go': `package main
+
+import (
+	"example.com/toolsx/api"
+)
+
+func external() {
+	api.Start()
+}
+`,
+      'tools/go.mod': 'module example.com/tools\n\ngo 1.22\n',
+      'tools/api/api.go': 'package api\n\nfunc Start() int { return 2 }\n',
+      'tools/lint/lint.go': `package lint
+
+type Linter struct{}
+
+func Run() {}
+
+func (l *Linter) Check() {}
+`,
+      'tools/gen/gen.go': `package main
+
+import "example.com/tools/api"
+
+func generate() {
+	api.Start()
+}
+`,
+    });
+  });
+
+  it('resolves an import of a sibling module whose path is not under the root module', () => {
+    expect(targets(cg, 'etcdutl/main.go', 'main')).toEqual(['server/storage/wal/wal.go::OpenForRead']);
+  });
+
+  it("resolves each module's import into that module's own package", () => {
+    expect(targets(cg, 'tools/gen/gen.go', 'generate')).toEqual(['tools/api/api.go::Start']);
+    expect(targets(cg, 'server/cmd/main.go', 'main')).toEqual([
+      'server/api/api.go::Start',
+      'tools/lint/lint.go::Run',
+    ]);
+  });
+
+  it("follows a struct field typed with the other module's package", () => {
+    expect(targets(cg, 'server/cmd/main.go', 'check')).toEqual(['tools/lint/lint.go::Linter::Check']);
+  });
+
+  it('leaves an import that only shares a prefix with a module path unresolved', () => {
+    expect(targets(cg, 'server/cmd/ext.go', 'external')).toEqual([]);
+  });
+});
+
+describe('Names written through a package of a nested module (#2322)', () => {
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    cg = await indexProject({
+      'src/go.mod': 'module example.com/harbor/src\n\ngo 1.22\n',
+      'src/jobservice/job/op.go': 'package job\n\ntype OPCommand string\n',
+      // A result type spelled like the method that returns it.
+      'src/jobservice/impl/context.go': `package impl
+
+import "example.com/harbor/src/jobservice/job"
+
+type Context struct{}
+
+func (c *Context) OPCommand() (job.OPCommand, bool) {
+	return "", false
+}
+`,
+      'src/pkg/artifact/manager.go': `package artifact
+
+type Manager interface {
+	Count() int64
+}
+`,
+      // A caching wrapper delegating to the same-named type of another package.
+      'src/pkg/cached/redis/manager.go': `package redis
+
+import "example.com/harbor/src/pkg/artifact"
+
+type Manager struct {
+	delegator artifact.Manager
+}
+
+func (m *Manager) Count() int64 {
+	return m.delegator.Count()
+}
+`,
+      // A test fixture claiming the real module's path. The go tool ignores
+      // testdata, so it never answers another module's import of that path.
+      'internal/testdata/stub/go.mod': 'module example.com/harbor/src\n\ngo 1.22\n',
+      'internal/testdata/stub/pkg/artifact/manager.go': `package artifact
+
+type Manager interface {
+	Count() int64
+}
+`,
+      'tools/go.mod': 'module example.com/harbor/tools\n\ngo 1.22\n',
+      'tools/report/report.go': `package report
+
+import "example.com/harbor/src/pkg/artifact"
+
+type Reporter struct {
+	mgr artifact.Manager
+}
+
+func (r *Reporter) Total() int64 {
+	return r.mgr.Count()
+}
+`,
+    });
+  });
+
+  it('a type reference lands on the named package’s type, not a same-named method', () => {
+    expect(targets(cg, 'src/jobservice/impl/context.go', 'OPCommand', 'references')).toEqual([
+      'src/jobservice/job/op.go::OPCommand',
+    ]);
+  });
+
+  it('a field typed with another package’s same-named type reaches that type, not the caller itself', () => {
+    expect(targets(cg, 'src/pkg/cached/redis/manager.go', 'Count')).toEqual([
+      'src/pkg/artifact/manager.go::Manager::Count',
+    ]);
+  });
+
+  it('a module under testdata never answers for the module it imitates', () => {
+    expect(targets(cg, 'tools/report/report.go', 'Total')).toEqual([
+      'src/pkg/artifact/manager.go::Manager::Count',
+    ]);
+  });
+});
+
+describe('Two Go modules declaring the same path (#2322)', () => {
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    const files: Record<string, string> = {};
+    for (const copy of ['v1', 'v2']) {
+      files[`${copy}/go.mod`] = 'module example.com/app/svc\n\ngo 1.22\n';
+      files[`${copy}/internal/store/store.go`] = STORE;
+      files[`${copy}/pkg/clock/clock.go`] = CLOCK;
+      files[`${copy}/internal/domain/service.go`] = service('example.com/app/svc');
+    }
+    cg = await indexProject(files);
+  });
+
+  it("resolves each copy's imports into its own module", () => {
+    for (const copy of ['v1', 'v2']) {
+      expect(targets(cg, `${copy}/internal/domain/service.go`, 'NewService')).toEqual([
+        `${copy}/internal/store/store.go::New`,
+      ]);
+      expect(targets(cg, `${copy}/internal/domain/service.go`, 'Stamp')).toEqual([
+        `${copy}/pkg/clock/clock.go::Now`,
+      ]);
+    }
+  });
+});
+
+describe('Go module at the project root', () => {
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    cg = await indexProject({
+      'go.mod': 'module example.com/app/svc\n\ngo 1.22\n',
+      'internal/store/store.go': STORE,
+      'pkg/clock/clock.go': CLOCK,
+      'internal/domain/service.go': service('example.com/app/svc'),
+    });
+  });
+
+  it('resolves exactly as before', () => {
+    expect(targets(cg, 'internal/domain/service.go', 'NewService')).toEqual(['internal/store/store.go::New']);
+    expect(targets(cg, 'internal/domain/service.go', 'Stamp')).toEqual(['pkg/clock/clock.go::Now']);
+    expect(targets(cg, 'internal/domain/service.go', 'AddItem')).toEqual([
+      'internal/store/store.go::Manager::CreateItem',
+    ]);
+  });
+});
diff --git a/__tests__/go-promoted-dispatch.test.ts b/__tests__/go-promoted-dispatch.test.ts
new file mode 100644
index 0000000000..76b5d6243f
--- /dev/null
+++ b/__tests__/go-promoted-dispatch.test.ts
@@ -0,0 +1,379 @@
+/**
+ * A Go struct can satisfy an interface with methods it gets by embedding:
+ *
+ *   type blockBaseSeriesSet struct{ … }      // prometheus's tsdb/querier.go
+ *   func (b *blockBaseSeriesSet) Next() bool  // Next, Err, Warnings — no At
+ *
+ *   type blockSeriesSet struct{ blockBaseSeriesSet }
+ *   func (b *blockSeriesSet) At() storage.Series
+ *
+ * go-implements links blockSeriesSet to storage.SeriesSet, and a call through
+ * `SeriesSet.Next` then runs blockBaseSeriesSet's Next. The interface-dispatch
+ * bridge linked an interface's methods only to the methods the implementing
+ * struct declares, so that call reached nothing: blockBaseSeriesSet has no At
+ * and implements nothing itself. The bridge now follows the embedding to the
+ * method Go's selector picks — the shallowest one, none when two tie — and
+ * stops at an embedded interface, whose method is a dynamic call again.
+ */
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { ToolHandler } from '../src/mcp/tools';
+import type { Edge, Node } from '../src/types';
+
+const BIG_METHODS = 45;
+const big = (i: number) => `M${String(i).padStart(2, '0')}`;
+
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  'storage/interface.go': `package storage
+
+type Series interface{ Labels() string }
+
+type ChunkSeries interface{ Labels() string }
+
+type SeriesSet interface {
+	Next() bool
+	At() Series
+	Err() error
+	Warnings() []string
+}
+
+type ChunkSeriesSet interface {
+	Next() bool
+	At() ChunkSeries
+	Err() error
+	Warnings() []string
+}
+`,
+  'tsdb/querier.go': `package tsdb
+
+import "example.com/app/storage"
+
+// Next, Err and Warnings for the two series sets below. No At: it is
+// neither series set itself.
+type blockBaseSeriesSet struct {
+	err error
+}
+
+func (b *blockBaseSeriesSet) Next() bool         { return false }
+func (b *blockBaseSeriesSet) Err() error         { return b.err }
+func (b *blockBaseSeriesSet) Warnings() []string { return nil }
+
+type blockSeriesSet struct {
+	blockBaseSeriesSet
+}
+
+func (b *blockSeriesSet) At() storage.Series { return nil }
+
+type blockChunkSeriesSet struct {
+	blockBaseSeriesSet
+}
+
+func (b *blockChunkSeriesSet) At() storage.ChunkSeries { return nil }
+
+func newBlockSeriesSet() storage.SeriesSet { return &blockSeriesSet{} }
+`,
+  'promql/engine.go': `package promql
+
+import "example.com/app/storage"
+
+func expandSeriesSet(it storage.SeriesSet) int {
+	n := 0
+	for it.Next() {
+		n++
+	}
+	return n
+}
+`,
+  'selector/selector.go': `package selector
+
+type Doer interface {
+	Do()
+	Name() string
+}
+
+type Runner interface{ Do() }
+
+// Do from two levels down.
+type inner struct{}
+
+func (inner) Do() {}
+
+type middle struct{ inner }
+
+type deep struct {
+	middle
+}
+
+func (deep) Name() string { return "" }
+
+// near's Do at depth 1 hides far's at depth 2.
+type near struct{}
+
+func (near) Do() {}
+
+type far struct{}
+
+func (far) Do() {}
+
+type farWrap struct{ far }
+
+type shadowed struct {
+	farWrap
+	near
+}
+
+func (shadowed) Name() string { return "" }
+
+// Two Dos at depth 1: Go rejects t.Do(), no method runs.
+type left struct{}
+
+func (left) Do() {}
+
+type right struct{}
+
+func (right) Do() {}
+
+type tie struct {
+	left
+	right
+}
+
+func (tie) Name() string { return "" }
+
+// One type's Do at depth 2 along two paths: as ambiguous.
+type core struct{}
+
+func (core) Do() {}
+
+type viaA struct{ core }
+
+type viaB struct{ core }
+
+type diamond struct {
+	viaA
+	viaB
+}
+
+func (diamond) Name() string { return "" }
+
+// Do from the interface it embeds: whatever that holds runs.
+type delegate struct{ Runner }
+
+func (delegate) Name() string { return "" }
+
+// The embedded interface's Do at depth 1 hides buried's at depth 2.
+type buried struct{}
+
+func (buried) Do() {}
+
+type cover struct{ buried }
+
+type hidden struct {
+	cover
+	Runner
+}
+
+func (hidden) Name() string { return "" }
+
+// Do from the defined type it embeds.
+type Chain []func()
+
+func (c Chain) Do() {}
+
+type chained struct{ Chain }
+
+func (chained) Name() string { return "" }
+
+// full is a Doer itself: its own edge, whoever embeds it.
+type fullWrap struct{ full }
+
+type full struct{}
+
+func (full) Do()          {}
+func (full) Name() string { return "" }
+`,
+  // More of the interface than the cap: one method of its own, the rest from
+  // a base that lacks the last.
+  'big/big.go': [
+    'package big',
+    '',
+    'type Big interface {',
+    ...Array.from({ length: BIG_METHODS }, (_, i) => `\t${big(i)}()`),
+    '}',
+    '',
+    'type bigBase struct{}',
+    '',
+    ...Array.from({ length: BIG_METHODS - 1 }, (_, i) => `func (bigBase) ${big(i)}() {}`),
+    '',
+    'type bigOne struct{ bigBase }',
+    '',
+    `func (bigOne) ${big(BIG_METHODS - 1)}() {}`,
+    '',
+  ].join('\n'),
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-promoted-'));
+  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 });
+}, 120_000);
+
+afterAll(() => {
+  cg?.destroy();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const meta = (e: Edge): Record<string, unknown> => (e.metadata ?? {}) as Record<string, unknown>;
+
+/** `file:line` of the first fixture line containing `text`. */
+function at(file: string, text: string): string {
+  const line = FILES[file]!.split('\n').findIndex((l) => l.includes(text));
+  expect(line, `${text} in ${file}`).toBeGreaterThanOrEqual(0);
+  return `${file}:${line + 1}`;
+}
+
+/** The one non-import node with this name in this file. */
+function one(name: string, file: string): Node {
+  const found = cg.getNodesByName(name).filter((n) => n.filePath === file && n.kind !== 'import');
+  expect(found, `${name} in ${file}`).toHaveLength(1);
+  return found[0]!;
+}
+
+/** An interface's method. */
+function methodOf(graph: CodeGraph, iface: Node, name: string): Node {
+  const m = graph
+    .getOutgoingEdgesFrom([iface.id], ['contains'])
+    .map((e) => graph.getNode(e.target))
+    .find((n) => n?.name === name);
+  expect(m, `${iface.name}.${name}`).toBeTruthy();
+  return m!;
+}
+
+/** Where a call through the method dispatches, as `Target::m` or `Target::m <- promotedInto @registeredAt`. */
+function dispatch(graph: CodeGraph, method: Node): string[] {
+  return graph
+    .getOutgoingEdgesFrom([method.id], ['calls'])
+    .filter((e) => meta(e).synthesizedBy === 'interface-impl')
+    .map((e) => {
+      const target = graph.getNode(e.target)?.qualifiedName;
+      const into = meta(e).promotedInto;
+      return into === undefined ? `${target}` : `${target} <- ${into} @${meta(e).registeredAt}`;
+    })
+    .sort();
+}
+
+describe('a call through a Go interface reaches the method embedding promotes', () => {
+  it('links the interface method to the embedded type that declares it', () => {
+    const seriesSet = one('SeriesSet', 'storage/interface.go');
+    const chunkSet = one('ChunkSeriesSet', 'storage/interface.go');
+    // blockSeriesSet's embedding, the first of the two.
+    const embedding = at('tsdb/querier.go', '\tblockBaseSeriesSet');
+    // Both structs satisfy both interfaces by name, and both get Next from
+    // the same base: one edge, through the first of them.
+    for (const iface of [seriesSet, chunkSet]) {
+      expect(dispatch(cg, methodOf(cg, iface, 'Next'))).toEqual([`blockBaseSeriesSet::Next <- blockSeriesSet @${embedding}`]);
+      expect(dispatch(cg, methodOf(cg, iface, 'Err'))).toEqual([`blockBaseSeriesSet::Err <- blockSeriesSet @${embedding}`]);
+      expect(dispatch(cg, methodOf(cg, iface, 'At'))).toEqual(['blockChunkSeriesSet::At', 'blockSeriesSet::At']);
+    }
+  });
+
+  it('picks the provider the way Go\'s selector does', () => {
+    const doer = one('Doer', 'selector/selector.go');
+    const file = 'selector/selector.go';
+    expect(dispatch(cg, methodOf(cg, doer, 'Do'))).toEqual(
+      [
+        // The defined type's method.
+        `Chain::Do <- chained @${at(file, 'type chained struct')}`,
+        // full's own edge, though fullWrap comes first.
+        'full::Do',
+        // Two levels down, through deep's own embedding of middle.
+        `inner::Do <- deep @${at(file, '\tmiddle')}`,
+        // near at depth 1, not far at depth 2.
+        `near::Do <- shadowed @${at(file, '\tnear')}`,
+      ].sort()
+    );
+    // Not linked: left and right (tie), core (two paths), the Runner that
+    // delegate and hidden embed, and buried behind it.
+  });
+
+  it('keeps the provider\'s own edge as it was', () => {
+    const doer = one('Doer', 'selector/selector.go');
+    const doEdge = cg
+      .getOutgoingEdgesFrom([methodOf(cg, doer, 'Do').id], ['calls'])
+      .find((e) => cg.getNode(e.target)?.qualifiedName === 'full::Do');
+    expect(doEdge).toMatchObject({
+      provenance: 'heuristic',
+      metadata: { synthesizedBy: 'interface-impl', via: 'Do', registeredAt: at('selector/selector.go', 'func (full) Do()') },
+    });
+    expect(meta(doEdge!)).not.toHaveProperty('promotedInto');
+  });
+
+  it('caps a struct\'s links into one interface, keeping its own method', () => {
+    const bigIface = one('Big', 'big/big.go');
+    const targets = Array.from({ length: BIG_METHODS }, (_, i) => dispatch(cg, methodOf(cg, bigIface, big(i)))).flat();
+    const embedding = at('big/big.go', 'type bigOne struct');
+    expect(targets).toHaveLength(40);
+    expect(targets).toContain(`bigOne::${big(BIG_METHODS - 1)}`);
+    // The 39 slots left go to methods the base promotes.
+    const promoted = targets.filter((t) => t.startsWith('bigBase::'));
+    expect(promoted).toHaveLength(39);
+    for (const t of promoted) expect(t).toMatch(new RegExp(`^bigBase::M\\d\\d <- bigOne @${embedding}$`));
+  });
+
+  it('shows the hop in codegraph_explore as a promoted method with its embedding', async () => {
+    const result = await new ToolHandler(cg).execute('codegraph_explore', {
+      query: 'expandSeriesSet SeriesSet.Next blockBaseSeriesSet.Next',
+    });
+    const text = result.content?.[0]?.text ?? '';
+    expect(text).toContain(
+      `dynamic: interface → method promoted into blockSeriesSet @${at('tsdb/querier.go', '\tblockBaseSeriesSet')}`
+    );
+  });
+});
+
+describe('a sync that changes what the struct declares', () => {
+  let dir = '';
+  let graph: CodeGraph | undefined;
+
+  afterEach(() => {
+    graph?.destroy();
+    graph = undefined;
+    if (dir) fs.rmSync(dir, { recursive: true, force: true });
+    dir = '';
+  });
+
+  it('moves the link between the promoted method and the struct\'s own', async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-promoted-sync-'));
+    const write = (rel: string, content: string) => {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    };
+    const wrap = 'package wrap\n\nimport "example.com/app/base"\n\ntype Wrapper struct {\n\tbase.Base\n}\n\nfunc (Wrapper) Name() string { return "" }\n';
+    write('go.mod', 'module example.com/app\n\ngo 1.22\n');
+    write('api/api.go', 'package api\n\ntype NamedCloser interface {\n\tClose() error\n\tName() string\n}\n');
+    write('base/base.go', 'package base\n\ntype Base struct{}\n\nfunc (Base) Close() error { return nil }\n');
+    write('wrap/wrap.go', wrap);
+    graph = await CodeGraph.init(dir, { index: true });
+    const g = graph;
+    const close = () => dispatch(g, methodOf(g, g.getNodesByName('NamedCloser')[0]!, 'Close'));
+
+    // Close comes from base.Base, embedded on line 6.
+    expect(close()).toEqual(['Base::Close <- Wrapper @wrap/wrap.go:6']);
+    write('wrap/wrap.go', `${wrap}\nfunc (Wrapper) Close() error { return nil }\n`);
+    await g.sync({ paths: ['wrap/wrap.go'] });
+    expect(close()).toEqual(['Wrapper::Close']);
+    write('wrap/wrap.go', wrap);
+    await g.sync({ paths: ['wrap/wrap.go'] });
+    expect(close()).toEqual(['Base::Close <- Wrapper @wrap/wrap.go:6']);
+  }, 60_000);
+});
diff --git a/__tests__/go-ref-qualifier.test.ts b/__tests__/go-ref-qualifier.test.ts
new file mode 100644
index 0000000000..cad483034a
--- /dev/null
+++ b/__tests__/go-ref-qualifier.test.ts
@@ -0,0 +1,415 @@
+/**
+ * A Go name written through an outside package is none of the project's
+ * symbols (#2322), so which package a call is written through decides what
+ * it may reach. Two misreadings of that qualifier, both seen on real trees:
+ *
+ * - A dotted call reference (`klog.Infof`) is recorded at its receiver, and
+ *   the reader looked for the line's only `X.Infof` instead of taking the
+ *   receiver the reference names. A second spelling of the name on the line
+ *   left it with no qualifier — `Digest:` beside `digest.Digest(dig)`
+ *   (harbor), `"Log using Infof"` (kubernetes) — so the call kept a project
+ *   namesake's method, and another selector before it made `perr.Error` in
+ *   `klog.Error(perr.Error())` a call through `klog`. Only the first segment
+ *   can be a package: `s.cache.Get` is no call through a `cache` import.
+ * - A parameter or local can take an import's name: etcd's
+ *   `jwt, err := newTokenProviderJWT(…)` beside `import ".../jwt/v5"`. A
+ *   call through it is a method call on the variable, which the
+ *   outside-package rule rejected along with the package's own calls.
+ */
+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';
+
+const files: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  // Project methods named like the outside packages' functions.
+  'logging/wrapper.go': `package logging
+
+// An adapter with klog's method names, like kubernetes' etcd3 logger.
+type klogWrapper struct{}
+
+func (klogWrapper) Infof(format string, args ...interface{})  {}
+func (klogWrapper) Errorf(format string, args ...interface{}) {}
+`,
+  'registry/suite.go': `package registry
+
+type Suite struct{}
+
+func (s *Suite) Digest(v string) string { return v }
+`,
+  'diff/differ.go': `package diff
+
+type Differ struct{}
+
+func (d *Differ) Diff(a, b string) string { return a + b }
+`,
+  'example/example.go': `package example
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/distribution/distribution/v3"
+	"github.com/google/go-cmp/cmp"
+	"github.com/opencontainers/go-digest"
+	"github.com/patrickmn/go-cache"
+	"k8s.io/klog/v2"
+)
+
+type parseError struct{}
+
+func (e *parseError) Error() string { return "parse" }
+
+type lru struct{}
+
+func (l *lru) Get(key string) string { return key }
+
+type Server struct {
+	cache *lru
+}
+
+func (s *Server) Lookup(key string) string {
+	return s.cache.Get(key)
+}
+
+func NewServer() *Server {
+	_ = cache.New(0, 0)
+	return &Server{cache: &lru{}}
+}
+
+func Run(dig string) {
+	klog.Infof("Log using Infof, key: %s", "value")
+	err := errors.New("fail")
+	klog.Errorf("Log using Errorf, err: %v", err)
+	desc := &distribution.Descriptor{Digest: digest.Digest(dig)}
+	_ = desc
+	perr := &parseError{}
+	klog.Error(perr.Error())
+}
+
+func TestParser(t *testing.T) {
+	t.Errorf("Unexpected policy! Diff:\\n%s", cmp.Diff("a", "b"))
+}
+`,
+  'auth/jwt.go': `package auth
+
+import "github.com/golang-jwt/jwt/v5"
+
+type tokenJWT struct{ key string }
+
+func newTokenProviderJWT(key string) (*tokenJWT, error) { return &tokenJWT{key: key}, nil }
+
+func (t *tokenJWT) assign(user string) (string, error) { return user, nil }
+
+func (t *tokenJWT) info(token string) (string, bool) { return token, true }
+
+// Named like the package's Parse.
+type jwtOptions struct{}
+
+func (o *jwtOptions) Parse(token string) error { return nil }
+
+func parse(token string) {
+	_, _ = jwt.Parse(token, nil)
+}
+`,
+  'auth/jwt_test.go': `package auth
+
+import (
+	"testing"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+func TestJWTInfo(t *testing.T) {
+	jwt, err := newTokenProviderJWT("key")
+	if err != nil {
+		t.Fatal(err)
+	}
+	token, _ := jwt.assign("abc")
+	_, ok := jwt.info(token)
+	_ = ok
+}
+
+func TestJWTParse(t *testing.T) {
+	jwt, err := jwt.Parse("x", nil)
+	_, _ = jwt, err
+}
+
+func TestJWTClosure(t *testing.T) {
+	check := func(jwt *tokenJWT) {
+		jwt.info("t")
+	}
+	check(nil)
+	_, _ = jwt.Parse("y", nil)
+}
+`,
+  'compare/compare.go': `package compare
+
+import "github.com/google/go-cmp/cmp"
+
+type Comparer interface {
+	Compare(a, b int) int
+}
+
+func comparers() []Comparer { return nil }
+
+func Check(cmp Comparer) int {
+	return cmp.Compare(1, 2)
+}
+
+func Report(a, b string) string {
+	for _, cmp := range comparers() {
+		_ = cmp.Compare(3, 4)
+	}
+	return cmp.Diff(a, b)
+}
+
+func Report2(a, b string) string {
+	cmp := cmp.Diff(a, b)
+	return cmp
+}
+`,
+  // A variable's declared type says whose methods it has: kubernetes'
+  // `clock clock.PassiveClock` parameter, `cache := &atomic.Bool{}`, and
+  // harbor's `logger logger.Interface`.
+  'clock/clock.go': `package clock
+
+import "time"
+
+// Named like k8s.io/utils/clock's interface.
+type Clock interface {
+	Now() time.Time
+}
+`,
+  'cache/store.go': `package cache
+
+type Store interface {
+	Add(obj interface{}) error
+}
+`,
+  'jobs/logger/logger.go': `package logger
+
+type Interface interface {
+	Error(v ...interface{})
+	String() string
+}
+
+func Error(v ...interface{}) {}
+`,
+  'jobs/transfer/transfer.go': `package transfer
+
+type Logger struct{}
+
+func (l *Logger) Error(v ...interface{}) {}
+`,
+  'jobs/job.go': `package jobs
+
+import (
+	"sync/atomic"
+	"time"
+
+	"example.com/app/cache"
+	"example.com/app/jobs/logger"
+	"k8s.io/utils/clock"
+	clocktesting "k8s.io/utils/clock/testing"
+)
+
+func logError(logger logger.Interface, err error) {
+	logger.Error(err)
+}
+
+func nextCheck(clock clock.PassiveClock) int64 {
+	return clock.Now().Unix()
+}
+
+func cachedHasSynced(store cache.Store) func() bool {
+	cache := &atomic.Bool{}
+	cache.Store(false)
+	return cache.Load
+}
+
+func describe(logger logger.Interface) string {
+	return logger.Kind.String()
+}
+
+func elapsed() time.Time {
+	clock := clocktesting.NewFakePassiveClock(time.Unix(1, 0))
+	now := clock.Now()
+	return now
+}
+`,
+  // harbor's controller/robot.Robot embeds model.Robot, whose method a
+  // local named like the import calls.
+  'robot/model/model.go': `package model
+
+type Robot struct{ Name string }
+
+func (r *Robot) ToJSON() (string, error) { return r.Name, nil }
+`,
+  'robot/robot.go': `package robot
+
+import "example.com/app/robot/model"
+
+type Robot struct {
+	model.Robot
+	Level string
+}
+`,
+  'scan/job_test.go': `package scan
+
+import (
+	"testing"
+
+	"example.com/app/robot"
+)
+
+func TestJob(t *testing.T) {
+	robot := &robot.Robot{Level: "system"}
+	data, _ := robot.ToJSON()
+	_ = data
+}
+`,
+  'store/store.go': `package store
+
+import "github.com/patrickmn/go-cache"
+
+type store struct{}
+
+func (cache *store) Refresh() {
+	cache.load()
+}
+
+func (s *store) load() {}
+
+func New() *cache.Cache {
+	return cache.New(0, 0)
+}
+`,
+};
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-ref-qualifier-'));
+  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 });
+}, 60_000);
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** The line of `file` that holds `snippet` (its nth occurrence, from 1). */
+const lineOf = (file: string, snippet: string, nth = 1): number => {
+  const lines = files[file]!.split('\n');
+  let seen = 0;
+  const at = lines.findIndex((l) => l.includes(snippet) && ++seen === nth);
+  if (at < 0) throw new Error(`no ${snippet} in ${file}`);
+  return at + 1;
+};
+
+/** What the calls on the line of `file` holding `snippet` reach, as qualified names. */
+const reachedAt = (file: string, snippet: string, nth = 1): string[] => {
+  const line = lineOf(file, snippet, nth);
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind !== 'contains' && e.line === line)
+    .map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('a dotted Go call is written through its own receiver', () => {
+  it('whatever else on the line spells the name', () => {
+    // `"Log using Infof"` and the `Digest:` key spell the name again.
+    expect(reachedAt('example/example.go', 'klog.Infof(')).not.toContain('klogWrapper::Infof');
+    expect(reachedAt('example/example.go', 'klog.Errorf(')).not.toContain('klogWrapper::Errorf');
+    expect(reachedAt('example/example.go', 'digest.Digest(dig)')).not.toContain('Suite::Digest');
+    expect(reachedAt('example/example.go', 'cmp.Diff("a", "b")')).not.toContain('Differ::Diff');
+  });
+
+  it('not through another selector on its line', () => {
+    // `klog.Error(perr.Error())`: perr's own method, not a call through klog.
+    expect(reachedAt('example/example.go', 'klog.Error(perr.Error())')).toContain('parseError::Error');
+    // `s.cache.Get(key)`: the field's type, not the go-cache package the
+    // middle segment is named like.
+    expect(reachedAt('example/example.go', 's.cache.Get(key)')).toContain('lru::Get');
+  });
+});
+
+describe('a Go parameter or local named like an import', () => {
+  it('is the variable where it is in scope', () => {
+    expect(reachedAt('auth/jwt_test.go', 'jwt.assign(')).toContain('tokenJWT::assign');
+    expect(reachedAt('auth/jwt_test.go', 'jwt.info(token)')).toContain('tokenJWT::info');
+    // A closure's parameter, a function's parameter, a range variable and a method receiver.
+    expect(reachedAt('auth/jwt_test.go', 'jwt.info("t")')).toContain('tokenJWT::info');
+    expect(reachedAt('compare/compare.go', 'cmp.Compare(1, 2)')).toContain('Comparer::Compare');
+    expect(reachedAt('compare/compare.go', 'cmp.Compare(3, 4)')).toContain('Comparer::Compare');
+    expect(reachedAt('store/store.go', 'cache.load()')).toContain('store::load');
+  });
+
+  it('leaves the package what the import names everywhere else', () => {
+    // Another function, the declaration's own right-hand side, past a
+    // closure or a loop that bound the name.
+    expect(reachedAt('auth/jwt.go', 'jwt.Parse(token, nil)')).not.toContain('jwtOptions::Parse');
+    expect(reachedAt('auth/jwt_test.go', 'jwt.Parse("x", nil)')).not.toContain('jwtOptions::Parse');
+    expect(reachedAt('auth/jwt_test.go', 'jwt.Parse("y", nil)')).not.toContain('jwtOptions::Parse');
+    expect(reachedAt('compare/compare.go', 'return cmp.Diff(a, b)')).not.toContain('Differ::Diff');
+    expect(reachedAt('compare/compare.go', 'cmp := cmp.Diff(a, b)')).not.toContain('Differ::Diff');
+  });
+
+  it('has the methods of the type it is declared as', () => {
+    // An outside package's type holds none of the project's methods, nor
+    // does a value one of its functions hands out…
+    expect(reachedAt('jobs/job.go', 'clock.Now()')).not.toContain('Clock::Now');
+    expect(reachedAt('jobs/job.go', 'cache.Store(false)')).toEqual([]);
+    expect(reachedAt('jobs/job.go', 'now := clock.Now()')).toEqual([]);
+    // …and a project package's type its own: not the function the import
+    // names, nor another package's `Logger::Error`. A method an embedded
+    // type brings in counts.
+    expect(reachedAt('jobs/job.go', 'logger.Error(err)')).toEqual(['Interface::Error']);
+    expect(reachedAt('scan/job_test.go', 'robot.ToJSON()')).toEqual(['Robot::ToJSON']);
+    // The type is the variable's, not a field's read through it.
+    expect(reachedAt('jobs/job.go', 'logger.Kind.String()')).not.toContain('Interface::String');
+  });
+
+  it('is read from the file as a sync leaves it', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-ref-qualifier-sync-'));
+    const write = (rel: string, content: string): void => {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    };
+    write('go.mod', 'module example.com/app\n\ngo 1.22\n');
+    write('auth/jwt.go', files['auth/jwt.go']!);
+    // The same lines either way: a stale reading would still see the local.
+    const use = (decl: string) => `package auth
+
+import "github.com/golang-jwt/jwt/v5"
+
+func use() {
+	${decl}
+	jwt.assign("user")
+}
+`;
+    write('auth/use.go', use('jwt, _ := newTokenProviderJWT("key")'));
+    const synced = await CodeGraph.init(dir, { index: true });
+    try {
+      const assigns = (): string[] => {
+        const ids = synced.getNodesInFile('auth/use.go').map((n) => n.id);
+        return synced.getOutgoingEdgesFrom(ids).filter((e) => e.line === 7).map((e) => synced.getNode(e.target)!.qualifiedName);
+      };
+      expect(assigns()).toEqual(['tokenJWT::assign']);
+      write('auth/use.go', use('_, _ = jwt.Parse("key", nil)'));
+      await synced.sync();
+      expect(assigns()).toEqual([]);
+    } finally {
+      synced.close();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, 60_000);
+});
diff --git a/__tests__/go-type-alias.test.ts b/__tests__/go-type-alias.test.ts
new file mode 100644
index 0000000000..9c4a3fe706
--- /dev/null
+++ b/__tests__/go-type-alias.test.ts
@@ -0,0 +1,397 @@
+/**
+ * A Go alias declaration (`type Event = mvccpb.Event`, `type ( A = B )`) was
+ * in neither extractor's graph. tree-sitter-go parses it as a `type_alias`
+ * beside the `type_spec` of a defined type (`type WatchChan <-chan
+ * WatchResponse`), and both extractors only read `type_spec`, so etcd's
+ * client/v3 `Event` had no node while the line below it did.
+ *
+ * An alias is now a node of the kind a declaration of its type gets: a
+ * `type_alias` that references the types it names, a `struct` or an
+ * `interface` when it names a struct or interface literal. Each reference sits
+ * on the type's name, where resolution reads a package qualifier back. A
+ * generic alias (`type Set[T any] = …`, Go 1.24) has no rule in this grammar:
+ * it parses as a `type_spec` around an error, so the kernel hands the file to
+ * the wasm extractor, which reads it as an alias too, without its type
+ * parameters.
+ *
+ * Resolution treats the alias as the type it names. A bare `Event{}` or
+ * `*Event` in its package links to the alias, a method called on an `*Event`
+ * is the aliased type's method, methods written with the alias as the
+ * receiver make it implement what they satisfy, and an alias whose target is
+ * written through a package the index doesn't know (`clientv3` under an
+ * unaliased `go.etcd.io/etcd/client/v3`, known as `v3` or `client`) never
+ * links to itself or to a namesake.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** Every alias shape the grammar has a rule for, beside defined types. */
+const ALIAS_SOURCE = `package clientv3
+
+import (
+	"context"
+
+	"go.etcd.io/etcd/api/v3/mvccpb"
+)
+
+// Event is the event a watcher reports.
+type Event = mvccpb.Event
+
+type WatchChan <-chan WatchResponse
+
+type WatchResponse struct {
+	Events []*Event
+}
+
+type (
+	// Local names a type of this package.
+	Local   = WatchResponse
+	Ptr     = *WatchResponse
+	Slice   = []WatchResponse
+	Handler = func(ctx context.Context, r WatchResponse) error
+	Index   = map[string]*mvccpb.KeyValue
+	Defined WatchResponse
+)
+
+type Plain = List[WatchResponse]
+
+type Anon = struct {
+	Key string
+}
+
+type Closer = interface {
+	Close() error
+}
+
+type Type = string
+
+type Word = uint
+`;
+
+/** Generic aliases: no grammar rule, so a parse error the kernel defers. */
+const GENERIC_SOURCE = `package clientv3
+
+type List[T any] struct {
+	items []T
+}
+
+// Set is a set of comparable values.
+type Set[T comparable] = map[T]struct{}
+
+type Items[T any] = List[T]
+
+type Pairs[K comparable, V any] = map[K]List[V]
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+/** `<kind> <name>` of every node but the file and its imports, in source order. */
+function declarations(result: ExtractionResult): string[] {
+  return result.nodes.filter((n) => n.kind !== 'file' && n.kind !== 'import').map((n) => `${n.kind} ${n.name}`);
+}
+
+/** `<source> <name>` for every `references` ref out of a type declaration, sorted. */
+function typeRefs(result: ExtractionResult): string[] {
+  const byId = new Map(result.nodes.map((n) => [n.id, n]));
+  return result.unresolvedReferences
+    .filter((r) => r.referenceKind === 'references' && ['type_alias', 'struct', 'interface'].includes(byId.get(r.fromNodeId)?.kind ?? ''))
+    .map((r) => `${byId.get(r.fromNodeId)!.name} ${r.referenceName}`)
+    .sort();
+}
+
+describe('Go alias declarations are extracted', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['go']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', file: string, source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource(file, source, 'go');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract(file, source, 'go');
+    expect(result, `kernel extraction of ${file}`).not.toBeNull();
+    return result!;
+  }
+
+  /** Each type ref sits on its name, where resolution reads a package qualifier back. */
+  function expectRefsOnTheirNames(result: ExtractionResult, source: string): void {
+    const lines = source.split(/\r?\n/);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'references');
+    expect(refs.length).toBeGreaterThan(0);
+    for (const r of refs) {
+      expect(lines[r.line - 1]!.startsWith(r.referenceName, r.column), `${r.referenceName} at ${r.line}:${r.column}`).toBe(true);
+    }
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const eol = (s: string) => (crlf ? s.replace(/\n/g, '\r\n') : s);
+    const label = crlf ? ' (CRLF)' : '';
+
+    it.each(backends)(`an alias is a node of its type's kind: %s${label}`, (backend) => {
+      const result = extract(backend, 'client/v3/watch.go', eol(ALIAS_SOURCE));
+      expect(declarations(result)).toEqual([
+        'type_alias Event',
+        'type_alias WatchChan',
+        'struct WatchResponse',
+        'type_alias Local',
+        'type_alias Ptr',
+        'type_alias Slice',
+        'type_alias Handler',
+        'type_alias Index',
+        'type_alias Defined',
+        'type_alias Plain',
+        'struct Anon',
+        'interface Closer',
+        'method Close',
+        'type_alias Type',
+        'type_alias Word',
+      ]);
+      const event = result.nodes.find((n) => n.name === 'Event')!;
+      expect(event.isExported).toBe(true);
+      expect(event.startLine).toBe(10);
+      // A doc comment is read as for any type declaration: inside a group.
+      expect(result.nodes.find((n) => n.name === 'Local')!.docstring).toBe('Local names a type of this package.');
+      // Nested under the file, as a defined type is.
+      const file = result.nodes.find((n) => n.kind === 'file')!;
+      expect(result.edges.some((e) => e.kind === 'contains' && e.source === file.id && e.target === event.id)).toBe(true);
+    });
+
+    it.each(backends)(`an alias references the types it names: %s${label}`, (backend) => {
+      const source = eol(ALIAS_SOURCE);
+      const result = extract(backend, 'client/v3/watch.go', source);
+      // The package of mvccpb.Event / context.Context stays in the source;
+      // predeclared types (string, uint, error) are no references. The
+      // defined types (WatchChan, Defined) reference theirs too.
+      expect(typeRefs(result)).toEqual([
+        'Defined WatchResponse',
+        'Event Event',
+        'Handler Context',
+        'Handler WatchResponse',
+        'Index KeyValue',
+        'Local WatchResponse',
+        'Plain List',
+        'Plain WatchResponse',
+        'Ptr WatchResponse',
+        'Slice WatchResponse',
+        'WatchChan WatchResponse',
+      ]);
+      expectRefsOnTheirNames(result, source);
+    });
+  }
+
+  it.each([false, true])('a generic alias is an alias without its type parameters (wasm; CRLF: %s)', (crlf) => {
+    const source = crlf ? GENERIC_SOURCE.replace(/\n/g, '\r\n') : GENERIC_SOURCE;
+    if (kernelAvailable) {
+      delete process.env.CODEGRAPH_KERNEL;
+      process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+      // No grammar rule: a parse error, which the kernel leaves to wasm.
+      expect(tryKernelExtract('client/v3/set.go', source, 'go')).toBeNull();
+    }
+    const result = extract('wasm', 'client/v3/set.go', source);
+    expect(declarations(result)).toEqual(['struct List', 'type_alias Set', 'type_alias Items', 'type_alias Pairs']);
+    expect(result.nodes.find((n) => n.name === 'Set')!.isExported).toBe(true);
+    expect(typeRefs(result)).toEqual(['Items List', 'Pairs List']);
+    expectRefsOnTheirNames(result, source);
+  });
+});
+
+describe('an indexed Go module resolves through its aliases', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-alias-'));
+    const files: Record<string, string> = {
+      'go.mod': 'module go.etcd.io/etcd\n\ngo 1.24\n',
+      'api/v3/mvccpb/kv.go': [
+        'package mvccpb',
+        '',
+        'type Event struct {',
+        '\tType int',
+        '}',
+        '',
+        'func (e *Event) IsCreate() bool { return e.Type == 0 }',
+        '',
+      ].join('\n'),
+      // A namesake package that sorts first, so a lookup by name meets its
+      // `Event` and `Event::IsCreate` before mvccpb's.
+      'alpha/event.go': [
+        'package alpha',
+        '',
+        'type Event struct{}',
+        '',
+        'func (e *Event) IsCreate() bool { return false }',
+        '',
+      ].join('\n'),
+      'client/v3/watch.go': [
+        'package clientv3',
+        '',
+        'import "go.etcd.io/etcd/api/v3/mvccpb"',
+        '',
+        'type Event = mvccpb.Event',
+        '',
+        'type WatchResponse struct {',
+        '\tEvents []*Event',
+        '}',
+        '',
+        'func (wr *WatchResponse) Err() error { return nil }',
+        '',
+        'type (',
+        '\tLocal = WatchResponse',
+        '\tPtr   = *Local',
+        ')',
+        '',
+        'func newEvent() Event { return Event{} }',
+        '',
+        'func isCreate(e *Event) bool { return e.IsCreate() }',
+        '',
+        'func check(p Ptr) error { return p.Err() }',
+        '',
+      ].join('\n'),
+      // A generic alias: the file parses with an error and goes to wasm.
+      'client/v3/list.go': [
+        'package clientv3',
+        '',
+        'type List[T any] struct{ items []T }',
+        '',
+        'func (l *List[T]) Len() int { return len(l.items) }',
+        '',
+        'type Items[T any] = List[T]',
+        '',
+        'func count(xs *Items[int]) int { return xs.Len() }',
+        '',
+      ].join('\n'),
+      // prometheus's discovery/xds: methods written on the alias are SDConfig's.
+      'discovery/kuma.go': [
+        'package discovery',
+        '',
+        'type Config interface {',
+        '\tName() string',
+        '}',
+        '',
+        'type SDConfig struct{}',
+        '',
+        'type KumaSDConfig = SDConfig',
+        '',
+        'func (*KumaSDConfig) Name() string { return "kuma" }',
+        '',
+      ].join('\n'),
+      'watcher/watcher.go': [
+        'package watcher',
+        '',
+        'import "go.etcd.io/etcd/client/v3"',
+        '',
+        '// The package is clientv3, though the index knows the import as v3 or client.',
+        'type Event = clientv3.Event',
+        '',
+      ].join('\n'),
+    };
+    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 });
+  }, 60_000);
+
+  afterAll(() => {
+    cg?.destroy();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  /** `kind file:qualifiedName` of each non-contains edge out of `name` in `file`, sorted. */
+  const linksFrom = (file: string, name: string) => {
+    const sources = cg.getNodesInFile(file).filter((n) => n.name === name && n.kind !== 'import');
+    expect(sources, `${name} in ${file}`).toHaveLength(1);
+    const links = cg.getOutgoingEdgesFrom(sources.map((n) => n.id))
+      .filter((e) => e.kind !== 'contains')
+      .map((e) => ({ kind: e.kind, target: cg.getNode(e.target)! }))
+      .map(({ kind, target }) => `${kind} ${target.filePath}:${target.qualifiedName}`);
+    return [...new Set(links)].sort();
+  };
+
+  it('an alias references the type it names, in the package it is written through', () => {
+    expect(linksFrom('client/v3/watch.go', 'Event')).toEqual(['references api/v3/mvccpb/kv.go:Event']);
+    expect(linksFrom('client/v3/watch.go', 'Local')).toEqual(['references client/v3/watch.go:WatchResponse']);
+    expect(linksFrom('client/v3/watch.go', 'Ptr')).toEqual(['references client/v3/watch.go:Local']);
+    expect(linksFrom('client/v3/list.go', 'Items')).toEqual(['references client/v3/list.go:List']);
+  });
+
+  it('a bare name in the alias package is the alias', () => {
+    expect(linksFrom('client/v3/watch.go', 'newEvent')).toEqual([
+      'instantiates client/v3/watch.go:Event',
+      'references client/v3/watch.go:Event',
+    ]);
+  });
+
+  it('a method called on an alias is the aliased type’s', () => {
+    expect(linksFrom('client/v3/watch.go', 'isCreate')).toEqual([
+      'calls api/v3/mvccpb/kv.go:Event::IsCreate',
+      'references client/v3/watch.go:Event',
+    ]);
+    // Through two aliases, one of a pointer.
+    expect(linksFrom('client/v3/watch.go', 'check')).toEqual([
+      'calls client/v3/watch.go:WatchResponse::Err',
+      'references client/v3/watch.go:Ptr',
+    ]);
+    expect(linksFrom('client/v3/list.go', 'count')).toEqual([
+      'calls client/v3/list.go:List::Len',
+      'references client/v3/list.go:Items',
+    ]);
+  });
+
+  it('an alias owning methods written on it implements what they satisfy', () => {
+    expect(linksFrom('discovery/kuma.go', 'KumaSDConfig')).toEqual([
+      'implements discovery/kuma.go:Config',
+      'references discovery/kuma.go:SDConfig',
+    ]);
+    // A call through Config.Name reaches the method written on the alias.
+    const config = cg.getNodesInFile('discovery/kuma.go').find((n) => n.name === 'Config')!;
+    const name = cg.getOutgoingEdgesFrom([config.id], ['contains']).map((e) => cg.getNode(e.target)!).find((n) => n.name === 'Name')!;
+    expect(cg.getOutgoingEdgesFrom([name.id], ['calls']).map((e) => cg.getNode(e.target)?.qualifiedName)).toEqual(['KumaSDConfig::Name']);
+  });
+
+  it('an alias written through a package the index does not know links to nothing', () => {
+    // Not to itself, nor to client/v3's, mvccpb's or alpha's `Event`.
+    expect(linksFrom('watcher/watcher.go', 'Event')).toEqual([]);
+    const event = cg.getNodesInFile('watcher/watcher.go').find((n) => n.name === 'Event')!;
+    expect(cg.getUnresolvedReferencesFrom(event.id).map((r) => `${r.referenceKind} ${r.referenceName}`)).toEqual(['references Event']);
+  });
+});
diff --git a/__tests__/go-type-assertion-calls.test.ts b/__tests__/go-type-assertion-calls.test.ts
new file mode 100644
index 0000000000..efd1da4143
--- /dev/null
+++ b/__tests__/go-type-assertion-calls.test.ts
@@ -0,0 +1,404 @@
+/**
+ * A Go call through a type assertion is a call of the asserted type's method:
+ *
+ *   func _KV_Range_Handler(srv interface{}, …) (interface{}, error) {
+ *     return srv.(KVServer).Range(ctx, in)   // etcd's generated gRPC code
+ *   }
+ *
+ * Both extractors record such a call by its bare member name (`Range`), at
+ * the column where its receiver expression starts, as any call through an
+ * expression. Resolution matched the name alone, so every handler etcd
+ * generates went to `UnimplementedKVServer`'s stub instead of the `KVServer`
+ * interface method. The asserted type is now read back from the source: its
+ * own method, the method its interface declares, or one embedding promotes
+ * into it — written bare (its own package's, or a dot import's), as a
+ * pointer, or through a project package. A type from outside the project
+ * (`http.Flusher`) or a type literal links nothing.
+ */
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** etcd's generated server handlers, a pointer assertion, and a chain continued on the next line. */
+const HANDLERS = `package pb
+
+import "context"
+
+type KVServer interface {
+	Range(context.Context, *RangeRequest) (*RangeResponse, error)
+	Put(context.Context, *RangeRequest) (*RangeResponse, error)
+}
+
+type UnimplementedKVServer struct{}
+
+func (UnimplementedKVServer) Range(context.Context, *RangeRequest) (*RangeResponse, error) {
+	return nil, nil
+}
+
+func (UnimplementedKVServer) Put(context.Context, *RangeRequest) (*RangeResponse, error) {
+	return nil, nil
+}
+
+type RangeRequest struct{}
+
+type RangeResponse struct{}
+
+func _KV_Range_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor func(context.Context, interface{}, func(context.Context, interface{}) (interface{}, error)) (interface{}, error)) (interface{}, error) {
+	in := new(RangeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KVServer).Range(ctx, in)
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KVServer).Range(ctx, req.(*RangeRequest))
+	}
+	return interceptor(ctx, in, handler)
+}
+
+func _KV_Put_Handler(srv interface{}, ctx context.Context, in *RangeRequest) (interface{}, error) {
+	return srv.(KVServer).
+		Put(ctx, in)
+}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+describe('Go calls through a type assertion are recorded at their receiver', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['go']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource('pb/rpc_grpc.pb.go', source, 'go');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract('pb/rpc_grpc.pb.go', source, 'go');
+    expect(result, 'kernel extraction').not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const source = crlf ? HANDLERS.replace(/\n/g, '\r\n') : HANDLERS;
+    it.each(backends)(`by the bare member name, at the receiver's column: %s${crlf ? ' (CRLF)' : ''}`, (backend) => {
+      const lines = source.split(/\r?\n/);
+      const refs = extract(backend, source).unresolvedReferences
+        .filter((r) => r.referenceKind === 'calls' && (r.referenceName.endsWith('Range') || r.referenceName.endsWith('Put')))
+        .map((r) => `${r.referenceName} ${r.line}:${r.column}`)
+        .sort();
+      // `line:column` of the receiver `srv` on the line `pick` finds.
+      const srvOn = (pick: (line: string) => boolean): string => {
+        const line = lines.findIndex(pick);
+        return `${line + 1}:${lines[line]!.indexOf('srv')}`;
+      };
+      expect(refs).toEqual([
+        `Put ${srvOn((l) => l.endsWith('srv.(KVServer).'))}`,
+        `Range ${srvOn((l) => l.includes('Range(ctx, in)'))}`,
+        `Range ${srvOn((l) => l.includes('Range(ctx, req.('))}`,
+      ].sort());
+    });
+  }
+});
+
+/**
+ * The module the resolution tests index. Namesakes sit where name matching
+ * looked first: a stub beside each interface, a same-file type with each
+ * method name, and an `alpha` package that sorts ahead of `storage`.
+ */
+const FILES: Record<string, string> = {
+  'go.mod': 'module example.com/app\n\ngo 1.22\n',
+  'pb/rpc_grpc.pb.go': HANDLERS.replace(/\n/g, '\r\n'),
+  'internal/bufconn/bufconn.go': `package bufconn
+
+import "io"
+
+type pipe struct{}
+
+func (p *pipe) Close() error { return nil }
+
+func (p *pipe) closeWrite() error { return nil }
+
+func (p *pipe) close() {}
+
+type conn struct {
+	io.Reader
+	io.Writer
+}
+
+func (c *conn) Close() error {
+	err1 := c.Reader.(*pipe).Close()
+	err2 := c.Writer.(*pipe).closeWrite()
+	c.Reader.(*pipe).close()
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+`,
+  'alpha/alpha.go': `package alpha
+
+type Store interface {
+	Fetch(key string) string
+}
+
+type sink struct{}
+
+func (s *sink) Fetch(key string) string { return "" }
+
+func (s *sink) Flush() error { return nil }
+
+func (s *sink) Read(p []byte) (int, error) { return 0, nil }
+
+type Ctx struct{}
+
+func (c *Ctx) Done() <-chan struct{} { return nil }
+`,
+  'storage/storage.go': `package storage
+
+type Store interface {
+	Fetch(key string) string
+}
+
+type Base struct{}
+
+func (b *Base) Flush() error { return nil }
+`,
+  'store/store.go': `package store
+
+import (
+	"context"
+
+	"example.com/app/storage"
+)
+
+type Reader interface {
+	Read(p []byte) (int, error)
+}
+
+type ReadCloser interface {
+	Reader
+	Close() error
+}
+
+type Wrapper struct {
+	*storage.Base
+	name string
+}
+
+type Job struct{}
+
+func (j *Job) Start() {}
+
+type Factory interface {
+	New() *Job
+}
+
+type Builder struct{}
+
+func (b *Builder) Add(n int) *Builder { return b }
+
+type Ctx = context.Context
+
+type Keeper = storage.Store
+`,
+  'store/use.go': `package store
+
+import (
+	"net/http"
+
+	"example.com/app/storage"
+)
+
+type sink struct{}
+
+func (s *sink) Flush() error { return nil }
+
+func (s *sink) Read(p []byte) (int, error) { return 0, nil }
+
+func (s *sink) Fetch(key string) string { return "" }
+
+func Use(v any, w http.ResponseWriter, p []byte) string {
+	v.(*Wrapper).Flush()
+	v.(ReadCloser).Read(p)
+	w.(http.Flusher).Flush()
+	return v.(storage.Store).Fetch("k")
+}
+
+func Anon(v any) string {
+	return v.(interface{ Fetch(key string) string }).Fetch("k")
+}
+
+func Run(v any) {
+	v.(Factory).New().Start()
+}
+
+func lookup(key string) any { return nil }
+
+func Quoted() string {
+	return lookup(")").(storage.Store).Fetch("k")
+}
+
+func (s *sink) Add(n int) *sink { return s }
+
+func Build(v any) {
+	v.(*Builder).Add(1).Add(2)
+}
+
+func Wait(v any) {
+	v.(Ctx).Done()
+}
+
+func Keep(v any) string {
+	return v.(Keeper).Fetch("k")
+}
+`,
+  'dot/dot.go': `package dot
+
+import . "example.com/app/storage"
+
+func Get(v any) string {
+	return v.(Store).Fetch("k")
+}
+`,
+};
+
+describe.each(['default', 'wasm'])('Go calls through a type assertion resolve on the asserted type (%s)', (backend) => {
+  let root = '';
+  let cg: CodeGraph | undefined;
+  let kernel: string | undefined;
+
+  beforeAll(async () => {
+    kernel = process.env.CODEGRAPH_KERNEL;
+    if (backend === 'wasm') process.env.CODEGRAPH_KERNEL = '0';
+    else delete process.env.CODEGRAPH_KERNEL;
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-assert-'));
+    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 });
+  }, 60_000);
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+    if (kernel === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernel;
+  });
+
+  /** `<line> <target file>::<target qualified name>` for every call the function or method `qualifiedName` in `file` makes. */
+  function calls(file: string, qualifiedName: string): string[] {
+    const fn = cg!.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName && (n.kind === 'function' || n.kind === 'method'));
+    expect(fn, `${qualifiedName} in ${file}`).toBeDefined();
+    return cg!
+      .getOutgoingEdges(fn!.id)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => `${e.line} ${cg!.getNode(e.target)!.filePath}::${cg!.getNode(e.target)!.qualifiedName}`)
+      .sort();
+  }
+
+  it("links etcd's gRPC handlers to the server interface's method, not the stub", () => {
+    expect(calls('pb/rpc_grpc.pb.go', '_KV_Range_Handler')).toEqual([
+      '30 pb/rpc_grpc.pb.go::KVServer::Range',
+      '33 pb/rpc_grpc.pb.go::KVServer::Range',
+    ]);
+    // A chain continued on the next line.
+    expect(calls('pb/rpc_grpc.pb.go', '_KV_Put_Handler')).toEqual(['39 pb/rpc_grpc.pb.go::KVServer::Put']);
+  });
+
+  it("links a pointer assertion to the type's own method, one named like a builtin too", () => {
+    expect(calls('internal/bufconn/bufconn.go', 'conn::Close')).toEqual([
+      '19 internal/bufconn/bufconn.go::pipe::Close',
+      '20 internal/bufconn/bufconn.go::pipe::closeWrite',
+      '21 internal/bufconn/bufconn.go::pipe::close',
+    ]);
+  });
+
+  it('follows embedding, a package qualifier and a dot import to the method', () => {
+    // *Wrapper's Flush is promoted from *storage.Base; ReadCloser's Read from Reader.
+    expect(calls('store/use.go', 'Use')).toEqual([
+      '18 storage/storage.go::Base::Flush',
+      '19 store/store.go::Reader::Read',
+      '21 storage/storage.go::Store::Fetch',
+    ]);
+    expect(calls('dot/dot.go', 'Get')).toEqual(['6 storage/storage.go::Store::Fetch']);
+    // An alias is the type it names.
+    expect(calls('store/use.go', 'Keep')).toEqual(['49 storage/storage.go::Store::Fetch']);
+    // A string argument holding a parenthesis is not the end of the call.
+    expect(calls('store/use.go', 'Quoted')).toEqual([
+      '35 storage/storage.go::Store::Fetch',
+      '35 store/use.go::lookup',
+    ]);
+  });
+
+  it('links nothing for a type from outside the project or a type literal', () => {
+    // http.Flusher's Flush, on line 20 of Use, has no edge (see above).
+    expect(calls('store/use.go', 'Anon')).toEqual([]);
+    // Ctx is an alias of context.Context.
+    expect(calls('store/use.go', 'Wait')).toEqual([]);
+    const flush = cg!.getNodesInFile('store/use.go').find((n) => n.qualifiedName === 'sink::Flush')!;
+    expect(cg!.getIncomingEdges(flush.id).filter((e) => e.kind === 'calls')).toEqual([]);
+  });
+
+  it("leaves a later link of the chain to the type the call before it returns", () => {
+    expect(calls('store/use.go', 'Run')).toEqual([
+      '29 store/store.go::Factory::New',
+      '29 store/store.go::Job::Start',
+    ]);
+  });
+
+  it('takes two calls of one name in a chain for the one made through the assertion', () => {
+    // Both `Add` calls start at `v`, so nothing tells them apart.
+    expect([...new Set(calls('store/use.go', 'Build'))]).toEqual(['41 store/store.go::Builder::Add']);
+  });
+
+  it('never links a namesake in another package or a same-file type', () => {
+    const decoys = [
+      ...cg!.getNodesInFile('alpha/alpha.go'),
+      ...cg!.getNodesInFile('store/use.go').filter((n) => n.qualifiedName.startsWith('sink::')),
+      ...cg!.getNodesInFile('pb/rpc_grpc.pb.go').filter((n) => n.qualifiedName.startsWith('UnimplementedKVServer::')),
+    ].filter((n) => n.kind === 'method');
+    expect(decoys.length).toBe(11);
+    for (const decoy of decoys) {
+      expect(cg!.getIncomingEdges(decoy.id).filter((e) => e.kind === 'calls' && e.provenance !== 'heuristic'), decoy.qualifiedName).toEqual([]);
+    }
+  });
+});
diff --git a/__tests__/go-type-doc-comments.test.ts b/__tests__/go-type-doc-comments.test.ts
new file mode 100644
index 0000000000..852c9a7938
--- /dev/null
+++ b/__tests__/go-type-doc-comments.test.ts
@@ -0,0 +1,220 @@
+/**
+ * A Go type declared on its own lost its doc comment in both extractors:
+ *
+ *   // Foo is documented.
+ *   type Foo struct{}
+ *
+ * tree-sitter-go wraps every type in a `type_declaration`, and the comment is
+ * that declaration's previous sibling. The node is made from the spec inside
+ * it (a `type_spec`, or a `type_alias` for `type A = B`), whose only
+ * predecessor is the `type` keyword, so the docstring walk found nothing. A
+ * type inside a `type ( … )` group kept its comment, which sits beside it in
+ * the parentheses.
+ *
+ * A declaration holding one spec is now read from outside, as go doc reads
+ * it. A group's leading comment stays the group's: it documents the group,
+ * not its first member.
+ *
+ * Reading from outside the declaration exposed a gap Go functions already
+ * had: a comment written after code on the line above (`const sides = 4 //
+ * sides of a square.`) belongs to that line, not to the declaration below
+ * it, and the docstring now starts after it.
+ *
+ * Runs against the native kernel (when built) and the wasm extractor, which
+ * must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+const SOURCE = `// Copyright 2026 The Shapes Authors.
+
+// Package shapes is documented.
+package shapes
+
+type Bare struct{}
+
+// Point is documented on its own.
+type Point struct{ X, Y int }
+
+// Shape is an interface documented on its own.
+type Shape interface {
+	Area() float64
+}
+
+// ID is a defined type documented on its own.
+type ID int
+
+// Set is a generic type documented on its own.
+type Set[T comparable] map[T]struct{}
+
+// Alias is an alias documented on its own.
+type Alias = Point
+
+/*
+Box is documented in a block comment.
+*/
+type Box struct{}
+
+// Kinds of shapes. The comment documents the group.
+type (
+	Circle struct{}
+
+	// Square is documented inside the group.
+	Square struct{}
+)
+
+// Lone is the only member of its group.
+type (
+	Lone int
+)
+
+// A group of one whose member has its own comment.
+type (
+	// Own is documented inside its group.
+	Own int
+)
+
+// Pair groups a type with its alias.
+type (
+	First  int
+	Second = First
+)
+
+type (
+	Celsius float64 // degrees C.
+	Kelvin  float64
+)
+
+// sides is documented above its line.
+const sides = 4 /* four */ // sides of a square.
+
+// Rect is documented below a constant's line.
+type Rect struct{}
+
+var origin = Point{} // the origin.
+type Polygon struct{}
+
+// Area is documented as before.
+func Area(s Shape) float64 { return s.Area() }
+
+// Norm is documented as before.
+func (p Point) Norm() int { return p.X } // Norm's line comment.
+func Next() int { return 0 }
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+describe('Go doc comments on types declared on their own', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['go']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', source: string): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource('shapes/shapes.go', source, 'go');
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract('shapes/shapes.go', source, 'go');
+    expect(result, 'kernel extraction').not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    it.each(backends)(`%s${crlf ? ' (CRLF)' : ''}`, (backend) => {
+      const result = extract(backend, crlf ? SOURCE.replace(/\n/g, '\r\n') : SOURCE);
+      const doc = (kind: string, name: string): string | null => {
+        const found = result.nodes.filter((n) => n.kind === kind && n.name === name);
+        expect(found, `${kind} ${name}`).toHaveLength(1);
+        return found[0].docstring ?? null;
+      };
+
+      expect({
+        // A type declared on its own takes the comment above `type`, and the
+        // file's header and package comment stay before the package clause.
+        Bare: doc('struct', 'Bare'),
+        Point: doc('struct', 'Point'),
+        Shape: doc('interface', 'Shape'),
+        ID: doc('type_alias', 'ID'),
+        Set: doc('type_alias', 'Set'),
+        Alias: doc('type_alias', 'Alias'),
+        Box: doc('struct', 'Box'),
+        // A group's comment is the group's; a member's own comment is found
+        // beside it. A group of one is that type's declaration, as in go doc,
+        // unless its member has a comment of its own.
+        Circle: doc('struct', 'Circle'),
+        Square: doc('struct', 'Square'),
+        Lone: doc('type_alias', 'Lone'),
+        Own: doc('type_alias', 'Own'),
+        // An alias is one of a group's members too.
+        First: doc('type_alias', 'First'),
+        Second: doc('type_alias', 'Second'),
+        // A comment after code is that line's, whatever comes below it.
+        Celsius: doc('type_alias', 'Celsius'),
+        Kelvin: doc('type_alias', 'Kelvin'),
+        sides: doc('constant', 'sides'),
+        Rect: doc('struct', 'Rect'),
+        Polygon: doc('struct', 'Polygon'),
+        Area: doc('function', 'Area'),
+        Norm: doc('method', 'Norm'),
+        Next: doc('function', 'Next'),
+      }).toEqual({
+        Bare: null,
+        Point: 'Point is documented on its own.',
+        Shape: 'Shape is an interface documented on its own.',
+        ID: 'ID is a defined type documented on its own.',
+        Set: 'Set is a generic type documented on its own.',
+        Alias: 'Alias is an alias documented on its own.',
+        Box: 'Box is documented in a block comment.',
+        Circle: null,
+        Square: 'Square is documented inside the group.',
+        Lone: 'Lone is the only member of its group.',
+        Own: 'Own is documented inside its group.',
+        First: null,
+        Second: null,
+        Celsius: null,
+        Kelvin: null,
+        sides: 'sides is documented above its line.',
+        Rect: "Rect is documented below a constant's line.",
+        Polygon: null,
+        Area: 'Area is documented as before.',
+        Norm: 'Norm is documented as before.',
+        Next: null,
+      });
+    });
+  }
+});
diff --git a/__tests__/go-type-position-kinds.test.ts b/__tests__/go-type-position-kinds.test.ts
new file mode 100644
index 0000000000..e7a0386ae1
--- /dev/null
+++ b/__tests__/go-type-position-kinds.test.ts
@@ -0,0 +1,245 @@
+/**
+ * A Go type position — a parameter or result type, a composite literal's
+ * type — names a type: a struct, an interface or a defined type, of the
+ * package Go reads the name from. Never a method or a function, which Go
+ * reaches only through a value or a package. Name matching took whatever
+ * declaration shared the name: etcd's
+ * `func (ti *treeIndex) KeyIndex(keyi *keyIndex) *keyIndex` linked both
+ * `keyIndex` types to the method `treeIndex.keyIndex` beside it, prometheus's
+ * `(ec2Client, error)` result to the method `EC2Discovery.ec2Client` it
+ * declares, every `samples{…}` literal to `sampleRing.samples`, and
+ * `&config_util.URL{…}` (an outside package) to `Target.URL`. A generic
+ * receiver's `[T]` declares `T` too: `func (p *Pool[T]) Get() T` returns the
+ * pool's own element type, not the method `Sample.T` of another package.
+ */
+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-go-type-pos-'));
+  const files: Record<string, string> = {
+    'go.mod': 'module example.com/app\n\ngo 1.22\n',
+    'mvcc/key_index.go': `package mvcc
+
+type keyIndex struct {
+	key []byte
+}
+
+type revisions []int64
+`,
+    'mvcc/index.go': `package mvcc
+
+type treeIndex struct {
+	tree map[string]*keyIndex
+}
+
+func (ti *treeIndex) KeyIndex(keyi *keyIndex) *keyIndex {
+	return ti.keyIndex(keyi)
+}
+
+func (ti *treeIndex) keyIndex(keyi *keyIndex) *keyIndex {
+	return &keyIndex{key: keyi.key}
+}
+
+func (ti *treeIndex) revisions() revisions {
+	return revisions{1, 2}
+}
+`,
+    'mvcc/watchable_store.go': `package mvcc
+
+type contains interface {
+	contains(rev int64) bool
+}
+
+func kvsToEvents(c contains, revs [][]byte) {}
+`,
+    'discovery/aws/ec2.go': `package aws
+
+import "context"
+
+type ec2Client interface {
+	DescribeInstances(ctx context.Context) error
+}
+
+type EC2Discovery struct {
+	client ec2Client
+}
+
+func (d *EC2Discovery) ec2Client(ctx context.Context) (ec2Client, error) {
+	return d.client, nil
+}
+`,
+    'util/zeropool/pool.go': `package zeropool
+
+type Pool[T any] struct {
+	items []T
+}
+
+func (p *Pool[T]) Get() T {
+	var zero T
+	return zero
+}
+
+func (p *Pool[T]) Put(item T) {}
+
+type LazyLoader[K comparable, V any] struct{}
+
+func (l *LazyLoader[K, V]) Load(key K) (V, error) {
+	var v V
+	return v, nil
+}
+`,
+    'prompb/types.pb.go': `package prompb
+
+type Histogram struct {
+	Count isHistogram_Count
+}
+
+type isHistogram_Count interface {
+	isHistogram_Count()
+}
+
+type Histogram_CountInt struct {
+	CountInt uint64
+}
+
+func (*Histogram_CountInt) isHistogram_Count() {}
+
+func (m *Histogram) GetCount() isHistogram_Count {
+	return m.Count
+}
+`,
+    'prompb/codec.go': `package prompb
+
+func FromIntHistogram(count uint64) Histogram {
+	return Histogram{
+		Count: &Histogram_CountInt{CountInt: count},
+	}
+}
+`,
+    'prompb/io/prometheus/write/v2/types.pb.go': `package writev2
+
+type Histogram_CountInt struct {
+	CountInt uint64
+}
+
+type Sample struct {
+	ts int64
+}
+
+func (s Sample) T() int64 { return s.ts }
+`,
+    'model/value/value.go': `package value
+
+type T struct{}
+
+type K struct{}
+`,
+    'storage/remote/client_test.go': `package remote
+
+import (
+	"testing"
+
+	config_util "github.com/prometheus/common/config"
+)
+
+type ClientConfig struct {
+	URL *config_util.URL
+}
+
+func TestStoreHTTPErrorHandling(t *testing.T) {
+	conf := &ClientConfig{
+		URL: &config_util.URL{URL: nil},
+	}
+	_ = conf
+}
+`,
+    'scrape/target.go': `package scrape
+
+type Target struct{}
+
+func (t *Target) URL() string { return "" }
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** The nodes of `file`, or the one named `from`. */
+const sourcesIn = (file: string, from?: string) => cg.getNodesInFile(file).filter((n) => !from || n.name === from);
+
+/**
+ * `kind file:qualifiedName` of each type-position edge (a `references` or an
+ * `instantiates`) out of `file`'s nodes whose target is named `name`,
+ * deduplicated and sorted.
+ */
+const typeLinksFrom = (file: string, name: string, from?: string) => {
+  const links = cg.getOutgoingEdgesFrom(sourcesIn(file, from).map((n) => n.id))
+    .filter((e) => e.kind === 'references' || e.kind === 'instantiates')
+    .map((e) => ({ kind: e.kind, target: cg.getNode(e.target)! }))
+    .filter(({ target }) => target.name === name)
+    .map(({ kind, target }) => `${kind} ${target.filePath}:${target.qualifiedName}`);
+  return [...new Set(links)].sort();
+};
+
+describe('A Go type position resolves to a type', () => {
+  it('an unexported parameter and result type is its package’s struct, not a method of that name', () => {
+    expect(typeLinksFrom('mvcc/index.go', 'keyIndex', 'KeyIndex')).toEqual(['references mvcc/key_index.go:keyIndex']);
+    expect(typeLinksFrom('mvcc/index.go', 'keyIndex', 'keyIndex')).toEqual([
+      'instantiates mvcc/key_index.go:keyIndex',
+      'references mvcc/key_index.go:keyIndex',
+    ]);
+  });
+
+  it('the method a call names stays a method', () => {
+    const calls = cg.getOutgoingEdgesFrom(sourcesIn('mvcc/index.go', 'KeyIndex').map((n) => n.id))
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(calls).toEqual(['treeIndex::keyIndex']);
+  });
+
+  it('a defined type in a result and a composite literal is that type', () => {
+    expect(typeLinksFrom('mvcc/index.go', 'revisions', 'revisions')).toEqual([
+      'instantiates mvcc/key_index.go:revisions',
+      'references mvcc/key_index.go:revisions',
+    ]);
+  });
+
+  it('an interface whose method shares its name is the interface', () => {
+    expect(typeLinksFrom('mvcc/watchable_store.go', 'contains', 'kvsToEvents')).toEqual(['references mvcc/watchable_store.go:contains']);
+    expect(typeLinksFrom('prompb/types.pb.go', 'isHistogram_Count', 'GetCount')).toEqual(['references prompb/types.pb.go:isHistogram_Count']);
+  });
+
+  it('a result type is the interface, not the method the line declares', () => {
+    expect(typeLinksFrom('discovery/aws/ec2.go', 'ec2Client', 'ec2Client')).toEqual(['references discovery/aws/ec2.go:ec2Client']);
+  });
+
+  it('a bare composite literal is its own package’s struct, not a namesake in another package', () => {
+    expect(typeLinksFrom('prompb/codec.go', 'Histogram_CountInt')).toEqual(['instantiates prompb/types.pb.go:Histogram_CountInt']);
+  });
+
+  it('a generic receiver’s type parameters are type parameters', () => {
+    expect(typeLinksFrom('util/zeropool/pool.go', 'T', 'Get')).toEqual([]);
+    expect(typeLinksFrom('util/zeropool/pool.go', 'T', 'Put')).toEqual([]);
+    expect(typeLinksFrom('util/zeropool/pool.go', 'K', 'Load')).toEqual([]);
+    expect(typeLinksFrom('util/zeropool/pool.go', 'V', 'Load')).toEqual([]);
+  });
+
+  it('a composite literal of an outside package’s type is no project method of that name', () => {
+    expect(typeLinksFrom('storage/remote/client_test.go', 'URL')).toEqual([]);
+  });
+});
diff --git a/__tests__/go-unexported-receiver.test.ts b/__tests__/go-unexported-receiver.test.ts
new file mode 100644
index 0000000000..dca097d928
--- /dev/null
+++ b/__tests__/go-unexported-receiver.test.ts
@@ -0,0 +1,140 @@
+/**
+ * Go calls through a method receiver of an unexported type (#2323).
+ *
+ * `func (s *server) Create()` is the idiomatic shape of gRPC and HTTP
+ * handlers, but only a PascalCase typed parameter used to give a receiver its
+ * type, so `s.service.AddItem()` — and every other call through `s` — lost its
+ * edge. Unexported names repeat across packages (each package may have its
+ * own `server`), so a receiver's type is its own package's: a same-named type
+ * elsewhere, with the same method or the same field, is never the target.
+ */
+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';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-unexported-recv-'));
+  const files: Record<string, string> = {
+    'go.mod': 'module example.com/app\n\ngo 1.22\n',
+    'internal/domain/service.go': `package domain
+
+type Service struct{}
+
+func (s *Service) AddItem(name string) error { return nil }
+
+func (s *Service) Count() int { return 0 }
+`,
+    // The issue's handler, plus calls on the receiver itself, through a type
+    // it embeds and through a field of an unexported type.
+    'internal/handlers/server.go': `package handlers
+
+import "example.com/app/internal/domain"
+
+type server struct {
+	BaseAPI
+	service *domain.Service
+	store   *store
+}
+
+func (s *server) Create(name string) error {
+	s.store.Put(name)
+	s.Close()
+	s.SendError()
+	return s.service.AddItem(name)
+}
+
+type cache[T any] struct {
+	service *domain.Service
+}
+
+func (c *cache[T]) Size() int {
+	return c.service.Count()
+}
+`,
+    'internal/handlers/store.go': `package handlers
+
+type store struct{}
+
+func (st *store) Put(name string) {}
+
+func (s *server) Close() {}
+`,
+    'internal/handlers/base.go': `package handlers
+
+type BaseAPI struct{}
+
+func (b *BaseAPI) SendError() {}
+`,
+    // Another package declaring the same unexported names: never a target.
+    'internal/admin/server.go': `package admin
+
+type server struct {
+	BaseAPI
+	store *store
+}
+
+type store struct{}
+
+func (st *store) Put(name string) {}
+
+func (s *server) Close() {}
+
+type BaseAPI struct{}
+
+func (b *BaseAPI) SendError() {}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `file::qualifiedName` of every symbol the function `name` in `file` calls. */
+function callTargets(file: string, name: string): string[] {
+  const fn = cg.getNodesInFile(file).find((n) => n.name === name);
+  expect(fn, `${name} in ${file}`).toBeDefined();
+  return cg
+    .getOutgoingEdges(fn!.id)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!)
+    .map((n) => `${n.filePath.replace(/\\/g, '/')}::${n.qualifiedName}`)
+    .sort();
+}
+
+describe('Go calls through an unexported method receiver (#2323)', () => {
+  it('resolves a call through a field of the receiver', () => {
+    expect(callTargets('internal/handlers/server.go', 'Create')).toContain(
+      'internal/domain/service.go::Service::AddItem'
+    );
+  });
+
+  it('resolves a generic receiver past its type parameters', () => {
+    expect(callTargets('internal/handlers/server.go', 'Size')).toEqual([
+      'internal/domain/service.go::Service::Count',
+    ]);
+  });
+
+  it("resolves every call within the receiver's own package, never a same-named type's in another", () => {
+    expect(callTargets('internal/handlers/server.go', 'Create')).toEqual([
+      'internal/domain/service.go::Service::AddItem',
+      'internal/handlers/base.go::BaseAPI::SendError',
+      'internal/handlers/store.go::server::Close',
+      'internal/handlers/store.go::store::Put',
+    ]);
+    for (const decoy of cg.getNodesInFile('internal/admin/server.go').filter((n) => n.kind === 'method')) {
+      expect(cg.getIncomingEdges(decoy.id).filter((e) => e.kind === 'calls'), decoy.qualifiedName).toEqual([]);
+    }
+  });
+});
diff --git a/__tests__/gradle-kts-dsl-calls.test.ts b/__tests__/gradle-kts-dsl-calls.test.ts
new file mode 100644
index 0000000000..62d34d5eee
--- /dev/null
+++ b/__tests__/gradle-kts-dsl-calls.test.ts
@@ -0,0 +1,67 @@
+/**
+ * A Gradle script's bare calls — `plugins { }`, `dependencies { }`,
+ * `api(projects.core)` — run on the build tool's own types, never on a class
+ * the project declares: nowinandroid's 110 such calls went to its build
+ * logic's `Graph.plugins()` / `Graph.dependencies()` and a lint registry's
+ * `api` property. Build logic's extension functions on Gradle's types stay.
+ */
+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-gradle-kts-'));
+  const files: Record<string, string> = {
+    'build-logic/src/main/kotlin/com/example/Graph.kt': `package com.example
+
+class Graph {
+    fun plugins(): List<String> = emptyList()
+    fun dependencies(): List<String> = emptyList()
+}
+`,
+    'build-support/src/main/kotlin/SourceSets.kt': `import org.gradle.api.NamedDomainObjectContainer
+
+fun NamedDomainObjectContainer<String>.createSourceSet(name: String) {
+}
+`,
+    'app/build.gradle.kts': `plugins {
+    id("com.android.application")
+}
+
+dependencies {
+    implementation(libs.core)
+}
+
+kotlin {
+    sourceSets {
+        createSourceSet("nonJvm")
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Gradle Kotlin script calls', () => {
+  it('never reach a member of a project class, but reach build-logic extensions', () => {
+    const ids = cg.getNodesInFile('app/build.gradle.kts').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.name);
+    expect(targets).not.toContain('plugins');
+    expect(targets).not.toContain('dependencies');
+    expect(targets).toContain('createSourceSet');
+  });
+});
diff --git a/__tests__/grammar-load-failure.test.ts b/__tests__/grammar-load-failure.test.ts
new file mode 100644
index 0000000000..1f285f0fd4
--- /dev/null
+++ b/__tests__/grammar-load-failure.test.ts
@@ -0,0 +1,167 @@
+/**
+ * A grammar that fails to load is an environment failure, not a parse result
+ * (#2335).
+ *
+ * A long-running daemon loads tree-sitter grammars lazily from its install
+ * directory. When an upgrade deletes that directory underneath it, every later
+ * grammar load fails (ENOENT) and the extractor answers `parser_error` with no
+ * nodes. That used to be STORED: the file's good symbols were replaced by a
+ * zero-node row carrying the new content hash, so `sync` never revisited it
+ * and `status` stayed green. Now nothing is stored for such a result — the
+ * file keeps its previous index data and the next sync or index retries it —
+ * and rows an older engine already wrote that way are re-indexed by `sync`.
+ *
+ * The failure is simulated at `getParser` (what a failed load leaves behind:
+ * no parser for the language), with the native kernel switched off so every
+ * file goes through the grammar path regardless of whether a kernel is built.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { CodeGraph } from '../src';
+import type { Language } from '../src/types';
+
+const { failing } = vi.hoisted(() => ({ failing: new Set<string>() }));
+
+vi.mock('../src/extraction/grammars', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../src/extraction/grammars')>();
+  return {
+    ...actual,
+    getParser: (language: Language) => (failing.has(language) ? null : actual.getParser(language)),
+  };
+});
+
+const MATH_TS =
+  'export function add(a: number, b: number): number {\n' +
+  '  return a + b;\n' +
+  '}\n' +
+  'export class Calculator {\n' +
+  '  total = 0;\n' +
+  '  plus(n: number): this { this.total = add(this.total, n); return this; }\n' +
+  '}\n';
+
+const VIEW_TS =
+  "import { Calculator } from './math';\n" +
+  'export function total(n: number): number {\n' +
+  '  return new Calculator().plus(n).total;\n' +
+  '}\n';
+
+const SUB_TS = '\nexport function sub(a: number, b: number): number {\n  return a - b;\n}\n';
+
+function names(cg: CodeGraph, file: string): string[] {
+  return cg.getNodesInFile(file).map((n) => n.name);
+}
+
+describe('grammar load failures are never stored (#2335)', () => {
+  let dir: string;
+  let cg: CodeGraph;
+  let kernelEnv: string | undefined;
+
+  beforeEach(() => {
+    kernelEnv = process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL = '0';
+    failing.clear();
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-grammar-load-failure-'));
+    fs.mkdirSync(path.join(dir, 'src'));
+    fs.writeFileSync(path.join(dir, 'src', 'math.ts'), MATH_TS);
+    fs.writeFileSync(path.join(dir, 'src', 'view.ts'), VIEW_TS);
+  });
+
+  afterEach(() => {
+    failing.clear();
+    cg?.destroy();
+    if (kernelEnv === undefined) delete process.env.CODEGRAPH_KERNEL;
+    else process.env.CODEGRAPH_KERNEL = kernelEnv;
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('sync keeps the previous symbols of a file whose grammar failed to load, then retries it', async () => {
+    cg = await CodeGraph.init(dir);
+    await cg.indexAll();
+    const before = cg.getFile('src/math.ts')!;
+    expect(before.nodeCount).toBeGreaterThan(1);
+    expect(names(cg, 'src/math.ts')).toEqual(expect.arrayContaining(['add', 'Calculator']));
+
+    // The upgrade removed the grammar; the watcher then re-indexes an edit.
+    failing.add('typescript');
+    fs.appendFileSync(path.join(dir, 'src', 'math.ts'), SUB_TS);
+    const failed = await cg.sync();
+
+    expect(failed.failedFilePaths).toContain('src/math.ts');
+    const kept = cg.getFile('src/math.ts')!;
+    expect(kept.nodeCount).toBe(before.nodeCount);
+    expect(kept.contentHash).toBe(before.contentHash);
+    expect(kept.errors ?? []).toEqual([]);
+    expect(names(cg, 'src/math.ts')).toEqual(expect.arrayContaining(['add', 'Calculator']));
+
+    // Grammar available again (a fresh process from the new install): the
+    // next sync sees the file as still changed and indexes the edit.
+    failing.clear();
+    const retried = await cg.sync();
+    expect(retried.filesModified).toBe(1);
+    expect(names(cg, 'src/math.ts')).toEqual(expect.arrayContaining(['add', 'Calculator', 'sub']));
+    expect(cg.getFile('src/math.ts')!.nodeCount).toBeGreaterThan(before.nodeCount);
+  });
+
+  it('a full index stores nothing for files whose grammar failed to load, and sync adds them later', async () => {
+    failing.add('typescript');
+    cg = await CodeGraph.init(dir);
+    const result = await cg.indexAll();
+
+    expect(result.filesErrored).toBe(2);
+    expect(result.errors.filter((e) => e.code === 'parser_error')).toHaveLength(2);
+    expect(cg.getFile('src/math.ts')).toBeNull();
+    expect(cg.getFile('src/view.ts')).toBeNull();
+
+    failing.clear();
+    const synced = await cg.sync();
+    expect(synced.filesAdded).toBe(2);
+    expect(names(cg, 'src/math.ts')).toEqual(expect.arrayContaining(['add', 'Calculator']));
+    expect(names(cg, 'src/view.ts')).toContain('total');
+  });
+
+  it('sync re-indexes rows an older engine stored while the grammar was missing', async () => {
+    cg = await CodeGraph.init(dir);
+    await cg.indexAll();
+    const before = cg.getFile('src/math.ts')!;
+
+    // What v1.6.2 wrote for a file it re-indexed with no grammar: no nodes,
+    // the parser error, and the CURRENT content hash — so a hash-based
+    // reconcile considers it up to date forever.
+    const db = (cg as unknown as { db: { getDb(): { prepare(sql: string): { run(...args: unknown[]): unknown } } } }).db.getDb();
+    db.prepare('DELETE FROM nodes WHERE file_path = ?').run('src/math.ts');
+    db.prepare('UPDATE files SET node_count = 0, errors = ? WHERE path = ?').run(
+      JSON.stringify([{ message: 'Failed to get parser for language: typescript', filePath: 'src/math.ts', severity: 'error', code: 'parser_error' }]),
+      'src/math.ts'
+    );
+    expect(cg.getFile('src/math.ts')!.nodeCount).toBe(0);
+
+    await cg.sync();
+
+    const healed = cg.getFile('src/math.ts')!;
+    expect(healed.nodeCount).toBe(before.nodeCount);
+    expect(healed.errors ?? []).toEqual([]);
+    expect(names(cg, 'src/math.ts')).toEqual(expect.arrayContaining(['add', 'Calculator']));
+  });
+
+  it('a component whose script grammar failed keeps its previous symbols too', async () => {
+    fs.writeFileSync(
+      path.join(dir, 'src', 'Counter.svelte'),
+      '<script lang="ts">\n  export let start = 0;\n  function increment(): void { start += 1; }\n</script>\n<button on:click={increment}>{start}</button>\n'
+    );
+    cg = await CodeGraph.init(dir);
+    await cg.indexAll();
+    const before = cg.getFile('src/Counter.svelte')!;
+    expect(names(cg, 'src/Counter.svelte')).toContain('increment');
+
+    failing.add('typescript');
+    fs.appendFileSync(path.join(dir, 'src', 'Counter.svelte'), '<p>edited</p>\n');
+    await cg.sync();
+
+    // The component node alone would have been stored before: the script's
+    // symbols gone, with a nonzero node count hiding it.
+    expect(cg.getFile('src/Counter.svelte')!.nodeCount).toBe(before.nodeCount);
+    expect(names(cg, 'src/Counter.svelte')).toContain('increment');
+  });
+});
diff --git a/__tests__/import-default-as.test.ts b/__tests__/import-default-as.test.ts
new file mode 100644
index 0000000000..a842d0e19c
--- /dev/null
+++ b/__tests__/import-default-as.test.ts
@@ -0,0 +1,253 @@
+/**
+ * `import { default as X } from './x'` is the module's default import, spelled
+ * as a named one. The import mapping recorded it as a named import of an
+ * export called `default`, which no module declares, so a call, a route or a
+ * JSX attribute naming `X` never resolved through the import. It fell through
+ * to matching the name alone, which can bind another file's `X`, and binds
+ * nothing (or a stranger) when the default export has a name of its own.
+ * bulletproof-react's router imports its app shell this way:
+ * `import { default as AppRoot, ErrorBoundary as AppRootErrorBoundary } from
+ * './routes/app/root'`.
+ */
+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';
+import { extractImportMappings } from '../src/resolution/import-resolver';
+import type { Edge } from '../src/types';
+
+const mappings = (source: string, language: Parameters<typeof extractImportMappings>[2] = 'tsx') =>
+  extractImportMappings('src/a.tsx', source, language).map(
+    (m) => `${m.localName}<${m.exportedName}${m.isDefault ? ' default' : ''}${m.isNamespace ? ' ns' : ''}`
+  );
+
+describe('`{ default as X }` maps to the default import', () => {
+  it('beside a named import, across lines, with a trailing comma', () => {
+    expect(mappings(`import {\n  default as AppRoot,\n  ErrorBoundary as AppRootErrorBoundary,\n} from './routes/app/root';\n`)).toEqual([
+      'AppRoot<default default',
+      'AppRootErrorBoundary<ErrorBoundary',
+    ]);
+  });
+
+  it('alone, type-only, and next to a default binding', () => {
+    expect(mappings(`import { default as Settings } from './settings';\n`)).toEqual(['Settings<default default']);
+    expect(mappings(`import type { default as Config } from './config';\n`)).toEqual(['Config<default default']);
+    expect(mappings(`import { type default as Config } from './config';\n`)).toEqual(['Config<default default']);
+    expect(mappings(`import Main, { default as Again, helper } from './main';\n`)).toEqual([
+      'Main<default default',
+      'Again<default default',
+      'helper<helper',
+    ]);
+  });
+
+  it('only for the export named exactly `default`', () => {
+    expect(mappings(`import { defaults as d, defaultTheme as theme } from './theme';\n`)).toEqual([
+      'd<defaults',
+      'theme<defaultTheme',
+    ]);
+  });
+
+  it('in a Svelte or Vue script block too', () => {
+    const sfc = `<script>\n  import { default as Card } from './Card.svelte';\n</script>\n\n<Card />\n`;
+    expect(mappings(sfc, 'svelte')).toEqual(['Card<default default']);
+    expect(mappings(sfc, 'vue')).toEqual(['Card<default default']);
+  });
+});
+
+describe('a symbol imported as `{ default as X }`', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-default-as-'));
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ name: 'web', dependencies: { react: '^18', 'react-router': '^7' } }),
+      // bulletproof-react's shape: the default export is a const declared
+      // above it, beside a named ErrorBoundary.
+      'src/app/routes/app/root.tsx': `import { Outlet } from 'react-router';
+
+export const ErrorBoundary = () => {
+  return <div>Something went wrong!</div>;
+};
+
+const AppRoot = () => {
+  return (
+    <main>
+      <Outlet />
+    </main>
+  );
+};
+
+export default AppRoot;
+`,
+      // A default export imported under a name that is not its own.
+      'src/app/routes/app/settings.tsx': `export default function SettingsRoute() {
+  return <section>settings</section>;
+}
+`,
+      'src/components/card.tsx': `import { memo } from 'react';
+
+const Card = memo(() => <div className="card" />);
+
+export default Card;
+`,
+      'src/components/layout.tsx': `export function Layout({ sidebar, children }: { sidebar: unknown; children: unknown }) {
+  return <div>{children}</div>;
+}
+`,
+      // Other symbols with the importing file's local names. Matching by name
+      // alone can only choose between these and the real targets.
+      'src/app/legacy.tsx': `export function AppRoot() {
+  return <div>legacy shell</div>;
+}
+
+export function Settings() {
+  return <div>legacy settings</div>;
+}
+`,
+      'src/app/router.tsx': `import { createBrowserRouter } from 'react-router';
+
+import {
+  default as AppRoot,
+  ErrorBoundary as AppRootErrorBoundary,
+} from './routes/app/root';
+import { default as Settings } from './routes/app/settings';
+
+export const createAppRouter = () =>
+  createBrowserRouter([
+    {
+      path: '/app',
+      element: <AppRoot />,
+      ErrorBoundary: AppRootErrorBoundary,
+      children: [{ path: 'settings', Component: Settings }],
+    },
+  ]);
+
+export function renderShell() {
+  return AppRoot();
+}
+`,
+      'src/app/AppRoutes.tsx': `import { Routes, Route } from 'react-router';
+
+import { Layout } from '../components/layout';
+import { default as Settings } from './routes/app/settings';
+import { default as Tile } from '../components/card';
+
+export function AppRoutes() {
+  return (
+    <Routes>
+      <Route path="/preferences" element={<Settings />} />
+    </Routes>
+  );
+}
+
+export function Gallery() {
+  return (
+    <Layout sidebar={Settings}>
+      <Tile />
+    </Layout>
+  );
+}
+`,
+    };
+    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 });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const node = (file: string, name: string) => {
+    const found = cg.getNodesInFile(file).find((n) => n.name === name && n.kind !== 'import');
+    expect(found, `${file}: ${name}`).toBeDefined();
+    return found!;
+  };
+  /** The edges into `target`, as `kind source-name resolvedBy`. */
+  const into = (target: { id: string }, kinds: Edge['kind'][]) =>
+    cg
+      .getIncomingEdges(target.id)
+      .filter((e) => kinds.includes(e.kind))
+      .map((e) => {
+        const meta = (e.metadata ?? {}) as { resolvedBy?: string; synthesizedBy?: string };
+        return `${e.kind} ${cg.getNode(e.source)!.name} ${meta.resolvedBy ?? meta.synthesizedBy}`;
+      })
+      .sort();
+  const route = (name: string) => {
+    const found = cg.getNodesByKind('route').find((r) => r.name === name);
+    expect(found, `route ${name}`).toBeDefined();
+    return found!;
+  };
+  const renders = (name: string) =>
+    cg
+      .getOutgoingEdges(route(name).id)
+      .filter((e) => e.kind === 'references')
+      .map((e) => {
+        const target = cg.getNode(e.target)!;
+        return `${target.filePath}:${target.name} ${(e.metadata as { resolvedBy?: string }).resolvedBy}`;
+      })
+      .sort();
+
+  it('a call reaches the module’s default export through the import', () => {
+    expect(into(node('src/app/routes/app/root.tsx', 'AppRoot'), ['calls'])).toEqual([
+      'calls createAppRouter jsx-render',
+      'calls renderShell import',
+    ]);
+    expect(into(node('src/app/legacy.tsx', 'AppRoot'), ['calls', 'references'])).toEqual([]);
+  });
+
+  it('a data router’s `element` and `Component` render the default exports', () => {
+    expect(renders('/app')).toEqual(['src/app/routes/app/root.tsx:AppRoot import']);
+    // A child route renders inside its parent's element, its layout.
+    expect(renders('/app/settings')).toEqual([
+      'src/app/routes/app/root.tsx:AppRoot framework',
+      'src/app/routes/app/settings.tsx:SettingsRoute import',
+    ]);
+  });
+
+  it('a JSX route and a JSX attribute name the default export', () => {
+    expect(renders('/preferences')).toEqual(['src/app/routes/app/settings.tsx:SettingsRoute import']);
+    // The router's `Component: Settings` is a function reference as well.
+    expect(into(node('src/app/routes/app/settings.tsx', 'SettingsRoute'), ['references'])).toEqual([
+      'references /app/settings import',
+      'references /preferences import',
+      'references Gallery import',
+      'references createAppRouter import',
+    ]);
+    expect(into(node('src/app/legacy.tsx', 'Settings'), ['references'])).toEqual([]);
+  });
+
+  it('a JSX tag renders the default-exported component it was imported as', () => {
+    expect(into(node('src/components/card.tsx', 'Card'), ['calls'])).toEqual(['calls Gallery jsx-render']);
+  });
+
+  it('the named import beside it is unchanged', () => {
+    expect(into(node('src/app/routes/app/root.tsx', 'ErrorBoundary'), ['references'])).toEqual([
+      'references createAppRouter import',
+    ]);
+  });
+
+  it('the import binding links the module, as a default import’s does', () => {
+    const file = cg.getNodesInFile('src/app/router.tsx').find((n) => n.kind === 'file')!;
+    const bindings = cg
+      .getOutgoingEdges(file.id)
+      .filter((e) => e.kind === 'imports')
+      .map((e) => {
+        const meta = e.metadata as { refName?: string; resolvedBy?: string };
+        const target = cg.getNode(e.target)!;
+        return `${meta.refName} → ${target.kind} ${target.filePath} ${meta.resolvedBy}`;
+      })
+      .filter((s) => !s.startsWith('.'))
+      .sort();
+    expect(bindings).toEqual([
+      'AppRoot → file src/app/routes/app/root.tsx import',
+      'AppRootErrorBoundary → function src/app/routes/app/root.tsx import',
+      'Settings → file src/app/routes/app/settings.tsx import',
+    ]);
+  });
+});
diff --git a/__tests__/import-type-modifier.test.ts b/__tests__/import-type-modifier.test.ts
new file mode 100644
index 0000000000..16b5c895bc
--- /dev/null
+++ b/__tests__/import-type-modifier.test.ts
@@ -0,0 +1,163 @@
+/**
+ * TypeScript's `type` modifiers are not bindings.
+ *
+ * `import type { X } from './x'` used to read as a default import named
+ * `type` beside `X` — every type-only import line bound `type` — so zod's
+ * `type.innerType()` (a parameter named `type`) was taken for a call on an
+ * import. An inline `{ util, type objectUtil }` named its binding
+ * `type objectUtil`.
+ *
+ * A binding is any JS identifier, `$` included. The import regexes matched
+ * names with `\w`, which stops at a `$`: `import items$ from './store'` and
+ * `import * as ns$` yielded no binding at all, and `{ a as b$ }` bound `b`.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { extractImportMappings, extractReExports } from '../src/resolution/import-resolver';
+
+const bindings = (source: string) =>
+  extractImportMappings('src/a.ts', source, 'typescript').map((m) => `${m.localName}<${m.exportedName}${m.isNamespace ? ' ns' : ''}`);
+
+describe('import mappings and TypeScript type modifiers', () => {
+  it('a type-only import binds its names, never `type`', () => {
+    expect(bindings(`import type { enumUtil } from './helpers/enumUtil.js';\n`)).toEqual(['enumUtil<enumUtil']);
+    expect(bindings(`import type * as z from './z';\n`)).toEqual(['z<* ns']);
+    expect(bindings(`import type Foo from './foo';\n`)).toEqual(['Foo<default']);
+  });
+
+  it('an inline `type` modifier is not part of the name', () => {
+    expect(bindings(`import { util, type objectUtil } from './helpers/util.js';\n`)).toEqual(['util<util', 'objectUtil<objectUtil']);
+    expect(bindings(`import { type A as B } from './ab';\n`)).toEqual(['B<A']);
+  });
+
+  it('a default import that is named `type` is still one', () => {
+    expect(bindings(`import type from './type';\n`)).toEqual(['type<default']);
+  });
+});
+
+describe('import bindings whose names contain `$`', () => {
+  it('default, namespace and mixed imports bind the whole name', () => {
+    expect(bindings(`import items$ from './store';\n`)).toEqual(['items$<default']);
+    expect(bindings(`import $store from './store';\n`)).toEqual(['$store<default']);
+    expect(bindings(`import * as ns$ from './ns';\n`)).toEqual(['ns$<* ns']);
+    expect(bindings(`import $, { ajax } from 'jquery';\n`)).toEqual(['$<default', 'ajax<ajax']);
+    expect(bindings(`import dflt$, * as $ns from './both';\n`)).toEqual(['dflt$<default', '$ns<* ns']);
+  });
+
+  it('aliased and type-only imports bind the whole name', () => {
+    expect(bindings(`import { a$ as b$, a as $b, default as items$ } from './ab';\n`)).toEqual(['b$<a$', '$b<a', 'items$<default']);
+    expect(bindings(`import type $T from './t';\n`)).toEqual(['$T<default']);
+    expect(bindings(`import { type $T, type U$ as V$ } from './t';\n`)).toEqual(['$T<$T', 'V$<U$']);
+    // `from$` is a name, not the `from` that ends a bare `import type from …`.
+    expect(bindings(`import type from$ from './t';\n`)).toEqual(['from$<default']);
+  });
+
+  it("a code generator's `${…}` is no binding", () => {
+    expect(bindings("const code = `import ${name} from '${src}'`;\n")).toEqual([]);
+    expect(bindings("const code = `import type ${name} from '${src}'`;\n")).toEqual([]);
+  });
+
+  it('a CommonJS destructuring binds the whole name', () => {
+    expect(bindings(`const { a$: b$, a: $c, d$ } = require('./r');\n`)).toEqual(['b$<a$', '$c<a', 'd$<d$']);
+  });
+
+  it('a re-export names the whole name', () => {
+    expect(extractReExports(`export { a$, $b as c$, default as $store } from './x';\n`, 'typescript')).toEqual([
+      { kind: 'named', exportedName: 'a$', originalName: 'a$', source: './x' },
+      { kind: 'named', exportedName: 'c$', originalName: '$b', source: './x' },
+      { kind: 'named', exportedName: '$store', originalName: 'default', source: './x' },
+    ]);
+  });
+});
+
+describe('a `$` binding imported from another file', () => {
+  const roots: string[] = [];
+  afterAll(() => {
+    for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+  });
+
+  it('`items$.getState().inc()` reaches the store action unless a local or parameter shadows `items$`', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-import-dollar-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ name: 'shop', dependencies: { zustand: '*' } }),
+      'src/store.ts': `import { create } from 'zustand';
+
+const items$ = create((set) => ({ inc: () => set({}) }));
+export default items$;
+`,
+      'src/util.ts': `export function helper() { return 1; }
+`,
+      'src/decoy.ts': `export function helper() { return 2; }
+`,
+      'src/use.ts': `import items$ from './store';
+import * as util$ from './util';
+
+export function clickInc() { items$.getState().inc(); }
+export function shadowed() { const items$ = other(); items$.getState().inc(); }
+export function param(items$: Store) { items$.getState().inc(); }
+export function run() { return util$.helper(); }
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const callers = (file: string, name: string) => {
+        const target = cg.getNodesInFile(file).find((n) => n.kind === 'function' && n.name === name);
+        expect(target, `${file}: ${name}`).toBeDefined();
+        return cg.getCallers(target!.id).filter((c) => c.edge.kind === 'calls').map((c) => c.node.name).sort();
+      };
+      expect(callers('src/store.ts', 'inc')).toEqual(['clickInc']);
+      expect(callers('src/util.ts', 'helper')).toEqual(['run']);
+      expect(callers('src/decoy.ts', 'helper')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('a name imported from a package names nothing in the project', () => {
+  const roots: string[] = [];
+  afterAll(() => {
+    for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+  });
+
+  it('halo: `type RsbuildConfig` and `type Command` are not a local `rsbuildConfig` or `command`', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-import-type-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ name: 'console', dependencies: { '@rsbuild/core': '*', '@tiptap/core': '*' } }),
+      'src/rsbuild.ts': `import { defineConfig, type RsbuildConfig } from '@rsbuild/core';
+export function rsbuildConfig(): RsbuildConfig { return defineConfig({}); }
+`,
+      'src/menu.ts': `export function command() { return 1; }
+`,
+      'src/gap.ts': `import type { Command } from '@tiptap/core';
+export function gapCursor(): Command { return () => true; }
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const targets = (file: string) =>
+        cg
+          .getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id), ['references', 'imports', 'type_of', 'returns'])
+          .map((e) => cg.getNode(e.target)!)
+          .filter((n) => n.kind !== 'file' && n.kind !== 'import')
+          .map((n) => n.name);
+      expect(targets('src/rsbuild.ts')).not.toContain('rsbuildConfig');
+      expect(targets('src/gap.ts')).not.toContain('command');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/inherited-class-method.test.ts b/__tests__/inherited-class-method.test.ts
new file mode 100644
index 0000000000..317cb6c6a2
--- /dev/null
+++ b/__tests__/inherited-class-method.test.ts
@@ -0,0 +1,130 @@
+/**
+ * A call through a class name reaches a class method the class inherits,
+ * read from its own and its ancestors' declaration heads, before any guess by
+ * name: Horse's `THorse.Get('/ping', …)` is THorseCore's (three `class(…)`
+ * heads up), not a route-group interface's `Get`; DRF's `MyView.as_view()` is
+ * APIView's; netbox's `ColorChoices.values()` is ChoiceSet's.
+ */
+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-inherited-class-method-'));
+  const files: Record<string, string> = {
+    'src/Horse.Core.pas': `unit Horse.Core;
+
+interface
+
+type
+  THorseCore = class
+  public
+    class function Get(const APath: string): THorseCore;
+  end;
+
+implementation
+
+class function THorseCore.Get(const APath: string): THorseCore;
+begin
+  Result := nil;
+end;
+
+end.
+`,
+    'src/Horse.Core.Group.pas': `unit Horse.Core.Group;
+
+interface
+
+type
+  IHorseCoreGroup = interface
+    function Get(const APath: string): IHorseCoreGroup;
+  end;
+
+implementation
+
+end.
+`,
+    'src/Horse.pas': `unit Horse;
+
+interface
+
+uses Horse.Core;
+
+type
+  THorseProvider = class(THorseCore)
+  end;
+
+  THorse = class(THorseProvider)
+  end;
+
+implementation
+
+end.
+`,
+    'samples/Console.dpr': `program Console;
+
+uses Horse;
+
+begin
+  THorse.Get('/ping');
+end.
+`,
+    'app/views.py': `class APIView:
+    @classmethod
+    def as_view(cls):
+        return cls
+
+
+class GenericAPIView(APIView):
+    pass
+
+
+class UserList(GenericAPIView):
+    pass
+
+
+class Router:
+    def as_view(self):
+        return None
+`,
+    'app/urls.py': `from app.views import UserList
+
+urlpatterns = [UserList.as_view()]
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('a class method reached through a subclass name', () => {
+  it('Pascal: walks the class(…) heads', () => {
+    expect(callsFrom('samples/Console.dpr').filter((q) => q.endsWith('Get'))).toEqual(['THorseCore::Get']);
+  });
+
+  it('Python: walks the class bases', () => {
+    expect(callsFrom('app/urls.py')).toEqual(['APIView::as_view']);
+  });
+});
diff --git a/__tests__/integration/full-pipeline.test.ts b/__tests__/integration/full-pipeline.test.ts
index 5b551c136c..857937d0c8 100644
--- a/__tests__/integration/full-pipeline.test.ts
+++ b/__tests__/integration/full-pipeline.test.ts
@@ -15,7 +15,7 @@
  * crawl).
  */
 
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -269,4 +269,53 @@ describe('Integration: full pipeline', () => {
       cg.destroy();
     }
   }, 30_000);
+
+  it('reports durationMs for the whole run, resolution and linking included (#2334)', async () => {
+    // The CLI summary printed the orchestrator's time — extraction alone —
+    // beside the totals of the whole run, so slow resolution never showed.
+    generateSyntheticProject(tempDir, 10);
+    const cg = await CodeGraph.init(tempDir, {
+      config: { include: ['**/*.ts'], exclude: [] },
+    });
+    const internals = cg as unknown as {
+      orchestrator: Record<'indexAll' | 'sync', (...args: unknown[]) => Promise<{ durationMs: number }>>;
+      resolver: { resolveDeferredThisMemberRefs: () => Promise<number> };
+    };
+    // What the orchestrator measured; and a linking pass that takes a known while.
+    let extraction = -1;
+    const measure = (method: 'indexAll' | 'sync') => {
+      const original = internals.orchestrator[method].bind(internals.orchestrator);
+      vi.spyOn(internals.orchestrator, method).mockImplementation(async (...args: unknown[]) => {
+        const result = await original(...args);
+        extraction = result.durationMs;
+        return result;
+      });
+    };
+    const LINKING_MS = 250;
+    const linking = internals.resolver.resolveDeferredThisMemberRefs.bind(internals.resolver);
+    vi.spyOn(internals.resolver, 'resolveDeferredThisMemberRefs').mockImplementation(async () => {
+      const until = Date.now() + LINKING_MS;
+      while (Date.now() < until) await new Promise((r) => setTimeout(r, 10));
+      return linking();
+    });
+
+    try {
+      measure('indexAll');
+      const indexed = await cg.indexAll();
+      expect(extraction).toBeGreaterThanOrEqual(0);
+      expect(indexed.durationMs).toBeGreaterThanOrEqual(extraction + LINKING_MS);
+
+      // Likewise a sync that re-resolves a changed file.
+      fs.appendFileSync(path.join(tempDir, 'src', 'index.ts'), 'export function again(): number { return entry(); }\n');
+      extraction = -1;
+      measure('sync');
+      const synced = await cg.sync();
+      expect(synced.filesModified).toBe(1);
+      expect(extraction).toBeGreaterThanOrEqual(0);
+      expect(synced.durationMs).toBeGreaterThanOrEqual(extraction + LINKING_MS);
+    } finally {
+      vi.restoreAllMocks();
+      cg.destroy();
+    }
+  }, 30_000);
 });
diff --git a/__tests__/is-test-file.test.ts b/__tests__/is-test-file.test.ts
index a24e48962a..08b67e7d48 100644
--- a/__tests__/is-test-file.test.ts
+++ b/__tests__/is-test-file.test.ts
@@ -10,7 +10,7 @@
  * `manifest.kt` / a `RealCall.kt` production file must NOT be flagged.
  */
 import { describe, it, expect } from 'vitest';
-import { isTestFile } from '../src/search/query-utils';
+import { isTestFile, isTestPath } from '../src/search/query-utils';
 
 describe('isTestFile', () => {
   it('flags test-support modules and doubles by directory name', () => {
@@ -56,6 +56,30 @@ describe('isTestFile', () => {
     expect(isTestFile('project/tests/foo.rb')).toBe(true);
   });
 
+  it("flags Google's unittest-named files as tests", () => {
+    // protobuf's 62 and Chromium's: `wire_format_unittest.cc` is a suite, not
+    // the code it tests, even with no `test/` directory above it.
+    for (const suite of [
+      'src/google/protobuf/wire_format_unittest.cc',
+      'src/google/protobuf/wire_format_unittest.h',
+      'src/compiler/register-allocator-unittest.cpp',
+      'lib/parser.unittest.js',
+      'tools/run_all_unittests.cc',
+      'build/android/pylib/device_unittest.py',
+    ]) {
+      expect(isTestPath(suite), suite).toBe(true);
+      expect(isTestFile(suite), suite).toBe(true);
+    }
+  });
+
+  it('does NOT flag a file merely named unittest', () => {
+    // promtool's `unittest.go` is the code that runs rule tests, and
+    // CPython's `unittest` package is the framework itself.
+    expect(isTestPath('cmd/promtool/unittest.go')).toBe(false);
+    expect(isTestPath('Lib/unittest/case.py')).toBe(false);
+    expect(isTestFile('cmd/promtool/unittest.go')).toBe(false);
+  });
+
   it('does NOT flag production files that merely contain "test" lowercase', () => {
     // The fix is capital-led so camelCase boundaries distinguish these.
     expect(isTestFile('src/latest/loader.kt')).toBe(false);
diff --git a/__tests__/java-bare-call-scope.test.ts b/__tests__/java-bare-call-scope.test.ts
new file mode 100644
index 0000000000..23c8fa190c
--- /dev/null
+++ b/__tests__/java-bare-call-scope.test.ts
@@ -0,0 +1,74 @@
+/**
+ * A bare Java call reaches a method of a class around it, a supertype of that
+ * class, or a static import — not another class's method that shares the name.
+ * halo's Mockito `verify(…)` bound 1,038 calls to `EmailVerificationService.verify`.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+const FILES: Record<string, string> = {
+  'src/main/java/app/EmailVerificationService.java': `package app;
+public class EmailVerificationService {
+  public boolean verify(String token) { return true; }
+}
+`,
+  'src/main/java/app/Util.java': `package app;
+public class Util {
+  public static String format(String s) { return s; }
+}
+`,
+  'src/main/java/app/Base.java': `package app;
+public class Base {
+  protected void helper() {}
+}
+`,
+  'src/main/java/app/Child.java': `package app;
+import static app.Util.format;
+public class Child extends Base {
+  public void run() {
+    helper();
+    format("x");
+    own();
+  }
+  private void own() {}
+}
+`,
+  'src/test/java/app/ChildTest.java': `package app;
+import static org.mockito.Mockito.verify;
+public class ChildTest {
+  public void sends(Object mock) {
+    verify(mock);
+  }
+}
+`,
+};
+
+describe('Java: a bare call reaches what is in scope', () => {
+  it('own class, a supertype, a static import — not a same-named method elsewhere', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-java-bare-'));
+    roots.push(root);
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const callsFrom = (name: string): string[] => {
+        const from = cg.getNodesByName(name).find((n) => n.kind === 'method')!;
+        return cg.getOutgoingEdgesFrom([from.id], ['calls']).map((e) => cg.getNode(e.target)!.name).sort();
+      };
+      expect(callsFrom('sends')).not.toContain('verify');
+      expect(callsFrom('run')).toEqual(['format', 'helper', 'own']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/java-declared-receiver.test.ts b/__tests__/java-declared-receiver.test.ts
new file mode 100644
index 0000000000..fd9978d579
--- /dev/null
+++ b/__tests__/java-declared-receiver.test.ts
@@ -0,0 +1,135 @@
+/**
+ * A Java receiver's declared type is read through generics and for-each
+ * loops (`final Pair<L, R> pair`, `for (Element el : this)`), from a field of
+ * the class (`private DateFormat dateTimeParser;` — outside the project, so
+ * no edge), or as the bound of a type parameter (`T extends ExceptionContext`).
+ * A constant's receiver is its type (`Phase.CONTROLLERS.getPhase()`). None of
+ * these fall back to a same-named method of some other project class:
+ * commons-lang's `dateTimeParser.parse(…)` went to its own `DateParser.parse`
+ * 284 times.
+ */
+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-java-receiver-'));
+  const files: Record<string, string> = {
+    'src/main/java/app/Pair.java': `package app;
+
+public abstract class Pair<L, R> {
+    public abstract L getKey();
+}
+`,
+    'src/main/java/app/MutablePair.java': `package app;
+
+public class MutablePair<L, R> extends Pair<L, R> {
+    private L left;
+
+    public L getKey() { return left; }
+
+    /**
+     * Copies the key of each element into this pair.
+     */
+    public void setValue(final Pair<L, R> pair) {
+        left = pair.getKey();
+    }
+}
+`,
+    'src/main/java/app/DateParser.java': `package app;
+
+public interface DateParser {
+    Object parse(String source);
+}
+`,
+    'src/main/java/app/Element.java': `package app;
+
+public class Element {
+    public void val(String value) { }
+}
+`,
+    'src/main/java/app/Elements.java': `package app;
+
+import java.util.ArrayList;
+
+public class Elements extends ArrayList<Element> {
+    public Elements val(String value) {
+        for (Element element : this)
+            element.val(value);
+        return this;
+    }
+}
+`,
+    'src/main/java/app/Phase.java': `package app;
+
+public enum Phase {
+    CONTROLLERS;
+
+    public int getPhase() { return 0; }
+}
+`,
+    'src/main/java/app/ExceptionContext.java': `package app;
+
+public interface ExceptionContext {
+    int getContextEntries();
+}
+`,
+    'src/test/java/app/DateUtilsTest.java': `package app;
+
+import java.text.DateFormat;
+
+public abstract class DateUtilsTest<T extends ExceptionContext> {
+    private DateFormat dateTimeParser;
+    protected T exceptionContext;
+
+    void rounds() throws Exception {
+        dateTimeParser.parse("January 1, 2008");
+        exceptionContext.getContextEntries();
+        Phase.CONTROLLERS.getPhase();
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('Java calls through declared receivers', () => {
+  it('read a generic parameter’s type', () => {
+    expect(callsFrom('src/main/java/app/MutablePair.java')).toEqual(['app::Pair::getKey']);
+  });
+
+  it('read a for-each variable’s type', () => {
+    expect(callsFrom('src/main/java/app/Elements.java')).toEqual(['app::Element::val']);
+  });
+
+  it('follow a field’s type, a type parameter’s bound and a constant’s type — and stop at an outside type', () => {
+    expect(callsFrom('src/test/java/app/DateUtilsTest.java')).toEqual([
+      'app::ExceptionContext::getContextEntries',
+      'app::Phase::getPhase',
+    ]);
+  });
+});
diff --git a/__tests__/java-outside-imports.test.ts b/__tests__/java-outside-imports.test.ts
new file mode 100644
index 0000000000..00a53d4a5d
--- /dev/null
+++ b/__tests__/java-outside-imports.test.ts
@@ -0,0 +1,123 @@
+/**
+ * A Java single-type import names the class it imports: after
+ * `import java.lang.reflect.Field;` the file's `Field` is the JDK's — gson's
+ * production code bound it to a test's nested `ParameterizedTypesTest.Field`,
+ * jsoup's W3C converter (`import org.w3c.dom.Document;`) to jsoup's own
+ * `Document`. A static import (`import static org.junit.Assert.assertEquals;`)
+ * likewise owns its name. Imports of the project's own classes — nested ones
+ * included — resolve as before. Kotlin imports (no `;`, optional `as`) are read
+ * the same way; a member the file itself declares still comes first.
+ */
+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-java-imports-'));
+  const files: Record<string, string> = {
+    'src/test/java/app/functional/TypesTest.java': `package app.functional;
+
+public class TypesTest {
+  static class Field {
+    String name;
+  }
+
+  static void assertEquals(Object a, Object b) { }
+}
+`,
+    'src/main/java/app/model/Outer.java': `package app.model;
+
+public class Outer {
+  public static class Inner {
+    public static Inner create() { return new Inner(); }
+  }
+}
+`,
+    'src/main/java/app/Reflect.java': `package app;
+
+import java.lang.reflect.Field;
+import app.model.Outer;
+import app.model.Outer.Inner;
+
+public class Reflect {
+  String nameOf(Field field) {
+    return field.getName();
+  }
+
+  Outer.Inner make() {
+    return Inner.create();
+  }
+}
+`,
+    'src/main/kotlin/app/Dates.kt': `package app
+
+import java.lang.reflect.Field
+import kotlinx.datetime.toLocalDateTime
+import app.model.Outer.Inner as Made
+
+class Dates {
+    private fun toLocalDateTime(value: Long): Long = value
+
+    fun parse(value: Long, field: Field): Long {
+        field.getName()
+        Made.create()
+        return toLocalDateTime(value)
+    }
+}
+`,
+    'src/test/java/app/ReflectTest.java': `package app;
+
+import static org.junit.Assert.assertEquals;
+
+public class ReflectTest {
+  void names() {
+    assertEquals("a", "a");
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `kind qualified-name` of every non-structural edge out of a file. */
+function edgesFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind !== 'contains' && e.kind !== 'imports')
+    .map((e) => `${e.kind} ${cg.getNode(e.target)!.qualifiedName}`)
+    .sort();
+}
+
+describe('Java single-type and static imports from outside the project', () => {
+  it('own their names; the project’s own imports still resolve', () => {
+    const edges = edgesFrom('src/main/java/app/Reflect.java');
+    expect(edges).not.toContain('references app.functional::TypesTest::Field');
+    expect(edges).toContain('calls app.model::Outer::Inner::create');
+  });
+
+  it('Kotlin: an outside import owns its name, but a member the file declares comes first; `as` aliases bind', () => {
+    const edges = edgesFrom('src/main/kotlin/app/Dates.kt');
+    expect(edges).not.toContain('references app.functional::TypesTest::Field');
+    expect(edges).toContain('calls app::Dates::toLocalDateTime');
+    expect(edges).toContain('calls app.model::Outer::Inner::create');
+  });
+
+  it('a static import’s method is not a project method of that name', () => {
+    expect(edgesFrom('src/test/java/app/ReflectTest.java')).not.toContain('calls app.functional::TypesTest::assertEquals');
+  });
+});
diff --git a/__tests__/java-type-name-visibility.test.ts b/__tests__/java-type-name-visibility.test.ts
new file mode 100644
index 0000000000..e83a29d810
--- /dev/null
+++ b/__tests__/java-type-name-visibility.test.ts
@@ -0,0 +1,106 @@
+/**
+ * A bare Java type name is its package's type, an import's, or a nested type
+ * in reach — inside its owner, a type deriving from it (an anonymous
+ * `new NodeFilter() { … }` included), or written through its owner
+ * (`new Retrofit.Builder()`). retrofit's `new Retrofit.Builder()` went to
+ * `RequestFactory.Builder`, halo's micrometer `Counter` to its own
+ * `core.extension.Counter`, and a constructor never stands in for its type.
+ */
+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-java-vis-'));
+  const files: Record<string, string> = {
+    'src/main/java/retrofit2/RequestFactory.java': `package retrofit2;
+
+final class RequestFactory {
+  static final class Builder {
+    Builder() { }
+  }
+}
+`,
+    'src/main/java/retrofit2/Retrofit.java': `package retrofit2;
+
+public final class Retrofit {
+  public static final class Builder {
+    public Builder() { }
+  }
+}
+`,
+    'src/test/java/retrofit2/CallTest.java': `package retrofit2;
+
+class CallTest {
+  Object make() {
+    return new Retrofit.Builder();
+  }
+}
+`,
+    'src/main/java/run/halo/core/extension/Counter.java': `package run.halo.core.extension;
+
+public class Counter { }
+`,
+    'src/main/java/run/halo/core/counter/MeterUtils.java': `package run.halo.core.counter;
+
+import io.micrometer.core.instrument.Counter;
+
+class MeterUtils {
+  static Counter counter() { return null; }
+}
+`,
+    'src/main/java/org/jsoup/select/NodeFilter.java': `package org.jsoup.select;
+
+public interface NodeFilter {
+  enum FilterResult { CONTINUE }
+  FilterResult head(Object node);
+}
+`,
+    'src/test/java/org/jsoup/select/TraversorTest.java': `package org.jsoup.select;
+
+class TraversorTest {
+  void filter() {
+    run(new NodeFilter() {
+      public FilterResult head(Object node) { return null; }
+    });
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('bare Java type names', () => {
+  it('written through their owner are that owner’s nested type, never a constructor', () => {
+    const targets = targetsFrom('src/test/java/retrofit2/CallTest.java');
+    expect(targets).toContain('retrofit2::Retrofit::Builder');
+    expect(targets.filter((t) => t.startsWith('retrofit2::RequestFactory') || t.endsWith('::Builder::Builder'))).toEqual([]);
+  });
+
+  it('imported from a library are nothing in the project', () => {
+    expect(targetsFrom('src/main/java/run/halo/core/counter/MeterUtils.java')).not.toContain('run.halo.core.extension::Counter');
+  });
+
+  it('reach a nested type of what an anonymous class implements', () => {
+    expect(targetsFrom('src/test/java/org/jsoup/select/TraversorTest.java')).toContain('org.jsoup.select::NodeFilter::FilterResult');
+  });
+});
diff --git a/__tests__/js-builtin-method-calls.test.ts b/__tests__/js-builtin-method-calls.test.ts
index d2d1f8f4c7..d850f3fdff 100644
--- a/__tests__/js-builtin-method-calls.test.ts
+++ b/__tests__/js-builtin-method-calls.test.ts
@@ -108,8 +108,8 @@ ${typed ? 'export function typed(cart: Cart) { cart.map(); }' : ''}
     for (const name of ['tidy', 'cached', 'unknownCache', 'literalArray', 'literalString']) expect(callees(name), name).toEqual([]);
     expect(callees('constructed')).toContain('Cart::add');
     expect(callees('imported')).toContain('Cart::bind');
-    expect(callees('objectLiteral')).toEqual(['map']);
-    expect(callees('localLiteral')).toEqual(['map']);
+    expect(callees('objectLiteral')).toEqual(['api::map']);
+    expect(callees('localLiteral')).toEqual(['local::map']);
     if (typed) expect(callees('typed')).toEqual(['Cart::map']);
     const self = cg.getNodesByKind('method').find(n => n.qualifiedName === 'Cart::self')!;
     expect(cg.getCallees(self.id).map(c => c.node.qualifiedName)).toEqual(['Cart::add']);
diff --git a/__tests__/js-function-local-binding.test.ts b/__tests__/js-function-local-binding.test.ts
new file mode 100644
index 0000000000..a0360929bd
--- /dev/null
+++ b/__tests__/js-function-local-binding.test.ts
@@ -0,0 +1,81 @@
+/**
+ * A JS/TS name the calling function binds itself — a parameter, or a `var` /
+ * `let` / `const` above the reference — is that local, never a same-named
+ * function declared elsewhere in the file. Every lodash helper lives inside
+ * `runInContext`, so `baseHas(object, key)`'s `object` and `mixin`'s
+ * `object(this.__wrapped__)` reached a `function object() {}` an IIFE declares
+ * there. A function that calls itself through its own `const` still does, and
+ * `if (handler) handler()` is not a parameter list.
+ */
+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-js-local-'));
+  const files: Record<string, string> = {
+    'lodash.js': `function runInContext(context) {
+  var baseCreate = (function() {
+    function object() {}
+    return function(proto) {
+      object.prototype = proto;
+      return new object;
+    };
+  }());
+
+  function baseHas(object, key) {
+    return object != null && hasOwnProperty.call(object, key);
+  }
+
+  function mixin(object, source) {
+    var result = object(this.__wrapped__);
+    return result;
+  }
+
+  function handler() {}
+
+  function run() {
+    if (handler) {
+      handler();
+    }
+    const walk = (node) => (node ? walk(node.next) : null);
+    return walk(context);
+  }
+
+  return { baseCreate, baseHas, mixin, run };
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (qualifiedName: string) => {
+  const ids = cg.getNodesInFile('lodash.js').filter((n) => n.qualifiedName === qualifiedName).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('JS names the calling function binds', () => {
+  it('are its parameters, not a same-named function elsewhere in the file', () => {
+    expect(targetsFrom('runInContext::baseHas')).not.toContain('runInContext::object');
+    expect(targetsFrom('runInContext::mixin')).not.toContain('runInContext::object');
+  });
+
+  it('leave unbound names and a const’s own recursion alone', () => {
+    expect(targetsFrom('runInContext::run')).toContain('runInContext::handler');
+    expect(targetsFrom('runInContext::run::walk')).toContain('runInContext::run::walk');
+  });
+});
diff --git a/__tests__/js-local-binding-backtracking.test.ts b/__tests__/js-local-binding-backtracking.test.ts
new file mode 100644
index 0000000000..5746cd3e85
--- /dev/null
+++ b/__tests__/js-local-binding-backtracking.test.ts
@@ -0,0 +1,73 @@
+/**
+ * Whether a JS function binds a name itself (jsFunctionLocalScope, #2226) is
+ * read off the function's comment-stripped code with a parameter-list regex.
+ * Its `(?<!\b(?:if|while|for|switch|with)\s*)` lookbehind is cheap only while
+ * V8 optimizes the regex, and Node 22's V8 stops optimizing new regexes once a
+ * process has generated about a megabyte of regex code — which a resolver pool
+ * worker does early, compiling patterns per receiver and per name. Unoptimized,
+ * the lookbehind runs at every position and reads back through each whitespace
+ * run before it, so a long blanked comment cost time in its length squared.
+ *
+ * go-ethereum's bundled `graphiql.min.js` is one 980 KB line, and the
+ * stripper, which doesn't know regex literals, read the `//` that ends
+ * `/Trident\//` as a comment and blanked the remaining 962 KB of it. Two pool
+ * workers sat on one such check each until the run was killed (`codegraph
+ * init` never finished resolving).
+ *
+ * The cost lives inside one regex execution, where there is nothing to count,
+ * so this is timed — with V8's unoptimized mode forced, on any Node version,
+ * and a bound far above the fix's cost and far below the quadratic one.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as v8 from 'v8';
+import { CodeGraph } from '../src';
+
+describe('JS local-binding check on a long comment (go-ethereum graphiql.min.js)', () => {
+  let tmpDir: string | undefined;
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5 });
+    tmpDir = undefined;
+  });
+
+  const callees = (graph: CodeGraph, name: string): string[] => {
+    const from = graph.getNodesByName(name).find((n) => n.kind === 'function')!;
+    return graph.getOutgoingEdges(from.id).filter((e) => e.kind === 'calls')
+      .map((e) => graph.getNode(e.target)!.name);
+  };
+
+  it('stays linear when V8 stops optimizing regexes', async () => {
+    // Blanked by the comment stripper into one 60,000-character run of spaces.
+    const comment = `/* ${'word '.repeat(12_000)} */`;
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-js-lookbehind-'));
+    fs.writeFileSync(path.join(tmpDir, 'paint.js'), [
+      'function paintWidget() {\n  return 1;\n}',
+      // Calls the file's own paintWidget: the check scans all of host's code and finds no binding.
+      `function host() {\n  ${comment}\n  return paintWidget();\n}`,
+      // Calls its parameter, which shadows the file's paintWidget.
+      `function shadow(paintWidget) {\n  ${comment}\n  return paintWidget();\n}`,
+      '',
+    ].join('\n'));
+
+    v8.setFlagsFromString('--no-regexp-optimization');
+    const started = Date.now();
+    try {
+      cg = CodeGraph.initSync(tmpDir);
+      await cg.indexAll();
+    } finally {
+      v8.setFlagsFromString('--regexp-optimization');
+    }
+    const elapsed = Date.now() - started;
+
+    expect(callees(cg, 'host')).toEqual(['paintWidget']);
+    expect(callees(cg, 'shadow')).toEqual([]);
+    // About a second with the fix; minutes when the lookbehind reads back through the run at every position.
+    expect(elapsed).toBeLessThan(20_000);
+  }, 300_000);
+});
diff --git a/__tests__/js-member-guessing.test.ts b/__tests__/js-member-guessing.test.ts
new file mode 100644
index 0000000000..65bdb4a282
--- /dev/null
+++ b/__tests__/js-member-guessing.test.ts
@@ -0,0 +1,228 @@
+/**
+ * A JS/TS call is never bound to a class member picked by name alone when the
+ * code rules the member out.
+ *
+ * - A namespace import (`import * as z from "zod/v4"`) is the module object:
+ *   `z.string()` calls one of the module's exports. It used to bind to the one
+ *   class in the project with a `string` member — on zod, 3,207 calls to a test
+ *   helper's getter.
+ * - A binding from a package outside the repository (`import { z } from 'zod'`)
+ *   names nothing in it.
+ * - A bare call (`it(…)`, `describe(…)`) resolves lexically: it cannot reach an
+ *   interface's `it` property or a class's `describe` field.
+ *
+ * A default import of a local module's instance still resolves by method.
+ *
+ * Vue, Svelte and Astro files follow the same rules (halo's 562 `t(…)` calls
+ * went to an interface's `t`). "Outside the repository" means a package the
+ * file's package.json declares, a Node built-in or a framework's virtual
+ * module: an alias the resolver doesn't know (SvelteKit's `$lib/…`, a nested
+ * Nuxt app's `~/…`) is still the project's.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+const FILES: Record<string, string> = {
+  'package.json': JSON.stringify({ name: 'app', dependencies: { zod: '^4.0.0', mocha: '^10.0.0', react: '^19.0.0', '@tanstack/react-query': '^5.0.0' } }),
+  'src/test/Mocker.ts': `export class Mocker {
+  get string(): string { return 'x'; }
+  record(): number { return 1; }
+}
+`,
+  'src/test/xfail.ts': `export interface XFailFunction {
+  it: (title: string) => void;
+}
+`,
+  'src/commands/CacheClear.ts': `export class CacheClearCommand {
+  describe = "Clears all data stored in query runner cache.";
+  run() { return 1; }
+}
+`,
+  'src/utils.ts': `export function helper() { return 1; }
+`,
+  'src/api.ts': `class ApiClient {
+  fetchUsers() { return []; }
+}
+export default new ApiClient();
+`,
+  'src/schemas.ts': `import * as z from 'zod';
+import { z as zz } from 'zod';
+import * as utils from './utils';
+import api from './api';
+
+export function schemas() {
+  const a = z.string();
+  const b = zz.record();
+  const c = utils.helper();
+  const d = api.fetchUsers();
+  return [a, b, c, d];
+}
+`,
+  'src/schemas.test.ts': `import { useQuery } from '@tanstack/react-query';
+describe('schemas', () => {
+  it('works', () => { useQuery({}); });
+});
+`,
+  'src/hooks.ts': `export function useQuery(key: string) { return key; }
+`,
+  'src/factory.ts': `export function createRootHooks() {
+  function useQuery(input: unknown) { return input; }
+  return { useQuery };
+}
+`,
+  'src/useAuth.ts': `export function useAuth() { return { user: null }; }
+`,
+  'src/App.tsx': `import { useQuery } from '@tanstack/react-query';
+import { useAuth } from './useAuth';
+export function App() {
+  const q = useQuery({ queryKey: ['a'] });
+  const auth = useAuth();
+  return <div>{String(q)}{String(auth)}</div>;
+}
+`,
+};
+
+describe('JS/TS: a member picked by name alone', () => {
+  it('is not what a namespace import, an outside package or a bare call reaches', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-js-member-guess-'));
+    roots.push(root);
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const callsFrom = (file: string): string[] => {
+        const ids = cg.getNodesInFile(file).map((n) => n.id);
+        return cg
+          .getOutgoingEdgesFrom(ids, ['calls'])
+          .map((e) => cg.getNode(e.target)?.qualifiedName ?? '?')
+          .sort();
+      };
+      const fromSchemas = callsFrom('src/schemas.ts');
+      expect(fromSchemas).not.toContain('Mocker::string');
+      expect(fromSchemas).not.toContain('Mocker::record');
+      expect(fromSchemas).toContain('helper');
+      expect(fromSchemas).toContain('ApiClient::fetchUsers');
+      const fromTest = callsFrom('src/schemas.test.ts');
+      expect(fromTest).not.toContain('XFailFunction::it');
+      expect(fromTest).not.toContain('CacheClearCommand::describe');
+      // Imported from a package: not the project's own `useQuery`.
+      expect(fromTest).not.toContain('useQuery');
+      // The same in a React file, where hooks resolve by framework rules — and a
+      // hook imported from the project still resolves.
+      const fromApp = callsFrom('src/App.tsx');
+      expect(fromApp.filter((q) => q.endsWith('useQuery'))).toEqual([]);
+      expect(fromApp).toContain('useAuth');
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('applies to Vue and Svelte files, and an unknown alias is still the project', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-js-sfc-guess-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'frontend/package.json': JSON.stringify({ name: 'frontend', dependencies: { 'vue-i18n': '*', dayjs: '*', '@app/shared': 'workspace:*' } }),
+      'shared/index.ts': `export function formatUrl(u: string) { return u; }
+`,
+      'frontend/types/context.ts': `export interface ProvidersContext {
+  t: (key: string) => string;
+}
+`,
+      'frontend/test/mocks.ts': `export function dayjs() { return 0; }
+`,
+      'frontend/composables/store.ts': `export function useLabelStore() { return {}; }
+`,
+      'frontend/composables/use-labels.ts': `import { useLabelStore } from '~/composables/store';
+export function useLabels() { return useLabelStore(); }
+`,
+      'frontend/pages/labels.vue': `<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import dayjs from 'dayjs';
+import { useLabelStore } from '~/composables/store';
+import { formatUrl } from '@app/shared';
+const { t } = useI18n();
+const url = formatUrl('/labels');
+const title = t('labels.title');
+const today = dayjs();
+const store = useLabelStore();
+</script>
+<template><h1>{{ title }}</h1></template>
+`,
+      'docs/package.json': JSON.stringify({ name: 'docs', devDependencies: { '@sveltejs/kit': '*' } }),
+      'docs/src/lib/design.ts': `export function useDesignSystem() { return 1; }
+`,
+      'docs/src/lib/router.ts': `export function goto(path: string) { return path; }
+`,
+      'docs/src/lib/use.ts': `import { useDesignSystem } from '$lib/design';
+export const current = () => useDesignSystem();
+`,
+      'docs/src/lib/instance.js': `export const DEV = true;
+if (DEV) {
+  const fetch = globalThis.fetch;
+  globalThis.fetch = async (info) => fetch(info);
+}
+`,
+      'docs/src/lib/Map.svelte': `<div>map</div>
+`,
+      'docs/src/routes/+page.svelte': `<script lang="ts">
+  import Map from '../lib/Map.svelte';
+  import { useDesignSystem } from '$lib/design';
+  import { goto } from '$app/navigation';
+  const ds = useDesignSystem();
+  function go() { goto('/'); fetch('/api'); }
+</script>
+<button on:click={go}>{ds}</button>
+`,
+      // Deno: the import map says `@std/assert` comes from JSR.
+      'deno/deno.json': JSON.stringify({ imports: { '@std/assert': 'jsr:@std/assert@^1', 'app/': '../src/' } }),
+      'deno/test/assert.ts': `export function assertEquals(a: unknown, b: unknown) { return a === b; }
+`,
+      'deno/app.test.ts': `import { assertEquals } from '@std/assert';
+assertEquals(1, 1);
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const callsFrom = (file: string): string[] => {
+        const ids = cg.getNodesInFile(file).map((n) => n.id);
+        return cg
+          .getOutgoingEdgesFrom(ids, ['calls'])
+          .map((e) => cg.getNode(e.target)?.qualifiedName ?? '?')
+          .sort();
+      };
+      const fromVue = callsFrom('frontend/pages/labels.vue');
+      expect(fromVue).not.toContain('ProvidersContext::t');
+      expect(fromVue).not.toContain('dayjs');
+      expect(fromVue).toContain('useLabelStore');
+      // A `workspace:*` dependency is in the repository.
+      expect(fromVue).toContain('formatUrl');
+      expect(callsFrom('frontend/composables/use-labels.ts')).toContain('useLabelStore');
+      const fromSvelte = callsFrom('docs/src/routes/+page.svelte');
+      expect(fromSvelte).toContain('useDesignSystem');
+      expect(fromSvelte).not.toContain('goto');
+      expect(fromSvelte).not.toContain('fetch');
+      expect(callsFrom('deno/app.test.ts')).not.toContain('assertEquals');
+      // A built-in's name imported from the project is the import.
+      const svelteIds = cg.getNodesInFile('docs/src/routes/+page.svelte').map((n) => n.id);
+      const imported = cg.getOutgoingEdgesFrom(svelteIds, ['imports']).map((e) => cg.getNode(e.target)!.filePath);
+      expect(imported).toContain('docs/src/lib/Map.svelte');
+      expect(callsFrom('docs/src/lib/use.ts')).toContain('useDesignSystem');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/js-object-literal-members.test.ts b/__tests__/js-object-literal-members.test.ts
new file mode 100644
index 0000000000..f24270e39f
--- /dev/null
+++ b/__tests__/js-object-literal-members.test.ts
@@ -0,0 +1,320 @@
+/**
+ * A named object literal owns its function members (#2300). Members used to
+ * become nodes only when the object was an `export const`; a plain `const`, an
+ * object inside an IIFE and one hung on a path (`window.WS = {…}`) produced
+ * none, so script-tag JavaScript was nearly invisible and the calls inside a
+ * member were credited to the enclosing constant (or lost).
+ *
+ * Now each member is a `function` node qualified under its owner
+ * (`store::shorthand`, `window.WS::wsM`), the calls written in it are its own,
+ * and the calls that reach it — `App.init()`, `window.App.init()`, a sibling's
+ * `this.render()`, `App.utils.pad()`, a classic script's `WS.wsM()` from
+ * another file — resolve to it. A bare `init()` never does.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { getKernel, resetKernelForTests } from '../src/extraction/kernel';
+
+const kernelBuilt = fs.existsSync(path.join(__dirname, '../codegraph-kernel/prebuilds',
+  `${process.platform}-${process.arch}`, 'codegraph-kernel.node'));
+
+describe.each(['native', 'wasm'].filter((backend) => backend === 'wasm' || kernelBuilt))(
+  'object-literal members (%s, #2300)', (backend) => {
+  let dir: string;
+  let cg: CodeGraph | undefined;
+
+  beforeEach(() => {
+    vi.stubEnv('CODEGRAPH_KERNEL', backend === 'wasm' ? '0' : '1');
+    vi.stubEnv('CODEGRAPH_KERNEL_LANGS', 'all');
+    resetKernelForTests();
+    if (backend === 'native') expect(getKernel()).not.toBeNull();
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-2300-'));
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(dir, { recursive: true, force: true });
+    vi.unstubAllEnvs();
+    resetKernelForTests();
+  });
+
+  async function index(files: Record<string, string>): Promise<CodeGraph> {
+    for (const [rel, body] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), body);
+    }
+    cg = await CodeGraph.init(dir, { index: true });
+    return cg;
+  }
+
+  /** The one node with this qualified name (in `file`, when several share it). */
+  function node(g: CodeGraph, qualifiedName: string, file?: string) {
+    const found = g.getNodesByQualifiedName(qualifiedName).filter((n) => !file || n.filePath === file);
+    expect(found, qualifiedName).toHaveLength(1);
+    return found[0]!;
+  }
+  /** The qualified names at the other end of a node's `calls` edges. */
+  const calls = (g: CodeGraph, id: string, direction: 'in' | 'out') =>
+    (direction === 'in' ? g.getIncomingEdges(id) : g.getOutgoingEdges(id))
+      .filter((e) => e.kind === 'calls')
+      .map((e) => g.getNode(direction === 'in' ? e.source : e.target)!.qualifiedName)
+      .sort();
+  const callers = (g: CodeGraph, qn: string, file?: string) => calls(g, node(g, qn, file).id, 'in');
+  const callees = (g: CodeGraph, qn: string, file?: string) => calls(g, node(g, qn, file).id, 'out');
+
+  it('gives every container shape from the issue its members, and the calls in a member to that member', async () => {
+    const g = await index({
+      'src/a_export.ts': 'export const objTsExp = { tsExpM() { return 1; }, tsExpProp: () => 1 };\n',
+      'src/b_plain.ts': 'const objTsPlain = { tsPlainM() { return 1; }, tsPlainProp: () => 1 };\n',
+      'src/c_export.js': 'export const objJsExp = { jsExpM() { return 1; }, jsExpProp: () => 1 };\n',
+      'src/d_plain.js': 'const objJsPlain = { jsPlainM() { return 1; }, jsPlainProp: () => 1 };\n',
+      'src/e_iife.js': [
+        '(function () {',
+        '  const objIife = { iifeM() { return 1; } };',
+        '  window.WS = { wsM() { return objIife.iifeM(); } };',
+        '})();',
+        '',
+      ].join('\n'),
+      'src/f_calls.js': [
+        'function helper() { return 2; }',
+        'var store = { shorthand() { return helper(); } };',
+        'function useStore() { return store.shorthand(); }',
+        'window.api = { load() { return store.shorthand(); } };',
+        'function viaWindow() { return window.WS.wsM(); }',
+        'function viaGlobal() { return WS.wsM(); }',
+        '',
+      ].join('\n'),
+    });
+
+    for (const qn of [
+      'objTsExp::tsExpM', 'objTsExp::tsExpProp', 'objTsPlain::tsPlainM', 'objTsPlain::tsPlainProp',
+      'objJsExp::jsExpM', 'objJsExp::jsExpProp', 'objJsPlain::jsPlainM', 'objJsPlain::jsPlainProp',
+      'objIife::iifeM', 'window.WS::wsM', 'store::shorthand', 'window.api::load',
+    ]) {
+      expect(node(g, qn).kind, qn).toBe('function');
+    }
+    // The member belongs to its owner, and `window.WS` is the global `WS`.
+    const plain = node(g, 'objTsPlain');
+    expect(g.getOutgoingEdges(plain.id).filter((e) => e.kind === 'contains').map((e) => g.getNode(e.target)!.name).sort())
+      .toEqual(['tsPlainM', 'tsPlainProp']);
+    expect(g.getNodesByName('WS').map((n) => `${n.kind} ${n.qualifiedName}`)).toEqual(['variable window.WS']);
+    // An exported literal's members stay exported, a plain one's do not.
+    expect(node(g, 'objTsExp::tsExpM').isExported).toBe(true);
+    expect(node(g, 'objTsPlain::tsPlainM').isExported).toBeFalsy();
+
+    // The call inside a member is the member's, not the constant's.
+    expect(callers(g, 'helper')).toEqual(['store::shorthand']);
+    expect(callers(g, 'objIife::iifeM')).toEqual(['window.WS::wsM']);
+    expect(callers(g, 'store::shorthand')).toEqual(['useStore', 'window.api::load']);
+    // `window.WS.wsM()`, and `WS.wsM()` from another classic script.
+    expect(callers(g, 'window.WS::wsM')).toEqual(['viaGlobal', 'viaWindow']);
+  });
+
+  it('resolves through the object the call names — never by the bare name', async () => {
+    const g = await index({
+      'app.js': [
+        'function init() { return "global"; }',
+        'var App = {',
+        '  init: function () { this.render(); helpers.fmt(); },',
+        '  render: function () { return 1; },',
+        '};',
+        'var helpers = { fmt() { return 2; } };',
+        'App.utils = { pad(s) { return s; } };',
+        'function boot() { App.init(); App.utils.pad("x"); init(); }',
+        'dw_page = { start() { App.render(); } };',
+        '',
+      ].join('\n'),
+      'page.js': [
+        'function main() { App.init(); window.App.render(); dw_page.start(); App.utils.pad("y"); }',
+        'function shadow(App) { return App.init(); }',
+        'function bare() { return render(); }',
+        '',
+      ].join('\n'),
+    });
+
+    expect(callees(g, 'boot')).toEqual(['App.utils::pad', 'App::init', 'init']);
+    expect(callees(g, 'App::init')).toEqual(['App::render', 'helpers::fmt']);
+    expect(callees(g, 'dw_page::start')).toEqual(['App::render']);
+    // Another script reaches the page's globals; a parameter of the same name does not.
+    expect(callees(g, 'main')).toEqual(['App.utils::pad', 'App::init', 'App::render', 'dw_page::start']);
+    expect(callees(g, 'shadow')).toEqual([]);
+    // `render()` alone is not `App.render`, and `init()` stays the global function.
+    expect(callees(g, 'bare')).toEqual([]);
+    expect(callers(g, 'init')).toEqual(['boot']);
+  });
+
+  it('never takes an object hung on a path, or one local to an IIFE, for a name elsewhere', async () => {
+    const g = await index({
+      // A Svelte project, where `$count` reads the store `count` — in a `.svelte` component.
+      'package.json': '{ "dependencies": { "svelte": "^4.0.0" } }\n',
+      'lib.js': [
+        '$.event.special.swipe = { setup: function () { return 1; } };',
+        'todos.model = { add: function () { return 2; } };',
+        '(function () { var n = { touch: function () { return 3; } }; n.touch(); })();',
+        '',
+      ].join('\n'),
+      'widget.js': [
+        'var Widget = {',
+        '  drag: function () { this.swipe(1); },',
+        '  make: function () { return new this.model(); },',
+        '};',
+        '',
+      ].join('\n'),
+      // Two compiled scripts, each with its own `$n`.
+      'gwt1.js': 'function $n(a) { this.a = a; }\nfunction make1() { return new $n(1); }\n',
+      'gwt2.js': 'function $n(a) { this.a = a; }\nfunction make2() { return new $n(2); }\n',
+    });
+    const edges = (qn: string) => g.getOutgoingEdges(node(g, qn).id).filter((e) => e.kind !== 'contains')
+      .map((e) => `${e.kind} ${g.getNode(e.target)!.qualifiedName} ${g.getNode(e.target)!.filePath}`);
+    // `this.swipe()` and `new this.model()` are not the objects at `$.event.special.swipe` and `todos.model`.
+    expect(edges('Widget::drag')).toEqual([]);
+    expect(edges('Widget::make')).toEqual([]);
+    // A plain script's `$n` is its own function, not a store read of the IIFE's `n`.
+    expect(edges('make1')).toEqual(['instantiates $n gwt1.js']);
+    expect(edges('make2')).toEqual(['instantiates $n gwt2.js']);
+  });
+
+  it('keeps each IIFE and function its own literal, and a module its private ones', async () => {
+    const g = await index({
+      'iife.js': [
+        '(function () { const Api = { run() { left(); } }; Api.run(); })();',
+        '(function () { const Api = { run() { right(); } }; Api.run(); })();',
+        'function left() {}',
+        'function right() {}',
+        'function outside() { return Api.run(); }',
+        'function a() { const local = { go() { left(); } }; local.go(); }',
+        'function b() { const local = { go() { right(); } }; local.go(); }',
+        '',
+      ].join('\n'),
+      'mod.js': 'import { x } from "./x.js";\nconst Local = { run() { return x; } };\nexport function useLocal() { return Local.run(); }\n',
+      'other.js': 'import { y } from "./y.js";\nexport function nope() { return Local.run(y); }\n',
+    });
+
+    const [first, second] = g.getNodesByQualifiedName('Api::run').sort((p, q) => p.startLine - q.startLine);
+    expect(calls(g, first!.id, 'out')).toEqual(['left']);
+    expect(calls(g, second!.id, 'out')).toEqual(['right']);
+    // Each IIFE's `Api.run()` reaches its own literal (the file runs both).
+    expect(calls(g, first!.id, 'in')).toEqual(['iife.js']);
+    expect(calls(g, second!.id, 'in')).toEqual(['iife.js']);
+    // Outside both IIFEs, `Api` is neither of them — not even as a value read.
+    expect(callees(g, 'outside')).toEqual([]);
+    expect(g.getOutgoingEdges(node(g, 'outside').id).filter((e) => e.kind !== 'contains')).toEqual([]);
+    expect(callees(g, 'a')).toEqual(['a::local::go']);
+    expect(callees(g, 'b')).toEqual(['b::local::go']);
+    expect(callees(g, 'useLocal')).toEqual(['Local::run']);
+    expect(callees(g, 'nope')).toEqual([]);
+  });
+
+  it('gives arrow members and values the `this` of the method around the literal', async () => {
+    const g = await index({
+      'app.ts': [
+        'class Emitter { on(cb: () => void) { return cb; } }',
+        'export class App {',
+        '  private emitter = new Emitter();',
+        '  updateScene() { return 1; }',
+        '  createApi() {',
+        '    const api = {',
+        '      updateScene: this.updateScene,',
+        '      onChange: (cb: () => void) => this.emitter.on(cb),',
+        '      refresh: () => this.updateScene(),',
+        '      own() { return this.refresh(); },',
+        '    };',
+        '    return api;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+    });
+    // A value in a method's literal is that method's own reference, as before.
+    const createApi = node(g, 'App::createApi');
+    expect(g.getOutgoingEdges(createApi.id).filter((e) => e.kind === 'references')
+      .map((e) => g.getNode(e.target)!.qualifiedName)).toContain('App::updateScene');
+    // An arrow member's `this` is the class instance…
+    expect(callees(g, 'App::createApi::api::onChange')).toEqual(['Emitter::on']);
+    expect(callees(g, 'App::createApi::api::refresh')).toEqual(['App::updateScene']);
+    // …an object's own method's `this` is the object.
+    expect(callees(g, 'App::createApi::api::own')).toEqual(['App::createApi::api::refresh']);
+  });
+
+  it('keeps a cross-file member edge through edits of the defining script', async () => {
+    const g = await index({
+      'ns.js': 'window.WS = { a() { return 1; }, wsM() { return 2; } };\n',
+      'use.js': 'function viaGlobal() { return WS.wsM(); }\n',
+    });
+    expect(callers(g, 'window.WS::wsM')).toEqual(['viaGlobal']);
+    fs.writeFileSync(path.join(dir, 'ns.js'), '// moved\nwindow.WS = {\n  wsM() { return 3; },\n};\n');
+    await g.sync();
+    expect(callers(g, 'window.WS::wsM')).toEqual(['viaGlobal']);
+    fs.writeFileSync(path.join(dir, 'ns.js'), 'window.WS = { renamed() { return 4; } };\n');
+    await g.sync();
+    expect(g.getNodesByQualifiedName('window.WS::wsM')).toEqual([]);
+    expect(callees(g, 'viaGlobal')).toEqual([]);
+  }, 30_000);
+
+  it('reaches an imported literal and a binding destructured off one', async () => {
+    const g = await index({
+      'api.js': [
+        'export const api = { get() { return 1; }, post() { return 2; } };',
+        'const { post } = api;',
+        'export function b() { return post(); }',
+        'export function c() { return get(); }',
+        '',
+      ].join('\n'),
+      'use.js': [
+        'import { api } from "./api.js";',
+        'export function a() { return api.get(); }',
+        '',
+      ].join('\n'),
+    });
+    expect(callees(g, 'a')).toEqual(['api::get']);
+    expect(callees(g, 'b')).toEqual(['api::post']);
+    // `get` was never destructured: a bare `get()` is not `api.get`.
+    expect(callees(g, 'c')).toEqual([]);
+  });
+
+  it('leaves CommonJS exports, prototypes, call arguments, data and minified bundles as they were', async () => {
+    const g = await index({
+      'shapes.js': [
+        'module.exports = { cjs() { return 1; } };',
+        'Foo.prototype = { proto() { return 1; } };',
+        'consume({ ephemeral() { return 1; } });',
+        'const data = { a: 1, b: [1, 2] };',
+        'this.state = { onThis() { return 1; } };',
+        '',
+      ].join('\n'),
+      'vendor/lib.min.js': 'var a={b:function(){return 1},c:function(){return 2}};window.L={d:function(){return a.b()}};\n',
+      // A bundle not named so: its lines are what gives it away.
+      'dist/bundle.js': `${'var q={b:function(){return r(1,2)},c:function(s){return s}};window.M={d:function(){return q.b()}};'.repeat(60)}\n`.repeat(2),
+      'iife.js': '(function () { var e; if (!e) { e = { getItem: function () { return 1; } }; } })();\n',
+    });
+    // …and a plain name reassigned inside a function (a bundle's `e = {…}`) is a local.
+    for (const name of ['cjs', 'proto', 'ephemeral', 'onThis', 'b', 'c', 'd', 'getItem']) {
+      expect(g.getNodesByName(name), name).toEqual([]);
+    }
+    expect(node(g, 'data').kind).toBe('constant');
+  });
+
+  it('keeps a <script setup> literal\'s members under their owner', async () => {
+    const g = await index({
+      'Panel.vue': [
+        '<template><button @click="save">Save</button></template>',
+        '<script setup>',
+        'const handlers = { onSave() { persist(); } };',
+        'function persist() {}',
+        'function save() { handlers.onSave(); }',
+        '</script>',
+        '',
+      ].join('\n'),
+    });
+    const owner = node(g, 'handlers');
+    const member = node(g, 'handlers::onSave');
+    expect(g.getIncomingEdges(member.id).filter((e) => e.kind === 'contains').map((e) => e.source)).toEqual([owner.id]);
+    expect(callees(g, 'handlers::onSave')).toEqual(['persist']);
+    expect(callees(g, 'save')).toEqual(['handlers::onSave']);
+  });
+});
diff --git a/__tests__/js-resolution-work.test.ts b/__tests__/js-resolution-work.test.ts
new file mode 100644
index 0000000000..1849f91a40
--- /dev/null
+++ b/__tests__/js-resolution-work.test.ts
@@ -0,0 +1,171 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { matchCollapsedObjectCall } from '../src/resolution/name-matcher';
+import { stripCommentsForRegex } from '../src/resolution/strip-comments';
+import type { ResolutionContext, UnresolvedRef } from '../src/resolution/types';
+
+// Pass-through, so a test can count how often text is stripped.
+vi.mock('../src/resolution/strip-comments', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../src/resolution/strip-comments')>();
+  return { ...actual, stripCommentsForRegex: vi.fn(actual.stripCommentsForRegex) };
+});
+
+/**
+ * #2334: resolving JS/TS does a bounded amount of work per file. In a file
+ * with destructuring, the check for a call through a destructured name
+ * stripped and scanned every line above each bare call; the check for a name
+ * the calling function binds itself stripped that function's lines above each
+ * reference again. A bundled library took time in the square of its size.
+ * Counted, never timed.
+ */
+describe('JS resolution work (#2334)', () => {
+  let tmpDir: string | undefined;
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    vi.mocked(stripCommentsForRegex).mockClear();
+    cg?.close();
+    cg = undefined;
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5 });
+    tmpDir = undefined;
+  });
+
+  async function index(files: Record<string, string>): Promise<CodeGraph> {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-js-work-'));
+    for (const [file, content] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(tmpDir, file)), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, file), content);
+    }
+    cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+    return cg;
+  }
+
+  /** How often a non-empty start of `text` was stripped as `lang`. */
+  const strips = (lang: string, text: string) => vi.mocked(stripCommentsForRegex).mock.calls
+    .filter(([stripped, as]) => as === lang && stripped.length > 0 && text.startsWith(stripped)).length;
+
+  const callers = (graph: CodeGraph, file: string, name: string) => {
+    const target = graph.getNodesByName(name).find((n) => n.filePath === file && n.kind === 'function')!;
+    return [...new Set(graph.getIncomingEdges(target.id).filter((e) => e.kind === 'calls')
+      .map((e) => graph.getNode(e.source)?.name))];
+  };
+
+  it('reads a file with destructuring once, not once per call', async () => {
+    const CALLS = 40;
+    const app = `import { useAuth } from './auth';\n` +
+      `const { login } = useAuth();\n` +
+      Array.from({ length: CALLS }, (_, i) => `function step${i}() { return ${i}; }\n`).join('') +
+      `export function run() {\n` +
+      Array.from({ length: CALLS }, (_, i) => `  step${i}();\n`).join('') +
+      // A division the blanking reads as a regex literal around the call.
+      `  return (${CALLS}) / login() / 2;\n}\n`;
+    const graph = await index({
+      'auth.js': 'export function useAuth() {\n  function login() {\n    return 1;\n  }\n  return { login };\n}\n',
+      'app.js': app,
+    });
+    // The call through the destructured name reaches the function the hook returns.
+    expect(callers(graph, 'auth.js', 'login')).toEqual(['run']);
+    expect(callers(graph, 'app.js', 'step7')).toEqual(['run']);
+    // Each bare call was checked; the file was stripped for that once, not once per call.
+    expect(strips('typescript', app)).toBeLessThan(CALLS / 4);
+  });
+
+  it("strips a function's lines once, not once per reference", async () => {
+    const LINES = 40;
+    const host = `export function host() {\n` +
+      Array.from({ length: LINES }, (_, i) => `  helper(${i});\n`).join('') + `}\n`;
+    const graph = await index({ 'lib.js': `export function helper(n) {\n  return n;\n}\n${host}` });
+    // Each call resolved, so each asked whether `host` binds `helper` itself.
+    expect(callers(graph, 'lib.js', 'helper')).toEqual(['host']);
+    expect(strips('javascript', host)).toBeLessThan(LINES / 4);
+  });
+});
+
+/**
+ * A call the extractor records by its bare name has its receiver read back
+ * from the source, from the ref's column on. A minified bundle is one long
+ * line, and joining it with the lines after it copied all of it for every
+ * call on it: about 1 MB per call on go-ethereum's graphiql.min.js. Counted,
+ * never timed.
+ */
+describe('a receiver read back from a minified line', () => {
+  /** How many characters arrays were joined into while `run` ran. */
+  function joinedDuring(run: () => void): number {
+    const join = Array.prototype.join;
+    let chars = 0;
+    Array.prototype.join = function (this: unknown[], separator?: string): string {
+      const text = join.call(this, separator);
+      chars += text.length;
+      return text;
+    };
+    try {
+      run();
+    } finally {
+      Array.prototype.join = join;
+    }
+    return chars;
+  }
+
+  /**
+   * Runs `refs` through the check for a call written on `window.App…`, which
+   * looks up the object the receiver it read back names.
+   */
+  function readBack(source: string, refs: UnresolvedRef[]): { holders: string[]; joined: number } {
+    const lines = source.split('\n');
+    const holders: string[] = [];
+    const context: ResolutionContext = {
+      getNodesInFile: () => [],
+      getNodesByName: (name) => {
+        holders.push(name);
+        return [];
+      },
+      getNodesByQualifiedName: () => [],
+      getNodesByKind: () => [],
+      getNodesByLowerName: () => [],
+      fileExists: () => false,
+      readFile: () => source,
+      getFileLines: () => lines,
+      getProjectRoot: () => '',
+      getAllFiles: () => [],
+      getImportMappings: () => [],
+    };
+    const joined = joinedDuring(() => {
+      for (const ref of refs) matchCollapsedObjectCall(ref, context);
+    });
+    return { holders, joined };
+  }
+
+  const call = (name: string, line: number, column: number): UnresolvedRef => ({
+    fromNodeId: 'bundle', referenceName: name, referenceKind: 'calls', line, column,
+    filePath: 'bundle.min.js', language: 'javascript',
+  });
+
+  it('reads every receiver on the line without copying the line once per call', () => {
+    const CALLS = 300;
+    const refs: UnresolvedRef[] = [];
+    let line = '!function(){';
+    for (let i = 0; i < CALLS; i++) {
+      refs.push(call(`m${i}`, 2, line.length));
+      line += `window.App${i}.m${i}(${i});`;
+    }
+    line += '}();';
+    const { holders, joined } = readBack(`/*! bundle */\n${line}\n//# sourceMappingURL=bundle.min.js.map`, refs);
+    // Each call's receiver was read back...
+    expect(holders).toEqual(refs.map((_, i) => `App${i}`));
+    // ...and all of them together copied less than the line once.
+    expect(joined).toBeLessThan(line.length);
+  });
+
+  it('reads on past the line when the line alone does not settle the call', () => {
+    // The call continues on the next lines.
+    expect(readBack('window.App\n  .go\n  (1);', [call('go', 1, 0)]).holders).toEqual(['App']);
+    // The line holds `foo(`, but the call is `foo[…](3)`, whose subscript runs onto the next line.
+    expect(readBack('window.App.foo[foo(1),\n2](3);', [call('foo', 1, 0)]).holders).toEqual(['App']);
+    // A column past the end of its line reads on from the next one.
+    expect(readBack('x\nwindow.App.go(1);', [call('go', 1, 2)]).holders).toEqual(['App']);
+  });
+});
diff --git a/__tests__/jsx-child-disambiguation.test.ts b/__tests__/jsx-child-disambiguation.test.ts
index 5c8465a900..2aedc99b56 100644
--- a/__tests__/jsx-child-disambiguation.test.ts
+++ b/__tests__/jsx-child-disambiguation.test.ts
@@ -129,3 +129,212 @@ export function Header() { return <h1><Badge /></h1>; }
     expect(rendersFrom(db, 'Header')).toEqual(['only/badge.tsx']);
   });
 });
+
+/**
+ * The pass reads tag names off a parent's source with a pattern, and two
+ * kinds of name it reads that way are no other file's component.
+ *
+ * - A type argument: `<PaginatedList<Document> …>` or `useState<User>()`
+ *   writes a type's name right after another name. outline's document list
+ *   rendered its `Document` model class, its settings tables the `User` and
+ *   `Group` classes.
+ * - A name the parent binds itself, as a `const` or a parameter, is that local
+ *   wherever its tags sit. outline's menus pick a Radix part into `const
+ *   Content = variant === 'dropdown' ? DropdownMenu.SubContent :
+ *   ContextMenu.SubContent` and rendered the command bar's styled `Content`
+ *   instead. A local is no node, so it renders nothing, unless the parent
+ *   declares a component of that name inside itself.
+ */
+describe('JSX child: a name the parent writes only as a type, or binds itself', () => {
+  let dir: string;
+  let cg: any;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsx-local-'));
+    fs.writeFileSync(path.join(dir, 'package.json'), '{"dependencies":{"react":"^18.0.0"}}');
+  });
+
+  afterEach(() => {
+    cg?.close?.();
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (rel: string, body: string) => {
+    const p = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, body);
+  };
+
+  async function index(): Promise<void> {
+    cg = await CodeGraph.init(dir, { silent: true });
+    await cg.indexAll();
+  }
+
+  /** `name file:line` of each node a jsx-render edge out of `parent` points at. */
+  const renders = (parent: string): string[] =>
+    cg.db.db
+      .prepare(
+        `SELECT t.name || ' ' || t.file_path || ':' || t.start_line AS r FROM edges e
+           JOIN nodes s ON s.id = e.source
+           JOIN nodes t ON t.id = e.target
+          WHERE s.name = ? AND json_extract(e.metadata, '$.synthesizedBy') = 'jsx-render'
+          ORDER BY r`
+      )
+      .all(parent)
+      .map((row: any) => row.r);
+
+  it('renders nothing for a name written only as a type argument or parameter', async () => {
+    write('app/models/Document.ts', 'export default class Document {\n  title = "";\n}\n');
+    write('app/models/User.ts', 'export default class User {\n  name = "";\n}\n');
+    write(
+      'app/components/PaginatedList.tsx',
+      'export function PaginatedList<T>({ items }: { items: T[] }) {\n  return <ul>{items.length}</ul>;\n}\n'
+    );
+    write(
+      'app/components/Badge.tsx',
+      'import * as React from "react";\nexport class Badge extends React.Component {\n  render() {\n    return <b />;\n  }\n}\n'
+    );
+    write(
+      'app/components/DocumentList.tsx',
+      `import * as React from 'react';
+import Document from '../models/Document';
+import User from '../models/User';
+import { Badge } from './Badge';
+import { PaginatedList } from './PaginatedList';
+
+export function DocumentList({ items }: { items: Document[] }) {
+  const [owner] = React.useState<User | null>(null);
+  const badge = React.useRef<Badge>(null);
+  return (
+    <div>
+      <PaginatedList<Document> items={items} />
+      <Badge ref={badge} />
+    </div>
+  );
+}
+`
+    );
+    // bulletproof-react's table: a generic arrow function's type parameter.
+    write('app/profile/entry.tsx', 'export function Entry() {\n  return <div />;\n}\n');
+    write(
+      'app/components/Table.tsx',
+      `type BaseEntity = { id: string };
+
+export const Table = <Entry extends BaseEntity>({ data }: { data: Entry[] }) => {
+  return <table>{data.length}</table>;
+};
+`
+    );
+    await index();
+    // `Badge` is written as a type argument too, but a tag of it is enough.
+    // A generic tag's own name is not read at all: no tag ends after
+    // `<PaginatedList` (its type arguments follow).
+    expect(renders('DocumentList')).toEqual(['Badge app/components/Badge.tsx:2']);
+    expect(renders('Table')).toEqual([]);
+  });
+
+  it('renders nothing for a name the parent binds itself as a const or a parameter', async () => {
+    write(
+      'app/components/CommandBarItem.tsx',
+      'export function Content() {\n  return <div />;\n}\n\nexport function Icon() {\n  return <svg />;\n}\n'
+    );
+    write('shared/editor/Widget.tsx', 'export function Widget() {\n  return <div />;\n}\n');
+    write('app/components/Portal.tsx', 'export function Portal({ children }) {\n  return <div>{children}</div>;\n}\n');
+    write(
+      'app/components/Menu.tsx',
+      `import * as DropdownMenu from '@radix-ui/react-dropdown-menu';
+import * as ContextMenu from '@radix-ui/react-context-menu';
+
+const Portal = DropdownMenu.Portal;
+
+export function SubMenuContent({ variant, children }) {
+  const Portal =
+    variant === 'dropdown' ? DropdownMenu.Portal : ContextMenu.Portal;
+  const Content =
+    variant === 'dropdown'
+      ? DropdownMenu.SubContent
+      : ContextMenu.SubContent;
+  return (
+    <Portal>
+      <Content collisionPadding={6}>{children}</Content>
+    </Portal>
+  );
+}
+
+export function SettingsLinks({ config }) {
+  return (
+    <ul>
+      {config.map((item) => {
+        const Icon = item.icon;
+        return <li key={item.path}><Icon /></li>;
+      })}
+    </ul>
+  );
+}
+
+export function Widgets({ widgets }) {
+  return <div>{Object.values(widgets).map((Widget, index) => <Widget key={index} />)}</div>;
+}
+`
+    );
+    await index();
+    // The file's own `Portal` is shadowed too: the tag means the local.
+    expect(renders('SubMenuContent')).toEqual([]);
+    expect(renders('SettingsLinks')).toEqual([]);
+    expect(renders('Widgets')).toEqual([]);
+  });
+
+  it('renders a component the parent declares inside itself, and the outer one for a tag above the local', async () => {
+    write('a-decoy/row.tsx', 'export function Row() {\n  return <tr />;\n}\n');
+    write('app/icon.tsx', 'export function Icon() {\n  return <svg />;\n}\n');
+    write(
+      'app/table.tsx',
+      `import { Icon } from './icon';
+
+function Row() {
+  return <tr className="outer" />;
+}
+
+export function Table({ rows }) {
+  const Row = ({ row }) => <tr>{row.name}</tr>;
+  return <table>{rows.map((row) => <Row key={row.id} row={row} />)}</table>;
+}
+
+export function Toolbar({ actions }) {
+  return (
+    <div>
+      <Icon />
+      {actions.map((action) => {
+        const Icon = action.icon;
+        return <Icon key={action.id} />;
+      })}
+    </div>
+  );
+}
+`
+    );
+    await index();
+    expect(renders('Table')).toEqual(['Row app/table.tsx:8']);
+    expect(renders('Toolbar')).toEqual(['Icon app/icon.tsx:1']);
+  });
+
+  it('keeps a destructured name on the same-named component, as a destructured call does', async () => {
+    // excalidraw's example app: `const { Sidebar, Footer, … } = excalidrawLib`.
+    // Destructuring is not the parent's own binding here, as it is not for a
+    // bare call (`const { t } = useI18n()`), so the name links by name.
+    write(
+      'packages/excalidraw/components/WelcomeScreen.tsx',
+      'export default function WelcomeScreen() {\n  return <div />;\n}\n'
+    );
+    write(
+      'examples/app/ExampleApp.tsx',
+      `export default function ExampleApp({ excalidrawLib }) {
+  const { WelcomeScreen, exportToSvg } = excalidrawLib;
+  return <div><WelcomeScreen /></div>;
+}
+`
+    );
+    await index();
+    expect(renders('ExampleApp')).toEqual(['WelcomeScreen packages/excalidraw/components/WelcomeScreen.tsx:1']);
+  });
+});
diff --git a/__tests__/jsx-render-work.test.ts b/__tests__/jsx-render-work.test.ts
new file mode 100644
index 0000000000..68f5ae4b87
--- /dev/null
+++ b/__tests__/jsx-render-work.test.ts
@@ -0,0 +1,84 @@
+/**
+ * The jsx-render pass reads each function's own lines for the component tags
+ * it renders. Every function of a minified bundle spans the bundle's one line,
+ * so it split, sliced and scanned the whole file once per function: 2,234
+ * times over go-ethereum's 980 KB `graphiql.min.js`, 25 of the 28 seconds its
+ * linking passes took on Node 22 (9 of 13 on Node 24). Functions that span
+ * the same lines render the same tags, so they share one scan. Counted, never
+ * timed.
+ */
+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';
+
+/** The source of the pass's tag pattern, to count its scans by. */
+const JSX_TAG_SOURCE = String.raw`<([A-Z][A-Za-z0-9_]*)[\s/>]`;
+
+describe('jsx-render pass work', () => {
+  let tmpDir: string | undefined;
+  let cg: CodeGraph | undefined;
+  const originalExec = RegExp.prototype.exec;
+
+  afterEach(() => {
+    RegExp.prototype.exec = originalExec;
+    cg?.close();
+    cg = undefined;
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5 });
+    tmpDir = undefined;
+  });
+
+  async function index(files: Record<string, string>): Promise<CodeGraph> {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-jsx-work-'));
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"dependencies":{"react":"^18.0.0"}}');
+    for (const [file, content] of Object.entries(files)) fs.writeFileSync(path.join(tmpDir, file), content);
+    cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+    return cg;
+  }
+
+  /** What each named function renders, by jsx-render edge. */
+  const renders = (graph: CodeGraph, name: string): string[] => {
+    const from = graph.getNodesByName(name).find((n) => n.kind === 'function' || n.kind === 'component')!;
+    return graph.getOutgoingEdges(from.id)
+      .filter((e) => (e.metadata as { synthesizedBy?: string } | undefined)?.synthesizedBy === 'jsx-render')
+      .map((e) => graph.getNode(e.target)!.name);
+  };
+
+  it('scans a line that many components share once, not once per component', async () => {
+    const COMPONENTS = 60;
+    const bundle = Array.from({ length: COMPONENTS }, (_, i) => `function Card${i}(){return <Badge/>}`).join('');
+    // A scan of the bundle's line: the tag pattern run over it from the start.
+    let scans = 0;
+    RegExp.prototype.exec = function (this: RegExp, input: string) {
+      if (this.source === JSX_TAG_SOURCE && this.lastIndex === 0 && typeof input === 'string' &&
+          input.includes(`Card${COMPONENTS - 1}(`)) scans++;
+      return originalExec.call(this, input);
+    };
+    const graph = await index({
+      'bundle.jsx': `${bundle}\n`,
+      'badge.jsx': 'export function Badge(){return null}\n',
+    });
+    RegExp.prototype.exec = originalExec;
+
+    for (const i of [0, 31, COMPONENTS - 1]) expect(renders(graph, `Card${i}`)).toEqual(['Badge']);
+    expect(scans).toBeGreaterThan(0);
+    expect(scans).toBeLessThan(COMPONENTS / 4);
+  });
+
+  it('keeps the tags of functions on different lines apart', async () => {
+    const graph = await index({
+      'page.jsx': [
+        'export function Page() { return <Header/>; }',
+        'export function Footer() {',
+        '  return <Links/>;',
+        '}',
+        'function Header(){return null} function Links(){return null}',
+        '',
+      ].join('\n'),
+    });
+    expect(renders(graph, 'Page')).toEqual(['Header']);
+    expect(renders(graph, 'Footer')).toEqual(['Links']);
+  });
+});
diff --git a/__tests__/kernel-ccpp-parity.test.ts b/__tests__/kernel-ccpp-parity.test.ts
index 720ffb623a..33baf912ec 100644
--- a/__tests__/kernel-ccpp-parity.test.ts
+++ b/__tests__/kernel-ccpp-parity.test.ts
@@ -232,6 +232,52 @@ describe.skipIf(!kernelBuilt)('kernel C/C++ extraction parity', () => {
     assertParity('fixtures/kern.cu', cuda, 'cpp');
   });
 
+  // protobuf's generated headers and leveldb's thread annotations put
+  // attribute macros where tree-sitter can't read them: stacked in a class
+  // head, between a pointer and its name, after a parameter list or a field,
+  // opening a member. The hoisted preParse blanks them all, so the file parses
+  // clean and goes through the kernel instead of deferring — at parity.
+  it.each(['\n', '\r\n'])('attribute-macro shapes parse clean through the hoisted preParse (%j)', (eol) => {
+    const source = [
+      'namespace google {',
+      'namespace protobuf {',
+      'class PROTOBUF_EXPORT  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Any final : public ::google::protobuf::Message',
+      '/* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {',
+      ' public:',
+      '  ~Any() PROTOBUF_FINAL;',
+      '  [[nodiscard]] const ::google::protobuf::UnknownFieldSet& unknown_fields() const',
+      '      ABSL_ATTRIBUTE_LIFETIME_BOUND {',
+      '    return _internal_metadata_.unknown_fields();',
+      '  }',
+      '  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL',
+      '  GetDescriptor() {',
+      '    return default_instance().GetMetadata().descriptor;',
+      '  }',
+      '  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD absl::string_view name() const { return name_; }',
+      '  void Swap(Any* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { InternalSwap(other); }',
+      '',
+      ' private:',
+      '  void InternalSwap(Any* PROTOBUF_NONNULL other);',
+      '  int count_ GUARDED_BY(mu_);',
+      '};',
+      'void Any::InternalSwap(Any* PROTOBUF_NONNULL other) { swap(*other); }',
+      '}  // namespace protobuf',
+      '}  // namespace google',
+      '',
+    ].join(eol);
+    assertParity('fixtures/any.pb.h', source, 'cpp', 6);
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract('fixtures/any.pb.h', source, 'cpp')!;
+    const methods = result.nodes.filter((n) => n.kind === 'method').map((n) => n.qualifiedName);
+    expect(methods).toEqual(expect.arrayContaining([
+      'google::protobuf::Any::GetDescriptor',
+      'google::protobuf::Any::InternalSwap',
+      'google::protobuf::Any::Swap',
+      'google::protobuf::Any::name',
+      'google::protobuf::Any::unknown_fields',
+    ]));
+  });
+
   // Every torture fixture again with CRLF line endings — the shape every
   // Windows autocrlf checkout has. Derived in memory (not a checked-in CRLF
   // file) so no platform or editor can silently normalize it away. Pins the
diff --git a/__tests__/kernel-csharp-parity.test.ts b/__tests__/kernel-csharp-parity.test.ts
index f26f5072df..7a15371891 100644
--- a/__tests__/kernel-csharp-parity.test.ts
+++ b/__tests__/kernel-csharp-parity.test.ts
@@ -8,11 +8,12 @@
  *
  *  - Torture.cs        — block namespace + nested/second-namespace quirks,
  *    base_list shapes, records, properties (incl. the bare-identifier
- *    signature loss and never-walked accessor bodies), fields/constants,
+ *    signature loss; accessor bodies and initializers walked as the
+ *    property), fields/constants (initializers walked as the field),
  *    events/operators/indexer/destructor (no nodes, calls → class), ctor
  *    initializer hole, explicit interface impl, local functions, the call
  *    zoo (raw member-access texts, chained re-encode, `(myDel)(x)` conv,
- *    `nameof`), instantiation shapes (incl. invisible `new()`/`new {}`/
+ *    `nameof`), instantiation shapes (incl. invisible body `new()`/`new {}`/
  *    arrays), static value reads, C# type refs, fn-ref candidates
  *    (`+=` subscription, `this.X` bare-name form, initializer lists),
  *    value-ref targets + local shadow prune, preprocessor passthrough.
@@ -167,6 +168,49 @@ describe.skipIf(!kernelBuilt)('kernel C# extraction parity', () => {
       source: 'public record Empty;\n',
       minNodes: 2,
     },
+    {
+      // Accessor bodies, `=> expr` and `= initializer` are walked as the
+      // property (calls, instantiations, static reads, fn-ref candidates).
+      name: 'property bodies and initializers are walked as the property',
+      source: [
+        'public class C {',
+        '  void H(int v) { }',
+        '  public Action P { get { return Make(H); } set { Register(H); } }',
+        '  public int Q => Run(H);',
+        '  public Action R { get; } = Wrap(H);',
+        '  public int S { get => Calc.Max; init => Store(new Widget()); }',
+        '}',
+        '',
+      ].join('\n'),
+      minNodes: 7,
+    },
+    {
+      // Each field declarator and each property `= initializer` is walked
+      // with its member on the stack — lambdas included — and its fn-ref
+      // candidates (varinit too) are the member's, captured once. A
+      // target-typed `new()` there instantiates the declared type; attribute
+      // arguments stay with the class's candidates-only scan.
+      name: 'field and property initializers are walked as the member',
+      source: [
+        'public class C {',
+        '  static void H() { }',
+        '  private readonly ILogger _log = LogManager.GetLogger(typeof(C));',
+        '  int a = 1, b = Calc.Max(2);',
+        '  private static readonly List<Action> Table = new() { H };',
+        '  private Widget? _w = new(1) { Size = Make() };',
+        '  private global::Ns.Box<int> _g = new(), _h = (new());',
+        '  private (int, int) _t = new();',
+        '  Action g = () => Register(H);',
+        '  Del d = H;',
+        '  public Widget P { get; } = new();',
+        '  public Action R { get; } = Wrap(H);',
+        '  public string S { get; } = Defaults.Name;',
+        '  [Attr(Make(H))] public int T { get; set; } = 3;',
+        '}',
+        '',
+      ].join('\n'),
+      minNodes: 17,
+    },
   ];
 
   for (const m of MICROS) {
diff --git a/__tests__/kernel-dart-parity.test.ts b/__tests__/kernel-dart-parity.test.ts
index 812f9f8c6f..487fcfd17d 100644
--- a/__tests__/kernel-dart-parity.test.ts
+++ b/__tests__/kernel-dart-parity.test.ts
@@ -6,8 +6,8 @@
  * ExtractionResult as the wasm TreeSitterExtractor — nodes, edges, and
  * unresolved refs compared as canonicalized multisets — over the checked-in
  * fixtures (torture.dart: the master inventory — imports incl. deferred
- * invisibility, dartdoc in all three comment forms with the
- * annotation-broken chain, stacked annotations in reverse order, the
+ * invisibility, dartdoc in all three comment forms and above an
+ * annotation, stacked annotations in reverse order, the
  * static_final_declaration constants hook, the full ctor set with the
  * unnamed-ctor skip and named-ctor renaming, operator methods as
  * `<anonymous>`, the extractBareCall matrix incl. cascade invisibility and
@@ -19,9 +19,26 @@
  * and the exact duplicated-ref interleave; TortureFnrefDart.dart: fn-ref
  * capture channels incl. named-argument non-capture and the file/class
  * twins; TortureMini/TortureSigs/TortureCtors/TortureVrefDart: signatures
- * verbatim, prefixed-return-type prefix bug, const factories invisible,
- * value-ref matrix with `$X` vs `${X}` asymmetry) and their CRLF variants
- * (derived in-memory — #1329), plus defer and generated-file pins.
+ * verbatim, prefixed-return-type prefix bug, a const factory as a method,
+ * value-ref matrix with `$X` vs `${X}` asymmetry; TortureReadsTypes.dart:
+ * getter-read refs and the type positions outside signatures — #2338/#2327;
+ * TortureInitializers.dart: initializers walked as the code their constant,
+ * class or file runs, every member-body kind, and a local declaration's
+ * second variable left to its function; TortureConstCtors.dart: `const`
+ * constructors and redirecting factories as methods with the unnamed ones
+ * skipped, every redirect-target form, and constructors called with type
+ * arguments, as statements and as expressions; TortureGenericCalls.dart:
+ * generic calls parsed as two comparisons, recovered as calls;
+ * TortureDeclarationDocs.dart: the dartdoc and annotations of a
+ * `declaration`-wrapped member with no body, read from before the wrapper;
+ * TortureCommentChains.dart: comments between a member chain's parts skipped
+ * by every sibling step; TortureAnnotatedDocs.dart: the dartdoc above a
+ * member's annotations, read past them, and what still ends the walk;
+ * TortureAnnotatedComments.dart: the comments between annotations and their
+ * declaration, stepped over by the decorator scan; TortureDirectives.dart /
+ * TorturePartOfName.dart: `part` as an import of the part's file, `part of`
+ * as nothing, and the arguments of annotated directives) and their CRLF
+ * variants (derived in-memory — #1329), plus defer and generated-file pins.
  *
  * The full-repo sweeps live in scripts/kernel-parity.mjs (shelf/bloc/flutter
  * with --max-deferral 0.3); this suite keeps the invariant alive in
@@ -110,6 +127,46 @@ describe.skipIf(!kernelBuilt)('kernel Dart extraction parity', () => {
     ['TortureSigs.dart', 4],
     ['TortureCtors.dart', 3],
     ['TortureVrefDart.dart', 4],
+    // Getter reads (#2338) and type positions outside signatures (#2327):
+    // extension `on` types, field / enum-field / top-level types, constant and
+    // field initializers, body types, and the read shapes that are not reads.
+    ['TortureReadsTypes.dart', 20],
+    // Initializers (top-level, static and instance) walked as code: calls,
+    // instantiations, reads, closures with block bodies and local functions,
+    // and function values captured once, for the declaration.
+    ['TortureInitializers.dart', 30],
+    // `const` constructors and redirecting factories as methods (the unnamed
+    // ones skipped), every redirect-target form, and constructors called
+    // with type arguments in statements and expressions.
+    ['TortureConstCtors.dart', 20],
+    // Generic calls the grammar parses as two comparisons (`ref.read<Repo>(p)`
+    // as `(ref.read < Repo) > (p)`): every callee, type-argument and argument
+    // shape, in bodies and initializers, and the comparisons that look alike.
+    ['TortureGenericCalls.dart', 10],
+    // Members with no body (`declaration`-wrapped constructors, abstract and
+    // external members) take their dartdoc and annotations from before the
+    // wrapper; a field's stay with the field.
+    ['TortureDeclarationDocs.dart', 20],
+    // Comments between a chain's parts — `tester //` + newline + `.state(…)`,
+    // dartdoc, block comments, one between a member and its arguments — are
+    // skipped by every sibling step: calls, chains, reads, static references.
+    ['TortureCommentChains.dart', 10],
+    // The dartdoc above a member's annotations (stacked, multi-line, inline,
+    // with comments between them) is read past them; a field, a variable, an
+    // import or the previous member's body still ends the walk. Class-like
+    // declarations open with their annotations.
+    ['TortureAnnotatedDocs.dart', 40],
+    // Comments of every form between annotations and the declaration they
+    // belong to — stacked, on the annotation's line, before members with no
+    // body — are stepped over by the decorator scan; a field, a variable, an
+    // import or the previous member's body still ends it.
+    ['TortureAnnotatedComments.dart', 30],
+    // A library's directives: imports and exports in every form, and `part`
+    // in every URI and quote form — each an import node and an `imports` ref
+    // — with the arguments of an annotated directive walked for fn-refs.
+    ['TortureDirectives.dart', 20],
+    // `part of` a library named by its library name records nothing.
+    ['TorturePartOfName.dart', 3],
   ] as const;
 
   for (const [file, minNodes] of FIXTURES) {
diff --git a/__tests__/kernel-rustlang-parity.test.ts b/__tests__/kernel-rustlang-parity.test.ts
index 3380ae67a8..523aab0fd7 100644
--- a/__tests__/kernel-rustlang-parity.test.ts
+++ b/__tests__/kernel-rustlang-parity.test.ts
@@ -113,6 +113,46 @@ fn next() {}
     assertParity('commands.rs', source.replace(/\n/g, '\r\n'));
   });
 
+  it('variant paths reference their receiver (#2328)', () => {
+    const source = `
+use crate::mode::{self, Mode};
+const DEFAULT: Mode = Mode::A;
+impl Mode {
+    fn flip(&self) -> u8 {
+        let _s = "ü"; let _x = Self::B;
+        match self { Self::A => 1, Mode::C(x) => *x, mode::Mode::D { x } => *x, _ => 0 }
+    }
+}
+trait Tr { fn t(&self) { let _ = Self::K; } }
+fn uses() {
+    use crate::mode::Mode::A;
+    let _a = crate::mode::Mode::A; let _b = Mode::C(1); let _c = Mode::D { x: 2 };
+    let _d = Mode::new(); let _e = util::take(3); let _f = u8::MAX; let _g = Limits::MAX;
+    let _h = xs.map(Mode::C); let _i = Option::<u8>::None; let _j = Mode::A.flip();
+    if let Mode::C(x) | Mode::B = m {}
+    match o { Option::Some(_) => std::cmp::Ordering::Less, _ => cmp::Ordering::Greater };
+}
+`;
+    assertParity('variants.rs', source);
+    assertParity('variants.rs', source.replace(/\n/g, '\r\n'));
+
+    // Not vacuous: each path to a capitalized member outside a call's callee,
+    // a struct literal and a `use` is a `references` ref to its receiver
+    // (`Self` read as the impl's type; none in a trait). The resolver decides
+    // which of them name a project enum's variant.
+    process.env.CODEGRAPH_KERNEL = '0';
+    const refs = extractFromSource('variants.rs', source, 'rust').unresolvedReferences;
+    delete process.env.CODEGRAPH_KERNEL;
+    const lines = source.split('\n');
+    const paths = refs
+      .filter((r) => r.referenceKind === 'references' && /^\w+\s*::/.test(lines[r.line - 1]!.slice(r.column)))
+      .map((r) => `${r.referenceName}:${r.line}`);
+    expect(paths.sort()).toEqual([
+      'Limits:14', 'Mode:13', 'Mode:15', 'Mode:15', 'Mode:16', 'Mode:16', 'Mode:3', 'Mode:6',
+      'Mode:7', 'Mode:7', 'Mode:7', 'Option:17', 'Ordering:17', 'Ordering:17',
+    ]);
+  });
+
   it('torture fixture: impl/trait quirks, use bindings, chains, fn-refs, value-refs, route macros', () => {
     const file = path.join(FIXTURE_DIR, 'torture.rs');
     assertParity('fixtures/torture.rs', fs.readFileSync(file, 'utf8'), 20);
diff --git a/__tests__/kernel-tsjs-parity.test.ts b/__tests__/kernel-tsjs-parity.test.ts
index dd4c8e13ae..9032f27ea2 100644
--- a/__tests__/kernel-tsjs-parity.test.ts
+++ b/__tests__/kernel-tsjs-parity.test.ts
@@ -96,6 +96,108 @@ describe.skipIf(!kernelBuilt)('kernel TS/JS extraction parity', () => {
     return viaWasm;
   }
 
+  it.each([
+    ['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
+  ] as const)('named object literals own their members: %s (#2300)', (ext, language) => {
+    const source = [
+      '/* é😀 */ const Api = { read() { helper(); }, close: () => helper(), gen: function* () { yield 1; }, \'quoted-key\': function () {}, [dyn()]() { helper(); }, eager: helper(), alias: helper, helper };',
+      'function helper() {}',
+      '/** Saved. */',
+      'export const Exported = { save() { helper(); } };',
+      '(function () { const Local = { run() { helper(); } }, data = { x: 1 }; Local.run(); window.WS = { ws() { Local.run(); } }; })();',
+      'App.utils = { pad(s) { return s; } };',
+      '// The page.',
+      'dw_page = { start() { helper(); } };',
+      'function setup() { ns.late = { go() {} }; let h; h = { on() {} }; }',
+      'module.exports = { cjs() {} };',
+      'Foo.prototype = { proto() {} };',
+      'self.handlers = { click() {} };',
+      'consume({ ephemeral() {} });',
+      '',
+    ].join('\n');
+    for (const ending of ['\n', '\r\n']) {
+      const result = assertParity(`literal.${ext}`, source.replace(/\n/g, ending), language);
+      expect(result.nodes.map((n) => n.qualifiedName)).toEqual(expect.arrayContaining([
+        'Api::read', 'Api::close', 'Api::gen', 'Api::quoted-key', 'Exported::save', 'Local::run', 'window.WS',
+        'window.WS::ws', 'App.utils::pad', 'dw_page::start', 'ns.late::go', 'self.handlers::click',
+      ]));
+      // A plain name reassigned inside a function is a local, not a namespace.
+      for (const name of ['cjs', 'proto', 'ephemeral', 'data', 'on']) expect(result.nodes.some((n) => n.name === name), name).toBe(false);
+    }
+  });
+
+  it.each(['bundle.js', 'vendor-min.js', 'vendor.min.js'])('a minified bundle keeps its literals unowned: %s (#2300)', (file) => {
+    // Mostly long lines dense with code punctuation, as a minifier writes them.
+    const line = `var a={b:function(){return c(1,2)},d:function(e){return e}};window.L={f:function(){return a.b()}};`.repeat(40);
+    const result = assertParity(file, `${line}\n${line}\n`, 'javascript');
+    expect(result.nodes.some((n) => n.kind === 'function' && (n.name === 'b' || n.name === 'f'))).toBe(false);
+  });
+
+  describe.each([
+    ['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
+  ] as const)('a store exported by a later statement: %s', (ext, language) => {
+    it.each(['LF', 'CRLF'])('keeps its actions (%s)', (ending) => {
+      // `export default useStore;` is found by a multiline regex over the
+      // source. JS's `$` matches before the `\r` of a CRLF line ending; the
+      // kernel's must too, or a Windows checkout loses the store's actions.
+      const source = [
+        'import { create } from "zustand";',
+        'const useStore = create((set) => ({ inc: () => set({}) }));',
+        'export default useStore;',
+        '',
+      ].join(ending === 'CRLF' ? '\r\n' : '\n');
+      const result = assertParity(`store.${ext}`, source, language);
+      expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(true);
+    });
+
+    it.each([
+      ['items$', 'export { items$ };', true],
+      ['$items', 'export { $items as default };', true],
+      ['items', 'export { items$ };', false],
+      ['items', 'export { $items };', false],
+    ] as const)('an export clause names %s only whole: `%s`', (name, exportLine, kept) => {
+      // `\b` takes a `$` for a separator: it can't bound `items$` or
+      // `$items`, and it finds `items` inside both. `other` keeps the
+      // negative cases above assertParity's node floor.
+      const source = [
+        'import { create } from "zustand";',
+        `const ${name} = create((set) => ({ inc: () => set({}) }));`,
+        'const other = 1;',
+        exportLine,
+        '',
+      ].join('\n');
+      const result = assertParity(`store.${ext}`, source, language);
+      expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(kept);
+    });
+  });
+
+  describe.each([
+    ['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
+  ] as const)('a store whose name has a `$`, exported by a later statement: %s', (ext, language) => {
+    // The later-export check builds a regex from the name. Its `$` must match
+    // the character, as the kernel's escaped pattern does, not a line end.
+    const store = (name: string, ...exportLines: string[]) => [
+      'import { create } from "zustand";',
+      `const ${name} = create((set) => ({ inc: () => set({}) }));`,
+      ...exportLines,
+      '',
+    ].join('\n');
+
+    it.each([
+      ['items$', 'export default items$;'],
+      ['$store', 'export default $store;'],
+      ['a$b', 'export { a$b };'],
+    ])('keeps its actions (%s)', (name, exportLine) => {
+      const result = assertParity(`store.${ext}`, store(name, exportLine), language);
+      expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(true);
+    });
+
+    it('is not exported by a different name at a line end', () => {
+      const result = assertParity(`store.${ext}`, store('items$', 'const items = 1;', 'export {', '  items', '};'), language);
+      expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(false);
+    });
+  });
+
   it.each([
     ['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
   ] as const)('same-line accessors retain distinct identities after Unicode: %s (#1349)', (ext, language) => {
@@ -188,6 +290,57 @@ async function exprReceivers(x, y) {
       ]);
   });
 
+  it.each([
+    ['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
+  ] as const)('walks a module-scope destructuring declaration like a body does: %s (#2340)', (ext, language) => {
+    const typed = language === 'typescript' || language === 'tsx';
+    const result = assertParity(`fixture.${ext}`, `
+import { handler } from './h';
+const { a } = useFoo(1);
+let [b, c] = pair();
+var { d: { e } } = nested();
+const { f = fallback() } = withDefault(handler);
+const [g = other(), ...rest] = list(() => inArrow(handler));
+export const { h } = exported(new Store());
+export const { useGetUserQuery } = api;
+${typed ? 'const { k }: Shape = make();' : ''}
+function probe() { const { j } = inner(); return j; }
+export function second() { return probe(); }
+`, language);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls').map((r) => r.referenceName);
+    expect(calls).toEqual(expect.arrayContaining([
+      'useFoo', 'pair', 'nested', 'fallback', 'withDefault', 'other', 'list', 'inArrow', 'exported', 'inner',
+      ...(typed ? ['make'] : []),
+    ]));
+  });
+
+  it.each([
+    ['ts', 'typescript'], ['tsx', 'tsx'],
+  ] as const)('typed styled tags are components, parsed as comparisons or not: %s', (ext, language) => {
+    // `styled.div<Props>\`…\`` parses as `(styled.div < Props) > \`…\``; the
+    // type argument's own operators sit between (`<A | B>`, `<Partial<A>>`).
+    const result = assertParity(`styles.${ext}`, `
+import styled, { css } from 'styled-components';
+import { s } from './theme';
+type Props = { align: 'start' | 'end' };
+const Plain = styled.div\`color: red;\`;
+export const Wrapper = styled.div<Props>\`color: \${(p) => s(p.align)};\`;
+const CloseAction = styled.div<{ animation: Animation | null }>\`top: 0;\`;
+const Content = styled(Plain)<Props>\`padding: 4px;\`;
+const NudeButton = styled(Plain).attrs((props: Props) => ({ type: "button" }))<Props>\`\`;
+const Either = styled.div<Props | Other>\`color: red;\`;
+const Nested = styled.div<Partial<Props>>\`color: red;\`;
+const Mixin = css<Props>\`color: red;\`;
+const Compared = styled.length < LIMIT > 2;
+const lowerCase = styled.div<Props>\`color: red;\`;
+`, language);
+    const kind = (name: string) => result.nodes.filter((n) => n.name === name).map((n) => n.kind);
+    for (const name of ['Plain', 'Wrapper', 'CloseAction', 'Content', 'NudeButton', 'Either', 'Nested']) {
+      expect(kind(name), name).toEqual(['component']);
+    }
+    for (const name of ['Mixin', 'Compared', 'lowerCase']) expect(kind(name), name).toEqual(['constant']);
+  });
+
   it('torture fixture (tsx): components, stores, RTK, fn-refs, value-refs, decorators', () => {
     const file = path.join(FIXTURE_DIR, 'torture.tsx');
     assertParity('fixtures/torture.tsx', fs.readFileSync(file, 'utf8'), 'tsx');
@@ -257,6 +410,30 @@ class Consumer:
     expect(result.unresolvedReferences.some(r => r.referenceKind === 'calls' && r.referenceName === 'c.Fetch')).toBe(true);
   });
 
+  it.each(['LF', 'CRLF'])('Go selector values stoplist the whole name, not the field (%s)', (ending) => {
+    // The stoplist holds bare words like Python's `None`; `raft.None` (etcd)
+    // and cgo's `C.NULL` are still values. The name is operand + field, so a
+    // break or comment after the dot keeps it; one inside the operand doesn't.
+    const source = `package demo
+import "example.com/raft"
+type Store struct{}
+func (s *Store) new() any { return nil }
+func wire(s *Store) {
+	Submit(raft.None, C.NULL, None, nil)
+	pool := sync.Pool{New: s.new}
+	Submit(raft.
+		Next, raft./* c */ Prev, raft.// c
+		Last)
+	Submit(s.
+		inner.Fetch)
+	_ = pool
+}
+`;
+    const result = assertParity('values.go', ending === 'CRLF' ? source.replace(/\n/g, '\r\n') : source, 'go');
+    const names = result.unresolvedReferences.filter(r => r.referenceKind === 'function_ref').map(r => r.referenceName);
+    expect(names.sort()).toEqual(['C.NULL', 'raft.Last', 'raft.Next', 'raft.None', 'raft.Prev', 's.new']);
+  });
+
   it.each(REAL_SOURCES)('real source parity: %s', (rel) => {
     const file = path.join(__dirname, '..', rel);
     assertParity(rel, fs.readFileSync(file, 'utf8'), 'typescript');
diff --git a/__tests__/kotlin-bare-member-scope.test.ts b/__tests__/kotlin-bare-member-scope.test.ts
new file mode 100644
index 0000000000..6121ad88c7
--- /dev/null
+++ b/__tests__/kotlin-bare-member-scope.test.ts
@@ -0,0 +1,130 @@
+/**
+ * A bare Kotlin call reaches a member of a type around it — a class, an
+ * anonymous `object : Base()`, an extension function's receiver — or of what
+ * those inherit; a member of a type the project's function types take as a
+ * lambda receiver (a DSL: koin's `single { get() }` runs on a Scope); or an
+ * object member the file imports. It never reaches another class's member by
+ * name: koin's `error("…")` — Kotlin's — went to a Logger's `error`, and
+ * `module { … }` in one test to another test class's private `module`.
+ * `require(n >= 0) { … }` is Kotlin's precondition, not a member `require`.
+ */
+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-kotlin-member-'));
+  const files: Record<string, string> = {
+    'src/main/kotlin/app/dsl/Module.kt': `package app.dsl
+
+class Scope {
+    fun get(): Any = 1
+}
+
+class Koin {
+    fun get(): Any = 2
+}
+
+class Module {
+    fun single(definition: Scope.() -> Any) { }
+}
+
+fun module(declaration: Module.() -> Unit): Module = Module().apply(declaration)
+`,
+    'src/main/kotlin/app/log/Logger.kt': `package app.log
+
+class Logger {
+    fun error(message: String) { }
+}
+`,
+    'src/main/kotlin/app/db/Table.kt': `package app.db
+
+abstract class Table {
+    fun integer(name: String): Int = 0
+}
+`,
+    'src/main/kotlin/app/io/Source.kt': `package app.io
+
+interface Source {
+    fun require(byteCount: Long)
+}
+
+class RealSource : Source {
+    override fun require(byteCount: Long) { }
+
+    fun read(byteCount: Long) {
+        require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
+        require(byteCount)
+    }
+}
+`,
+    'src/test/kotlin/app/TestUtil.kt': `package app
+
+object TestUtil {
+    fun deepCopy(value: Int): Int = value
+}
+`,
+    'src/test/kotlin/app/AppTest.kt': `package app
+
+import app.TestUtil.deepCopy
+import app.db.Table
+import app.dsl.module
+
+class AppTest {
+    fun wires() {
+        val m = module {
+            single { get() }
+        }
+        val table = object : Table() {
+            val id = integer("id")
+        }
+        val copy = deepCopy(1)
+        if (copy < 0) error("negative")
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('bare Kotlin calls', () => {
+  it('reach a DSL lambda’s receiver, an anonymous object’s base and an imported object member — nothing else', () => {
+    const calls = callsFrom('src/test/kotlin/app/AppTest.kt');
+    expect(calls).toContain('app.dsl::Module::single');
+    expect(calls).toContain('app.dsl::Scope::get');
+    expect(calls).toContain('app.db::Table::integer');
+    expect(calls).toContain('app::TestUtil::deepCopy');
+    expect(calls).not.toContain('app.dsl::Koin::get');
+    expect(calls).not.toContain('app.log::Logger::error');
+  });
+
+  it('leave Kotlin’s precondition `require(cond) { … }` to the standard library', () => {
+    const read = cg.getNodesInFile('src/main/kotlin/app/io/Source.kt').find((n) => n.name === 'read')!;
+    const requires = cg.getOutgoingEdgesFrom([read.id]).filter((e) => e.kind === 'calls').map((e) => e.line);
+    expect(requires).toEqual([12]);
+  });
+});
diff --git a/__tests__/kotlin-infix-calls.test.ts b/__tests__/kotlin-infix-calls.test.ts
new file mode 100644
index 0000000000..176b88411e
--- /dev/null
+++ b/__tests__/kotlin-infix-calls.test.ts
@@ -0,0 +1,81 @@
+/**
+ * A Kotlin infix call — `Users.id eq id1`, koin's `single { … } bind I::class`
+ * — is a call of the infix function; nothing recorded it before, so a
+ * project's infix DSL had no callers (Exposed's `eq` alone is called over a
+ * thousand times). A standard-library infix name on an expression receiver
+ * (`alias(libs.x) apply false` in a build script) is not a project method's.
+ */
+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-kotlin-infix-calls-'));
+  const files: Record<string, string> = {
+    'src/main/kotlin/app/Ops.kt': `package app
+
+class Column {
+    infix fun eq(other: Int): Boolean = true
+}
+
+class Definition {
+    infix fun bind(type: Any): Definition = this
+}
+
+fun single(block: () -> Any): Definition = Definition()
+
+class Ops(private val id: Column) {
+    fun same(id1: Int): Boolean = id eq id1
+
+    fun wire() {
+        single { Ops(Column()) } bind Ops::class
+    }
+}
+
+class Spec {
+    fun apply(block: Spec.() -> Unit): Spec = this
+}
+`,
+    'build.gradle.kts': `plugins {
+    alias(libs.plugins.kotlin.jvm) apply false
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('Kotlin infix calls', () => {
+  it('call the infix function', () => {
+    const calls = callsFrom('src/main/kotlin/app/Ops.kt');
+    expect(calls).toContain('app::Column::eq');
+    expect(calls).toContain('app::Definition::bind');
+  });
+
+  it('leave a standard infix name on an expression to the library', () => {
+    expect(callsFrom('build.gradle.kts')).not.toContain('app::Spec::apply');
+  });
+});
diff --git a/__tests__/kotlin-infix-e-parse.test.ts b/__tests__/kotlin-infix-e-parse.test.ts
new file mode 100644
index 0000000000..35a19ead46
--- /dev/null
+++ b/__tests__/kotlin-infix-e-parse.test.ts
@@ -0,0 +1,55 @@
+/**
+ * The Kotlin grammar's scanner inserted an automatic semicolon on the same
+ * line before any word starting with `e` that was not `else` — so an infix
+ * call named like Exposed's `eq` (`Users.id eq id1`) ended its statement
+ * early and the rest became a parse error. Error recovery could then swallow
+ * the class around it: Exposed's r2dbc `UpsertTests` came out as one loose
+ * function nesting all its tests. The vendored scanner (wasm and kernel) is
+ * patched; see docs/grammars/tree-sitter-kotlin.md.
+ */
+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';
+import { initGrammars, loadGrammarsForLanguages, getParser } from '../src/extraction/grammars';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-kotlin-infix-'));
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src/Ops.kt'), `package app
+
+infix fun Int.eq(other: Int): Boolean = this == other
+
+class Ops {
+    fun same(a: Int, b: Int): Boolean = a eq b
+
+    fun found(id1: Int): Int = listOf(1).filter { it eq id1 }.single()
+}
+`);
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('a Kotlin infix call named with a leading `e`', () => {
+  it('parses clean', async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['kotlin']);
+    const parser = getParser('kotlin')!;
+    for (const src of ['fun f() { val c = a eq b }', 'fun f() { w { t.id eq id1 }.single() }', 'fun f() { if (a) b else c }']) {
+      expect(parser.parse(src)!.rootNode.hasError, src).toBe(false);
+    }
+  });
+
+  it('leaves the class around it and its methods intact', () => {
+    const methods = cg.getNodesInFile('src/Ops.kt').filter((n) => n.qualifiedName.startsWith('app::Ops::')).map((n) => n.name).sort();
+    expect(methods).toEqual(['found', 'same']);
+  });
+});
diff --git a/__tests__/kotlin-lambda-receiver.test.ts b/__tests__/kotlin-lambda-receiver.test.ts
new file mode 100644
index 0000000000..46c2abf96b
--- /dev/null
+++ b/__tests__/kotlin-lambda-receiver.test.ts
@@ -0,0 +1,95 @@
+/**
+ * A Kotlin lambda runs on the receiver its function's parameter type names —
+ * directly (`Scope.() -> T`) or through a typealias (koin's `definition:
+ * Definition<T>` with `typealias Definition<T> = Scope.(ParametersHolder) ->
+ * T`) — and the members the code around a bare call reaches come before
+ * those only some other lambda type in the project could: koin's
+ * `single { C51(get(), get()) }` and `Scope.new(…)`'s `get()` are Scope's,
+ * not Koin's (2,190 of them).
+ */
+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-kotlin-lambda-'));
+  const files: Record<string, string> = {
+    'src/main/kotlin/org/koin/core/Koin.kt': `package org.koin.core
+
+class Koin {
+    fun <T> get(): T = TODO()
+}
+
+fun koinTest(block: Koin.() -> Unit) { }
+`,
+    'src/main/kotlin/org/koin/core/scope/Scope.kt': `package org.koin.core.scope
+
+class Scope {
+    fun <T> get(): T = TODO()
+}
+`,
+    'src/main/kotlin/org/koin/core/definition/Definition.kt': `package org.koin.core.definition
+
+import org.koin.core.scope.Scope
+
+typealias Definition<T> = Scope.(Int) -> T
+`,
+    'src/main/kotlin/org/koin/core/module/Module.kt': `package org.koin.core.module
+
+import org.koin.core.definition.Definition
+
+class Module {
+    fun <T> single(definition: Definition<T>) { }
+}
+`,
+    'src/main/kotlin/org/koin/dsl/New.kt': `package org.koin.dsl
+
+import org.koin.core.scope.Scope
+
+inline fun <reified R, reified T1, reified T2> Scope.new(
+    constructor: (T1, T2) -> R,
+): R = constructor(get(), get())
+`,
+    'src/test/kotlin/app/Perfs.kt': `package app
+
+import org.koin.core.module.Module
+
+class C51(a: Int, b: Int)
+
+fun perfModule(m: Module) {
+    m.single { C51(get(), get()) }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const getTargets = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return [...new Set(cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!).filter((t) => t.name === 'get').map((t) => t.qualifiedName))];
+};
+
+describe('Kotlin lambda receivers', () => {
+  it('a lambda passed through a typealiased function type runs on its receiver', () => {
+    expect(getTargets('src/test/kotlin/app/Perfs.kt')).toEqual(['org.koin.core.scope::Scope::get']);
+  });
+
+  it('an extension function’s receiver beats a lambda type elsewhere', () => {
+    expect(getTargets('src/main/kotlin/org/koin/dsl/New.kt')).toEqual(['org.koin.core.scope::Scope::get']);
+  });
+});
diff --git a/__tests__/kotlin-newer-syntax.test.ts b/__tests__/kotlin-newer-syntax.test.ts
new file mode 100644
index 0000000000..81713ddbc0
--- /dev/null
+++ b/__tests__/kotlin-newer-syntax.test.ts
@@ -0,0 +1,80 @@
+/**
+ * Kotlin syntax newer than the vendored grammar — `when` guards (2.1), `..<`
+ * ranges (1.9), multi-dollar strings (2.1), nullable function-type
+ * receivers — is rewritten to an older equivalent of the same length before
+ * the parse; otherwise error recovery dropped the class around it (Exposed's
+ * dialect classes came out as loose functions).
+ */
+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';
+import { rewriteNewerKotlinSyntax } from '../src/extraction/languages/kotlin';
+
+const SOURCE = `package app
+
+class Dialect(private val mode: Int) {
+    fun sql(value: Any?): String = when (value) {
+        is String if mode == 2 -> "text"
+        is Int if (
+            mode > 0
+        ) -> "int"
+        is Long -> if (mode == 1) "long" else "big"
+        else -> "other"
+    }
+
+    fun ranges(n: Int) {
+        for (i in 0..<n) println(i)
+    }
+
+    fun path(team: String) = $$"?(@.user.team == $team)"
+
+    fun adjust(body: Op<Boolean>?.() -> Op<Boolean>): Dialect = this
+
+    fun after(): Int = 1
+}
+
+class Op<T>
+`;
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-kotlin-newer-'));
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src/Dialect.kt'), SOURCE);
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('newer Kotlin syntax', () => {
+  it('is rewritten with every offset intact', () => {
+    const out = rewriteNewerKotlinSyntax(SOURCE);
+    expect(out.length).toBe(SOURCE.length);
+    expect(out).toContain('is String,   mode == 2 ->');
+    expect(out).toContain('is Long -> if (mode == 1)');
+    expect(out).toContain('0.. n');
+    expect(out).toContain('  "?(@.user.team == $team)"');
+    expect(out).toContain('Op<Boolean>.( ) -> Op<Boolean>');
+  });
+
+  it('keeps the class around it and every method', () => {
+    const methods = cg.getNodesInFile('src/Dialect.kt')
+      .filter((n) => n.kind === 'method')
+      .map((n) => n.qualifiedName)
+      .sort();
+    expect(methods).toEqual([
+      'app::Dialect::adjust',
+      'app::Dialect::after',
+      'app::Dialect::path',
+      'app::Dialect::ranges',
+      'app::Dialect::sql',
+    ]);
+  });
+});
diff --git a/__tests__/kotlin-split-constructor-std-chain.test.ts b/__tests__/kotlin-split-constructor-std-chain.test.ts
new file mode 100644
index 0000000000..645c2f721a
--- /dev/null
+++ b/__tests__/kotlin-split-constructor-std-chain.test.ts
@@ -0,0 +1,78 @@
+/**
+ * Two Kotlin fixes that travel together:
+ * - a primary constructor on the line after its class name with a supertype
+ *   list (`expect open class ByteString` / `internal constructor(…) :
+ *   Comparable<ByteString> {`, Kotlin Multiplatform's shape) dropped the class
+ *   and scattered its members as loose functions; the constructor's modifiers
+ *   and keyword are blanked (offsets kept) so the class parses;
+ * - with members back on their classes, a standard-library name on an
+ *   untyped chain link (`builder.apply { … }`, `"x".toPath().toString()`)
+ *   needs a receiver named after the owner — okhttp's `.apply { }` went to
+ *   `ConnectionSpec.apply`.
+ */
+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';
+import { joinKotlinSplitConstructors } from '../src/extraction/languages/kotlin';
+
+let root = '';
+let cg: CodeGraph;
+
+const BYTE_STRING = `package okio
+
+expect open class ByteString
+// Trusted internal constructor doesn't clone data.
+internal constructor(data: ByteArray) : Comparable<ByteString> {
+  fun hex(): String
+  fun toByteArray(): ByteArray
+}
+`;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-kotlin-split-'));
+  const files: Record<string, string> = {
+    'src/commonMain/kotlin/okio/ByteString.kt': BYTE_STRING,
+    'src/main/kotlin/app/ConnectionSpec.kt': `package app
+
+class ConnectionSpec {
+  fun apply(sslSocket: Any, isFallback: Boolean) {}
+}
+`,
+    'src/main/kotlin/app/Builder.kt': `package app
+
+class Builder {
+  var name = ""
+  fun build(): String = StringBuilder().apply { append(name) }.toString()
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Kotlin split primary constructors and standard chain calls', () => {
+  it('keeps the class and its members', () => {
+    const nodes = cg.getNodesInFile('src/commonMain/kotlin/okio/ByteString.kt');
+    const hex = nodes.find((n) => n.name === 'hex')!;
+    expect(hex.qualifiedName).toBe('okio::ByteString::hex');
+    const out = joinKotlinSplitConstructors(BYTE_STRING);
+    expect(out.length).toBe(BYTE_STRING.length);
+    expect(out.split('\n')[4]).toMatch(/^\s+\(data: ByteArray\) : Comparable<ByteString> \{$/);
+  });
+
+  it('never sends a scope function to a project type', () => {
+    const build = cg.getNodesInFile('src/main/kotlin/app/Builder.kt').find((n) => n.name === 'build')!;
+    const targets = cg.getOutgoingEdges(build.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(targets.some((t) => t.endsWith('ConnectionSpec::apply'))).toBe(false);
+  });
+});
diff --git a/__tests__/kotlin-top-level-visibility.test.ts b/__tests__/kotlin-top-level-visibility.test.ts
new file mode 100644
index 0000000000..11850413ef
--- /dev/null
+++ b/__tests__/kotlin-top-level-visibility.test.ts
@@ -0,0 +1,153 @@
+/**
+ * A top-level Kotlin function — an extension function included — is visible
+ * from its own package, and from a file that imports it by name or imports
+ * its package with `*`. Nowhere else.
+ *
+ * Exposed keeps a JDBC and an R2DBC test suite, each with a
+ * `fun <T> …Transaction.assertEquals(…)` helper. Tests that imported
+ * kotlin.test's or JUnit's `assertEquals`, or the JDBC helper, all landed on
+ * the R2DBC one: 3,075 calls. okhttp's tests constructed the deprecated
+ * `okhttp3.mockwebserver.MockResponse` although every one imports
+ * `mockwebserver3.MockResponse`.
+ *
+ * Also: a function type with a qualified receiver
+ * (`(DatabaseConfig.Builder.() -> Unit)?`) no longer breaks the parse of the
+ * class around it. Exposed's `DatabaseTestsBase` came out as loose functions.
+ */
+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';
+import { blankKotlinQualifiedReceivers } from '../src/extraction/languages/kotlin';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-kotlin-visibility-'));
+  const files: Record<string, string> = {
+    'jdbc/src/main/kotlin/app/jdbc/tests/Assert.kt': `package app.jdbc.tests
+
+class JdbcTransaction
+
+fun withTables(statement: JdbcTransaction.() -> Unit) {}
+
+fun <T> JdbcTransaction.assertEquals(exp: T, act: T) {}
+`,
+    'r2dbc/src/main/kotlin/app/r2dbc/tests/Assert.kt': `package app.r2dbc.tests
+
+class R2dbcTransaction
+
+fun withTables(statement: R2dbcTransaction.() -> Unit) {}
+
+fun <T> R2dbcTransaction.assertEquals(exp: T, act: T) {}
+`,
+    'jdbc/src/test/kotlin/app/jdbc/JdbcTest.kt': `package app.jdbc
+
+import app.jdbc.tests.assertEquals
+import app.jdbc.tests.withTables
+
+class JdbcTest {
+  fun works() {
+    withTables { assertEquals(1, 1) }
+  }
+}
+`,
+    'r2dbc/src/test/kotlin/app/r2dbc/R2dbcTest.kt': `package app.r2dbc
+
+import app.r2dbc.tests.*
+
+class R2dbcTest {
+  fun works() {
+    withTables { assertEquals(1, 1) }
+  }
+}
+`,
+    'core/src/test/kotlin/app/core/PlainTest.kt': `package app.core
+
+import kotlin.test.assertEquals
+
+class PlainTest {
+  fun works() {
+    assertEquals(1, 1)
+  }
+}
+`,
+    'jdbc/src/main/kotlin/app/jdbc/tests/Local.kt': `package app.jdbc.tests
+
+fun check() {
+  withTables { assertEquals(1, 1) }
+}
+`,
+    'jdbc/src/main/kotlin/app/jdbc/tests/DatabaseTestsBase.kt': `package app.jdbc.tests
+
+class DatabaseConfig {
+  class Builder
+}
+
+@MethodSource("data")
+abstract class DatabaseTestsBase {
+  fun withTables(configure: (DatabaseConfig.Builder.() -> Unit)? = null, statement: () -> Unit) {
+    statement()
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** The file each `assertEquals` call in `file` resolved to. */
+function assertTargets(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!)
+    .filter((n) => n.name === 'assertEquals')
+    .map((n) => n.filePath);
+}
+
+describe('Kotlin top-level functions are visible where imported', () => {
+  it('an explicit import picks that package’s extension', () => {
+    expect(assertTargets('jdbc/src/test/kotlin/app/jdbc/JdbcTest.kt')).toEqual(['jdbc/src/main/kotlin/app/jdbc/tests/Assert.kt']);
+  });
+
+  it('a star import of the package does too', () => {
+    expect(assertTargets('r2dbc/src/test/kotlin/app/r2dbc/R2dbcTest.kt')).toEqual(['r2dbc/src/main/kotlin/app/r2dbc/tests/Assert.kt']);
+  });
+
+  it('a file importing kotlin.test’s assertEquals reaches neither project helper', () => {
+    expect(assertTargets('core/src/test/kotlin/app/core/PlainTest.kt')).toEqual([]);
+  });
+
+  it('the same package needs no import', () => {
+    expect(assertTargets('jdbc/src/main/kotlin/app/jdbc/tests/Local.kt')).toEqual(['jdbc/src/main/kotlin/app/jdbc/tests/Assert.kt']);
+  });
+});
+
+describe('a function type with a qualified receiver', () => {
+  it('keeps the class around it', () => {
+    const nodes = cg.getNodesInFile('jdbc/src/main/kotlin/app/jdbc/tests/DatabaseTestsBase.kt');
+    const withTables = nodes.find((n) => n.name === 'withTables')!;
+    expect(withTables.kind).toBe('method');
+    expect(withTables.qualifiedName).toBe('app.jdbc.tests::DatabaseTestsBase::withTables');
+  });
+
+  it('is blanked to its simple name, offsets intact', () => {
+    const src = 'fun f(c: (DatabaseConfig.Builder.() -> Unit)?, d: a.b.Response.Builder<T>.(Int) -> Unit, e: Builder.() -> Unit) {}';
+    const out = blankKotlinQualifiedReceivers(src);
+    expect(out.length).toBe(src.length);
+    const blank = (s: string) => ' '.repeat(s.length);
+    expect(out).toBe(src.replace('DatabaseConfig.', blank('DatabaseConfig.')).replace('a.b.Response.', blank('a.b.Response.')));
+  });
+});
diff --git a/__tests__/laravel-controller-strings.test.ts b/__tests__/laravel-controller-strings.test.ts
new file mode 100644
index 0000000000..e5497796cf
--- /dev/null
+++ b/__tests__/laravel-controller-strings.test.ts
@@ -0,0 +1,74 @@
+/**
+ * A Laravel route names its controller however the app writes it: akaunting
+ * writes `'Common\Uploads@inline'` — no `Controller` suffix, a namespace below
+ * App\Http\Controllers — and `Route::resource('companies', 'Common\Companies',
+ * [...options])`. Only `XController@action` was read, so 304 of akaunting's
+ * 313 routes bound to nothing. Same-named controllers in two namespaces are
+ * told apart by the written path.
+ */
+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;
+
+const controller = (ns: string, name: string, methods: string[]) => `<?php
+
+namespace App\\Http\\Controllers\\${ns};
+
+class ${name}
+{
+${methods.map((m) => `    public function ${m}() { return 1; }`).join('\n')}
+}
+`;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-laravel-strings-'));
+  const files: Record<string, string> = {
+    'artisan': '#!/usr/bin/env php\n',
+    'composer.json': JSON.stringify({ require: { 'laravel/framework': '^10.0' } }),
+    'routes/admin.php': `<?php
+
+use Illuminate\\Support\\Facades\\Route;
+
+Route::get('uploads/{id}/inline', 'Common\\Uploads@inline')->name('inline');
+Route::delete('uploads/{id}', 'Common\\Uploads@destroy');
+Route::get('portal/uploads/{id}', 'Portal\\Uploads@inline');
+Route::resource('companies', 'Common\\Companies', ['middleware' => ['dropzone']]);
+`,
+    'app/Http/Controllers/Common/Uploads.php': controller('Common', 'Uploads', ['inline', 'destroy']),
+    'app/Http/Controllers/Portal/Uploads.php': controller('Portal', 'Uploads', ['inline']),
+    'app/Http/Controllers/Common/Companies.php': controller('Common', 'Companies', ['index', 'store']),
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const servedBy = (routeName: string) => {
+  const route = cg.getNodesByKind('route').find((r) => r.name === routeName);
+  expect(route, routeName).toBeDefined();
+  return cg.getOutgoingEdgesFrom([route!.id]).map((e) => cg.getNode(e.target)!).map((n) => `${n.name} ${n.filePath}`);
+};
+
+describe('Laravel string controllers', () => {
+  it('resolve without a Controller suffix, by their namespace path', () => {
+    expect(servedBy('GET /uploads/{id}/inline')).toEqual(['inline app/Http/Controllers/Common/Uploads.php']);
+    expect(servedBy('DELETE /uploads/{id}')).toEqual(['destroy app/Http/Controllers/Common/Uploads.php']);
+    expect(servedBy('GET /portal/uploads/{id}')).toEqual(['inline app/Http/Controllers/Portal/Uploads.php']);
+  });
+
+  it('read a resource controller named by string, past its options', () => {
+    expect(servedBy('resource:companies')).toEqual(['Companies app/Http/Controllers/Common/Companies.php']);
+  });
+});
diff --git a/__tests__/library-receiver-calls.test.ts b/__tests__/library-receiver-calls.test.ts
new file mode 100644
index 0000000000..72e3f8cd9b
--- /dev/null
+++ b/__tests__/library-receiver-calls.test.ts
@@ -0,0 +1,129 @@
+/**
+ * Calls on a library's own types and modules stay the library's, not a
+ * same-named project method's:
+ *
+ * - Rust `Vec::new()` / `task::spawn(…)`: a type the project doesn't declare,
+ *   and a module path (tokio's `task::spawn` went to TaskTracker's `spawn`
+ *   300 times, `Vec::new` to a VecWithInitialized);
+ * - a link further down a multi-line Rust chain is named after the chain's
+ *   head: `bat()\n.stdout(…)` is assert_cmd's, `Arg::new("x")\n.value_hint(…)`
+ *   the project's Arg;
+ * - Go's `w.Header().Get(…)` is net/http's Header, not gin's `Context.Get`;
+ * - R's bare `range(x)` is base R's, not a ggproto object's `range` method;
+ * - JS `response.text()` is fetch's Response, not a project class's `text`.
+ */
+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-library-receivers-'));
+  const files: Record<string, string> = {
+    'src/lib.rs': `pub struct VecWithInitialized;
+impl VecWithInitialized {
+    pub fn new() -> Self { VecWithInitialized }
+}
+
+pub struct TaskTracker;
+impl TaskTracker {
+    pub fn spawn(&self) {}
+}
+
+pub struct OutputType;
+impl OutputType {
+    pub fn stdout(&self) {}
+}
+
+pub struct Arg;
+impl Arg {
+    pub fn new(name: &str) -> Arg { Arg }
+    pub fn value_hint(self, hint: u8) -> Arg { self }
+}
+
+pub fn run() {
+    let v: Vec<u8> = Vec::new();
+    task::spawn(async {});
+    bat()
+        .assert()
+        .stdout("x");
+    let a = Arg::new("cmd")
+        .value_hint(1);
+}
+`,
+    'context.go': `package gin
+
+type Context struct{}
+
+func (c *Context) Get(key string) (any, bool) { return nil, false }
+
+func handler(w Writer) string {
+	return w.Header().Get("Content-Type")
+}
+`,
+    'R/coord.R': `Coord <- ggproto("Coord",
+  range = function(panel_params) {
+    list(x = panel_params$x$dimension())
+  }
+)
+
+scale_limits <- function(x) {
+  range(x)
+}
+`,
+    'src/file.js': `export class LazyFile {
+  text() { return ''; }
+}
+
+export async function load(response) {
+  return await response.text();
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('calls on a library’s types and modules', () => {
+  it('Rust: outside types, module paths and multi-line chains', () => {
+    const calls = callsFrom('src/lib.rs');
+    expect(calls).not.toContain('VecWithInitialized::new');
+    expect(calls).not.toContain('TaskTracker::spawn');
+    expect(calls).not.toContain('OutputType::stdout');
+    expect(calls).toContain('Arg::value_hint');
+  });
+
+  it('Go: net/http Header methods', () => {
+    expect(callsFrom('context.go')).not.toContain('Context::Get');
+  });
+
+  it('R: a bare call is a function, not an object’s method', () => {
+    expect(callsFrom('R/coord.R').filter((q) => q.endsWith('range'))).toEqual([]);
+  });
+
+  it('JS: fetch Response bodies', () => {
+    expect(callsFrom('src/file.js')).not.toContain('LazyFile::text');
+  });
+});
diff --git a/__tests__/lua-bare-builtins.test.ts b/__tests__/lua-bare-builtins.test.ts
new file mode 100644
index 0000000000..85ad547fd1
--- /dev/null
+++ b/__tests__/lua-bare-builtins.test.ts
@@ -0,0 +1,88 @@
+/**
+ * A bare Lua call cannot reach a table's method — `function M.error()` is
+ * `M.error(…)`, never `error(…)` — and a Lua global (`ipairs`, `error`,
+ * busted's `setup`) is Lua's unless the file defines its own. Telescope's
+ * 120 `for _, v in ipairs(…)` went to a linked list's `ipairs` method,
+ * kong's 118 `error(…)` to its response PDK's `error`. A function's own
+ * `local get_query = kong.request.get_query` alias still reaches the method
+ * of the table named after its holder.
+ */
+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-lua-builtins-'));
+  const files: Record<string, string> = {
+    'lua/app/linked_list.lua': `local LinkedList = {}
+
+function LinkedList:ipairs()
+  return function() end
+end
+
+return LinkedList
+`,
+    'lua/app/response.lua': `local _RESPONSE = {}
+
+function _RESPONSE.error(status)
+  return status
+end
+
+return _RESPONSE
+`,
+    'lua/app/request.lua': `local _REQUEST = {}
+
+function _REQUEST.get_query()
+  return {}
+end
+
+return _REQUEST
+`,
+    'lua/app/handler.lua': `local M = {}
+
+function M.run(items)
+  for _, v in ipairs(items) do
+    if not v then
+      error("missing")
+    end
+  end
+  local get_query = kong.request.get_query
+  return get_query()
+end
+
+return M
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const callsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.qualifiedName).sort();
+};
+
+describe('bare Lua calls', () => {
+  it('are Lua’s globals, never a table’s method of that name', () => {
+    const calls = callsFrom('lua/app/handler.lua');
+    expect(calls).not.toContain('LinkedList::ipairs');
+    expect(calls).not.toContain('_RESPONSE::error');
+  });
+
+  it('still follow a function’s own alias of a host table’s member', () => {
+    expect(callsFrom('lua/app/handler.lua')).toContain('_REQUEST::get_query');
+  });
+});
diff --git a/__tests__/lua-library-calls.test.ts b/__tests__/lua-library-calls.test.ts
new file mode 100644
index 0000000000..381cb89814
--- /dev/null
+++ b/__tests__/lua-library-calls.test.ts
@@ -0,0 +1,78 @@
+/**
+ * A Lua call through a standard or host library table (`string`, `table`,
+ * `vim`, `ngx`, busted's `assert` …), or a string method on a value
+ * (`s:find(…)`), is the library's — never the one project method that shares
+ * the name. kong's specs sent `assert.truthy(…)` to a condition helper 987
+ * times; telescope's `line:find(…)` went to its picker's `find`. A method the
+ * project defines on the table itself (kong patches `ngx.sleep`) keeps it.
+ */
+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-lua-library-'));
+  const files: Record<string, string> = {
+    'spec/helpers/wait.lua': `local COND = {}
+function COND:truthy(v)
+  return v
+end
+return COND
+`,
+    'lua/picker.lua': `local Picker = {}
+function Picker:find(text)
+  return text
+end
+return Picker
+`,
+    'lua/patches.lua': `function ngx.sleep(s)
+  return s
+end
+`,
+    'lua/widget.lua': `local Widget = {}
+function Widget:refresh()
+  return true
+end
+return Widget
+`,
+    'spec/run_spec.lua': `local function run(line, w)
+  assert.truthy(line)
+  local at = line:find("x")
+  ngx.sleep(1)
+  w:refresh()
+  return at
+end
+return run
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Lua library calls', () => {
+  it('stay the library’s; a project method keeps a plain receiver and a patched library function', () => {
+    const ids = cg.getNodesInFile('spec/run_spec.lua').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName)
+      .sort();
+    expect(targets).not.toContain('COND::truthy');
+    expect(targets).not.toContain('Picker::find');
+    expect(targets).toContain('Widget::refresh');
+    expect(targets.some((t) => t.endsWith('sleep'))).toBe(true);
+  });
+});
diff --git a/__tests__/lua-local-alias-calls.test.ts b/__tests__/lua-local-alias-calls.test.ts
new file mode 100644
index 0000000000..4c9a120936
--- /dev/null
+++ b/__tests__/lua-local-alias-calls.test.ts
@@ -0,0 +1,115 @@
+/**
+ * A bare Lua call through a `local` alias reaches what the alias names. Kong
+ * localizes everything it calls — `local splitn = require("kong.tools.string").splitn`,
+ * `local check_phase = phase_checker.check`, `local fmt = string.format`,
+ * `local type = type` — so its calls stopped at a same-file variable: 8,000 of
+ * them, most for the standard library. A module member is followed to its
+ * function, including one the module hands out under another name
+ * (`return { check = check_phase }`) or re-exports from a module of its own
+ * (`unindent = misc.unindent`); the standard library and outside modules are
+ * no edge at all.
+ */
+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-lua-alias-'));
+  const files: Record<string, string> = {
+    'kong/tools/string.lua': `local _M = {}
+
+function _M.splitn(value)
+  return value
+end
+
+return _M
+`,
+    'kong/pdk/phases.lua': `local function check_phase(accepted)
+  return accepted
+end
+
+return {
+  check = check_phase,
+}
+`,
+    'kong/handler.lua': `local type = type
+local fmt = string.format
+local splitn = require("kong.tools.string").splitn
+local phase_checker = require "kong.pdk.phases"
+local check_phase = phase_checker.check
+local cjson_encode = require("cjson").encode
+
+local function run(v)
+  check_phase("access")
+  if type(v) ~= "string" then
+    error(fmt("bad %s", v))
+  end
+  return splitn(v), cjson_encode(v)
+end
+
+return { run = run }
+`,
+    'spec/internal/misc.lua': `local function unindent(s)
+  return s
+end
+
+return { unindent = unindent }
+`,
+    'spec/helpers.lua': `local misc = require("spec.internal.misc")
+
+return {
+  unindent = misc.unindent,
+}
+`,
+    'spec/handler_spec.lua': `local helpers = require "spec.helpers"
+local unindent = helpers.unindent
+
+describe("handler", function()
+  it("runs", function()
+    unindent("a")
+  end)
+end)
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `file: qualified name` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${t.filePath}: ${t.qualifiedName}`;
+    })
+    .sort();
+}
+
+describe('bare Lua calls through a local alias', () => {
+  it('reach the module function the alias names, and nothing for the standard library', () => {
+    expect(callsFrom('kong/handler.lua')).toEqual([
+      'kong/pdk/phases.lua: check_phase',
+      'kong/tools/string.lua: _M::splitn',
+    ]);
+  });
+
+  it('follow a module that re-exports another module’s member', () => {
+    expect(callsFrom('spec/handler_spec.lua')).toEqual(['spec/internal/misc.lua: unindent']);
+  });
+});
diff --git a/__tests__/lua-local-visibility.test.ts b/__tests__/lua-local-visibility.test.ts
new file mode 100644
index 0000000000..acefdeb2a8
--- /dev/null
+++ b/__tests__/lua-local-visibility.test.ts
@@ -0,0 +1,55 @@
+/**
+ * A Lua `local` belongs to its chunk: another file can never name it.
+ *
+ * kong's spec helpers re-bind busted's globals (`local it = it`,
+ * `local assert = require "luassert"`); every other spec file's `it(…)` and
+ * `assert(…)` linked to them — 4,166 and 1,234 times. koreader's
+ * `local ipairs = ipairs` in one module took the whole project's `ipairs`.
+ * A global function stays reachable.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+describe('Lua locals', () => {
+  it('are invisible outside their file; globals are not', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-lua-local-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'spec/helpers.lua': `local it = it
+local ipairs = ipairs
+local function helper() return 1 end
+function global_helper() return 2 end
+return {}
+`,
+      'spec/plugin_spec.lua': `describe("plugin", function()
+  it("works", function()
+    for _, v in ipairs({ 1 }) do helper(v) end
+    global_helper()
+  end)
+end)
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const targets = cg
+        .getOutgoingEdgesFrom(cg.getNodesInFile('spec/plugin_spec.lua').map((n) => n.id), ['calls'])
+        .map((e) => cg.getNode(e.target)!.name)
+        .sort();
+      expect(targets).toEqual(['global_helper']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/mcp-daemon.test.ts b/__tests__/mcp-daemon.test.ts
index 71cc7b71ff..5b8b305002 100644
--- a/__tests__/mcp-daemon.test.ts
+++ b/__tests__/mcp-daemon.test.ts
@@ -817,4 +817,142 @@ describe('Shared MCP daemon (issue #411)', () => {
     expect(resp.result !== undefined || resp.error !== undefined).toBe(true);
     expect(isAlive(server.child.pid!)).toBe(true);
   }, 45000);
+
+  it('a proxy serving in-process hands the writer lock back to a fresh daemon (#2277)', async () => {
+    // After its daemon dies, the proxy's in-process engine takes writer.pid in
+    // fallback mode. Every later daemon start used to fail on that lock for the
+    // rest of the session, so every other session on the project ran read-only
+    // without auto-sync. The degraded proxy now retries the daemon: it stops
+    // its engine (releasing the lock), lets a daemon start, and proxies again.
+    const env = {
+      CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS: '30000',
+      CODEGRAPH_PPID_POLL_MS: '5000',
+      // The default, spelled out: long enough to observe the lockout first.
+      CODEGRAPH_DAEMON_RETRY_MS: '5000',
+    };
+    const a = spawnServer(tempDir, env);
+    servers.push(a);
+    const proxyPid = a.child.pid!;
+    sendInitialize(a.child, `file://${tempDir}`, 1);
+    await waitFor(() => findResponse(a.stdout, 1), 20000, 25, 'initialize response');
+    await waitFor(() => a.stderr.some((l) => l.includes('Attached to shared daemon')), 8000, 25, 'first daemon attach');
+    sendMessage(a.child, { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+    await waitFor(() => findResponse(a.stdout, 2), 30000, 25, 'warm tools/call via daemon');
+    const firstDaemon = readLockPid(realRoot)!;
+
+    process.kill(firstDaemon, 'SIGTERM');
+    expect(await waitProcessExit(firstDaemon, 8000)).toBe(true);
+    await waitFor(() => a.stderr.some((l) => l.includes('serving this session in-process')), 8000, 25, 'in-process failover');
+    sendMessage(a.child, { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+    await waitFor(() => findResponse(a.stdout, 3), 15000, 25, 'in-process tools/call');
+
+    // The lockout: the in-process engine owns the project's writer slot.
+    expect(readWriterInfo(realRoot)).toMatchObject({ pid: proxyPid, mode: 'fallback' });
+
+    // Another session starting now cannot get a daemon while that lock is held.
+    const b = spawnServer(tempDir, env);
+    servers.push(b);
+    sendInitialize(b.child, `file://${tempDir}`, 1);
+    await waitFor(() => findResponse(b.stdout, 1), 20000, 25, 'second session initialize');
+
+    // Keep calling through the handover: every request gets exactly one reply.
+    let nextId = 4;
+    const send = (): void => {
+      sendMessage(a.child, { jsonrpc: '2.0', id: nextId++, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+    };
+    const ticker = setInterval(send, 250);
+    let daemonWriter: { pid: number; mode: string } | null = null;
+    try {
+      daemonWriter = await waitFor(() => {
+        const w = readWriterInfo(realRoot);
+        return w && w.mode === 'daemon' && w.pid !== proxyPid && isAlive(w.pid) ? w : null;
+      }, 30000, 25, 'a daemon to own the writer lock');
+      await waitFor(
+        () => a.stderr.some((l) => l.includes(`Attached to shared daemon`) && l.includes(`(pid ${daemonWriter!.pid},`)),
+        15000, 25, 'the proxy to reattach to the new daemon',
+      );
+    } finally {
+      clearInterval(ticker);
+    }
+    send();
+    const lastId = nextId - 1;
+    await waitFor(() => findResponse(a.stdout, lastId), 15000, 25, 'a tools/call through the new daemon');
+    for (let id = 2; id <= lastId; id++) {
+      const replies = a.stdout.filter((line) => {
+        try { const m = JSON.parse(line); return m.id === id && ('result' in m || 'error' in m); } catch { return false; }
+      });
+      expect(replies, `replies to request ${id}`).toHaveLength(1);
+      expect(JSON.parse(replies[0]).error, `request ${id}`).toBeUndefined();
+    }
+    expect(readLockPid(realRoot)).toBe(daemonWriter!.pid);
+
+    // The session that started during the lockout ends up on the shared daemon too.
+    await waitFor(
+      () => b.stderr.some((l) => l.includes('Attached to shared daemon') && l.includes(`(pid ${daemonWriter!.pid},`)),
+      30000, 25, 'the second session to attach',
+    );
+    sendMessage(b.child, { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+    const bReply = await waitFor(() => findResponse(b.stdout, 2), 15000, 25, 'second session tools/call');
+    expect(bReply.error).toBeUndefined();
+  }, 90000);
+
+  it('a read-only in-process session moves to the shared daemon once one can start (#2277)', async () => {
+    // A session that fell back read-only (another daemon held the project)
+    // used to stay that way for life. Once the blocker is gone it now starts
+    // and attaches to a daemon of its own version.
+    const sockPath = getDaemonSocketPath(realRoot);
+    const pidPath = path.join(realRoot, '.codegraph', 'daemon.pid');
+    fs.writeFileSync(pidPath, JSON.stringify({ pid: process.pid, version: '0.0.0-mismatch', socketPath: sockPath, startedAt: Date.now() }));
+    const miniServer = net.createServer((sock) => {
+      sock.write(JSON.stringify({ codegraph: '0.0.0-mismatch', pid: process.pid, socketPath: sockPath, protocol: 1 }) + '\n');
+    });
+    await new Promise<void>((resolve) => miniServer.listen(sockPath, () => resolve()));
+    let miniServerOpen = true;
+    try {
+      const server = spawnServer(tempDir, {
+        CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS: '30000',
+        CODEGRAPH_DAEMON_RETRY_MS: '300',
+        CODEGRAPH_DAEMON_RETRY_MAX_MS: '1000',
+      });
+      servers.push(server);
+      sendInitialize(server.child, `file://${tempDir}`, 1);
+      await waitFor(() => server.stderr.some((l) => l.includes('serving this session in-process')), 10000, 25, 'in-process fallback');
+      sendMessage(server.child, { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+      const local = await waitFor(() => findResponse(server.stdout, 2), 10000, 25, 'read-only tools/call');
+      expect(local.error).toBeUndefined();
+      expect(server.stderr.some((l) => l.includes('Serving reads in-process without auto-sync'))).toBe(true);
+      // Retries while the other version still answers start no daemon.
+      await waitFor(
+        () => server.stderr.filter((l) => l.includes('differs from ours')).length >= 3,
+        10000, 25, 'repeated retries against the other version',
+      );
+      expect(countListeningLines(realRoot)).toBe(0);
+
+      // The other-version daemon goes away.
+      await new Promise<void>((resolve) => miniServer.close(() => resolve()));
+      miniServerOpen = false;
+      fs.rmSync(pidPath, { force: true });
+
+      const attached = await waitFor(
+        () => server.stderr.find((l) => l.includes('Attached to shared daemon')),
+        30000, 25, 'the session to attach to a daemon',
+      );
+      const daemonPid = readLockPid(realRoot)!;
+      expect(attached).toContain(`(pid ${daemonPid},`);
+      expect(readWriterInfo(realRoot)).toMatchObject({ pid: daemonPid, mode: 'daemon' });
+      sendMessage(server.child, { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
+      const viaDaemon = await waitFor(() => findResponse(server.stdout, 3), 15000, 25, 'tools/call through the daemon');
+      expect(viaDaemon.error).toBeUndefined();
+      expect(JSON.stringify(viaDaemon.result)).toContain('CodeGraph Status');
+    } finally {
+      if (miniServerOpen) await new Promise<void>((resolve) => miniServer.close(() => resolve()));
+    }
+  }, 60000);
 });
+
+function readWriterInfo(root: string): { pid: number; mode: string } | null {
+  try {
+    const info = JSON.parse(fs.readFileSync(path.join(root, '.codegraph', 'writer.pid'), 'utf8'));
+    return typeof info.pid === 'number' && typeof info.mode === 'string' ? info : null;
+  } catch { return null; }
+}
diff --git a/__tests__/mcp-freshness-bounds.test.ts b/__tests__/mcp-freshness-bounds.test.ts
index 5710b4e137..a9dae57aff 100644
--- a/__tests__/mcp-freshness-bounds.test.ts
+++ b/__tests__/mcp-freshness-bounds.test.ts
@@ -5,7 +5,7 @@ import * as path from 'path';
 import { createHash } from 'crypto';
 import { Readable } from 'stream';
 import { validateAnswerFiles } from '../src/mcp/answer-freshness';
-import { measurePendingChanges } from '../src/mcp/index-freshness';
+import { endFreshnessMeasurements, measurePendingChanges } from '../src/mcp/index-freshness';
 
 vi.mock('fs', async importOriginal => {
   const actual = await importOriginal<typeof import('fs')>();
@@ -46,16 +46,47 @@ describe('bounded freshness validation (#1959)', () => {
     const pending = measurePendingChanges('/freshness-timeout');
     expect(measurePendingChanges('/freshness-timeout')).toBe(pending);
     expect(workers).toHaveLength(1);
+    workers[0].emit('message', { type: 'loaded' }); // stuck past loading, in the scan
     await vi.advanceTimersByTimeAsync(8000);
     expect(await pending).toBeNull();
     expect(workers[0].terminate).toHaveBeenCalledOnce();
   });
 
+  it('answers unknown on deadline but never terminates a worker still loading its modules', async () => {
+    // Terminating a worker while it loads its modules can crash the process
+    // on Windows (0xC0000005) — see worker-start.ts.
+    vi.useFakeTimers();
+    const pending = measurePendingChanges('/freshness-still-loading');
+    await vi.advanceTimersByTimeAsync(8000);
+    expect(await pending).toBeNull();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(workers[0].terminate).not.toHaveBeenCalled();
+    workers[0].emit('message', { type: 'loaded' });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(workers[0].terminate).toHaveBeenCalledOnce();
+  });
+
+  it('a server shutting down ends measurements once they have loaded', async () => {
+    vi.useFakeTimers();
+    const pending = measurePendingChanges('/freshness-shutdown');
+    let ended = false;
+    const ending = endFreshnessMeasurements().then(() => { ended = true; });
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(ended).toBe(false);
+    expect(workers[0].terminate).not.toHaveBeenCalled();
+    workers[0].emit('message', { type: 'loaded' });
+    await ending;
+    expect(workers[0].terminate).toHaveBeenCalled();
+    workers[0].emit('exit', 1); // what a terminated worker does
+    expect(await pending).toBeNull();
+  });
+
   it('returns unknown on deadline even if worker termination is delayed', async () => {
     vi.useFakeTimers();
     const pending = measurePendingChanges('/freshness-delayed-exit');
     let release!: () => void;
     workers[0].terminate.mockImplementation(() => new Promise<void>(resolve => { release = resolve; }));
+    workers[0].emit('message', { type: 'loaded' });
     await vi.advanceTimersByTimeAsync(8000);
     expect(await pending).toBeNull();
     release();
@@ -81,11 +112,13 @@ describe('bounded freshness validation (#1959)', () => {
     expect(await measurePendingChanges('/freshness-three')).toBeNull();
     expect(workers).toHaveLength(2);
     workers[0].emit('error', new Error('worker failed'));
-    workers[1].emit('message', { added: -1, modified: 0, removed: 0 });
+    workers[1].emit('message', { type: 'counts', counts: { added: -1, modified: 0, removed: 0 } });
     expect(await first).toBeNull();
     expect(await second).toBeNull();
+    await new Promise((r) => setTimeout(r, 0)); // the slots free once each worker is terminated
     const retry = measurePendingChanges('/freshness-three');
-    workers[2].emit('message', { added: 0, modified: 1, removed: 0 });
+    workers[2].emit('message', { type: 'loaded' });
+    workers[2].emit('message', { type: 'counts', counts: { added: 0, modified: 1, removed: 0 } });
     expect(await retry).toEqual({ added: 0, modified: 1, removed: 0 });
   });
 });
diff --git a/__tests__/mcp-nested-repo-projectpath.test.ts b/__tests__/mcp-nested-repo-projectpath.test.ts
new file mode 100644
index 0000000000..6dc27cc075
--- /dev/null
+++ b/__tests__/mcp-nested-repo-projectpath.test.ts
@@ -0,0 +1,356 @@
+/**
+ * A `projectPath` inside an independent nested git repository that the
+ * ancestor index excludes (#2110).
+ *
+ * `findNearestCodeGraphRoot` walks up to the nearest `.codegraph/` without
+ * looking at git boundaries. For a submodule or embedded clone the ancestor
+ * indexes, that is what we want — one index serves the whole workspace. For a
+ * nested repository the ancestor does NOT index (typically gitignored), the
+ * call silently answered from the ancestor's code instead. It must now get the
+ * same success-shaped "isn't indexed" guidance a project with no index at all
+ * gets, while every layout the ancestor index does cover keeps resolving to it.
+ *
+ * Real `git`, real temp repositories, real indexes — no mocking.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFileSync, spawn, ChildProcessWithoutNullStreams } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { ToolHandler, __setLoadCodeGraphForTests } from '../src/mcp/tools';
+import { WASM_RUNTIME_FLAGS } from '../src/extraction/wasm-runtime-flags';
+
+const BIN = path.resolve(__dirname, '../dist/bin/codegraph.js');
+
+function git(cwd: string, ...args: string[]): void {
+  execFileSync('git', args, { cwd, stdio: ['ignore', 'ignore', 'ignore'], windowsHide: true });
+}
+
+function initRepo(dir: string): void {
+  fs.mkdirSync(dir, { recursive: true });
+  git(dir, 'init', '-q');
+  git(dir, 'config', 'user.email', 'test@example.com');
+  git(dir, 'config', 'user.name', 'Test');
+  git(dir, 'config', 'commit.gpgsign', 'false');
+}
+
+/**
+ * The issue's layout: `parent/` is a repository that gitignores `nested/`,
+ * and `nested/` is an independent repository of its own. Only the parent is
+ * indexed. `parent/src/` is an ordinary subdirectory of the parent.
+ */
+function makeParentWithIgnoredNestedRepo(root: string, ignoreNested = true): { parent: string; nested: string } {
+  const parent = path.join(root, 'parent');
+  const nested = path.join(parent, 'nested');
+  initRepo(parent);
+  if (ignoreNested) fs.writeFileSync(path.join(parent, '.gitignore'), 'nested/\nwt/\n');
+  fs.writeFileSync(path.join(parent, 'parent-only.ts'), "export function parentOnly() { return 'parent'; }\n");
+  fs.mkdirSync(path.join(parent, 'src'));
+  fs.writeFileSync(path.join(parent, 'src', 'sub.ts'), "export function parentSub() { return 'sub'; }\n");
+  git(parent, 'add', '.');
+  git(parent, 'commit', '-q', '-m', 'repro-parent');
+
+  initRepo(nested);
+  fs.writeFileSync(path.join(nested, 'nested-only.ts'), "export function nestedOnly() { return 'nested'; }\n");
+  fs.mkdirSync(path.join(nested, 'lib'));
+  fs.writeFileSync(path.join(nested, 'lib', 'deep.ts'), "export function nestedDeep() { return 'deep'; }\n");
+  git(nested, 'add', '.');
+  git(nested, 'commit', '-q', '-m', 'repro-nested');
+  return { parent, nested };
+}
+
+function text(res: { content: Array<{ type: string; text?: string }> }): string {
+  const first = res.content[0];
+  return first && first.type === 'text' ? first.text ?? '' : '';
+}
+
+describe('projectPath inside a nested git repository the ancestor index excludes (#2110)', () => {
+  let root: string;
+  let parent: string;
+  let nested: string;
+  let cg: CodeGraph;
+  let handler: ToolHandler | null;
+
+  beforeEach(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-nested-repo-'));
+    ({ parent, nested } = makeParentWithIgnoredNestedRepo(root));
+    cg = CodeGraph.initSync(parent);
+    await cg.indexAll();
+    handler = null;
+  });
+
+  afterEach(async () => {
+    __setLoadCodeGraphForTests(null);
+    if (handler) await handler.closeAll();
+    try { cg.destroy(); } catch { /* best effort */ }
+    try { git(parent, 'worktree', 'remove', '--force', path.join(parent, 'wt')); } catch { /* none added */ }
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+  });
+
+  it('the fixture matches the issue: the parent index holds none of the nested repository', () => {
+    expect(cg.getFile('parent-only.ts')).not.toBeNull();
+    expect(cg.getFile('nested/nested-only.ts')).toBeNull();
+  });
+
+  it('answers with success-shaped "isn\'t indexed" guidance instead of the parent\'s code', async () => {
+    handler = new ToolHandler(cg); // the server runs in the parent, as in the issue
+    const res = await handler.execute('codegraph_explore', {
+      query: 'parentOnly nestedOnly',
+      projectPath: nested,
+      maxFiles: 10,
+    });
+    const body = text(res);
+    expect(res.isError).toBeUndefined();
+    expect(body).toMatch(/isn't indexed/);
+    expect(body).toMatch(/codegraph init/);
+    expect(body).toMatch(/built-in tools/);
+    expect(body).not.toContain('parent-only.ts');
+    expect(body).not.toContain('parentOnly()');
+  });
+
+  it('covers a subdirectory of the nested repository, existing or not', async () => {
+    handler = new ToolHandler(cg);
+    for (const projectPath of [path.join(nested, 'lib'), path.join(nested, 'lib', 'not-created-yet')]) {
+      const res = await handler.execute('codegraph_search', { query: 'parentOnly', projectPath });
+      expect(res.isError).toBeUndefined();
+      expect(text(res)).toMatch(/isn't indexed/);
+    }
+  });
+
+  it('refuses the same way when the parent is not the session\'s default project', async () => {
+    __setLoadCodeGraphForTests(CodeGraph);
+    handler = new ToolHandler(null);
+    const res = await handler.execute('codegraph_search', { query: 'parentOnly', projectPath: nested });
+    expect(res.isError).toBeUndefined();
+    expect(text(res)).toMatch(/isn't indexed/);
+
+    // …while the parent itself is still served by projectPath.
+    const ok = await handler.execute('codegraph_search', { query: 'parentOnly', projectPath: parent });
+    expect(ok.isError).toBeUndefined();
+    expect(text(ok)).toContain('parent-only.ts');
+  });
+
+  it('keeps resolving an ordinary subdirectory of the parent to the parent index', async () => {
+    handler = new ToolHandler(cg);
+    const res = await handler.execute('codegraph_search', {
+      query: 'parentSub',
+      projectPath: path.join(parent, 'src'),
+    });
+    expect(res.isError).toBeUndefined();
+    expect(text(res)).not.toMatch(/isn't indexed/);
+    expect(text(res)).toContain('src/sub.ts');
+  });
+
+  it('keeps serving a linked worktree of the parent from the parent index, with the #155 notice', async () => {
+    // A worktree nested inside (and ignored by) the main checkout is the SAME
+    // repository — the borrowed-worktree case, which is warned about, not refused.
+    const wt = path.join(parent, 'wt');
+    git(parent, 'worktree', 'add', '-q', '-b', 'feature', wt);
+    handler = new ToolHandler(cg);
+    const res = await handler.execute('codegraph_search', { query: 'parentOnly', projectPath: wt });
+    expect(res.isError).toBeUndefined();
+    expect(text(res)).not.toMatch(/isn't indexed/);
+    expect(text(res)).toContain('different git worktree');
+    expect(text(res)).toContain('parent-only.ts');
+  });
+
+  it('notices the nested repository joining the index without a restart', async () => {
+    handler = new ToolHandler(cg);
+    const before = await handler.execute('codegraph_search', { query: 'nestedOnly', projectPath: nested });
+    expect(text(before)).toMatch(/isn't indexed/);
+
+    // The user stops ignoring it and the parent re-syncs (an embedded clone the
+    // parent does not ignore is indexed with it).
+    fs.writeFileSync(path.join(parent, '.gitignore'), 'wt/\n');
+    await cg.sync();
+    expect(cg.getFile('nested/nested-only.ts')).not.toBeNull();
+
+    const after = await handler.execute('codegraph_search', { query: 'nestedOnly', projectPath: nested });
+    expect(after.isError).toBeUndefined();
+    expect(text(after)).not.toMatch(/isn't indexed/);
+    expect(text(after)).toContain('nested/nested-only.ts');
+  });
+
+  it('serves a nested repository that has its own index from that index', async () => {
+    const nestedCg = CodeGraph.initSync(nested);
+    await nestedCg.indexAll();
+    nestedCg.close();
+    __setLoadCodeGraphForTests(CodeGraph);
+    handler = new ToolHandler(cg);
+    const res = await handler.execute('codegraph_search', { query: 'nestedOnly', projectPath: nested });
+    expect(res.isError).toBeUndefined();
+    expect(text(res)).not.toMatch(/isn't indexed/);
+    expect(text(res)).toContain('nested-only.ts');
+  });
+
+  it('fails open to the ancestor index when git cannot be run', async () => {
+    handler = new ToolHandler(cg);
+    const savedPath = process.env.PATH;
+    process.env.PATH = '';
+    try {
+      const res = await handler.execute('codegraph_search', { query: 'parentOnly', projectPath: nested });
+      expect(res.isError).toBeUndefined();
+      expect(text(res)).not.toMatch(/isn't indexed/);
+    } finally {
+      process.env.PATH = savedPath;
+    }
+  });
+});
+
+describe('projectPath inside a nested git repository the ancestor index DOES cover (#2110)', () => {
+  let root: string;
+  let parent: string;
+  let nested: string;
+  let cg: CodeGraph;
+
+  beforeEach(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-nested-covered-'));
+    // Same two repositories, but the parent does not ignore the nested one — an
+    // embedded clone the parent's index takes in.
+    ({ parent, nested } = makeParentWithIgnoredNestedRepo(root, false));
+    cg = CodeGraph.initSync(parent);
+    await cg.indexAll();
+  });
+
+  afterEach(() => {
+    try { cg.destroy(); } catch { /* best effort */ }
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+  });
+
+  it('keeps resolving to the parent index, which answers for the nested repository', async () => {
+    expect(cg.getFile('nested/nested-only.ts')).not.toBeNull();
+    const res = await new ToolHandler(cg).execute('codegraph_search', {
+      query: 'nestedOnly',
+      projectPath: nested,
+    });
+    expect(res.isError).toBeUndefined();
+    expect(text(res)).not.toMatch(/isn't indexed/);
+    expect(text(res)).toContain('nested/nested-only.ts');
+  });
+
+  it('keeps resolving a submodule the parent indexes to the parent index', async () => {
+    const source = path.join(root, 'sub-source');
+    initRepo(source);
+    fs.writeFileSync(path.join(source, 'lib.ts'), 'export function fromSubmodule() { return 1; }\n');
+    git(source, 'add', '.');
+    git(source, 'commit', '-q', '-m', 'sub');
+    git(parent, '-c', 'protocol.file.allow=always', 'submodule', 'add', '-q', source, 'service-a');
+    git(parent, 'commit', '-q', '-m', 'add submodule');
+    await cg.sync();
+    expect(cg.getFile('service-a/lib.ts')).not.toBeNull();
+
+    const res = await new ToolHandler(cg).execute('codegraph_search', {
+      query: 'fromSubmodule',
+      projectPath: path.join(parent, 'service-a'),
+    });
+    expect(res.isError).toBeUndefined();
+    expect(text(res)).not.toMatch(/isn't indexed/);
+    expect(text(res)).toContain('service-a/lib.ts');
+  });
+});
+
+/** Send a JSON-RPC request and resolve with the response matching its id. */
+function request(
+  child: ChildProcessWithoutNullStreams,
+  msg: { id: number; method: string; params?: unknown },
+  timeoutMs = 20000,
+): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    let buf = '';
+    const timer = setTimeout(() => {
+      child.stdout.off('data', onData);
+      reject(new Error(`timeout waiting for response id=${msg.id}`));
+    }, timeoutMs);
+    const onData = (chunk: Buffer) => {
+      buf += chunk.toString();
+      let idx: number;
+      while ((idx = buf.indexOf('\n')) !== -1) {
+        const line = buf.slice(0, idx).trim();
+        buf = buf.slice(idx + 1);
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line) as Record<string, unknown>;
+          if (parsed.id === msg.id) {
+            clearTimeout(timer);
+            child.stdout.off('data', onData);
+            resolve(parsed);
+            return;
+          }
+        } catch {
+          // non-JSON noise on stdout — ignore
+        }
+      }
+    };
+    child.stdout.on('data', onData);
+    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...msg }) + '\n');
+  });
+}
+
+describe('stdio MCP: projectPath inside an excluded nested git repository (#2110)', { timeout: 60_000 }, () => {
+  let root: string;
+  let parent: string;
+  let nested: string;
+  let child: ChildProcessWithoutNullStreams | null = null;
+
+  beforeEach(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-nested-stdio-'));
+    ({ parent, nested } = makeParentWithIgnoredNestedRepo(root));
+    const cg = CodeGraph.initSync(parent);
+    await cg.indexAll();
+    cg.close();
+  });
+
+  afterEach(async () => {
+    if (child) {
+      const exited = new Promise<void>((resolve) => child!.once('exit', () => resolve()));
+      child.kill('SIGKILL');
+      await Promise.race([exited, new Promise((r) => setTimeout(r, 3000))]);
+      child = null;
+    }
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+  });
+
+  it('returns the not-indexed guidance for the nested repository and still serves the parent', async () => {
+    child = spawn(process.execPath, [...WASM_RUNTIME_FLAGS, BIN, 'serve', '--mcp'], {
+      cwd: parent,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+      // In-process server (no detached daemon to leak); see mcp-unindexed.test.ts.
+      env: { ...process.env, CODEGRAPH_NO_DAEMON: '1', CODEGRAPH_WASM_RELAUNCHED: '1' },
+    }) as ChildProcessWithoutNullStreams;
+
+    await request(child, {
+      id: 0,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2025-11-25',
+        capabilities: {},
+        clientInfo: { name: 'test', version: '0.0.0' },
+        rootUri: `file://${parent}`,
+      },
+    });
+
+    const res = await request(child, {
+      id: 3,
+      method: 'tools/call',
+      params: {
+        name: 'codegraph_explore',
+        arguments: { query: 'parentOnly nestedOnly', projectPath: nested, maxFiles: 10 },
+      },
+    });
+    const result = res.result as { content: Array<{ text: string }>; isError?: boolean };
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0]!.text).toMatch(/isn't indexed/);
+    expect(result.content[0]!.text).not.toContain('parent-only.ts');
+
+    const ok = await request(child, {
+      id: 4,
+      method: 'tools/call',
+      params: { name: 'codegraph_explore', arguments: { query: 'parentOnly', projectPath: parent } },
+    });
+    const okResult = ok.result as { content: Array<{ text: string }>; isError?: boolean };
+    expect(okResult.isError).toBeUndefined();
+    expect(okResult.content[0]!.text).toContain('parent-only.ts');
+  });
+});
diff --git a/__tests__/mcp-projectpath-lifecycle.test.ts b/__tests__/mcp-projectpath-lifecycle.test.ts
index 23a1a36a95..10ea19abc6 100644
--- a/__tests__/mcp-projectpath-lifecycle.test.ts
+++ b/__tests__/mcp-projectpath-lifecycle.test.ts
@@ -442,6 +442,61 @@ describe('MCP explicit projectPath lifecycle (#1835)', { timeout: 30_000 }, () =
   }, 60_000);
 
 
+  // A daemon that answered one projectPath query for another project must not
+  // keep that project's writer lock until it exits: the project's own daemon
+  // and `codegraph index` there would stay locked out (#2087).
+  it('releases an idle explicit project and its writer lock, and retakes it on the next call', async () => {
+    const prev = process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS;
+    process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS = '200';
+    const lock = path.join(serviceB, '.codegraph/writer.pid');
+    try {
+      expect(await search(serviceB, 'betaOriginal')).toContain('betaOriginal');
+      expect(JSON.parse(fs.readFileSync(lock, 'utf8')).pid).toBe(process.pid);
+      expect(opened[0]!.isWatching()).toBe(true);
+
+      expect(await waitFor(async () => !fs.existsSync(lock), 10000)).toBe(true);
+      expect(() => opened[0]!.getStats()).toThrow();
+
+      // Still synchronized while in use: the next call reopens and catches up.
+      fs.writeFileSync(path.join(serviceB, 'src/sample.ts'), 'export function afterIdleRelease() {}\n');
+      expect(await search(serviceB, 'afterIdleRelease')).toContain('afterIdleRelease');
+      expect(opened).toHaveLength(2);
+      expect(opened[1]!.isWatching()).toBe(true);
+      expect(JSON.parse(fs.readFileSync(lock, 'utf8')).pid).toBe(process.pid);
+    } finally {
+      if (prev === undefined) delete process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS;
+      else process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS = prev;
+    }
+  });
+
+  it('defers an idle release until an active catch-up finishes (#2087)', async () => {
+    let release!: () => void;
+    const held = new Promise<void>((resolve) => { release = resolve; });
+    onOpen = (cg) => {
+      const sync = cg.sync.bind(cg);
+      vi.spyOn(cg, 'sync').mockImplementation(async (...args) => { await held; return sync(...args); });
+    };
+    const prevIdle = process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS;
+    process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS = '50';
+    process.env.CODEGRAPH_CATCHUP_GATE_TIMEOUT_MS = '10';
+    const lock = path.join(serviceB, '.codegraph/writer.pid');
+    try {
+      fs.writeFileSync(path.join(serviceB, 'src/sample.ts'), 'export function idleCatchUp() {}\n');
+      await search(serviceB, 'betaOriginal');
+      await new Promise((r) => setTimeout(r, 300));
+      expect(() => opened[0]!.getStats()).not.toThrow();
+      expect(fs.existsSync(lock)).toBe(true);
+      release();
+      expect(await waitFor(async () => !fs.existsSync(lock), 10000)).toBe(true);
+      expect(names(serviceB)).toEqual(['idleCatchUp']);
+      expect(() => opened[0]!.getStats()).toThrow();
+    } finally {
+      release();
+      if (prevIdle === undefined) delete process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS;
+      else process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS = prevIdle;
+    }
+  });
+
   it('drains a tool operation before closing its cached graph', async () => {
     await search(serviceA, 'alphaOriginal');
     const handler = engine.getToolHandler();
diff --git a/__tests__/mcp-server-discover.test.ts b/__tests__/mcp-server-discover.test.ts
new file mode 100644
index 0000000000..c464a57701
--- /dev/null
+++ b/__tests__/mcp-server-discover.test.ts
@@ -0,0 +1,135 @@
+/**
+ * `server/discover` probe regression tests (issue #2084).
+ *
+ * Newer MCP clients (Antigravity 2.5) send `server/discover` before the legacy
+ * `initialize` and wait for the answer. A legacy server is expected to reply
+ * `-32601 Method not found`, which sends the client on to `initialize`. The
+ * stdio proxy forwarded the probe to the shared daemon instead, so nothing was
+ * written until the daemon connected: a client that closed stdin first got no
+ * reply at all, and with the daemon unavailable the reply came ~6s later as a
+ * `-32603` the client can't read as "use initialize".
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import { once } from 'events';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { WASM_RUNTIME_FLAGS } from '../src/extraction/wasm-runtime-flags';
+import { recordSpawns, removeSpawnLog, settleLosingCandidates, spawnLogFor } from './daemon-candidates';
+
+const BIN = path.resolve(__dirname, '../dist/bin/codegraph.js');
+const DISCOVER = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'server/discover' }) + '\n';
+
+function readLockPid(root: string): number | null {
+  try {
+    const info = JSON.parse(fs.readFileSync(path.join(root, '.codegraph', 'daemon.pid'), 'utf8'));
+    return typeof info === 'number' ? info : typeof info.pid === 'number' ? info.pid : null;
+  } catch { return null; }
+}
+
+function isAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+/**
+ * Send one `server/discover` line and resolve with everything the server wrote
+ * to stdout once it has exited. `closeStdin: 'at-once'` is the shape of the
+ * `printf … | codegraph serve --mcp` repro; `'after-reply'` is a client that
+ * waits for the answer (stdin is closed on the first stdout line).
+ */
+async function discover(
+  cwd: string,
+  env: NodeJS.ProcessEnv,
+  children: ChildProcessWithoutNullStreams[],
+  closeStdin: 'at-once' | 'after-reply' = 'at-once',
+): Promise<string> {
+  const recorder = recordSpawns(cwd);
+  const child = spawn(process.execPath, [...WASM_RUNTIME_FLAGS, ...recorder.args, BIN, 'serve', '--mcp', '--no-watch'], {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, ...recorder.env, CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS: '1000', ...env },
+  }) as ChildProcessWithoutNullStreams;
+  children.push(child);
+  child.on('error', () => { /* ignore */ });
+  child.stdin.on('error', () => { /* ignore */ });
+  let stdout = '';
+  child.stdout.on('data', (chunk: Buffer) => {
+    stdout += chunk.toString('utf8');
+    if (closeStdin === 'after-reply' && stdout.includes('\n')) child.stdin.end();
+  });
+  child.stderr.resume();
+  const exited = once(child, 'exit');
+  if (closeStdin === 'at-once') child.stdin.end(DISCOVER);
+  else child.stdin.write(DISCOVER);
+  await exited;
+  return stdout;
+}
+
+function expectMethodNotFound(stdout: string): void {
+  const replies = stdout.split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+  expect(replies).toEqual([
+    { jsonrpc: '2.0', id: 1, error: expect.objectContaining({ code: -32601 }) },
+  ]);
+}
+
+describe('server/discover probe (issue #2084)', () => {
+  let tempDir: string;
+  let realRoot: string;
+  const children: ChildProcessWithoutNullStreams[] = [];
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-mcp-discover-'));
+    realRoot = fs.realpathSync(tempDir);
+  });
+
+  afterEach(async () => {
+    await Promise.all(children.map(async (child) => {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      const exited = once(child, 'exit');
+      child.kill('SIGKILL');
+      await exited;
+    }));
+    children.length = 0;
+    // The proxy spawns a detached daemon candidate; wait for the losers, then
+    // stop the lock holder — never the vitest worker, which one test plants as
+    // the holder.
+    if (fs.existsSync(spawnLogFor(tempDir))) {
+      await settleLosingCandidates(tempDir, () => readLockPid(realRoot));
+      const daemonPid = readLockPid(realRoot);
+      if (daemonPid && daemonPid !== process.pid && isAlive(daemonPid)) {
+        try { process.kill(daemonPid, 'SIGKILL'); } catch { /* race */ }
+        for (let i = 0; i < 100 && isAlive(daemonPid); i++) await new Promise((r) => setTimeout(r, 50));
+      }
+      removeSpawnLog(tempDir);
+    }
+    await fs.promises.rm(tempDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+  }, 45_000);
+
+  it('proxy mode answers -32601 even when the client closes stdin right after the probe', async () => {
+    const cg = await CodeGraph.init(tempDir);
+    cg.close();
+    expectMethodNotFound(await discover(tempDir, {}, children));
+  }, 20_000);
+
+  it('proxy mode answers -32601, not "daemon unavailable", when the daemon cannot start', async () => {
+    const cg = await CodeGraph.init(tempDir);
+    cg.close();
+    // A legacy plain-pid lock held by a live process (this worker) makes every
+    // daemon candidate step aside, so the proxy never gets a daemon.
+    fs.writeFileSync(path.join(realRoot, '.codegraph', 'daemon.pid'), `${process.pid}\n`);
+    expectMethodNotFound(await discover(tempDir, {}, children, 'after-reply'));
+  }, 20_000);
+
+  it.each([
+    ['CODEGRAPH_NO_DAEMON=1 on an indexed project', true, { CODEGRAPH_NO_DAEMON: '1' }],
+    ['no .codegraph/ in the working directory', false, {}],
+  ])('direct mode answers -32601 (%s)', async (_label, indexed, env) => {
+    if (indexed) {
+      const cg = await CodeGraph.init(tempDir);
+      cg.close();
+    }
+    expectMethodNotFound(await discover(tempDir, env, children));
+  }, 20_000);
+});
diff --git a/__tests__/mcp-stale-refusal.test.ts b/__tests__/mcp-stale-refusal.test.ts
index 53362c7a29..309cf92ee2 100644
--- a/__tests__/mcp-stale-refusal.test.ts
+++ b/__tests__/mcp-stale-refusal.test.ts
@@ -121,7 +121,9 @@ describe('a degraded index refuses answers from changed files (#1959)', () => {
     const result = await handler.execute('codegraph_search', { query: 'unicodeSymbol' });
     expect(result.isError).toBeFalsy();
     expect(result.content[0].text).toContain('cannot answer from this index');
-    expect(result.structuredContent).toEqual({ freshness: { stale: [relative], unchecked: [] } });
+    expect(result.content[0].text).toContain(`- ${relative}`);
+    // Claude Code would show structuredContent in place of this text (#2088).
+    expect(result).not.toHaveProperty('structuredContent');
     expect(result).not.toHaveProperty('_cgAnswerFiles');
   });
 
@@ -137,7 +139,7 @@ describe('a degraded index refuses answers from changed files (#1959)', () => {
   );
 
   it('refuses rather than silently validating only the first 200 contributing files', async () => {
-    for (let i = 0; i < 201; i++) {
+    for (let i = 0; i < 230; i++) {
       fs.writeFileSync(path.join(root, `caller${i}.ts`),
         `import { alphaOnly } from './alpha'; export function caller${i}() { return alphaOnly(); }\n`);
     }
@@ -147,7 +149,13 @@ describe('a degraded index refuses answers from changed files (#1959)', () => {
     const result = await handler.execute('codegraph_impact', { symbol: 'alphaOnly' });
     expect(result.isError).toBeFalsy();
     expect(result.content[0].text).toContain('validation budget');
-    expect((result.structuredContent!.freshness as { unchecked: string[] }).unchecked.length).toBeGreaterThan(0);
+    const text = result.content[0].text;
+    const total = Number(text.match(/validation budget for (\d+) files/)![1]);
+    // A long unchecked list stays bounded: the first 20 and a count of the rest.
+    expect(total).toBeGreaterThan(20);
+    expect(text.split('\n').filter(line => /^- (?!…)/.test(line))).toHaveLength(20);
+    expect(text).toContain(`- … ${total - 20} more (narrow the query)`);
+    expect(result).not.toHaveProperty('structuredContent');
     expect(result.content[0].text).not.toContain('**Impact');
   });
 
diff --git a/__tests__/mcp-status-freshness.test.ts b/__tests__/mcp-status-freshness.test.ts
index 19c14f7ce1..c78844db53 100644
--- a/__tests__/mcp-status-freshness.test.ts
+++ b/__tests__/mcp-status-freshness.test.ts
@@ -1,8 +1,9 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
+import { Worker } from 'worker_threads';
 import CodeGraph from '../src/index';
 import { measurePendingChanges } from '../src/mcp/index-freshness';
 import { ToolHandler } from '../src/mcp/tools';
@@ -42,9 +43,8 @@ describe('MCP status freshness (#1959)', () => {
     fs.writeFileSync(path.join(root, 'add.ts'), 'export const added = 1;\n');
 
     const result = await handler.execute('codegraph_status', {});
-    expect(result.structuredContent).toEqual({ freshness: {
-      lastIndexedAt: cg.getLastIndexedAt(), changes: { added: 1, modified: 1, removed: 1 }, complete: true,
-    } });
+    // Claude Code would show structuredContent in place of this text (#2088).
+    expect(result).not.toHaveProperty('structuredContent');
     const changed = result.content[0].text;
     expect(changed).toContain('**Changes since index:** 1 added, 1 modified, 1 removed');
   });
@@ -53,6 +53,32 @@ describe('MCP status freshness (#1959)', () => {
     expect(await measurePendingChanges(path.join(root, 'missing'))).toBeNull();
   });
 
+  it('past its deadline, never terminates the worker before it has loaded its modules', async () => {
+    // Terminating a worker while it loads its modules can crash the whole
+    // process on Windows (0xC0000005). A 1 ms deadline passes while the real
+    // worker is still loading: the answer is unknown at once, and the worker
+    // is terminated only after it has posted 'loaded'.
+    const posted = new WeakSet<object>();
+    const loadedWhenEnded: boolean[] = [];
+    const emit = Worker.prototype.emit;
+    vi.spyOn(Worker.prototype, 'emit').mockImplementation(function (this: Worker, event: string | symbol, ...args: unknown[]) {
+      if (event === 'message') posted.add(this);
+      return emit.call(this, event, ...args);
+    });
+    const terminate = Worker.prototype.terminate;
+    vi.spyOn(Worker.prototype, 'terminate').mockImplementation(function (this: Worker) {
+      loadedWhenEnded.push(posted.has(this));
+      return terminate.call(this);
+    });
+    try {
+      expect(await measurePendingChanges(root, 1)).toBeNull();
+      await vi.waitFor(() => expect(loadedWhenEnded).toHaveLength(1), { timeout: 20_000 });
+      expect(loadedWhenEnded).toEqual([true]);
+    } finally {
+      vi.restoreAllMocks();
+    }
+  }, 30_000);
+
   it('counts edits committed after the index even when the working tree is clean', async () => {
     fs.writeFileSync(path.join(root, 'modify.ts'), 'export const modify = 99;\n');
     execFileSync('git', ['add', 'modify.ts'], { cwd: root, stdio: 'pipe' });
diff --git a/__tests__/member-function-ref-owner.test.ts b/__tests__/member-function-ref-owner.test.ts
new file mode 100644
index 0000000000..697057da83
--- /dev/null
+++ b/__tests__/member-function-ref-owner.test.ts
@@ -0,0 +1,61 @@
+/**
+ * A member passed as a value through a receiver nothing types —
+ * `device=self.parent.device`, `self.check.last_ping` — is only the
+ * project's one method of that name when the receiver is named after its
+ * owner: netbox's model-field reads bound to a GraphQL filter's `device`
+ * method, healthchecks' `check.last_ping` to a transport's.
+ */
+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-member-fnref-'));
+  const files: Record<string, string> = {
+    'app/filters.py': `class FHRPGroupAssignmentFilter:
+    def device(self, queryset):
+        return queryset
+`,
+    'app/components.py': `def describe(parent):
+    return "{interface}".format(interface=parent, device=parent.device)
+`,
+    'app/recorder.py': `class HookRecorder:
+    def finish_recording(self):
+        return None
+
+
+def register(request, hook_recorder):
+    request.addfinalizer(hook_recorder.finish_recording)
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const refsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('member values through an untyped receiver', () => {
+  it('are not a method whose owner the receiver is not named after', () => {
+    expect(refsFrom('app/components.py')).not.toContain('FHRPGroupAssignmentFilter::device');
+  });
+
+  it('are a method whose owner the receiver is named after', () => {
+    expect(refsFrom('app/recorder.py')).toContain('HookRecorder::finish_recording');
+  });
+});
diff --git a/__tests__/migrations-pinable-compat.test.ts b/__tests__/migrations-pinable-compat.test.ts
index 0dd54821a5..9f52ffcf01 100644
--- a/__tests__/migrations-pinable-compat.test.ts
+++ b/__tests__/migrations-pinable-compat.test.ts
@@ -75,7 +75,7 @@ describe('Pinable/upstream schema-version collision (#2060)', () => {
 
   function assertSchema(db: SqliteDatabase): void {
     expect(getCurrentVersion(db)).toBe(CURRENT_SCHEMA_VERSION);
-    expect(CURRENT_SCHEMA_VERSION).toBe(12);
+    expect(CURRENT_SCHEMA_VERSION).toBe(15);
     expect(getPendingMigrations(db)).toEqual([]);
     expect(() => db.prepare('SELECT file_path FROM synthesis_inputs').all()).not.toThrow();
     for (const [index, columns] of Object.entries({
@@ -114,7 +114,7 @@ describe('Pinable/upstream schema-version collision (#2060)', () => {
     connection.close();
     connection = DatabaseConnection.open(dbPath);
     expect(getMigrationHistory(connection.getDb())).toEqual(history);
-    connection.getDb().exec('DELETE FROM schema_versions WHERE version = 12');
+    connection.getDb().exec('DELETE FROM schema_versions WHERE version >= 12');
     runMigrations(connection.getDb(), 11);
     assertSchema(connection.getDb());
     expect(connection.getDb().prepare('SELECT * FROM edges ORDER BY id').all()).toEqual(rows);
diff --git a/__tests__/migrations-pinable-v12.test.ts b/__tests__/migrations-pinable-v12.test.ts
new file mode 100644
index 0000000000..6137c03953
--- /dev/null
+++ b/__tests__/migrations-pinable-v12.test.ts
@@ -0,0 +1,159 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { DatabaseConnection } from '../src/db';
+import { CURRENT_SCHEMA_VERSION, getCurrentVersion, getMigrationHistory, runMigrations } from '../src/db/migrations';
+
+const cursors = ['idx_edges_source_id', 'idx_edges_target_id', 'idx_nodes_file_id'];
+const retryIndexes = ['idx_unresolved_failed_import_tail', 'idx_unresolved_failed_import_name'];
+
+describe('Pinable v12 adoption of upstream v12-v15 without another version collision', () => {
+  let dir: string | undefined;
+  let connection: DatabaseConnection | undefined;
+
+  afterEach(() => {
+    connection?.close();
+    connection = undefined;
+    if (dir) fs.rmSync(dir, { recursive: true, force: true });
+    dir = undefined;
+  });
+
+  function fixture(version = 12, legacyImports = true): string {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-pinable-v12-'));
+    const dbPath = path.join(dir, 'index.db');
+    connection = DatabaseConnection.initialize(dbPath);
+    const db = connection.getDb();
+    db.exec('DELETE FROM schema_versions');
+    db.prepare('INSERT INTO schema_versions VALUES (?, 123, ?)').run(version, 'original history, do not replace');
+    for (const name of cursors) db.exec(`DROP INDEX ${name}`);
+    if (legacyImports) for (const name of retryIndexes) db.exec(`DROP INDEX ${name}`);
+    if (version < 15) db.exec('DROP INDEX idx_unresolved_failed_module_name');
+    db.prepare('INSERT INTO project_metadata VALUES (?, ?, ?)').run('synthesis_pending', '0', 7);
+    db.prepare("INSERT INTO files(path, content_hash, language, size, modified_at, indexed_at) VALUES ('a.dart', 'hash', 'dart', 10, 0, 0)").run();
+    db.prepare(`INSERT INTO nodes(id, kind, name, qualified_name, file_path, language,
+      start_line, end_line, start_column, end_column, updated_at)
+      VALUES ('a', 'file', 'a.dart', 'a.dart', 'a.dart', 'dart', 1, 2, 0, 1, 0)`).run();
+    for (const [name, kind, status, tail] of [
+      ['package:app/b.dart', 'imports', 'failed', legacyImports ? 'dart' : 'b'],
+      ['c.h', 'imports', 'failed', 'h'],
+      ['pending/path.dart', 'imports', 'pending', 'dart'],
+      ['snippets/price.liquid', 'references', 'failed', version < 13 ? 'liquid' : 'price.liquid'],
+      ['lazy-import:./pages/Team', 'references', 'failed', version < 14 ? '/pages/Team' : 'module:Team'],
+      ['lists::map/2', 'calls', 'failed', 'map'],
+    ]) {
+      db.prepare(`INSERT INTO unresolved_refs(from_node_id, reference_name, reference_kind, line, col, file_path, language, status, name_tail)
+        VALUES ('a', ?, ?, 1, 0, 'a.dart', 'dart', ?, ?)`).run(name, kind, status, tail);
+    }
+    return dbPath;
+  }
+
+  const tails = () => connection!.getDb().prepare('SELECT reference_name, status, name_tail FROM unresolved_refs ORDER BY id').all();
+  const hasIndex = (name: string) => !!connection!.getDb().prepare("SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
+
+  it('repairs legacy v12 imports, applies v13-v15, and preserves the occupied v12 history', () => {
+    const dbPath = fixture();
+    connection!.close();
+    connection = DatabaseConnection.open(dbPath);
+    expect(getCurrentVersion(connection.getDb())).toBe(CURRENT_SCHEMA_VERSION);
+    expect(getMigrationHistory(connection.getDb()).map(row => row.version)).toEqual([12, 13, 14, 15]);
+    expect(getMigrationHistory(connection.getDb())[0]).toEqual({version: 12, appliedAt: 123, description: 'original history, do not replace'});
+    for (const name of [...cursors, ...retryIndexes, 'idx_unresolved_failed_module_name']) expect(hasIndex(name)).toBe(true);
+    expect(tails().map(row => row.name_tail)).toEqual(['b', 'h', 'dart', 'price.liquid', 'module:Team', 'map']);
+    expect(connection.getDb().prepare('SELECT COUNT(*) AS n FROM nodes').get().n).toBe(1);
+    expect(connection.getDb().prepare('SELECT COUNT(*) AS n FROM unresolved_refs').get().n).toBe(6);
+    expect(connection.getDb().prepare("SELECT value FROM project_metadata WHERE key = 'synthesis_pending'").get().value).toBe('0');
+  });
+
+  it('adopts an upstream v12 database without replaying its correct import rewrite', () => {
+    const dbPath = fixture(12, false);
+    const before = tails().slice(0, 3);
+    connection!.close();
+    connection = DatabaseConnection.open(dbPath);
+    expect(tails().slice(0, 3)).toEqual(before);
+    expect(tails().map(row => row.name_tail)).toEqual(['b', 'h', 'dart', 'price.liquid', 'module:Team', 'map']);
+    for (const name of cursors) expect(hasIndex(name)).toBe(true);
+  });
+
+  it('adds cursor indexes even when the upstream version is already current', () => {
+    const dbPath = fixture(15, false);
+    const history = getMigrationHistory(connection!.getDb());
+    const rows = tails();
+    connection!.close();
+    connection = DatabaseConnection.open(dbPath);
+    for (const name of cursors) expect(hasIndex(name)).toBe(true);
+    expect(getMigrationHistory(connection.getDb())).toEqual(history);
+    expect(tails()).toEqual(rows);
+  });
+
+  it.each(retryIndexes)('repairs when just %s is missing', missing => {
+    fixture(15, false);
+    connection!.getDb().exec(`DROP INDEX ${missing}`);
+    connection!.getDb().prepare('UPDATE unresolved_refs SET name_tail = ? WHERE reference_name = ?').run('dart', 'package:app/b.dart');
+    runMigrations(connection!.getDb(), 15);
+    for (const name of retryIndexes) expect(hasIndex(name)).toBe(true);
+    expect(tails()[0].name_tail).toBe('b');
+    expect(getMigrationHistory(connection!.getDb())).toHaveLength(1);
+  });
+
+  it.each([12, 15])('does not repair or change history through a read-only v%s connection', version => {
+    const dbPath = fixture(version, version === 12);
+    const before = tails();
+    const history = getMigrationHistory(connection!.getDb());
+    connection!.close();
+    connection = DatabaseConnection.open(dbPath, {readOnly: true});
+    for (const name of cursors) expect(hasIndex(name)).toBe(false);
+    expect(tails()).toEqual(before);
+    expect(getMigrationHistory(connection.getDb())).toEqual(history);
+    connection.close();
+    connection = DatabaseConnection.open(dbPath);
+    for (const name of cursors) expect(hasIndex(name)).toBe(true);
+  });
+
+  it('rolls back feature repairs together when the legacy import rewrite fails', () => {
+    fixture();
+    const db = connection!.getDb();
+    db.exec(`DROP TABLE synthesis_inputs;
+      CREATE TRIGGER reject_import_rewrite BEFORE UPDATE ON unresolved_refs
+      WHEN OLD.reference_kind = 'imports' BEGIN SELECT RAISE(ABORT, 'repair blocked'); END;`);
+    const before = tails();
+    const history = getMigrationHistory(db);
+    expect(() => runMigrations(db, 12)).toThrow(/repair blocked/);
+    expect(tails()).toEqual(before);
+    expect(getMigrationHistory(db)).toEqual(history);
+    expect(db.prepare("SELECT 1 FROM sqlite_master WHERE name = 'synthesis_inputs'").get()).toBeUndefined();
+    expect(db.prepare("SELECT value FROM project_metadata WHERE key = 'synthesis_pending'").get().value).toBe('0');
+    for (const name of [...cursors, ...retryIndexes]) expect(hasIndex(name)).toBe(false);
+    db.exec('DROP TRIGGER reject_import_rewrite');
+    runMigrations(db, 12);
+    expect(getCurrentVersion(db)).toBe(15);
+    expect(tails()[0].name_tail).toBe('b');
+  });
+
+  it('does no DDL or row writes on a healthy repeated migration and preserves reopen state', () => {
+    const dbPath = fixture();
+    const db = connection!.getDb();
+    runMigrations(db, 12);
+    const before = tails();
+    const history = getMigrationHistory(db);
+    const schemaVersion = db.pragma('schema_version', {simple: true});
+    const changes = db.prepare('SELECT total_changes() AS n').get().n;
+    runMigrations(db, getCurrentVersion(db));
+    expect(db.prepare('SELECT total_changes() AS n').get().n).toBe(changes);
+    expect(db.pragma('schema_version', {simple: true})).toBe(schemaVersion);
+    connection!.close();
+    connection = DatabaseConnection.open(dbPath);
+    expect(tails()).toEqual(before);
+    expect(getMigrationHistory(connection.getDb())).toEqual(history);
+    expect(connection.getDb().pragma('schema_version', {simple: true})).toBe(schemaVersion);
+  });
+
+  it('leaves an unknown newer schema to the application version that owns it', () => {
+    const dbPath = fixture(CURRENT_SCHEMA_VERSION + 1, false);
+    const history = getMigrationHistory(connection!.getDb());
+    connection!.close();
+    connection = DatabaseConnection.open(dbPath);
+    for (const name of cursors) expect(hasIndex(name)).toBe(false);
+    expect(getMigrationHistory(connection.getDb())).toEqual(history);
+  });
+});
diff --git a/__tests__/minified-call-targets.test.ts b/__tests__/minified-call-targets.test.ts
new file mode 100644
index 0000000000..b154c0212b
--- /dev/null
+++ b/__tests__/minified-call-targets.test.ts
@@ -0,0 +1,47 @@
+/**
+ * A vendored minified script's names are mangled, so no other file's call
+ * means one of them by name: healthchecks' 369 `$(…)` calls — jQuery, loaded
+ * as a global — went to a one-letter helper inside bootstrap-native.min.js.
+ * Detected by name (`*.min.js`) or by text (a few enormous lines).
+ */
+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-minified-'));
+  const bundle = `!function(){${Array.from({ length: 120 }, (_, i) => `function f${i}(e,t){return e+t+${i}}`).join(';')};function u(e){return f1(e,2)}}();\n`;
+  const files: Record<string, string> = {
+    'static/js/vendor.min.js': `function $(e){return document.querySelector(e)}function q(e){return $(e)}\n`,
+    'static/js/bundle.js': bundle.repeat(4),
+    'static/js/app.js': `function init() {
+  $("#edit-name").click(function () {});
+  u("x");
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('calls into minified scripts', () => {
+  it('never resolve by name from another file', () => {
+    const ids = cg.getNodesInFile('static/js/app.js').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.filePath);
+    expect(targets).not.toContain('static/js/vendor.min.js');
+    expect(targets).not.toContain('static/js/bundle.js');
+  });
+});
diff --git a/__tests__/monorepo-app-frameworks.test.ts b/__tests__/monorepo-app-frameworks.test.ts
new file mode 100644
index 0000000000..c5a4664fc8
--- /dev/null
+++ b/__tests__/monorepo-app-frameworks.test.ts
@@ -0,0 +1,128 @@
+/**
+ * In a monorepo, a file-based router reads only its own app's files.
+ *
+ * create-t3-turbo, tamagui's starter and react-native-reusables keep an Expo
+ * app beside a Next.js app. Expo Router read the Next app's `app/` folder as
+ * its own: `app/layout.tsx` became a `/layout` screen, `app/page.tsx` a
+ * `/page` one, a `_components/posts.tsx` a `/_components/posts` screen, and
+ * `app/api/auth/[...all]/route.ts` a screen named after the file.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+async function project(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-app-frameworks-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+const routesIn = (cg: CodeGraph, dir: string): string[] =>
+  cg
+    .getNodesByKind('route')
+    .filter((n) => n.filePath.startsWith(dir))
+    .map((n) => n.name)
+    .sort();
+
+describe('file-based routers in a monorepo', () => {
+  it('Expo Router reads the Expo app, Next.js the Next app', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'mono', private: true, workspaces: ['apps/*'] }),
+      'apps/mobile/package.json': JSON.stringify({ name: 'mobile', dependencies: { expo: '*', 'expo-router': '*', react: '*' } }),
+      'apps/mobile/app/_layout.tsx': `export default function Layout() { return null; }
+`,
+      'apps/mobile/app/index.tsx': `export default function Home() { return null; }
+`,
+      'apps/mobile/app/user/[id].tsx': `export default function User() { return null; }
+`,
+      'apps/web/package.json': JSON.stringify({ name: 'web', dependencies: { next: '*', react: '*' } }),
+      'apps/web/app/layout.tsx': `export default function RootLayout({ children }: { children: unknown }) { return children; }
+`,
+      'apps/web/app/page.tsx': `export default function Page() { return null; }
+`,
+      'apps/web/app/user/[id]/page.tsx': `export default function UserPage() { return null; }
+`,
+      'apps/web/app/_components/posts.tsx': `export default function Posts() { return null; }
+`,
+      'apps/web/app/api/auth/[...all]/route.ts': `export async function GET() { return new Response('ok'); }
+`,
+    });
+    try {
+      expect(routesIn(cg, 'apps/mobile/')).toEqual(['/', '/user/[id]']);
+      const web = routesIn(cg, 'apps/web/');
+      expect(web).toContain('/');
+      expect(web).toContain('/user/:id');
+      for (const bogus of ['/layout', '/page', '/_components/posts', '/api/auth/[...all]/route', '/user/[id]/page']) {
+        expect(web).not.toContain(bogus);
+      }
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a single Expo app at the repository root keeps its routes', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'demo', dependencies: { expo: '*', 'expo-router': '*' } }),
+      'app/_layout.tsx': `export default function Layout() { return null; }
+`,
+      'app/settings.tsx': `export default function Settings() { return null; }
+`,
+    });
+    try {
+      expect(routesIn(cg, 'app/')).toEqual(['/settings']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('the nearest manifest that names a router decides: a Next docs app under an Expo root', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'true-sheet', devDependencies: { expo: '*', 'expo-router': '*', react: '*' } }),
+      'docs/package.json': JSON.stringify({ name: 'docs', dependencies: { next: '*', react: '*' } }),
+      'docs/app/layout.tsx': `export default function RootLayout({ children }: { children: unknown }) { return children; }
+`,
+      'docs/app/(docs)/[...slug]/page.tsx': `export default function DocPage() { return null; }
+`,
+      'example/app/_layout.tsx': `export default function Layout() { return null; }
+`,
+      'example/app/sheet.tsx': `export default function Sheet() { return null; }
+`,
+    });
+    try {
+      expect(routesIn(cg, 'docs/')).toEqual(['/:slug*']);
+      expect(routesIn(cg, 'example/')).toEqual(['/sheet']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('an Expo API route is an endpoint per exported method, not a screen', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'site', dependencies: { expo: '*', 'expo-router': '*' } }),
+      'app/index.tsx': `export default function Home() { return null; }
+`,
+      'app/blog/og-image/[post]+api.ts': `export async function GET(request: Request) { return new Response('png'); }
+export const POST = async () => new Response('ok');
+`,
+    });
+    try {
+      expect(routesIn(cg, 'app/')).toEqual(['/', 'GET /blog/og-image/:post', 'POST /blog/og-image/:post']);
+      const get = cg.getNodesByKind('route').find((n) => n.name.startsWith('GET '))!;
+      const handler = cg.getOutgoingEdges(get.id).map((e) => cg.getNode(e.target)!).find((n) => n.name === 'GET');
+      expect(handler?.kind).toBe('function');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/mpeg-ts-not-typescript.test.ts b/__tests__/mpeg-ts-not-typescript.test.ts
index 5d44003d2e..dfc23a1950 100644
--- a/__tests__/mpeg-ts-not-typescript.test.ts
+++ b/__tests__/mpeg-ts-not-typescript.test.ts
@@ -215,7 +215,10 @@ describe('MPEG-TS video named .ts is skipped, real TypeScript is indexed (#1910)
   });
 });
 
-describe('a video .ts never stays pending (#1910)', () => {
+// Each case builds a git repository and indexes it, the last one twice over. On
+// Windows every git process costs ~100 ms, which puts these cases at 5–6 s there,
+// past vitest's 5 s default.
+describe('a video .ts never stays pending (#1910)', { timeout: 30_000 }, () => {
   const dirs: string[] = [];
   afterEach(() => { for (const d of dirs.splice(0)) fs.rmSync(d, { recursive: true, force: true }); });
   const gitProject = (): string => {
diff --git a/__tests__/namespace-reexport.test.ts b/__tests__/namespace-reexport.test.ts
new file mode 100644
index 0000000000..2d9fcc7d70
--- /dev/null
+++ b/__tests__/namespace-reexport.test.ts
@@ -0,0 +1,103 @@
+/**
+ * `export * as core from './core'` exports `core` — not every member of
+ * `./core` as if it were `export *`. Read as a wildcard, zod's
+ * `z.number()` walked into core and on into `export * as regexes`, landing
+ * on the `number` regex constant (262 `z.string()` calls did the same); the
+ * schema function it means sits in a LATER `export * from './schemas'`.
+ * `z.core.safeParse()` continues into the namespaced module, and a member a
+ * barrel forwards by name (`export { safeParse } from '../core'`) is found
+ * for `import * as m` too.
+ */
+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-ns-reexport-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'schema', private: true }),
+    'src/core/regexes.ts': `export const number = /^-?\\d+$/;
+`,
+    'src/core/parse.ts': `export function safeParse(value: unknown) {
+  return { success: true, data: value };
+}
+`,
+    'src/core/api.ts': `export function _lt(limit: number) {
+  return limit;
+}
+`,
+    'src/core/index.ts': `export * as regexes from "./regexes.js";
+export * from "./parse.js";
+export * from "./api.js";
+`,
+    'src/classic/schemas.ts': `export function number() {
+  return { kind: "number" };
+}
+`,
+    'src/classic/external.ts': `export * as core from "../core/index.js";
+export * from "./schemas.js";
+export { _lt as lt } from "../core/index.js";
+`,
+    'src/mini/parse.ts': `export { safeParse } from "../core/index.js";
+`,
+    'src/mini/external.ts': `export * as core from "../core/index.js";
+export * from "./parse.js";
+`,
+    'src/tests/classic.test.ts': `import * as z from "../classic/external.js";
+
+export function classic() {
+  z.number();
+  z.lt(10);
+  z.core.safeParse(1);
+}
+`,
+    'src/tests/mini.test.ts': `import * as m from "../mini/external.js";
+
+export function mini() {
+  m.safeParse(1);
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `file: qualified name` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => {
+      const t = cg.getNode(e.target)!;
+      return `${t.filePath}: ${t.qualifiedName}`;
+    })
+    .sort();
+}
+
+describe('`export * as ns` re-exports', () => {
+  it('export the namespace only, so a later `export *` supplies the member', () => {
+    expect(callsFrom('src/tests/classic.test.ts')).toEqual([
+      'src/classic/schemas.ts: number',
+      'src/core/api.ts: _lt',
+      'src/core/parse.ts: safeParse',
+    ]);
+  });
+
+  it('find a member a barrel forwards by name for a namespace import', () => {
+    expect(callsFrom('src/tests/mini.test.ts')).toEqual(['src/core/parse.ts: safeParse']);
+  });
+});
diff --git a/__tests__/nestjs-global-prefix.test.ts b/__tests__/nestjs-global-prefix.test.ts
new file mode 100644
index 0000000000..fcb554a538
--- /dev/null
+++ b/__tests__/nestjs-global-prefix.test.ts
@@ -0,0 +1,217 @@
+/**
+ * A NestJS route is named by the path a request takes to it — the app's
+ * global prefix and URI version included.
+ *
+ * `app.setGlobalPrefix('api')` and `app.enableVersioning({ type:
+ * VersioningType.URI, defaultVersion: '1' })` in `main.ts` put every
+ * controller under `/api/v1`, but the routes were named `GET /user`. A front
+ * end's `this.http.get('/api/v1/user')` then connected to nothing: Ghostfolio's
+ * Angular client had no link to its own NestJS API.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const projects: string[] = [];
+afterAll(() => {
+  for (const p of projects.splice(0)) fs.rmSync(p, { recursive: true, force: true });
+});
+
+async function project(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-nest-prefix-'));
+  projects.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+const MAIN = `import { NestFactory } from '@nestjs/core';
+import { VersioningType } from '@nestjs/common';
+import { AppModule } from './app/app.module';
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableVersioning({ defaultVersion: '1', type: VersioningType.URI });
+  app.setGlobalPrefix('api', { exclude: ['sitemap.xml', 'health{/*wildcard}'] });
+  await app.listen(3333);
+}
+bootstrap();
+`;
+
+describe('NestJS: the global prefix and URI versioning', () => {
+  it('names each route under the prefix and its version — or neither, where the app says so', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ dependencies: { '@nestjs/core': '^11.0.0', '@nestjs/common': '^11.0.0' } }),
+      'apps/api/src/main.ts': MAIN,
+      // A seed script creates the same app without serving it — and is read first.
+      'apps/api/src/database/run-seed.ts': `import { NestFactory } from '@nestjs/core';
+const runSeed = async () => {
+  const app = await NestFactory.create(SeedModule);
+  await app.close();
+};
+void runSeed();
+`,
+      'apps/api/src/app/user.controller.ts': `import { Controller, Get, Post, Version, VERSION_NEUTRAL } from '@nestjs/common';
+@Controller('user')
+export class UserController {
+  @Get()
+  public getUser() {}
+
+  @Post()
+  @UseGuards(AuthGuard('jwt'))
+  @Version('2')
+  public createUser() {}
+
+  @Get('oidc/callback')
+  @Version(VERSION_NEUTRAL)
+  public callback() {}
+}
+`,
+      'apps/api/src/app/sitemap.controller.ts': `import { Controller, Get, Version, VERSION_NEUTRAL } from '@nestjs/common';
+@Controller()
+@Version(VERSION_NEUTRAL)
+export class SitemapController {
+  @Get('sitemap.xml')
+  public sitemap() {}
+}
+`,
+      'apps/api/src/app/health.controller.ts': `import { Controller, Get } from '@nestjs/common';
+@Controller({ path: 'health', version: '3' })
+export class HealthController {
+  @Get('db')
+  public db() {}
+}
+`,
+      // A second app that sets nothing: its routes stay as written.
+      'apps/jobs/src/main.ts': `import { NestFactory } from '@nestjs/core';
+NestFactory.create(JobsModule).then((app) => app.listen(3335));
+`,
+      'apps/jobs/src/jobs.controller.ts': `import { Controller, Get } from '@nestjs/common';
+@Controller('jobs')
+export class JobsController {
+  @Get()
+  public list() {}
+}
+`,
+    });
+    try {
+      expect(
+        cg
+          .getNodesByKind('route')
+          .map((r) => r.name)
+          .sort()
+      ).toEqual([
+        // VERSION_NEUTRAL: prefixed, not versioned.
+        'GET /api/user/oidc/callback',
+        'GET /api/v1/user',
+        'GET /jobs',
+        'GET /sitemap.xml',
+        // Excluded from the prefix, still versioned by its controller.
+        'GET /v3/health/db',
+        'POST /api/v2/user',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('reads a version past decorators with object arguments, and each app its own bootstrap', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ dependencies: { '@nestjs/core': '^11.0.0', '@nestjs/common': '^11.0.0' } }),
+      'apps/api/src/main.ts': MAIN,
+      'apps/api/src/app/stats.controller.ts': `import { Controller, Get, Version } from '@nestjs/common';
+@Controller('stats')
+export class StatsController {
+  @Version('2')
+  @ApiResponse({ status: 200, description: 'The stats' })
+  @Get('daily')
+  public daily() {}
+
+  @Get('weekly')
+  public weekly() {}
+}
+`,
+      'apps/api/src/app/reports.controller.ts': `import { Controller, Get, Version } from '@nestjs/common';
+@Version('4')
+@ApiTags({ name: 'reports' })
+@Controller('reports')
+export class ReportsController {
+  @Get()
+  public list() {}
+}
+`,
+      // A second app whose prefix is read from config: no prefix is claimed for
+      // it, and the other app's `/api` is not borrowed.
+      'apps/admin/src/main.ts': `import { NestFactory } from '@nestjs/core';
+async function bootstrap() {
+  const app = await NestFactory.create(AdminModule);
+  app.setGlobalPrefix(config.get('app.prefix'));
+  app.enableVersioning({ defaultVersion: '1' });
+  await app.listen(3334);
+}
+bootstrap();
+`,
+      'apps/admin/src/users.controller.ts': `import { Controller, Get } from '@nestjs/common';
+@Controller('users')
+export class UsersController {
+  @Get()
+  public list() {}
+}
+`,
+    });
+    try {
+      expect(
+        cg
+          .getNodesByKind('route')
+          .map((r) => r.name)
+          .sort()
+      ).toEqual(['GET /api/v1/stats/weekly', 'GET /api/v2/stats/daily', 'GET /api/v4/reports', 'GET /v1/users']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it("connects a front end's request to the route it reaches, and leaves an Express route in the same repo alone", async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({
+        dependencies: { '@nestjs/core': '^11.0.0', '@nestjs/common': '^11.0.0', '@angular/core': '^19.0.0', express: '^4.0.0' },
+      }),
+      'apps/api/src/main.ts': MAIN,
+      'apps/api/src/app/user.controller.ts': `import { Controller, Get } from '@nestjs/common';
+@Controller('user')
+export class UserController {
+  @Get()
+  public getUser() {}
+}
+`,
+      'apps/client/src/app/user.service.ts': `import { HttpClient } from '@angular/common/http';
+export class UserService {
+  constructor(private http: HttpClient) {}
+  public fetchUser() {
+    return this.http.get<User>('/api/v1/user');
+  }
+}
+`,
+      'tools/mock-server/src/server.ts': `import express from 'express';
+const app = express();
+app.get('/status', (req, res) => res.json({ ok: true }));
+`,
+    });
+    try {
+      const names = cg.getNodesByKind('route').map((r) => r.name).sort();
+      expect(names).toContain('GET /api/v1/user');
+      expect(names).toContain('GET /status');
+      const fetchUser = cg.getNodesByName('fetchUser')[0]!;
+      const reached = cg
+        .getOutgoingEdgesFrom([fetchUser.id], ['calls'])
+        .filter((e) => (e.metadata as Record<string, unknown> | undefined)?.channel === 'http')
+        .map((e) => cg.getNode(e.target)?.name);
+      expect(reached).toEqual(['GET /api/v1/user']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/nestjs-provider-same-file.test.ts b/__tests__/nestjs-provider-same-file.test.ts
new file mode 100644
index 0000000000..fe219d0c9f
--- /dev/null
+++ b/__tests__/nestjs-provider-same-file.test.ts
@@ -0,0 +1,54 @@
+/**
+ * The NestJS provider convention (`*Service`, `*Controller`, …) picks a
+ * class by name only from the reference's own file in a TS/JS module —
+ * another file's comes through an import, the import resolver's. Its
+ * file-name preference (`*.service.ts`) beat name matching's proximity:
+ * Nest's own specs' `TransientService` / `TestService` went to same-named
+ * classes in unrelated integration apps.
+ */
+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-nest-provider-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'nest', private: true, dependencies: { '@nestjs/common': '^10.0.0' } }),
+    'integration/injector/src/app.module.ts': `import { Module } from '@nestjs/common';
+
+@Module({})
+export class AppModule {}
+`,
+    'integration/injector/src/scoped/transient.service.ts': `export class TransientService {}
+`,
+    'packages/core/test/scope/helpers.ts': `export class TransientService {}
+`,
+    'packages/core/test/scope/transient-scope.spec.ts': `class Holder {
+  constructor(public transient: TransientService) {}
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('NestJS provider names', () => {
+  it('never prefer another file’s class for its file name over a nearer one', () => {
+    const ids = cg.getNodesInFile('packages/core/test/scope/transient-scope.spec.ts').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references').map((e) => cg.getNode(e.target)!.filePath);
+    expect(targets).not.toContain('integration/injector/src/scoped/transient.service.ts');
+  });
+});
diff --git a/__tests__/objc-message-scope.test.ts b/__tests__/objc-message-scope.test.ts
new file mode 100644
index 0000000000..522263bb80
--- /dev/null
+++ b/__tests__/objc-message-scope.test.ts
@@ -0,0 +1,118 @@
+/**
+ * An Objective-C message reached by name alone must be in reach:
+ *
+ * - a message to `self` / `super` (the extractor drops the receiver) is a
+ *   method of the sender's class hierarchy — SDWebImage's `[self class]`
+ *   went to SDWeakProxy's `class` 71 times;
+ * - C call syntax (`completionBlock()`) calls a block, a function or a
+ *   function pointer, never a method or property;
+ * - a message to an untyped local needs its declaration (`FMResultSet *rs`)
+ *   or a receiver named after the class — `[image respondsToSelector:]` is
+ *   NSObject's, not the one proxy class that overrides it.
+ */
+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-objc-scope-'));
+  const files: Record<string, string> = {
+    'Core/SDWeakProxy.h': `#import <Foundation/Foundation.h>
+@interface SDWeakProxy : NSProxy
+- (Class)class;
+- (BOOL)respondsToSelector:(SEL)aSelector;
+@end
+`,
+    'Core/SDWeakProxy.m': `#import "SDWeakProxy.h"
+@implementation SDWeakProxy
+- (Class)class {
+    return nil;
+}
+- (BOOL)respondsToSelector:(SEL)aSelector {
+    return NO;
+}
+@end
+`,
+    'Core/SDPrefetchToken.h': `#import <Foundation/Foundation.h>
+@interface SDPrefetchToken : NSObject
+@property (nonatomic, copy) void (^completionBlock)(void);
+@end
+`,
+    'Core/FMResultSet.h': `#import <Foundation/Foundation.h>
+@interface FMResultSet : NSObject
+- (BOOL)next;
+@end
+`,
+    'Core/FMResultSet.m': `#import "FMResultSet.h"
+@implementation FMResultSet
+- (BOOL)next {
+    return NO;
+}
+@end
+`,
+    'Core/SDBase.h': `#import <Foundation/Foundation.h>
+@interface SDBase : NSObject
+- (void)prepare;
+@end
+`,
+    'Core/SDBase.m': `#import "SDBase.h"
+@implementation SDBase
+- (void)prepare {
+}
+@end
+`,
+    'Core/SDCache.h': `#import "SDBase.h"
+@interface SDCache : SDBase
+- (void)storeWithCompletion:(void (^)(void))completionBlock image:(id)image;
+@end
+`,
+    'Core/SDCache.m': `#import "SDCache.h"
+#import "FMResultSet.h"
+@implementation SDCache
+- (void)storeWithCompletion:(void (^)(void))completionBlock image:(id)image {
+    Class cls = [self class];
+    [super prepare];
+    [self helper];
+    FMResultSet *rs = [self query];
+    while ([rs next]) {
+    }
+    if ([image respondsToSelector:@selector(copy)]) {
+    }
+    completionBlock();
+}
+- (void)helper {
+}
+- (FMResultSet *)query {
+    return nil;
+}
+@end
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Objective-C messages reached by name alone', () => {
+  it('reach the sender’s hierarchy and typed locals; never a proxy override or a property through C call syntax', () => {
+    const method = cg.getNodesInFile('Core/SDCache.m').find((n) => n.name.startsWith('storeWithCompletion'))!;
+    const targets = cg
+      .getOutgoingEdges(method.id)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName)
+      .sort();
+    expect(targets).toEqual(['FMResultSet::next', 'SDBase::prepare', 'SDCache::helper', 'SDCache::query']);
+  });
+});
diff --git a/__tests__/objc-same-name-protocol.test.ts b/__tests__/objc-same-name-protocol.test.ts
new file mode 100644
index 0000000000..df471e353d
--- /dev/null
+++ b/__tests__/objc-same-name-protocol.test.ts
@@ -0,0 +1,57 @@
+/**
+ * An Objective-C class that conforms to a protocol of its own name —
+ * SDWebImage's `@interface SDDiskCache : NSObject <SDDiskCache>` — implements
+ * the protocol, not itself. The SwiftUI / UIKit / Vapor conventions are
+ * Swift's (they took the ObjC ref), and among the protocol's copies the
+ * declaring header's own is the one.
+ */
+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;
+
+const header = `#import <Foundation/Foundation.h>
+
+@protocol SDDiskCache <NSObject>
+- (nullable NSData *)dataForKey:(nonnull NSString *)key;
+@end
+
+@interface SDDiskCache : NSObject <SDDiskCache>
+@end
+`;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-objc-protocol-'));
+  const files: Record<string, string> = {
+    'SDWebImage/Core/SDDiskCache.h': header,
+    'SDWebImage/include/SDWebImage/SDDiskCache.h': header,
+    'Examples/SwiftUIDemo/ContentView.swift': `import SwiftUI
+
+struct ContentView: View {
+    var body: some View { Text("x") }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('an Objective-C class conforming to its namesake protocol', () => {
+  it('implements the protocol in its own header', () => {
+    const cls = cg.getNodesInFile('SDWebImage/Core/SDDiskCache.h').find((n) => n.kind === 'class')!;
+    const targets = cg.getOutgoingEdgesFrom([cls.id]).filter((e) => e.kind === 'implements').map((e) => cg.getNode(e.target)!);
+    expect(targets.map((t) => `${t.kind} ${t.filePath}`)).toEqual(['protocol SDWebImage/Core/SDDiskCache.h']);
+  });
+});
diff --git a/__tests__/objc-super-send.test.ts b/__tests__/objc-super-send.test.ts
new file mode 100644
index 0000000000..3a6ba69153
--- /dev/null
+++ b/__tests__/objc-super-send.test.ts
@@ -0,0 +1,84 @@
+/**
+ * `[super init]` goes past the class it is written in: to the superclass's
+ * `init`, or — for an NSObject subclass — to no project method at all.
+ * SDWebImage's NSObject subclasses sent `[super init]` to SDDiskCache's
+ * `init` (their `@implementation` range was lost, so no hierarchy was read
+ * and any `init` passed), and SDDiskCache's own `[super init]` came back to
+ * itself.
+ */
+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-objc-super-'));
+  const files: Record<string, string> = {
+    'Base.h': `#import <Foundation/Foundation.h>
+@interface Base : NSObject
+- (instancetype)init;
+@end
+`,
+    'Base.m': `#import "Base.h"
+@implementation Base
+- (instancetype)init {
+    self = [super init];
+    return self;
+}
+@end
+`,
+    'Child.h': `#import "Base.h"
+@interface Child : Base
+@end
+`,
+    'Child.m': `#import "Child.h"
+@implementation Child
+- (instancetype)init {
+    self = [super init];
+    return self;
+}
+@end
+`,
+    'Other.m': `#import <Foundation/Foundation.h>
+@interface Other : NSObject
+@end
+@implementation Other
+- (instancetype)init {
+    self = [super init];
+    return self;
+}
+@end
+`,
+  };
+  for (const [rel, content] of Object.entries(files)) {
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('Objective-C messages to super', () => {
+  it('reach the superclass, never the sender itself or an unrelated class', () => {
+    expect(callsFrom('Child.m')).toEqual(['Base::init']);
+    expect(callsFrom('Base.m')).toEqual([]);
+    expect(callsFrom('Other.m')).toEqual([]);
+  });
+});
diff --git a/__tests__/oversize-file-not-read.test.ts b/__tests__/oversize-file-not-read.test.ts
index f32267f73f..fad014c375 100644
--- a/__tests__/oversize-file-not-read.test.ts
+++ b/__tests__/oversize-file-not-read.test.ts
@@ -89,8 +89,17 @@ describe('an unchanged file over the size limit is not reported as drifted (#191
     dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-oversize-drift-'));
     fs.writeFileSync(path.join(dir, 'app.ts'), 'export function alpha() { return 1; }\n');
     // 1.4 MB of ordinary text: over the index limit, under the viewer's 8 MB read cap.
-    const line = 'const x = 1;\n';
-    fs.writeFileSync(path.join(dir, 'big.js'), line.repeat(Math.ceil((1.4 * 1024 * 1024) / line.length)));
+    // Each line differs: Windows Defender's script scan of a freshly written `.js`
+    // made of one statement repeated 110k times takes close to a minute on the
+    // first read, so the viewer's read below blew the test timeout there. Real
+    // code of the same size is scanned in milliseconds.
+    const line = 'const last = 0;\n';
+    const lines: string[] = [];
+    for (let size = 0, i = 0; size < 1.4 * 1024 * 1024; i++) {
+      lines.push(`const x${i} = ${i};\n`);
+      size += lines[i]!.length;
+    }
+    fs.writeFileSync(path.join(dir, 'big.js'), lines.join(''));
     const cg = await CodeGraph.init(dir, { index: true });
     try {
       const record = cg.getFiles().find((f) => f.path === 'big.js')!;
diff --git a/__tests__/package-deps.test.ts b/__tests__/package-deps.test.ts
new file mode 100644
index 0000000000..1bfa7b669b
--- /dev/null
+++ b/__tests__/package-deps.test.ts
@@ -0,0 +1,246 @@
+/**
+ * Which `package.json` files framework detection reads
+ * (`src/resolution/frameworks/package-deps.ts`).
+ *
+ * The index lists source files, never manifests, so the candidates are
+ * directories probed on disk. An ASP.NET solution keeps its single-page app
+ * three levels down: jasontaylordev/CleanArchitecture's Angular app is
+ * `src/Web/ClientApp/` and its React twin `src/Web/ClientApp-React/`.
+ * prometheus keeps its React apps in `web/ui/mantine-ui/` and
+ * `web/ui/react-app/`, under a workspace root at `web/ui/` that declares only
+ * tooling. Read two levels deep, none of those manifests was read, so Angular
+ * Router, the Angular template pass and React Router's navigation never ran,
+ * and every template-bound handler was listed as dead code.
+ */
+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';
+import { buildDeadCodeReport } from '../src/graph/dead-code';
+import { declaredDependencies, dependsOn } from '../src/resolution/frameworks/package-deps';
+import type { ResolutionContext } from '../src/resolution/types';
+
+/** A context over an indexed file list and the manifests on disk, recording every probe. */
+function tree(files: string[], manifests: Record<string, Record<string, Record<string, string>>>) {
+  const probes: string[] = [];
+  const context = {
+    getAllFiles: () => files,
+    fileExists: (p: string) => {
+      probes.push(p);
+      return p in manifests;
+    },
+    readFile: (p: string) => (p in manifests ? JSON.stringify(manifests[p]) : null),
+  } as unknown as ResolutionContext;
+  return { context, probes };
+}
+
+describe('declaredDependencies: manifests below the first two levels', () => {
+  it.each([
+    ['src/Web/ClientApp/', 'an ASP.NET solution'],
+    ['src/Presentation/Web/ClientApp/', 'a solution folder deeper still'],
+  ])('reads %s, where %s keeps its app', (app) => {
+    const { context } = tree(
+      ['src/Web/Program.cs', `${app}karma.conf.js`, `${app}src/main.ts`, `${app}src/app/app.module.ts`],
+      { [`${app}package.json`]: { dependencies: { '@angular/core': '^21.1.5', '@angular/router': '^21.1.5' } } }
+    );
+    expect(dependsOn(context, '@angular/router')).toBe(true);
+  });
+
+  it('reads a workspace root two levels down and the apps a level below it', () => {
+    const { context } = tree(
+      ['cmd/prometheus/main.go', 'web/ui/mantine-ui/src/main.tsx', 'web/ui/react-app/src/App.tsx', 'web/ui/module/lezer-promql/src/index.ts'],
+      {
+        'web/ui/package.json': { devDependencies: { typescript: '*', vite: '*' } },
+        'web/ui/mantine-ui/package.json': { dependencies: { react: '*', 'react-router-dom': '*' } },
+        'web/ui/react-app/package.json': { dependencies: { react: '*', 'react-router': '*' } },
+      }
+    );
+    const names = declaredDependencies(context);
+    expect([...names].sort()).toEqual(['react', 'react-router', 'react-router-dom', 'typescript', 'vite']);
+  });
+
+  it('never reads a manifest inside node_modules', () => {
+    const { context, probes } = tree(
+      ['tools/site/node_modules/framework/dist/index.js', 'tools/site/src/index.ts'],
+      { 'tools/site/node_modules/framework/package.json': { dependencies: { next: '*' } } }
+    );
+    expect(dependsOn(context, 'next')).toBe(false);
+    expect(probes.filter((p) => p.includes('node_modules'))).toEqual([]);
+  });
+
+  it('probes only above JS/TS code, and a bounded number of directories however many hold it', () => {
+    const files = ['src/Api/Tools/Generator.cs'];
+    for (let i = 0; i < 3000; i++) files.push(`src/app/feature${i}/parts/widget.component.ts`);
+    const { context, probes } = tree(files, { 'src/Api/Tools/package.json': { dependencies: { express: '*' } } });
+    expect(dependsOn(context, 'express')).toBe(false);
+    // `src/`, `src/Api/`, `src/app/` from the first two levels; the rest below them.
+    expect(probes.length).toBeLessThanOrEqual(3 + 192);
+  });
+
+  it('reads the same manifests whatever order the files are listed in', () => {
+    const files: string[] = [];
+    const manifests: Record<string, Record<string, Record<string, string>>> = {};
+    for (let i = 0; i < 40; i++) {
+      files.push(`clients/web/app${i}/src/index.ts`);
+      manifests[`clients/web/app${i}/package.json`] = { dependencies: { [`dep-${i}`]: '*' } };
+    }
+    const scanned = declaredDependencies(tree(files, manifests).context);
+    const reversed = declaredDependencies(tree([...files].reverse(), manifests).context);
+    expect([...reversed].sort()).toEqual([...scanned].sort());
+    // A sample, as above two levels: the root and 24 more.
+    expect(scanned.size).toBe(24);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// End to end: CleanArchitecture's shape
+// ---------------------------------------------------------------------------
+
+const ngComponent = (name: string, selector: string, templateUrl: string, body = '', imports = '') => `import { Component } from '@angular/core';
+${imports}
+@Component({
+  standalone: false,
+  selector: '${selector}',
+  templateUrl: '${templateUrl}'
+})
+export class ${name} {
+${body}
+}
+`;
+
+describe('an ASP.NET solution with its single-page apps three levels down, indexed', () => {
+  let root: string;
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-deep-manifest-'));
+    const files: Record<string, string> = {
+      'src/Web/Program.cs': 'var app = WebApplication.CreateBuilder(args).Build();\napp.Run();\n',
+      'src/Web/ClientApp/package.json': JSON.stringify({ dependencies: { '@angular/core': '^21.1.5', '@angular/router': '^21.1.5' } }),
+      'src/Web/ClientApp/angular.json': '{}',
+      'src/Web/ClientApp/src/app/app.module.ts': `import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { HomeComponent } from './home/home.component';
+import { CounterComponent } from './counter/counter.component';
+import { LoginComponent } from './login/login.component';
+
+@NgModule({
+  imports: [
+    RouterModule.forRoot([
+      { path: '', component: HomeComponent, pathMatch: 'full' },
+      { path: 'counter', component: CounterComponent },
+      { path: 'login', component: LoginComponent }
+    ])
+  ]
+})
+export class AppModule {}
+`,
+      'src/Web/ClientApp/src/app/home/home.component.ts': ngComponent('HomeComponent', 'app-home', './home.component.html'),
+      'src/Web/ClientApp/src/app/home/home.component.html': '<h1>Hello, world!</h1>\n',
+      'src/Web/ClientApp/src/app/login/login.component.ts': ngComponent('LoginComponent', 'app-login', './login.component.html'),
+      'src/Web/ClientApp/src/app/login/login.component.html': '<h1>Log in</h1>\n',
+      'src/Web/ClientApp/src/app/counter/counter.component.ts': ngComponent(
+        'CounterComponent',
+        'app-counter-component',
+        './counter.component.html',
+        '  public currentCount = 0;\n\n  public incrementCounter() {\n    this.currentCount++;\n  }'
+      ),
+      'src/Web/ClientApp/src/app/counter/counter.component.html': '<p>Current count: {{ currentCount }}</p>\n<button (click)="incrementCounter()">Increment</button>\n',
+      'src/Web/ClientApp/src/app/nav-menu/nav-menu.component.ts': ngComponent(
+        'NavMenuComponent',
+        'app-nav-menu',
+        './nav-menu.component.html',
+        "  constructor(private router: Router) {}\n\n  logout(): void {\n    this.router.navigate(['/login']);\n  }",
+        "import { Router } from '@angular/router';"
+      ),
+      'src/Web/ClientApp/src/app/nav-menu/nav-menu.component.html': `<a [routerLink]="['/counter']">Counter</a>
+<a href="#" (click)="logout()">Log out</a>
+`,
+      'src/Web/ClientApp-React/package.json': JSON.stringify({ dependencies: { react: '^19.1.0', 'react-dom': '^19.1.0', 'react-router-dom': '^7.6.1' } }),
+      'src/Web/ClientApp-React/src/App.jsx': `import { Routes, Route } from 'react-router-dom';
+import { Home } from './components/Home';
+import { Counter } from './components/Counter';
+import { LoginPage } from './components/LoginPage';
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/" element={<Home />} />
+      <Route path="/counter" element={<Counter />} />
+      <Route path="/login" element={<LoginPage />} />
+    </Routes>
+  );
+}
+`,
+      'src/Web/ClientApp-React/src/components/Home.jsx': 'export function Home() {\n  return <h1>Hello, world!</h1>;\n}\n',
+      'src/Web/ClientApp-React/src/components/Counter.jsx': 'export function Counter() {\n  return <h1>Counter</h1>;\n}\n',
+      'src/Web/ClientApp-React/src/components/LoginPage.jsx': 'export function LoginPage() {\n  return <h1>Log in</h1>;\n}\n',
+      'src/Web/ClientApp-React/src/components/NavMenu.jsx': `import { Link, useNavigate } from 'react-router-dom';
+
+export function NavMenu() {
+  const navigate = useNavigate();
+  const handleLogout = (e) => {
+    e.preventDefault();
+    navigate('/login');
+  };
+  return (
+    <nav>
+      <Link to="/counter">Counter</Link>
+      <a href="#" onClick={handleLogout}>Log out</a>
+    </nav>
+  );
+}
+`,
+    };
+    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 });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const routesUnder = (dir: string) => cg.getNodesByKind('route').filter((r) => r.filePath.startsWith(dir));
+  const navigations = (dir: string) =>
+    routesUnder(dir)
+      .flatMap((r) =>
+        cg.getIncomingEdgesTo([r.id], ['navigates']).map((e) => `${cg.getNode(e.source)?.name} -> ${r.name} (${(e.metadata as Record<string, unknown>).navMethod})`)
+      )
+      .sort();
+
+  it('detects the frameworks the nested manifests declare', () => {
+    expect(cg.getDetectedFrameworks()).toEqual(expect.arrayContaining(['angular-router', 'react-router']));
+  });
+
+  it("reads the Angular app's routes, bound to their components", () => {
+    const routes = routesUnder('src/Web/ClientApp/')
+      .map((r) => `${r.name} -> ${cg.getOutgoingEdgesFrom([r.id], ['references']).map((e) => cg.getNode(e.target)?.name).join(', ')}`)
+      .sort();
+    expect(routes).toEqual(['/ -> HomeComponent', '/counter -> CounterComponent', '/login -> LoginComponent']);
+  });
+
+  it("draws the Angular app's navigation from routerLink and router.navigate", () => {
+    expect(navigations('src/Web/ClientApp/')).toEqual(['NavMenuComponent -> /counter (routerLink)', 'logout -> /login (navigate)']);
+  });
+
+  it("links a template's event binding to its handler, so the handler is not dead code", () => {
+    const counter = cg.getNodesByKind('class').find((c) => c.name === 'CounterComponent')!;
+    const handlers = cg
+      .getOutgoingEdgesFrom([counter.id], ['calls'])
+      .filter((e) => (e.metadata as Record<string, unknown> | undefined)?.synthesizedBy === 'angular-event')
+      .map((e) => cg.getNode(e.target)?.name);
+    expect(handlers).toEqual(['incrementCounter']);
+    const dead = buildDeadCodeReport(cg, { limit: 1000 }).entries.map((e) => e.node.name);
+    expect(dead).not.toContain('incrementCounter');
+    expect(dead).not.toContain('logout');
+  });
+
+  it("resolves the React twin's navigate() as well as its <Link to>", () => {
+    expect(navigations('src/Web/ClientApp-React/')).toEqual(['NavMenu -> /counter (link)', 'handleLogout -> /login (navigate)']);
+  });
+});
diff --git a/__tests__/parse-pool.test.ts b/__tests__/parse-pool.test.ts
index 6211481a44..ac51b984b5 100644
--- a/__tests__/parse-pool.test.ts
+++ b/__tests__/parse-pool.test.ts
@@ -248,3 +248,82 @@ describe('ParseWorkerPool', () => {
     await expect(pool.requestParse(task('y.ts'))).rejects.toThrow(/destroyed/);
   });
 });
+
+/**
+ * A fake whose grammar load takes `loadMs` (or never finishes, with `null`), and
+ * which records when it finished loading and when it was terminated.
+ */
+class SlowLoadWorker implements ParsePoolWorker {
+  private msgCb?: (m: unknown) => void;
+  private exitCb?: (code: number) => void;
+  loadedAt: number | null = null;
+  terminatedAt: number | null = null;
+  constructor(private loadMs: number | null) {}
+  on(event: string, cb: (...args: any[]) => void): void {
+    if (event === 'message') this.msgCb = cb;
+    else if (event === 'exit') this.exitCb = cb;
+  }
+  postMessage(msg: unknown): void {
+    if ((msg as { type: string }).type !== 'load-grammars' || this.loadMs === null) return;
+    setTimeout(() => {
+      if (this.terminatedAt !== null) return;
+      this.loadedAt = performance.now();
+      this.msgCb?.({ type: 'grammars-loaded' });
+    }, this.loadMs);
+  }
+  exit(code: number): void { this.exitCb?.(code); }
+  terminate(): Promise<number> { this.terminatedAt = performance.now(); return Promise.resolve(0); }
+}
+
+describe('teardown never terminates a worker mid-load', () => {
+  // Terminating a worker whose grammar WASM is still compiling can crash the
+  // process with an access violation (0xC0000005) on Windows; a pool torn down
+  // right after a short index often has a late-spawned worker in that state.
+  const poolOf = (worker: SlowLoadWorker, loadSettleMs?: number) =>
+    new ParseWorkerPool({ languages: ['typescript'] as Language[], size: 1, createWorker: () => worker, loadSettleMs });
+
+  it('waits for a loading worker to finish before terminating it', async () => {
+    const w = new SlowLoadWorker(120);
+    const pool = poolOf(w);
+    await pool.destroy();
+    expect(w.loadedAt).not.toBeNull();
+    expect(w.terminatedAt).not.toBeNull();
+    expect(w.terminatedAt!).toBeGreaterThanOrEqual(w.loadedAt!);
+  });
+
+  it('terminates a worker that is already loaded right away', async () => {
+    const w = new SlowLoadWorker(0);
+    const pool = poolOf(w);
+    await sleep(20);
+    expect(w.loadedAt).not.toBeNull();
+    const t0 = performance.now();
+    await pool.destroy();
+    expect(w.terminatedAt! - t0).toBeLessThan(50);
+  });
+
+  it('does not wait past the cap on a load that never finishes', async () => {
+    const w = new SlowLoadWorker(null);
+    const pool = poolOf(w, 80);
+    const t0 = performance.now();
+    await pool.destroy();
+    expect(w.terminatedAt).not.toBeNull();
+    expect(w.terminatedAt! - t0).toBeGreaterThanOrEqual(70);
+    expect(w.terminatedAt! - t0).toBeLessThan(1000);
+  });
+
+  it('does not wait on a worker that died while loading', async () => {
+    const w = new SlowLoadWorker(null);
+    // The pool respawns a crashed worker; the replacement loads normally. The
+    // default 15s cap stays, so waiting on the dead one would time the test out.
+    const workers = [w];
+    const pool = new ParseWorkerPool({
+      languages: ['typescript'] as Language[], size: 1,
+      createWorker: () => workers.shift() ?? new SlowLoadWorker(0),
+    });
+    w.exit(1);
+    await sleep(20);
+    const t0 = performance.now();
+    await pool.destroy();
+    expect(performance.now() - t0).toBeLessThan(200);
+  });
+});
diff --git a/__tests__/pascal-inc-detection.test.ts b/__tests__/pascal-inc-detection.test.ts
new file mode 100644
index 0000000000..0d4708bc7b
--- /dev/null
+++ b/__tests__/pascal-inc-detection.test.ts
@@ -0,0 +1,215 @@
+/**
+ * `.inc` is both PHP's include extension and Pascal/Delphi's (#2279).
+ *
+ * The extension map routes `.inc` to PHP (Drupal), so a Delphi include — a
+ * `{$IFDEF}`/`{$DEFINE}` block or a declaration fragment pulled in with
+ * `{$I defs.inc}` — was parsed as PHP and contributed nothing. Detection now
+ * reads the file: a PHP open tag keeps it PHP, Pascal-shaped content makes it
+ * Pascal, and anything else keeps the old PHP routing so C / assembly /
+ * template `.inc` files are not handed to the Pascal grammar. An explicit
+ * `codegraph.json` mapping for `.inc` still wins.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { CodeGraph } from '../src';
+import { detectLanguage } from '../src/extraction/grammars';
+import { preloadLanguagesForFiles } from '../src/extraction';
+import { clearProjectConfigCache } from '../src/project-config';
+
+const DIRECTIVES = [
+  '{ Compiler version switches }',
+  '{$IFDEF VER150}',
+  '  {$DEFINE DELPHI7}',
+  '{$ENDIF}',
+  '{$IFNDEF FPC}',
+  '  {$WARN SYMBOL_PLATFORM OFF}',
+  '{$ELSE}',
+  '  {$MODE DELPHI}{$H+}',
+  '{$ENDIF}',
+  '',
+].join('\n');
+
+const ROUTINES = [
+  'procedure Foo;',
+  'begin',
+  "  WriteLn('foo');",
+  'end;',
+  '',
+  'function Bar(A: Integer): Integer;',
+  'begin',
+  '  Result := A + 1;',
+  'end;',
+  '',
+].join('\n');
+
+describe('.inc language detection (#2279)', () => {
+  describe('detectLanguage', () => {
+    it('reads a directive-only include as Pascal', () => {
+      expect(detectLanguage('src/defs.inc', DIRECTIVES)).toBe('pascal');
+      expect(detectLanguage('src/defs.inc', '{$I other.inc}\n')).toBe('pascal');
+      expect(detectLanguage('src/defs.inc', '{$R-}\n{$Q-}\n')).toBe('pascal');
+      expect(detectLanguage('src/DEFS.INC', '{$define FOO}\n')).toBe('pascal');
+      // Lazarus opens its includes with an IDE marker naming the owning unit.
+      expect(detectLanguage('lcl/include/control.inc', '{%MainUnit ../controls.pp}\n{ comment }\n')).toBe('pascal');
+    });
+
+    it('skips a leading UTF-8 BOM and CRLF line endings', () => {
+      expect(detectLanguage('defs.inc', '\uFEFF{$IFDEF WIN32}\r\n{$DEFINE X}\r\n{$ENDIF}\r\n')).toBe('pascal');
+      expect(detectLanguage('defs.inc', '\uFEFFprocedure Foo;\r\n')).toBe('pascal');
+    });
+
+    it('reads a declaration fragment as Pascal', () => {
+      expect(detectLanguage('r.inc', ROUTINES)).toBe('pascal');
+      expect(detectLanguage('r.inc', 'procedure Foo;\nfunction Bar(A: Integer): Integer;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'procedure TForm1.Button1Click(Sender: TObject);\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'const\n  X = 1;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'const // ids\n{ Internal functions }\n   fpc_in_lo = 1;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'const Max: Integer = 10;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'type\n  TColor = (Red, Green);\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'type TFoo = class(TObject)\nend;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'var\n  G, H: Integer;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'uses\n  SysUtils, Classes;\n')).toBe('pascal');
+      expect(detectLanguage('r.inc', 'unit Foo;\ninterface\nimplementation\nend.\n')).toBe('pascal');
+    });
+
+    it('keeps an include with a PHP open tag as PHP', () => {
+      expect(detectLanguage('page.inc', '<?php\nfunction mymodule_help() {}\n')).toBe('php');
+      expect(detectLanguage('page.inc', '\uFEFF  <?PHP\nfunction a() {}\n')).toBe('php');
+      expect(detectLanguage('page.inc', '<div><?= $title ?></div>\n')).toBe('php');
+      // A tag anywhere wins over Pascal-looking text elsewhere in the file.
+      expect(detectLanguage('page.inc', '<p>\nprocedure Foo;\n</p>\n<?php echo 1; ?>\n')).toBe('php');
+    });
+
+    it('leaves non-Pascal, untagged includes on the PHP mapping', () => {
+      // C / C++ preprocessor and X-macro tables.
+      expect(detectLanguage('tbl.inc', '#define X 1\n#define Y 2\nconst int z = 3;\n')).toBe('php');
+      expect(detectLanguage('tbl.inc', 'OPCODE(ADD, 0x01)\nOPCODE(SUB, 0x02)\n')).toBe('php');
+      // C++ out-of-line static member definition.
+      expect(detectLanguage('Path.inc', 'const file_t::value_type file_t::Invalid = nullptr;\n')).toBe('php');
+      // SourcePawn typeset members: `function <return type> (<params>);`.
+      expect(
+        detectLanguage('menus.inc', 'typeset MenuHandler\n{\n\tfunction int (Menu menu, MenuAction action);\n\tfunction void (Menu menu);\n};\n'),
+      ).toBe('php');
+      // NASM / MASM.
+      expect(detectLanguage('m.inc', '%define STACK 0x1000\n; comment\nfoo equ 1\nmov eax, 1\n')).toBe('php');
+      // POV-Ray.
+      expect(detectLanguage('s.inc', '#declare R = 1;\n#macro M(a)\n#end\n')).toBe('php');
+      // Classic ASP / VBScript server-side include.
+      expect(detectLanguage('a.inc', 'Const X = 1\nFunction Foo(a)\n  Foo = a\nEnd Function\n')).toBe('php');
+      // Makefile include.
+      expect(detectLanguage('config.inc', 'CC := gcc\nCFLAGS := -O2\n')).toBe('php');
+      // HTML fragment with inline script, and a Smarty-style `{$var}` line.
+      expect(
+        detectLanguage('f.inc', '<script>\n  const x = 1;\n  var y = 2;\n  function go() { return x; }\n</script>\n{$title}\n'),
+      ).toBe('php');
+      // Prose that happens to put Pascal keywords on their own lines.
+      expect(detectLanguage('f.inc', '<li>\n  Implementation\n</li>\n<li>\n  Begin\n</li>\n')).toBe('php');
+    });
+
+    it('keeps the path-only answer (no source) on PHP', () => {
+      expect(detectLanguage('defs.inc')).toBe('php');
+      expect(detectLanguage('defs.inc', '')).toBe('php');
+    });
+
+    it('lets an explicit codegraph.json mapping for .inc win', () => {
+      expect(detectLanguage('defs.inc', DIRECTIVES, { '.inc': 'php' })).toBe('php');
+      expect(detectLanguage('defs.inc', '#define X 1\n', { '.inc': 'cpp' })).toBe('cpp');
+      expect(detectLanguage('page.inc', '<?php echo 1;', { '.inc': 'pascal' })).toBe('pascal');
+    });
+  });
+
+  describe('grammar preload set', () => {
+    it('loads the Pascal grammar when an .inc file is in the set', () => {
+      expect(preloadLanguagesForFiles(['defs.inc'])).toEqual(expect.arrayContaining(['php', 'pascal']));
+    });
+
+    it('adds nothing for a PHP project without .inc files, or when .inc is mapped explicitly', () => {
+      expect(preloadLanguagesForFiles(['index.php', 'a.module'])).not.toContain('pascal');
+      expect(preloadLanguagesForFiles(['defs.inc'], { '.inc': 'php' })).not.toContain('pascal');
+    });
+  });
+
+  describe('index and sync', () => {
+    let dir: string;
+    beforeEach(() => {
+      dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-pascal-inc-'));
+      clearProjectConfigCache();
+    });
+    afterEach(() => {
+      clearProjectConfigCache();
+      fs.rmSync(dir, { recursive: true, force: true });
+    });
+    const write = (rel: string, body: string) => {
+      const p = path.join(dir, rel);
+      fs.mkdirSync(path.dirname(p), { recursive: true });
+      fs.writeFileSync(p, body);
+    };
+    const languageOf = (cg: CodeGraph, rel: string) => cg.getFiles().find((f) => f.path === rel)?.language;
+    const symbolsIn = (cg: CodeGraph, rel: string) =>
+      cg.getNodesInFile(rel).filter((n) => n.kind !== 'file').map((n) => `${n.kind}:${n.name}:${n.language}`).sort();
+
+    // Runs first, before anything in this file has loaded the Pascal grammar
+    // through a `.pas` file: an include-only tree must still get a parser.
+    it('indexes a tree of Pascal includes with no .pas file', async () => {
+      write('inc/defs.inc', DIRECTIVES);
+      write('inc/routines.inc', ROUTINES);
+      const cg = await CodeGraph.init(dir, { index: true });
+      try {
+        expect(languageOf(cg, 'inc/defs.inc')).toBe('pascal');
+        expect(languageOf(cg, 'inc/routines.inc')).toBe('pascal');
+        expect(symbolsIn(cg, 'inc/routines.inc')).toEqual(['function:Bar:pascal', 'function:Foo:pascal']);
+        expect(cg.getFiles().find((f) => f.path === 'inc/routines.inc')?.errors ?? []).toEqual([]);
+      } finally {
+        cg.close();
+      }
+    });
+
+    it('classifies each include by content, and sync keeps the language', async () => {
+      write('U.pas', 'unit U;\n\ninterface\n\n{$I defs.inc}\n\nprocedure Foo;\n\nimplementation\n\n{$I routines.inc}\n\nend.\n');
+      write('defs.inc', DIRECTIVES);
+      write('routines.inc', ROUTINES);
+      write('drupal/mymodule.inc', '<?php\n\nfunction mymodule_helper() {\n  return 1;\n}\n');
+      write('native/table.inc', '#define X 1\n#define Y 2\n');
+      const cg = await CodeGraph.init(dir, { index: true });
+      try {
+        expect(languageOf(cg, 'defs.inc')).toBe('pascal');
+        expect(languageOf(cg, 'routines.inc')).toBe('pascal');
+        expect(languageOf(cg, 'drupal/mymodule.inc')).toBe('php');
+        expect(languageOf(cg, 'native/table.inc')).toBe('php');
+
+        // A directive-only fragment: a file record, no symbols, no errors.
+        expect(symbolsIn(cg, 'defs.inc')).toEqual([]);
+        expect(cg.getFiles().find((f) => f.path === 'defs.inc')?.errors ?? []).toEqual([]);
+        expect(symbolsIn(cg, 'routines.inc')).toEqual(['function:Bar:pascal', 'function:Foo:pascal']);
+        expect(symbolsIn(cg, 'drupal/mymodule.inc')).toEqual(['function:mymodule_helper:php']);
+
+        write('defs.inc', DIRECTIVES + '{$DEFINE USE_FAST_MM}\n');
+        write('routines.inc', ROUTINES + 'procedure Baz;\nbegin\nend;\n');
+        await cg.sync();
+
+        expect(languageOf(cg, 'defs.inc')).toBe('pascal');
+        expect(languageOf(cg, 'routines.inc')).toBe('pascal');
+        expect(symbolsIn(cg, 'routines.inc')).toEqual(['function:Bar:pascal', 'function:Baz:pascal', 'function:Foo:pascal']);
+        expect(languageOf(cg, 'drupal/mymodule.inc')).toBe('php');
+      } finally {
+        cg.close();
+      }
+    });
+
+    it('honors a codegraph.json .inc mapping through index and sync', async () => {
+      write('codegraph.json', JSON.stringify({ extensions: { '.inc': 'php' } }));
+      write('defs.inc', DIRECTIVES);
+      const cg = await CodeGraph.init(dir, { index: true });
+      try {
+        expect(languageOf(cg, 'defs.inc')).toBe('php');
+        write('defs.inc', DIRECTIVES + '{$DEFINE MORE}\n');
+        await cg.sync();
+        expect(languageOf(cg, 'defs.inc')).toBe('php');
+      } finally {
+        cg.close();
+      }
+    });
+  });
+});
diff --git a/__tests__/php-namespace-alias-instantiation.test.ts b/__tests__/php-namespace-alias-instantiation.test.ts
new file mode 100644
index 0000000000..103235c739
--- /dev/null
+++ b/__tests__/php-namespace-alias-instantiation.test.ts
@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { CodeGraph } from '../src';
+
+/**
+ * `use App\Fields as Alias;` aliases a namespace, so `new Alias\X()` names
+ * `App\Fields\X`. The alias is the first segment of the qualified name and
+ * has to be expanded through the file's `use` map before the class lookup.
+ */
+describe('PHP instantiation through a namespace alias', () => {
+  let dir: string;
+  let cg: CodeGraph | undefined;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'php-ns-alias-'));
+  });
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (file: string, source: string) => {
+    const target = path.join(dir, file);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, source);
+  };
+
+  const firstName = (ns: string) => `<?php
+namespace ${ns};
+
+class FirstName
+{
+    public function label(): string { return 'First name'; }
+}
+`;
+
+  const consumer = (use: string, expr: string) => `<?php
+namespace App\\Blocks\\Personal;
+
+${use}
+
+class Personal
+{
+    public function fields(): array
+    {
+        return [${expr}];
+    }
+}
+`;
+
+  /** `instantiates` targets of the `fields` method, as `<qualifiedName>`. */
+  const instantiated = async (): Promise<string[]> => {
+    cg = await CodeGraph.init(dir, { silent: true });
+    await cg.indexAll();
+    const fields = cg.searchNodes('fields')
+      .map(({ node }) => node)
+      .find((n) => n.kind === 'method' && n.filePath === 'app/Blocks/Personal/Personal.php')!;
+    expect(fields).toBeDefined();
+    const db = (cg as any).db.db;
+    const rows: { qn: string }[] = db
+      .prepare(
+        `SELECT t.qualified_name qn FROM edges e JOIN nodes t ON t.id = e.target
+         WHERE e.source = ? AND e.kind = 'instantiates'`,
+      )
+      .all(fields.id);
+    return rows.map((r) => r.qn).sort();
+  };
+
+  it('resolves `new Alias\\X()` when Alias is an imported namespace', async () => {
+    write('app/Blocks/Personal/Fields/FirstName.php', firstName('App\\Blocks\\Personal\\Fields'));
+    write('app/Blocks/Personal/Personal.php',
+      consumer('use App\\Blocks\\Personal\\Fields as Field;', 'new Field\\FirstName()'));
+    expect(await instantiated()).toEqual(['App\\Blocks\\Personal\\Fields::FirstName']);
+  });
+
+  it('picks the class in the aliased namespace over a same-named class elsewhere', async () => {
+    write('app/Blocks/Personal/Fields/FirstName.php', firstName('App\\Blocks\\Personal\\Fields'));
+    write('app/Blocks/Other/FirstName.php', firstName('App\\Blocks\\Other'));
+    write('app/Blocks/Personal/Personal.php',
+      consumer('use App\\Blocks\\Personal\\Fields as Field;', 'new Field\\FirstName()'));
+    expect(await instantiated()).toEqual(['App\\Blocks\\Personal\\Fields::FirstName']);
+  });
+
+  it('expands the alias for a deeper qualified name', async () => {
+    write('app/Blocks/Personal/Fields/Text/FirstName.php', firstName('App\\Blocks\\Personal\\Fields\\Text'));
+    write('app/Blocks/Personal/Personal.php',
+      consumer('use App\\Blocks\\Personal\\Fields as Field;', 'new Field\\Text\\FirstName()'));
+    expect(await instantiated()).toEqual(['App\\Blocks\\Personal\\Fields\\Text::FirstName']);
+  });
+
+  it('leaves a qualified name whose first segment is not imported alone', async () => {
+    write('app/Blocks/Personal/Fields/FirstName.php', firstName('App\\Blocks\\Personal\\Fields'));
+    write('app/Blocks/Personal/Personal.php',
+      consumer('use App\\Blocks\\Personal\\Fields as Field;', 'new Elsewhere\\FirstName()'));
+    expect(await instantiated()).toEqual([]);
+  });
+
+  /** Non-`contains` edges out of a file, as `<source> <kind> <target qualifiedName>`. */
+  const edgesFrom = async (file: string): Promise<string[]> => {
+    cg = await CodeGraph.init(dir, { silent: true });
+    await cg.indexAll();
+    const db = (cg as any).db.db;
+    const rows: { s: string; k: string; t: string }[] = db
+      .prepare(
+        `SELECT s.name s, e.kind k, t.qualified_name t FROM edges e
+         JOIN nodes s ON s.id = e.source JOIN nodes t ON t.id = e.target
+         WHERE s.file_path = ? AND e.kind NOT IN ('contains', 'imports')`,
+      )
+      .all(file);
+    return rows.map((r) => `${r.s} ${r.k} ${r.t}`).sort();
+  };
+
+  const fields = `<?php
+namespace App\\Fields;
+
+interface Field {}
+class Base {}
+class FirstName extends Base implements Field
+{
+    public static function make(): self { return new self(); }
+}
+`;
+
+  it('resolves extends, implements and static calls written through a namespace alias', async () => {
+    write('app/Fields/FirstName.php', fields);
+    write('app/Personal.php', `<?php
+namespace App;
+
+use App\\Fields as F;
+
+class Personal extends F\\Base implements F\\Field
+{
+    public function make() { return F\\FirstName::make(); }
+}
+`);
+    expect(await edgesFrom('app/Personal.php')).toEqual([
+      'Personal extends App\\Fields::Base',
+      'Personal implements App\\Fields::Field',
+      'make calls App\\Fields::FirstName::make',
+    ]);
+  });
+
+  it('reads a qualified name without an imported first segment relative to the current namespace', async () => {
+    write('app/Fields/FirstName.php', fields);
+    write('app/Personal.php', `<?php
+namespace App;
+
+class Personal extends Fields\\Base
+{
+    public function a() { return new Fields\\FirstName(); }
+}
+`);
+    expect(await edgesFrom('app/Personal.php')).toEqual([
+      'Personal extends App\\Fields::Base',
+      'a instantiates App\\Fields::FirstName',
+    ]);
+  });
+
+  it('reads a leading backslash as a fully qualified name', async () => {
+    write('app/Fields/FirstName.php', fields);
+    write('app/Other/FirstName.php', firstName('App\\Other'));
+    write('app/Personal.php', `<?php
+namespace App\\Other;
+
+class Personal extends \\App\\Fields\\Base
+{
+    public function a() { return new \\App\\Fields\\FirstName(); }
+    public function b() { return \\App\\Fields\\FirstName::make(); }
+}
+`);
+    expect(await edgesFrom('app/Personal.php')).toEqual([
+      'Personal extends App\\Fields::Base',
+      'a instantiates App\\Fields::FirstName',
+      'b calls App\\Fields::FirstName::make',
+    ]);
+  });
+
+  it('does not bind a qualified name outside the project to a same-named project class', async () => {
+    write('app/Fields/FirstName.php', fields);
+    write('app/Personal.php', `<?php
+namespace App;
+
+use Vendor\\Lib as L;
+
+class Personal extends L\\Base
+{
+    public function a() { return new \\Vendor\\Lib\\FirstName(); }
+    public function b() { return L\\FirstName::make(); }
+}
+`);
+    expect(await edgesFrom('app/Personal.php')).toEqual([]);
+  });
+});
diff --git a/__tests__/php-namespace-class-visibility.test.ts b/__tests__/php-namespace-class-visibility.test.ts
new file mode 100644
index 0000000000..04a313abef
--- /dev/null
+++ b/__tests__/php-namespace-class-visibility.test.ts
@@ -0,0 +1,85 @@
+/**
+ * An unqualified PHP class name is the current namespace's class or the one
+ * a `use` imports — PHP never falls back to another namespace for classes.
+ * koel's `extends Request` (in `App\Http\Requests\API`, under `use
+ * App\Http\Requests\API\Request;`, or under `use Saloon\Http\Request;`) all
+ * went to the first `Request` indexed, and BookStack's controllers'
+ * `Request $request` (`use Illuminate\Http\Request;`) to its own subclass.
+ */
+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-php-ns-'));
+  const files: Record<string, string> = {
+    'app/Http/Requests/API/Interaction/Request.php': `<?php
+
+namespace App\\Http\\Requests\\API\\Interaction;
+
+abstract class Request {}
+`,
+    'app/Http/Requests/API/Request.php': `<?php
+
+namespace App\\Http\\Requests\\API;
+
+abstract class Request {}
+`,
+    'app/Http/Requests/API/DeleteSongsRequest.php': `<?php
+
+namespace App\\Http\\Requests\\API;
+
+class DeleteSongsRequest extends Request {}
+`,
+    'app/Http/Requests/API/Playlist/PlaylistSongUpdateRequest.php': `<?php
+
+namespace App\\Http\\Requests\\API\\Playlist;
+
+use App\\Http\\Requests\\API\\Request;
+
+class PlaylistSongUpdateRequest extends Request {}
+`,
+    'app/Http/Integrations/SearchRequest.php': `<?php
+
+namespace App\\Http\\Integrations;
+
+use Saloon\\Http\\Request;
+
+class SearchRequest extends Request {}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const supertypesOf = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'extends').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('bare PHP class names', () => {
+  it('are the namespace’s own class', () => {
+    expect(supertypesOf('app/Http/Requests/API/DeleteSongsRequest.php')).toEqual(['App\\Http\\Requests\\API::Request']);
+  });
+
+  it('or the one a use imports', () => {
+    expect(supertypesOf('app/Http/Requests/API/Playlist/PlaylistSongUpdateRequest.php')).toEqual(['App\\Http\\Requests\\API::Request']);
+  });
+
+  it('and nothing in the project when the import is a library’s', () => {
+    expect(supertypesOf('app/Http/Integrations/SearchRequest.php')).toEqual([]);
+  });
+});
diff --git a/__tests__/php-receiver-guess.test.ts b/__tests__/php-receiver-guess.test.ts
new file mode 100644
index 0000000000..11afdfbcc7
--- /dev/null
+++ b/__tests__/php-receiver-guess.test.ts
@@ -0,0 +1,89 @@
+/**
+ * A PHP call through a receiver nothing typed takes the one project method of
+ * that name only when the receiver is named after its class — or after a
+ * class that inherits it (`$page->save()` → Page extends Entity). Guzzle's
+ * tests' PSR-7 `$response->getHeaderLine()` went to a test double's method,
+ * symfony/console's `$e->getMessage()` to a progress bar's.
+ */
+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-php-receiver-'));
+  const files: Record<string, string> = {
+    'src/Models/Entity.php': `<?php
+namespace App\\Models;
+
+abstract class Entity
+{
+    public function save(): bool { return true; }
+}
+`,
+    'src/Models/Page.php': `<?php
+namespace App\\Models;
+
+class Page extends Entity
+{
+}
+`,
+    'src/Helper/ProgressBar.php': `<?php
+namespace App\\Helper;
+
+class ProgressBar
+{
+    public function getMessage(): string { return ''; }
+}
+`,
+    'src/Uploads/UserAvatars.php': `<?php
+namespace App\\Uploads;
+
+class UserAvatars
+{
+    public function assignToUser($user): void {}
+}
+`,
+    'src/Controller.php': `<?php
+namespace App;
+
+function handle($page, $avatars, $user)
+{
+    try {
+        $page->save();
+        $avatars->assignToUser($user);
+    } catch (\\Exception $e) {
+        return $e->getMessage();
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('PHP calls through an untyped receiver', () => {
+  it('keep a receiver named after the class or one that inherits the method; drop the rest', () => {
+    const ids = cg.getNodesInFile('src/Controller.php').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName)
+      .sort();
+    expect(targets).toContain('App\\Models::Entity::save');
+    expect(targets).toContain('App\\Uploads::UserAvatars::assignToUser');
+    expect(targets).not.toContain('App\\Helper::ProgressBar::getMessage');
+  });
+});
diff --git a/__tests__/php-this-hierarchy.test.ts b/__tests__/php-this-hierarchy.test.ts
new file mode 100644
index 0000000000..45068e2a38
--- /dev/null
+++ b/__tests__/php-this-hierarchy.test.ts
@@ -0,0 +1,149 @@
+/**
+ * `$this->m()`, `self::m()`, `static::m()` and `parent::m()` name a method of
+ * the class the call is written in, a class it extends, or a trait any of them
+ * uses — never another class's method that shares the name.
+ *
+ * Drupal core's tests call PHPUnit's `$this->assertEquals()` (a vendor base
+ * class), which went to the one in-repo `assertEquals`, a comparator's, 8,832
+ * times; `$this->t()` from StringTranslationTrait went to `Views::t`.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+describe('PHP calls on $this, self and parent', () => {
+  it('reach the class hierarchy and its traits, and nothing outside it', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-php-this-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'core/lib/StringTranslationTrait.php': `<?php
+namespace Drupal\\Core\\StringTranslation;
+trait StringTranslationTrait {
+  protected function t($string) { return $string; }
+}
+`,
+      'core/lib/Views.php': `<?php
+namespace Drupal\\views;
+class Views {
+  public static function t($s) { return $s; }
+}
+`,
+      'core/lib/MarkupComparator.php': `<?php
+namespace Drupal\\TestTools\\Comparator;
+class MarkupInterfaceComparator {
+  public function assertEquals($expected, $actual) {}
+}
+`,
+      'core/lib/FormBase.php': `<?php
+namespace Drupal\\Core\\Form;
+use Drupal\\Core\\StringTranslation\\StringTranslationTrait;
+abstract class FormBase {
+  use StringTranslationTrait;
+  public function setUp() {}
+  protected function helper() {}
+}
+`,
+      'core/modules/my/MyForm.php': `<?php
+namespace Drupal\\my\\Form;
+use Drupal\\Core\\Form\\FormBase;
+class MyForm extends FormBase {
+  public function setUp() {
+    parent::setUp();
+    $this->helper();
+    return $this->t('Hi');
+  }
+}
+`,
+      'core/tests/NodeTest.php': `<?php
+namespace Drupal\\Tests\\node;
+use PHPUnit\\Framework\\TestCase;
+class NodeTest extends TestCase {
+  public function testTitle() {
+    $this->assertEquals(1, 1);
+  }
+}
+`,
+      // Laravel's own tests extend Orchestra's TestCase, which isn't in the
+      // repository but composes the repository's testing traits.
+      'src/Testing/InteractsWithTime.php': `<?php
+namespace Illuminate\\Foundation\\Testing\\Concerns;
+trait InteractsWithTime {
+  public function travelTo($date) {}
+}
+`,
+      // Inside a trait, \$this is the class that uses it.
+      'src/Validation/ValidatesAttributes.php': `<?php
+namespace Illuminate\\Validation\\Concerns;
+trait ValidatesAttributes {
+  public function validateSame($attribute) { return $this->getValue($attribute); }
+}
+`,
+      'src/Validation/Validator.php': `<?php
+namespace Illuminate\\Validation;
+use Illuminate\\Validation\\Concerns\\ValidatesAttributes;
+class Validator {
+  use ValidatesAttributes;
+  public function getValue($attribute) { return null; }
+}
+`,
+      // A base class calling what its subclass defines.
+      'app/Entity.php': `<?php
+namespace BookStack\\Entities;
+abstract class Entity {
+  public function parentBook() { return $this->book(); }
+}
+`,
+      'app/Page.php': `<?php
+namespace BookStack\\Entities;
+class Page extends Entity {
+  public function book() { return null; }
+}
+`,
+      'tests/QueueTest.php': `<?php
+namespace Illuminate\\Tests\\Integration;
+use Orchestra\\Testbench\\TestCase;
+class QueueTest extends TestCase {
+  public function testDelay() {
+    $this->travelTo('2000-01-02');
+  }
+}
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const callees = (file: string, method: string) => {
+        const from = cg.getNodesInFile(file).find((n) => n.kind === 'method' && n.name === method)!;
+        return cg
+          .getOutgoingEdges(from.id)
+          .filter((e) => e.kind === 'calls')
+          .map((e) => cg.getNode(e.target)!.qualifiedName)
+          .sort();
+      };
+      expect(callees('core/modules/my/MyForm.php', 'setUp')).toEqual([
+        'Drupal\\Core\\Form::FormBase::helper',
+        'Drupal\\Core\\Form::FormBase::setUp',
+        'Drupal\\Core\\StringTranslation::StringTranslationTrait::t',
+      ]);
+      // PHPUnit's TestCase is not in the repository, and a comparator's
+      // `assertEquals` is no method of it.
+      expect(callees('core/tests/NodeTest.php', 'testTitle')).toEqual([]);
+      expect(callees('src/Validation/ValidatesAttributes.php', 'validateSame')).toEqual(['Illuminate\\Validation::Validator::getValue']);
+      expect(callees('app/Entity.php', 'parentBook')).toEqual(['BookStack\\Entities::Page::book']);
+      // Past an ancestor this cannot see, the repository's traits still count.
+      expect(callees('tests/QueueTest.php', 'testDelay')).toEqual(['Illuminate\\Foundation\\Testing\\Concerns::InteractsWithTime::travelTo']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/play-nested-projects.test.ts b/__tests__/play-nested-projects.test.ts
new file mode 100644
index 0000000000..688c6c8f04
--- /dev/null
+++ b/__tests__/play-nested-projects.test.ts
@@ -0,0 +1,52 @@
+/**
+ * A repository of Play projects — playframework/play-samples keeps each one's
+ * `conf/routes` in its own directory, with no build at the root — still reads
+ * as Play: it had no routes at all.
+ */
+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-play-nested-'));
+  const files: Record<string, string> = {
+    'play-java-hello/conf/routes': `GET     /                controllers.HomeController.index()
+GET     /count           controllers.CountController.count()
+`,
+    'play-java-hello/app/controllers/HomeController.java': `package controllers;
+public class HomeController {
+    public Result index() { return null; }
+}
+`,
+    'play-java-hello/app/controllers/CountController.java': `package controllers;
+public class CountController {
+    public Result count() { return null; }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Play projects in subdirectories', () => {
+  it('have their routes, linked to the actions', () => {
+    const routes = cg.getNodesByKind('route');
+    expect(routes.map((r) => r.name).sort()).toEqual(['GET /', 'GET /count']);
+    const count = routes.find((r) => r.name === 'GET /count')!;
+    const target = cg.getOutgoingEdges(count.id).map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(target.some((t) => t.endsWith('CountController::count'))).toBe(true);
+  });
+});
diff --git a/__tests__/prod-to-test-suite.test.ts b/__tests__/prod-to-test-suite.test.ts
new file mode 100644
index 0000000000..71669a0867
--- /dev/null
+++ b/__tests__/prod-to-test-suite.test.ts
@@ -0,0 +1,86 @@
+/**
+ * A test suite is not linked into the program, so production code never
+ * means one of its symbols by name: typeorm's `Record<string, …>` bound to a
+ * test entity `Record`, okhttp's samples' `@Override` to a test's nested
+ * `Override`. Test-support code a project ships (`testing/`) stays in reach,
+ * and a test still reaches another test's helpers.
+ */
+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-prod-test-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'orm', private: true }),
+    'test/functional/entity/Record.ts': `export class Record {
+  id = 0;
+}
+`,
+    'test/functional/helpers.ts': `export function makeFixture(): number {
+  return 1;
+}
+`,
+    'test/functional/record.test.ts': `export function uses(): number {
+  return makeFixture();
+}
+`,
+    'src/testing/stub.ts': `export function stubConnection(): number {
+  return 2;
+}
+`,
+    'src/columns.ts': `export function toJson(values: Record<string, number>): string {
+  return JSON.stringify(values);
+}
+
+export function connect(): number {
+  return stubConnection();
+}
+`,
+    'src/main/java/app/Service.java': `package app;
+
+public class Service implements Runnable {
+  @Override
+  public void run() { }
+}
+`,
+    'src/test/java/app/InterceptorTest.java': `package app;
+
+public class InterceptorTest {
+  @interface Override { }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.filePath);
+};
+
+describe('production code and test suites', () => {
+  it('production code never names a test suite’s symbol', () => {
+    expect(targetsFrom('src/columns.ts')).not.toContain('test/functional/entity/Record.ts');
+    expect(targetsFrom('src/main/java/app/Service.java')).not.toContain('src/test/java/app/InterceptorTest.java');
+  });
+
+  it('shipped test support stays in reach, and tests reach each other', () => {
+    expect(targetsFrom('src/columns.ts')).toContain('src/testing/stub.ts');
+    expect(targetsFrom('test/functional/record.test.ts')).toContain('test/functional/helpers.ts');
+  });
+});
diff --git a/__tests__/proxy-liveness-watchdog.test.ts b/__tests__/proxy-liveness-watchdog.test.ts
index 8e9094ba45..b09bf91c55 100644
--- a/__tests__/proxy-liveness-watchdog.test.ts
+++ b/__tests__/proxy-liveness-watchdog.test.ts
@@ -45,7 +45,11 @@ async function exercise(mode: 'connecting-wedge' | 'fallback-wedge' | 'slow-fall
           await delay(2500);
           return { content: [{ type: 'text', text: 'finished' }] };
         } }),
-        stop: () => {},
+        // Slow, like a stop waiting on a query worker still starting up: the
+        // proxy must not exit before it settles.
+        stop: () => mode === 'slow-fallback'
+          ? delay(300).then(() => { require('fs').writeSync(1, 'STOPPED\\n'); })
+          : undefined,
       }),
     });
   `], {
@@ -76,6 +80,7 @@ async function exercise(mode: 'connecting-wedge' | 'fallback-wedge' | 'slow-fall
       await until(exited);
       expect(child.exitCode, stderr).toBe(0);
       expect(child.signalCode).toBeNull();
+      expect(stdout, stderr).toContain('STOPPED');
     } else {
       await until(() => stdout.includes('WEDGED') || exited());
       expect(stdout, stderr).toContain('WEDGED');
diff --git a/__tests__/proxy-shutdown.test.ts b/__tests__/proxy-shutdown.test.ts
new file mode 100644
index 0000000000..052984594a
--- /dev/null
+++ b/__tests__/proxy-shutdown.test.ts
@@ -0,0 +1,172 @@
+/**
+ * The local-handshake proxy's shutdown waits for every in-process engine it
+ * owns, and starts nothing new once it is shutting down (#2311). An engine's
+ * stop can wait on a query worker still starting up — exiting before it
+ * settles is the Windows crash QueryPool.destroy avoids — and stopping is
+ * what releases the writer lock.
+ *
+ * Each case runs the real proxy entry point in a child process, with only the
+ * daemon and engine dependencies replaced. Engines print `ENGINE n` when made
+ * and `STOPPED n` once a deliberately slow stop settles.
+ */
+import { describe, it, expect } from 'vitest';
+import { spawn, type ChildProcess } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+const MODULE = path.resolve(__dirname, '../dist/mcp/proxy.js');
+const delay = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+async function until(check: () => boolean, what: string, timeout = 10_000): Promise<void> {
+  const deadline = Date.now() + timeout;
+  while (!check()) {
+    if (Date.now() > deadline) throw new Error(`Timed out waiting for ${what}`);
+    await delay(25);
+  }
+}
+
+const line = (msg: object): string => JSON.stringify({ jsonrpc: '2.0', ...msg }) + '\n';
+const INITIALIZE = line({ id: 1, method: 'initialize', params: {} });
+const toolCall = (id: number): string => line({ id, method: 'tools/call', params: { name: 'test', arguments: {} } });
+
+/** Shared by every scenario: the proxy, with markers on stdout. */
+const PRELUDE = `
+  const { runLocalHandshakeProxy } = require(${JSON.stringify(MODULE)});
+  const fs = require('fs');
+  const net = require('net');
+  const say = (s) => fs.writeSync(1, s + '\\n');
+  const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  let engines = 0;
+  const makeEngine = ({ readOnly, callMs, stopMs }) => () => {
+    const n = ++engines;
+    say('ENGINE ' + n);
+    return {
+      ensureInitialized: async () => {},
+      isReadOnly: () => { say('RETRY ' + n); return readOnly; },
+      getToolHandler: () => ({ execute: async () => {
+        await delay(n === 1 ? callMs : 0);
+        return { content: [{ type: 'text', text: 'finished ' + n }] };
+      } }),
+      stop: () => delay(stopMs).then(() => say('STOPPED ' + n)),
+    };
+  };
+`;
+
+interface Proxy {
+  child: ChildProcess;
+  out: () => string;
+  err: () => string;
+  exited: () => boolean;
+  write: (s: string) => void;
+  dispose: () => Promise<void>;
+}
+
+function startProxy(script: string, env: Record<string, string> = {}): Proxy {
+  const child = spawn(process.execPath, ['-e', PRELUDE + script], {
+    env: {
+      ...process.env,
+      CODEGRAPH_TELEMETRY: '0', DO_NOT_TRACK: '1', CODEGRAPH_NO_PROMPT_HOOK: '1',
+      CODEGRAPH_NO_WATCHDOG: '1', CODEGRAPH_PPID_POLL_MS: '0',
+      CODEGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS: '0',
+      CODEGRAPH_DAEMON_RETRY_MS: '200',
+      ...env,
+    },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  let stdout = '', stderr = '';
+  child.stdout!.on('data', (d) => { stdout += d; });
+  child.stderr!.on('data', (d) => { stderr += d; });
+  // On a proxy that has already exited, a write fails with EPIPE; the
+  // assertions say what went wrong, not an unhandled stream error.
+  child.stdin!.on('error', () => { /* proxy gone */ });
+  const exited = () => child.exitCode !== null || child.signalCode !== null;
+  return {
+    child,
+    out: () => stdout,
+    err: () => stderr,
+    exited,
+    write: (s) => { if (!exited()) child.stdin!.write(s); },
+    dispose: async () => {
+      if (!exited()) child.kill('SIGKILL');
+      await until(exited, 'the proxy to exit');
+      child.stdin!.destroy();
+    },
+  };
+}
+
+describe('local proxy shutdown (#2311)', () => {
+  it('waits for an engine being retired before it exits', async () => {
+    // A writing engine is retired so a daemon can take its lock: the retry
+    // hands it back once its call answers. stdin closes while the retirement is
+    // still waiting on that call, so `engine` is already null at shutdown.
+    const proxy = startProxy(`
+      runLocalHandshakeProxy({
+        root: process.cwd(),
+        getDaemonSocket: async () => null,
+        makeEngine: makeEngine({ readOnly: false, callMs: 10000, stopMs: 500 }),
+      });
+    `);
+    try {
+      proxy.write(INITIALIZE);
+      proxy.write(toolCall(2));
+      await until(() => proxy.out().includes('RETRY 1') || proxy.exited(), 'the retry to retire the engine');
+      expect(proxy.out(), proxy.err()).toContain('RETRY 1');
+      proxy.child.stdin!.end();
+      await until(proxy.exited, 'the proxy to exit');
+      expect(proxy.child.exitCode, proxy.err()).toBe(0);
+      expect(proxy.out(), proxy.err()).toContain('STOPPED 1');
+      expect(proxy.out()).not.toContain('finished 1');
+    } finally {
+      await proxy.dispose();
+    }
+  }, 20_000);
+
+  it('starts no engine for client input that arrives once shutdown has begun', async () => {
+    // A read-only engine is retired after the daemon comes back; the daemon
+    // then drops again, so calls are served in-process with no live engine.
+    // The host pid exiting starts shutdown while stdin is still open, and a
+    // call written then must not start an engine shutdown() never stops.
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-proxy-stop-'));
+    const sock = process.platform === 'win32'
+      ? `\\\\.\\pipe\\cg-proxy-stop-${process.pid}-${Date.now()}`
+      : path.join(dir, 'd.sock');
+    const host = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore' });
+    const hostGone = new Promise<void>((resolve) => host.once('exit', () => resolve()));
+    const proxy = startProxy(`
+      const conns = [];
+      const server = net.createServer((c) => { conns.push(c); c.on('data', () => {}); });
+      let gets = 0;
+      server.listen(${JSON.stringify(sock)}, () => runLocalHandshakeProxy({
+        root: process.cwd(),
+        getDaemonSocket: async () => {
+          if (++gets !== 2) return null;
+          const s = net.createConnection(${JSON.stringify(sock)});
+          await new Promise((resolve, reject) => { s.once('connect', resolve); s.once('error', reject); });
+          setTimeout(() => { for (const c of conns) c.destroy(); }, 100);
+          return s;
+        },
+        makeEngine: makeEngine({ readOnly: true, callMs: 10000, stopMs: 1500 }),
+      }));
+    `, { CODEGRAPH_PPID_POLL_MS: '50', CODEGRAPH_HOST_PPID: String(host.pid) });
+    try {
+      proxy.write(INITIALIZE);
+      proxy.write(toolCall(2));
+      await until(() => proxy.err().includes('Shared daemon connection lost') || proxy.exited(), 'the daemon to drop');
+      expect(proxy.out(), proxy.err()).toContain('ENGINE 1');
+      host.kill('SIGKILL');
+      await hostGone;
+      await until(() => proxy.err().includes('Parent process exited') || proxy.exited(), 'shutdown to begin');
+      proxy.write(toolCall(3));
+      await until(proxy.exited, 'the proxy to exit');
+      expect(proxy.child.exitCode, proxy.err()).toBe(0);
+      expect(proxy.out(), proxy.err()).toContain('STOPPED 1');
+      expect(proxy.out(), proxy.err()).not.toContain('ENGINE 2');
+      expect(proxy.out()).not.toContain('"id":3');
+    } finally {
+      if (host.exitCode === null && host.signalCode === null) host.kill('SIGKILL');
+      await proxy.dispose();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, 20_000);
+});
diff --git a/__tests__/pytest-fixture-receiver.test.ts b/__tests__/pytest-fixture-receiver.test.ts
new file mode 100644
index 0000000000..bb0c839ad8
--- /dev/null
+++ b/__tests__/pytest-fixture-receiver.test.ts
@@ -0,0 +1,81 @@
+/**
+ * A pytest test's parameter is what its fixture returns — `return Cls(…)`, or
+ * a local assigned `Cls(…)` — so a call on it is that class's method, and
+ * none of the project's when the class comes from outside: flask's
+ * `runner.invoke(cli, …)` on click's `CliRunner()` is not `FlaskCliRunner.invoke`.
+ * A fixture is in reach from its own module, a `conftest.py` above the test,
+ * or a module such a conftest star-imports or lists in `pytest_plugins`.
+ */
+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-pytest-fixture-'));
+  const files: Record<string, string> = {
+    'app/cli.py': `class AlembicGroup:
+    def invoke(self, ctx):
+        return ctx
+`,
+    'app/models.py': `class Forum:
+    def save(self):
+        return self
+`,
+    'tests/conftest.py': `from tests.fixtures.cli import *  # noqa
+from tests.fixtures.forum import *  # noqa
+`,
+    'tests/fixtures/cli.py': `import pytest
+from click.testing import CliRunner
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+`,
+    'tests/fixtures/forum.py': `import pytest
+from app.models import Forum
+
+
+@pytest.fixture
+def forum():
+    forum = Forum()
+    return forum
+`,
+    'tests/test_cli.py': `def test_routes(runner):
+    result = runner.invoke(cli, ["routes"])
+    return result
+
+
+def test_forum(forum):
+    forum.save()
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (qualifiedName: string) => {
+  const ids = cg.getNodesInFile('tests/test_cli.py').filter((n) => n.qualifiedName === qualifiedName).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('pytest fixture parameters', () => {
+  // Both fixtures live in modules `tests/conftest.py` star-imports.
+  it('are the class their fixture returns', () => {
+    expect(targetsFrom('test_routes')).not.toContain('app/cli.py:AlembicGroup::invoke');
+    expect(targetsFrom('test_forum')).toContain('app/models.py:Forum::save');
+  });
+});
diff --git a/__tests__/python-function-value-scope.test.ts b/__tests__/python-function-value-scope.test.ts
new file mode 100644
index 0000000000..d6152c78a0
--- /dev/null
+++ b/__tests__/python-function-value-scope.test.ts
@@ -0,0 +1,121 @@
+/**
+ * A name passed as a value means what is in scope where it is written. A
+ * function nested in another function is in scope only in there — httpx's
+ * `self._build_auth(auth)` passes its parameter, not the `auth` a test
+ * defines inside `test_custom_auth`. A Python name the function around it
+ * binds is that local's — `auth_flow(self, request)` handing `request` on is
+ * not the package's `request()`. And a pytest fixture is a test's parameter
+ * only in its own module or under its `conftest.py`.
+ */
+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-fnvalue-'));
+  const files: Record<string, string> = {
+    'httpx/_client.py': `class Client:
+    @property
+    def auth(self):
+        return self._auth
+
+    def _build_auth(self, auth):
+        return auth
+
+    def set_auth(self, auth):
+        self._auth = self._build_auth(auth)
+`,
+    'httpx/_api.py': `def request(method, url):
+    return method, url
+`,
+    'httpx/_auth.py': `class Auth:
+    def auth_flow(self, request):
+        yield request
+
+    def sync_auth_flow(self, request):
+        flow = self.auth_flow(request)
+        return flow
+
+
+class Recorder:
+    def request(self):
+        return None
+`,
+    'tests/test_auth.py': `def test_custom_auth():
+    def auth(request):
+        return request
+
+    return register(auth)
+
+
+def test_basic_auth():
+    auth = ("user", "pass")
+    return register(auth)
+`,
+    'docs/example/test_order.py': `import pytest
+
+
+@pytest.fixture
+def func():
+    return 1
+`,
+    'tests/test_coverage.py': `import pytest
+
+
+def _run_both(func):
+    return func()
+
+
+@pytest.fixture(
+    scope="module",
+)
+def recipe():
+    return {}
+
+
+def test_recipe(recipe):
+    return use(recipe)
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string, qualifiedName?: string) => {
+  const ids = cg.getNodesInFile(file).filter((n) => !qualifiedName || n.qualifiedName === qualifiedName).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references' || e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('Python names passed as values', () => {
+  it('never reach a function nested in another function', () => {
+    expect(targetsFrom('httpx/_client.py')).not.toContain('tests/test_auth.py:test_custom_auth::auth');
+    expect(targetsFrom('tests/test_auth.py', 'test_basic_auth')).not.toContain('tests/test_auth.py:test_custom_auth::auth');
+  });
+
+  it('reach a nested function from inside its container', () => {
+    expect(targetsFrom('tests/test_auth.py', 'test_custom_auth')).toContain('tests/test_auth.py:test_custom_auth::auth');
+  });
+
+  it('are the local a parameter binds', () => {
+    expect(targetsFrom('httpx/_auth.py')).not.toContain('httpx/_api.py:request');
+  });
+
+  it('reach a fixture only from its own module', () => {
+    expect(targetsFrom('tests/test_coverage.py', '_run_both')).not.toContain('docs/example/test_order.py:func');
+    expect(targetsFrom('tests/test_coverage.py', 'test_recipe')).toContain('tests/test_coverage.py:recipe');
+  });
+});
diff --git a/__tests__/python-local-binding.test.ts b/__tests__/python-local-binding.test.ts
new file mode 100644
index 0000000000..9ff2739a4c
--- /dev/null
+++ b/__tests__/python-local-binding.test.ts
@@ -0,0 +1,87 @@
+/**
+ * A bare Python call to a name its function (or module) binds itself —
+ * DRF's `view = SomeView.as_view()` then `view(request)` — is that value,
+ * not another file's `def view` (118 such calls went to one test file's
+ * `view`). A pytest fixture the test takes as a parameter is still the
+ * fixture, and an imported name is the import's, whatever a docstring says.
+ */
+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-local-'));
+  const files: Record<string, string> = {
+    'tests/test_testing.py': `def view(request):
+    return request
+`,
+    'tests/test_versioning.py': `class TestVersion:
+    def test_version(self, request):
+        view = MyView.as_view()
+        response = view(request)
+        return response
+`,
+    'tests/conftest.py': `import pytest
+
+
+@pytest.fixture
+def user_factory():
+    def make():
+        return 1
+    return make
+`,
+    'tests/test_users.py': `def test_user(user_factory):
+    user = user_factory()
+    return user
+`,
+    'app/utils.py': `def user_display(user):
+    return str(user)
+`,
+    'app/tags.py': `from app.utils import user_display
+
+
+def user_display_tag(user):
+    """
+    {% user_display user as user_display %}
+    """
+    return user_display(user)
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const callsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => {
+    const t = cg.getNode(e.target)!;
+    return `${t.filePath}: ${t.qualifiedName}`;
+  }).sort();
+};
+
+describe('bare Python calls to locally bound names', () => {
+  it('are the local value, not another file’s function of that name', () => {
+    expect(callsFrom('tests/test_versioning.py')).not.toContain('tests/test_testing.py: view');
+  });
+
+  it('still reach a pytest fixture taken as a parameter', () => {
+    expect(callsFrom('tests/test_users.py')).toContain('tests/conftest.py: user_factory');
+  });
+
+  it('still reach an imported function a docstring happens to mention', () => {
+    expect(callsFrom('app/tags.py')).toContain('app/utils.py: user_display');
+  });
+});
diff --git a/__tests__/python-package-reexports.test.ts b/__tests__/python-package-reexports.test.ts
new file mode 100644
index 0000000000..439e73e77e
--- /dev/null
+++ b/__tests__/python-package-reexports.test.ts
@@ -0,0 +1,83 @@
+/**
+ * A Python name imported from a package resolves through the package's
+ * re-exports — `from .users import *`, `from .tokens import Token` in its
+ * `__init__.py` — to where it is defined. netbox's `from users.models import
+ * User` names `users/models/__init__.py`, which star-imports `.users`;
+ * `httpx.Client(…)` names `httpx/__init__.py`, which imports `._client`.
+ */
+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-reexport-'));
+  const files: Record<string, string> = {
+    'netbox/users/__init__.py': '',
+    'netbox/users/models/__init__.py': `from .tokens import Token
+from .users import *
+`,
+    'netbox/users/models/users.py': `class User:
+    pass
+`,
+    'netbox/users/models/tokens.py': `class Token:
+    pass
+`,
+    'netbox/extras/tests/test_templatetags.py': `class User:
+    pass
+`,
+    'netbox/alembic/versions/0001_tokens.py': `class Token:
+    pass
+`,
+    'netbox/netbox/__init__.py': '',
+    'netbox/netbox/views/__init__.py': '',
+    'netbox/netbox/views/generic/__init__.py': `from .object_views import *
+`,
+    'netbox/netbox/views/generic/object_views.py': `class ObjectEditView:
+    pass
+`,
+    'netbox/dcim/views.py': `from netbox.views import generic
+
+
+class DeviceEditView(generic.ObjectEditView):
+    pass
+`,
+    'netbox/extras/views.py': `class ObjectEditView:
+    pass
+`,
+    'netbox/core/views.py': `from users.models import Token, User
+
+
+def make():
+    return User(), Token()
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Python package re-exports', () => {
+  it('lead a module member to its definition', () => {
+    const ids = cg.getNodesInFile('netbox/dcim/views.py').map((n) => n.id);
+    const bases = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'extends').map((e) => cg.getNode(e.target)!.filePath);
+    expect(bases).toEqual(['netbox/netbox/views/generic/object_views.py']);
+  });
+
+  it('lead an imported name to its definition, through star and named re-exports', () => {
+    const ids = cg.getNodesInFile('netbox/core/views.py').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'instantiates').map((e) => cg.getNode(e.target)!.filePath).sort();
+    expect(targets).toEqual(['netbox/users/models/tokens.py', 'netbox/users/models/users.py']);
+  });
+});
diff --git a/__tests__/python-receiver-guess.test.ts b/__tests__/python-receiver-guess.test.ts
new file mode 100644
index 0000000000..c5ba8a5062
--- /dev/null
+++ b/__tests__/python-receiver-guess.test.ts
@@ -0,0 +1,106 @@
+/**
+ * A method guessed from a receiver's name alone must be one the call can mean:
+ *
+ * - a request handler the framework dispatches to — a Django / DRF view's
+ *   `post`, a controller's `update` — is never called through an instance:
+ *   allauth's test `client.post(…)` went to a ClientRegistrationView 425 times;
+ * - a test double is only what a test names — mealie's `response.json()`
+ *   went to a `_FakeHTTPResponse` 424 times from files that never mention it;
+ * - `site = Site.objects.create(…)` makes `site` a Site, so `site.save()` is
+ *   Site's own.
+ */
+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-receiver-'));
+  const files: Record<string, string> = {
+    'app/views.py': `from django.views import View
+
+
+class ClientRegistrationView(View):
+    def post(self, request):
+        return None
+
+
+class SessionView(View):
+    def post(self, request):
+        return None
+`,
+    'app/models.py': `from django.db import models
+
+
+class Site(models.Model):
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+
+
+class Rack(models.Model):
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+`,
+    'tests/fakes.py': `class _FakeHTTPResponse:
+    def json(self):
+        return {}
+
+
+class Payload:
+    def json(self):
+        return {}
+`,
+    'tests/test_views.py': `from app.models import Site
+
+
+def test_login(client):
+    resp = client.post("/login")
+    assert resp.status_code == 200
+
+
+def test_api(api_client):
+    response = api_client.get("/recipes")
+    data = response.json()
+    assert data
+
+
+def test_site():
+    site = Site.objects.create(name="a")
+    site.save()
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('receiver-name guesses', () => {
+  it('never land on a dispatched view handler or an unnamed test double; a Django manager call types its result', () => {
+    const calls = callsFrom('tests/test_views.py');
+    expect(calls.filter((q) => q.endsWith('::post'))).toEqual([]);
+    expect(calls).not.toContain('_FakeHTTPResponse::json');
+    expect(calls).toContain('Site::save');
+    expect(calls).not.toContain('Rack::save');
+  });
+});
diff --git a/__tests__/python-receiver-guessing.test.ts b/__tests__/python-receiver-guessing.test.ts
new file mode 100644
index 0000000000..dcc9452039
--- /dev/null
+++ b/__tests__/python-receiver-guessing.test.ts
@@ -0,0 +1,89 @@
+/**
+ * A Python call whose receiver the extractor could not keep — `User.objects.get(…)`,
+ * `self.client.login(…)` reach the resolver as `get`, `login` — is not a project
+ * method picked by name. netbox bound 3,610 `.all()` calls to one `UserConfig.all`,
+ * healthchecks 880 `objects.get` to a test case's `get`. A bare `get(1)` cannot be a
+ * method either (no implicit self); `self.helper()` still resolves to the class's own.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+const FILES: Record<string, string> = {
+  'app/tests.py': `class AuthTestCase:
+    def get(self, url):
+        return url
+
+    def login(self, name):
+        return name
+`,
+  'app/curl.py': `def get(url):
+    return url
+`,
+  'app/helpers.py': `def slugify(text):
+    return text
+`,
+  'app/tags.py': `def render(context):
+    return context
+`,
+  'app/pages.py': `import app.helpers
+from django.shortcuts import render
+
+def page(request):
+    kind = request.POST.get("kind")
+    slug = app.helpers.slugify(kind)
+    return render(request, "page.html", {"slug": slug})
+`,
+  'app/views.py': `from django.contrib.auth.models import User
+
+class Backend:
+    def authenticate(self, username):
+        user = User.objects.get(email=username)
+        self.client.login(username="a")
+        self.helper()
+        self.assertEqual(self.filterset(params, self.queryset).qs.get(), 2)
+        get(1)
+        return user
+
+    def helper(self):
+        return 1
+`,
+};
+
+describe('Python: a method is reached through a receiver', () => {
+  it('not by its name alone', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-py-receiver-'));
+    roots.push(root);
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const authenticate = cg.getNodesByName('authenticate')[0]!;
+      const targets = cg
+        .getOutgoingEdgesFrom([authenticate.id], ['calls'])
+        .map((e) => cg.getNode(e.target)!.qualifiedName);
+      expect(targets).not.toContain('AuthTestCase::get');
+      expect(targets).not.toContain('AuthTestCase::login');
+      expect(targets).toContain('Backend::helper');
+      const page = cg.getNodesByName('page')[0]!;
+      const fromPage = cg.getOutgoingEdgesFrom([page.id], ['calls']).map((e) => cg.getNode(e.target)!);
+      const pageTargets = fromPage.map((n) => `${n.filePath}:${n.name}`);
+      // \`request.POST.get\` names no project module; \`render\` is Django's.
+      expect(pageTargets).not.toContain('app/curl.py:get');
+      expect(pageTargets).not.toContain('app/tags.py:render');
+      // A module path names the module's function.
+      expect(pageTargets).toContain('app/helpers.py:slugify');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/python-resolution-work.test.ts b/__tests__/python-resolution-work.test.ts
new file mode 100644
index 0000000000..f4faf445b5
--- /dev/null
+++ b/__tests__/python-resolution-work.test.ts
@@ -0,0 +1,102 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import type { ReferenceResolver } from '../src/resolution';
+import { stripCommentsForRegex } from '../src/resolution/strip-comments';
+
+// Pass-through, so a test can count how often a file's text is stripped.
+vi.mock('../src/resolution/strip-comments', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../src/resolution/strip-comments')>();
+  return { ...actual, stripCommentsForRegex: vi.fn(actual.stripCommentsForRegex) };
+});
+
+/**
+ * #2332: resolving Python does a bounded amount of work per file and per call.
+ * The cross-module write scan for a module global read every Python file once
+ * per global; the local-binding check stripped the calling file once per
+ * function, and looked up the function around a call once per same-named
+ * candidate. On CPython that was minutes of CPU. Counted, never timed.
+ */
+describe('Python resolution work (#2332)', () => {
+  let tmpDir: string | undefined;
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.mocked(stripCommentsForRegex).mockClear();
+    cg?.close();
+    cg = undefined;
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5 });
+    tmpDir = undefined;
+  });
+
+  /** Index `files`, counting per file what resolution reads, strips and looks up. */
+  async function indexCounting(files: Record<string, string>) {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-py-work-'));
+    for (const [file, content] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(tmpDir, file)), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, file), content);
+    }
+    cg = CodeGraph.initSync(tmpDir);
+    const context = (cg as unknown as { resolver: ReferenceResolver }).resolver.getResolutionContext();
+    const reads = vi.spyOn(context, 'readFile');
+    const lookups = vi.spyOn(context, 'getNodesInFile');
+    await cg.indexAll();
+    return {
+      graph: cg,
+      reads: (file: string) => reads.mock.calls.filter(([f]) => f === file).length,
+      lookups: (file: string) => lookups.mock.calls.filter(([f]) => f === file).length,
+      strips: (file: string) => vi.mocked(stripCommentsForRegex).mock.calls.filter(([text]) => text === files[file]).length,
+    };
+  }
+
+  it('reads no file once per module global, and strips no file once per function', async () => {
+    const SCALE = 16;
+    const conns = Array.from({ length: SCALE }, (_, i) => `conn${i}`);
+    const files: Record<string, string> = {
+      // Globals typed by their own module's writes: each one's type also
+      // depends on what every other module writes to it.
+      'store.py': 'class Store:\n    def fetch(self, ids):\n        return ids\n',
+      'settings.py': `from store import Store\n${conns.map(c => `${c} = None\n`).join('')}\n` +
+        `def init():\n    global ${conns.join(', ')}\n${conns.map(c => `    ${c} = Store()\n`).join('')}`,
+      'consumer.py': `import settings\n${conns.map((c, i) => `\ndef cb${i}(pool):\n    pool.submit(settings.${c}.fetch)\n`).join('')}`,
+      // A bare call in every function: each asks whether its function binds the name.
+      'helpers.py': 'def helper():\n    return 1\n',
+      'callers.py': Array.from({ length: SCALE }, (_, i) => `def f${i}():\n    return helper()\n\n`).join('') +
+        'def shadowed(make):\n    helper = make()\n    return helper()\n',
+    };
+    // Files no reference touches.
+    const fillers = Array.from({ length: 20 }, (_, i) => `pkg/filler${i}.py`);
+    fillers.forEach((file, i) => { files[file] = `def filler${i}(x):\n    return x + ${i}\n`; });
+    const { graph, reads, strips } = await indexCounting(files);
+
+    // Both paths ran: every global's method value reached Store.fetch, and the
+    // function that binds `helper` itself calls its own value.
+    const fetch = graph.getNodesByName('fetch').find(n => n.qualifiedName === 'Store::fetch')!;
+    expect(graph.getIncomingEdges(fetch.id).filter(e => e.metadata?.fnRef === true)
+      .map(e => graph.getNode(e.source)?.name).sort()).toEqual(conns.map((_, i) => `cb${i}`).sort());
+    const helper = graph.getNodesByName('helper').find(n => n.kind === 'function')!;
+    expect(graph.getIncomingEdges(helper.id).filter(e => e.kind === 'calls')
+      .map(e => graph.getNode(e.source)?.name).sort()).toEqual(Array.from({ length: SCALE }, (_, i) => `f${i}`).sort());
+    // A few whole-project passes read each file once; the write scan read every
+    // file once more per global.
+    expect(Math.max(...fillers.map(reads))).toBeLessThan(SCALE / 2);
+    // Stripped once for the pass, not once per function.
+    expect(strips('callers.py')).toBeLessThan(SCALE / 2);
+  });
+
+  it('finds the function around a call once, however many functions share its name', async () => {
+    const CANDIDATES = 16;
+    const CALLS = 8;
+    const files: Record<string, string> = {
+      'callers.py': Array.from({ length: CALLS }, (_, i) => `def f${i}():\n    return helper()\n\n`).join(''),
+    };
+    for (let k = 0; k < CANDIDATES; k++) files[`lib${k}/helpers.py`] = 'def helper():\n    return 1\n';
+    const { lookups } = await indexCounting(files);
+    // Each same-named candidate asks whether the caller binds `helper`; the
+    // answer is the call's, so the caller's nodes are read per call.
+    expect(lookups('callers.py')).toBeLessThanOrEqual(2 * CALLS);
+  });
+});
diff --git a/__tests__/python-self-call-not-import.test.ts b/__tests__/python-self-call-not-import.test.ts
new file mode 100644
index 0000000000..30a373a292
--- /dev/null
+++ b/__tests__/python-self-call-not-import.test.ts
@@ -0,0 +1,94 @@
+/**
+ * A Python call written on the instance, `self.get_ip(request)`, is a method
+ * call even when the file also imports a function named `get_ip`. The
+ * extractor records it by its bare name, and the import strategy claimed it:
+ * django-allauth's `DefaultAccountAdapter.send_notification_mail` calling
+ * `self.get_client_ip(self.request)` was linked to `httpkit.get_client_ip`,
+ * which `adapter.py` imports, instead of the adapter's own method.
+ */
+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';
+
+describe('Python self-calls do not resolve through a same-named import', () => {
+  const dirs: string[] = [];
+  let cg: CodeGraph | undefined;
+
+  afterEach(() => {
+    cg?.close();
+    cg = undefined;
+    for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  async function callsIn(files: Record<string, string>): Promise<string[]> {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-py-self-'));
+    dirs.push(dir);
+    for (const [rel, content] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    }
+    cg = await CodeGraph.init(dir, { index: true });
+    const rows = (cg as any).db.db
+      .prepare(
+        `SELECT s.qualified_name s, t.qualified_name t, t.file_path f FROM edges e
+         JOIN nodes s ON s.id = e.source JOIN nodes t ON t.id = e.target WHERE e.kind = 'calls'`,
+      )
+      .all() as { s: string; t: string; f: string }[];
+    return rows.map((r) => `${r.s} -> ${r.t} (${r.f})`).sort();
+  }
+
+  const httpkit = 'def get_ip(request):\n    return "1.2.3.4"\n';
+
+  it('a method calling its own same-named method through self', async () => {
+    expect(
+      await callsIn({
+        'pkg/__init__.py': '',
+        'pkg/httpkit.py': httpkit,
+        'pkg/adapter.py': [
+          'from pkg.httpkit import get_ip',
+          '',
+          '',
+          'class Adapter:',
+          '    def get_ip(self, request):',
+          '        return get_ip(request)',
+          '',
+          '    def notify(self, request):',
+          '        return self.get_ip(request)',
+          '',
+        ].join('\n'),
+      }),
+    ).toEqual([
+      // The bare call is still the imported function.
+      'Adapter::get_ip -> get_ip (pkg/httpkit.py)',
+      'Adapter::notify -> Adapter::get_ip (pkg/adapter.py)',
+    ]);
+  });
+
+  it('a method a base class in another file declares', async () => {
+    expect(
+      await callsIn({
+        'pkg/__init__.py': '',
+        'pkg/httpkit.py': httpkit,
+        'pkg/base.py': 'class Base:\n    def get_ip(self, request):\n        return "base"\n',
+        'pkg/adapter.py': [
+          'from pkg.base import Base',
+          'from pkg.httpkit import get_ip',
+          '',
+          '',
+          'class Adapter(Base):',
+          '    def notify(self, request):',
+          '        return self.get_ip(request)',
+          '',
+          '    def raw(self, request):',
+          '        return get_ip(request)',
+          '',
+        ].join('\n'),
+      }),
+    ).toEqual([
+      'Adapter::notify -> Base::get_ip (pkg/base.py)',
+      'Adapter::raw -> get_ip (pkg/httpkit.py)',
+    ]);
+  });
+});
diff --git a/__tests__/query-pool.test.ts b/__tests__/query-pool.test.ts
index 2087e6af47..7c28f48f04 100644
--- a/__tests__/query-pool.test.ts
+++ b/__tests__/query-pool.test.ts
@@ -182,6 +182,63 @@ describe('QueryPool', () => {
     expect(pool.healthy).toBe(false);
   });
 
+  describe('destroy never terminates a worker still starting up', () => {
+    // Terminating a worker while it is still loading its modules can crash the
+    // whole process on Windows (0xC0000005), and the daemon destroys its pool
+    // whenever it stops. FakeWorker(…, null) never posts 'ready' by itself.
+    it('answers callers at once, then waits for the worker to start', async () => {
+      let worker!: FakeWorker;
+      const pool = new QueryPool({
+        root: '/x', size: 1, softTimeoutMs: 10_000,
+        createWorker: () => (worker = new FakeWorker(() => ({ hang: true }), null)),
+      });
+      const pending = pool.run('codegraph_explore', { query: 'q' });
+      let destroyed = false;
+      const down = pool.destroy().then(() => { destroyed = true; });
+      expect((await pending).isError).toBe(true); // not held behind the start
+      await sleep(50);
+      expect(destroyed).toBe(false);
+      expect(worker.alive).toBe(true);
+      worker.emitMessage({ type: 'ready', ok: true });
+      await down;
+      expect(worker.alive).toBe(false);
+    });
+
+    it('terminates a started worker at once', async () => {
+      let worker!: FakeWorker;
+      const pool = new QueryPool({ root: '/x', size: 1, startSettleMs: 10_000, createWorker: () => (worker = new FakeWorker(() => ({ result: ok('r') }))) });
+      await sleep(5);
+      const started = Date.now();
+      await pool.destroy();
+      expect(worker.alive).toBe(false);
+      expect(Date.now() - started).toBeLessThan(1_000);
+    });
+
+    it('gives up waiting on a start that never finishes', async () => {
+      let worker!: FakeWorker;
+      const pool = new QueryPool({ root: '/x', size: 1, startSettleMs: 60, createWorker: () => (worker = new FakeWorker(() => ({ hang: true }), null)) });
+      const started = Date.now();
+      await pool.destroy();
+      expect(worker.alive).toBe(false);
+      expect(Date.now() - started).toBeGreaterThanOrEqual(55);
+    });
+
+    it('does not wait on a worker that died while starting', async () => {
+      const workers: FakeWorker[] = [];
+      const pool = new QueryPool({
+        root: '/x', size: 1, startSettleMs: 10_000,
+        // The first never starts; its replacement does.
+        createWorker: () => { const w = new FakeWorker(() => ({ result: ok('r') }), workers.length ? true : null); workers.push(w); return w; },
+      });
+      workers[0].emitExit();
+      await sleep(5);
+      const started = Date.now();
+      await pool.destroy();
+      expect(Date.now() - started).toBeLessThan(1_000);
+      expect(workers.every((w) => !w.alive)).toBe(true);
+    });
+  });
+
   it('is not `ready` until a worker completes its cold start (#662 first-call stall)', async () => {
     // A worker cold start is seconds (tens under load); a call queued behind it
     // waits for the 45s busy backstop with nothing served. The ToolHandler must
@@ -408,6 +465,50 @@ describe('MCP query pool with real projects (#1465)', () => {
     }
   }, 30000);
 
+  it('never terminates a real worker before it has started', async () => {
+    const alpha = await indexProject('alpha', 'alphaSymbol');
+    const startedWhenEnded: boolean[] = [];
+    pool = new QueryPool({
+      root: alpha, size: 1,
+      createWorker: () => {
+        const worker = new Worker(path.resolve(__dirname, '../dist/mcp/query-worker.js'), { workerData: { root: alpha } });
+        let started = false;
+        worker.on('message', (m: { type?: string }) => { if (m?.type === 'ready') started = true; });
+        const terminate = worker.terminate.bind(worker);
+        worker.terminate = () => {
+          startedWhenEnded.push(started);
+          return terminate();
+        };
+        return worker;
+      },
+    });
+    await pool.destroy(); // its eager worker is still loading
+    expect(startedWhenEnded).toEqual([true]);
+  }, 30000);
+
+  it('engine stop waits for the query pool to shut down', async () => {
+    const alpha = await indexProject('alpha', 'alphaSymbol');
+    const activeEngine = await start(alpha);
+    expect(pool).not.toBeNull();
+    const realPool = pool!;
+    let release!: () => void;
+    const destroy = vi.spyOn(realPool, 'destroy').mockReturnValue(new Promise<void>((r) => { release = r; }));
+    try {
+      let stopped = false;
+      const stopping = activeEngine.stop().then(() => { stopped = true; });
+      // Everything else stop() closes is done well inside this; only the pool is held.
+      await Promise.race([stopping, sleep(1_500)]);
+      expect(stopped).toBe(false);
+      release();
+      await stopping;
+      expect(stopped).toBe(true);
+    } finally {
+      release();
+      destroy.mockRestore();
+      await realPool.destroy();
+    }
+  }, 30000);
+
   it('honors size=0 for projectPath-only sessions', async () => {
     const alpha = await indexProject('alpha', 'alphaSymbol');
     const workspace = path.join(tempDir, 'workspace');
diff --git a/__tests__/r-call-skips-data-binding.test.ts b/__tests__/r-call-skips-data-binding.test.ts
new file mode 100644
index 0000000000..45e80e3188
--- /dev/null
+++ b/__tests__/r-call-skips-data-binding.test.ts
@@ -0,0 +1,50 @@
+/**
+ * R looks a call's name up among functions only, skipping other bindings:
+ * ggplot2's facet tests bind `c <- data_frame(b = 3)`, and every `c(1, 2)`
+ * in those files — base R's `c` — went to that data frame. A project binding
+ * made by a function factory (`geom_point <- make_constructor(…)`) stays.
+ */
+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-r-call-'));
+  const files: Record<string, string> = {
+    'DESCRIPTION': 'Package: ggplot2\n',
+    'R/geom-point.R': `geom_point <- make_constructor(GeomPoint, position = "identity")
+`,
+    'tests/testthat/test-facet-wrap.R': `a <- data_frame(a = 1:3)
+c <- data_frame(b = 3)
+
+test_that("facets", {
+  p <- geom_point()
+  expect_equal(c(1, 2), a$a)
+})
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('R calls', () => {
+  it('skip a data binding that shadows a base function, keep a factory-made function', () => {
+    const ids = cg.getNodesInFile('tests/testthat/test-facet-wrap.R').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.name);
+    expect(targets).not.toContain('c');
+    expect(targets).toContain('geom_point');
+  });
+});
diff --git a/__tests__/r-test-file-scope.test.ts b/__tests__/r-test-file-scope.test.ts
new file mode 100644
index 0000000000..7db573b71d
--- /dev/null
+++ b/__tests__/r-test-file-scope.test.ts
@@ -0,0 +1,57 @@
+/**
+ * testthat runs each test file in an environment of its own: a variable one
+ * test assigns is invisible to the package and to other tests. ggplot2's
+ * `c <- ggplot(…)` in one test took the package's 2,455 `c(…)` calls. A
+ * `helper-*.R` file is sourced for every test, so its bindings stay shared,
+ * and a package function defined through a factory
+ * (`geom_point <- make_constructor(…)`) stays callable.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+describe('R test-file bindings', () => {
+  it('stay in their file, except helpers; package bindings stay callable', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-r-tests-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      DESCRIPTION: 'Package: demo\n',
+      'R/geom-point.R': `geom_point <- make_constructor(GeomPoint)
+table_of <- function() {
+  c("a", "b")
+}
+`,
+      'tests/testthat/helper-s3.R': `quux <- structure(list(), class = "quux")
+`,
+      'tests/testthat/test-scales.R': `c <- ggplot(df, aes(x, y))
+test_that("works", {
+  geom_point()
+  quux()
+})
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const targets = (file: string) =>
+        cg
+          .getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id), ['calls'])
+          .map((e) => `${cg.getNode(e.target)!.name}@${cg.getNode(e.target)!.filePath}`)
+          .sort();
+      expect(targets('R/geom-point.R')).toEqual([]);
+      expect(targets('tests/testthat/test-scales.R')).toEqual(['geom_point@R/geom-point.R', 'quux@tests/testthat/helper-s3.R']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/rails-only-except-forms.test.ts b/__tests__/rails-only-except-forms.test.ts
new file mode 100644
index 0000000000..c72e582e3c
--- /dev/null
+++ b/__tests__/rails-only-except-forms.test.ts
@@ -0,0 +1,57 @@
+/**
+ * A `resources` line's `only:` / `except:` is read however Rails lets it be
+ * written. maybe's `resources :family_exports, only: %i[new create index]` was
+ * not read, so it drew all seven RESTful routes — four of them to actions the
+ * controller does not have, which the viewer listed as routes bound to nothing.
+ */
+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-rails-only-'));
+  const files: Record<string, string> = {
+    'Gemfile': 'source "https://rubygems.org"\ngem "rails", "~> 7.1"\n',
+    'config/routes.rb': `Rails.application.routes.draw do
+  resources :family_exports, only: %i[new create index] do
+    member do
+      get :download
+    end
+  end
+  resources :tags, except: %w(destroy edit update)
+  resources :imports, :only => [:index, :show]
+  resource :session, only: "show"
+end
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const routes = (controller: string) =>
+  cg.getNodesByKind('route').map((r) => r.qualifiedName).filter((q) => q.includes(`${controller}#`)).map((q) => q.slice(q.lastIndexOf('#') + 1)).sort();
+
+describe('Rails resources only: / except:', () => {
+  it('reads %i[] and %w() lists', () => {
+    expect(routes('family_exports')).toEqual(['create', 'download', 'index', 'new']);
+    expect(routes('tags')).toEqual(['create', 'index', 'new', 'show']);
+  });
+
+  it('reads the hash-rocket and string forms', () => {
+    expect(routes('imports')).toEqual(['index', 'show']);
+    expect(routes('sessions')).toEqual(['show']);
+  });
+});
diff --git a/__tests__/rails-scoped-routes.test.ts b/__tests__/rails-scoped-routes.test.ts
new file mode 100644
index 0000000000..29df4eab0f
--- /dev/null
+++ b/__tests__/rails-scoped-routes.test.ts
@@ -0,0 +1,113 @@
+/**
+ * A Rails routes file is read with its blocks: `namespace :admin` prefixes
+ * paths and controllers, `scope` its path and module, a `resources … do`
+ * block nests children under `/:parent_id`, and `member` / `collection`
+ * blocks add actions. A Rails engine's routes (`Spree::Core::Engine.routes.draw`
+ * in `backend/config/routes.rb`) count too — solidus had no routes at all —
+ * and a namespaced route reaches its own module's controller.
+ */
+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-rails-scoped-'));
+  const files: Record<string, string> = {
+    'Gemfile': 'source "https://rubygems.org"\ngem "rails", "~> 7.1"\n',
+    'backend/config/routes.rb': `Spree::Core::Engine.routes.draw do
+  namespace :admin do
+    get "/search/users", to: "search#users", as: :search_users
+    resources :zones, only: [
+      :index,
+      :show
+    ]
+    resources :products do
+      resources :images
+      member do
+        get :preview
+      end
+      collection do
+        post :update_positions
+      end
+    end
+  end
+  scope "/v2", module: "api" do
+    resource :account, only: [:show]
+  end
+  root to: "home#index"
+end
+`,
+    'backend/app/controllers/spree/admin/zones_controller.rb': `module Spree
+  module Admin
+    class ZonesController < ResourceController
+      def show; end
+    end
+  end
+end
+`,
+    'api/app/controllers/spree/api/zones_controller.rb': `module Spree
+  module Api
+    class ZonesController < BaseController
+      def index; end
+      def show; end
+    end
+  end
+end
+`,
+    'backend/app/controllers/spree/admin/products_controller.rb': `module Spree
+  module Admin
+    class ProductsController < ResourceController
+      def preview; end
+      def update_positions; end
+    end
+  end
+end
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const handlerOf = (name: string): string | undefined => {
+  const route = cg.getNodesByKind('route').find((r) => r.name === name);
+  if (!route) return undefined;
+  const target = cg.getOutgoingEdges(route.id).find((e) => e.kind === 'references');
+  return target ? cg.getNode(target.target)!.filePath : '';
+};
+
+describe('Rails routes with their nesting', () => {
+  it('prefixes namespaces and scopes, nests resources, adds member and collection actions', () => {
+    const names = cg.getNodesByKind('route').map((r) => r.name).sort();
+    expect(names).toEqual(expect.arrayContaining([
+      'GET /admin/search/users',
+      'GET /admin/zones', 'GET /admin/zones/:id',
+      'GET /admin/products/:product_id/images',
+      'GET /admin/products/:id/preview',
+      'POST /admin/products/update_positions',
+      'GET /v2/account',
+      'GET /',
+    ]));
+    // `only:` written across lines still limits the actions.
+    expect(names).not.toContain('DELETE /admin/zones/:id');
+  });
+
+  it('reaches the controller of the route’s own module, not another module’s namesake', () => {
+    expect(handlerOf('GET /admin/zones/:id')).toBe('backend/app/controllers/spree/admin/zones_controller.rb');
+    // The admin controller inherits `index`; the API's `index` is not it.
+    expect(handlerOf('GET /admin/zones')).toBe('');
+    expect(handlerOf('GET /admin/products/:id/preview')).toBe('backend/app/controllers/spree/admin/products_controller.rb');
+  });
+});
diff --git a/__tests__/react-heuristic-same-file.test.ts b/__tests__/react-heuristic-same-file.test.ts
new file mode 100644
index 0000000000..3eef6bb773
--- /dev/null
+++ b/__tests__/react-heuristic-same-file.test.ts
@@ -0,0 +1,65 @@
+/**
+ * In a JS/TS module another file's binding is reached only through an
+ * import — the import resolver's to follow — so the React resolver's hook
+ * and context heuristics pick from the reference's own file alone. trpc's
+ * WebSocket adapter's `createContext?.(…)` (an option) went to an example
+ * app's `createContext`, and bulletproof-react's per-app `useUser()` to
+ * another app's hook.
+ */
+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-react-heur-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'trpc', private: true, dependencies: { react: '^18.0.0' } }),
+    'examples/next-app/src/server/context.ts': `export async function createContext() {
+  return {};
+}
+`,
+    'apps/nextjs-app/src/lib/auth.tsx': `export function useUser() {
+  return null;
+}
+`,
+    'packages/server/src/adapters/ws.ts': `export function getHandler(opts: any) {
+  const { createContext } = opts;
+  return createContext?.({});
+}
+`,
+    'apps/react-vite/src/lib/auth.tsx': `const { useUser } = configureAuth({});
+
+export function AuthLoader() {
+  const user = useUser();
+  return user;
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetFilesFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.filePath);
+};
+
+describe('React name heuristics in JS/TS', () => {
+  it('never reach another file’s hook or context by name', () => {
+    expect(targetFilesFrom('packages/server/src/adapters/ws.ts')).not.toContain('examples/next-app/src/server/context.ts');
+    expect(targetFilesFrom('apps/react-vite/src/lib/auth.tsx')).not.toContain('apps/nextjs-app/src/lib/auth.tsx');
+  });
+});
diff --git a/__tests__/react-hoc-component.test.ts b/__tests__/react-hoc-component.test.ts
index cac29b8363..41e371704f 100644
--- a/__tests__/react-hoc-component.test.ts
+++ b/__tests__/react-hoc-component.test.ts
@@ -60,6 +60,100 @@ export const Rewrapped = memo(Button);
     }
   });
 
+  it('classifies typed styled consts as component nodes too', async () => {
+    // tree-sitter's tagged-template call takes no type arguments, so a type
+    // argument that also reads as an expression turns the initializer into
+    // comparisons: `(styled.div < WrapperProps) > \`…\``. These shapes come from
+    // outline/outline (FloatingToolbar's Wrapper and Background, Lightbox's
+    // CloseAction, NudeButton, HStack).
+    fs.writeFileSync(
+      path.join(dir, 'typed.tsx'),
+      `import styled from 'styled-components';
+import { s, depths } from './theme';
+type WrapperProps = { active: boolean };
+type Props = { align: 'start' | 'end' };
+const Plain = styled.div\`color: red;\`;
+export const Wrapper = styled.div<WrapperProps>\`
+  z-index: \${depths.editorToolbar};
+  color: \${(props) => (props.active ? s("accent") : s("text"))};
+\`;
+const Background = styled.div<{ align: Props["align"] }>\`color: red;\`;
+const CloseAction = styled.div<{ animation: Animation | null }>\`top: 0;\`;
+const Content = styled(Plain)<WrapperProps>\`padding: 4px;\`;
+const NudeButton = styled(Plain).attrs((props: Props) => ({ type: "button" }))<Props>\`width: 24px;\`;
+export const HStack = styled(Plain)
+  .withConfig({ shouldForwardProp: (prop) => prop !== "spacing" })
+  .attrs<Props>((props) => ({ align: props.align }))<Props>\`\`;
+const Either = styled.div<WrapperProps | Props>\`color: red;\`;
+const Both = styled.span<WrapperProps & { open: boolean }>\`color: red;\`;
+const Nested = styled.div<Partial<WrapperProps>>\`color: red;\`;
+const Deeper = styled.div<Partial<Record<string, WrapperProps>>>\`color: red;\`;
+const Named = styled("figure")<Props>\`margin: 0;\`;
+`
+    );
+    const db = await index();
+    for (const name of [
+      'Wrapper', 'Background', 'CloseAction', 'Content', 'NudeButton', 'HStack',
+      'Either', 'Both', 'Nested', 'Deeper', 'Named',
+    ]) {
+      expect(kindsOf(db, name), `${name} should be a component`).toEqual(['component']);
+    }
+  });
+
+  it('gives a typed styled const its jsx-render callers', async () => {
+    fs.writeFileSync(
+      path.join(dir, 'toolbar.tsx'),
+      `import styled from 'styled-components';
+type WrapperProps = { active: boolean };
+export const Wrapper = styled.div<WrapperProps>\`opacity: 0;\`;
+export function FloatingToolbar() {
+  return <Wrapper active>menu</Wrapper>;
+}
+`
+    );
+    fs.writeFileSync(
+      path.join(dir, 'page.tsx'),
+      `import { Wrapper } from './toolbar';
+export function Page() {
+  return <Wrapper active={false} />;
+}
+`
+    );
+    const db = await index();
+    const callers = db
+      .prepare(
+        `SELECT s.name caller FROM edges e
+         JOIN nodes s ON s.id = e.source
+         JOIN nodes t ON t.id = e.target
+         WHERE json_extract(e.metadata, '$.synthesizedBy') = 'jsx-render'
+           AND t.kind = 'component' AND t.name = 'Wrapper'
+         ORDER BY s.name`
+      )
+      .all()
+      .map((r: any) => r.caller);
+    expect(callers).toEqual(['FloatingToolbar', 'Page']);
+  });
+
+  it('keeps other typed template tags and real comparisons constants (precision)', async () => {
+    fs.writeFileSync(
+      path.join(dir, 'tags.tsx'),
+      `import styled, { css, createGlobalStyle, keyframes } from 'styled-components';
+type Props = { open: boolean };
+export const Mixin = css<Props>\`color: red;\`;
+export const GlobalStyle = createGlobalStyle<Props>\`body { margin: 0; }\`;
+export const Fade = keyframes<Props>\`from { opacity: 0; }\`;
+export const Styledish = styledLike<Props>\`color: red;\`;
+export const Compared = styled.length < LIMIT > 2;
+export const Untagged = styled.div < Props > other;
+const lowerCase = styled.div<Props>\`color: red;\`;
+`
+    );
+    const db = await index();
+    for (const name of ['Mixin', 'GlobalStyle', 'Fade', 'Styledish', 'Compared', 'Untagged', 'lowerCase']) {
+      expect(kindsOf(db, name), `${name} must stay a constant`).toEqual(['constant']);
+    }
+  });
+
   it('emits jsx-render edges so getCallers/getImpactRadius resolve a forwardRef component', async () => {
     fs.writeFileSync(
       path.join(dir, 'button.tsx'),
diff --git a/__tests__/react-resolver-language.test.ts b/__tests__/react-resolver-language.test.ts
new file mode 100644
index 0000000000..50bbf3bf36
--- /dev/null
+++ b/__tests__/react-resolver-language.test.ts
@@ -0,0 +1,65 @@
+/**
+ * The React resolver's hook (`use…`) and context (`…Context` / `…Provider`)
+ * rules are a script's, never another language's: in halo — a Spring app
+ * with a React-detected UI package — Java imports of `SecurityContext` or
+ * `ObjectProvider` were taken by the context rule, and a Java test's own
+ * `responseContext()` helper went unresolved.
+ */
+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-react-lang-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', dependencies: { react: '^18' } }),
+    'ui/src/ThemeContext.tsx': `import { createContext } from 'react';
+
+export const responseContext = createContext(null);
+`,
+    'src/main/java/app/Filter.java': `package app;
+
+import org.springframework.security.core.context.SecurityContext;
+
+public class Filter {
+  Object responseContext() {
+    return null;
+  }
+
+  void filter() {
+    responseContext();
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('the React resolver', () => {
+  it('does not take a Java import of a …Context class', () => {
+    const ids = cg.getNodesInFile('src/main/java/app/Filter.java').map((n) => n.id);
+    const byReact = cg.getOutgoingEdgesFrom(ids).filter((e) => (e.metadata as { framework?: string } | undefined)?.framework === 'react');
+    expect(byReact).toEqual([]);
+  });
+
+  it('leaves a Java call named like a context to Java', () => {
+    const filter = cg.getNodesInFile('src/main/java/app/Filter.java').find((n) => n.name === 'filter')!;
+    const targets = cg.getOutgoingEdges(filter.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!);
+    expect(targets.map((t) => t.filePath)).not.toContain('ui/src/ThemeContext.tsx');
+    expect(targets.map((t) => t.qualifiedName)).toContain('app::Filter::responseContext');
+  });
+});
diff --git a/__tests__/react-router-config-href.test.ts b/__tests__/react-router-config-href.test.ts
new file mode 100644
index 0000000000..eb724aa75d
--- /dev/null
+++ b/__tests__/react-router-config-href.test.ts
@@ -0,0 +1,114 @@
+/**
+ * React Router links written through a route-config object (bulletproof-react's
+ * `config/paths.ts`): `<Link to={paths.app.discussion.getHref(id)}>` and
+ * `navigate(paths.auth.login.getHref())` read the href the helper returns —
+ * a template's whole-segment `${id}` stays a parameter, a hole glued onto a
+ * segment (`?redirectTo=…`) is dropped. An arrow-function attribute before
+ * `to` (`onMouseEnter={() => …}`) no longer ends the tag early.
+ */
+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-rr-config-href-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'web', dependencies: { react: '^18', 'react-router': '^7' } }),
+    'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['./src/*'] } } }),
+    'src/config/paths.ts': `export const paths = {
+  auth: {
+    login: {
+      path: '/auth/login',
+      getHref: (redirectTo?: string | null | undefined) =>
+        \`/auth/login\${redirectTo ? \`?redirectTo=\${encodeURIComponent(redirectTo)}\` : ''}\`,
+    },
+  },
+  app: {
+    root: { path: '/app', getHref: () => '/app' },
+    discussions: { path: 'discussions', getHref: () => '/app/discussions' },
+    discussion: {
+      path: 'discussions/:discussionId',
+      getHref: (id: string) => \`/app/discussions/\${id}\`,
+    },
+  },
+} as const;
+`,
+    'src/app/router.tsx': `import { createBrowserRouter } from 'react-router';
+import { paths } from '@/config/paths';
+
+export const router = createBrowserRouter([
+  { path: paths.auth.login.path, lazy: () => import('./routes/auth/login') },
+  {
+    path: paths.app.root.path,
+    lazy: () => import('./routes/app/root'),
+    children: [
+      { path: paths.app.discussions.path, lazy: () => import('./routes/app/discussions') },
+      { path: paths.app.discussion.path, lazy: () => import('./routes/app/discussion') },
+    ],
+  },
+]);
+`,
+    'src/app/routes/auth/login.tsx': `export default function LoginRoute() { return null; }
+`,
+    'src/app/routes/app/root.tsx': `export default function AppRoot() { return null; }
+`,
+    'src/app/routes/app/discussions.tsx': `export default function DiscussionsRoute() { return null; }
+`,
+    'src/app/routes/app/discussion.tsx': `export default function DiscussionRoute() { return null; }
+`,
+    'src/features/discussions/discussions-list.tsx': `import { Link } from 'react-router';
+import { paths } from '@/config/paths';
+
+export function DiscussionsList({ items, prefetch }: { items: { id: string }[]; prefetch: (id: string) => void }) {
+  return items.map((d) => (
+    <Link onMouseEnter={() => prefetch(d.id)} to={paths.app.discussion.getHref(d.id)}>
+      open
+    </Link>
+  ));
+}
+`,
+    'src/lib/auth.tsx': `import { useNavigate } from 'react-router';
+import { paths } from '@/config/paths';
+
+export function Logout() {
+  const navigate = useNavigate();
+  return <button onClick={() => navigate(paths.auth.login.getHref(location.pathname))}>out</button>;
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `route name` of every navigates edge out of a file. */
+function navigatesFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'navigates')
+    .map((e) => cg.getNode(e.target)!.name)
+    .sort();
+}
+
+describe('React Router links through a route-config object', () => {
+  it('reads a Link’s `to={paths.x.getHref(id)}`, past an arrow attribute before it', () => {
+    expect(navigatesFrom('src/features/discussions/discussions-list.tsx')).toEqual(['/app/discussions/:discussionId']);
+  });
+
+  it('reads `navigate(paths.x.getHref(…))`, dropping a query suffix glued onto the path', () => {
+    expect(navigatesFrom('src/lib/auth.tsx')).toEqual(['/auth/login']);
+  });
+});
diff --git a/__tests__/react-router-lazy-barrel.test.ts b/__tests__/react-router-lazy-barrel.test.ts
new file mode 100644
index 0000000000..9bc5d57057
--- /dev/null
+++ b/__tests__/react-router-lazy-barrel.test.ts
@@ -0,0 +1,273 @@
+/**
+ * A lazily loaded route module that is a barrel (luci-go's milo/ui):
+ * `lazy: () => import('@/test_verdict/pages/invocation_page')` loads
+ * `invocation_page/index.ts`, whose `export * from './invocation_page'`
+ * forwards the `Component` that `invocation_page.tsx` declares. The route
+ * renders that component; before, the barrel was read for an export of its
+ * own, found none, and the route linked nothing. (The fixture's folder is
+ * `builds/`: a `build/` folder is skipped as build output.)
+ */
+import { describe, it, expect, afterAll, afterEach, 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-rr-lazy-barrel-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'ui', private: true, dependencies: { react: '^18', 'react-router': '^7' } }),
+    'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['./src/*'] } } }),
+    'src/router.tsx': `import { lazy } from 'react';
+import { createBrowserRouter } from 'react-router';
+
+const Settings = lazy(() => import('@/settings'));
+
+export const router = createBrowserRouter([
+  {
+    path: '/builds/:id',
+    lazy: () => import('@/builds/build_page'),
+    children: [{ path: 'overview', lazy: () => import('@/builds/build_page/overview_tab') }],
+  },
+  { path: '/builders', lazy: () => import('@/builds/pages') },
+  { path: '/fleet', lazy: () => import('@/fleet/home_page') },
+  { path: '/login', lazy: () => import('@/auth/login_page') },
+  { path: '/graph', lazy: () => import('@/chronicle/graph_view') },
+  { path: '/settings', element: <Settings /> },
+  { path: '/redirect', lazy: () => import('@/core/redirection_loader') },
+  { path: '/clash', lazy: () => import('@/clash') },
+  { path: '/loop', lazy: () => import('@/loop/a') },
+  { path: '/no-default', lazy: () => import('@/legacy') },
+]);
+`,
+    // `export *` forwards the `Component` its module declares.
+    'src/builds/build_page/index.ts': `export * from './build_page';
+`,
+    'src/builds/build_page/build_page.tsx': `export const BuildPage = () => null;
+
+export function Component() {
+  return <BuildPage />;
+}
+`,
+    'src/builds/build_page/overview_tab/index.ts': `export * from './overview_tab';
+`,
+    'src/builds/build_page/overview_tab/overview_tab.tsx': `export function Component() {
+  return null;
+}
+`,
+    // A barrel of barrels.
+    'src/builds/pages/index.ts': `export * from './builder_list_page';
+`,
+    'src/builds/pages/builder_list_page/index.ts': `export * from './builder_list_page';
+`,
+    'src/builds/pages/builder_list_page/builder_list_page.tsx': `export function BuilderListPage() {
+  return null;
+}
+
+export const Component = BuilderListPage;
+`,
+    // A named re-export, renamed to the name React Router reads.
+    'src/fleet/home_page/index.ts': `export { HomePage as Component } from './home_page';
+`,
+    'src/fleet/home_page/home_page.tsx': `export function HomePage() {
+  return null;
+}
+`,
+    // The default export, forwarded.
+    'src/auth/login_page/index.ts': `export { default } from './login_page';
+`,
+    'src/auth/login_page/login_page.tsx': `export default function LoginPage() {
+  return null;
+}
+`,
+    // An export clause in the module itself.
+    'src/chronicle/graph_view.tsx': `function GraphView() {
+  return null;
+}
+
+export { GraphView as Component };
+`,
+    // `React.lazy` reads the default export, through a barrel too.
+    'src/settings/index.ts': `export { default } from './settings_page';
+`,
+    'src/settings/settings_page.tsx': `export default function SettingsPage() {
+  return null;
+}
+`,
+    // A module that only redirects renders nothing.
+    'src/core/redirection_loader.ts': `export function redirectionLoader() {
+  return null;
+}
+
+export const loader = redirectionLoader;
+`,
+    // Two modules forward a `Component` through `export *`: JavaScript exports neither.
+    'src/clash/index.ts': `export * from './first';
+export * from './second';
+`,
+    'src/clash/first.tsx': `export function Component() {
+  return null;
+}
+`,
+    'src/clash/second.tsx': `export function Component() {
+  return null;
+}
+`,
+    // Barrels that forward each other.
+    'src/loop/a.ts': `export * from './b';
+`,
+    'src/loop/b.ts': `export * from './a';
+`,
+    // `export *` forwards every name but the default.
+    'src/legacy/index.ts': `export * from './legacy_page';
+`,
+    'src/legacy/legacy_page.tsx': `export default function LegacyPage() {
+  return null;
+}
+`,
+  };
+  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 });
+}, 60_000);
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** What a route's `references` edges reach, as `name@file`: what it renders, or the layouts around it. */
+const bindings = (routeName: string, layout: boolean): string[] => {
+  const route = cg.getNodesByKind('route').find((r) => r.name === routeName);
+  if (!route) return [`no route ${routeName}`];
+  return cg.getOutgoingEdges(route.id)
+    .filter((e) => e.kind === 'references' && Boolean((e.metadata as Record<string, unknown> | undefined)?.layout) === layout)
+    .map((e) => cg.getNode(e.target)!)
+    .map((n) => `${n.name}@${n.filePath}`);
+};
+const renders = (routeName: string): string[] => bindings(routeName, false);
+
+describe('a lazy route module that is a barrel', () => {
+  it('renders the Component an `export *` barrel forwards', () => {
+    expect(renders('/builds/:id')).toEqual(['Component@src/builds/build_page/build_page.tsx']);
+    expect(renders('/builds/:id/overview')).toEqual(['Component@src/builds/build_page/overview_tab/overview_tab.tsx']);
+  });
+
+  it('follows a barrel that forwards another barrel', () => {
+    expect(renders('/builders')).toEqual(['Component@src/builds/pages/builder_list_page/builder_list_page.tsx']);
+  });
+
+  it('renders inside the layout a barrel forwards', () => {
+    expect(bindings('/builds/:id/overview', true)).toEqual(['Component@src/builds/build_page/build_page.tsx']);
+  });
+
+  it('follows a named re-export to what it renames', () => {
+    expect(renders('/fleet')).toEqual(['HomePage@src/fleet/home_page/home_page.tsx']);
+    expect(renders('/login')).toEqual(['LoginPage@src/auth/login_page/login_page.tsx']);
+  });
+
+  it('reads an export clause in the module itself', () => {
+    expect(renders('/graph')).toEqual(['GraphView@src/chronicle/graph_view.tsx']);
+  });
+
+  it('follows the barrel a React.lazy value loads', () => {
+    expect(renders('/settings')).toEqual(['SettingsPage@src/settings/settings_page.tsx']);
+  });
+
+  it('links nothing a barrel does not forward', () => {
+    // A loader-only module, a name two `export *` modules both forward, a
+    // cycle, and a default export behind `export *`.
+    expect(renders('/redirect')).toEqual([]);
+    expect(renders('/clash')).toEqual([]);
+    expect(renders('/loop')).toEqual([]);
+    expect(renders('/no-default')).toEqual([]);
+  });
+});
+
+describe('sync, for a lazy route module that is a barrel', () => {
+  type Files = Record<string, string>;
+  const ROUTER: Files = {
+    'package.json': JSON.stringify({ name: 'ui', private: true, dependencies: { react: '^18', 'react-router': '^7' } }),
+    'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['./src/*'] } } }),
+    'src/router.tsx': `import { createBrowserRouter } from 'react-router';
+
+export const router = createBrowserRouter([
+  { path: '/reports', lazy: () => import('@/reports/report_list') },
+  { path: '/reports/:id', lazy: () => import('@/reports/report_page') },
+]);
+`,
+    'src/reports/report_list/index.ts': `export { ReportList as Component } from './report_list';
+`,
+    'src/reports/report_page/index.ts': `export * from './report_page';
+`,
+  };
+  const PAGES: Files = {
+    'src/reports/report_list/report_list.tsx': `export function ReportList() {
+  return null;
+}
+`,
+    'src/reports/report_page/report_page.tsx': `export function Component() {
+  return null;
+}
+`,
+  };
+  const LINKED = {
+    '/reports': ['ReportList@src/reports/report_list/report_list.tsx'],
+    '/reports/:id': ['Component@src/reports/report_page/report_page.tsx'],
+  };
+
+  let dirs: string[] = [];
+  let graphs: CodeGraph[] = [];
+  afterEach(() => {
+    for (const graph of graphs) graph.close();
+    for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
+    graphs = [];
+    dirs = [];
+  });
+
+  const write = (dir: string, files: Files): void => {
+    for (const [rel, content] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    }
+  };
+  /** A project of `files`, indexed from scratch in a folder of its own. */
+  const indexed = async (files: Files): Promise<{ dir: string; graph: CodeGraph }> => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rr-lazy-barrel-sync-'));
+    dirs.push(dir);
+    write(dir, files);
+    const graph = await CodeGraph.init(dir, { index: true });
+    graphs.push(graph);
+    return { dir, graph };
+  };
+  /** Each route's `references` edges, as `name@file`. */
+  const routeLinks = (graph: CodeGraph): Record<string, string[]> => Object.fromEntries(
+    graph.getNodesByKind('route').map((route) => [route.name, graph.getOutgoingEdges(route.id)
+      .filter((e) => e.kind === 'references')
+      .map((e) => graph.getNode(e.target)!)
+      .map((n) => `${n.name}@${n.filePath}`)
+      .sort()])
+  );
+
+  it('links a page that appears behind its barrel later', async () => {
+    const { dir, graph } = await indexed(ROUTER);
+    expect(routeLinks(graph)).toEqual({ '/reports': [], '/reports/:id': [] });
+    write(dir, PAGES);
+    expect((await graph.sync()).filesAdded).toBe(2);
+    expect(routeLinks(graph)).toEqual(LINKED);
+    expect(routeLinks((await indexed({ ...ROUTER, ...PAGES })).graph)).toEqual(LINKED);
+  }, 60_000);
+
+  it('links a page once an edit gives it the Component its barrel forwards', async () => {
+    const { dir, graph } = await indexed({ ...ROUTER, ...PAGES, 'src/reports/report_page/report_page.tsx': 'export const placeholder = 1;\n' });
+    expect(routeLinks(graph)['/reports/:id']).toEqual([]);
+    write(dir, { 'src/reports/report_page/report_page.tsx': PAGES['src/reports/report_page/report_page.tsx']! });
+    expect((await graph.sync()).filesModified).toBe(1);
+    expect(routeLinks(graph)).toEqual(LINKED);
+  }, 60_000);
+});
diff --git a/__tests__/react-router-nested-lazy.test.ts b/__tests__/react-router-nested-lazy.test.ts
new file mode 100644
index 0000000000..da5d594143
--- /dev/null
+++ b/__tests__/react-router-nested-lazy.test.ts
@@ -0,0 +1,107 @@
+/**
+ * A data router's nested, lazy, constant-named routes (bulletproof-react):
+ * - a child's `path` is relative to its parent's — `discussions` under `/app`
+ *   is `/app/discussions`;
+ * - `lazy: () => import('./routes/x')` renders the module's default export;
+ * - `path: paths.app.root.path` reads the constant object where it is
+ *   declared — here through a monorepo app's own tsconfig `@/*` alias, which
+ *   now resolves from the tsconfig nearest the importing file;
+ * - `element: (<ProtectedRoute><AppRoot /></ProtectedRoute>)` renders AppRoot.
+ */
+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-rr-nested-'));
+  const app = (rel: string) => `apps/web/${rel}`;
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'mono', private: true }),
+    [app('package.json')]: JSON.stringify({ name: 'web', dependencies: { react: '^18', 'react-router': '^7' } }),
+    [app('tsconfig.json')]: JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['./src/*'] } } }),
+    [app('src/config/paths.ts')]: `export const paths = {
+  home: { path: '/', getHref: () => '/' },
+  app: {
+    root: { path: '/app', getHref: () => '/app' },
+    discussions: { path: 'discussions', getHref: () => '/app/discussions' },
+  },
+} as const;
+`,
+    [app('src/app/router.tsx')]: `import { createBrowserRouter } from 'react-router';
+import { paths } from '@/config/paths';
+import { ProtectedRoute } from '@/lib/auth';
+import AppRoot from './routes/app/root';
+
+export const router = createBrowserRouter([
+  { path: paths.home.path, lazy: () => import('./routes/landing') },
+  {
+    path: paths.app.root.path,
+    element: (
+      <ProtectedRoute>
+        <AppRoot />
+      </ProtectedRoute>
+    ),
+    children: [
+      { path: paths.app.discussions.path, lazy: () => import('./routes/app/discussions') },
+      { path: 'settings', element: <Settings /> },
+    ],
+  },
+]);
+`,
+    [app('src/lib/auth.tsx')]: `export function ProtectedRoute({ children }: { children: unknown }) { return children; }
+`,
+    [app('src/app/routes/landing.tsx')]: `const LandingRoute = () => null;
+export default LandingRoute;
+`,
+    [app('src/app/routes/app/root.tsx')]: `export default function AppRoot() { return null; }
+`,
+    [app('src/app/routes/app/discussions.tsx')]: `export default function DiscussionsRoute() { return null; }
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const bindings = (routeName: string, layout: boolean): string[] => {
+  const route = cg.getNodesByKind('route').find((r) => r.name === routeName);
+  if (!route) return [];
+  return cg.getOutgoingEdges(route.id)
+    .filter((e) => e.kind === 'references' && Boolean((e.metadata as Record<string, unknown> | undefined)?.layout) === layout)
+    .map((e) => cg.getNode(e.target)!.name);
+};
+const renders = (routeName: string): string[] => bindings(routeName, false);
+
+describe('nested, lazy and constant React Router routes', () => {
+  it('compose their paths and render their modules', () => {
+    const names = cg.getNodesByKind('route').map((r) => r.name).sort();
+    expect(names).toEqual(['/', '/app', '/app/discussions', '/app/settings']);
+    expect(renders('/')).toEqual(['LandingRoute']);
+    expect(renders('/app')).toEqual(['AppRoot']);
+    expect(renders('/app/discussions')).toEqual(['DiscussionsRoute']);
+  });
+
+  it('a child route renders inside its parent’s component, the layout around it', () => {
+    expect(bindings('/app/discussions', true)).toEqual(['AppRoot']);
+    expect(bindings('/', true)).toEqual([]);
+  });
+
+  it('resolves an app’s own tsconfig alias', () => {
+    const router = cg.getNodesInFile('apps/web/src/app/router.tsx').map((n) => n.id);
+    const imported = cg.getOutgoingEdgesFrom(router).filter((e) => e.kind === 'imports').map((e) => cg.getNode(e.target)!.filePath);
+    expect(imported).toContain('apps/web/src/config/paths.ts');
+    expect(imported).toContain('apps/web/src/lib/auth.tsx');
+  });
+});
diff --git a/__tests__/react-router.test.ts b/__tests__/react-router.test.ts
index 70ea8266ce..419b1f7ad9 100644
--- a/__tests__/react-router.test.ts
+++ b/__tests__/react-router.test.ts
@@ -516,9 +516,10 @@ describe('react-router: route declaration boundaries (#1348)', () => {
     const routes = cg.getNodesByKind('route');
     return {
       paths: routes.map((route) => route.name).sort(),
+      // `->` what a route renders, `~>` a layout it renders inside.
       bindings: routes.flatMap((route) => cg!.getOutgoingEdges(route.id)
         .filter((edge) => edge.kind === 'references')
-        .map((edge) => `${route.name}->${cg!.getNode(edge.target)?.name}`)).sort(),
+        .map((edge) => `${route.name}${(edge.metadata as Record<string, unknown> | undefined)?.layout ? '~>' : '->'}${cg!.getNode(edge.target)?.name}`)).sort(),
     };
   }
 
@@ -548,8 +549,11 @@ describe('react-router: route declaration boundaries (#1348)', () => {
       }
     `, extension);
     expect(result).toEqual({
-      paths: ['/dashboard', '/empty', '/legacy', '/long', '/no-element', '/sibling', 'settings'],
-      bindings: ['/legacy->Settings', '/long->Shell', '/sibling->Settings', 'settings->Settings'],
+      // A nested route's path is relative to its parent's (`settings` under
+      // `/dashboard`). The index route is the page at `/dashboard`; the `<Route
+      // path>` around it only groups, so it is not a second, empty `/dashboard`.
+      paths: ['/dashboard', '/dashboard/settings', '/empty', '/legacy', '/long', '/no-element', '/sibling'],
+      bindings: ['/dashboard->DashboardHome', '/dashboard/settings->Settings', '/legacy->Settings', '/long->Shell', '/sibling->Settings'],
     });
   });
 
@@ -573,8 +577,136 @@ describe('react-router: route declaration boundaries (#1348)', () => {
       ]);
     `, extension);
     expect(result).toEqual({
-      paths: ['/', '/long', '/quoted', '/sibling', 'prefs'],
-      bindings: ['/->DataSettings', '/long->DataSettings', '/quoted->DataSettings', '/sibling->DataSettings', 'prefs->DataSettings'],
+      // `{ index: true, Component: DataIndex }` is the page at its parent's address.
+      paths: ['/', '/data', '/data/prefs', '/long', '/quoted', '/sibling'],
+      bindings: ['/->DataSettings', '/data->DataIndex', '/data/prefs->DataSettings', '/long->DataSettings', '/quoted->DataSettings', '/sibling->DataSettings'],
+    });
+  });
+
+  it.each(['tsx', 'jsx', 'js'])('reads what a route renders past placeholders, guards and line breaks in %s', async (extension) => {
+    const result = await index(`
+      import { Suspense } from 'react';
+      import { Routes, Route } from 'react-router-dom';
+      function Loader() { return null; }
+      function AdminPanel() { return null; }
+      function RequireAuth({ children }) { return children; }
+      function ProtectedPage() { return null; }
+      function PrivateRoot({ component }) { return component; }
+      function HomePage() { return null; }
+      function AuthPage() { return null; }
+      function RememberMe() { return null; }
+      export function App() {
+        return <Routes>
+          <Route path="/admin" element={<Suspense fallback={<Loader />}><AdminPanel /></Suspense>} />
+          <Route
+            path="/protected"
+            element={
+              <RequireAuth>
+                <ProtectedPage />
+              </RequireAuth>
+            }
+          />
+          <Route path="/home" element={<PrivateRoot component={<HomePage />} />} />
+          <Route path="/login" element={<Suspense fallback={<Loader />}><AuthPage /></Suspense>} />
+          <Route path="/signin" element={<AuthPage type="login" rememberMe={<RememberMe />} />} />
+        </Routes>;
+      }
+    `, extension);
+    expect(result.bindings).toEqual([
+      // A `fallback` is shown while the page loads; it is not the page.
+      '/admin->AdminPanel',
+      // A page handed to a guard as a prop.
+      '/home->HomePage',
+      // `AuthPage` reads like a guard's name (`Auth…`); when every tag does, the innermost is the page.
+      '/login->AuthPage',
+      // Prettier writes a long element on lines of its own.
+      '/protected->ProtectedPage',
+      // Only a `component`, `element` or `page` prop hands over a page.
+      '/signin->AuthPage',
+    ]);
+  });
+
+  it('reads an index route only where its parent’s address is written down', async () => {
+    const result = await index(`
+      import { Routes, Route } from 'react-router-dom';
+      import { paths } from './paths';
+      function Navigation() { return null; }
+      function Home() { return null; }
+      function CategoriesPreview() { return null; }
+      function Category() { return null; }
+      function ListAgents() { return null; }
+      function ListWorkspaces() { return null; }
+      // Mounted at \`shop/*\` below: its index is the page at \`/shop\`, which its own <Routes> does not say.
+      function Shop() {
+        return <Routes>
+          <Route index element={<CategoriesPreview />} />
+          <Route path=":category" element={<Category />} />
+        </Routes>;
+      }
+      export function App() {
+        return <Routes>
+          <Route path="/" element={<Navigation />}>
+            <Route index element={<Home />} />
+            <Route path="shop/*" element={<Shop />} />
+            <Route path={paths.agents}>
+              <Route index element={<ListAgents />} />
+            </Route>
+            <Route path={"workspaces"}>
+              <Route index element={<ListWorkspaces />} />
+            </Route>
+          </Route>
+        </Routes>;
+      }
+    `, 'jsx');
+    expect(result.paths.filter((p) => p === '/')).toEqual(['/']);
+    expect(result.bindings).toContain('/->Home');
+    // Neither a component's own <Routes> nor a path the file does not spell out says where these are.
+    expect(result.bindings.filter((b) => /CategoriesPreview|ListAgents/.test(b))).toEqual([]);
+    // A path in braces is still written down.
+    expect(result.bindings).toContain('/workspaces->ListWorkspaces');
+  });
+
+  it.each(['tsx', 'jsx'])('reads an index route at the top of the router itself as `/` in %s', async (extension) => {
+    const result = await index(`
+      import { BrowserRouter, createBrowserRouter, createRoutesFromElements, Routes, Route } from 'react-router-dom';
+      function Home() { return null; }
+      function About() { return null; }
+      function Dashboard() { return null; }
+      export function App() {
+        return <BrowserRouter>
+          <Routes>
+            <Route index element={<Home />} />
+            <Route path="about" element={<About />} />
+          </Routes>
+        </BrowserRouter>;
+      }
+      export const router = createBrowserRouter(createRoutesFromElements(<Route index element={<Dashboard />} />));
+    `, extension);
+    expect(result).toEqual({ paths: ['/', '/', '/about'], bindings: ['/->Dashboard', '/->Home', '/about->About'] });
+  });
+
+  it('keeps a version 5 catch-all out, and reads a version 3 parent route as the layout around its children', async () => {
+    const result = await index(`
+      import { Router, Route, Switch } from 'react-router';
+      function App() { return null; }
+      function About() { return null; }
+      function NotFound() { return null; }
+      export const routes = (
+        <Router>
+          <Route path="/" component={App}>
+            <Route path="about" component={About} />
+          </Route>
+          <Switch>
+            <Route path="" component={NotFound} />
+            <Route component={NotFound} />
+          </Switch>
+        </Router>
+      );
+    `, 'jsx');
+    expect(result).toEqual({
+      // No child claims `/`, so App is the page there as well as the layout around `/about`.
+      paths: ['/', '/about'],
+      bindings: ['/->App', '/about->About', '/about~>App'],
     });
   });
 
@@ -593,3 +725,1033 @@ describe('react-router: route declaration boundaries (#1348)', () => {
     expect(result).toEqual({ paths: ['/child', '/shell'], bindings: ['/child->Child', '/shell->Shell'] });
   });
 });
+
+describe('react-router: v5 redirects and styled link wrappers', () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rr-wrappers-'));
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ name: 'app', dependencies: { react: '*', 'react-router-dom': '^5.0.0', 'styled-components': '*' } }),
+      // react-boilerplate: the header's links are a styled Link, default-exported.
+      'app/components/Header/HeaderLink.js': `import { Link } from 'react-router-dom';
+import styled from 'styled-components';
+
+export default styled(Link)\`
+  color: #41addd;
+\`;
+`,
+      'app/components/Header/index.js': `import React from 'react';
+import HeaderLink from './HeaderLink';
+
+export default function Header() {
+  return (
+    <nav>
+      <HeaderLink to="/">Home</HeaderLink>
+      <HeaderLink to="/features">Features</HeaderLink>
+    </nav>
+  );
+}
+`,
+      'app/components/Nav.js': `import React from 'react';
+import { NavLink } from 'react-router-dom';
+import styled from 'styled-components';
+
+const MenuLink = styled(NavLink)\`
+  padding: 4px;
+\`;
+
+export default function Nav() {
+  return <MenuLink to="/features">Features</MenuLink>;
+}
+`,
+      // takenote: a guard renders v5's <Redirect to>.
+      'app/router/PrivateRoute.js': `import React from 'react';
+import { Route, Redirect } from 'react-router-dom';
+
+export default function PrivateRoute({ component: Component, ...rest }) {
+  return <Route {...rest} render={(props) => (rest.isAuthenticated ? <Component {...props} /> : <Redirect to="/" />)} />;
+}
+`,
+      'app/containers/App.js': `import React from 'react';
+import { Switch, Route } from 'react-router-dom';
+import HomePage from './HomePage';
+import FeaturePage from './FeaturePage';
+
+export default function App() {
+  return (
+    <Switch>
+      <Route exact path="/" component={HomePage} />
+      <Route path="/features" component={FeaturePage} />
+    </Switch>
+  );
+}
+`,
+      'app/containers/HomePage.js': `import React from 'react';
+export default function HomePage() { return <h1>Home</h1>; }
+`,
+      'app/containers/FeaturePage.js': `import React from 'react';
+export default function FeaturePage() { return <h1>Features</h1>; }
+`,
+    };
+    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 });
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const navsFrom = (name: string) => {
+    const from = cg.getNodesByName(name).find((n) => n.kind === 'function' || n.kind === 'component')!;
+    return cg
+      .getOutgoingEdges(from.id)
+      .filter((e) => e.kind === 'navigates')
+      .map((e) => `${(e.metadata as Record<string, unknown>).navMethod} ${cg.getNode(e.target)!.name}`)
+      .sort();
+  };
+
+  it('a styled(Link) wrapper, imported or local, is a link', () => {
+    expect(navsFrom('Header')).toEqual(['link /', 'link /features']);
+    expect(navsFrom('Nav')).toEqual(['link /features']);
+  });
+
+  it('v5’s <Redirect to> navigates', () => {
+    expect(navsFrom('PrivateRoute')).toEqual(['redirect /']);
+  });
+});
+
+// =============================================================================
+// Route tables another file hands the router
+// =============================================================================
+
+function writeFiles(root: string, 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 indexProject(files: Record<string, string>): Promise<{ root: string; cg: CodeGraph }> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rr-tables-'));
+  writeFiles(root, files);
+  return { root, cg: await CodeGraph.init(root, { index: true }) };
+}
+
+/** `path -> Component` for what each route renders, `path ~> Layout` for each layout around it. */
+function routeBindings(cg: CodeGraph): string[] {
+  return cg.getNodesByKind('route').flatMap((r) => cg.getOutgoingEdges(r.id)
+    .filter((e) => e.kind === 'references')
+    .map((e) => `${r.name} ${(e.metadata as Record<string, unknown> | undefined)?.layout ? '~>' : '->'} ${cg.getNode(e.target)?.name}`))
+    .sort();
+}
+
+/** `Source -> /path` for every navigation into a route. */
+function navigations(cg: CodeGraph): string[] {
+  return cg.getNodesByKind('route').flatMap((r) => cg.getIncomingEdges(r.id)
+    .filter((e) => e.kind === 'navigates')
+    .map((e) => `${cg.getNode(e.source)?.name} -> ${r.name}`))
+    .sort();
+}
+
+const routeNames = (cg: CodeGraph): string[] => cg.getNodesByKind('route').map((r) => r.name).sort();
+
+const component = (name: string): string => `export function ${name}() {\n  return <div>${name}</div>;\n}\n`;
+
+/** A screen file whose component is its default export. */
+const screen = (name: string): string => `export default function ${name}() {\n  return <div>${name}</div>;\n}\n`;
+
+/** jasontaylordev/CleanArchitecture's ClientApp-React and the ASP.NET Core React template it comes from. */
+const ASPNET_TEMPLATE: Record<string, string> = {
+  'src/Web/ClientApp/package.json': JSON.stringify({ name: 'web', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+  'src/Web/ClientApp/src/AppRoutes.js': `import ApiAuthorzationRoutes from './components/api-authorization/ApiAuthorizationRoutes';
+import { Counter } from "./components/Counter";
+import { FetchData } from "./components/FetchData";
+import { Home } from "./components/Home";
+import { ProtectedRoute } from "./components/ProtectedRoute";
+import AdminWrapper from "./components/AdminWrapper";
+import { Users } from "./components/Users";
+
+const AppRoutes = [
+  {
+    index: true,
+    element: <Home />
+  },
+  {
+    path: '/counter',
+    element: <Counter />
+  },
+  {
+    path: '/fetch-data',
+    requireAuth: true,
+    element: <ProtectedRoute><FetchData /></ProtectedRoute>
+  },
+  {
+    path: 'admin/users',
+    element: <AdminWrapper><Users /></AdminWrapper>
+  },
+  ...ApiAuthorzationRoutes
+];
+
+export default AppRoutes;
+`,
+  'src/Web/ClientApp/src/components/api-authorization/ApiAuthorizationRoutes.js': `import { Profile } from './Profile';
+import { Login } from './Login';
+import { ApplicationPaths } from './ApiAuthorizationConstants';
+
+const ApiAuthorizationRoutes = [
+  {
+    path: '/authentication/profile',
+    element: <Profile />
+  },
+  {
+    path: ApplicationPaths.Login,
+    element: loginAction('login')
+  }
+];
+
+function loginAction(name) {
+  return <Login action={name}></Login>;
+}
+
+export default ApiAuthorizationRoutes;
+`,
+  'src/Web/ClientApp/src/components/api-authorization/ApiAuthorizationConstants.js':
+    "const prefix = '/authentication';\nexport const ApplicationPaths = {\n  Login: `${prefix}/login`,\n};\n",
+  'src/Web/ClientApp/src/App.js': `import React, { Component } from 'react';
+import { Route, Routes } from 'react-router-dom';
+import AppRoutes from './AppRoutes';
+import AuthorizeRoute from './components/api-authorization/AuthorizeRoute';
+import { Layout } from './components/Layout';
+
+export default class App extends Component {
+  static displayName = App.name;
+
+  render() {
+    return (
+      <Layout>
+        <Routes>
+          {AppRoutes.map((route, index) => {
+            const { element, requireAuth, ...rest } = route;
+            return <Route key={index} {...rest} element={requireAuth ? <AuthorizeRoute {...rest} element={element} /> : element} />;
+          })}
+        </Routes>
+      </Layout>
+    );
+  }
+}
+`,
+  'src/Web/ClientApp/src/components/NavMenu.js': `import { Link, NavLink, useNavigate } from 'react-router-dom';
+import { menu } from '../menu';
+
+export function NavMenu() {
+  const navigate = useNavigate();
+  const showProfile = () => {
+    navigate('/authentication/profile');
+  };
+  return (
+    <nav>
+      <Link to="/">Home</Link>
+      <Link to="/counter">Counter</Link>
+      <Link to="/fetch-data">Fetch data</Link>
+      <button onClick={showProfile}>Profile</button>
+      {menu.map((item) => <NavLink key={item.path} to={item.path}>{item.element}</NavLink>)}
+    </nav>
+  );
+}
+`,
+  // `{ path, element }` lists that are not route tables: a menu rendered as
+  // links, a list nothing renders, and a table mapped into a path it does not
+  // hold (`layout + path`).
+  'src/Web/ClientApp/src/menu.js': `import { HelpIcon, SettingsIcon } from './icons';
+export const menu = [
+  { path: '/help', element: <HelpIcon /> },
+  { path: '/settings', element: <SettingsIcon /> },
+];
+`,
+  'src/Web/ClientApp/src/breadcrumbs.js': `import { Crumb } from './icons';
+export const crumbs = [{ path: '/history', element: <Crumb /> }];
+`,
+  'src/Web/ClientApp/src/dashboard.js': `import { Route, Routes } from 'react-router-dom';
+import { Stats } from './icons';
+const dashboardRoutes = [{ path: '/stats', layout: '/admin', element: <Stats /> }];
+export function Dashboard() {
+  return <Routes>{dashboardRoutes.map((r) => <Route key={r.path} path={r.layout + r.path} element={r.element} />)}</Routes>;
+}
+`,
+  'src/Web/ClientApp/src/icons.js': component('HelpIcon') + component('SettingsIcon') + component('Crumb') + component('Stats'),
+  'src/Web/ClientApp/src/components/Home.js': component('Home'),
+  'src/Web/ClientApp/src/components/Counter.js': component('Counter'),
+  'src/Web/ClientApp/src/components/FetchData.js': component('FetchData'),
+  'src/Web/ClientApp/src/components/ProtectedRoute.js': 'export function ProtectedRoute({ children }) {\n  return children;\n}\n',
+  'src/Web/ClientApp/src/components/AdminWrapper.js': 'export default function AdminWrapper({ children }) {\n  return children;\n}\n',
+  'src/Web/ClientApp/src/components/Users.js': component('Users'),
+  'src/Web/ClientApp/src/components/Layout.js':
+    "import { NavMenu } from './NavMenu';\nexport function Layout({ children }) {\n  return <div><NavMenu />{children}</div>;\n}\n",
+  'src/Web/ClientApp/src/components/api-authorization/Profile.js': component('Profile'),
+  'src/Web/ClientApp/src/components/api-authorization/Login.js': component('Login'),
+  'src/Web/ClientApp/src/components/api-authorization/AuthorizeRoute.js':
+    'export default function AuthorizeRoute({ element }) {\n  return element;\n}\n',
+};
+
+describe('react-router: a route table another file maps into <Route> (the ASP.NET Core React template)', () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject(ASPNET_TEMPLATE));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('reads the table App.js spreads into <Route {...rest}>, and the table it spreads in turn', () => {
+    expect(routeBindings(cg)).toEqual([
+      // `index: true` at the top of the table is the app's `/`.
+      '/ -> Home',
+      // `<AdminWrapper><Users /></AdminWrapper>` and
+      // `<ProtectedRoute><FetchData /></ProtectedRoute>` render what they wrap.
+      '/admin/users -> Users',
+      '/authentication/profile -> Profile',
+      '/counter -> Counter',
+      '/fetch-data -> FetchData',
+    ]);
+    // An entry that renders a call's result names no component, so it is no route.
+    expect(routeNames(cg)).toEqual(['/', '/admin/users', '/authentication/profile', '/counter', '/fetch-data']);
+  });
+
+  it('keeps each route at the line of its own object in the table', () => {
+    const counter = cg.getNodesByKind('route').find((r) => r.name === '/counter')!;
+    expect(counter.filePath).toBe('src/Web/ClientApp/src/AppRoutes.js');
+    expect(counter.startLine).toBe(15);
+  });
+
+  it('makes no route of a menu, a list nothing hands the router, or a path the table does not hold', () => {
+    for (const p of ['/help', '/settings', '/history', '/stats', '/admin/stats']) expect(routeNames(cg)).not.toContain(p);
+  });
+
+  it('gives the navigation that names those routes somewhere to go', () => {
+    expect(navigations(cg)).toEqual([
+      'NavMenu -> /',
+      'NavMenu -> /counter',
+      'NavMenu -> /fetch-data',
+      'showProfile -> /authentication/profile',
+    ]);
+  });
+
+  it('lands on the Screens tab', async () => {
+    const screens = await buildScreens(cg, root);
+    expect(screens.routed).toBe(true);
+    expect(screens.screens.map((s) => s.path).sort()).toEqual(['/', '/admin/users', '/authentication/profile', '/counter', '/fetch-data']);
+  });
+});
+
+describe('react-router: a table handed to useRoutes from another file, an index route under a layout', () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject({
+      'package.json': JSON.stringify({ name: 'kit', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+      // A table written as a function of the login state, the way many admin kits write it.
+      'src/routes.jsx': `import { Navigate } from 'react-router-dom';
+import DashboardLayout from './layouts/DashboardLayout';
+import MainLayout from './layouts/MainLayout';
+import { Account, Dashboard, Landing, Login } from './pages';
+
+const routes = (isLoggedIn) => [
+  {
+    path: 'app',
+    element: isLoggedIn ? <DashboardLayout /> : <Navigate to="/login" />,
+    children: [
+      { path: 'dashboard', element: <Dashboard /> },
+      { path: 'account', element: <Account /> },
+    ],
+  },
+  {
+    path: '/',
+    element: <MainLayout />,
+    children: [
+      { index: true, element: <Landing /> },
+      { path: 'login', element: <Login /> },
+    ],
+  },
+];
+
+export default routes;
+`,
+      'src/App.jsx': `import { useRoutes } from 'react-router-dom';
+import routes from './routes';
+
+export default function App({ isLoggedIn }) {
+  return useRoutes(routes(isLoggedIn));
+}
+`,
+      'src/layouts/MainLayout.jsx': `import { Link, Outlet } from 'react-router-dom';
+export default function MainLayout() {
+  return <div><Link to="/app/dashboard">Dashboard</Link><Outlet /></div>;
+}
+`,
+      'src/layouts/DashboardLayout.jsx': `import { Outlet } from 'react-router-dom';
+export default function DashboardLayout() {
+  return <Outlet />;
+}
+`,
+      'src/pages.jsx': `import { useNavigate } from 'react-router-dom';
+export function Dashboard() { return <div>Dashboard</div>; }
+export function Account() { return <div>Account</div>; }
+export function Landing() { return <div>Landing</div>; }
+export function Login() {
+  const navigate = useNavigate();
+  const onSubmit = () => navigate('/app/account');
+  return <form onSubmit={onSubmit} />;
+}
+`,
+    }));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('reads the table the function returns, nested paths composed', () => {
+    expect(routeBindings(cg)).toEqual([
+      // The index route is the page at `/`; MainLayout is the layout around it, not a second `/`.
+      '/ -> Landing',
+      '/ ~> MainLayout',
+      // `app`'s element is a choice made at runtime: a path to sit under, no layout.
+      '/app/account -> Account',
+      '/app/dashboard -> Dashboard',
+      '/login -> Login',
+      '/login ~> MainLayout',
+    ]);
+  });
+
+  it("draws a layout's links on every screen inside it", async () => {
+    expect(navigations(cg)).toEqual([
+      'MainLayout -> /app/dashboard',
+      'onSubmit -> /app/account',
+      // The table's own guard: `isLoggedIn ? <DashboardLayout /> : <Navigate to="/login" />`.
+      'routes -> /login',
+    ]);
+    const screens = await buildScreens(cg, root);
+    expect(screens.routed).toBe(true);
+    const at = (p: string) => screens.screens.find((s) => s.path === p)!.id;
+    for (const from of ['/', '/login']) {
+      expect(screens.links.find((l) => l.from === at(from) && l.to === at('/app/dashboard'))).toBeDefined();
+    }
+    expect(screens.links.find((l) => l.from === at('/login') && l.to === at('/app/account'))).toBeDefined();
+  });
+});
+
+describe("react-router: route objects in their own files, handed to createBrowserRouter (codedthemes' admin templates)", () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject({
+      'package.json': JSON.stringify({ name: 'berry', dependencies: { react: '^18', 'react-router-dom': '^7' } }),
+      'src/routes/index.jsx': `import { createBrowserRouter } from 'react-router-dom';
+
+// routes
+import AuthenticationRoutes from './AuthenticationRoutes';
+import MainRoutes from './MainRoutes';
+
+const router = createBrowserRouter([MainRoutes, AuthenticationRoutes], {
+  basename: import.meta.env.VITE_APP_BASE_NAME
+});
+
+export default router;
+`,
+      'src/routes/MainRoutes.jsx': `import { lazy } from 'react';
+import MainLayout from '../layout/MainLayout';
+import Loadable from '../ui-component/Loadable';
+
+const DashboardDefault = Loadable(lazy(() => import('../views/DashboardDefault')));
+// An import only the app's own build resolves (\`baseUrl\`).
+const SamplePage = Loadable(lazy(() => import('views/sample-page')));
+
+const MainRoutes = {
+  path: '/',
+  element: <MainLayout />,
+  children: [
+    {
+      path: '/',
+      element: <DashboardDefault />
+    },
+    {
+      path: 'dashboard',
+      children: [
+        {
+          path: 'default',
+          element: <DashboardDefault />
+        }
+      ]
+    },
+    {
+      path: '/sample-page',
+      element: <SamplePage />
+    }
+  ]
+};
+
+export default MainRoutes;
+`,
+      'src/routes/AuthenticationRoutes.jsx': `import MinimalLayout from '../layout/MinimalLayout';
+import LoginPage from '../views/LoginPage';
+
+const AuthenticationRoutes = {
+  path: '/',
+  element: <MinimalLayout />,
+  children: [
+    {
+      path: '/pages/login',
+      element: <LoginPage />
+    }
+  ]
+};
+
+export default AuthenticationRoutes;
+`,
+      'src/layout/MainLayout.jsx': 'export default function MainLayout() {\n  return <main />;\n}\n',
+      'src/layout/MinimalLayout.jsx': 'export default function MinimalLayout() {\n  return <main />;\n}\n',
+      'src/views/DashboardDefault.jsx': 'export default function DashboardDefault() {\n  return <div />;\n}\n',
+      'src/views/LoginPage.jsx': 'export default function LoginPage() {\n  return <div />;\n}\n',
+      'src/ui-component/Loadable.jsx': 'export default function Loadable(Component) {\n  return (props) => <Component {...props} />;\n}\n',
+      // The repository's other app, with pages of the same names.
+      'next/package.json': JSON.stringify({ name: 'berry-next', dependencies: { next: '^15', react: '^18' } }),
+      'next/src/views/sample-page.jsx': 'export default function SamplePage() {\n  return <div />;\n}\n',
+      'next/src/views/default.jsx': 'export default function DashboardDefault() {\n  return <div />;\n}\n',
+    }));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('reads each route object the array names, its children under its path', () => {
+    expect(routeBindings(cg)).toEqual([
+      // MainRoutes' `/` child claims its layout's address.
+      '/ -> DashboardDefault',
+      '/ ~> MainLayout',
+      // No child of the login layout claims `/`, so it is a page there of its
+      // own — the rule Angular and Vue routes follow.
+      '/ -> MinimalLayout',
+      '/dashboard/default -> DashboardDefault',
+      '/dashboard/default ~> MainLayout',
+      '/pages/login -> LoginPage',
+      '/pages/login ~> MinimalLayout',
+      '/sample-page -> SamplePage',
+      '/sample-page ~> MainLayout',
+    ].sort());
+  });
+
+  it('binds a page the route file loads lazily to the module it loads, and never to a same-named page of another app', () => {
+    const rendered = (p: string): string[] => cg.getNodesByKind('route').filter((r) => r.name === p).flatMap((r) => cg.getOutgoingEdges(r.id)
+      .filter((e) => e.kind === 'references' && !(e.metadata as Record<string, unknown> | undefined)?.layout)
+      .map((e) => { const n = cg.getNode(e.target)!; return `${n.kind} ${n.name} ${n.filePath}`; }));
+    expect(rendered('/dashboard/default')).toEqual(['function DashboardDefault src/views/DashboardDefault.jsx']);
+    // Its module is out of reach, so the page is the declaration itself.
+    expect(rendered('/sample-page')).toEqual(['constant SamplePage src/routes/MainRoutes.jsx']);
+  });
+});
+
+describe('react-router: a table mapped inside <Route path> in the same file', () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject({
+      'ClientApp/package.json': JSON.stringify({ name: 'client', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+      'ClientApp/src/routes.js': `import { Routes, Route } from 'react-router-dom';
+import AdminLayout from './layouts/admin';
+import { adminRoutes } from './adminRoutes';
+import DashboardLayout from './layouts/dashboard';
+import DashboardApp from './pages/DashboardApp';
+import LandingPage from './pages/LandingPage';
+import TicketDetail from './pages/TicketDetail';
+
+const DashboardRoutes = [
+    {
+        path: 'app',
+        requireAuth: true,
+        element: <DashboardApp/>
+    },
+    {
+        path: 'tickets/:id',
+        requireAuth: true,
+        element: <TicketDetail/>
+    }
+];
+
+export default function Router() {
+    return (
+        <Routes>
+            <Route path="landing" element={<LandingPage/>}/>
+            <Route path="/dashboard" element={<DashboardLayout/>}>
+                {DashboardRoutes.map((route, index) => {
+                    const {element, requireAuth, ...rest} = route;
+                    return <Route key={index} {...rest} element={element}/>;
+                })}
+            </Route>
+            <Route path="/admin" element={<AdminLayout/>}>
+                {adminRoutes.map((route) => <Route key={route.path} {...route}/>)}
+            </Route>
+        </Routes>
+    );
+}
+`,
+      'ClientApp/src/adminRoutes.js': `import Reports from './pages/Reports';
+
+export const adminRoutes = [{ path: 'reports', element: <Reports/> }];
+`,
+      'ClientApp/src/layouts/dashboard.js': 'export default function DashboardLayout() {\n  return <div />;\n}\n',
+      'ClientApp/src/layouts/admin.js': 'export default function AdminLayout() {\n  return <div />;\n}\n',
+      'ClientApp/src/pages/DashboardApp.js': 'export default function DashboardApp() {\n  return <div />;\n}\n',
+      'ClientApp/src/pages/LandingPage.js': 'export default function LandingPage() {\n  return <div />;\n}\n',
+      'ClientApp/src/pages/TicketDetail.js': 'export default function TicketDetail() {\n  return <div />;\n}\n',
+      'ClientApp/src/pages/Reports.js': 'export default function Reports() {\n  return <div />;\n}\n',
+    }));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("composes the table's relative paths onto the <Route path> it is mapped inside, and renders them inside its element", () => {
+    expect(routeBindings(cg)).toEqual([
+      '/admin -> AdminLayout',
+      // A table written in another file keeps its routes there, where a layout
+      // named in this file would be looked up: they get no layout edge.
+      '/admin/reports -> Reports',
+      '/dashboard -> DashboardLayout',
+      '/dashboard/app -> DashboardApp',
+      '/dashboard/app ~> DashboardLayout',
+      '/dashboard/tickets/:id -> TicketDetail',
+      '/dashboard/tickets/:id ~> DashboardLayout',
+      '/landing -> LandingPage',
+    ]);
+  });
+});
+
+describe('react-router: a route table as the files around it change', () => {
+  let root: string;
+  let cg: CodeGraph;
+  const app = (body: string) => `import { Route, Routes } from 'react-router-dom';
+import AppRoutes from './AppRoutes';
+import { Counter } from './Counter';
+
+export default function App() {
+  return (
+    <Routes>
+      ${body}
+    </Routes>
+  );
+}
+`;
+  const MAPPED = app('{AppRoutes.map(({ element, ...rest }, index) => <Route key={index} {...rest} element={element} />)}');
+  const table = (extra: string) => `import { Counter } from './Counter';
+import { Home } from './Home';
+import { FetchData } from './FetchData';
+
+const AppRoutes = [${extra}
+  { index: true, element: <Home /> },
+  { path: '/counter', element: <Counter /> },
+];
+
+export default AppRoutes;
+`;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject({
+      'package.json': JSON.stringify({ name: 'app', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+      'src/AppRoutes.js': table(''),
+      'src/App.js': MAPPED,
+      'src/Home.js': component('Home'),
+      'src/Counter.js': component('Counter'),
+      'src/FetchData.js': component('FetchData'),
+      'src/NavMenu.js': `import { Link, useNavigate } from 'react-router-dom';
+export function NavMenu() {
+  const navigate = useNavigate();
+  const goHome = () => navigate('/');
+  return <nav><button onClick={goHome}>Home</button><Link to="/counter">Counter</Link></nav>;
+}
+`,
+    }));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('starts with the table read', () => {
+    expect(routeNames(cg)).toEqual(['/', '/counter']);
+    expect(navigations(cg)).toEqual(['NavMenu -> /counter', 'goHome -> /']);
+  });
+
+  it('an edit to the table moves its routes, and what navigated to them still does', async () => {
+    writeFiles(root, { 'src/AppRoutes.js': table("\n  { path: '/fetch-data', element: <FetchData /> },") });
+    await cg.sync();
+    expect(routeBindings(cg)).toEqual(['/ -> Home', '/counter -> Counter', '/fetch-data -> FetchData']);
+    expect(navigations(cg)).toEqual(['NavMenu -> /counter', 'goHome -> /']);
+  });
+
+  it('a file that stops handing the table over takes its routes with it, and putting it back brings them back', async () => {
+    writeFiles(root, { 'src/App.js': app('<Route path="/static" element={<Counter />} />') });
+    await cg.sync();
+    expect(routeNames(cg)).toEqual(['/static']);
+    writeFiles(root, { 'src/App.js': MAPPED });
+    await cg.sync();
+    expect(routeNames(cg)).toEqual(['/', '/counter', '/fetch-data']);
+    // `navigate('/')` failed while `/` was gone; the routes coming back retry it.
+    expect(navigations(cg)).toEqual(['NavMenu -> /counter', 'goHome -> /']);
+  });
+
+  it('deleting that file is a change too', async () => {
+    fs.rmSync(path.join(root, 'src/App.js'));
+    await cg.sync();
+    expect(routeNames(cg)).toEqual([]);
+  });
+});
+
+// =============================================================================
+// JSX index routes, and the <Route element> around other routes
+// =============================================================================
+
+/** React Router 6's own examples: a layout route at `/`, an index route inside it. */
+const JSX_LAYOUTS: Record<string, string> = {
+  'package.json': JSON.stringify({ name: 'app', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+  'src/App.jsx': `import { Routes, Route } from 'react-router-dom';
+import Layout from './Layout';
+import DashboardLayout from './DashboardLayout';
+import AdminLayout from './AdminLayout';
+import RequireAuth from './RequireAuth';
+import { Home, About, Login, DashboardHome, Stats, Account, Settings, NoMatch, Users } from './pages';
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/" element={<Layout />}>
+        <Route index element={<Home />} />
+        <Route path="about" element={<About />} />
+        <Route path="login" element={<Login />} />
+        <Route path="dashboard" element={<DashboardLayout />}>
+          <Route index element={<DashboardHome />} />
+          <Route path="stats" element={<Stats />} />
+        </Route>
+        <Route element={<RequireAuth />}>
+          <Route path="account" element={<Account />} />
+        </Route>
+        <Route path="settings">
+          <Route index element={<Settings />} />
+        </Route>
+        <Route path="*" element={<NoMatch />} />
+      </Route>
+      <Route path="/admin" element={<AdminLayout />}>
+        <Route path="users" element={<Users />} />
+      </Route>
+    </Routes>
+  );
+}
+`,
+  'src/Layout.jsx': `import { Link, Outlet } from 'react-router-dom';
+export default function Layout() {
+  return (
+    <div>
+      <nav>
+        <Link to="/">Home</Link>
+        <Link to="/about">About</Link>
+        <Link to="/dashboard">Dashboard</Link>
+      </nav>
+      <Outlet />
+    </div>
+  );
+}
+`,
+  'src/DashboardLayout.jsx': `import { Link, Outlet } from 'react-router-dom';
+export default function DashboardLayout() {
+  return <section><Link to="/dashboard/stats">Stats</Link><Outlet /></section>;
+}
+`,
+  'src/AdminLayout.jsx': `import { Link, Outlet } from 'react-router-dom';
+export default function AdminLayout() {
+  return <div><Link to="/admin/users">Users</Link><Outlet /></div>;
+}
+`,
+  'src/RequireAuth.jsx': `import { Navigate, Outlet } from 'react-router-dom';
+export default function RequireAuth({ user }) {
+  return user ? <Outlet /> : <Navigate to="/login" replace />;
+}
+`,
+  'src/pages.jsx': `import { useNavigate } from 'react-router-dom';
+export function Home() { return <h1>Home</h1>; }
+export function About() { return <h1>About</h1>; }
+export function Login() { return <h1>Login</h1>; }
+export function DashboardHome() { return <h1>Dashboard</h1>; }
+export function Stats() { return <h1>Stats</h1>; }
+export function Account() {
+  const navigate = useNavigate();
+  const signOut = () => navigate('/');
+  return <button onClick={signOut}>Sign out</button>;
+}
+export function Settings() { return <h1>Settings</h1>; }
+export function NoMatch() { return <h1>Nothing here</h1>; }
+export function Users() { return <h1>Users</h1>; }
+`,
+};
+
+describe('react-router: a JSX index route is the page at its parent’s address, and the <Route element> around it the layout', () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject(JSX_LAYOUTS));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('binds each address to its page, inside every layout around it', () => {
+    expect(routeBindings(cg)).toEqual([
+      '/ -> Home',
+      '/ ~> Layout',
+      '/* -> NoMatch',
+      '/* ~> Layout',
+      '/about -> About',
+      '/about ~> Layout',
+      // A `<Route element>` with no path is a layout at no address of its own.
+      '/account -> Account',
+      '/account ~> Layout',
+      '/account ~> RequireAuth',
+      // No child claims `/admin`, so AdminLayout is the page there as well.
+      '/admin -> AdminLayout',
+      '/admin/users -> Users',
+      '/admin/users ~> AdminLayout',
+      '/dashboard -> DashboardHome',
+      '/dashboard ~> DashboardLayout',
+      '/dashboard ~> Layout',
+      '/dashboard/stats -> Stats',
+      '/dashboard/stats ~> DashboardLayout',
+      '/dashboard/stats ~> Layout',
+      '/login -> Login',
+      '/login ~> Layout',
+      // `<Route path="settings">` renders nothing: it only groups its index route.
+      '/settings -> Settings',
+      '/settings ~> Layout',
+    ].sort());
+  });
+
+  it('puts one route at each address', () => {
+    expect(routeNames(cg)).toEqual(['/', '/*', '/about', '/account', '/admin', '/admin/users', '/dashboard', '/dashboard/stats', '/login', '/settings']);
+    const home = cg.getNodesByKind('route').find((r) => r.name === '/')!;
+    expect(home.startLine).toBe(12);
+  });
+
+  it('lands a navigation to a layout’s address on the page there', () => {
+    expect(navigations(cg)).toEqual([
+      'AdminLayout -> /admin/users',
+      'DashboardLayout -> /dashboard/stats',
+      'Layout -> /',
+      'Layout -> /about',
+      'Layout -> /dashboard',
+      'RequireAuth -> /login',
+      'signOut -> /',
+    ]);
+  });
+
+  it('draws a layout’s links on every screen inside it, and only there', async () => {
+    const screens = await buildScreens(cg, root);
+    expect(screens.routed).toBe(true);
+    const at = (p: string) => screens.screens.find((s) => s.path === p)!.id;
+    const linked = (from: string, to: string) => screens.links.some((l) => l.from === at(from) && l.to === at(to));
+    // Layout's nav bar is on every page it wraps, the deepest included.
+    for (const from of ['/', '/about', '/login', '/dashboard', '/dashboard/stats', '/account', '/settings']) {
+      expect(linked(from, '/about')).toBe(true);
+    }
+    expect(linked('/dashboard/stats', '/dashboard')).toBe(true);
+    // The guard's redirect happens on the page it guards.
+    expect(linked('/account', '/login')).toBe(true);
+    expect(linked('/about', '/login')).toBe(false);
+    // The admin pages are not inside Layout.
+    expect(linked('/admin/users', '/about')).toBe(false);
+    expect(linked('/admin', '/admin/users')).toBe(true);
+  });
+});
+
+describe('react-router: createRoutesFromElements with an index route and guards at path="" (proshop-v2)', () => {
+  let root: string;
+  let cg: CodeGraph;
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject({
+      'package.json': JSON.stringify({ name: 'proshop', private: true }),
+      'frontend/package.json': JSON.stringify({ name: 'frontend', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+      'frontend/src/index.js': `import { createBrowserRouter, createRoutesFromElements, Route, RouterProvider } from 'react-router-dom';
+import App from './App';
+import PrivateRoute from './components/PrivateRoute';
+import AdminRoute from './components/AdminRoute';
+import HomeScreen from './screens/HomeScreen';
+import CartScreen from './screens/CartScreen';
+import LoginScreen from './screens/LoginScreen';
+import ShippingScreen from './screens/ShippingScreen';
+import OrderListScreen from './screens/admin/OrderListScreen';
+
+const router = createBrowserRouter(
+  createRoutesFromElements(
+    <Route path='/' element={<App />}>
+      <Route index={true} path='/' element={<HomeScreen />} />
+      <Route path='/cart' element={<CartScreen />} />
+      <Route path='/login' element={<LoginScreen />} />
+      {/* Registered users */}
+      <Route path='' element={<PrivateRoute />}>
+        <Route path='/shipping' element={<ShippingScreen />} />
+      </Route>
+      {/* Admin users */}
+      <Route path='' element={<AdminRoute />}>
+        <Route path='/admin/orderlist' element={<OrderListScreen />} />
+      </Route>
+    </Route>
+  )
+);
+
+export default function Root() {
+  return <RouterProvider router={router} />;
+}
+`,
+      'frontend/src/App.js': `import { Outlet } from 'react-router-dom';
+import Header from './components/Header';
+export default function App() {
+  return (
+    <>
+      <Header />
+      <main><Outlet /></main>
+    </>
+  );
+}
+`,
+      'frontend/src/components/Header.js': `import { Link } from 'react-router-dom';
+export default function Header() {
+  return <header><Link to='/cart'>Cart</Link></header>;
+}
+`,
+      'frontend/src/components/PrivateRoute.js': `import { Navigate, Outlet } from 'react-router-dom';
+export default function PrivateRoute({ userInfo }) {
+  return userInfo ? <Outlet /> : <Navigate to='/login' replace />;
+}
+`,
+      'frontend/src/components/AdminRoute.js': `import { Navigate, Outlet } from 'react-router-dom';
+export default function AdminRoute({ userInfo }) {
+  return userInfo && userInfo.isAdmin ? <Outlet /> : <Navigate to='/login' replace />;
+}
+`,
+      'frontend/src/screens/HomeScreen.js': screen('HomeScreen'),
+      'frontend/src/screens/CartScreen.js': screen('CartScreen'),
+      'frontend/src/screens/LoginScreen.js': screen('LoginScreen'),
+      'frontend/src/screens/ShippingScreen.js': screen('ShippingScreen'),
+      'frontend/src/screens/admin/OrderListScreen.js': screen('OrderListScreen'),
+    }));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('makes HomeScreen the page at `/` and App the layout around every screen, the guards around theirs', () => {
+    expect(routeBindings(cg)).toEqual([
+      '/ -> HomeScreen',
+      '/ ~> App',
+      '/admin/orderlist -> OrderListScreen',
+      '/admin/orderlist ~> AdminRoute',
+      '/admin/orderlist ~> App',
+      '/cart -> CartScreen',
+      '/cart ~> App',
+      '/login -> LoginScreen',
+      '/login ~> App',
+      '/shipping -> ShippingScreen',
+      '/shipping ~> App',
+      '/shipping ~> PrivateRoute',
+    ]);
+    // Neither App nor a guard is a second page at `/`.
+    expect(routeNames(cg)).toEqual(['/', '/admin/orderlist', '/cart', '/login', '/shipping']);
+  });
+
+  it('draws the header’s link from every screen, and a guard’s redirect from the screens it guards', async () => {
+    const screens = await buildScreens(cg, root);
+    const at = (p: string) => screens.screens.find((s) => s.path === p)!.id;
+    const linked = (from: string, to: string) => screens.links.some((l) => l.from === at(from) && l.to === at(to));
+    for (const from of ['/', '/login', '/shipping', '/admin/orderlist']) expect(linked(from, '/cart')).toBe(true);
+    expect(linked('/shipping', '/login')).toBe(true);
+    expect(linked('/admin/orderlist', '/login')).toBe(true);
+    expect(linked('/cart', '/login')).toBe(false);
+  });
+});
+
+describe('react-router: JSX index routes as the route file changes', () => {
+  let root: string;
+  let cg: CodeGraph;
+  const app = (index: boolean) => `import { Routes, Route } from 'react-router-dom';
+import Layout from './Layout';
+import { Home, About } from './pages';
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/" element={<Layout />}>${index ? '\n        <Route index element={<Home />} />' : ''}
+        <Route path="about" element={<About />} />
+      </Route>
+    </Routes>
+  );
+}
+`;
+  const files = (index: boolean): Record<string, string> => ({
+    'package.json': JSON.stringify({ name: 'app', dependencies: { react: '^18', 'react-router-dom': '^6' } }),
+    'src/App.jsx': app(index),
+    'src/Layout.jsx': `import { Link, Outlet } from 'react-router-dom';
+export default function Layout() {
+  return <div><Link to="/about">About</Link><Outlet /></div>;
+}
+`,
+    'src/pages.jsx': `import { useNavigate } from 'react-router-dom';
+export function Home() { return <h1>Home</h1>; }
+export function About() {
+  const navigate = useNavigate();
+  const goHome = () => navigate('/');
+  return <button onClick={goHome}>Home</button>;
+}
+`,
+  });
+  /** What a fresh index of the same files says. */
+  const fresh = async (index: boolean): Promise<{ bindings: string[]; navigations: string[] }> => {
+    const project = await indexProject(files(index));
+    try {
+      return { bindings: routeBindings(project.cg), navigations: navigations(project.cg) };
+    } finally {
+      project.cg.close();
+      fs.rmSync(project.root, { recursive: true, force: true });
+    }
+  };
+  beforeAll(async () => {
+    ({ root, cg } = await indexProject(files(false)));
+  });
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('starts with the layout as the page at its own address', () => {
+    expect(routeBindings(cg)).toEqual(['/ -> Layout', '/about -> About', '/about ~> Layout']);
+    expect(navigations(cg)).toEqual(['Layout -> /about', 'goHome -> /']);
+  });
+
+  // Each also indexes the same files afresh, to compare with.
+  it('an index route added takes the address, and what navigated there follows it', async () => {
+    writeFiles(root, { 'src/App.jsx': app(true) });
+    await cg.sync();
+    expect(routeBindings(cg)).toEqual(['/ -> Home', '/ ~> Layout', '/about -> About', '/about ~> Layout']);
+    expect({ bindings: routeBindings(cg), navigations: navigations(cg) }).toEqual(await fresh(true));
+  }, 60_000);
+
+  it('taking it away gives the address back to the layout', async () => {
+    writeFiles(root, { 'src/App.jsx': app(false) });
+    await cg.sync();
+    expect({ bindings: routeBindings(cg), navigations: navigations(cg) }).toEqual(await fresh(false));
+  }, 60_000);
+});
diff --git a/__tests__/require-default.test.ts b/__tests__/require-default.test.ts
new file mode 100644
index 0000000000..a908e35965
--- /dev/null
+++ b/__tests__/require-default.test.ts
@@ -0,0 +1,243 @@
+/**
+ * `require('./x').default` reads the `default` PROPERTY of the module's
+ * exports, and so does `const { default: X } = require('./x')`. The import
+ * mapping records it as a named import of `default`, which is right for a
+ * CommonJS module that sets the property by name (`exports.default = fn`, or
+ * the dual `module.exports = X; module.exports.default = X`). A module
+ * written as an ES module and compiled to CommonJS sets it to its default
+ * export, `export default class Foo`, which is no named export: bitwarden's
+ * desktop app loads its macOS biometrics service with
+ * `require("./os-biometrics-mac.service").default` and `new`s it, and that
+ * `instantiates` reference stayed unresolved. The named property is still
+ * looked up first; the ES module's default export answers only when there is
+ * no such property, and only in the module asked for.
+ */
+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';
+import type { Edge } from '../src/types';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-require-default-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'desktop', devDependencies: { svelte: '^4' } }),
+    // bitwarden's shape: an ES module with an unexported helper above its
+    // default-exported class, loaded with `require(...).default` on one
+    // platform only.
+    'src/biometrics/os-biometrics.service.ts': `export interface OsBiometricService {
+  enrollPersistent(userId: string): Promise<string>;
+}
+`,
+    'src/biometrics/os-biometrics-mac.service.ts': `import { OsBiometricService } from './os-biometrics.service';
+
+function getLookupKeyForUser(userId: string): string {
+  return \`\${userId}_user_biometric\`;
+}
+
+export default class OsBiometricsServiceMac implements OsBiometricService {
+  async enrollPersistent(userId: string): Promise<string> {
+    return getLookupKeyForUser(userId);
+  }
+}
+`,
+    'src/biometrics/main-biometrics.service.ts': `import { OsBiometricService } from './os-biometrics.service';
+
+export class MainBiometricsService {
+  private osBiometricsService: OsBiometricService | undefined;
+
+  constructor(platform: string) {
+    if (platform === 'darwin') {
+      // eslint-disable-next-line
+      const OsBiometricsServiceMac = require('./os-biometrics-mac.service').default;
+      this.osBiometricsService = new OsBiometricsServiceMac();
+    }
+  }
+}
+`,
+    'src/biometrics/os-biometrics-mac.service.spec.ts': `describe('OsBiometricsServiceMac', () => {
+  it('enrolls in an isolated module registry', async () => {
+    const { default: ServiceCtor } = require('./os-biometrics-mac.service');
+    const isolated = new ServiceCtor();
+    await isolated.enrollPersistent('user');
+  });
+});
+`,
+    // A single-file component is its module's default export.
+    'src/App.svelte': `<script>
+  export let name = 'world';
+</script>
+
+<h1>Hello {name}!</h1>
+`,
+    'src/main.js': `const App = require('./App.svelte').default;
+
+const app = new App({ target: document.body });
+
+module.exports = app;
+`,
+    // CommonJS modules that set the property by name.
+    'lib/format.js': `'use strict';
+
+exports.pad = function (value) {
+  return String(value).padStart(2, '0');
+};
+
+function formatDate(date) {
+  return exports.pad(date.getDate());
+}
+
+exports.default = formatDate;
+`,
+    'lib/server.js': `'use strict';
+
+function createServer(options) {
+  return { options };
+}
+
+module.exports = createServer;
+module.exports.default = createServer;
+module.exports.createServer = createServer;
+`,
+    // A CommonJS module without the property: its exports are no default.
+    'lib/plain.js': `'use strict';
+
+exports.first = function () {
+  return 1;
+};
+
+exports.second = () => 2;
+`,
+    // `export * from` forwards every export but the default.
+    'src/widgets/Dial.ts': `export const DIAL_SIZE = 3;
+
+export default class Dial {
+  size = DIAL_SIZE;
+}
+`,
+    'src/widgets/index.ts': `export * from './Dial';
+`,
+    'src/dashboard.ts': `export function mountDashboard(): unknown {
+  const Widget = require('./widgets').default;
+  return new Widget();
+}
+`,
+    'lib/app.js': `'use strict';
+
+const format = require('./format').default;
+const build = require('./server').default;
+const { default: fastify } = require('./server');
+const plain = require('./plain').default;
+
+function start() {
+  const server = build({ port: 3000 });
+  fastify({ logger: true });
+  plain();
+  return format(new Date()) + server.options.port;
+}
+
+module.exports = start;
+`,
+    // Python has no default export: `default` is an attribute's name.
+    'py/__init__.py': '',
+    'py/mod.py': `def first():
+    return 1
+`,
+    'py/use.py': `from .mod import default
+
+
+def run():
+    return default()
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const node = (file: string, name: string) => {
+  const found = cg.getNodesInFile(file).find((n) => n.name === name && n.kind !== 'import');
+  expect(found, `${file}: ${name}`).toBeDefined();
+  return found!;
+};
+
+/** The edges into `target`, as `kind source-file resolvedBy`. */
+const into = (target: { id: string }, kinds: Edge['kind'][]) =>
+  cg
+    .getIncomingEdges(target.id)
+    .filter((e) => kinds.includes(e.kind))
+    .map((e) => `${e.kind} ${cg.getNode(e.source)!.filePath} ${(e.metadata as { resolvedBy?: string }).resolvedBy}`)
+    .sort();
+
+/** The call and instantiation edges out of a file's nodes, as `kind target-file:target-name`. */
+const outOf = (file: string) =>
+  cg
+    .getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id))
+    .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+    .map((e) => {
+      const target = cg.getNode(e.target)!;
+      return `${e.kind} ${target.filePath}:${target.name}`;
+    })
+    .sort();
+
+describe('`require(…).default` of an ES module', () => {
+  it('is the module’s default export, as `.default` and as `{ default: X }`', () => {
+    expect(into(node('src/biometrics/os-biometrics-mac.service.ts', 'OsBiometricsServiceMac'), ['instantiates'])).toEqual([
+      'instantiates src/biometrics/main-biometrics.service.ts import',
+      'instantiates src/biometrics/os-biometrics-mac.service.spec.ts import',
+    ]);
+  });
+
+  it('is the component a single-file component file is', () => {
+    expect(into(node('src/App.svelte', 'App'), ['instantiates'])).toEqual(['instantiates src/main.js import']);
+  });
+});
+
+describe('`require(…).default` of a CommonJS module', () => {
+  it('is what `exports.default` names, not the module’s first export', () => {
+    expect(outOf('lib/app.js')).toContain('calls lib/format.js:formatDate');
+    expect(into(node('lib/format.js', 'pad'), ['calls'])).toEqual([]);
+  });
+
+  it('is X in the dual export `module.exports = X; module.exports.default = X`', () => {
+    expect(into(node('lib/server.js', 'createServer'), ['calls'])).toEqual([
+      'calls lib/app.js import',
+      'calls lib/app.js import',
+    ]);
+  });
+
+  it('is nothing when the module sets no `default`: its exports are no default', () => {
+    expect(into(node('lib/plain.js', 'first'), ['calls'])).toEqual([]);
+    expect(into(node('lib/plain.js', 'second'), ['calls'])).toEqual([]);
+  });
+});
+
+describe('what the fallback leaves alone', () => {
+  it('a default behind `export * from`, which forwards none', () => {
+    expect(into(node('src/widgets/Dial.ts', 'Dial'), ['instantiates', 'calls'])).toEqual([]);
+    expect(outOf('src/dashboard.ts')).toEqual([]);
+  });
+
+  it('every other require binding, which reaches only what it names', () => {
+    expect(outOf('lib/app.js').filter((e) => !e.includes(' lib/app.js:'))).toEqual([
+      'calls lib/format.js:formatDate',
+      'calls lib/server.js:createServer',
+      'calls lib/server.js:createServer',
+    ]);
+  });
+
+  it('Python’s `from .mod import default`, an attribute of that name', () => {
+    expect(into(node('py/mod.py', 'first'), ['calls'])).toEqual([]);
+  });
+});
diff --git a/__tests__/resolution.test.ts b/__tests__/resolution.test.ts
index 0fb2a1bfd5..14b5198f47 100644
--- a/__tests__/resolution.test.ts
+++ b/__tests__/resolution.test.ts
@@ -648,6 +648,28 @@ from ..services import auth_service
       expect(mappings.some((m) => m.localName === 'helper')).toBe(true);
       expect(mappings.some((m) => m.localName === 'User')).toBe(true);
     });
+
+    it('should extract parenthesized Python from-imports', () => {
+      const content = `
+from store.base import (
+    Base,
+    helper as h,  # a comment, with a comma and a call()
+)
+"""
+from docstring import NotAnImport
+"""
+from store.rows import (Row, Col)
+`;
+
+      const mappings = extractImportMappings('src/main.py', content, 'python');
+
+      expect(mappings.map((m) => [m.localName, m.exportedName, m.source])).toEqual([
+        ['Base', 'Base', 'store.base'],
+        ['h', 'helper', 'store.base'],
+        ['Row', 'Row', 'store.rows'],
+        ['Col', 'Col', 'store.rows'],
+      ]);
+    });
   });
 
   describe('JVM FQN Import Resolution', () => {
@@ -932,6 +954,8 @@ from ..services import auth_service
       const frameworks = detectFrameworks(context);
       const reactResolver = frameworks.find((f) => f.name === 'react');
 
+      // In a JS/TS module another file's hook comes through an import (the
+      // import resolver's), never by name: App.tsx imports nothing here.
       const ref = {
         fromNodeId: 'component:src/App.tsx:App:1',
         referenceName: 'useAuth',
@@ -941,10 +965,11 @@ from ..services import auth_service
         filePath: 'src/App.tsx',
         language: 'typescript' as const,
       };
+      expect(reactResolver!.resolve(ref, context)).toBeNull();
 
-      const result = reactResolver!.resolve(ref, context);
-      expect(result).not.toBeNull();
-      expect(result?.targetNodeId).toBe('hook:src/hooks/useAuth.ts:useAuth:1');
+      // The file's own hook resolves.
+      const own = reactResolver!.resolve({ ...ref, filePath: 'src/hooks/useAuth.ts', fromNodeId: 'function:src/hooks/useAuth.ts:x:30' }, context);
+      expect(own?.targetNodeId).toBe('hook:src/hooks/useAuth.ts:useAuth:1');
     });
   });
 
@@ -1339,12 +1364,9 @@ impl<T> Source for BufSource<T> {
       // The two ways this could overreach. `self.missing()` names nothing on
       // the owner, so it must not fall back to some other type's `missing`.
       //
-      // The receiver-less half is pinned as it BEHAVES, not as it should: a
-      // bare `reset()` is a free-function call, and it already resolved to
-      // `Target::reset` before this change — the mirror image of #1861, where
-      // a call with no receiver is given one. That is a separate defect in the
-      // bare-name strategy, measured on this branch's parent; the cell is here
-      // so this change is pinned to not make it worse.
+      // And a bare `reset()` is a free-function call: Rust reaches a method
+      // only through `self.` or `Type::`, so it is the free `reset`, never
+      // `Target::reset` (it used to be — the mirror image of #1861).
       writeRustCrate(tempDir, {
         'lib.rs':
           'pub fn reset() {}\n\n' +
@@ -1355,8 +1377,7 @@ impl<T> Source for BufSource<T> {
       });
       cg = await CodeGraph.init(tempDir, { index: true });
 
-      // Unchanged by this commit — see the note above.
-      expect(callsFrom('Target::free').map((c) => c.target)).toEqual(['Target::reset']);
+      expect(callsFrom('Target::free').map((c) => c.target)).toEqual(['reset']);
       // Nothing on the owner is named `missing`, so no edge at all.
       expect(callsFrom('Target::absent')).toEqual([]);
     });
diff --git a/__tests__/resolver-pool-sizing.test.ts b/__tests__/resolver-pool-sizing.test.ts
index cd949a4f0e..e70b7a6911 100644
--- a/__tests__/resolver-pool-sizing.test.ts
+++ b/__tests__/resolver-pool-sizing.test.ts
@@ -8,7 +8,7 @@
  */
 import { describe, it, expect } from 'vitest';
 import * as os from 'os';
-import { ResolverPool } from '../src/resolution/resolver-pool';
+import { ResolverPool, ADAPTIVE_ENGAGE_MIN_REFS, shouldEngageAdaptively } from '../src/resolution/resolver-pool';
 import {
   cgroupMemoryAvailable,
   darwinMemoryAvailable,
@@ -106,3 +106,17 @@ describe('memory budget helpers', () => {
     }
   );
 });
+
+describe('adaptive pool engagement needs a real amount of work left', () => {
+  it('does not boot the pool for a small remainder, however slow the observed rate', () => {
+    // A busy machine: 11 refs left projected at 506 ms (seen on a loaded 4-core VM).
+    expect(shouldEngageAdaptively(506, 11, 400)).toBe(false);
+    expect(shouldEngageAdaptively(60_000, ADAPTIVE_ENGAGE_MIN_REFS - 1, 400)).toBe(false);
+  });
+
+  it('boots it for a large remainder whose projected settle clears the bar', () => {
+    // tokio-class: ~55k Rust refs at ~36 µs each.
+    expect(shouldEngageAdaptively(1_980, 55_000, 400)).toBe(true);
+    expect(shouldEngageAdaptively(399, 55_000, 400)).toBe(false);
+  });
+});
diff --git a/__tests__/rn-event-channel.test.ts b/__tests__/rn-event-channel.test.ts
index ccf6e751e3..a5b01e58ed 100644
--- a/__tests__/rn-event-channel.test.ts
+++ b/__tests__/rn-event-channel.test.ts
@@ -226,3 +226,86 @@ function tick() {}
     expect(rows[1].registered_at).toBe('App.tsx:4');
   });
 });
+
+describe('RN event channel — event names held in constants', () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rn-event-const-'));
+  });
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (rel: string, content: string) => {
+    fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+    fs.writeFileSync(path.join(dir, rel), content);
+  };
+  const channel = (cg: CodeGraph) =>
+    ((cg as any).db.db
+      .prepare(
+        `SELECT s.name s, t.name t, json_extract(e.metadata,'$.event') event FROM edges e
+         JOIN nodes s ON s.id = e.source JOIN nodes t ON t.id = e.target
+         WHERE json_extract(e.metadata,'$.synthesizedBy') = 'rn-event-channel' ORDER BY s, t`
+      )
+      .all() as Array<{ s: string; t: string; event: string }>).map((r) => `${r.s} -> ${r.t} (${r.event})`);
+
+  it('NetInfo: a JS listener on `PrivateTypes.DEVICE_CONNECTIVITY_EVENT`, native sends the literal', async () => {
+    write('package.json', '{"name":"netinfo","dependencies":{"react-native":"^0.73"}}');
+    write('ios/RNCNetInfo.m', `@implementation RNCNetInfo
+- (void)connectionChanged {
+  [self sendEventWithName:@"netInfo.networkStatusDidChange" body:@{}];
+}
+@end
+`);
+    write('src/internal/privateTypes.ts', `export const DEVICE_CONNECTIVITY_EVENT = 'netInfo.networkStatusDidChange';
+`);
+    write('src/internal/state.ts', `import * as PrivateTypes from './privateTypes';
+export default class State {
+  start(emitter: any) {
+    emitter.addListener(
+      PrivateTypes.DEVICE_CONNECTIVITY_EVENT,
+      this._handleNativeStateUpdate,
+    );
+  }
+  _handleNativeStateUpdate(state: unknown) { return state; }
+}
+`);
+    const cg = await CodeGraph.init(dir, { index: true });
+    try {
+      expect(channel(cg)).toEqual(['connectionChanged -> _handleNativeStateUpdate (netInfo.networkStatusDidChange)']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a Java constant emit and a Kotlin const val meet a JS literal listener', async () => {
+    write('package.json', '{"name":"lib","dependencies":{"react-native":"^0.73"}}');
+    write('android/src/main/java/app/Tracker.java', `package app;
+public class Tracker {
+  private static final String PROGRESS_EVENT = "downloadProgress";
+  void report(ReactContext ctx) {
+    ctx.getJSModule(RCTDeviceEventEmitter.class).emit(PROGRESS_EVENT, null);
+  }
+}
+`);
+    write('android/src/main/java/app/Finisher.kt', `package app
+const val DONE_EVENT = "downloadDone"
+class Finisher {
+  fun finish(ctx: ReactContext) {
+    sendEvent(ctx, DONE_EVENT, null)
+  }
+}
+`);
+    write('src/index.js', `export function onProgress(e) { return e; }
+export function onDone(e) { return e; }
+emitter.addListener('downloadProgress', onProgress);
+emitter.addListener('downloadDone', onDone);
+`);
+    const cg = await CodeGraph.init(dir, { index: true });
+    try {
+      expect(channel(cg)).toEqual(['finish -> onDone (downloadDone)', 'report -> onProgress (downloadProgress)']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/route-inline-handler-calls.test.ts b/__tests__/route-inline-handler-calls.test.ts
new file mode 100644
index 0000000000..9a006a937a
--- /dev/null
+++ b/__tests__/route-inline-handler-calls.test.ts
@@ -0,0 +1,75 @@
+/**
+ * The calls an inline route handler makes keep their receivers. Read bare,
+ * hono's `app.get('/', (c) => c.text('Hello'))` called the one other `text`
+ * in the project — its client's `ClientResponse.text` — 419 times; kept as
+ * `c.text` it resolves like any other member call, and `userService.lookup()`
+ * reaches the service it names.
+ */
+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-route-inline-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'api', dependencies: { hono: '^4' } }),
+    'src/client/types.ts': `export interface ClientResponse {
+  text(): Promise<string>;
+}
+`,
+    'src/services.ts': `export const userService = {
+  lookup(id: number) {
+    return { id };
+  },
+};
+`,
+    'src/routes/app.ts': `import { Hono } from 'hono';
+import { userService } from '../services';
+
+const app = new Hono();
+
+app.get('/hello', (c) => c.text('Hello'));
+
+app.get('/users/:id', async (c) => {
+  const user = await userService.lookup(1);
+  return c.json(user);
+});
+
+export default app;
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const routeCalls = (name: string) => {
+  const route = cg.getNodesByKind('route').find((r) => r.name.endsWith(name));
+  if (!route) return [];
+  return cg.getOutgoingEdges(route.id).filter((e) => e.kind === 'calls').map((e) => {
+    const t = cg.getNode(e.target)!;
+    return `${t.filePath}: ${t.qualifiedName}`;
+  }).sort();
+};
+
+describe('inline route handler calls', () => {
+  it('are not a same-named method of an unrelated type', () => {
+    expect(routeCalls('/hello')).not.toContain('src/client/types.ts: ClientResponse::text');
+  });
+
+  it('reach the service a member call names', () => {
+    expect(routeCalls('/users/:id')).toContain('src/services.ts: userService::lookup');
+  });
+});
diff --git a/__tests__/ruby-call-scope.test.ts b/__tests__/ruby-call-scope.test.ts
new file mode 100644
index 0000000000..e9dab71597
--- /dev/null
+++ b/__tests__/ruby-call-scope.test.ts
@@ -0,0 +1,137 @@
+/**
+ * Ruby has nothing that types a receiver, so a method reached by name alone
+ * must earn it:
+ *
+ * - `receiver.m()` through an untyped receiver takes the one project method
+ *   named `m` only when the receiver is named after its owner
+ *   (`web_push_request.legacy_encrypt` → WebPushRequest). rubocop's
+ *   `node.loc` — a rubocop-ast node — went to the project's lone `loc` 1,201
+ *   times; lobsters' `value.to_s` to a short-id class's `to_s`.
+ * - a bare `m()` inside a class is a call on self: the class's own methods,
+ *   its superclasses', and those of modules mixed into any of them. rubocop's
+ *   `format(…)` — Kernel's — went to the LSP runtime's `format` 411 times.
+ */
+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-ruby-scope-'));
+  const files: Record<string, string> = {
+    'lib/app/ext/regexp.rb': `module App
+  module Ext
+    module Expression
+      def loc
+        @loc
+      end
+    end
+  end
+end
+`,
+    'lib/app/lsp/runtime.rb': `module App
+  module LSP
+    class Runtime
+      def format(text)
+        text
+      end
+    end
+  end
+end
+`,
+    'lib/app/web_push_request.rb': `class WebPushRequest
+  def legacy_encrypt(payload)
+    payload
+  end
+end
+`,
+    'lib/app/cop/base.rb': `module App
+  module Cop
+    module RangeHelp
+      def range_between(a, b)
+        [a, b]
+      end
+    end
+
+    class Base
+      def add_offense(node)
+        node
+      end
+    end
+  end
+end
+`,
+    'lib/app/cop/style/foo.rb': `module App
+  module Cop
+    module Style
+      class Foo < Base
+        include RangeHelp
+
+        MSG = 'Use %<x>s.'
+
+        def on_send(node, web_push_request)
+          selector = node.loc
+          web_push_request.legacy_encrypt(selector)
+          add_offense(node)
+          range_between(1, 2)
+          format(MSG, x: 1)
+        end
+      end
+    end
+  end
+end
+`,
+    'lib/app/greeting.rb': `module Greeting
+  def greet
+    "Hello, " + display_name()
+  end
+end
+`,
+    'lib/app/person.rb': `class Person
+  include Greeting
+
+  def display_name
+    'Ada'
+  end
+end
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::method` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('Ruby calls reached by name alone', () => {
+  it('keep the inherited and mixed-in methods, and the receiver named after its class', () => {
+    expect(callsFrom('lib/app/cop/style/foo.rb')).toEqual([
+      'App::Cop::Base::add_offense',
+      'App::Cop::RangeHelp::range_between',
+      'WebPushRequest::legacy_encrypt',
+    ]);
+  });
+
+  it('leave a call in a module body alone: a module runs on whatever includes it', () => {
+    expect(callsFrom('lib/app/greeting.rb')).toEqual(['Person::display_name']);
+  });
+});
diff --git a/__tests__/rust-enum-variant-reference.test.ts b/__tests__/rust-enum-variant-reference.test.ts
new file mode 100644
index 0000000000..6d7aee2c58
--- /dev/null
+++ b/__tests__/rust-enum-variant-reference.test.ts
@@ -0,0 +1,347 @@
+/**
+ * A Rust enum used only through its variants is a dependency of the code that
+ * uses them (#2328). `mode::Mode::A` in an expression, `Mode::B => …` in a
+ * `match`, a `Mode::C(x)` / `Mode::D { .. }` pattern and `Self::A` in the
+ * enum's impl reference the enum that declares the variant — the same
+ * `references` edge a type annotation (`fn takes(_m: Mode)`) produces. Nothing
+ * else read through a path does: not an associated const or function
+ * (`Limits::MAX`, `Mode::new()`), not a standard-library enum's variant.
+ */
+import { afterEach, beforeEach, describe, 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-variant-ref-')); });
+afterEach(() => { cg?.close(); cg = undefined; fs.rmSync(root, { recursive: true, force: true }); });
+
+async function index(files: Record<string, string>) {
+  fs.mkdirSync(path.join(root, 'src'));
+  fs.writeFileSync(path.join(root, 'Cargo.toml'), '[package]\nname = "repro"\nversion = "0.1.0"\nedition = "2021"\n');
+  for (const [file, text] of Object.entries(files)) fs.writeFileSync(path.join(root, 'src', file), text);
+  cg = await CodeGraph.init(root, { index: true });
+}
+
+/** The enum named `name` declared in `src/<file>`. */
+function enumIn(file: string, name = 'Mode') {
+  const node = cg!.getNodesByKind('enum').find((n) => n.filePath === `src/${file}` && n.name === name);
+  expect(node, `enum ${name} in ${file}`).toBeDefined();
+  return node!;
+}
+
+/** `file:name` of every symbol with a `references` edge to the node. */
+function referencers(nodeId: string): string[] {
+  const names = cg!.getIncomingEdges(nodeId)
+    .filter((e) => e.kind === 'references')
+    .map((e) => cg!.getNode(e.source)!)
+    .map((n) => `${n.filePath.replace(/^src\//, '')}:${n.name}`);
+  return [...new Set(names)].sort();
+}
+
+const MODE = `pub enum Mode {
+    A,
+    B,
+    C(u8),
+    D { x: u8 },
+}
+
+pub fn takes(_m: Mode) {}
+
+pub fn current() -> Mode { Mode::B }
+`;
+
+describe('Rust enum variant paths reference their enum (#2328)', () => {
+  it('the issue: a variant path in an expression and in match arms, through the module', async () => {
+    await index({
+      'mode.rs': MODE,
+      'variant_use.rs': `use crate::mode;
+
+pub fn code(flag: bool) -> u8 {
+    let m = if flag { mode::Mode::A } else { mode::Mode::B };
+    match m {
+        mode::Mode::A => 1,
+        mode::Mode::B => 2,
+        _ => 3,
+    }
+}
+`,
+      'main.rs': `mod mode;
+mod variant_use;
+
+fn main() {
+    mode::takes(mode::Mode::A);
+    let _ = variant_use::code(true);
+}
+`,
+    });
+    expect(referencers(enumIn('mode.rs').id)).toEqual(['main.rs:main', 'mode.rs:current', 'mode.rs:takes', 'variant_use.rs:code']);
+  });
+
+  it('a bare `Mode::A` after `use crate::mode::Mode;`', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod bare;\n',
+      'mode.rs': MODE,
+      'bare.rs': `use crate::mode::{self, Mode};
+
+pub fn pick() -> u8 {
+    let _m = Mode::B;
+    0
+}
+
+pub fn score() -> u8 {
+    match mode::current() {
+        Mode::A => 1,
+        _ => 0,
+    }
+}
+`,
+    });
+    expect(referencers(enumIn('mode.rs').id)).toEqual(['bare.rs:pick', 'bare.rs:score', 'mode.rs:current', 'mode.rs:takes']);
+    const pick = cg!.getNodesByKind('function').find((n) => n.name === 'pick')!;
+    const at = cg!.getOutgoingEdges(pick.id).filter((e) => e.kind === 'references').map((e) => `${e.line}:${e.column}`);
+    expect(at).toEqual(['4:13']);
+  });
+
+  it('tuple and struct variant patterns, and a variant read as a value', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod pat;\n',
+      'mode.rs': MODE,
+      'pat.rs': `use crate::mode::{self, Mode};
+
+pub fn tuple() -> u8 {
+    match mode::current() {
+        Mode::C(x) => x,
+        _ => 0,
+    }
+}
+
+pub fn structure() -> u8 {
+    if let crate::mode::Mode::D { x } = mode::current() { x } else { 0 }
+}
+
+pub fn ctor_value(xs: Vec<u8>) -> usize {
+    xs.into_iter().map(Mode::C).count()
+}
+`,
+    });
+    expect(referencers(enumIn('mode.rs').id)).toEqual([
+      'mode.rs:current', 'mode.rs:takes', 'pat.rs:ctor_value', 'pat.rs:structure', 'pat.rs:tuple',
+    ]);
+  });
+
+  it('constructing a tuple or struct variant stays linked to the variant itself', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod build;\n',
+      'mode.rs': MODE,
+      'build.rs': `use crate::mode::Mode;
+
+pub fn build() {
+    let _c = Mode::C(3);
+    let _d = Mode::D { x: 2 };
+}
+`,
+    });
+    const build = cg!.getNodesByKind('function').find((n) => n.name === 'build')!;
+    const out = cg!.getOutgoingEdges(build.id).map((e) => `${e.kind}:${cg!.getNode(e.target)!.qualifiedName}`).sort();
+    expect(out).toEqual(['calls:Mode::C', 'instantiates:Mode::D']);
+  });
+
+  it('`Self::A` inside `impl Mode`, in the enum\'s file and in another one', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod ops;\n',
+      'mode.rs': `${MODE}
+impl Mode {
+    pub fn flip(&self) -> u8 {
+        match self {
+            Self::A => 1,
+            _ => 0,
+        }
+    }
+}
+`,
+      'ops.rs': `use crate::mode::Mode;
+
+impl Mode {
+    pub fn is_b(&self) -> bool {
+        if let Self::B = self { true } else { false }
+    }
+}
+`,
+    });
+    expect(referencers(enumIn('mode.rs').id)).toEqual(['mode.rs:current', 'mode.rs:flip', 'mode.rs:takes', 'ops.rs:is_b']);
+  });
+
+  it('a variant imported by name and used bare has no path to read the enum from', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod other;\npub mod glob;\n',
+      'mode.rs': MODE,
+      'other.rs': 'pub enum Mode {\n    A,\n    Z,\n}\n',
+      'glob.rs': `use crate::mode::Mode::*;
+
+pub fn bare(m: u8) -> u8 {
+    match m {
+        0 => { let _ = A; 1 }
+        _ => 0,
+    }
+}
+`,
+    });
+    // Out of scope (#2328 is about paths): a bare name gives no receiver, and
+    // it must never land on the other module's same-named enum either.
+    expect(referencers(enumIn('mode.rs').id)).toEqual(['mode.rs:current', 'mode.rs:takes']);
+    expect(referencers(enumIn('other.rs').id)).toEqual([]);
+  });
+
+  it('the path picks the type that declares the variant, never a same-named type without it', async () => {
+    await index({
+      'lib.rs': 'pub mod matching;\npub mod other;\npub mod user;\n',
+      'matching.rs': 'pub enum Match {\n    None,\n    Ignore,\n}\n',
+      'other.rs': 'pub struct Match;\n',
+      'user.rs': `use crate::matching::Match;
+
+pub enum ColorChoice {
+    Auto,
+    Ansi,
+}
+
+pub fn first() -> u8 {
+    let _m = Match::None;
+    0
+}
+
+pub fn color() -> u8 {
+    let _c = termcolor::ColorChoice::AlwaysAnsi;
+    0
+}
+`,
+    });
+    expect(referencers(enumIn('matching.rs', 'Match').id)).toEqual(['user.rs:first']);
+    const struct = cg!.getNodesByKind('struct').find((n) => n.filePath === 'src/other.rs')!;
+    expect(referencers(struct.id)).toEqual([]);
+    // `termcolor`'s ColorChoice, not the file's own enum, which has no `AlwaysAnsi`.
+    expect(referencers(enumIn('user.rs', 'ColorChoice').id)).toEqual([]);
+  });
+
+  it('an associated const or function read through a type is not a variant path', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod limits;\npub mod user;\n',
+      'mode.rs': `${MODE}
+impl Mode {
+    pub const ALL: [u8; 2] = [0, 1];
+    pub fn count() -> usize { Self::ALL.len() }
+}
+`,
+      'limits.rs': 'pub struct Limits;\n\nimpl Limits {\n    pub const MAX: u8 = 3;\n    pub fn new() -> Self { Limits }\n}\n',
+      'user.rs': `use crate::limits::Limits;
+use crate::mode::Mode;
+
+pub fn cap() -> u8 {
+    Limits::MAX
+}
+
+pub fn all() -> usize {
+    Mode::ALL.len()
+}
+
+pub fn make() {
+    let _l = Limits::new();
+    let _f = Limits::new;
+}
+`,
+    });
+    // Only variants: the enum's own `count` and every reader of `Mode::ALL` /
+    // `Limits::MAX` stay off, and `Limits::new` links the function, not the type.
+    expect(referencers(enumIn('mode.rs').id)).toEqual(['mode.rs:current', 'mode.rs:takes']);
+    const limits = cg!.getNodesByKind('struct').find((n) => n.name === 'Limits')!;
+    expect(referencers(limits.id)).toEqual([]);
+    const make = cg!.getNodesByKind('function').find((n) => n.name === 'make')!;
+    expect(cg!.getOutgoingEdges(make.id).map((e) => `${e.kind}:${cg!.getNode(e.target)!.qualifiedName}`)).toEqual(['calls:Limits::new']);
+  });
+
+  it('std and prelude enums never reach a same-named project enum', async () => {
+    await index({
+      'lib.rs': 'pub mod shapes;\npub mod user;\n',
+      'shapes.rs': `pub enum Ordering {
+    Less,
+    Greater,
+}
+
+pub enum Option {
+    Some,
+    None,
+}
+`,
+      'user.rs': `use std::cmp::{self, Ordering};
+
+pub fn sorted(a: u8, b: u8) -> bool {
+    a.cmp(&b) == Ordering::Less || b.cmp(&a) == cmp::Ordering::Greater || a.cmp(&b) != std::cmp::Ordering::Less
+}
+
+pub fn first(o: Option<u8>) -> u8 {
+    match o {
+        Option::Some(x) => x,
+        Option::None => 0,
+    }
+}
+
+pub fn bare(o: Option<u8>, r: Result<u8, ()>) -> u8 {
+    match (o, r) {
+        (Some(x), Ok(_)) => x,
+        (None, Err(())) => 0,
+        _ => 1,
+    }
+}
+`,
+    });
+    expect(referencers(enumIn('shapes.rs', 'Ordering').id)).toEqual([]);
+    expect(referencers(enumIn('shapes.rs', 'Option').id)).toEqual([]);
+    for (const variant of cg!.getNodesByKind('enum_member')) {
+      expect(cg!.getIncomingEdges(variant.id).filter((e) => e.kind !== 'contains'), variant.qualifiedName).toEqual([]);
+    }
+  });
+
+  it('a module path, an associated function and a same-named enum elsewhere are not references to the enum', async () => {
+    await index({
+      'lib.rs': 'pub mod mode;\npub mod other;\npub mod util;\npub mod paths;\n',
+      'mode.rs': `${MODE}
+impl Mode {
+    pub fn new() -> Mode { Mode::A }
+}
+`,
+      'other.rs': 'pub enum Mode {\n    A,\n    Z,\n}\n',
+      'util.rs': 'pub fn take(x: u8) -> u8 { x }\n',
+      'paths.rs': `use crate::mode;
+use crate::other;
+use crate::util;
+
+pub fn via_module() -> u8 {
+    util::take(3)
+}
+
+pub fn via_ctor() {
+    let _m = mode::Mode::new();
+}
+
+pub fn via_other() -> u8 {
+    match other::Mode::A {
+        other::Mode::Z => 1,
+        _ => 0,
+    }
+}
+
+pub fn via_mode() {
+    let _m = mode::Mode::A;
+}
+`,
+    });
+    const viaModule = cg!.getNodesByKind('function').find((n) => n.name === 'via_module')!;
+    expect(cg!.getOutgoingEdges(viaModule.id).filter((e) => e.kind === 'references')).toEqual([]);
+    expect(referencers(enumIn('other.rs').id)).toEqual(['paths.rs:via_other']);
+    // `new`'s own `Mode::A` and return type; `via_ctor` calls an associated
+    // function, which links the function, not the enum.
+    expect(referencers(enumIn('mode.rs').id)).toEqual(['mode.rs:current', 'mode.rs:new', 'mode.rs:takes', 'paths.rs:via_mode']);
+  });
+});
diff --git a/__tests__/rust-framework-name-scope.test.ts b/__tests__/rust-framework-name-scope.test.ts
new file mode 100644
index 0000000000..614834f249
--- /dev/null
+++ b/__tests__/rust-framework-name-scope.test.ts
@@ -0,0 +1,83 @@
+/**
+ * The Rust resolver's struct/handler/service name heuristics never reach an
+ * item declared inside a function body — axum's examples' `Uri` (imported
+ * from `http`) went to a `struct Uri` a routing test declares inside itself —
+ * and a file's own item comes first: ripgrep's `Ok(Glob { … })` in
+ * globset's glob.rs is its own `Glob`, not the CLI flags' `Glob`.
+ */
+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-rust-fw-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[workspace]\nmembers = ["crates/core", "crates/globset", "crates/web", "examples/tls"]\n',
+    'crates/core/Cargo.toml': '[package]\nname = "rg-core"\n',
+    'crates/web/Cargo.toml': '[package]\nname = "web"\n',
+    'crates/web/src/lib.rs': 'pub mod http;\n',
+    'crates/web/src/http.rs': 'pub use ::http::Uri;\n',
+    'crates/web/src/routing/tests.rs': `fn outer_middleware_still_see_whole_url() {
+    struct Uri;
+    let _ = Uri;
+}
+`,
+    'examples/tls/Cargo.toml': '[package]\nname = "example-tls"\n\n[dependencies]\nweb = { path = "../../crates/web" }\n',
+    'examples/tls/src/main.rs': `use web::http::Uri;
+
+fn make_https(uri: Uri, port: u16) -> Uri {
+    uri
+}
+`,
+    'crates/core/src/flags/defs.rs': `pub struct Glob;
+
+pub fn glob_flag() -> Glob {
+    Glob
+}
+`,
+    'crates/globset/Cargo.toml': '[package]\nname = "globset"\n',
+    'crates/globset/src/glob.rs': `pub struct Glob {
+    glob: String,
+}
+
+impl Glob {
+    pub fn new(glob: &str) -> Result<Glob, ()> {
+        Ok(Glob { glob: glob.to_string() })
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains')
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('Rust framework name heuristics', () => {
+  it('never reach an item declared inside a function body', () => {
+    expect(targetsFrom('examples/tls/src/main.rs').filter((t) => t.includes('outer_middleware'))).toEqual([]);
+  });
+
+  it('take the file’s own item first', () => {
+    const globs = targetsFrom('crates/globset/src/glob.rs').filter((t) => t.endsWith(':Glob'));
+    expect(globs.length).toBeGreaterThan(0);
+    expect(new Set(globs)).toEqual(new Set(['crates/globset/src/glob.rs:Glob']));
+  });
+});
diff --git a/__tests__/rust-go-call-shape.test.ts b/__tests__/rust-go-call-shape.test.ts
new file mode 100644
index 0000000000..34a1b6a729
--- /dev/null
+++ b/__tests__/rust-go-call-shape.test.ts
@@ -0,0 +1,93 @@
+/**
+ * Rust and Go extractors keep one receiver level, so a chain's later links
+ * (`sym.filename().map(…)`, `c.Flags().String(…)`) arrive as bare names. Read
+ * at the call: a bare call never reaches a method (axum's routing `get(h)`
+ * went to a cookie jar's `get`, tokio's `drop(x)` to a `Drop` impl); a chained
+ * call with a standard-library name (`unwrap`, `map`, Go's `String`) needs a
+ * receiver named after the owner, while a project-specific one keeps its
+ * match (clap's `flag("n").short('n')` → `Arg::short`).
+ */
+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-rust-go-shape-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[package]\nname = "app"\nversion = "0.1.0"\n',
+    'src/guard.rs': `pub struct MutexGuard;
+impl MutexGuard {
+    pub fn map(self) -> Self { self }
+}
+pub struct CookieJar;
+impl CookieJar {
+    pub fn get(&self) -> Option<u8> { None }
+}
+pub struct Arg;
+impl Arg {
+    pub fn short(self, c: char) -> Self { self }
+}
+pub fn flag(name: &str) -> Arg { Arg }
+`,
+    'src/main.rs': `mod guard;
+use guard::flag;
+fn get(handler: u8) -> u8 { handler }
+fn run(sym: Option<&str>) {
+    let _ = sym.map(|s| s.len());
+    let _ = get(1);
+    let _ = flag("n").short('n');
+}
+fn main() { run(None); }
+`,
+    'go.mod': 'module example.com/app\n\ngo 1.21\n',
+    'flags.go': `package app
+
+type customString struct{}
+
+func (c customString) String() string { return "" }
+
+type FlagSet struct{}
+
+func Flags() *FlagSet { return nil }
+`,
+    'cmd.go': `package app
+
+func run() {
+	Flags().String("name", "", "")
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const callsIn = (file: string, fn: string): string[] => {
+  const node = cg.getNodesInFile(file).find((n) => n.name === fn)!;
+  return cg.getOutgoingEdges(node.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.qualifiedName);
+};
+
+describe('Rust and Go call shapes', () => {
+  it('Rust: bare never a method, std chain names need their receiver, project chain names keep theirs', () => {
+    const targets = callsIn('src/main.rs', 'run');
+    expect(targets.some((t) => t.endsWith('MutexGuard::map'))).toBe(false);
+    expect(targets.some((t) => t.endsWith('CookieJar::get'))).toBe(false);
+    expect(targets.some((t) => t.endsWith('Arg::short'))).toBe(true);
+  });
+
+  it('Go: a std-named chained call is not a project type’s method', () => {
+    expect(callsIn('cmd.go', 'run').some((t) => t.endsWith('customString::String'))).toBe(false);
+  });
+});
diff --git a/__tests__/rust-prelude-scope.test.ts b/__tests__/rust-prelude-scope.test.ts
new file mode 100644
index 0000000000..5e12b0c575
--- /dev/null
+++ b/__tests__/rust-prelude-scope.test.ts
@@ -0,0 +1,79 @@
+/**
+ * A bare Rust name reaches only what is in scope. `Some(x)` / `Ok(x)` are the
+ * prelude's: ripgrep bound every one to its own `EncodingMode::Some` and
+ * `ParseResult::Ok` variants, serde its `Ok`/`Result` to the structs its
+ * macro-hygiene test declares. A variant needs a `use` of it or its enum's `*`.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+const FILES: Record<string, string> = {
+  'Cargo.toml': '[package]\nname = "app"\nversion = "0.1.0"\n',
+  'src/lowargs.rs': `pub enum EncodingMode {
+    Auto,
+    Some(u8),
+    Disabled,
+}
+pub enum ParseResult<T> {
+    Ok(T),
+    Err(String),
+}
+`,
+  'src/hygiene.rs': `struct Ok;
+struct Result;
+fn local() -> Ok { Ok }
+`,
+  'src/decompress.rs': `pub fn find(cmd: u8) -> Option<u8> {
+    if cmd > 0 { return Some(cmd); }
+    let r: std::result::Result<u8, ()> = Ok(cmd);
+    None
+}
+`,
+  'src/error.rs': `pub struct Error;
+pub type Result<T> = std::result::Result<T, Error>;
+`,
+  'src/api.rs': `pub fn load() -> crate::error::Result<u8> { unimplemented!() }
+`,
+  'src/modes.rs': `use crate::lowargs::EncodingMode::*;
+pub fn pick() -> crate::lowargs::EncodingMode { Some(1) }
+`,
+};
+
+describe('Rust: a bare name reaches what is in scope', () => {
+  it('the prelude, a used variant, a same-file item', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-prelude-'));
+    roots.push(root);
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const targets = (fn: string): string[] => {
+        const from = cg.getNodesByName(fn).filter((n) => n.kind === 'function');
+        return cg
+          .getOutgoingEdgesFrom(from.map((n) => n.id), ['calls', 'references', 'instantiates'])
+          .map((e) => cg.getNode(e.target)!)
+          .map((n) => `${n.kind}:${n.qualifiedName}`);
+      };
+      // Prelude `Some` / `Ok`, not the project's variants or structs.
+      expect(targets('find').filter((t) => /Some|Ok|Result/.test(t))).toEqual([]);
+      // `use EncodingMode::*` brings the variant in.
+      expect(targets('pick')).toContain('enum_member:EncodingMode::Some');
+      // A path (`crate::error::Result`) is not a prelude lookup, so it still links.
+      expect(targets('load').some((t) => t.endsWith(':Result'))).toBe(true);
+      // A same-file struct still shadows the prelude.
+      expect(targets('local')).toContain('struct:Ok');
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/rust-route-handler-line.test.ts b/__tests__/rust-route-handler-line.test.ts
new file mode 100644
index 0000000000..41e4749fd5
--- /dev/null
+++ b/__tests__/rust-route-handler-line.test.ts
@@ -0,0 +1,208 @@
+/**
+ * A Rust route's handler reference sits on the line its handler is written
+ * on (#2326). rustfmt wraps a long `.route(` call, putting the handler on a
+ * line below `.route(`; the Rust scope gate reads the reference's line to see
+ * how the name is written (`handlers::f` names the `handlers` module), so a
+ * reference left on the `.route(` line never found the name there and the
+ * edge was dropped — as it was when the line wrote the handler's name
+ * elsewhere too (`/login` in the path, `delete(` as the method router), which
+ * the gate read as a bare use. A call inside a closure handler's body is not a method
+ * router: `cache.get(keys::session_key)` is not a `GET` route handled by
+ * `session_key`. Nor is an Actix resource's chain longer than the call it is
+ * an argument of: the App-level `.route(..)` after it is not its method.
+ */
+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';
+import { rustResolver } from '../src/resolution/frameworks/rust';
+
+const MAIN_RS = `mod actix_app;
+mod handlers;
+mod keys;
+use axum::{routing::{delete, get, post}, Router};
+use crate::handlers::used_handler;
+
+pub fn app() -> Router {
+    Router::new()
+        .route("/single", get(handlers::single_line_handler))
+        .route(
+            "/multi",
+            get(handlers::multi_line_handler),
+        )
+        .route(
+            "/deep",
+            get(
+                handlers::deep_line_handler,
+            ),
+        )
+        .route(
+            "/items",
+            get(handlers::list_items)
+                .post(handlers::create_item)
+                .delete(handlers::delete_item),
+        )
+        .route(
+            "/used",
+            post(used_handler),
+        )
+        .route(
+            "/other",
+            get(metrics::render_handler),
+        )
+        .route("/login", post(handlers::login))
+        .route("/account", delete(handlers::delete))
+        .route("/closure-inline", get(|| async { cache().get(keys::session_key) }))
+        .route(
+            "/closure",
+            get(|| async move {
+                cache().get(keys::session_key)
+            }),
+        )
+}
+`;
+
+const ACTIX_RS = `use actix_web::{web, App};
+use crate::handlers;
+
+pub fn actix() {
+    App::new()
+        .service(
+            web::resource("/index/with/a/rather/long/path/{id}")
+                .to(handlers::actix_index),
+        )
+        .service(
+            web::resource("/user/{id}")
+                .route(
+                    web::get()
+                        .to(handlers::actix_get_user),
+                ),
+        )
+        .route(
+            "/hey",
+            web::get().to(handlers::actix_hello),
+        );
+}
+`;
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-route-line-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[package]\nname = "repro"\nversion = "0.1.0"\nedition = "2021"\n\n[dependencies]\naxum = "0.7"\nactix-web = "4"\nmetrics = "0.23"\n',
+    'src/main.rs': MAIN_RS,
+    'src/actix_app.rs': ACTIX_RS,
+    'src/handlers/mod.rs': `pub async fn single_line_handler() {}
+pub async fn multi_line_handler() {}
+pub async fn deep_line_handler() {}
+pub async fn list_items() {}
+pub async fn create_item() {}
+pub async fn delete_item() {}
+pub async fn used_handler() {}
+pub async fn render_handler() {}
+pub async fn login() {}
+pub async fn delete() {}
+pub async fn actix_index() {}
+pub async fn actix_get_user() {}
+pub async fn actix_hello() {}
+`,
+    'src/keys.rs': 'pub fn session_key() -> &\'static str { "s" }\n',
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `METHOD /path -> file:handler` for every route -> function `references` edge out of a file's routes. */
+const routeEdges = (file: string): string[] => {
+  const routes = cg.getNodesInFile(file).filter((n) => n.kind === 'route');
+  return cg.getOutgoingEdgesFrom(routes.map((r) => r.id), ['references'])
+    .map((e) => `${cg.getNode(e.source)!.name} -> ${cg.getNode(e.target)!.filePath}:${cg.getNode(e.target)!.name}`)
+    .sort();
+};
+
+describe('Axum: a handler written below `.route(` is linked to its route (#2326)', () => {
+  it('links a single-line route, as before', () => {
+    expect(routeEdges('src/main.rs')).toContain('GET /single -> src/handlers/mod.rs:single_line_handler');
+  });
+
+  it('links a rustfmt-wrapped route', () => {
+    expect(routeEdges('src/main.rs')).toContain('GET /multi -> src/handlers/mod.rs:multi_line_handler');
+  });
+
+  it('links a handler wrapped below its method router too', () => {
+    expect(routeEdges('src/main.rs')).toContain('GET /deep -> src/handlers/mod.rs:deep_line_handler');
+  });
+
+  it('links every method of a chain wrapped over several lines', () => {
+    expect(routeEdges('src/main.rs')).toEqual(expect.arrayContaining([
+      'GET /items -> src/handlers/mod.rs:list_items',
+      'POST /items -> src/handlers/mod.rs:create_item',
+      'DELETE /items -> src/handlers/mod.rs:delete_item',
+    ]));
+  });
+
+  it('links a wrapped handler named through a `use`', () => {
+    expect(routeEdges('src/main.rs')).toContain('POST /used -> src/handlers/mod.rs:used_handler');
+  });
+
+  it('does not link a wrapped handler another module names to a same-named one', () => {
+    expect(routeEdges('src/main.rs').filter((e) => e.includes('render_handler'))).toEqual([]);
+  });
+
+  it('links a single-line route whose line also writes the handler name elsewhere', () => {
+    // `/login` in the path, `delete(` as the method router: neither is how the handler is named.
+    expect(routeEdges('src/main.rs')).toEqual(expect.arrayContaining([
+      'POST /login -> src/handlers/mod.rs:login',
+      'DELETE /account -> src/handlers/mod.rs:delete',
+    ]));
+  });
+
+  it('never reads a call inside a closure handler as a route', () => {
+    expect(routeEdges('src/main.rs').filter((e) => e.includes('closure'))).toEqual([]);
+    const routes = cg.getNodesInFile('src/main.rs').filter((n) => n.kind === 'route').map((n) => n.name);
+    expect(routes.filter((n) => n.includes('closure'))).toEqual([]);
+  });
+
+  it('keeps the route on the `.route(` line and puts the reference on the handler', () => {
+    const { nodes, references } = rustResolver.extract!('src/main.rs', MAIN_RS);
+    const lines = MAIN_RS.split('\n');
+    const lineOf = (text: string) => lines.findIndex((l) => l.includes(text)) + 1;
+    const multi = nodes.find((n) => n.name === 'GET /multi')!;
+    expect(multi.startLine).toBe(lineOf('"/multi"') - 1);
+    const ref = references.find((r) => r.referenceName === 'multi_line_handler')!;
+    expect(ref.line).toBe(lineOf('handlers::multi_line_handler'));
+    expect(lines[ref.line - 1]!.startsWith('multi_line_handler', ref.column)).toBe(true);
+    const single = references.find((r) => r.referenceName === 'single_line_handler')!;
+    expect(single.line).toBe(nodes.find((n) => n.name === 'GET /single')!.startLine);
+  });
+});
+
+describe('Actix: a handler written below its route is linked to it (#2326)', () => {
+  it('links a wrapped `web::resource(..).to(handler)`', () => {
+    expect(routeEdges('src/actix_app.rs')).toContain('ANY /index/with/a/rather/long/path/{id} -> src/handlers/mod.rs:actix_index');
+  });
+
+  it('links a wrapped `web::get().to(handler)` inside `.route(`', () => {
+    expect(routeEdges('src/actix_app.rs')).toContain('GET /user/{id} -> src/handlers/mod.rs:actix_get_user');
+  });
+
+  it('links a wrapped App-level `.route("/path", web::get().to(handler))`', () => {
+    expect(routeEdges('src/actix_app.rs')).toContain('GET /hey -> src/handlers/mod.rs:actix_hello');
+  });
+
+  it('does not read the App-level route after a `.service(..)` into its resource', () => {
+    expect(routeEdges('src/actix_app.rs').filter((e) => e.startsWith('GET /user/{id}')))
+      .toEqual(['GET /user/{id} -> src/handlers/mod.rs:actix_get_user']);
+  });
+});
diff --git a/__tests__/rust-self-associated-type.test.ts b/__tests__/rust-self-associated-type.test.ts
new file mode 100644
index 0000000000..2c34e56a39
--- /dev/null
+++ b/__tests__/rust-self-associated-type.test.ts
@@ -0,0 +1,65 @@
+/**
+ * In Rust, `Self::Error` in a signature is the enclosing impl's (or trait's)
+ * own associated type, and `V::Value` an associated type of a generic's bound
+ * — never a struct of that name. serde's `Self::Error`s went to
+ * `de::value::Error`, the one `struct Error` the crate defines.
+ */
+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-rust-self-assoc-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[package]\nname = "serde"\n',
+    'src/de/value.rs': `pub struct Error {
+    msg: String,
+}
+
+pub struct Value;
+`,
+    'src/private/de.rs': `use crate::de::value::{Error, Value};
+
+pub trait Deserializer {
+    type Error;
+}
+
+pub struct ContentDeserializer<E> {
+    err: E,
+}
+
+impl<E> Deserializer for ContentDeserializer<E> {
+    type Error = E;
+
+    fn deserialize_any<V: Visitor>(self, visitor: V) -> Result<V::Value, Self::Error> {
+        todo!()
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Rust Self:: and generic-parameter paths', () => {
+  it('name the impl’s associated type, never a struct of that name', () => {
+    const ids = cg.getNodesInFile('src/private/de.rs').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references' && e.line === 14)
+      .map((e) => cg.getNode(e.target)!).map((t) => `${t.kind} ${t.filePath}:${t.startLine}`);
+    expect(targets).toContain('type_alias src/private/de.rs:12');
+    expect(targets.filter((t) => t.includes('src/de/value.rs'))).toEqual([]);
+  });
+});
diff --git a/__tests__/rust-type-scope.test.ts b/__tests__/rust-type-scope.test.ts
new file mode 100644
index 0000000000..766252fc65
--- /dev/null
+++ b/__tests__/rust-type-scope.test.ts
@@ -0,0 +1,90 @@
+/**
+ * A bare Rust type or function from another file is in scope only through a
+ * `use` that binds it (or a glob over its module), and one the file imports
+ * from outside the project — `use std::task::{Context, Poll}` — is that
+ * outside item: tokio's 1,221 `io::Result<…>` bound to a private
+ * `runtime::task::Result` alias, its 642 `Context<'_>` to
+ * `runtime::context::Context`. A path names its module (`io::Result` is no
+ * `task` alias; `std::io::Error` is std's), a project crate's name
+ * (`clap::Command`) re-exports as `crate::` does, and an inline test module
+ * (`mod support { pub mod panic; }`) is the project's own.
+ */
+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-rust-scope-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': `[package]\nname = "app"\nversion = "0.1.0"\n\n[dependencies]\nfutures = "0.3"\n`,
+    'src/lib.rs': `pub mod runtime;\npub mod io;\npub mod net;\n`,
+    'src/runtime/mod.rs': `pub mod context;\npub mod task;\npub mod driver;\n`,
+    'src/runtime/context.rs': `pub struct Context {\n    pub depth: u8,\n}\n`,
+    'src/runtime/task/mod.rs': `pub type Result<T> = std::result::Result<T, ()>;\n`,
+    'src/io/mod.rs': `pub mod copy;\n`,
+    'src/io/copy.rs': `pub struct Error;\n`,
+    'src/net.rs': `use std::io;
+use std::task::{Context, Poll};
+
+pub fn poll_ready(cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    let _ = cx;
+    Poll::Ready(Ok(()))
+}
+
+pub fn fail() -> std::io::Error {
+    std::io::Error::other("x")
+}
+`,
+    'src/runtime/driver.rs': `use crate::runtime::context::Context;
+
+pub fn enter(ctx: &Context) -> u8 {
+    ctx.depth
+}
+`,
+    'tests/support/panic.rs': `pub fn test_panic() {}\n`,
+    'tests/io_panic.rs': `mod support {
+    pub mod panic;
+}
+use support::panic::test_panic;
+
+#[test]
+fn panics() {
+    test_panic();
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.filePath);
+};
+
+describe('Rust names in scope', () => {
+  it('an outside import, or a path through one, is never a project item', () => {
+    const targets = targetsFrom('src/net.rs');
+    expect(targets).not.toContain('src/runtime/context.rs');
+    expect(targets).not.toContain('src/runtime/task/mod.rs');
+    expect(targets).not.toContain('src/io/copy.rs');
+  });
+
+  it('a crate-local use, and an inline test module, still reach the project item', () => {
+    expect(targetsFrom('src/runtime/driver.rs')).toContain('src/runtime/context.rs');
+    expect(targetsFrom('tests/io_panic.rs')).toContain('tests/support/panic.rs');
+  });
+});
diff --git a/__tests__/scala-bare-call-scope.test.ts b/__tests__/scala-bare-call-scope.test.ts
new file mode 100644
index 0000000000..9f24022c2d
--- /dev/null
+++ b/__tests__/scala-bare-call-scope.test.ts
@@ -0,0 +1,90 @@
+/**
+ * A bare Scala name reached by name alone must be in reach:
+ * - a parameter or local binds it: `f(true)` with `f: A => B` is not a case
+ *   class's field `f` (cats: 438 times);
+ * - a later link of a chain (`fa.iterator.map(f)`) reaches a member of what
+ *   the receiver is named after (`basicRequest.send` → Request), never a
+ *   package object's function;
+ * - otherwise a member of the types around it — an anonymous subclass's base
+ *   included (`new OptionParser[C]("x") { head("x") }`) — of their supertypes,
+ *   or of an imported object.
+ */
+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-scala-scope-'));
+  const files: Record<string, string> = {
+    'src/main/scala/app/FreeT.scala': `package app
+
+final case class FlatMapped[A](f: A => A)
+`,
+    'src/main/scala/app/LazyOps.scala': `package app
+
+class LazyOps[A](xs: List[A]) {
+  def map[B](g: A => B): List[B] = xs.map(g)
+}
+`,
+    'src/main/scala/app/OptionParser.scala': `package app
+
+abstract class OptionParser[C](name: String) {
+  def head(xs: String*): Unit = ()
+}
+`,
+    'src/main/scala/app/Base.scala': `package app
+
+trait Base {
+  def helper(): Int = 1
+}
+`,
+    'src/main/scala/app/Request.scala': `package app
+
+class Request {
+  def send(backend: String): String = backend
+}
+`,
+    'src/main/scala/app/Use.scala': `package app
+
+object Use extends Base {
+  def tabulate[A](f: Boolean => A): (A, A) = (f(true), f(false))
+  def twice(fa: List[Int]): List[Int] = fa.iterator.map(_ + 1).toList
+  def run(basicRequest: Request): String = basicRequest.send("b")
+  def local(): Int = helper()
+  val parser = new OptionParser[Int]("scopt") {
+    head("scopt", "3.x")
+  }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('bare Scala calls', () => {
+  it('stay with locals, the receiver’s type, the class hierarchy and anonymous bases', () => {
+    const ids = cg.getNodesInFile('src/main/scala/app/Use.scala').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(targets.some((t) => t.endsWith('FlatMapped::f'))).toBe(false);
+    expect(targets.some((t) => t.endsWith('LazyOps::map'))).toBe(false);
+    expect(targets.some((t) => t.endsWith('Request::send'))).toBe(true);
+    expect(targets.some((t) => t.endsWith('Base::helper'))).toBe(true);
+    expect(targets.some((t) => t.endsWith('OptionParser::head'))).toBe(true);
+  });
+});
diff --git a/__tests__/scala-block-locals.test.ts b/__tests__/scala-block-locals.test.ts
new file mode 100644
index 0000000000..2b079ec425
--- /dev/null
+++ b/__tests__/scala-block-locals.test.ts
@@ -0,0 +1,118 @@
+/**
+ * A Scala `val` written inside a block of a class body — cats' `test("…") {
+ * val f = … }` — is that block's, not a member of the class: a lambda
+ * parameter `f` in another suite (`forAll { (e: Int, f: Int => Int) => f(e) }`)
+ * and a sibling test's `f(2)` are not calls to it. A lowercase package import
+ * (`import cats.syntax.all._`) no longer lets every class's members in; an
+ * imported package object's supertypes do (`package object api extends Api`),
+ * as does the package object of the file's own package.
+ */
+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-scala-block-'));
+  const files: Record<string, string> = {
+    'src/test/scala/app/ASuite.scala': `package app
+
+class ASuite {
+  def test(name: String)(body: => Unit): Unit = ()
+
+  test("a") {
+    val f = (i: Int) => i
+    f(1)
+  }
+
+  test("c") {
+    f(2)
+  }
+}
+`,
+    'src/test/scala/app/BSuite.scala': `package app
+
+import app.syntax.all._
+
+class BSuite {
+  def test(name: String)(body: => Unit): Unit = ()
+  def forAll(p: (Int, Int => Int) => Boolean): Unit = ()
+
+  test("b") {
+    forAll { (e: Int, f: Int => Int) =>
+      f(e) == 1
+    }
+  }
+}
+`,
+    'src/main/scala/app/syntax/all.scala': `package app.syntax
+
+object all
+`,
+    'src/main/scala/app/Api.scala': `package app
+
+trait Api {
+  def multipart(s: String): String = s
+}
+`,
+    'src/main/scala/app/api/package.scala': `package app
+
+package object api extends Api
+`,
+    'src/main/scala/app/client/Client.scala': `package app.client
+
+import app.api._
+
+class Client {
+  def send(): String = multipart("x")
+}
+`,
+    'src/main/scala/app/api/Inner.scala': `package app.api
+
+class Inner {
+  def send(): String = multipart("y")
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `qualified name:line` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => `${cg.getNode(e.target)!.qualifiedName}:${e.line}`)
+    .sort();
+}
+
+describe('Scala block-local vals', () => {
+  it('are called from their own block only', () => {
+    expect(callsFrom('src/test/scala/app/ASuite.scala').filter((c) => c.startsWith('ASuite::f'))).toEqual(['ASuite::f:8']);
+  });
+
+  it('are not another suite’s lambda parameter, whatever the file imports', () => {
+    expect(callsFrom('src/test/scala/app/BSuite.scala').filter((c) => c.includes('::f:'))).toEqual([]);
+  });
+});
+
+describe('Scala package objects', () => {
+  it('bring their supertypes’ members in when imported, and into their own package', () => {
+    expect(callsFrom('src/main/scala/app/client/Client.scala')).toEqual(['Api::multipart:6']);
+    expect(callsFrom('src/main/scala/app/api/Inner.scala')).toEqual(['Api::multipart:4']);
+  });
+});
diff --git a/__tests__/scala-chain-object.test.ts b/__tests__/scala-chain-object.test.ts
new file mode 100644
index 0000000000..831765b65a
--- /dev/null
+++ b/__tests__/scala-chain-object.test.ts
@@ -0,0 +1,67 @@
+/**
+ * A Scala chain link `x.map { … }` is a member of what `x` is — never an
+ * object that happens to be named `map` (alleycats' `object map`, cats'
+ * `instances.map` / `syntax.flatMap` objects took 418 such calls). A type or
+ * object is a chain link only when the receiver names what holds it:
+ * `sttp.client4.Response(…)`, `fs2.concurrent.Topic(1)`.
+ */
+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-scala-chain-'));
+  const files: Record<string, string> = {
+    'src/main/scala/alleycats/std/map.scala': `package alleycats.std
+
+object map {
+  val instances: Int = 1
+}
+`,
+    'src/main/scala/app/client/Response.scala': `package app.client
+
+case class Response(code: Int)
+`,
+    'src/main/scala/app/Use.scala': `package app
+
+class Use {
+  def gen[A](a: A): List[A] = List(a)
+  def run(): List[Int] = gen[Int](1).map { x => x + 1 }
+  def make(): Any = app.client.Response(200)
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+    .map((e) => cg.getNode(e.target)!.filePath)
+    .sort();
+};
+
+describe('Scala chain links', () => {
+  it('never land on an object named like the member', () => {
+    expect(targetsFrom('src/main/scala/app/Use.scala')).not.toContain('src/main/scala/alleycats/std/map.scala');
+  });
+
+  it('reach a type the receiver’s package path names', () => {
+    expect(targetsFrom('src/main/scala/app/Use.scala')).toContain('src/main/scala/app/client/Response.scala');
+  });
+});
diff --git a/__tests__/scala-kind-projector.test.ts b/__tests__/scala-kind-projector.test.ts
new file mode 100644
index 0000000000..54d195712d
--- /dev/null
+++ b/__tests__/scala-kind-projector.test.ts
@@ -0,0 +1,53 @@
+/**
+ * A Scala kind-projector placeholder in a type — `Align[Either[A, *]]`,
+ * `Functor[Map[K, ?]]` — names no method: cats' 567 `*` type arguments went
+ * to an algebra `Sign`'s `*` operator.
+ */
+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-scala-kp-'));
+  const files: Record<string, string> = {
+    'src/main/scala/algebra/Signed.scala': `package algebra
+
+object Signed {
+  sealed abstract class Sign(val toInt: Int) {
+    def *(that: Sign): Sign = this
+  }
+}
+`,
+    'src/main/scala/cats/Align.scala': `package cats
+
+trait Align[F[_]]
+
+object Align {
+  implicit def catsAlignForEither[A]: Align[Either[A, *]] = null
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Scala kind-projector placeholders', () => {
+  it('are not references to a `*` method', () => {
+    const ids = cg.getNodesInFile('src/main/scala/cats/Align.scala').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references').map((e) => cg.getNode(e.target)!.name);
+    expect(targets).not.toContain('*');
+  });
+});
diff --git a/__tests__/scala-package-object-scope.test.ts b/__tests__/scala-package-object-scope.test.ts
new file mode 100644
index 0000000000..86164fa2f6
--- /dev/null
+++ b/__tests__/scala-package-object-scope.test.ts
@@ -0,0 +1,69 @@
+/**
+ * A Scala package object's member is in scope in its package and the
+ * packages under it, or through an import of that package. cats.laws' `Eq`
+ * is the `cats` package object's alias — 752 references went to the
+ * `algebra` package object's `Eq` instead.
+ */
+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-scala-pkgobj-'));
+  const files: Record<string, string> = {
+    'algebra-core/src/main/scala/algebra/package.scala': `package object algebra {
+  type Eq[A] = cats.kernel.Eq[A]
+}
+`,
+    'core/src/main/scala/cats/package.scala': `package object cats {
+  type Eq[A] = cats.kernel.Eq[A]
+}
+`,
+    'laws/src/main/scala/cats/laws/FunctorLaws.scala': `package cats
+package laws
+
+trait FunctorLaws {
+  def identity[A](eq: Eq[A]): Boolean = true
+}
+`,
+    'algebra-laws/src/main/scala/algebra/laws/RingLaws.scala': `package algebra.laws
+
+import algebra._
+
+trait RingLaws {
+  def eqv[A](eq: Eq[A]): Boolean = true
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const eqTargets = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return [...new Set(cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'references')
+    .map((e) => cg.getNode(e.target)!).filter((t) => t.name === 'Eq').map((t) => t.filePath))];
+};
+
+describe('Scala package object members', () => {
+  it('are in scope in their package and those under it', () => {
+    expect(eqTargets('laws/src/main/scala/cats/laws/FunctorLaws.scala')).toEqual(['core/src/main/scala/cats/package.scala']);
+  });
+
+  it('and through an import of their package', () => {
+    expect(eqTargets('algebra-laws/src/main/scala/algebra/laws/RingLaws.scala')).toEqual(['algebra-core/src/main/scala/algebra/package.scala']);
+  });
+});
diff --git a/__tests__/self-call-delegation.test.ts b/__tests__/self-call-delegation.test.ts
new file mode 100644
index 0000000000..40e2a617aa
--- /dev/null
+++ b/__tests__/self-call-delegation.test.ts
@@ -0,0 +1,130 @@
+/**
+ * A method that hands its call on to another object — a wrapper — is not
+ * calling itself. Calls through `this.<field>…` / `window.<x>…` (TS/JS) or
+ * through an expression's value (Scala `requestToArmeria(request).execute()`,
+ * Rust `self.0.into_route(state)`) reach the resolver by their bare name, so
+ * BookStack's `toggle()` doing `this.container.classList.toggle('open')`
+ * bound to itself; a guess from a receiver's name alone (`FileStorage::delete`
+ * doing `$storage->delete($path)`) did too, and a value's initializer chain
+ * (`val response = basicRequest.get(…).response(…)`) to the value. A recursion
+ * through a field the class declares as its own type stays.
+ */
+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-self-call-'));
+  const files: Record<string, string> = {
+    'resources/js/editor-toolbox.ts': `export class EditorToolbox {
+  container: HTMLElement;
+
+  toggle(): void {
+    this.container.classList.toggle('open');
+    this.toggle();
+  }
+}
+`,
+    'resources/js/tree.ts': `export class TreeNode {
+  left: TreeNode | null = null;
+
+  insert(v: number): void {
+    this.left.insert(v);
+  }
+}
+`,
+    'resources/js/common-events.js': `export function listen(editor) {
+  window.$events.listen('editor::replace', () => editor.reset());
+}
+`,
+    'app/Uploads/FileStorage.php': `<?php
+
+class FileStorage
+{
+    public function delete(string $path): void
+    {
+        $storage = $this->getStorageDisk();
+        $storage->delete($path);
+    }
+
+    protected function getStorageDisk()
+    {
+        return null;
+    }
+}
+`,
+    'app/Uploads/ImageStorage.php': `<?php
+
+class ImageStorage
+{
+    public function delete(string $path): void
+    {
+    }
+}
+`,
+    'core/src/main/scala/sttp/ArmeriaBackend.scala': `package sttp
+
+class ArmeriaBackend {
+  def requestToArmeria(request: String): Client = new Client
+
+  def execute(request: String): Unit = {
+    val armeriaRes = requestToArmeria(request).execute()
+  }
+}
+
+class CurlTest {
+  val response = basicRequest
+    .get("http://example.com")
+    .response(asString)
+}
+`,
+    'src/routing/route.rs': `pub struct BoxedIntoRoute(Box<dyn ErasedIntoRoute>);
+
+impl BoxedIntoRoute {
+    pub fn into_route(self, state: u32) -> u32 {
+        self.0.into_route(state)
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const selfCallLines = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls' && e.source === e.target).map((e) => e.line);
+};
+
+describe('a call a method hands on', () => {
+  it('through a field of another type is not the method itself', () => {
+    expect(selfCallLines('resources/js/editor-toolbox.ts')).toEqual([6]);
+    expect(selfCallLines('resources/js/common-events.js')).toEqual([]);
+  });
+
+  it('through a field of the class’s own type is a recursion', () => {
+    expect(selfCallLines('resources/js/tree.ts')).toEqual([5]);
+  });
+
+  it('through another expression’s value is not the method itself', () => {
+    expect(selfCallLines('core/src/main/scala/sttp/ArmeriaBackend.scala')).toEqual([]);
+    expect(selfCallLines('src/routing/route.rs')).toEqual([]);
+  });
+
+  it('through a receiver named like the caller’s class is not the method itself', () => {
+    expect(selfCallLines('app/Uploads/FileStorage.php')).toEqual([]);
+  });
+});
diff --git a/__tests__/self-overload-calls.test.ts b/__tests__/self-overload-calls.test.ts
new file mode 100644
index 0000000000..d18b7c66e7
--- /dev/null
+++ b/__tests__/self-overload-calls.test.ts
@@ -0,0 +1,109 @@
+/**
+ * A call that lands on an overload its arguments cannot fit is to the one
+ * sibling overload they do: `toInstant(instant)` delegating to
+ * `toInstant(instant, Instant.EPOCH)` bound to itself (commons-lang had 180
+ * such self-edges, Newtonsoft 107), and `HashCodeBuilder.reflectionHashCode(this)`
+ * to the first overload indexed, a three-parameter one.
+ */
+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-self-overload-'));
+  const files: Record<string, string> = {
+    'src/main/java/app/Instants.java': `package app;
+
+public class Instants {
+  public static Object toInstant(final Object instant) {
+    return toInstant(instant, null);
+  }
+
+  public static Object toInstant(final Object instant, final Object defaultInstant) {
+    return instant != null ? instant : defaultInstant;
+  }
+
+  public static int depth(final int n) {
+    return n <= 0 ? 0 : depth(n - 1);
+  }
+}
+`,
+    'src/main/java/app/HashCodeBuilder.java': `package app;
+
+public class HashCodeBuilder {
+  public static int reflectionHashCode(final int initial, final int multiplier, final Object object) {
+    return initial * multiplier;
+  }
+
+  public static int reflectionHashCode(final Object object, final String... excludeFields) {
+    return 1;
+  }
+}
+`,
+    'src/main/java/app/Point.java': `package app;
+
+public class Point {
+  public int hash() {
+    return HashCodeBuilder.reflectionHashCode(this);
+  }
+}
+`,
+    'src/Json/Convert.cs': `namespace App
+{
+    public static class Convert
+    {
+        public static string DeserializeXNode(string value)
+        {
+            return DeserializeXNode(value, null);
+        }
+
+        public static string DeserializeXNode(string value, string root)
+        {
+            return value + root;
+        }
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `callerLine -> targetLine` of the calls between same-named methods of a file. */
+const selfNamed = (file: string, name: string) => {
+  const nodes = cg.getNodesInFile(file).filter((n) => n.name === name);
+  const ids = new Set(nodes.map((n) => n.id));
+  return cg.getOutgoingEdgesFrom([...ids]).filter((e) => e.kind === 'calls' && ids.has(e.target))
+    .map((e) => `${cg.getNode(e.source)!.startLine} -> ${cg.getNode(e.target)!.startLine}`);
+};
+
+describe('a method calling its own name', () => {
+  it('Java: reaches the overload the arguments fit; real recursion stays', () => {
+    expect(selfNamed('src/main/java/app/Instants.java', 'toInstant')).toEqual(['4 -> 8']);
+    expect(selfNamed('src/main/java/app/Instants.java', 'depth')).toEqual(['12 -> 12']);
+  });
+
+  it('from another class: reaches the overload the arguments fit, not the first indexed', () => {
+    const hash = cg.getNodesInFile('src/main/java/app/Point.java').find((n) => n.name === 'hash')!;
+    const lines = cg.getOutgoingEdges(hash.id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!)
+      .filter((t) => t.name === 'reflectionHashCode').map((t) => t.startLine);
+    expect(lines).toEqual([8]);
+  });
+
+  it('C#: reaches the overload the arguments fit', () => {
+    expect(selfNamed('src/Json/Convert.cs', 'DeserializeXNode')).toEqual(['5 -> 10']);
+  });
+});
diff --git a/__tests__/setup-home-sandbox.ts b/__tests__/setup-home-sandbox.ts
new file mode 100644
index 0000000000..5acb473944
--- /dev/null
+++ b/__tests__/setup-home-sandbox.ts
@@ -0,0 +1,66 @@
+/**
+ * Give every engine test file a throwaway home directory (#2275).
+ *
+ * The suite exercises code that writes to the user's GLOBAL state: the Claude
+ * prompt hook in `~/.claude/settings.json`, the daemon registry under
+ * `~/.codegraph/daemons`, every agent target's global config. A test that
+ * forgot to redirect the home dir wrote to the developer's real one — a
+ * successful fake `codegraph upgrade` wired the prompt hook into their own
+ * Claude profile, and the daemon suites left thousands of registry records
+ * behind. CI never noticed: its runners have no Claude profile to edit.
+ *
+ * So the home dir is redirected here, before any test module loads, rather
+ * than file by file. Everything that resolves a home dir is covered:
+ * `os.homedir()` reads HOME on POSIX but USERPROFILE on Windows; git on
+ * Windows falls back to HOMEDRIVE+HOMEPATH; the per-agent overrides
+ * (CLAUDE_CONFIG_DIR, CODEX_HOME, ...) win over either, so they are cleared;
+ * and git's global config is pinned to a seeded file, so a test's `git
+ * commit` neither reads the developer's identity, signing or hooks nor
+ * depends on them. Spawned CLI / MCP processes inherit all of it.
+ *
+ * Tests that redirect the home dir themselves (spying on `os.homedir`, or
+ * setting HOME and restoring it) keep working: they restore to this sandbox.
+ */
+import { afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+// Resolved, so a comparison against a realpath'd cwd (macOS `/var` →
+// `/private/var`) sees the same home everything else does.
+const home = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-test-home-')));
+
+process.env.HOME = home;
+process.env.USERPROFILE = home;
+if (process.platform === 'win32') {
+  const drive = /^([A-Za-z]:)(\\.*)$/.exec(home);
+  if (drive) {
+    process.env.HOMEDRIVE = drive[1];
+    process.env.HOMEPATH = drive[2];
+  }
+  process.env.APPDATA = path.join(home, 'AppData', 'Roaming');
+  process.env.LOCALAPPDATA = path.join(home, 'AppData', 'Local');
+} else {
+  // Only ever set on Windows in real life; on POSIX a stray one would point
+  // the opencode/Copilot legacy-path logic somewhere real.
+  delete process.env.APPDATA;
+  delete process.env.LOCALAPPDATA;
+}
+process.env.XDG_CONFIG_HOME = path.join(home, '.config');
+for (const override of ['CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'COPILOT_HOME', 'HERMES_HOME']) {
+  delete process.env[override];
+}
+
+// Both spellings: GIT_CONFIG_GLOBAL for git >= 2.32, and `$HOME/.gitconfig`
+// (the same file) for older ones.
+const gitConfig = path.join(home, '.gitconfig');
+fs.writeFileSync(gitConfig, '[user]\n\tname = CodeGraph Test\n\temail = test@codegraph.invalid\n');
+process.env.GIT_CONFIG_GLOBAL = gitConfig;
+
+afterAll(() => {
+  try {
+    fs.rmSync(home, { recursive: true, force: true, maxRetries: 3 });
+  } catch {
+    /* a straggling child still holding a file there; it's in the temp dir */
+  }
+});
diff --git a/__tests__/sfc-component-owns-script.test.ts b/__tests__/sfc-component-owns-script.test.ts
new file mode 100644
index 0000000000..4941e04e56
--- /dev/null
+++ b/__tests__/sfc-component-owns-script.test.ts
@@ -0,0 +1,101 @@
+/**
+ * A Vue / Svelte / Astro file is one file node holding the component it is,
+ * and the component holds its script: each symbol has one parent, and a
+ * component never contains its own file. What a per-instance script does at
+ * its top level — `<script setup>`, a Svelte instance script, Astro's
+ * frontmatter — is the component's doing (a Nuxt page's `useAsyncData(…)`, a
+ * Svelte page's `onMount(…)`); a module-level script's, and every import,
+ * stays with the file.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadAllGrammars } from '../src/extraction/grammars';
+import type { ExtractionResult } from '../src/types';
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadAllGrammars();
+});
+
+const componentOf = (r: ExtractionResult) => r.nodes.find((n) => n.kind === 'component')!;
+const from = (r: ExtractionResult, name: string) =>
+  r.unresolvedReferences.filter((ref) => ref.referenceName === name && ref.referenceKind === 'calls').map((ref) => ref.fromNodeId);
+const parents = (r: ExtractionResult) => {
+  const out = new Map<string, string[]>();
+  for (const e of r.edges) if (e.kind === 'contains') out.set(e.target, [...(out.get(e.target) ?? []), e.source]);
+  return out;
+};
+
+describe('a single-file component’s structure', () => {
+  it('is a file holding the component holding the script, one parent each', () => {
+    const r = extractFromSource('pages/index.vue', `<template><button @click="load">Load</button></template>
+<script setup lang="ts">
+import { useFetch } from '#app';
+const data = useFetch('/api/items');
+function load() {
+  return data;
+}
+</script>
+`);
+    const file = r.nodes.find((n) => n.kind === 'file')!;
+    const component = componentOf(r);
+    expect(file).toMatchObject({ id: 'file:pages/index.vue', startLine: 1, endLine: 9 });
+    const p = parents(r);
+    expect(p.get(component.id)).toEqual([file.id]);
+    expect(p.get(file.id)).toBeUndefined();
+    const load = r.nodes.find((n) => n.name === 'load')!;
+    expect(p.get(load.id)).toEqual([component.id]);
+    for (const [, list] of p) expect(list).toHaveLength(1);
+  });
+
+  it('gives a <script setup>’s top-level calls to the component, and its imports to the file', () => {
+    const r = extractFromSource('pages/index.vue', `<template><div /></template>
+<script setup lang="ts">
+import { useFetch } from '#app';
+const data = useFetch('/api/items');
+</script>
+`);
+    expect(from(r, 'useFetch').filter((id) => id.startsWith('component:'))).toHaveLength(1);
+    expect(r.unresolvedReferences.filter((ref) => ref.referenceKind === 'imports').every((ref) => ref.fromNodeId === 'file:pages/index.vue')).toBe(true);
+  });
+
+  it('leaves a plain <script>’s module-level calls with the file', () => {
+    const r = extractFromSource('src/Widget.vue', `<template><div /></template>
+<script>
+registerWidget('widget');
+export default { name: 'Widget' };
+</script>
+`);
+    expect(from(r, 'registerWidget')).toEqual(['file:src/Widget.vue']);
+  });
+
+  it('gives a Svelte instance script to the component, and a module script to the file', () => {
+    const r = extractFromSource('src/routes/+page.svelte', `<script context="module">
+  preload();
+</script>
+<script module>
+  register();
+</script>
+<script>
+  import { onMount } from 'svelte';
+  onMount(() => fetchItems());
+</script>
+<p>items</p>
+`);
+    const component = componentOf(r).id;
+    expect(from(r, 'onMount')).toEqual([component]);
+    expect(from(r, 'preload')).toEqual(['file:src/routes/+page.svelte']);
+    expect(from(r, 'register')).toEqual(['file:src/routes/+page.svelte']);
+  });
+
+  it('gives Astro frontmatter to the component, and makes a file node for a file without one', () => {
+    const r = extractFromSource('src/pages/blog.astro', `---
+const posts = await getCollection('blog');
+---
+<ul>{posts.map((p) => <li>{p.title}</li>)}</ul>
+`);
+    expect(from(r, 'getCollection')).toEqual([componentOf(r).id]);
+    const bare = extractFromSource('src/pages/about.astro', `<p>about</p>\n`);
+    expect(bare.nodes.map((n) => n.kind).sort()).toEqual(['component', 'file']);
+  });
+});
diff --git a/__tests__/sfc-private-declarations.test.ts b/__tests__/sfc-private-declarations.test.ts
new file mode 100644
index 0000000000..640e3d56f1
--- /dev/null
+++ b/__tests__/sfc-private-declarations.test.ts
@@ -0,0 +1,94 @@
+/**
+ * What a Svelte component's instance `<script>` or a Vue SFC's `<script setup>`
+ * declares is the component's own — no other file reaches it by name. Only a
+ * Svelte `<script module>`, a Vue `<script>` that is not `setup`, or a type a
+ * `<script setup>` exports can be imported. shadcn-svelte's `<Item.Root>` (a
+ * namespace import) went to a `type Item` one example component declares,
+ * and halo's `isActive` from `@/tiptap/core` to a tab's local `computed`.
+ */
+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-sfc-private-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'docs', private: true }),
+    'src/lib/examples/attachment-group.svelte': `<script lang="ts">
+	type Item = {
+		name: string;
+	};
+	const items: Item[] = [];
+</script>
+
+<div>{items.length}</div>
+`,
+    'src/lib/examples/item-demo.svelte': `<script lang="ts">
+	import * as Item from "$lib/ui/item/index.js";
+	let label: Item = null;
+</script>
+
+<Item.Root>{label}</Item.Root>
+`,
+    'src/components/TabItem.vue': `<script lang="ts" setup>
+import { computed } from "vue";
+const isActive = computed(() => true);
+</script>
+
+<template><div v-if="isActive" /></template>
+`,
+    'src/extensions/code-block.ts': `import { isActive } from "@/tiptap/core";
+
+export function active(state: unknown) {
+  return isActive(state);
+}
+`,
+    'src/components/CrudTable.vue': `<script setup lang="ts">
+export interface TableConfig {
+  hideColumns: boolean;
+}
+defineProps<{ config: TableConfig }>();
+</script>
+
+<template><table /></template>
+`,
+    'src/pages/GroupDataPage.vue': `<script setup lang="ts">
+import type { TableConfig } from "~/components/CrudTable.vue";
+const config: TableConfig = { hideColumns: false };
+</script>
+
+<template><div>{{ config }}</div></template>
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetsFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.name}`);
+};
+
+describe('single-file component declarations', () => {
+  it('are private to the component', () => {
+    expect(targetsFrom('src/lib/examples/item-demo.svelte')).not.toContain('src/lib/examples/attachment-group.svelte:Item');
+    expect(targetsFrom('src/extensions/code-block.ts')).not.toContain('src/components/TabItem.vue:isActive');
+  });
+
+  it('except a type a Vue <script setup> exports', () => {
+    expect(targetsFrom('src/pages/GroupDataPage.vue')).toContain('src/components/CrudTable.vue:TableConfig');
+  });
+});
diff --git a/__tests__/solidity-erlang-call-scope.test.ts b/__tests__/solidity-erlang-call-scope.test.ts
new file mode 100644
index 0000000000..2ced668f58
--- /dev/null
+++ b/__tests__/solidity-erlang-call-scope.test.ts
@@ -0,0 +1,98 @@
+/**
+ * A call written without a receiver reaches what its language lets it:
+ *
+ * - Solidity: a function of the contract around the call or of one it
+ *   inherits (OpenZeppelin's `_msgSender()` in a Context-derived Governor
+ *   went to ERC2771Context's override 83 times);
+ * - Erlang: another module's function only through `-import(Mod, [f/N])`
+ *   (cowboy's `-import(req_SUITE, [do_get/3])` went to compress_SUITE's
+ *   `do_get/3`).
+ */
+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-sol-erl-scope-'));
+  const files: Record<string, string> = {
+    'contracts/Context.sol': `pragma solidity ^0.8.20;
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+}
+`,
+    'contracts/ERC2771Context.sol': `pragma solidity ^0.8.20;
+
+import {Context} from "./Context.sol";
+
+abstract contract ERC2771Context is Context {
+    function _msgSender() internal view virtual override returns (address) {
+        return msg.sender;
+    }
+}
+`,
+    'contracts/Governor.sol': `pragma solidity ^0.8.20;
+
+import {Context} from "./Context.sol";
+
+abstract contract Governor is Context {
+    function castVote() public returns (address) {
+        return _msgSender();
+    }
+}
+`,
+    'test/req_SUITE.erl': `-module(req_SUITE).
+-export([do_get/3]).
+
+do_get(Path, Headers, Config) -> {Path, Headers, Config}.
+`,
+    'test/compress_SUITE.erl': `-module(compress_SUITE).
+-export([do_get/3]).
+
+do_get(Path, Headers, Config) -> {Path, Headers, Config}.
+`,
+    'test/static_handler_SUITE.erl': `-module(static_handler_SUITE).
+-export([etag/1]).
+-import(req_SUITE, [do_get/3]).
+
+etag(Config) -> do_get("/etag", [], Config).
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('receiver-less calls', () => {
+  it('Solidity: reach the inherited function, not a sibling override', () => {
+    expect(callsFrom('contracts/Governor.sol')).toEqual(['Context::_msgSender']);
+  });
+
+  it('Erlang: reach the module the file imports the function from', () => {
+    expect(callsFrom('test/static_handler_SUITE.erl')).toEqual(['req_SUITE::do_get/3']);
+  });
+});
diff --git a/__tests__/solidity-overload-calls.test.ts b/__tests__/solidity-overload-calls.test.ts
new file mode 100644
index 0000000000..adc5217ae5
--- /dev/null
+++ b/__tests__/solidity-overload-calls.test.ts
@@ -0,0 +1,49 @@
+/**
+ * Solidity overloads by parameter count like the other overloading
+ * languages: OpenZeppelin's `_checkRole(role, _msgSender())` inside the
+ * one-argument `_checkRole(bytes32 role)` is the two-argument overload, not
+ * a call to itself.
+ */
+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-sol-overload-'));
+  const files: Record<string, string> = {
+    'contracts/access/AccessControl.sol': `pragma solidity ^0.8.20;
+
+abstract contract AccessControl {
+    function _checkRole(bytes32 role) internal view virtual {
+        _checkRole(role, msg.sender);
+    }
+
+    function _checkRole(bytes32 role, address account) internal view virtual {
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Solidity overloads', () => {
+  it('a call reaches the overload its argument count fits', () => {
+    const ids = cg.getNodesInFile('contracts/access/AccessControl.sol').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls' && e.line === 5).map((e) => cg.getNode(e.target)!.startLine);
+    expect(targets).toEqual([8]);
+  });
+});
diff --git a/__tests__/spring-model-name-scope.test.ts b/__tests__/spring-model-name-scope.test.ts
new file mode 100644
index 0000000000..d8d60c7c29
--- /dev/null
+++ b/__tests__/spring-model-name-scope.test.ts
@@ -0,0 +1,64 @@
+/**
+ * The Spring resolver's name heuristics (an entity under `/model/`, a
+ * `…Service`, a `…Controller`) start from what the reference's own scope
+ * declares — its file, then its package — and never reach a class nested in
+ * another file's class by its bare name: every MyBatis `XExample` declares its
+ * own nested `Criteria`, and mall's `new Criteria()` all went to the first.
+ */
+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;
+
+const example = (name: string) => `package com.macro.mall.model;
+
+public class ${name} {
+    public Criteria createCriteria() {
+        Criteria criteria = new Criteria();
+        return criteria;
+    }
+
+    public static class Criteria {
+    }
+}
+`;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-spring-model-'));
+  const files: Record<string, string> = {
+    'pom.xml': '<project><dependency>spring-boot-starter</dependency></project>\n',
+    'mall-mbg/src/main/java/com/macro/mall/model/CmsHelpCategoryExample.java': example('CmsHelpCategoryExample'),
+    'mall-mbg/src/main/java/com/macro/mall/model/OmsOrderExample.java': example('OmsOrderExample'),
+    'mall-admin/src/main/java/com/macro/mall/service/OrderService.java': `package com.macro.mall.service;
+
+@Service
+public class OrderService {
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Spring name heuristics', () => {
+  it('resolve a name to its own file’s nested class, not another file’s', () => {
+    const file = 'mall-mbg/src/main/java/com/macro/mall/model/OmsOrderExample.java';
+    const ids = cg.getNodesInFile(file).map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'instantiates' || e.kind === 'references')
+      .map((e) => cg.getNode(e.target)!).filter((t) => t.name === 'Criteria').map((t) => t.filePath);
+    expect(targets.length).toBeGreaterThan(0);
+    expect(new Set(targets)).toEqual(new Set([file]));
+  });
+});
diff --git a/__tests__/status-index-health.test.ts b/__tests__/status-index-health.test.ts
new file mode 100644
index 0000000000..b94562c8eb
--- /dev/null
+++ b/__tests__/status-index-health.test.ts
@@ -0,0 +1,159 @@
+/**
+ * `codegraph status` must not call an index "up to date" while indexed files
+ * are missing their symbols (#2336, #2335).
+ *
+ * "Up to date" used to mean only "every file's content hash matches the
+ * index". Two kinds of file pass that check with nothing usable in the graph:
+ *
+ *   - a file the parser could not read — `export type * from` is valid
+ *     TypeScript 5.0 the bundled grammar has no rule for, so the file is stored
+ *     with a parse error and no symbols (#2336);
+ *   - a row stored without its symbols — by an engine whose grammar failed to
+ *     load (#2335), or the #1541 wipe — which `codegraph sync` re-indexes.
+ *
+ * Both are counted in `status` (human and `--json`), and `files --json` carries
+ * each file's recorded errors. Exercised against the built CLI so the output
+ * and the JSON field names are what users and scripts actually see.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const BIN = path.resolve(__dirname, '../dist/bin/codegraph.js');
+
+function spawn(cwd: string, args: string[]) {
+  return spawnSync(process.execPath, [BIN, ...args], {
+    cwd,
+    encoding: 'utf-8',
+    timeout: 30_000,
+    env: {
+      ...process.env,
+      CODEGRAPH_NO_DAEMON: '1',
+      CODEGRAPH_TELEMETRY: '0',
+      CODEGRAPH_NO_UPDATE_CHECK: '1',
+      NO_COLOR: '1',
+    },
+  });
+}
+
+function run(cwd: string, args: string[]): { status: number | null; out: string } {
+  const result = spawn(cwd, args);
+  return { status: result.status, out: (result.stdout ?? '') + (result.stderr ?? '') };
+}
+
+function runJson(cwd: string, args: string[]): any {
+  const result = spawn(cwd, args);
+  expect(result.status, (result.stdout ?? '') + (result.stderr ?? '')).toBe(0);
+  return JSON.parse(result.stdout);
+}
+
+describe('status reports files indexed without their symbols (#2336, #2335)', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-status-health-'));
+    fs.mkdirSync(path.join(dir, 'src', 'constants'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'src', 'types'), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'src', 'constants', 'index.ts'),
+      'export const MAX_ITEMS = 10;\nexport function clamp(n: number): number { return Math.min(n, MAX_ITEMS); }\n'
+    );
+    fs.writeFileSync(
+      path.join(dir, 'src', 'types', 'database.ts'),
+      'export interface Row { id: number; name: string }\nexport type RowId = Row["id"];\n'
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  async function index(): Promise<void> {
+    const cg = CodeGraph.initSync(dir);
+    await cg.indexAll();
+    cg.destroy();
+  }
+
+  it('a clean index is up to date, with zero counts and empty error lists', async () => {
+    await index();
+
+    const human = run(dir, ['status']);
+    expect(human.status, human.out).toBe(0);
+    expect(human.out).toContain('Index is up to date');
+
+    const json = runJson(dir, ['status', '--json']);
+    expect(json.index.filesNeedingReindex).toBe(0);
+    expect(json.index.filesWithParseErrors).toBe(0);
+
+    const files = runJson(dir, ['files', '--json']);
+    expect(files).toHaveLength(2);
+    for (const f of files) expect(f.errors).toEqual([]);
+  });
+
+  it('a file the parser could not read keeps status from reporting "up to date"', async () => {
+    fs.writeFileSync(
+      path.join(dir, 'src', 'index.ts'),
+      'export * from "./constants/index.js";\nexport type * from "./types/database.js";\n'
+    );
+    await index();
+
+    const human = run(dir, ['status']);
+    expect(human.status, human.out).toBe(0);
+    expect(human.out).not.toContain('Index is up to date');
+    expect(human.out).toMatch(/1 file could not be parsed/);
+    expect(human.out).toContain('src/index.ts');
+
+    const json = runJson(dir, ['status', '--json']);
+    expect(json.index.filesWithParseErrors).toBe(1);
+    expect(json.index.filesNeedingReindex).toBe(0);
+
+    const files = runJson(dir, ['files', '--json']);
+    const broken = files.find((f: any) => f.path === 'src/index.ts');
+    expect(broken.errors).toHaveLength(1);
+    expect(broken.errors[0]).toMatchObject({ severity: 'warning', code: 'parse_error' });
+    expect(broken.errors[0].message).toContain('parse produced no symbols');
+    expect(files.find((f: any) => f.path === 'src/constants/index.ts').errors).toEqual([]);
+  });
+
+  it('rows stored without their symbols ask for a sync, and the sync repairs them', async () => {
+    await index();
+
+    // A row v1.6.2 wrote with its grammar missing (#2335), and a #1541 wipe:
+    // both carry the current content hash, so the hash check calls them current.
+    const { DatabaseSync } = require('node:sqlite');
+    const db = new DatabaseSync(path.join(dir, '.codegraph', 'codegraph.db'));
+    db.prepare('DELETE FROM nodes WHERE file_path IN (?, ?)').run('src/constants/index.ts', 'src/types/database.ts');
+    db.prepare('UPDATE files SET node_count = 0, errors = ? WHERE path = ?').run(
+      JSON.stringify([{ message: 'Failed to get parser for language: typescript', severity: 'error', code: 'parser_error' }]),
+      'src/constants/index.ts'
+    );
+    db.prepare('UPDATE files SET node_count = 0 WHERE path = ?').run('src/types/database.ts');
+    db.close();
+
+    const human = run(dir, ['status']);
+    expect(human.status, human.out).toBe(0);
+    expect(human.out).not.toContain('Index is up to date');
+    expect(human.out).toMatch(/2 files are missing their symbols/);
+    expect(human.out).toContain('codegraph sync');
+
+    const json = runJson(dir, ['status', '--json']);
+    expect(json.index.filesNeedingReindex).toBe(2);
+    expect(json.index.filesWithParseErrors).toBe(0);
+    expect(json.pendingChanges).toEqual({ added: 0, modified: 0, removed: 0 });
+
+    const synced = run(dir, ['sync']);
+    expect(synced.status, synced.out).toBe(0);
+
+    const after = runJson(dir, ['status', '--json']);
+    expect(after.index.filesNeedingReindex).toBe(0);
+    expect(run(dir, ['status']).out).toContain('Index is up to date');
+    const files = runJson(dir, ['files', '--json']);
+    for (const f of files) {
+      expect(f.nodeCount).toBeGreaterThan(1);
+      expect(f.errors).toEqual([]);
+    }
+  });
+});
diff --git a/__tests__/store-exported-later.test.ts b/__tests__/store-exported-later.test.ts
index 19c124f1de..c5cf774ef1 100644
--- a/__tests__/store-exported-later.test.ts
+++ b/__tests__/store-exported-later.test.ts
@@ -48,6 +48,20 @@ describe('store actions on a later-exported const', () => {
     expect(fnNames(asDefault)).toContain('bump');
   });
 
+  it.each([
+    ['items$', 'export { items$ };', true],
+    ['$items', 'export { $items as default };', true],
+    ['items', 'export { items$ };', false],
+    ['items', 'export { $items };', false],
+  ] as const)('an export clause names %s only whole: `%s`', (name, exportLine, kept) => {
+    // A `$` belongs to the name: `items$` is exported, `items` is not.
+    const code = `
+      const ${name} = create((set) => ({ inc: () => set({}) }))
+      ${exportLine}
+    `;
+    expect(fnNames(code).includes('inc')).toBe(kept);
+  });
+
   it('a const nothing exports keeps its members out of the graph', () => {
     const code = `
       const useStore = create((set) => ({ bump: () => set({}) }))
diff --git a/__tests__/super-call-self-edge.test.ts b/__tests__/super-call-self-edge.test.ts
new file mode 100644
index 0000000000..6067a54919
--- /dev/null
+++ b/__tests__/super-call-self-edge.test.ts
@@ -0,0 +1,96 @@
+/**
+ * A `super` call inside an override calls the parent's implementation, never
+ * the method making the call.
+ *
+ * Extraction keeps `super.didMoveToWindow()` under the bare method name, so
+ * every strategy resolved it to the enclosing override itself — a self-edge
+ * that made a view's lifecycle methods look recursive (eleven of one
+ * expo-camera view's overrides). Real recursion keeps its edge.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+async function project(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-super-self-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+/** `Owner.method` names of every method whose calls include itself. */
+function selfCalling(cg: CodeGraph): string[] {
+  const out: string[] = [];
+  for (const kind of ['method', 'function'] as const) {
+    for (const n of cg.getNodesByKind(kind)) {
+      if (cg.getOutgoingEdges(n.id).some((e) => e.kind === 'calls' && e.target === n.id)) out.push(n.name);
+    }
+  }
+  return out.sort();
+}
+
+describe('a super call is not a self-call', () => {
+  it('Swift, Kotlin, Java, Python, TypeScript and C#', async () => {
+    const cg = await project({
+      'ios/CameraView.swift': `import UIKit
+class CameraView: UIView {
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    setup()
+  }
+  func setup() {}
+  func countdown(_ n: Int) {
+    if n > 0 { countdown(n - 1) }
+  }
+}
+`,
+      'android/CameraView.kt': `package app
+class CameraView(context: Context) : FrameLayout(context) {
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+  }
+}
+`,
+      'java/Service.java': `package app;
+public class Service extends Base {
+  @Override
+  public void start() {
+    super.start();
+  }
+}
+`,
+      'py/views.py': `class ProfileView(BaseView):
+    def dispatch(self, request):
+        return super().dispatch(request)
+`,
+      'ts/list.ts': `export class List extends Base {
+  render(): string {
+    return super.render() + '!';
+  }
+}
+`,
+      'cs/Handler.cs': `public class Handler : BaseHandler {
+  public override void Handle() {
+    base.Handle();
+  }
+}
+`,
+    });
+    try {
+      // Only the real recursion is left.
+      expect(selfCalling(cg)).toEqual(['countdown']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/supertype-not-self.test.ts b/__tests__/supertype-not-self.test.ts
new file mode 100644
index 0000000000..8db453ed14
--- /dev/null
+++ b/__tests__/supertype-not-self.test.ts
@@ -0,0 +1,73 @@
+/**
+ * A type never inherits from itself. cats' `trait BigDecimalInstances extends
+ * cats.kernel.instances.BigDecimalInstances` and `trait AllOps … with
+ * Functor.AllOps[F, A]` reached the resolver by the bare name they share with
+ * the declaring trait, and 111 such `extends` pointed back at it. The
+ * supertype is the other type of that name the written qualifier leads to.
+ */
+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-super-self-'));
+  const files: Record<string, string> = {
+    'kernel/src/main/scala/cats/kernel/instances/BigDecimalInstances.scala': `package cats.kernel
+package instances
+
+trait BigDecimalInstances {
+  def order: Int = 0
+}
+`,
+    'core/src/main/scala/cats/instances/bigDecimal.scala': `package cats
+package instances
+
+trait BigDecimalInstances extends cats.kernel.instances.BigDecimalInstances {
+  def show: String = ""
+}
+`,
+    'core/src/main/scala/cats/Functor.scala': `package cats
+
+object Functor {
+  trait AllOps[F[_], A]
+}
+
+object Apply {
+  trait AllOps[F[_], A] extends Functor.AllOps[F, A]
+}
+
+object Foldable {
+  trait AllOps[F[_], A]
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const supertypesOf = (file: string, qualifiedName: string) => {
+  const ids = cg.getNodesInFile(file).filter((n) => n.qualifiedName === qualifiedName).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'extends').map((e) => cg.getNode(e.target)!).map((t) => `${t.filePath}:${t.qualifiedName}`);
+};
+
+describe('a supertype sharing the declaring type’s name', () => {
+  it('is the other type the written qualifier names', () => {
+    expect(supertypesOf('core/src/main/scala/cats/instances/bigDecimal.scala', 'BigDecimalInstances'))
+      .toEqual(['kernel/src/main/scala/cats/kernel/instances/BigDecimalInstances.scala:BigDecimalInstances']);
+    expect(supertypesOf('core/src/main/scala/cats/Functor.scala', 'Apply::AllOps'))
+      .toEqual(['core/src/main/scala/cats/Functor.scala:Functor::AllOps']);
+  });
+});
diff --git a/__tests__/sveltekit-route-names.test.ts b/__tests__/sveltekit-route-names.test.ts
new file mode 100644
index 0000000000..1f7ab5e465
--- /dev/null
+++ b/__tests__/sveltekit-route-names.test.ts
@@ -0,0 +1,61 @@
+/**
+ * SvelteKit route names are the URL a browser asks for.
+ *
+ * - A `(group)` directory organizes layouts and never appears in the URL:
+ *   shadcn-svelte's `src/routes/(app)/(layout)/blocks/+page.svelte` is `/blocks`.
+ * - `[param=matcher]` is a parameter whose value a matcher checks: `/view/:view`.
+ *
+ * Named with the groups, no `goto('/blocks')` or `<a href="/blocks">` ever
+ * matched its page.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+describe('SvelteKit route names', () => {
+  it('drop (group) directories and parameter matchers', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sveltekit-groups-'));
+    roots.push(root);
+    const files: Record<string, string> = {
+      'package.json': JSON.stringify({ name: 'site', devDependencies: { '@sveltejs/kit': '*', svelte: '*' } }),
+      'src/routes/(app)/(layout)/blocks/+page.svelte': `<h1>Blocks</h1>
+`,
+      'src/routes/(app)/(layout)/+page.svelte': `<script>
+  import { goto } from '$app/navigation';
+</script>
+<button on:click={() => goto('/blocks')}>Blocks</button>
+<a href="/view/card">Card</a>
+`,
+      'src/routes/(view)/view/[view=view]/+page.svelte': `<p>view</p>
+`,
+      'src/routes/docs/[...slug=doc]/+page.svelte': `<p>doc</p>
+`,
+      'src/params/view.ts': `export function match(p: string) { return p.length > 0; }
+`,
+    };
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const routes = cg.getNodesByKind('route').map((n) => n.name).sort();
+      expect(routes).toEqual(['/', '/blocks', '/docs/*slug', '/view/:view']);
+      const home = cg.getNodesByKind('route').find((n) => n.name === '/')!;
+      const navigates = cg
+        .getOutgoingEdgesFrom(cg.getNodesInFile(home.filePath).map((n) => n.id), ['navigates' as never])
+        .map((e) => cg.getNode(e.target)!.name)
+        .sort();
+      expect(navigates).toEqual(['/blocks', '/view/:view']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/swift-call-shape.test.ts b/__tests__/swift-call-shape.test.ts
new file mode 100644
index 0000000000..0f999609b7
--- /dev/null
+++ b/__tests__/swift-call-shape.test.ts
@@ -0,0 +1,133 @@
+/**
+ * Swift's extractor keeps one receiver level, so `super.reset()`,
+ * `axis.entries.removeAll()` and `min(a, b)` reach the resolver as bare
+ * names. How the call is written decides what it can mean:
+ *
+ * - bare or through `self.`: a member of a type around the call or of what it
+ *   inherits or conforms to (UIKit ancestry and the standard collection
+ *   protocols included), the nearest first — `super.`: the latter only.
+ *   Charts' `min(a, b)` went to a range type's `min` field, `max(a, b)` to a
+ *   `Sequence` extension, `super.init(…)` to an Objective-C demo's `init`;
+ * - down a longer chain, a name the standard types all carry is theirs unless
+ *   the receiver names the owner or the call gives a label only the project's
+ *   method takes (Kingfisher's `data.kf.contains(jpeg:)`);
+ * - a global `let` in a playground is nobody else's call target.
+ */
+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-swift-shape-'));
+  const files: Record<string, string> = {
+    'Sources/Charts/Utils/Sequence+KeyPath.swift': `extension Sequence {
+    func max<T: Comparable>(by keyPath: KeyPath<Element, T>) -> Element? {
+        return nil
+    }
+}
+`,
+    'Sources/Charts/Renderers/Renderer.swift': `open class Renderer {
+    public struct XBounds {
+        public var min: Int = 0
+    }
+}
+`,
+    'Sources/Charts/Data/ChartData.swift': `open class ChartData {
+    open func removeAll() { }
+}
+`,
+    'Sources/Charts/Formatters/Formatter.swift': `open class Formatter {
+    open func reset() { }
+}
+`,
+    'Sources/Charts/Charts/ChartViewBase.swift': `open class ChartViewBase: NSObject {
+    open func highlightValue(_ h: Int) { }
+    open func reset() { }
+}
+`,
+    'Sources/Charts/Charts/BarChartView.swift': `open class BarChartView: ChartViewBase {
+    open override func highlightValue(_ h: Int) { }
+}
+`,
+    'Sources/Charts/Charts/BarLineChartViewBase.swift': `open class BarLineChartViewBase: ChartViewBase {
+    open func tapped(axis: Axis) {
+        highlightValue(1)
+        let widest = max(1, 2)
+        let narrowest = min(3, 4)
+        super.reset()
+        axis.entries.removeAll()
+    }
+}
+`,
+    'Sources/Charts/Wrapper/KingfisherWrapper.swift': `public struct KingfisherWrapper<Base> {
+    public let base: Base
+}
+
+extension KingfisherWrapper where Base == Data {
+    func contains(jpeg marker: Int) -> Bool {
+        return false
+    }
+}
+`,
+    'Sources/Charts/Wrapper/Decoder.swift': `final class Decoder {
+    func scan(data: Data) -> Bool {
+        return data.kf.contains(jpeg: 0xC2)
+    }
+}
+`,
+    'Demo/Extensions/UIViewController+Bar.swift': `extension UIViewController {
+    func setupOperationBar() { }
+}
+`,
+    'Demo/Controllers/ListController.swift': `class ListController: UICollectionViewController {
+    override func viewDidLoad() {
+        setupOperationBar()
+    }
+}
+`,
+    'Demo/Chart.playground/Contents.swift': `let min = 20.0
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('Swift calls reached by name alone', () => {
+  it('reach the nearest inherited member, and nothing outside the hierarchy', () => {
+    expect(callsFrom('Sources/Charts/Charts/BarLineChartViewBase.swift')).toEqual([
+      'ChartViewBase::highlightValue',
+      'ChartViewBase::reset',
+    ]);
+  });
+
+  it('keep a standard-named method the call labels as the project’s', () => {
+    expect(callsFrom('Sources/Charts/Wrapper/Decoder.swift')).toEqual(['KingfisherWrapper::contains']);
+  });
+
+  it('reach an extension of a UIKit ancestor', () => {
+    expect(callsFrom('Demo/Controllers/ListController.swift')).toEqual(['UIViewController::setupOperationBar']);
+  });
+});
diff --git a/__tests__/swift-constructed-receiver.test.ts b/__tests__/swift-constructed-receiver.test.ts
new file mode 100644
index 0000000000..a92ececa39
--- /dev/null
+++ b/__tests__/swift-constructed-receiver.test.ts
@@ -0,0 +1,62 @@
+/**
+ * A Swift call on a just-constructed value — `URLQueryDecoder().decode(…)`,
+ * `JSONDecoder().decode(…)` — is a member of the type constructed (or of what
+ * it inherits), never some other type's method of that name: vapor's
+ * `JSONDecoder().decode` went to a request's private
+ * `_URLQueryContainer.decode`, and so did its own decoders' calls.
+ */
+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-swift-constructed-'));
+  const files: Record<string, string> = {
+    'Sources/App/URLQueryDecoder.swift': `struct URLQueryDecoder {
+    func decode<D>(_ type: D.Type) -> Int {
+        return 0
+    }
+}
+`,
+    'Sources/App/Request.swift': `struct Request {
+    struct _Container {
+        func decode<D>(_ type: D.Type) -> Int {
+            return 1
+        }
+    }
+}
+`,
+    'Sources/App/Use.swift': `import Foundation
+
+func run(data: Data) throws -> Int {
+    let a = URLQueryDecoder().decode(Int.self)
+    let b = try JSONDecoder().decode(Int.self, from: data)
+    return a + b
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Swift calls on a constructed value', () => {
+  it('reach the constructed type’s member, and no other type’s', () => {
+    const run = cg.getNodesInFile('Sources/App/Use.swift').find((n) => n.name === 'run')!;
+    const decodes = cg.getOutgoingEdges(run.id).filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!).filter((t) => t.name === 'decode').map((t) => t.qualifiedName);
+    expect(decodes).toEqual(['URLQueryDecoder::decode']);
+  });
+});
diff --git a/__tests__/swift-label-overload.test.ts b/__tests__/swift-label-overload.test.ts
new file mode 100644
index 0000000000..e8ecfb8b6e
--- /dev/null
+++ b/__tests__/swift-label-overload.test.ts
@@ -0,0 +1,62 @@
+/**
+ * Swift overloads by argument label as much as by count: Alamofire's
+ * `self.tableView(tableView, numberOfRowsInSection: section)` inside
+ * `tableView(_:titleForHeaderInSection:)` is the other `tableView`, and
+ * `cancel(optionallyProducingResumeData:)` is not `cancel(producingResumeData:)`.
+ * A call reaches the overload whose labels it spells, defaulted ones optional.
+ */
+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-swift-labels-'));
+  const files: Record<string, string> = {
+    'Sources/TableController.swift': `class TableController {
+    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+        return 0
+    }
+
+    func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
+        if self.tableView(tableView, numberOfRowsInSection: section) == 0 { return nil }
+        return "x"
+    }
+
+    func cancel(producingResumeData shouldProduce: Bool) -> Self {
+        return cancel(optionallyProducingResumeData: nil)
+    }
+
+    private func cancel(optionallyProducingResumeData handler: ((Data?) -> Void)?, retry: Bool = false) -> Self {
+        return self
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const targetLineOfCallAt = (line: number) => {
+  const ids = cg.getNodesInFile('Sources/TableController.swift').map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls' && e.line === line).map((e) => cg.getNode(e.target)!.startLine);
+};
+
+describe('Swift overloads by label', () => {
+  it('reach the overload whose labels the call spells', () => {
+    expect(targetLineOfCallAt(7)).toEqual([2]);
+    expect(targetLineOfCallAt(12)).toEqual([15]);
+  });
+});
diff --git a/__tests__/swift-member-receiver.test.ts b/__tests__/swift-member-receiver.test.ts
new file mode 100644
index 0000000000..629908aa63
--- /dev/null
+++ b/__tests__/swift-member-receiver.test.ts
@@ -0,0 +1,60 @@
+/**
+ * A Swift call on a property the enclosing type declares with a type —
+ * Kingfisher's `var cache: ImageCache!` — is a member of that type (or of
+ * what it inherits): `cache.imageCachedType(forKey:)` is ImageCache's, not a
+ * test subclass's override (`EvictingPrefetchCache`) that shared its name.
+ */
+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-swift-member-'));
+  const files: Record<string, string> = {
+    'Sources/Cache/ImageCache.swift': `open class ImageCache {
+    open func imageCachedType(forKey key: String) -> Int {
+        return 0
+    }
+}
+`,
+    'Tests/KingfisherTests/ImagePrefetcherTests.swift': `class EvictingPrefetchCache: ImageCache {
+    override func imageCachedType(forKey key: String) -> Int {
+        return 1
+    }
+}
+`,
+    'Tests/KingfisherTests/ImageCacheTests.swift': `class ImageCacheTests {
+    var cache: ImageCache!
+
+    func testCachedType() {
+        _ = cache.imageCachedType(forKey: "a")
+        _ = self.cache.imageCachedType(forKey: "b")
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Swift calls on a typed property', () => {
+  it('reach the declared type’s method, not a subclass override elsewhere', () => {
+    const ids = cg.getNodesInFile('Tests/KingfisherTests/ImageCacheTests.swift').map((n) => n.id);
+    const targets = [...new Set(cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName))];
+    expect(targets).toEqual(['ImageCache::imageCachedType']);
+  });
+});
diff --git a/__tests__/swift-type-path-calls.test.ts b/__tests__/swift-type-path-calls.test.ts
new file mode 100644
index 0000000000..3e9d8c0e12
--- /dev/null
+++ b/__tests__/swift-type-path-calls.test.ts
@@ -0,0 +1,135 @@
+/**
+ * A Swift call through a type path lands on the type the path names.
+ *
+ * `API.PackageController.GetRoute.query(on:)` kept only `query`, which
+ * exact-matched whichever type's `query` came first — in a Vapor app every
+ * route type has one, so a health check "called" the dependency controller's
+ * query. The path is now kept and resolved on its type: declared nested,
+ * in `extension API.PackageController { … }`, in `extension A.B.C { … }`,
+ * shortened inside its namespace, or module-qualified. A path that names no
+ * project type is left unresolved.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+const FILES: Record<string, string> = {
+  'Sources/App/API.swift': `enum API {}
+extension API {
+    enum PackageController {
+        enum GetRoute {
+            static func query(on db: Int) -> Int { db }
+            static func query(on db: Int, limit: Int) -> Int { db + limit }
+        }
+        struct Model { let name: String }
+    }
+}
+extension API.PackageController {
+    enum ShowRoute {
+        static func query(on db: Int) -> Int { db }
+    }
+}
+extension API.DependencyController.GetRoute {
+    static func query(on db: Int) -> Int { db }
+}
+extension API {
+    enum DependencyController {
+        enum GetRoute {}
+        static func inside() -> Int { PackageController.GetRoute.query(on: 0) }
+    }
+}
+`,
+  'Sources/App/Other.swift': `enum Other { static func query(on db: Int) -> Int { db } }
+enum Gitlab { enum Error: Swift.Error { case requestFailed(status: Int) } }
+enum Remote { enum Error: Swift.Error { case requestFailed(status: Int) } }
+struct Detail {}
+enum Screens {
+    @Reducer
+    enum Path { case detail(Detail) }
+}
+enum Zed { enum GetRoute { static func query(on db: Int) -> Int { db } } }
+enum Yon { enum GetRoute { static func query(on db: Int) -> Int { db } } }
+`,
+  'Sources/App/Basics.swift': `struct BasicsView {}
+struct ObservableBasicsView {}
+extension BasicsView { struct Feature {} }
+extension ObservableBasicsView { struct Feature {} }
+extension BasicsView.Feature { struct State {} }
+extension ObservableBasicsView.Feature { struct State {} }
+`,
+  'Sources/App/Health.swift': `import Foundation
+enum Health {
+    static func one() -> Int { API.PackageController.GetRoute.query(on: 1) }
+    static func two() -> Int {
+        API.PackageController.GetRoute
+            .query(on: 2)
+    }
+    static func three() -> Int { Other.query(on: 3) }
+    static func four() -> Int { API.PackageController.ShowRoute.query(on: 4) }
+    static func five() -> Int { API.DependencyController.GetRoute.query(on: 5) }
+    static func six() -> API.PackageController.Model { API.PackageController.Model(name: "x") }
+    static func seven() -> Int { App.Zed.GetRoute.query(on: 7) }
+    static func eight() -> Int { Missing.Thing.query(on: 8) }
+    static func nine() -> Int { API.PackageController.GetRoute.nothing(on: 9) }
+    static func ten() throws { throw Gitlab.Error.requestFailed(status: 10) }
+    static func eleven() { _ = Screens.Path.State.detail(Detail()) }
+    static func twelve() { _ = ObservableBasicsView.Feature.State() }
+}
+`,
+};
+
+describe('Swift: a call through a type path', () => {
+  it('lands on the type the path names, or nowhere', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-swift-type-path-'));
+    roots.push(root);
+    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);
+    }
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const reached = (caller: string): string[] => {
+        const from = cg.getNodesByName(caller).find((n) => n.kind === 'method');
+        expect(from, caller).toBeDefined();
+        return cg
+          .getOutgoingEdgesFrom([from!.id], ['calls', 'instantiates'])
+          .map((e) => cg.getNode(e.target))
+          .filter((n) => n && n.language === 'swift')
+          .map((n) => `${n!.qualifiedName}:${n!.startLine}`)
+          .sort();
+      };
+      // The first declared of GetRoute's two overloads.
+      expect(reached('one')).toEqual(['API::PackageController::GetRoute::query:5']);
+      expect(reached('two')).toEqual(['API::PackageController::GetRoute::query:5']);
+      expect(reached('three')).toEqual(['Other::query:1']);
+      // Declared in `extension API.PackageController { enum ShowRoute … }`.
+      expect(reached('four')).toEqual(['PackageController::ShowRoute::query:13']);
+      // Declared in `extension API.DependencyController.GetRoute { … }`.
+      expect(reached('five')).toEqual(['GetRoute::query:17']);
+      // A nested type's initializer.
+      expect(reached('six')).toEqual(['API::PackageController::Model:8']);
+      // A module qualifier.
+      expect(reached('seven')).toEqual(['Zed::GetRoute::query:9']);
+      // No such type, and no such member: nothing, not some other type's `query`.
+      expect(reached('eight')).toEqual([]);
+      expect(reached('nine')).toEqual([]);
+      // A case with associated values.
+      expect(reached('ten')).toEqual(['Gitlab::Error::requestFailed:2']);
+      // The case a TCA `@Reducer enum` generates its State from.
+      expect(reached('eleven')).toContain('Screens::Path::detail:7');
+      // Two types share the qualified name `Feature::State`; the extension each is declared in tells them apart.
+      expect(reached('twelve')).toEqual(['Feature::State:6']);
+      // Shortened inside its namespace.
+      expect(reached('inside')).toEqual(['API::PackageController::GetRoute::query:5']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/sync-import-binding-retry.test.ts b/__tests__/sync-import-binding-retry.test.ts
new file mode 100644
index 0000000000..c34f4f1cbc
--- /dev/null
+++ b/__tests__/sync-import-binding-retry.test.ts
@@ -0,0 +1,338 @@
+/**
+ * A sync links a reference through an import binding once the module appears.
+ *
+ * `import tagsController from './tag/tag.controller'` binds a name the module
+ * never declares: its default export is a `router`. So does a namespace import
+ * and an aliased one (`import { Component as GroupsPageWrapper }`). Every
+ * reference through such a name — the import itself, a call, `new`, a base
+ * class, a JSX or Vue template tag, an Express mount — resolves only through
+ * the module. Sync retries a parked failed ref by its tail (#1240), and these
+ * were parked under the binding's own name, which neither the module's file
+ * nor its symbols carry. So a module added after its importers were indexed,
+ * one restored after a delete, or one that gained its export in a later edit
+ * stayed unlinked from them until each importer changed or the project was
+ * indexed again. #2392 fixed the same gap for the import of the file itself.
+ *
+ * Such a reference is now parked under its module's key, and still found by
+ * its own name: a binding its module never resolves is linked by that name
+ * alone, to whichever declaration carries it (vben's `{ VbenFormSchema as
+ * FormSchema }`), and that link must come back when the declaration does.
+ */
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { DatabaseConnection, getDatabasePath } from '../src/db';
+import { CURRENT_SCHEMA_VERSION, getCurrentVersion, runMigrations } from '../src/db/migrations';
+import { QueryBuilder } from '../src/db/queries';
+import { moduleReferenceKeys, moduleTail } from '../src/db/reference-tail';
+
+type Files = Record<string, string>;
+
+/** The files that reach a module through a binding the module doesn't declare by that name. */
+const IMPORTERS: Files = {
+  'package.json': JSON.stringify({ name: 'app', dependencies: { express: '^4', vue: '^3', svelte: '^4', astro: '^4' } }),
+  'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['src/*'] } } }),
+  // A default import of a module whose default export has another name (ts-express).
+  'src/routes/routes.ts': "import tagsController from './tag/tag.controller';\nexport const routes = [tagsController];\n",
+  // An aliased import through a tsconfig alias (luci-go's milo).
+  'src/pages/groups_page.test.tsx': "import { Component as GroupsPageWrapper } from '@/pages/groups_page';\nexport const page = <GroupsPageWrapper />;\n",
+  'src/use-ns.ts': "import * as NS from './ns';\nexport const all = NS;\n",
+  'src/call.ts': "import runIt from './handler';\nexport function go() { return runIt(); }\n",
+  'src/draw.ts': "import { Widget as W } from './widgets/Widget';\nexport function paint() { return new W(); }\n",
+  'src/admin.ts': "import Base from './base';\nexport class Admin extends Base {}\n",
+  // An Express router mounted through a default import (proshop).
+  'backend/server.js': "import express from 'express';\nimport uploadRoutes from './routes/uploadRoutes.js';\nconst app = express();\napp.use('/api/upload', uploadRoutes);\nexport default app;\n",
+  // A Vue component imported through an alias and rendered by the template (vue3-element-admin).
+  'src/layouts/LayoutMain.vue': "<template><Error404 /></template>\n<script setup>\nimport Error404 from '@/views/error/404.vue';\n</script>\n",
+  'src/App.svelte': "<script>\n  import Banner from './lib/Hero.svelte';\n</script>\n<Banner />\n",
+  'src/pages/index.astro': "---\nimport Shell from '../layouts/BaseLayout.astro';\n---\n<Shell><h1>Home</h1></Shell>\n",
+};
+
+const MODULES: Files = {
+  'src/routes/tag/tag.controller.ts': 'const router = { list() { return []; } };\nexport default router;\n',
+  'src/pages/groups_page.tsx': 'export function Component() { return null; }\n',
+  'src/ns.ts': 'export const member = 1;\n',
+  'src/handler.ts': 'export default function handle() { return 1; }\n',
+  'src/widgets/Widget.ts': 'export class Widget {}\n',
+  'src/base.ts': 'export default class BaseUser {}\n',
+  'backend/routes/uploadRoutes.js': "import express from 'express';\nconst router = express.Router();\nrouter.post('/', (req, res) => res.send('ok'));\nexport default router;\n",
+  'src/views/error/404.vue': '<template><p>Not found</p></template>\n',
+  'src/lib/Hero.svelte': '<h1>Hero</h1>\n',
+  'src/layouts/BaseLayout.astro': '<html><body><slot /></body></html>\n',
+};
+
+/** What a full index links through the bindings: `<refName>: <edge> <source kind> <file> -> <target kind> <file>::<name>`. */
+const LINKS = [
+  'Banner: imports file src/App.svelte -> component src/lib/Hero.svelte::Hero',
+  'Banner: references component src/App.svelte -> component src/lib/Hero.svelte::Hero',
+  'Base: extends class src/admin.ts -> class src/base.ts::BaseUser',
+  'Base: imports file src/admin.ts -> file src/base.ts::base.ts',
+  'Error404: imports file src/layouts/LayoutMain.vue -> component src/views/error/404.vue::404',
+  'Error404: references component src/layouts/LayoutMain.vue -> component src/views/error/404.vue::404',
+  'GroupsPageWrapper: imports file src/pages/groups_page.test.tsx -> function src/pages/groups_page.tsx::Component',
+  'NS: imports file src/use-ns.ts -> file src/ns.ts::ns.ts',
+  'Shell: imports file src/pages/index.astro -> component src/layouts/BaseLayout.astro::BaseLayout',
+  'Shell: references component src/pages/index.astro -> component src/layouts/BaseLayout.astro::BaseLayout',
+  'W: imports file src/draw.ts -> class src/widgets/Widget.ts::Widget',
+  'W: instantiates function src/draw.ts -> class src/widgets/Widget.ts::Widget',
+  'runIt: calls function src/call.ts -> function src/handler.ts::handle',
+  'runIt: imports file src/call.ts -> file src/handler.ts::handler.ts',
+  'tagsController: imports file src/routes/routes.ts -> file src/routes/tag/tag.controller.ts::tag.controller.ts',
+  'uploadRoutes: imports file backend/server.js -> file backend/routes/uploadRoutes.js::uploadRoutes.js',
+  'uploadRoutes: references route backend/server.js -> constant backend/routes/uploadRoutes.js::router',
+];
+
+let roots: string[] = [];
+let graphs: CodeGraph[] = [];
+
+afterEach(() => {
+  for (const graph of graphs) graph.close();
+  graphs = [];
+  for (const root of roots) fs.rmSync(root, { recursive: true, force: true });
+  roots = [];
+});
+
+function tempRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-binding-'));
+  roots.push(root);
+  return root;
+}
+
+function write(root: string, files: Files): void {
+  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);
+  }
+}
+
+async function index(root: string): Promise<CodeGraph> {
+  const graph = await CodeGraph.init(root, { index: true });
+  graphs.push(graph);
+  return graph;
+}
+
+/** Every edge, by its ends' natural keys, with where it is written and how it resolved. */
+function edgesOf(graph: CodeGraph): string[] {
+  const keys = new Map(
+    graph.getFiles()
+      .flatMap((file) => graph.getNodesInFile(file.path))
+      .map((n) => [n.id, `${n.kind} ${n.filePath}:${n.qualifiedName}:${n.startLine}`] as const)
+  );
+  return graph.getOutgoingEdgesFrom([...keys.keys()])
+    .map((e) => `${e.kind} ${keys.get(e.source)} -> ${keys.get(e.target) ?? e.target} @${e.line}:${e.column} ${JSON.stringify(e.metadata ?? {})}`)
+    .sort();
+}
+
+/** The {@link LINKS} the graph has. */
+function linksOf(graph: CodeGraph): string[] {
+  const names = new Set(LINKS.map((link) => link.slice(0, link.indexOf(':'))));
+  const ids = graph.getFiles().flatMap((file) => graph.getNodesInFile(file.path)).map((n) => n.id);
+  const links: string[] = [];
+  for (const edge of graph.getOutgoingEdgesFrom(ids)) {
+    const ref = edge.metadata?.refName;
+    if (typeof ref !== 'string' || !names.has(ref)) continue;
+    const source = graph.getNode(edge.source)!;
+    const target = graph.getNode(edge.target)!;
+    links.push(`${ref}: ${edge.kind} ${source.kind} ${source.filePath} -> ${target.kind} ${target.filePath}::${target.name}`);
+  }
+  return [...new Set(links)].sort();
+}
+
+/** The final tree, indexed from scratch in a folder of its own: what the sync has to match. */
+async function fullIndexOf(files: Files): Promise<string[]> {
+  const root = tempRoot();
+  write(root, files);
+  return edgesOf(await index(root));
+}
+
+/** A module before the edit that gives it what its importers import. */
+const stub = (file: string): string =>
+  file.endsWith('.vue') ? '<template><p></p></template>\n' : /\.(svelte|astro)$/.test(file) ? '<p></p>\n' : 'export const placeholder = 1;\n';
+
+describe('sync links references through an import binding to their module', () => {
+  it('when the module is added after its importers', async () => {
+    const root = tempRoot();
+    write(root, IMPORTERS);
+    const graph = await index(root);
+    expect(linksOf(graph)).toEqual([]);
+
+    write(root, MODULES);
+    const result = await graph.sync();
+    // The importers did not change: only the retry of their parked refs links them.
+    expect(result.filesAdded).toBe(Object.keys(MODULES).length);
+    expect(result.filesModified).toBe(0);
+    expect(linksOf(graph)).toEqual(LINKS);
+    expect(edgesOf(graph)).toEqual(await fullIndexOf({ ...IMPORTERS, ...MODULES }));
+    expect(graph.getPendingReferenceCount()).toBe(0);
+  }, 120_000);
+
+  it('when the module comes back after it was deleted', async () => {
+    const root = tempRoot();
+    write(root, { ...IMPORTERS, ...MODULES });
+    const graph = await index(root);
+    expect(linksOf(graph)).toEqual(LINKS);
+
+    for (const file of Object.keys(MODULES)) fs.rmSync(path.join(root, file));
+    expect((await graph.sync()).filesRemoved).toBe(Object.keys(MODULES).length);
+    expect(linksOf(graph)).toEqual([]);
+
+    write(root, MODULES);
+    expect((await graph.sync()).filesAdded).toBe(Object.keys(MODULES).length);
+    expect(linksOf(graph)).toEqual(LINKS);
+    expect(edgesOf(graph)).toEqual(await fullIndexOf({ ...IMPORTERS, ...MODULES }));
+  }, 120_000);
+
+  it('when an edit gives the module what its importers import', async () => {
+    const root = tempRoot();
+    write(root, IMPORTERS);
+    write(root, Object.fromEntries(Object.keys(MODULES).map((file) => [file, stub(file)])));
+    const graph = await index(root);
+
+    write(root, MODULES);
+    const result = await graph.sync();
+    expect(result.filesModified).toBe(Object.keys(MODULES).length);
+    expect(result.filesAdded).toBe(0);
+    expect(linksOf(graph)).toEqual(LINKS);
+    expect(edgesOf(graph)).toEqual(await fullIndexOf({ ...IMPORTERS, ...MODULES }));
+  }, 120_000);
+
+  it('and by its own name when its module never resolves it', async () => {
+    // vben: the module doesn't declare the imported name, so a full index
+    // links the local name to the declaration that carries it.
+    const initial: Files = {
+      'src/lib.ts': 'export const unrelated = 1;\n',
+      'src/form.ts': "import type { VbenFormSchema as FormSchema } from './lib';\nexport type Schema = FormSchema;\n",
+    };
+    const added: Files = { 'src/types.ts': 'export type FormSchema = { field: string };\n' };
+    const root = tempRoot();
+    write(root, initial);
+    const graph = await index(root);
+
+    write(root, added);
+    expect((await graph.sync()).filesAdded).toBe(1);
+    const formSchema = edgesOf(graph).filter((edge) => edge.includes('"refName":"FormSchema"'));
+    expect(formSchema).toHaveLength(2);
+    expect(formSchema.every((edge) => edge.includes('-> type_alias src/types.ts:'))).toBe(true);
+    expect(edgesOf(graph)).toEqual(await fullIndexOf({ ...initial, ...added }));
+  }, 120_000);
+});
+
+describe('a failed reference through an import binding', () => {
+  it('waits for its module, and every other reference keeps its own tail', async () => {
+    const root = tempRoot();
+    write(root, {
+      ...IMPORTERS,
+      // A package's binding, an unaliased named import and a member of a
+      // namespace import wait for the name they use.
+      'src/other.ts': "import express from 'express';\nimport { helper } from './util';\nimport * as NS from './ns';\nexport const app = express();\nexport const values = [helper, NS.make()];\n",
+    });
+    (await CodeGraph.init(root, { index: true })).close();
+
+    const db = DatabaseConnection.open(getDatabasePath(root));
+    try {
+      const rows = db.getDb()
+        .prepare("SELECT reference_name AS name, reference_kind AS kind, file_path AS file, name_tail AS tail FROM unresolved_refs WHERE status = 'failed'")
+        .all() as Array<{ name: string; kind: string; file: string; tail: string }>;
+      const tailOf = (file: string, name: string, kind: string): string | undefined =>
+        rows.find((r) => r.file === file && r.name === name && r.kind === kind)?.tail;
+
+      expect(tailOf('src/routes/routes.ts', 'tagsController', 'imports')).toBe('module:tag');
+      expect(tailOf('src/pages/groups_page.test.tsx', 'GroupsPageWrapper', 'imports')).toBe('module:groups_page');
+      expect(tailOf('src/use-ns.ts', 'NS', 'imports')).toBe('module:ns');
+      expect(tailOf('src/call.ts', 'runIt', 'calls')).toBe('module:handler');
+      expect(tailOf('src/draw.ts', 'W', 'instantiates')).toBe('module:Widget');
+      expect(tailOf('src/admin.ts', 'Base', 'extends')).toBe('module:base');
+      expect(tailOf('backend/server.js', 'uploadRoutes', 'references')).toBe('module:uploadRoutes');
+      expect(tailOf('src/layouts/LayoutMain.vue', 'Error404', 'imports')).toBe('module:404');
+      expect(tailOf('src/App.svelte', 'Banner', 'references')).toBe('module:Hero');
+      expect(tailOf('src/pages/index.astro', 'Shell', 'imports')).toBe('module:BaseLayout');
+
+      expect(tailOf('src/other.ts', 'express', 'imports')).toBe('express');
+      expect(tailOf('src/other.ts', 'helper', 'imports')).toBe('helper');
+      expect(tailOf('src/other.ts', 'NS.make', 'calls')).toBe('make');
+
+      // Each module's file is one of the keys its references wait under.
+      for (const [file, module] of [
+        ['src/routes/tag/tag.controller.ts', './tag/tag.controller'],
+        ['src/views/error/404.vue', '@/views/error/404.vue'],
+        ['src/pages/Team/index.tsx', './pages/Team'],
+      ]) {
+        expect(moduleReferenceKeys(file)).toContain(moduleTail(module));
+      }
+    } finally {
+      db.close();
+    }
+  }, 60_000);
+});
+
+describe('schema v15', () => {
+  let db: DatabaseConnection | undefined;
+
+  afterEach(() => {
+    db?.close();
+    db = undefined;
+  });
+
+  function fixture(): QueryBuilder {
+    const root = tempRoot();
+    db = DatabaseConnection.initialize(path.join(root, 'test.db'));
+    const queries = new QueryBuilder(db.getDb());
+    queries.insertNode({ id: 'f', kind: 'file', name: 'form.ts', qualifiedName: 'src/form.ts', filePath: 'src/form.ts',
+      language: 'typescript', startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: 0 });
+    for (const [referenceName, referenceKind, tail, line] of [
+      ['FormSchema', 'imports', 'module:lib', 1],
+      ['FormSchema', 'references', 'module:lib', 2],
+      ['tagsController', 'imports', 'module:tag', 3],
+      // A ref its name parks: the name lookup finds it by its tail already.
+      ['helper', 'calls', 'helper', 4],
+    ] as const) {
+      queries.insertUnresolvedRef({ fromNodeId: 'f', referenceName, referenceKind, line, column: 0, filePath: 'src/form.ts', language: 'typescript' });
+      db.getDb().prepare("UPDATE unresolved_refs SET status = 'failed', name_tail = ? WHERE line = ?").run(tail, line);
+    }
+    return queries;
+  }
+
+  const retried = (queries: QueryBuilder, names: string[], ceiling?: number) =>
+    queries.getRetryableFailedReferences(names, ceiling).map((ref) => `${ref.referenceKind} ${ref.referenceName}`).sort();
+
+  it('finds a reference parked under its module by its module and by its own name', () => {
+    const queries = fixture();
+    expect(retried(queries, moduleReferenceKeys('src/lib.ts'))).toEqual(['imports FormSchema', 'references FormSchema']);
+    expect(retried(queries, ['FormSchema'])).toEqual(['imports FormSchema', 'references FormSchema']);
+    expect(retried(queries, ['FormSchema', 'module:lib', 'helper'])).toEqual(['calls helper', 'imports FormSchema', 'references FormSchema']);
+    expect(retried(queries, ['tag', 'module:tag.controller.ts'])).toEqual([]);
+    // The per-name ceiling holds for the name lookup too.
+    expect(retried(queries, ['FormSchema'], 1)).toEqual([]);
+  });
+
+  it('adds the name index to an older index, and replays cleanly', () => {
+    fixture();
+    const indexes = () => db!.getDb().prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_unresolved_failed_module_name'").all();
+    db!.getDb().exec(`DROP INDEX idx_unresolved_failed_module_name;
+      DELETE FROM schema_versions WHERE version >= 15;
+      INSERT OR IGNORE INTO schema_versions(version, applied_at, description) VALUES (14, 0, 'legacy fixture');`);
+    expect(indexes()).toHaveLength(0);
+    runMigrations(db!.getDb(), 14);
+    expect(getCurrentVersion(db!.getDb())).toBe(CURRENT_SCHEMA_VERSION);
+    expect(indexes()).toHaveLength(1);
+    db!.getDb().exec('DELETE FROM schema_versions WHERE version >= 15');
+    runMigrations(db!.getDb(), 14);
+    expect(indexes()).toHaveLength(1);
+  });
+
+  it('looks a reference up by its name through the name index, not every failed row', () => {
+    const queries = fixture();
+    const prepare = vi.spyOn(db!.getDb(), 'prepare');
+    queries.getRetryableFailedReferences(['FormSchema']);
+    const selects = prepare.mock.calls.map(([sql]) => sql as string).filter((sql) => sql.includes('reference_name IN'));
+    prepare.mockRestore();
+    expect(selects).toHaveLength(2);
+    for (const select of selects) {
+      const plan = db!.getDb().prepare(`EXPLAIN QUERY PLAN ${select}`).all('FormSchema')
+        .map((row) => (row as { detail: string }).detail).join('; ');
+      expect(plan).toMatch(/USING (COVERING )?INDEX idx_unresolved_failed_module_name/);
+    }
+  });
+});
diff --git a/__tests__/sync-import-retry.test.ts b/__tests__/sync-import-retry.test.ts
new file mode 100644
index 0000000000..1d93a9a572
--- /dev/null
+++ b/__tests__/sync-import-retry.test.ts
@@ -0,0 +1,431 @@
+/**
+ * A sync links an import whose file appears after the importer was indexed.
+ *
+ * Sync retries parked failed refs by name tail (#1240), but an import names a
+ * file, a folder or a namespace, not a symbol, so the symbol-name lookup never
+ * found it: the tail of `package:app/b.dart` was `dart`, of `inc/db.php`
+ * `php`, of `./foo` `/foo`. Most languages never even parked theirs: a module
+ * path that named no file reached the importing file's own `import` node by
+ * its qualified name, and that edge was never revisited. A Lua `require` took
+ * the local it is assigned to. Either way the import linked only once the
+ * importer itself changed, or on a full index.
+ */
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { DatabaseConnection } from '../src/db';
+import { CURRENT_SCHEMA_VERSION, getCurrentVersion, runMigrations } from '../src/db/migrations';
+import { QueryBuilder } from '../src/db/queries';
+import { importPathKeys } from '../src/db/reference-tail';
+import type { Node } from '../src/types';
+
+interface Case {
+  name: string;
+  initial: Record<string, string>;
+  added: Record<string, string>;
+  /** The importing file. */
+  from: string;
+  /** What its imports reach once `added` exists: `<kind> <file>`. */
+  expected: string[];
+}
+
+const CASES: Case[] = [
+  {
+    name: 'Dart',
+    initial: {
+      'pubspec.yaml': 'name: app\n',
+      'lib/a.dart': "import 'package:app/b.dart';\nimport 'package:kit/kit.dart';\nimport 'c.dart';\nimport 'src/d.dart';\nexport 'src/e.dart';\npart 'a.g.dart';\n\nvoid main() {}\n",
+    },
+    added: {
+      'lib/b.dart': 'class B {}\n',
+      'packages/kit/pubspec.yaml': 'name: kit\n',
+      'packages/kit/lib/kit.dart': 'class Kit {}\n',
+      'lib/c.dart': 'class C {}\n',
+      'lib/src/d.dart': 'class D {}\n',
+      'lib/src/e.dart': 'class E {}\n',
+      // A generated part, written by build_runner after the library was indexed.
+      'lib/a.g.dart': "part of 'a.dart';\n\nclass _Generated {}\n",
+    },
+    from: 'lib/a.dart',
+    expected: ['file lib/b.dart', 'file packages/kit/lib/kit.dart', 'file lib/c.dart', 'file lib/src/d.dart', 'file lib/src/e.dart', 'file lib/a.g.dart'],
+  },
+  {
+    name: 'TypeScript',
+    initial: {
+      'src/a.ts': "import { X } from './x';\nimport './side';\nimport * as NS from './ns';\nimport { Y } from './dir';\nimport { Z } from './z.js';\nimport type { T } from './types';\nexport function run() { return [X, NS, Y, Z]; }\nexport type U = T;\n",
+    },
+    added: {
+      'src/x.ts': 'export const X = 1;\n',
+      'src/side.ts': 'console.log(1);\n',
+      'src/ns.ts': 'export const member = 1;\n',
+      'src/dir/index.ts': 'export const Y = 2;\n',
+      'src/z.ts': 'export const Z = 3;\n',
+      'src/types.d.ts': 'export interface T { a: number }\n',
+    },
+    from: 'src/a.ts',
+    expected: ['file src/x.ts', 'file src/side.ts', 'file src/ns.ts', 'file src/dir/index.ts', 'file src/z.ts', 'file src/types.d.ts'],
+  },
+  {
+    name: 'JavaScript',
+    initial: {
+      'a.js': "import './side';\nimport def from './def.js';\nconst req = require('./req');\nconst lib = require('./lib');\nmodule.exports = { def, req, lib };\n",
+    },
+    added: {
+      'side.js': 'console.log(1);\n',
+      'def.js': 'export default function def() {}\n',
+      'req.js': 'module.exports = 1;\n',
+      'lib/index.js': 'module.exports = 2;\n',
+    },
+    from: 'a.js',
+    expected: ['file side.js', 'file def.js', 'file req.js', 'file lib/index.js'],
+  },
+  {
+    name: 'C',
+    initial: { 'src/main.c': '#include "a/b.h"\n#include "c.h"\n#include <stdio.h>\nint main(void) { return 0; }\n' },
+    added: { 'src/a/b.h': 'int b(void);\n', 'src/c.h': 'int c(void);\n' },
+    from: 'src/main.c',
+    expected: ['file src/a/b.h', 'file src/c.h'],
+  },
+  {
+    name: 'C++',
+    initial: { 'src/main.cpp': '#include "util/u.hpp"\n#include "w.h"\nint main() { return 0; }\n' },
+    added: { 'src/util/u.hpp': 'namespace util { int u(); }\n', 'src/w.h': 'int w();\n' },
+    from: 'src/main.cpp',
+    expected: ['file src/util/u.hpp', 'file src/w.h'],
+  },
+  {
+    name: 'Objective-C',
+    initial: { 'Foo.m': '#import "Bar.h"\n#import "sub/Baz.h"\n@implementation Foo\n@end\n' },
+    added: { 'Bar.h': '@interface Bar\n@end\n', 'sub/Baz.h': '@interface Baz\n@end\n' },
+    from: 'Foo.m',
+    expected: ['file Bar.h', 'file sub/Baz.h'],
+  },
+  {
+    name: 'PHP',
+    initial: { 'index.php': "<?php\nrequire 'inc/db.php';\ninclude_once 'helpers.php';\n" },
+    added: { 'inc/db.php': '<?php\nfunction db() {}\n', 'helpers.php': '<?php\nfunction helper() {}\n' },
+    from: 'index.php',
+    expected: ['file inc/db.php', 'file helpers.php'],
+  },
+  {
+    name: 'Ruby',
+    initial: { 'app.rb': "require_relative 'lib/foo'\nrequire 'lib/bar'\nclass App; end\n" },
+    added: { 'lib/foo.rb': 'class Foo; end\n', 'lib/bar.rb': 'class Bar; end\n' },
+    from: 'app.rb',
+    expected: ['file lib/foo.rb', 'file lib/bar.rb'],
+  },
+  {
+    name: 'Python',
+    initial: { 'main.py': 'import pkg.mod\nfrom pkg import other\nfrom pkg.sub import thing\nimport single\n\ndef run():\n    return pkg.mod, other, thing, single\n' },
+    added: {
+      'pkg/__init__.py': '',
+      'pkg/mod.py': 'def f():\n    return 1\n',
+      'pkg/other.py': 'def g():\n    return 2\n',
+      'pkg/sub/__init__.py': 'thing = 3\n',
+      'single.py': 'value = 4\n',
+    },
+    from: 'main.py',
+    expected: ['file pkg/mod.py', 'file pkg/other.py', 'file pkg/sub/__init__.py', 'file single.py', 'variable pkg/sub/__init__.py'],
+  },
+  {
+    name: 'Lua',
+    initial: { 'main.lua': 'local m = require("lib.mod")\nlocal p = require("pkg")\nreturn { m, p }\n' },
+    added: { 'lib/mod.lua': 'local M = {}\nreturn M\n', 'pkg/init.lua': 'local P = {}\nreturn P\n' },
+    from: 'main.lua',
+    expected: ['file lib/mod.lua', 'file pkg/init.lua'],
+  },
+  {
+    name: 'Luau',
+    initial: { 'src/main.luau': 'local Signal = require(script.Parent.Signal)\nreturn Signal\n' },
+    added: { 'src/Signal.luau': 'local S = {}\nreturn S\n' },
+    from: 'src/main.luau',
+    expected: ['file src/Signal.luau'],
+  },
+  {
+    name: 'Nix',
+    initial: { 'default.nix': '{ pkgs }:\nlet\n  foo = import ./foo.nix;\n  bar = import ./bar;\nin { inherit foo bar; }\n' },
+    added: { 'foo.nix': '{ a = 1; }\n', 'bar/default.nix': '{ b = 2; }\n' },
+    from: 'default.nix',
+    expected: ['file foo.nix', 'file bar/default.nix'],
+  },
+  {
+    name: 'R',
+    initial: { 'main.R': 'source("utils.R")\nsource("R/helpers.R")\nrun <- function() 1\n' },
+    added: { 'utils.R': 'u <- function() 1\n', 'R/helpers.R': 'h <- function() 2\n' },
+    from: 'main.R',
+    expected: ['file utils.R', 'file R/helpers.R'],
+  },
+  {
+    name: 'Solidity',
+    initial: { 'A.sol': 'pragma solidity ^0.8.0;\nimport "./B.sol";\nimport "./lib/C.sol";\ncontract A {}\n' },
+    added: { 'B.sol': 'pragma solidity ^0.8.0;\ncontract B {}\n', 'lib/C.sol': 'pragma solidity ^0.8.0;\ncontract C {}\n' },
+    from: 'A.sol',
+    expected: ['file B.sol', 'file lib/C.sol'],
+  },
+  {
+    name: 'Erlang',
+    initial: { 'src/a.erl': '-module(a).\n-include("b.hrl").\n-include_lib("app/include/c.hrl").\n-export([f/0]).\nf() -> ok.\n' },
+    added: { 'src/b.hrl': '-define(B, 1).\n', 'include/c.hrl': '-define(C, 1).\n' },
+    from: 'src/a.erl',
+    expected: ['file src/b.hrl', 'file include/c.hrl'],
+  },
+  {
+    name: 'COBOL',
+    initial: {
+      'MAIN.cbl': '       IDENTIFICATION DIVISION.\n       PROGRAM-ID. MAIN.\n       DATA DIVISION.\n       WORKING-STORAGE SECTION.\n       COPY CUSTREC.\n       PROCEDURE DIVISION.\n           STOP RUN.\n',
+    },
+    added: { 'CUSTREC.cpy': '       01 CUST-REC.\n          05 CUST-ID PIC 9(5).\n' },
+    from: 'MAIN.cbl',
+    expected: ['file CUSTREC.cpy'],
+  },
+  {
+    name: 'Java (a package wildcard)',
+    initial: { 'src/com/x/A.java': 'package com.x;\nimport com.z.*;\npublic class A {}\n' },
+    added: { 'src/com/z/Z.java': 'package com.z;\npublic class Z {}\n' },
+    from: 'src/com/x/A.java',
+    expected: ['namespace src/com/z/Z.java'],
+  },
+  {
+    name: 'C# (a using of a namespace declared later)',
+    initial: { 'A.cs': 'using Foo.Bar;\nnamespace App { class A {} }\n' },
+    added: { 'Baz.cs': 'namespace Foo.Bar { class Baz {} }\n' },
+    from: 'A.cs',
+    expected: ['namespace Baz.cs'],
+  },
+  {
+    name: 'Svelte',
+    initial: { 'src/App.svelte': "<script>\n  import Child from './Child.svelte';\n</script>\n<Child />\n" },
+    added: { 'src/Child.svelte': '<p>child</p>\n' },
+    from: 'src/App.svelte',
+    expected: ['file src/Child.svelte'],
+  },
+  {
+    name: 'Vue',
+    initial: { 'src/App.vue': "<script setup>\nimport Child from './Child.vue';\n</script>\n<template><Child /></template>\n" },
+    added: { 'src/Child.vue': '<template><p>child</p></template>\n' },
+    from: 'src/App.vue',
+    expected: ['file src/Child.vue'],
+  },
+];
+
+let root = '';
+let cg: CodeGraph | undefined;
+
+afterEach(() => {
+  cg?.destroy();
+  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);
+  }
+}
+
+/** `<kind> <file>` for every `imports` edge out of `file`, plus how many land on one of its own import statements. */
+function importsOf(file: string): { targets: string[]; ownStatements: number } {
+  const graph = cg!;
+  const ids = graph.getNodesInFile(file).map((n) => n.id);
+  const targets = new Set<string>();
+  let ownStatements = 0;
+  for (const edge of graph.getOutgoingEdgesFrom(ids, ['imports'])) {
+    const target = graph.getNode(edge.target);
+    if (!target) continue;
+    if (target.filePath === file) {
+      if (target.kind === 'import') ownStatements++;
+      continue;
+    }
+    targets.add(`${target.kind} ${target.filePath}`);
+  }
+  return { targets: [...targets].sort(), ownStatements };
+}
+
+describe('sync links an import of a file that appears after the importer', () => {
+  it.each(CASES)('$name', async (c) => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-import-'));
+    write(c.initial);
+    cg = await CodeGraph.init(root, { index: true });
+
+    // Unresolved, the import parks as failed — not as an edge to itself.
+    const before = importsOf(c.from);
+    expect(before.ownStatements).toBe(0);
+    for (const target of c.expected) expect(before.targets).not.toContain(target);
+
+    write(c.added);
+    const result = await cg.sync();
+    expect(result.filesAdded).toBe(Object.keys(c.added).length);
+
+    // The importer did not change: only the retry of its parked import links it.
+    const synced = importsOf(c.from);
+    expect(synced.targets).toEqual(expect.arrayContaining(c.expected));
+    expect(synced.ownStatements).toBe(0);
+    expect(cg.getPendingReferenceCount()).toBe(0);
+
+    // A full re-index links the same. It has to start from an empty database,
+    // as `codegraph index` does: indexAll over this one skips the unchanged
+    // importer and keeps the edges the sync wrote. Close first: recreate
+    // unlinks the database file, which a held handle makes EBUSY on Windows.
+    cg.close();
+    cg = await CodeGraph.recreate(root);
+    await cg.indexAll();
+    expect(importsOf(c.from)).toEqual(synced);
+  }, 60_000);
+});
+
+describe('a removed file', () => {
+  it('relinks its unchanged importers when it is restored', async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-import-'));
+    write({
+      'pubspec.yaml': 'name: app\n',
+      'lib/a.dart': "import 'package:app/b.dart';\n\nvoid main() {}\n",
+      'lib/b.dart': 'class B {}\n',
+    });
+    cg = await CodeGraph.init(root, { index: true });
+    expect(importsOf('lib/a.dart').targets).toEqual(['file lib/b.dart']);
+
+    fs.rmSync(path.join(root, 'lib/b.dart'));
+    expect((await cg.sync()).filesRemoved).toBe(1);
+    expect(importsOf('lib/a.dart')).toEqual({ targets: [], ownStatements: 0 });
+    expect(cg.getPendingReferenceCount()).toBe(0);
+
+    write({ 'lib/b.dart': 'class B {}\n' });
+    expect((await cg.sync()).filesAdded).toBe(1);
+    expect(importsOf('lib/a.dart').targets).toEqual(['file lib/b.dart']);
+  }, 60_000);
+});
+
+describe('importPathKeys', () => {
+  it('names a file and its folder, whole and up to the first dot', () => {
+    expect(importPathKeys('lib/src/d.dart')).toEqual(['src', 'd.dart', 'd']);
+    expect(importPathKeys('src/types.d.ts')).toEqual(['src', 'types.d.ts', 'types']);
+    expect(importPathKeys('pkg/sub/__init__.py')).toEqual(['sub', '__init__.py', '__init__']);
+    expect(importPathKeys('vendor/gopkg.in/yaml.v3/yaml.go')).toEqual(['yaml.v3', 'yaml', 'yaml.go']);
+    expect(importPathKeys('main.c')).toEqual(['main.c', 'main']);
+    expect(importPathKeys('.github/.eslintrc.js')).toEqual(['.github', '.eslintrc.js', '.eslintrc']);
+  });
+});
+
+describe('getRetryableFailedImports', () => {
+  let db: DatabaseConnection | undefined;
+
+  afterEach(() => {
+    db?.close();
+    db = undefined;
+  });
+
+  function setup(): QueryBuilder {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-import-'));
+    db = DatabaseConnection.initialize(path.join(root, 'test.db'));
+    const queries = new QueryBuilder(db.getDb());
+    const failed = (id: string, referenceName: string, referenceKind: 'imports' | 'calls' = 'imports') => {
+      const node: Node = { id, kind: 'file', name: id, qualifiedName: id, filePath: id, language: 'dart',
+        startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: Date.now() };
+      queries.insertNode(node);
+      queries.insertUnresolvedRef({ fromNodeId: id, referenceName, referenceKind, line: 1, column: 0, filePath: id, language: 'dart' });
+      queries.markReferencesFailed([{ fromNodeId: id, referenceName, referenceKind }]);
+    };
+    failed('a.dart', 'package:app/b.dart');
+    failed('c.dart', '../b.dart');
+    failed('d.dart', 'src/b.dart');
+    failed('e.dart', 'b.dart');
+    failed('f.dart', 'x.b', 'calls');
+    failed('g.cs', 'Foo.Bar');
+    failed('h.ts', 'useState');
+    return queries;
+  }
+
+  const names = (refs: Array<{ referenceName: string }>) => refs.map((r) => r.referenceName).sort();
+
+  it('finds an import by the stem of its path or by its whole name, and nothing else', () => {
+    const queries = setup();
+    expect(names(queries.getRetryableFailedImports(['b']))).toEqual(['../b.dart', 'package:app/b.dart', 'src/b.dart']);
+    expect(names(queries.getRetryableFailedImports(['b.dart']))).toEqual(['b.dart']);
+    expect(queries.getRetryableFailedImports(['b', 'b.dart', 'b'])).toHaveLength(4);
+  });
+
+  it('finds an import by a node name only when the name is not also its tail', () => {
+    const queries = setup();
+    // `using Foo.Bar` waits for the namespace node of that name.
+    expect(names(queries.getRetryableFailedImports([], ['Foo.Bar', 'useState', 'b']))).toEqual(['Foo.Bar']);
+    // A path key still reaches a plain name.
+    expect(names(queries.getRetryableFailedImports(['useState']))).toEqual(['useState']);
+  });
+
+  it('skips a key that more failed imports share than the ceiling', () => {
+    const queries = setup();
+    expect(queries.getRetryableFailedImports(['b'], [], 2)).toEqual([]);
+    expect(names(queries.getRetryableFailedImports(['b', 'b.dart'], [], 2))).toEqual(['b.dart']);
+    expect(queries.getRetryableFailedImports(['b'], [], 3)).toHaveLength(3);
+  });
+});
+
+describe('schema v12', () => {
+  let db: DatabaseConnection | undefined;
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    db?.close();
+    db = undefined;
+  });
+
+  function fixture(): QueryBuilder {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-import-'));
+    db = DatabaseConnection.initialize(path.join(root, 'test.db'));
+    const queries = new QueryBuilder(db.getDb());
+    queries.insertNode({ id: 'a', kind: 'file', name: 'a.dart', qualifiedName: 'lib/a.dart', filePath: 'lib/a.dart',
+      language: 'dart', startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: 0 });
+    for (const [referenceName, referenceKind, tail] of [
+      ['package:app/b.dart', 'imports', 'dart'],
+      ['c.h', 'imports', 'h'],
+      ['lists::map/2', 'calls', 'map'],
+    ] as const) {
+      queries.insertUnresolvedRef({ fromNodeId: 'a', referenceName, referenceKind, line: 1, column: 0, filePath: 'lib/a.dart', language: 'dart' });
+      db.getDb().prepare("UPDATE unresolved_refs SET status = 'failed', name_tail = ? WHERE reference_name = ?").run(tail, referenceName);
+    }
+    return queries;
+  }
+
+  const tails = () => db!.getDb().prepare('SELECT reference_name AS name, name_tail AS tail FROM unresolved_refs ORDER BY id').all();
+
+  it('rewrites the tail of a path import parked by an older version, and replays cleanly', () => {
+    fixture();
+    db!.getDb().exec(`DROP INDEX idx_unresolved_failed_import_tail;
+      DROP INDEX idx_unresolved_failed_import_name;
+      DELETE FROM schema_versions WHERE version >= 12;
+      INSERT OR IGNORE INTO schema_versions(version, applied_at, description) VALUES (11, 0, 'legacy fixture');`);
+    db!.close();
+    db = DatabaseConnection.open(path.join(root, 'test.db'));
+    expect(getCurrentVersion(db.getDb())).toBe(CURRENT_SCHEMA_VERSION);
+    const indexes = db.getDb().prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE 'idx_unresolved_failed_import_%' ORDER BY name").all();
+    expect(indexes).toEqual([{ name: 'idx_unresolved_failed_import_name' }, { name: 'idx_unresolved_failed_import_tail' }]);
+    const migrated = tails();
+    expect(migrated).toEqual([
+      { name: 'package:app/b.dart', tail: 'b' },
+      { name: 'c.h', tail: 'h' },
+      { name: 'lists::map/2', tail: 'map' },
+    ]);
+
+    db.getDb().exec('DELETE FROM schema_versions WHERE version >= 12');
+    runMigrations(db.getDb(), 11);
+    expect(tails()).toEqual(migrated);
+  });
+
+  it('looks failed imports up through their own indexes', () => {
+    const queries = fixture();
+    const prepare = vi.spyOn(db!.getDb(), 'prepare');
+    // The fixture's tails are old ones: `dart` finds a row by tail, `c.h` by name.
+    expect(queries.getRetryableFailedImports(['dart', 'c.h'], ['Foo.Bar'])).toHaveLength(2);
+    const lookups = prepare.mock.calls.map(([sql]) => sql as string).filter((sql) => sql.includes("reference_kind = 'imports'"));
+    prepare.mockRestore();
+    expect(lookups.length).toBeGreaterThan(0);
+    for (const sql of lookups) {
+      const plan = db!.getDb().prepare(`EXPLAIN QUERY PLAN ${sql}`).all('k').map((row) => (row as { detail: string }).detail).join('; ');
+      expect(plan).toMatch(/USING (COVERING )?INDEX idx_unresolved_failed_import_(tail|name)/);
+    }
+  });
+});
diff --git a/__tests__/sync-navigation-retry.test.ts b/__tests__/sync-navigation-retry.test.ts
new file mode 100644
index 0000000000..79070b1e27
--- /dev/null
+++ b/__tests__/sync-navigation-retry.test.ts
@@ -0,0 +1,671 @@
+/**
+ * A sync binds a navigation call to a route that appears after the call was
+ * indexed, for every router, as a full index binds it.
+ *
+ * `history.push('/login')`, `navigate('/login')`, `router.push('/x')`,
+ * `goto('/x')`: a navigation call names its route by path and its reference
+ * by the router's method. While the route did not exist, the call was parked
+ * as failed, and sync's retry — a failed ref's name tail against the names
+ * the synced files define — never found it, because no file that adds
+ * `/login` defines anything named `push`. The synced index kept a failure a
+ * fresh index of the same files does not have (CG-33).
+ */
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { QueryBuilder } from '../src/db/queries';
+import { referenceNameTail } from '../src/db/reference-tail';
+import { getAllFrameworkResolvers } from '../src/resolution/frameworks';
+import { changedRoutes, type ReferenceResolver } from '../src/resolution';
+import type { Node } from '../src/types';
+
+interface Case {
+  name: string;
+  /** The project as it ends up. */
+  files: Record<string, string>;
+  /** The file the route comes from, and what it holds while the route does not exist (null: no such file yet). */
+  route: { file: string; before: string | null };
+  /** The file whose navigation call waits for the route. */
+  from: string;
+  /** Where that call goes once the route exists: `<href> → <route>`. */
+  expected: string;
+}
+
+const angularComponent = (name: string, body = '', template = '<p>x</p>') => `import { Component } from '@angular/core';
+import { Router } from '@angular/router';
+@Component({ selector: 'app-x', template: '${template}' })
+export class ${name} {
+  constructor(private readonly router: Router) {}
+${body}
+}
+`;
+
+const CASES: Case[] = [
+  {
+    name: 'React Router (a <Route> in the markup)',
+    files: {
+      'package.json': JSON.stringify({ name: 'shop', dependencies: { react: '18', 'react-router-dom': '5' } }),
+      'src/App.js':
+        "import { BrowserRouter as Router, Route } from 'react-router-dom'\n" +
+        "import LoginScreen from './screens/LoginScreen'\n" +
+        "import CartScreen from './screens/CartScreen'\n" +
+        'const App = () => (\n' +
+        '  <Router>\n' +
+        "    <Route path='/login' component={LoginScreen} />\n" +
+        "    <Route path='/cart' component={CartScreen} />\n" +
+        '  </Router>\n' +
+        ')\n' +
+        'export default App\n',
+      'src/screens/LoginScreen.js': 'const LoginScreen = () => <div>Login</div>\nexport default LoginScreen\n',
+      'src/screens/CartScreen.js':
+        'const CartScreen = ({ history }) => {\n' +
+        '  const checkout = () => {\n' +
+        "    history.push('/login?redirect=shipping')\n" +
+        '  }\n' +
+        '  return <button onClick={checkout}>Checkout</button>\n' +
+        '}\n' +
+        'export default CartScreen\n',
+    },
+    route: {
+      file: 'src/App.js',
+      before:
+        "import { BrowserRouter as Router, Route } from 'react-router-dom'\n" +
+        "import LoginScreen from './screens/LoginScreen'\n" +
+        "import CartScreen from './screens/CartScreen'\n" +
+        'const App = () => (\n' +
+        '  <Router>\n' +
+        "    <Route path='/cart' component={CartScreen} />\n" +
+        '  </Router>\n' +
+        ')\n' +
+        'export default App\n',
+    },
+    from: 'src/screens/CartScreen.js',
+    expected: '/login?redirect=shipping → /login',
+  },
+  {
+    name: 'React Router (a path built from a constant another file holds)',
+    files: {
+      'package.json': JSON.stringify({ name: 'web', dependencies: { react: '18', 'react-router': '7' } }),
+      'src/config/paths.ts': "export const paths = {\n  auth: { login: { path: '/auth/login' } },\n} as const;\n",
+      'src/app/router.tsx':
+        "import { createBrowserRouter } from 'react-router';\n" +
+        "import { paths } from '../config/paths';\n" +
+        "import { LoginRoute } from './routes/login';\n" +
+        'export const router = createBrowserRouter([\n' +
+        '  { path: paths.auth.login.path, element: <LoginRoute /> },\n' +
+        ']);\n',
+      'src/app/routes/login.tsx': 'export function LoginRoute() { return null; }\n',
+      'src/lib/auth.tsx':
+        "import { useNavigate } from 'react-router';\n" +
+        'export function Logout() {\n' +
+        '  const navigate = useNavigate();\n' +
+        "  return <button onClick={() => navigate('/auth/login')}>out</button>;\n" +
+        '}\n',
+    },
+    // The route's own file never changes: the constant it reads does.
+    route: { file: 'src/config/paths.ts', before: "export const paths = {\n  auth: { login: { path: '/auth/sign-in' } },\n} as const;\n" },
+    from: 'src/lib/auth.tsx',
+    expected: '/auth/login → /auth/login',
+  },
+  {
+    // The routes live in a file that never changes: they exist only while
+    // another file hands that table to the router.
+    name: 'React Router (a table another file hands the router)',
+    files: {
+      'package.json': JSON.stringify({ name: 'app', dependencies: { react: '18', 'react-router-dom': '6' } }),
+      'src/AppRoutes.js':
+        "import { Home } from './Home';\n" +
+        "import { Counter } from './Counter';\n" +
+        'const AppRoutes = [\n' +
+        '  { index: true, element: <Home /> },\n' +
+        "  { path: '/counter', element: <Counter /> },\n" +
+        '];\n' +
+        'export default AppRoutes;\n',
+      'src/App.js':
+        "import { Route, Routes } from 'react-router-dom';\n" +
+        "import AppRoutes from './AppRoutes';\n" +
+        'export default function App() {\n' +
+        '  return <Routes>{AppRoutes.map(({ element, ...rest }, index) => <Route key={index} {...rest} element={element} />)}</Routes>;\n' +
+        '}\n',
+      'src/Home.js': 'export function Home() { return null; }\n',
+      'src/Counter.js': 'export function Counter() { return null; }\n',
+      'src/NavMenu.js':
+        "import { Link, useNavigate } from 'react-router-dom';\n" +
+        'export function NavMenu() {\n' +
+        '  const navigate = useNavigate();\n' +
+        "  const goHome = () => navigate('/');\n" +
+        '  return <nav><button onClick={goHome}>Home</button><Link to="/counter">Counter</Link></nav>;\n' +
+        '}\n',
+    },
+    route: {
+      file: 'src/App.js',
+      before:
+        "import { Route, Routes } from 'react-router-dom';\n" +
+        "import { Counter } from './Counter';\n" +
+        'export default function App() {\n' +
+        '  return <Routes><Route path="/static" element={<Counter />} /></Routes>;\n' +
+        '}\n',
+    },
+    from: 'src/NavMenu.js',
+    expected: '/ → /',
+  },
+  {
+    name: 'React Router (one arm of a conditional destination)',
+    files: {
+      'package.json': JSON.stringify({ name: 'shop', dependencies: { react: '18', 'react-router-dom': '5' } }),
+      'src/App.js':
+        "import { BrowserRouter as Router, Route } from 'react-router-dom'\n" +
+        "import LoginScreen from './screens/LoginScreen'\n" +
+        "import CartScreen from './screens/CartScreen'\n" +
+        'const App = () => (\n' +
+        '  <Router>\n' +
+        "    <Route path='/login' component={LoginScreen} />\n" +
+        "    <Route path='/cart' component={CartScreen} />\n" +
+        '  </Router>\n' +
+        ')\n' +
+        'export default App\n',
+      'src/screens/LoginScreen.js': 'const LoginScreen = () => <div>Login</div>\nexport default LoginScreen\n',
+      // While `/login` is missing the call still resolves, through its other
+      // arm: it is not parked as failed, it lost a destination.
+      'src/screens/CartScreen.js':
+        'const CartScreen = ({ history, user }) => {\n' +
+        '  const checkout = () => {\n' +
+        "    history.push(user ? '/cart' : '/login')\n" +
+        '  }\n' +
+        '  return <button onClick={checkout}>Checkout</button>\n' +
+        '}\n' +
+        'export default CartScreen\n',
+    },
+    route: {
+      file: 'src/App.js',
+      before:
+        "import { BrowserRouter as Router, Route } from 'react-router-dom'\n" +
+        "import CartScreen from './screens/CartScreen'\n" +
+        'const App = () => (\n' +
+        '  <Router>\n' +
+        "    <Route path='/cart' component={CartScreen} />\n" +
+        '  </Router>\n' +
+        ')\n' +
+        'export default App\n',
+    },
+    from: 'src/screens/CartScreen.js',
+    expected: '/login → /login',
+  },
+  {
+    name: 'React Router (a parameter route that took the call meanwhile)',
+    files: {
+      'package.json': JSON.stringify({ name: 'admin', dependencies: { react: '18', 'react-router-dom': '6' } }),
+      'src/App.jsx':
+        "import { Routes, Route } from 'react-router-dom'\n" +
+        "import { User, NewUser } from './User'\n" +
+        'export const App = () => (\n' +
+        '  <Routes>\n' +
+        '    <Route path="/users/new" element={<NewUser />} />\n' +
+        '    <Route path="/users/:id" element={<User />} />\n' +
+        '  </Routes>\n' +
+        ')\n',
+      'src/User.jsx': 'export const User = () => <div>User</div>\nexport const NewUser = () => <div>New</div>\n',
+      'src/Admin.jsx':
+        "import { useNavigate } from 'react-router-dom'\n" +
+        'export const Admin = () => {\n' +
+        '  const navigate = useNavigate()\n' +
+        "  const add = () => navigate('/users/new')\n" +
+        '  return <button onClick={add}>Add</button>\n' +
+        '}\n',
+    },
+    route: {
+      file: 'src/App.jsx',
+      before:
+        "import { Routes, Route } from 'react-router-dom'\n" +
+        "import { User } from './User'\n" +
+        'export const App = () => (\n' +
+        '  <Routes>\n' +
+        '    <Route path="/users/:id" element={<User />} />\n' +
+        '  </Routes>\n' +
+        ')\n',
+    },
+    from: 'src/Admin.jsx',
+    expected: '/users/new → /users/new',
+  },
+  {
+    name: 'Next.js',
+    files: {
+      'package.json': JSON.stringify({ name: 'site', dependencies: { next: '15', react: '19' } }),
+      'app/page.tsx': 'export default function Home() {\n  return null\n}\n',
+      'app/login/page.tsx': 'export default function LoginPage() {\n  return null\n}\n',
+      'components/logout-button.tsx':
+        "'use client'\n" +
+        "import { useRouter } from 'next/navigation'\n" +
+        'export function LogoutButton() {\n' +
+        '  const router = useRouter()\n' +
+        "  const out = () => router.push('/login')\n" +
+        '  return <button onClick={out}>Log out</button>\n' +
+        '}\n',
+    },
+    route: { file: 'app/login/page.tsx', before: null },
+    from: 'components/logout-button.tsx',
+    expected: '/login → /login',
+  },
+  {
+    name: 'Expo Router',
+    files: {
+      'package.json': JSON.stringify({ name: 'app', dependencies: { expo: '52', 'expo-router': '4', react: '18' } }),
+      'src/app/_layout.tsx': 'export default function Layout() { return null }\n',
+      'src/app/index.tsx': 'export default function Home() { return null }\n',
+      'src/app/settings.tsx': 'export default function Settings() { return null }\n',
+      'src/services/nav.ts': "import { router } from 'expo-router'\nexport function openSettings() {\n  router.push('/settings')\n}\n",
+    },
+    route: { file: 'src/app/settings.tsx', before: null },
+    from: 'src/services/nav.ts',
+    expected: '/settings → /settings',
+  },
+  {
+    name: 'Expo Router (a catch-all screen that took the call meanwhile)',
+    files: {
+      'package.json': JSON.stringify({ name: 'app', dependencies: { expo: '52', 'expo-router': '4', react: '18' } }),
+      'src/app/_layout.tsx': 'export default function Layout() { return null }\n',
+      'src/app/index.tsx': 'export default function Home() { return null }\n',
+      'src/app/[...missing].tsx': 'export default function NotFound() { return null }\n',
+      'src/app/login.tsx': 'export default function Login() { return null }\n',
+      'src/services/session.ts': "import { router } from 'expo-router'\nexport function signOut() {\n  router.replace('/login')\n}\n",
+    },
+    route: { file: 'src/app/login.tsx', before: null },
+    from: 'src/services/session.ts',
+    expected: '/login → /login',
+  },
+  {
+    name: 'Vue Router',
+    files: {
+      'package.json': JSON.stringify({ name: 'conduit', dependencies: { vue: '3', 'vue-router': '4' } }),
+      'src/router/index.js':
+        'import { createRouter, createWebHistory } from "vue-router"\n' +
+        'const router = createRouter({\n' +
+        '  history: createWebHistory(),\n' +
+        '  routes: [\n' +
+        '    { name: "home", path: "/", component: () => import("@/views/Home") },\n' +
+        '    { name: "login", path: "/login", component: () => import("@/views/Login") },\n' +
+        '  ]\n' +
+        '})\n' +
+        'export default router\n',
+      'src/views/Home.vue':
+        '<template>\n  <button @click="signIn">Sign in</button>\n</template>\n' +
+        '<script setup>\n' +
+        'import { useRouter } from "vue-router"\n' +
+        'const router = useRouter()\n' +
+        'function signIn() {\n' +
+        '  router.push("/login")\n' +
+        '}\n' +
+        '</script>\n',
+      'src/views/Login.vue': '<template>\n  <div>Login</div>\n</template>\n<script setup>\nconst x = 1\n</script>\n',
+    },
+    route: {
+      file: 'src/router/index.js',
+      before:
+        'import { createRouter, createWebHistory } from "vue-router"\n' +
+        'const router = createRouter({\n' +
+        '  history: createWebHistory(),\n' +
+        '  routes: [\n' +
+        '    { name: "home", path: "/", component: () => import("@/views/Home") },\n' +
+        '  ]\n' +
+        '})\n' +
+        'export default router\n',
+    },
+    from: 'src/views/Home.vue',
+    expected: '/login → /login',
+  },
+  {
+    name: 'Angular',
+    files: {
+      'package.json': JSON.stringify({ dependencies: { '@angular/core': '19', '@angular/router': '19' } }),
+      'src/app/app.routes.ts':
+        "import { Routes } from '@angular/router';\n" +
+        "import { HomeComponent } from './home.component';\n" +
+        "import { LoginComponent } from './login.component';\n" +
+        'export const routes: Routes = [\n' +
+        "  { path: 'home', component: HomeComponent },\n" +
+        "  { path: 'login', component: LoginComponent },\n" +
+        '];\n',
+      'src/app/home.component.ts': angularComponent('HomeComponent', "  signIn() { this.router.navigate(['/login']); }"),
+      'src/app/login.component.ts': angularComponent('LoginComponent'),
+    },
+    route: {
+      file: 'src/app/app.routes.ts',
+      before:
+        "import { Routes } from '@angular/router';\n" +
+        "import { HomeComponent } from './home.component';\n" +
+        'export const routes: Routes = [\n' +
+        "  { path: 'home', component: HomeComponent },\n" +
+        '];\n',
+    },
+    from: 'src/app/home.component.ts',
+    expected: '/login → /login',
+  },
+  {
+    // A link in a template is a synthesizer's edge, and a routes file holds
+    // nothing that sends a sync to the synthesizers on its own.
+    name: 'Angular (a routerLink, the routes file added later)',
+    files: {
+      'package.json': JSON.stringify({ dependencies: { '@angular/core': '19', '@angular/router': '19' } }),
+      'src/app/app.routes.ts':
+        "import { Routes } from '@angular/router';\n" +
+        "import { HomeComponent } from './home.component';\n" +
+        "import { LoginComponent } from './login.component';\n" +
+        'export const routes: Routes = [\n' +
+        "  { path: 'home', component: HomeComponent },\n" +
+        "  { path: 'login', component: LoginComponent },\n" +
+        '];\n',
+      'src/app/home.component.ts': angularComponent('HomeComponent', '', '<a routerLink="/login">Sign in</a>'),
+      'src/app/login.component.ts': angularComponent('LoginComponent'),
+    },
+    route: { file: 'src/app/app.routes.ts', before: null },
+    from: 'src/app/home.component.ts',
+    expected: '/login → /login',
+  },
+  {
+    name: 'TanStack Router',
+    files: {
+      'package.json': JSON.stringify({ name: 'app', dependencies: { react: '19', '@tanstack/react-router': '1' } }),
+      'src/routes/index.tsx':
+        "import { createFileRoute, useNavigate } from '@tanstack/react-router'\n" +
+        "export const Route = createFileRoute('/')({ component: IndexComponent })\n" +
+        'function IndexComponent() {\n' +
+        '  const navigate = useNavigate()\n' +
+        "  const signIn = () => navigate({ to: '/login' })\n" +
+        '  return <button onClick={signIn}>Sign in</button>\n' +
+        '}\n',
+      'src/routes/login.tsx':
+        "import { createFileRoute } from '@tanstack/react-router'\n" +
+        "export const Route = createFileRoute('/login')({ component: LoginComponent })\n" +
+        'function LoginComponent() {\n  return <div>Login</div>\n}\n',
+    },
+    route: { file: 'src/routes/login.tsx', before: null },
+    from: 'src/routes/index.tsx',
+    expected: '/login → /login',
+  },
+  {
+    name: 'SvelteKit',
+    files: {
+      'package.json': JSON.stringify({ name: 'conduit', devDependencies: { '@sveltejs/kit': '2', svelte: '5' } }),
+      'src/routes/+page.svelte': '<h1>Home</h1>\n',
+      'src/routes/settings/+page.svelte': '<h1>Settings</h1>\n',
+      'src/routes/settings/+page.server.js':
+        "import { redirect } from '@sveltejs/kit'\n" +
+        'export function load({ locals }) {\n' +
+        "  if (!locals.user) redirect(302, '/login')\n" +
+        '}\n',
+      'src/routes/login/+page.svelte': '<h1>Sign in</h1>\n',
+    },
+    route: { file: 'src/routes/login/+page.svelte', before: null },
+    from: 'src/routes/settings/+page.server.js',
+    expected: '/login → /login',
+  },
+];
+
+const roots: string[] = [];
+const graphs: CodeGraph[] = [];
+
+afterEach(() => {
+  for (const graph of graphs.splice(0)) graph.close();
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+function tempRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-nav-'));
+  roots.push(root);
+  return root;
+}
+
+function write(root: string, 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);
+  }
+}
+
+/** Set a file's content, or remove the file for null. */
+function put(root: string, rel: string, content: string | null): void {
+  if (content === null) fs.rmSync(path.join(root, rel));
+  else write(root, { [rel]: content });
+}
+
+async function index(root: string): Promise<CodeGraph> {
+  const graph = await CodeGraph.init(root, { index: true });
+  graphs.push(graph);
+  return graph;
+}
+
+/** `<href> → <route>` for every navigation out of `file`. */
+function navigations(graph: CodeGraph, file: string): string[] {
+  const ids = graph.getNodesInFile(file).map((n) => n.id);
+  return graph
+    .getOutgoingEdgesFrom(ids, ['navigates'])
+    .map((edge) => `${String(edge.metadata?.href)} → ${graph.getNode(edge.target)?.name}`)
+    .sort();
+}
+
+/** The same files, indexed from scratch in a folder of their own. */
+async function freshNavigations(files: Record<string, string>, file: string): Promise<string[]> {
+  const root = tempRoot();
+  write(root, files);
+  return navigations(await index(root), file);
+}
+
+function internals(graph: CodeGraph): { queries: QueryBuilder; resolver: ReferenceResolver } {
+  return graph as unknown as { queries: QueryBuilder; resolver: ReferenceResolver };
+}
+
+describe('sync binds a navigation call to a route that appears later', () => {
+  it.each(CASES)('$name', async (c) => {
+    const root = tempRoot();
+    const without = { ...c.files };
+    if (c.route.before === null) delete without[c.route.file];
+    else without[c.route.file] = c.route.before;
+    write(root, without);
+    const graph = await index(root);
+    const missing = navigations(graph, c.from);
+    expect(missing).not.toContain(c.expected);
+    const fresh = await freshNavigations(c.files, c.from);
+    expect(fresh).toContain(c.expected);
+
+    // The route appears; the file with the call does not change.
+    put(root, c.route.file, c.files[c.route.file]!);
+    await graph.sync();
+    expect(navigations(graph, c.from)).toEqual(fresh);
+    expect(graph.getPendingReferenceCount()).toBe(0);
+
+    // Gone again, and back: the call parks while the route is missing and
+    // binds again when it returns, as a full index of each state has it.
+    put(root, c.route.file, c.route.before);
+    await graph.sync();
+    expect(navigations(graph, c.from)).toEqual(missing);
+    put(root, c.route.file, c.files[c.route.file]!);
+    await graph.sync();
+    expect(navigations(graph, c.from)).toEqual(fresh);
+    expect(graph.getPendingReferenceCount()).toBe(0);
+  }, 120_000);
+});
+
+describe('a route that goes away', () => {
+  it('lets a call two routes tied for bind to the one left', async () => {
+    const files = {
+      'package.json': JSON.stringify({ name: 'admin', dependencies: { react: '18', 'react-router-dom': '6' } }),
+      'src/App.jsx':
+        "import { Routes, Route } from 'react-router-dom'\n" +
+        "import { User } from './User'\n" +
+        'export const App = () => (\n' +
+        '  <Routes>\n' +
+        '    <Route path="/users/:id" element={<User />} />\n' +
+        '  </Routes>\n' +
+        ')\n',
+      'src/User.jsx': 'export const User = () => <div>User</div>\n',
+      'src/Admin.jsx':
+        "import { useNavigate } from 'react-router-dom'\n" +
+        'export const Admin = () => {\n' +
+        '  const navigate = useNavigate()\n' +
+        "  const open = () => navigate('/users/5')\n" +
+        '  return <button onClick={open}>Open</button>\n' +
+        '}\n',
+    };
+    const root = tempRoot();
+    write(root, files);
+    // A second route of the same shape: `/users/5` matches both, and a tie names nothing.
+    put(root, 'src/App.jsx', files['src/App.jsx'].replace('  </Routes>', '    <Route path="/users/:name" element={<User />} />\n  </Routes>'));
+    const graph = await index(root);
+    expect(navigations(graph, 'src/Admin.jsx')).toEqual([]);
+
+    put(root, 'src/App.jsx', files['src/App.jsx']);
+    await graph.sync();
+    expect(navigations(graph, 'src/Admin.jsx')).toEqual(['/users/5 → /users/:id']);
+    expect(navigations(graph, 'src/Admin.jsx')).toEqual(await freshNavigations(files, 'src/Admin.jsx'));
+  }, 60_000);
+});
+
+describe('reopenNavigationsFor', () => {
+  const app = (name: string) => ({
+    [`apps/${name}/package.json`]: JSON.stringify({ name, dependencies: { react: '18', 'react-router-dom': '6' } }),
+    [`apps/${name}/src/App.jsx`]:
+      "import { Routes, Route } from 'react-router-dom'\n" +
+      "import { Home } from './Home'\n" +
+      'export const App = () => (\n  <Routes>\n    <Route path="/" element={<Home />} />\n  </Routes>\n)\n',
+    // Two calls to routes the app does not have, and one to its `/`.
+    [`apps/${name}/src/Home.jsx`]:
+      "import { useNavigate } from 'react-router-dom'\n" +
+      'export const Home = () => {\n' +
+      '  const navigate = useNavigate()\n' +
+      "  const go = () => navigate('/login')\n" +
+      "  const back = () => navigate('/back')\n" +
+      "  const home = () => navigate('/')\n" +
+      '  return <button onClick={go} onDoubleClick={back} onBlur={home}>Go</button>\n' +
+      '}\n',
+  });
+
+  async function monorepo(): Promise<CodeGraph> {
+    const root = tempRoot();
+    write(root, { 'package.json': JSON.stringify({ name: 'mono', private: true, workspaces: ['apps/*'] }), ...app('web'), ...app('admin') });
+    return index(root);
+  }
+
+  /** `<file> failed` per failed `navigate` call, `<file> → <route>` per navigation. */
+  const navigationState = (graph: CodeGraph): string[] => [
+    ...internals(graph).queries.getFailedCallsByTail(['navigate']).map((ref) => `${ref.filePath} failed`),
+    ...internals(graph).queries.getResolvedNavigations().map((e) => `${e.sourceFilePath} → ${graph.getNode(e.target)?.name}`),
+  ].sort();
+
+  /** The app's `/` route, moved to `path` — a route of that app the sync added. */
+  const routeAt = (route: Node, path: string): Node => ({ ...route, id: route.id.replace(/:\/$/, `:${path}`), name: path });
+
+  it('re-opens the calls in the app the route belongs to, failed and resolved, and no others', async () => {
+    const graph = await monorepo();
+    const { queries, resolver } = internals(graph);
+    const admin = ['apps/admin/src/Home.jsx failed', 'apps/admin/src/Home.jsx failed', 'apps/admin/src/Home.jsx → /'];
+    expect(navigationState(graph)).toEqual([...admin, 'apps/web/src/Home.jsx failed', 'apps/web/src/Home.jsx failed', 'apps/web/src/Home.jsx → /']);
+    const web = queries.getNodesByKind('route').find((r) => r.filePath === 'apps/web/src/App.jsx')!;
+
+    expect(resolver.reopenNavigationsFor([routeAt(web, '/login')])).toBe(3);
+    expect(navigationState(graph)).toEqual(admin);
+    expect(graph.getPendingReferenceCount()).toBe(3);
+  }, 60_000);
+
+  it('leaves alone the calls in a file the sync just resolved', async () => {
+    const graph = await monorepo();
+    const { queries, resolver } = internals(graph);
+    const web = queries.getNodesByKind('route').find((r) => r.filePath === 'apps/web/src/App.jsx')!;
+    expect(resolver.reopenNavigationsFor([routeAt(web, '/login')], ['apps/web/src/Home.jsx'])).toBe(0);
+    expect(graph.getPendingReferenceCount()).toBe(0);
+  }, 60_000);
+
+  it('skips a name more calls share than the ceiling', async () => {
+    const graph = await monorepo();
+    const { queries, resolver } = internals(graph);
+    // Both apps gain a route: six `navigate` calls between them.
+    const added = queries.getNodesByKind('route').map((r) => routeAt(r, '/login'));
+    expect(resolver.reopenNavigationsFor(added, [], 5)).toBe(0);
+    expect(resolver.reopenNavigationsFor(added, [], 6)).toBe(6);
+  }, 60_000);
+
+  it('passes over a route no router navigates to', async () => {
+    const graph = await monorepo();
+    const { queries, resolver } = internals(graph);
+    // A nested route's relative path is not a destination of its own.
+    const added = queries.getNodesByKind('route').map((r) => routeAt(r, 'login'));
+    const lookup = vi.spyOn(QueryBuilder.prototype, 'getFailedCallsByTail');
+    expect(resolver.reopenNavigationsFor(added)).toBe(0);
+    expect(lookup).not.toHaveBeenCalled();
+  }, 60_000);
+});
+
+describe('changedRoutes', () => {
+  const route = (filePath: string, name: string, id = `route:${filePath}:1:${name}`): Node => ({
+    id, kind: 'route', name, qualifiedName: `${filePath}::route:${name}`, filePath, language: 'jsx',
+    startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: 0,
+  });
+
+  it('is the routes on one side only, by file and path', () => {
+    const kept = route('src/App.jsx', '/');
+    const moved = route('src/App.jsx', '/cart');
+    const gone = route('src/App.jsx', '/login');
+    const added = route('src/Admin.jsx', '/admin');
+    // A body edit moves a route's line, and with it its id: still the same route.
+    const after = [{ ...kept, id: 'route:src/App.jsx:2:/', startLine: 2 }, moved, added];
+    expect(changedRoutes([kept, moved, gone], after)).toEqual([gone, added]);
+  });
+
+  it('counts a route renamed in place as its old path and its new one', () => {
+    const old = route('src/router.tsx', '/auth/sign-in', 'route:src/router.tsx:5:paths.auth.login.path');
+    const renamed = { ...old, name: '/auth/login' };
+    expect(changedRoutes([old], [renamed])).toEqual([old, renamed]);
+  });
+});
+
+describe('a sync that changes no route', () => {
+  it('looks up no failed navigation', async () => {
+    const c = CASES[0]!;
+    const root = tempRoot();
+    write(root, c.files);
+    const graph = await index(root);
+    const lookup = vi.spyOn(QueryBuilder.prototype, 'getFailedCallsByTail');
+    // A body edit to the file the routes are declared in, and to an unrelated one.
+    put(root, c.route.file, c.files[c.route.file]!.replace('export default App', 'export default App // routes'));
+    put(root, 'src/screens/LoginScreen.js', 'const LoginScreen = () => <div>Sign in</div>\nexport default LoginScreen\n');
+    const result = await graph.sync();
+    expect(result.filesModified).toBe(2);
+    expect(lookup).not.toHaveBeenCalled();
+  }, 60_000);
+
+  it('takes no route snapshot without a router that navigates', async () => {
+    const root = tempRoot();
+    write(root, { 'package.json': JSON.stringify({ name: 'lib' }), 'src/a.ts': 'export function a() { return 1; }\n' });
+    const graph = await index(root);
+    const reopen = vi.spyOn(internals(graph).resolver, 'reopenNavigationsFor');
+    put(root, 'src/a.ts', 'export function a() { return 2; }\n');
+    expect((await graph.sync()).filesModified).toBe(1);
+    expect(reopen).not.toHaveBeenCalled();
+  }, 60_000);
+});
+
+describe('FrameworkResolver.navigation', () => {
+  // Navigation calls each router's own tests resolve.
+  const CALLS: Record<string, string[]> = {
+    'react-router': ['history.push', 'history.replace', 'navigate', 'navigate.push', 'router.navigate', 'redirect'],
+    nextjs: ['router.push', 'router.replace', 'router.prefetch', 'redirect', 'permanentRedirect', 'NextResponse.redirect'],
+    'expo-router': ['router.push', 'router.replace', 'router.navigate', 'router.dismissTo', 'nav.push'],
+    'vue-router': ['router.push', 'this.$router.push', '$router.replace', 'navigateTo'],
+    'angular-router': ['this.router.navigate', 'router.navigateByUrl', 'this._router.createUrlTree', 'Router.parseUrl'],
+    'tanstack-router': ['navigate', 'redirect', 'router.navigate', 'Route.navigate'],
+    'sveltekit-router': ['goto', 'redirect'],
+  };
+
+  it('is set by every router that binds navigation calls, and finds each by its tail', () => {
+    const routers = getAllFrameworkResolvers().filter((r) => r.navigation);
+    expect(routers.map((r) => r.name).sort()).toEqual(Object.keys(CALLS).sort());
+    for (const router of routers) {
+      for (const call of CALLS[router.name]!) {
+        expect(router.claimsReference?.(call), `${router.name} claims ${call}`).toBe(true);
+        expect(router.navigation!.tails, `${router.name} ${call}`).toContain(referenceNameTail(call, 'calls'));
+      }
+    }
+  });
+});
diff --git a/__tests__/sync-path-reference-retry.test.ts b/__tests__/sync-path-reference-retry.test.ts
new file mode 100644
index 0000000000..f6953cb0ee
--- /dev/null
+++ b/__tests__/sync-path-reference-retry.test.ts
@@ -0,0 +1,139 @@
+/**
+ * A sync links a reference written as a path once the file it names appears.
+ *
+ * Sync retries parked failed refs by name tail (#1240): the tail is matched
+ * against the names of the nodes a sync adds, and a file's node is named for
+ * the file. A reference written as a path — Liquid's `{% render 'price' %}` is
+ * `snippets/price.liquid`, a JSON template's section `"type": "404"` is
+ * `sections/404.liquid` — was parked under its extension, `liquid`, which no
+ * node is named, so it linked only once the file naming it changed or on a
+ * full index. #2392 fixed the same gap for imports.
+ */
+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/index';
+import { DatabaseConnection, getDatabasePath } from '../src/db';
+import { CURRENT_SCHEMA_VERSION, getCurrentVersion, runMigrations } from '../src/db/migrations';
+import { QueryBuilder } from '../src/db/queries';
+import { referenceNameTail } from '../src/db/reference-tail';
+
+let root: string | undefined;
+let cg: CodeGraph | undefined;
+let db: DatabaseConnection | undefined;
+
+afterEach(() => {
+  cg?.close();
+  cg = undefined;
+  db?.close();
+  db = undefined;
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+  root = undefined;
+});
+
+function write(files: Record<string, string>): void {
+  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);
+  }
+}
+
+describe('referenceNameTail', () => {
+  it('parks a reference written as a path under the name of the file it names', () => {
+    expect(referenceNameTail('snippets/price.liquid', 'references')).toBe('price.liquid');
+    expect(referenceNameTail('sections/404.liquid', 'references')).toBe('404.liquid');
+    expect(referenceNameTail('snippets/icon.logo.liquid', 'references')).toBe('icon.logo.liquid');
+  });
+
+  it('keeps the symbol tail of a reference that names no file', () => {
+    // No path, a path with no file name at its end, or an Erlang arity. (A
+    // route's module, `lazy-import:./routes/about.tsx` or
+    // `import:./home.component#HomeComponent`, is sync-route-module-retry's.)
+    expect(referenceNameTail('Foo.Bar', 'references')).toBe('Bar');
+    expect(referenceNameTail('snippets/price', 'references')).toBe('snippets/price');
+    expect(referenceNameTail('lists::map/2', 'references')).toBe('map');
+    // A call's slashes sit in its arguments, a comment or a division.
+    expect(referenceNameTail('assert.logfile("logs/error.log").has.line', 'calls')).toBe('line');
+    expect(referenceNameTail('(rss_kb / 1024.0).to_i', 'calls')).toBe('to_i');
+    // An import keeps the stem of its path (#2392).
+    expect(referenceNameTail('package:app/b.dart', 'imports')).toBe('b');
+  });
+});
+
+describe('sync links a path reference whose file appears later', () => {
+  it('in an index whose references an older version parked', async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-path-ref-'));
+    write({
+      'layout/theme.liquid': "{% render 'price' %}{{ content_for_layout }}\n",
+      'templates/404.json': JSON.stringify({ sections: { main: { type: '404' } }, order: ['main'] }),
+    });
+    cg = await CodeGraph.init(root, { index: true });
+    cg.close();
+    cg = undefined;
+
+    // What a version before 13 left: the extension as the tail.
+    db = DatabaseConnection.open(getDatabasePath(root));
+    db.getDb().exec(`UPDATE unresolved_refs SET name_tail = 'liquid' WHERE reference_kind = 'references';
+      DELETE FROM schema_versions WHERE version >= 13;
+      INSERT OR IGNORE INTO schema_versions(version, applied_at, description) VALUES (12, 0, 'legacy fixture');`);
+    db.close();
+    db = undefined;
+
+    cg = await CodeGraph.open(root);
+    write({ 'sections/404.liquid': '<h1>404</h1>\n', 'snippets/price.liquid': '{{ product.price }}\n' });
+    expect((await cg.sync()).filesAdded).toBe(2);
+    expect(cg.getFileDependencies('templates/404.json')).toEqual(['sections/404.liquid']);
+    expect(cg.getFileDependencies('layout/theme.liquid')).toEqual(['snippets/price.liquid']);
+    expect(cg.getPendingReferenceCount()).toBe(0);
+  }, 60_000);
+});
+
+describe('schema v13', () => {
+  function fixture(): QueryBuilder {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-sync-path-ref-'));
+    db = DatabaseConnection.initialize(path.join(root, 'test.db'));
+    const queries = new QueryBuilder(db.getDb());
+    queries.insertNode({ id: 'a', kind: 'file', name: 'theme.liquid', qualifiedName: 'layout/theme.liquid', filePath: 'layout/theme.liquid',
+      language: 'liquid', startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: 0 });
+    for (const [referenceName, referenceKind, status, tail] of [
+      ['snippets/price.liquid', 'references', 'failed', 'liquid'],
+      ['sections/icon.logo.liquid', 'references', 'failed', 'liquid'],
+      ['snippets/card.liquid', 'references', 'pending', ''],
+      ['package:app/b.dart', 'imports', 'failed', 'b'],
+      ['assert.logfile("logs/error.log").has.line', 'calls', 'failed', 'line'],
+      ['lists::map/2', 'calls', 'failed', 'map'],
+    ] as const) {
+      queries.insertUnresolvedRef({ fromNodeId: 'a', referenceName, referenceKind, line: 1, column: 0, filePath: 'layout/theme.liquid', language: 'liquid' });
+      db.getDb().prepare('UPDATE unresolved_refs SET status = ?, name_tail = ? WHERE reference_name = ?').run(status, tail, referenceName);
+    }
+    return queries;
+  }
+
+  const tails = () => db!.getDb().prepare('SELECT reference_name AS name, name_tail AS tail FROM unresolved_refs ORDER BY id').all();
+
+  it('rewrites the tail of a path reference parked by an older version, and replays cleanly', () => {
+    fixture();
+    db!.getDb().exec(`DELETE FROM schema_versions WHERE version >= 13;
+      INSERT OR IGNORE INTO schema_versions(version, applied_at, description) VALUES (12, 0, 'legacy fixture');`);
+    db!.close();
+    db = DatabaseConnection.open(path.join(root!, 'test.db'));
+    expect(getCurrentVersion(db.getDb())).toBe(CURRENT_SCHEMA_VERSION);
+    const migrated = tails();
+    expect(migrated).toEqual([
+      { name: 'snippets/price.liquid', tail: 'price.liquid' },
+      { name: 'sections/icon.logo.liquid', tail: 'icon.logo.liquid' },
+      // Only a failed row is looked up by its tail.
+      { name: 'snippets/card.liquid', tail: '' },
+      { name: 'package:app/b.dart', tail: 'b' },
+      { name: 'assert.logfile("logs/error.log").has.line', tail: 'line' },
+      { name: 'lists::map/2', tail: 'map' },
+    ]);
+    const queries = new QueryBuilder(db.getDb());
+    expect(queries.getRetryableFailedReferences(['price.liquid', 'liquid']).map((ref) => ref.referenceName)).toEqual(['snippets/price.liquid']);
+
+    db.getDb().exec('DELETE FROM schema_versions WHERE version >= 13');
+    runMigrations(db.getDb(), 12);
+    expect(tails()).toEqual(migrated);
+  });
+});
diff --git a/__tests__/sync-route-module-retry.test.ts b/__tests__/sync-route-module-retry.test.ts
new file mode 100644
index 0000000000..2e138329fe
--- /dev/null
+++ b/__tests__/sync-route-module-retry.test.ts
@@ -0,0 +1,454 @@
+/**
+ * A sync links a route to the module it lazily loads once the module appears.
+ *
+ * A router names a lazily loaded page or layout by the module's path: React
+ * Router's `lazy: () => import('./pages/Team')` is the reference
+ * `lazy-import:./pages/Team`, Vue Router's `component: () =>
+ * import('@/views/Login')` is `import:@/views/Login#Login`, and Angular's
+ * `loadComponent: () => import('./home/home.component')` is
+ * `import:./home/home.component#default`. Sync retries a parked failed ref by
+ * its tail (#1240), and these were parked under a fragment of the path —
+ * `/pages/Team`, `@/views/Login#Login`, `component#default` — that no file's
+ * keys match. So a route whose module was added after the router was indexed
+ * stayed unlinked until the router file changed or the project was indexed
+ * again, and so did one whose module gained its component in a later edit.
+ * #2392 fixed the same gap for imports, #2403 for Liquid's path references.
+ */
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import CodeGraph from '../src/index';
+import { DatabaseConnection, getDatabasePath } from '../src/db';
+import { CURRENT_SCHEMA_VERSION, getCurrentVersion, runMigrations } from '../src/db/migrations';
+import { QueryBuilder } from '../src/db/queries';
+import { moduleReferenceKeys, referenceNameTail } from '../src/db/reference-tail';
+
+type Files = Record<string, string>;
+/** Each route's links: `<edge kind>[ layout] <target file>::<target name>`. */
+type Links = Record<string, string[]>;
+
+interface Scenario {
+  name: string;
+  initial: Files;
+  added: Files;
+  expected: Links;
+}
+
+const pkg = (dependencies: Record<string, string>) => JSON.stringify({ name: 'app', dependencies });
+const angularComponent = (name: string, exported = 'export') =>
+  `import { Component } from '@angular/core';\n\n@Component({ selector: 'app-x', template: '' })\n${exported} class ${name} {}\n`;
+const vueView = (text: string) => `<template><div>${text}</div></template>\n<script setup>\nconst ready = true\n</script>\n`;
+
+const SCENARIOS: Scenario[] = [
+  {
+    name: 'React Router',
+    initial: {
+      'package.json': pkg({ react: '^18', 'react-router-dom': '^6' }),
+      'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['src/*'] } } }),
+      'src/router.tsx': [
+        "import { createBrowserRouter } from 'react-router-dom';",
+        'export const router = createBrowserRouter([',
+        "  { path: '/team', lazy: () => import('./pages/Team') },",
+        "  { path: '/about', lazy: () => import('./pages/About.tsx') },",
+        "  { path: '/docs', lazy: () => import('./pages/Docs') },",
+        "  { path: '/settings', lazy: () => import('./pages/Settings') },",
+        "  { path: '/billing', lazy: () => import('@/pages/Billing') },",
+        "  { path: '/app', lazy: () => import('./layouts/Shell'), children: [",
+        "    { path: 'inbox', lazy: () => import('./pages/Inbox') },",
+        '  ] },',
+        ']);',
+        '',
+      ].join('\n'),
+    },
+    added: {
+      'src/pages/Team.tsx': 'export default function Team() { return null; }\n',
+      'src/pages/About.tsx': 'export default function About() { return null; }\n',
+      // A default export named unlike its file.
+      'src/pages/Docs.tsx': 'export default function DocsPage() { return null; }\n',
+      // A folder's index file.
+      'src/pages/Settings/index.tsx': 'export default function Settings() { return null; }\n',
+      // Through a tsconfig alias, rendering the module's `Component` export.
+      'src/pages/Billing.tsx': 'export function Component() { return null; }\n',
+      'src/layouts/Shell.tsx': 'export default function Shell() { return null; }\n',
+      'src/pages/Inbox.tsx': 'export default function Inbox() { return null; }\n',
+    },
+    expected: {
+      '/team': ['references src/pages/Team.tsx::Team'],
+      '/about': ['references src/pages/About.tsx::About'],
+      '/docs': ['references src/pages/Docs.tsx::DocsPage'],
+      '/settings': ['references src/pages/Settings/index.tsx::Settings'],
+      '/billing': ['references src/pages/Billing.tsx::Component'],
+      '/app': ['references src/layouts/Shell.tsx::Shell'],
+      '/app/inbox': ['references layout src/layouts/Shell.tsx::Shell', 'references src/pages/Inbox.tsx::Inbox'],
+    },
+  },
+  {
+    name: 'Vue Router',
+    initial: {
+      'package.json': pkg({ vue: '^3', 'vue-router': '^4' }),
+      'src/router/index.js': [
+        "import { createRouter, createWebHistory } from 'vue-router'",
+        'export default createRouter({',
+        '  history: createWebHistory(),',
+        '  routes: [',
+        "    { path: '/', component: () => import('../views/Home.vue') },",
+        "    { path: '/login', component: () => import('@/views/Login') },",
+        "    { path: '/admin', component: () => import('@/layout/index.vue'), children: [",
+        "      { path: 'dashboard', component: () => import('@/views/dashboard/index') },",
+        '    ] },',
+        '  ]',
+        '})',
+        '',
+      ].join('\n'),
+    },
+    added: {
+      'src/views/Home.vue': vueView('home'),
+      'src/views/Login.vue': vueView('login'),
+      'src/layout/index.vue': vueView('<router-view />'),
+      'src/views/dashboard/index.vue': vueView('dashboard'),
+    },
+    expected: {
+      '/': ['calls src/views/Home.vue::Home'],
+      '/login': ['calls src/views/Login.vue::Login'],
+      '/admin': ['calls src/layout/index.vue::index'],
+      '/admin/dashboard': ['calls src/views/dashboard/index.vue::index', 'references layout src/layout/index.vue::index'],
+    },
+  },
+  {
+    name: 'Angular',
+    initial: {
+      'package.json': pkg({ '@angular/core': '^17', '@angular/router': '^17' }),
+      'src/app/app.routes.ts': [
+        "import { Routes } from '@angular/router';",
+        'export const routes: Routes = [',
+        "  { path: '', loadComponent: () => import('./home/home.component').then((m) => m.HomeComponent) },",
+        "  { path: 'about', loadComponent: () => import('./about/about.component') },",
+        "  { path: 'admin', loadComponent: () => import('./admin/shell.component').then((m) => m.ShellComponent), children: [",
+        "      { path: 'users', loadComponent: () => import('./admin/users.component').then((m) => m.UsersComponent) },",
+        '  ] },',
+        '];',
+        '',
+      ].join('\n'),
+    },
+    added: {
+      'src/app/home/home.component.ts': angularComponent('HomeComponent'),
+      'src/app/about/about.component.ts': angularComponent('AboutComponent', 'export default'),
+      'src/app/admin/shell.component.ts': angularComponent('ShellComponent'),
+      'src/app/admin/users.component.ts': angularComponent('UsersComponent'),
+    },
+    expected: {
+      '/': ['references src/app/home/home.component.ts::HomeComponent'],
+      '/about': ['references src/app/about/about.component.ts::AboutComponent'],
+      '/admin': ['references src/app/admin/shell.component.ts::ShellComponent'],
+      '/admin/users': ['references layout src/app/admin/shell.component.ts::ShellComponent', 'references src/app/admin/users.component.ts::UsersComponent'],
+    },
+  },
+  {
+    // Ghostfolio's markets page: the child loads the class its layout
+    // renders, so the child's route and layout references make one edge, and
+    // the reference resolved first names it — in a full index, the one
+    // written first.
+    name: 'Angular, a child loading its layout\'s class',
+    initial: {
+      'package.json': pkg({ '@angular/core': '^17', '@angular/router': '^17' }),
+      'src/app/app.routes.ts': [
+        "import { Routes } from '@angular/router';",
+        "import { MarketsComponent } from './markets/markets.component';",
+        'export const routes: Routes = [',
+        "  { path: 'markets', component: MarketsComponent, children: [",
+        "      { path: '', loadComponent: () => import('./markets/markets.component').then((m) => m.MarketsComponent) },",
+        '  ] },',
+        '];',
+        '',
+      ].join('\n'),
+    },
+    added: { 'src/app/markets/markets.component.ts': angularComponent('MarketsComponent') },
+    expected: { '/markets': ['references src/app/markets/markets.component.ts::MarketsComponent'] },
+  },
+];
+
+/**
+ * The module is there from the start, but only a later edit gives it the
+ * component the route renders: React's default export, a component a Vue
+ * route loads from a script, Angular's class.
+ */
+const EDITED: Scenario[] = [
+  {
+    name: 'React Router',
+    initial: {
+      'package.json': pkg({ react: '^18', 'react-router-dom': '^6' }),
+      'src/router.tsx': "import { createBrowserRouter } from 'react-router-dom';\nexport const router = createBrowserRouter([{ path: '/team', lazy: () => import('./pages/Team') }]);\n",
+      'src/pages/Team.tsx': 'export const placeholder = 1;\n',
+    },
+    added: { 'src/pages/Team.tsx': 'export default function Team() { return null; }\n' },
+    expected: { '/team': ['references src/pages/Team.tsx::Team'] },
+  },
+  {
+    name: 'Vue Router',
+    initial: {
+      'package.json': pkg({ vue: '^3', 'vue-router': '^4' }),
+      'src/router/index.js': "import { createRouter, createWebHistory } from 'vue-router'\nexport default createRouter({ history: createWebHistory(), routes: [{ path: '/', component: () => import('../views/Home.js') }] })\n",
+      'src/views/Home.js': 'export const placeholder = 1\n',
+    },
+    added: { 'src/views/Home.js': 'export default function Home() { return null }\n' },
+    expected: { '/': ['calls src/views/Home.js::Home'] },
+  },
+  {
+    name: 'Angular',
+    initial: {
+      'package.json': pkg({ '@angular/core': '^17', '@angular/router': '^17' }),
+      'src/app/app.routes.ts': "import { Routes } from '@angular/router';\nexport const routes: Routes = [{ path: '', loadComponent: () => import('./home/home.component').then((m) => m.HomeComponent) }];\n",
+      'src/app/home/home.component.ts': 'export const placeholder = 1;\n',
+    },
+    added: { 'src/app/home/home.component.ts': angularComponent('HomeComponent') },
+    expected: { '/': ['references src/app/home/home.component.ts::HomeComponent'] },
+  },
+];
+
+let root: string | undefined;
+let cg: CodeGraph | undefined;
+let db: DatabaseConnection | undefined;
+
+afterEach(() => {
+  cg?.close();
+  cg = undefined;
+  db?.close();
+  db = undefined;
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+  root = undefined;
+});
+
+function write(dir: string, files: Files): void {
+  for (const [file, text] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
+    fs.writeFileSync(path.join(dir, file), text);
+  }
+}
+
+function routeLinks(graph: CodeGraph): Links {
+  const links: Links = {};
+  for (const route of graph.getNodesByKind('route')) {
+    links[route.name] = graph
+      .getOutgoingEdges(route.id)
+      .filter((edge) => edge.kind !== 'contains')
+      .map((edge) => {
+        const target = graph.getNode(edge.target);
+        return `${edge.kind}${edge.metadata?.layout ? ' layout' : ''} ${target?.filePath}::${target?.name}`;
+      })
+      .sort();
+  }
+  return links;
+}
+
+const unlinked = (expected: Links): Links => Object.fromEntries(Object.keys(expected).map((route) => [route, []]));
+
+/** The route links of a fresh index of `files`, in a folder of its own: indexing again over an index skips its unchanged files. */
+async function freshRouteLinks(files: Files): Promise<Links> {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-route-module-fresh-'));
+  try {
+    write(dir, files);
+    const fresh = await CodeGraph.init(dir, { index: true });
+    try {
+      return routeLinks(fresh);
+    } finally {
+      fresh.close();
+    }
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe('sync links a route to the module it lazily loads', () => {
+  it.each(SCENARIOS)('when the module is added after the router: $name', async (s) => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-route-module-'));
+    write(root, s.initial);
+    cg = await CodeGraph.init(root, { index: true });
+    expect(routeLinks(cg)).toEqual(unlinked(s.expected));
+
+    write(root, s.added);
+    expect((await cg.sync()).filesAdded).toBe(Object.keys(s.added).length);
+    // The router did not change: only the retry of its parked references links it.
+    expect(routeLinks(cg)).toEqual(s.expected);
+    expect(cg.getPendingReferenceCount()).toBe(0);
+    expect(await freshRouteLinks({ ...s.initial, ...s.added })).toEqual(s.expected);
+  }, 60_000);
+
+  // The component a route renders is the module's, so an edit that gives the
+  // module one is what the route waited for.
+  it.each(EDITED)('when an edit gives the module its component: $name', async (s) => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-route-module-'));
+    write(root, s.initial);
+    cg = await CodeGraph.init(root, { index: true });
+    expect(routeLinks(cg)).toEqual(unlinked(s.expected));
+
+    write(root, s.added);
+    expect((await cg.sync()).filesModified).toBe(1);
+    expect(routeLinks(cg)).toEqual(s.expected);
+    expect(cg.getPendingReferenceCount()).toBe(0);
+    expect(await freshRouteLinks({ ...s.initial, ...s.added })).toEqual(s.expected);
+  }, 60_000);
+
+  it('when a deleted module comes back', async () => {
+    const [react] = SCENARIOS;
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-route-module-'));
+    write(root, { ...react!.initial, ...react!.added });
+    cg = await CodeGraph.init(root, { index: true });
+    expect(routeLinks(cg)['/team']).toEqual(['references src/pages/Team.tsx::Team']);
+
+    fs.rmSync(path.join(root, 'src/pages/Team.tsx'));
+    expect((await cg.sync()).filesRemoved).toBe(1);
+    expect(routeLinks(cg)['/team']).toEqual([]);
+    expect(cg.getPendingReferenceCount()).toBe(0);
+
+    write(root, { 'src/pages/Team.tsx': react!.added['src/pages/Team.tsx']! });
+    expect((await cg.sync()).filesAdded).toBe(1);
+    expect(routeLinks(cg)).toEqual(react!.expected);
+  }, 60_000);
+
+  it('in an index whose references an older version parked', async () => {
+    const [react] = SCENARIOS;
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-route-module-'));
+    write(root, react!.initial);
+    cg = await CodeGraph.init(root, { index: true });
+    cg.close();
+    cg = undefined;
+
+    // What a version before 14 left: the tail cut at the path's last dot or colon.
+    db = DatabaseConnection.open(getDatabasePath(root));
+    const refs = db.getDb().prepare("SELECT id, reference_name AS name FROM unresolved_refs WHERE reference_name LIKE '%lazy-import:%'").all() as Array<{ id: number; name: string }>;
+    expect(refs).toHaveLength(8);
+    for (const ref of refs) {
+      const legacy = ref.name.slice(Math.max(ref.name.lastIndexOf('.'), ref.name.lastIndexOf(':')) + 1);
+      db.getDb().prepare('UPDATE unresolved_refs SET name_tail = ? WHERE id = ?').run(legacy, ref.id);
+    }
+    db.getDb().exec(`DELETE FROM schema_versions WHERE version >= 14;
+      INSERT OR IGNORE INTO schema_versions(version, applied_at, description) VALUES (13, 0, 'legacy fixture');`);
+    db.close();
+    db = undefined;
+
+    cg = await CodeGraph.open(root);
+    write(root, react!.added);
+    await cg.sync();
+    expect(routeLinks(cg)).toEqual(react!.expected);
+    expect(cg.getPendingReferenceCount()).toBe(0);
+  }, 60_000);
+});
+
+describe('referenceNameTail', () => {
+  it('parks a route\'s reference to a module under the stem of its path, behind module:', () => {
+    // React Router: a lazy route, and the lazy layout route around another.
+    expect(referenceNameTail('lazy-import:./pages/Team', 'references')).toBe('module:Team');
+    expect(referenceNameTail('lazy-import:./routes/about.tsx', 'references')).toBe('module:about');
+    expect(referenceNameTail('lazy-import:@/pages/Billing', 'references')).toBe('module:Billing');
+    expect(referenceNameTail('lazy-import:./pages/Settings/', 'references')).toBe('module:Settings');
+    expect(referenceNameTail('layout:lazy-import:./layouts/Shell', 'references')).toBe('module:Shell');
+    // Vue Router: the component a route renders is a call, its layout a reference;
+    // vben's `#/` alias puts a `#` in the path.
+    expect(referenceNameTail('import:@/views/Login#Login', 'calls')).toBe('module:Login');
+    expect(referenceNameTail('import:../views/Home.vue#Home', 'calls')).toBe('module:Home');
+    expect(referenceNameTail('import:#/views/dashboard/analytics/index.vue#index', 'calls')).toBe('module:index');
+    expect(referenceNameTail('layout:import:@/layout/index.vue#index', 'references')).toBe('module:index');
+    // Angular: a member the import names, or the module's default.
+    expect(referenceNameTail('import:./home/home.component#HomeComponent', 'references')).toBe('module:home');
+    expect(referenceNameTail('import:./about/about.component#default', 'references')).toBe('module:about');
+    expect(referenceNameTail('layout:import:./admin/shell.component#ShellComponent', 'references')).toBe('module:shell');
+  });
+
+  it('keeps the tail of a reference that names no module', () => {
+    // A layout named by its component, a module path of dots only, an import
+    // name with no member, and an import itself.
+    expect(referenceNameTail('layout:MainLayout', 'references')).toBe('MainLayout');
+    expect(referenceNameTail('lazy-import:..', 'references')).not.toMatch(/^module:/);
+    expect(referenceNameTail('import:./x', 'calls')).toBe('/x');
+    expect(referenceNameTail('./pages/Team', 'imports')).toBe('Team');
+    // The same names as another kind of reference are not a route's.
+    expect(referenceNameTail('import:./home.component#HomeComponent', 'imports')).toBe('home');
+    expect(referenceNameTail('lazy-import:./pages/Team', 'type_of')).toBe('/pages/Team');
+  });
+});
+
+describe('moduleReferenceKeys', () => {
+  it('gives a file the keys a module reference it could satisfy waits under', () => {
+    expect(moduleReferenceKeys('src/pages/Team.tsx')).toEqual(['module:pages', 'module:Team.tsx', 'module:Team']);
+    expect(moduleReferenceKeys('src/pages/Settings/index.tsx')).toEqual(['module:Settings', 'module:index.tsx', 'module:index']);
+    expect(moduleReferenceKeys('src/app/home/home.component.ts')).toEqual(['module:home', 'module:home.component.ts']);
+  });
+});
+
+describe('schema v14', () => {
+  function fixture(): QueryBuilder {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-route-module-'));
+    db = DatabaseConnection.initialize(path.join(root, 'test.db'));
+    const queries = new QueryBuilder(db.getDb());
+    queries.insertNode({ id: 'r', kind: 'route', name: '/team', qualifiedName: 'src/router.tsx::route:/team', filePath: 'src/router.tsx',
+      language: 'tsx', startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: 0 });
+    for (const [referenceName, referenceKind, status, tail] of [
+      ['lazy-import:./pages/Team', 'references', 'failed', '/pages/Team'],
+      ['layout:lazy-import:./layouts/Shell', 'references', 'failed', '/layouts/Shell'],
+      ['lazy-import:./pages/About.tsx', 'references', 'failed', 'About.tsx'],
+      ['import:@/views/Login#Login', 'calls', 'failed', '@/views/Login#Login'],
+      ['layout:import:@/layout/index.vue#index', 'references', 'failed', 'vue#index'],
+      ['import:./home/home.component#HomeComponent', 'references', 'failed', 'component#HomeComponent'],
+      // Only a failed row is looked up by its tail.
+      ['lazy-import:./pages/Docs', 'references', 'pending', ''],
+      ['layout:MainLayout', 'references', 'failed', 'MainLayout'],
+      ['snippets/price.liquid', 'references', 'failed', 'price.liquid'],
+      ['./pages/Team', 'imports', 'failed', 'Team'],
+      ['Team', 'calls', 'failed', 'Team'],
+    ] as const) {
+      queries.insertUnresolvedRef({ fromNodeId: 'r', referenceName, referenceKind, line: 1, column: 0, filePath: 'src/router.tsx', language: 'tsx' });
+      db.getDb().prepare('UPDATE unresolved_refs SET status = ?, name_tail = ? WHERE reference_name = ?').run(status, tail, referenceName);
+    }
+    return queries;
+  }
+
+  const tails = () => db!.getDb().prepare('SELECT reference_name AS name, name_tail AS tail FROM unresolved_refs ORDER BY id').all();
+
+  it('rewrites the tail of a module reference parked by an older version, and replays cleanly', () => {
+    fixture();
+    db!.getDb().exec(`DELETE FROM schema_versions WHERE version >= 14;
+      INSERT OR IGNORE INTO schema_versions(version, applied_at, description) VALUES (13, 0, 'legacy fixture');`);
+    db!.close();
+    db = DatabaseConnection.open(path.join(root!, 'test.db'));
+    expect(getCurrentVersion(db.getDb())).toBe(CURRENT_SCHEMA_VERSION);
+    const migrated = tails();
+    expect(migrated).toEqual([
+      { name: 'lazy-import:./pages/Team', tail: 'module:Team' },
+      { name: 'layout:lazy-import:./layouts/Shell', tail: 'module:Shell' },
+      { name: 'lazy-import:./pages/About.tsx', tail: 'module:About' },
+      { name: 'import:@/views/Login#Login', tail: 'module:Login' },
+      { name: 'layout:import:@/layout/index.vue#index', tail: 'module:index' },
+      { name: 'import:./home/home.component#HomeComponent', tail: 'module:home' },
+      { name: 'lazy-import:./pages/Docs', tail: '' },
+      { name: 'layout:MainLayout', tail: 'MainLayout' },
+      { name: 'snippets/price.liquid', tail: 'price.liquid' },
+      { name: './pages/Team', tail: 'Team' },
+      { name: 'Team', tail: 'Team' },
+    ]);
+
+    // A module reference waits for a file that could be the module, not for
+    // a symbol: `Team` is the tail of the import and the call, not of the route.
+    const queries = new QueryBuilder(db.getDb());
+    const retried = (names: string[]) => queries.getRetryableFailedReferences(names).map((ref) => ref.referenceName).sort();
+    expect(retried(moduleReferenceKeys('src/pages/Team.tsx'))).toEqual(['lazy-import:./pages/Team']);
+    expect(retried(moduleReferenceKeys('src/app/home/home.component.ts'))).toEqual(['import:./home/home.component#HomeComponent']);
+    expect(retried(['Team', 'home', 'index'])).toEqual(['./pages/Team', 'Team']);
+
+    db.getDb().exec('DELETE FROM schema_versions WHERE version >= 14');
+    runMigrations(db.getDb(), 13);
+    expect(tails()).toEqual(migrated);
+  });
+
+  it('reads only the references its prefixes name, not every failed one', () => {
+    fixture();
+    const prepare = vi.spyOn(db!.getDb(), 'prepare');
+    db!.getDb().exec('DELETE FROM schema_versions WHERE version >= 14');
+    runMigrations(db!.getDb(), 13);
+    const select = prepare.mock.calls.map(([sql]) => sql as string).find((sql) => sql.includes("GLOB 'lazy-import:*'"));
+    prepare.mockRestore();
+    const plan = db!.getDb().prepare(`EXPLAIN QUERY PLAN ${select}`).all().map((row) => (row as { detail: string }).detail).join('; ');
+    expect(plan).toMatch(/USING (COVERING )?INDEX idx_unresolved_name/);
+    expect(plan).not.toMatch(/idx_unresolved_status|SCAN unresolved_refs/);
+  });
+});
diff --git a/__tests__/sync.test.ts b/__tests__/sync.test.ts
index 556f93a9a1..5729756a21 100644
--- a/__tests__/sync.test.ts
+++ b/__tests__/sync.test.ts
@@ -12,8 +12,42 @@ import * as path from 'path';
 import * as os from 'os';
 import { execFileSync } from 'child_process';
 import CodeGraph, { LockUnavailableError } from '../src/index';
+import { QueryBuilder } from '../src/db/queries';
 import { __emitWatchEventForTests } from '../src/sync/watcher';
 
+/**
+ * Index `cg`'s project again from an empty database, as `codegraph index`
+ * does, and return the new handle: the graph a synced index has to match.
+ * indexAll over the synced index is no stand-in — it skips every file whose
+ * content is unchanged, so the edges the sync wrote survive it untouched.
+ */
+async function reindexFromScratch(cg: CodeGraph): Promise<CodeGraph> {
+  const root = cg.getProjectRoot();
+  // recreate unlinks the database file; a held handle makes that EBUSY on Windows.
+  cg.close();
+  const rebuilt = await CodeGraph.recreate(root);
+  await rebuilt.indexAll();
+  return rebuilt;
+}
+
+/**
+ * For a test that indexes twice in its body: on a busy host the default 5s
+ * timeout measures the machine rather than the tree (#1773).
+ */
+const REINDEX_TIMEOUT = 60_000;
+
+/** Every node and edge by natural key, so two indexes of the same files compare directly. */
+function graphOf(cg: CodeGraph): { nodes: string[]; edges: string[] } {
+  const keys = new Map(
+    cg.getFiles()
+      .flatMap((file) => cg.getNodesInFile(file.path))
+      .map((n) => [n.id, `${n.kind} ${n.filePath}:${n.qualifiedName}:${n.startLine}`] as const)
+  );
+  const edges = cg.getOutgoingEdgesFrom([...keys.keys()])
+    .map((e) => `${e.kind} ${keys.get(e.source)} -> ${keys.get(e.target) ?? e.target}`);
+  return { nodes: [...keys.values()].sort(), edges: edges.sort() };
+}
+
 describe('Sync Module', () => {
   describe('Sync Functionality', () => {
     let testDir: string;
@@ -568,14 +602,11 @@ describe('Sync Module', () => {
     it('the synced graph matches a full re-index (the issue\'s exact complaint)', async () => {
       write('b.ts', `export function greet(): number {\n  return 42;\n}\n`);
       await cg.sync();
-      const synced = cg.getStats();
+      const synced = graphOf(cg);
 
-      await cg.indexAll();
-      const reindexed = cg.getStats();
-
-      expect(synced.edgeCount).toBe(reindexed.edgeCount);
-      expect(synced.nodeCount).toBe(reindexed.nodeCount);
-    });
+      cg = await reindexFromScratch(cg);
+      expect(synced).toEqual(graphOf(cg));
+    }, REINDEX_TIMEOUT);
 
     it('a second sync is a no-op and does not duplicate edges', async () => {
       write('b.ts', `export function greet(): number {\n  return 42;\n}\n`);
@@ -662,10 +693,10 @@ describe('Sync Module', () => {
       expect(def?.filePath).toBe('d.ts');
       expect(greetCallers()).toContain('run');
       // Parity with a full re-index — the issue's contract.
-      const synced = cg.getStats();
-      await cg.indexAll();
-      expect(cg.getStats().edgeCount).toBe(synced.edgeCount);
-    });
+      const synced = graphOf(cg);
+      cg = await reindexFromScratch(cg);
+      expect(synced).toEqual(graphOf(cg));
+    }, REINDEX_TIMEOUT);
 
     it('drops the edge on removal and restores it when the symbol returns', async () => {
       write('b.ts', `export function other(): number {\n  return 1;\n}\n`);
@@ -833,6 +864,228 @@ describe('Sync Module', () => {
   });
 });
 
+describe('Same-named symbols keep their own cross-file callers across a re-index (#2276)', () => {
+  const dirs: string[] = [];
+  const graphs: CodeGraph[] = [];
+
+  afterEach(() => {
+    for (const cg of graphs.splice(0)) cg.destroy();
+    for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  async function indexProject(files: Record<string, string>, include: string[]) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-2276-'));
+    dirs.push(dir);
+    for (const [rel, content] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+      fs.writeFileSync(path.join(dir, rel), content);
+    }
+    const cg = CodeGraph.initSync(dir, { config: { include, exclude: [] } });
+    graphs.push(cg);
+    await cg.indexAll();
+    return { dir, cg };
+  }
+
+  /** Every method named `name`, in file/line order, with its callers. */
+  function callersOf(cg: CodeGraph, name: string): string[] {
+    return cg
+      .getNodesByName(name)
+      .filter((n) => n.kind === 'method')
+      .sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine)
+      .map((n) => `${n.qualifiedName}: ${cg.getCallers(n.id).map((c) => c.node.name).sort().join(',')}`);
+  }
+
+  /**
+   * Index `files`, rewrite one of them, sync, and return the callers of `name`
+   * before the edit, after the sync, and from a fresh index of the edited tree
+   * — the answer a synced index must agree with.
+   */
+  async function editAndSync(
+    files: Record<string, string>,
+    include: string[],
+    editPath: string,
+    edited: string,
+    name: string
+  ) {
+    const { dir, cg } = await indexProject(files, include);
+    const before = callersOf(cg, name);
+    fs.writeFileSync(path.join(dir, editPath), edited);
+    const result = await cg.sync();
+    expect(result.filesModified).toBe(1);
+    const fresh = await indexProject({ ...files, [editPath]: edited }, include);
+    return { before, synced: callersOf(cg, name), fresh: callersOf(fresh.cg, name) };
+  }
+
+  const tsOps = [
+    `export class Foo {`,
+    `  execute(): number {`,
+    `    return 1;`,
+    `  }`,
+    `}`,
+    ``,
+    `export class Bar {`,
+    `  execute(): number {`,
+    `    return 2;`,
+    `  }`,
+    `}`,
+    ``,
+  ].join('\n');
+  const tsFiles = {
+    'ops.ts': tsOps,
+    'callers.ts': [
+      `import { Foo, Bar } from './ops';`,
+      ``,
+      `export function runFoo(): number {`,
+      `  const foo = new Foo();`,
+      `  return foo.execute();`,
+      `}`,
+      ``,
+      `export function runBar(): number {`,
+      `  const bar = new Bar();`,
+      `  return bar.execute();`,
+      `}`,
+      ``,
+    ].join('\n'),
+  };
+
+  it.each([
+    ['a body-only edit', tsOps.replace('return 1;', 'return 10;')],
+    ['an edit that shifts the second class', tsOps.replace('return 1;', 'const n = 1;\n    return n;')],
+  ])('two classes defining `execute`: %s keeps each method its own callers', async (_label, edited) => {
+    const { before, synced, fresh } = await editAndSync(tsFiles, ['**/*.ts'], 'ops.ts', edited, 'execute');
+    expect(before).toEqual(['Foo::execute: runFoo', 'Bar::execute: runBar']);
+    expect(synced).toEqual(before);
+    expect(synced).toEqual(fresh);
+  });
+
+  it('a re-store that fails part-way leaves the old rows and their incoming edges in place', async () => {
+    const { dir, cg } = await indexProject(tsFiles, ['**/*.ts']);
+    const before = callersOf(cg, 'execute');
+    fs.writeFileSync(path.join(dir, 'ops.ts'), tsOps.replace('return 1;', 'return 10;'));
+
+    const store = vi.spyOn(QueryBuilder.prototype, 'storeFileBundle').mockImplementationOnce(() => {
+      throw new Error('simulated crash mid-store');
+    });
+    try {
+      await expect(cg.sync()).rejects.toThrow('simulated crash mid-store');
+    } finally {
+      store.mockRestore();
+    }
+    // Rolled back to the pre-edit file, so the retry still sees a modified
+    // file — one it snapshots — rather than a new one with no history.
+    expect(callersOf(cg, 'execute')).toEqual(before);
+
+    const retry = await cg.sync();
+    expect(retry.filesModified).toBe(1);
+    expect(callersOf(cg, 'execute')).toEqual(before);
+  });
+
+  it('a caller of a removed twin is re-resolved, not handed to the survivor', async () => {
+    const edited = tsOps.slice(tsOps.indexOf('export class Bar'));
+    const { synced, fresh } = await editAndSync(tsFiles, ['**/*.ts'], 'ops.ts', edited, 'execute');
+    expect(synced).toEqual(fresh);
+  });
+
+  const javaFactory = [
+    `package app;`,
+    ``,
+    `public class Factory {`,
+    `  public static Widget create(int size) {`,
+    `    return new Widget();`,
+    `  }`,
+    ``,
+    `  public static Widget create(String name) {`,
+    `    return new Widget();`,
+    `  }`,
+    `}`,
+    ``,
+  ].join('\n');
+  const javaFiles = {
+    'src/app/Factory.java': javaFactory,
+    'src/app/Widget.java': `package app;\n\npublic class Widget {}\n`,
+    'src/app/Client.java': [
+      `package app;`,
+      ``,
+      `public class Client {`,
+      `  public Widget small() {`,
+      `    return Factory.create(1);`,
+      `  }`,
+      ``,
+      `  public Widget named() {`,
+      `    return Factory.create("x");`,
+      `  }`,
+      `}`,
+      ``,
+    ].join('\n'),
+  };
+
+  it('Java overloads: a body edit leaves each overload the callers it had', async () => {
+    const edited = javaFactory.replace(
+      `create(int size) {\n    return new Widget();`,
+      `create(int size) {\n    Widget w = new Widget();\n    return w;`
+    );
+    const { before, synced, fresh } = await editAndSync(javaFiles, ['**/*.java'], 'src/app/Factory.java', edited, 'create');
+    expect(before.some((line) => /: .+/.test(line))).toBe(true);
+    expect(synced).toEqual(before);
+    expect(synced).toEqual(fresh);
+  });
+
+  // C# records no signature, so its overloads differ only by position.
+  const csFactory = [
+    `namespace App {`,
+    `  public class Factory {`,
+    `    public static Widget Create(int size) {`,
+    `      return new Widget();`,
+    `    }`,
+    ``,
+    `    public static Widget Create(string name) {`,
+    `      return new Widget();`,
+    `    }`,
+    `  }`,
+    ``,
+    `  public class Widget {}`,
+    `}`,
+    ``,
+  ].join('\n');
+  const csFiles = {
+    'Factory.cs': csFactory,
+    'Client.cs': [
+      `namespace App {`,
+      `  public class Client {`,
+      `    public Widget Small() {`,
+      `      return Factory.Create(1);`,
+      `    }`,
+      ``,
+      `    public Widget Named() {`,
+      `      return Factory.Create("x");`,
+      `    }`,
+      `  }`,
+      `}`,
+      ``,
+    ].join('\n'),
+  };
+
+  it('C# overloads with no signature: a body edit pairs them by position', async () => {
+    const edited = csFactory.replace(
+      `Create(int size) {\n      return new Widget();`,
+      `Create(int size) {\n      var w = new Widget();\n      return w;`
+    );
+    const { before, synced, fresh } = await editAndSync(csFiles, ['**/*.cs'], 'Factory.cs', edited, 'Create');
+    expect(before.some((line) => /: .+/.test(line))).toBe(true);
+    expect(synced).toEqual(before);
+    expect(synced).toEqual(fresh);
+  });
+
+  it('C# overloads: a new indistinguishable overload re-resolves the callers instead of guessing', async () => {
+    const edited = csFactory.replace(
+      `  public class Factory {\n`,
+      `  public class Factory {\n    public static Widget Create(bool flag) {\n      return new Widget();\n    }\n\n`
+    );
+    const { synced, fresh } = await editAndSync(csFiles, ['**/*.cs'], 'Factory.cs', edited, 'Create');
+    expect(synced).toEqual(fresh);
+  });
+});
+
 describe('Scoped sync parity (#watcher-scoped)', () => {
   let testDir: string;
   let cg: CodeGraph;
diff --git a/__tests__/telemetry-services.test.ts b/__tests__/telemetry-services.test.ts
new file mode 100644
index 0000000000..657681cc78
--- /dev/null
+++ b/__tests__/telemetry-services.test.ts
@@ -0,0 +1,438 @@
+/**
+ * The self-hosted telemetry services — `telemetry-worker/` (ingest + nightly rollup)
+ * and `telemetry-dashboard/` (the read API) — run against the checked-in D1
+ * migrations in an in-memory node:sqlite database (#2333).
+ *
+ * D1 is SQLite, so every statement here is the SQL production runs. The one stand-in
+ * is a thin adapter giving node:sqlite D1's prepare/bind/first/all/run/batch shape,
+ * with `batch()` as one transaction the way D1 runs it. No wrangler, no workerd, no
+ * network: the end-to-end versions of these checks are the packages' own smoke
+ * suites (`npm run smoke`, `smoke:rollup`, `smoke:cutover`, `smoke:api`), which boot
+ * `wrangler dev`.
+ *
+ *   npx vitest run __tests__/telemetry-services.test.ts
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import worker from '../telemetry-worker/src/index';
+import { runNightly } from '../telemetry-worker/src/rollup';
+import { handleApi } from '../telemetry-dashboard/src/api';
+
+let nodeSqlite: typeof import('node:sqlite') | null = null;
+try {
+  nodeSqlite = require('node:sqlite') as typeof import('node:sqlite');
+} catch {
+  /* Node < 22.5 — skipped below */
+}
+
+const MIGRATIONS = path.join(__dirname, '..', 'telemetry-worker', 'migrations');
+const MINUTE = 60_000;
+/** Cloudflare ends a Cron Trigger invocation after 15 minutes of wall-clock time. */
+const CRON_LIMIT_MS = 15 * MINUTE;
+
+type Row = Record<string, unknown>;
+
+// ---------------------------------------------------------------------------
+// D1 over node:sqlite
+// ---------------------------------------------------------------------------
+
+/** Binds integral numbers as INTEGER, as D1 does (node:sqlite would bind them as REAL). */
+const bindable = (v: unknown): unknown => (typeof v === 'number' && Number.isInteger(v) ? BigInt(v) : v);
+
+class SqliteD1Statement {
+  constructor(
+    private readonly d1: SqliteD1,
+    readonly sql: string,
+    private readonly params: unknown[] = [],
+  ) {}
+
+  bind(...params: unknown[]): SqliteD1Statement {
+    return new SqliteD1Statement(this.d1, this.sql, params);
+  }
+
+  execute(): { success: true; results: Row[]; meta: { changes: number } } {
+    this.d1.onStatement?.(this.sql);
+    const stmt = this.d1.db.prepare(this.sql);
+    const params = this.params.map(bindable) as never[];
+    if (/^\s*(SELECT|WITH)\b/i.test(this.sql)) {
+      return { success: true, results: stmt.all(...params) as Row[], meta: { changes: 0 } };
+    }
+    const info = stmt.run(...params);
+    return { success: true, results: [], meta: { changes: Number(info.changes) } };
+  }
+
+  async first<T>(): Promise<T | null> {
+    return (this.execute().results[0] as T | undefined) ?? null;
+  }
+
+  async all(): Promise<ReturnType<SqliteD1Statement['execute']>> {
+    return this.execute();
+  }
+
+  async run(): Promise<ReturnType<SqliteD1Statement['execute']>> {
+    return this.execute();
+  }
+}
+
+class SqliteD1 {
+  /** Runs before every statement — the cron tests use it to model elapsed wall-clock time. */
+  onStatement: ((sql: string) => void) | null = null;
+
+  constructor(readonly db: import('node:sqlite').DatabaseSync) {}
+
+  prepare(sql: string): SqliteD1Statement {
+    return new SqliteD1Statement(this, sql);
+  }
+
+  async batch(statements: SqliteD1Statement[]): Promise<ReturnType<SqliteD1Statement['execute']>[]> {
+    this.db.exec('BEGIN');
+    try {
+      const results = statements.map((s) => s.execute());
+      this.db.exec('COMMIT');
+      return results;
+    } catch (err) {
+      this.db.exec('ROLLBACK');
+      throw err;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Harness
+// ---------------------------------------------------------------------------
+
+describe.skipIf(!nodeSqlite)('telemetry services against the D1 schema (#2333)', () => {
+  let db: import('node:sqlite').DatabaseSync;
+  let d1: SqliteD1;
+  let env: never;
+  let logged: Row[];
+
+  const at = (iso: string): void => {
+    vi.setSystemTime(new Date(iso));
+  };
+
+  const one = (sql: string, ...params: unknown[]): Row | undefined =>
+    db.prepare(sql).get(...(params.map(bindable) as never[])) as Row | undefined;
+
+  /** POST /v1/events the way a client does, then wait for the off-response-path write. */
+  async function post(machineId: string, events: Row[]): Promise<number> {
+    const body = JSON.stringify({
+      machine_id: machineId,
+      codegraph_version: '1.6.2',
+      os: 'linux',
+      arch: 'x64',
+      node_major: 22,
+      ci: false,
+      schema_version: 2,
+      events,
+    });
+    const pending: Promise<unknown>[] = [];
+    const request = new Request('https://telemetry.test/v1/events', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'content-length': String(Buffer.byteLength(body)) },
+      body,
+    });
+    const ctx = { waitUntil: (p: Promise<unknown>) => void pending.push(p), passThroughOnException: () => {} };
+    const response = await worker.fetch(request as never, env, ctx as never);
+    await Promise.all(pending);
+    return response.status;
+  }
+
+  /** GET one dashboard endpoint, as the signed-in page does. */
+  async function api(pathAndQuery: string): Promise<Row> {
+    const result = await handleApi(env, new URL(`https://stats.test${pathAndQuery}`));
+    expect(result.status ?? 200).toBe(200);
+    return result.body as Row;
+  }
+
+  /**
+   * One cron invocation at `iso`. `chunkMs` is the wall-clock time each legacy-usage
+   * fold chunk is charged; a statement that starts after Cloudflare's 15-minute limit
+   * throws, the way the runtime ends the invocation there.
+   */
+  async function nightly(iso: string, chunkMs = 0): Promise<{ latestStartMs: number; summary: Row | undefined }> {
+    at(iso);
+    const started = Date.now();
+    let latestStartMs = 0;
+    d1.onStatement = (sql) => {
+      const elapsed = Date.now() - started;
+      if (elapsed > CRON_LIMIT_MS) {
+        throw new Error(`statement started ${elapsed / MINUTE} min into the cron run — past the 15-minute limit`);
+      }
+      latestStartMs = Math.max(latestStartMs, elapsed);
+      if (/INSERT INTO usage_daily/.test(sql) && /FROM events/.test(sql)) vi.setSystemTime(Date.now() + chunkMs);
+    };
+    const before = logged.length;
+    try {
+      await runNightly(env, Date.parse(iso));
+    } finally {
+      d1.onStatement = null;
+    }
+    const summary = logged.slice(before).find((line) => line.msg === 'nightly rollup');
+    return { latestStartMs, summary };
+  }
+
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] });
+    db = new nodeSqlite!.DatabaseSync(':memory:');
+    for (const file of fs.readdirSync(MIGRATIONS).filter((f) => f.endsWith('.sql')).sort()) {
+      db.exec(fs.readFileSync(path.join(MIGRATIONS, file), 'utf8'));
+    }
+    d1 = new SqliteD1(db);
+    env = {
+      DB: d1,
+      RETENTION_DAYS: 90,
+      MACHINE_RATE_LIMITER: { limit: async () => ({ success: true }) },
+      ADMIN_RATE_LIMITER: { limit: async () => ({ success: true }) },
+    } as never;
+    logged = [];
+    const capture = (line: unknown): void => {
+      try {
+        logged.push(JSON.parse(String(line)) as Row);
+      } catch {
+        /* not one of the worker's JSON lines */
+      }
+    };
+    vi.spyOn(console, 'log').mockImplementation(capture);
+    vi.spyOn(console, 'error').mockImplementation(capture);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+    db.close();
+  });
+
+  const M1 = '00000000-0000-4000-8000-000000000001';
+  const M2 = '00000000-0000-4000-8000-000000000002';
+  const M3 = '00000000-0000-4000-8000-000000000003';
+  const install = (ts: string): Row => ({ event: 'install', ts, props: { scope: 'local', kind: 'fresh' } });
+  const index = (ts: string): Row => ({ event: 'index', ts, props: { languages: ['typescript'] } });
+  const usage = (day: string, count: number): Row => ({
+    event: 'usage_rollup',
+    ts: `${day}T12:00:00.000Z`,
+    props: { kind: 'mcp_tool', name: 'codegraph_explore', count, client_name: 'Claude Code' },
+  });
+
+  // -------------------------------------------------------------------------
+  // 1. Activation counts an index run that uploads late
+  // -------------------------------------------------------------------------
+
+  describe('a late index upload', () => {
+    it('counts toward activation even when it arrives after the nightly run stopped revisiting its day', async () => {
+      // Sep 25: the machine installs. Its index run fails to upload and stays in the
+      // client's queue, keeping its original timestamp.
+      at('2026-09-25T15:00:00Z');
+      expect(await post(M1, [install('2026-09-25T14:00:00Z')])).toBe(204);
+      await nightly('2026-09-26T00:30:00Z');
+
+      // Oct 3: the queued index run finally goes out — eight days late, inside the
+      // 30 days ingest accepts, but long past the three days each nightly run re-rolls.
+      at('2026-10-03T10:00:00Z');
+      expect(await post(M1, [index('2026-09-25T14:05:00Z')])).toBe(204);
+      // Someone else's activity, so the rollup's coverage moves past the cohort's window.
+      expect(await post(M2, [install('2026-10-03T09:00:00Z')])).toBe(204);
+      await nightly('2026-10-04T00:30:00Z');
+
+      at('2026-10-04T08:00:00Z');
+      const funnel = await api('/api/activation?from=2026-09-25&to=2026-09-25&window=7');
+      expect(funnel).toMatchObject({ installs: 1, activated: 1, dropped: 0, covered_through: '2026-10-03' });
+      expect(one('SELECT first_day, first_index_day FROM machine_first_seen WHERE machine_id = ?', M1)).toEqual({
+        first_day: '2026-09-25',
+        first_index_day: '2026-09-25',
+      });
+    });
+
+    it('is applied as it is stored, and only ever moves the first index day earlier', async () => {
+      const firstSeen = (machineId: string): Row | undefined =>
+        one('SELECT first_day, first_index_day FROM machine_first_seen WHERE machine_id = ?', machineId);
+
+      at('2026-10-03T10:00:00Z');
+      // A batch without an index run says nothing about indexing.
+      expect(await post(M1, [install('2026-10-02T10:00:00Z')])).toBe(204);
+      expect(await post(M1, [usage('2026-10-01', 4)])).toBe(204);
+      expect(firstSeen(M1)).toEqual({ first_day: '2026-10-01', first_index_day: null });
+
+      // The earliest index run in a batch wins, with no rollup involved.
+      expect(await post(M1, [index('2026-10-03T09:00:00Z'), index('2026-10-02T11:00:00Z')])).toBe(204);
+      expect(firstSeen(M1)).toEqual({ first_day: '2026-10-01', first_index_day: '2026-10-02' });
+
+      // A later index run leaves it alone; a backdated one lowers it, and first_day with it.
+      expect(await post(M1, [index('2026-10-03T09:30:00Z')])).toBe(204);
+      expect(firstSeen(M1)).toEqual({ first_day: '2026-10-01', first_index_day: '2026-10-02' });
+      expect(await post(M1, [index('2026-09-20T08:00:00Z')])).toBe(204);
+      expect(firstSeen(M1)).toEqual({ first_day: '2026-09-20', first_index_day: '2026-09-20' });
+
+      // A machine whose very first batch carries an index run.
+      expect(await post(M2, [install('2026-10-03T08:00:00Z'), index('2026-10-03T08:01:00Z')])).toBe(204);
+      expect(firstSeen(M2)).toEqual({ first_day: '2026-10-03', first_index_day: '2026-10-03' });
+
+      // The nightly rollup agrees with what ingest already wrote.
+      await nightly('2026-10-04T00:30:00Z');
+      expect(firstSeen(M1)).toEqual({ first_day: '2026-09-20', first_index_day: '2026-09-20' });
+      expect(firstSeen(M2)).toEqual({ first_day: '2026-10-03', first_index_day: '2026-10-03' });
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 2. Usage-only days are not a stalled ingest
+  // -------------------------------------------------------------------------
+
+  describe('the stalled-ingest flag', () => {
+    it('counts usage counters as ingest that is still storing', async () => {
+      // The last lifecycle event is Sep 25; after that only usage counters arrive.
+      at('2026-09-25T15:00:00Z');
+      expect(await post(M1, [install('2026-09-25T14:00:00Z')])).toBe(204);
+      // Clients upload a day's counters only once it is over: Oct 3's arrive on Oct 4.
+      at('2026-10-04T06:00:00Z');
+      expect(await post(M2, [usage('2026-10-03', 12)])).toBe(204);
+
+      at('2026-10-04T08:00:00Z');
+      const meta = await api('/api/meta');
+      expect(meta).toMatchObject({ latest_raw_day: '2026-09-25', latest_ingest_day: '2026-10-03', ingest_stalled: false });
+
+      // Just past midnight nobody has sent Oct 4's counters yet; that is not a stall.
+      at('2026-10-05T00:10:00Z');
+      expect(await api('/api/meta')).toMatchObject({ ingest_stalled: false });
+
+      // A whole day later with nothing stored at all, it is — and the banner date is
+      // the last day anything was stored, not the last lifecycle event.
+      at('2026-10-06T08:00:00Z');
+      expect(await api('/api/meta')).toMatchObject({ latest_ingest_day: '2026-10-03', ingest_stalled: true });
+    });
+
+    it('still reports a stall when nothing at all has arrived, and not on an empty database', async () => {
+      at('2026-10-04T08:00:00Z');
+      expect(await api('/api/meta')).toMatchObject({ latest_ingest_day: null, ingest_stalled: false });
+
+      at('2026-09-25T15:00:00Z');
+      expect(await post(M1, [install('2026-09-25T14:00:00Z')])).toBe(204);
+      at('2026-10-04T08:00:00Z');
+      expect(await api('/api/meta')).toMatchObject({ latest_ingest_day: '2026-09-25', ingest_stalled: true });
+
+      // A lifecycle event from yesterday is fresh, as before.
+      expect(await post(M1, [index('2026-10-03T22:00:00Z')])).toBe(204);
+      expect(await api('/api/meta')).toMatchObject({ latest_ingest_day: '2026-10-03', ingest_stalled: false });
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 3. A long catch-up stays inside the cron's wall-clock limit, and the purge runs
+  // -------------------------------------------------------------------------
+
+  describe('the nightly run under a catch-up backlog', () => {
+    /** The rollup folds legacy usage rows 50,000 per transaction (rollup.ts, LEGACY_CHUNK_ROWS). */
+    const CHUNK_ROWS = 50_000;
+    /**
+     * Each fold chunk is charged 4 minutes, so a backlog of legacy-heavy days costs
+     * several minutes apiece, as it did in production. The six missed days below hold
+     * seven chunks: 28 minutes of folding, against a 15-minute limit.
+     */
+    const CHUNK_MS = 4 * MINUTE;
+    const NIGHT_1 = '2026-10-05T00:30:00Z';
+    /** Missed days, newest first — the order catch-up takes them in. Sep 21 needs two chunks. */
+    const MISSED = ['2026-09-23', '2026-09-22', '2026-09-21', '2026-09-20', '2026-09-19', '2026-09-18'];
+    const LEGACY_ROWS: Record<string, number> = Object.fromEntries(
+      MISSED.map((day) => [day, day === '2026-09-21' ? CHUNK_ROWS + 3 : 3]),
+    );
+    const PAST_WINDOW = '2026-06-01';
+
+    /** Legacy rows as they were stored before migrations/0003: one `events` row per upload, count 1. */
+    function seedLegacyDay(day: string, rows: number): void {
+      db.prepare(
+        `WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i + 1 FROM n WHERE i < ?1)
+         INSERT INTO events (received_at, ts, day, event, machine_id, codegraph_version, os, arch,
+                             node_major, ci, schema_version, props)
+         SELECT ?2 || 'T13:00:00.000Z', ?2 || 'T12:00:00.000Z', ?2, 'usage_rollup',
+                '00000000-0000-4000-8000-00000000010' || ((i - 1) % 5), '1.5.0', 'linux', 'x64', 22, 0, 1,
+                '{"kind":"mcp_tool","name":"codegraph_explore","count":1,"error_count":0,"client_name":"Claude Code"}'
+           FROM n`,
+      ).run(BigInt(rows), day);
+      for (let m = 0; m < Math.min(rows, 5); m++) {
+        const machine = `00000000-0000-4000-8000-00000000010${m}`;
+        db.prepare('INSERT INTO machine_days (machine_id, day, prod) VALUES (?, ?, 1)').run(machine, day);
+        db.prepare(
+          `INSERT INTO machine_first_seen (machine_id, first_day) VALUES (?, ?)
+             ON CONFLICT (machine_id) DO UPDATE SET first_day = min(first_day, excluded.first_day)`,
+        ).run(machine, day);
+      }
+    }
+
+    /** Where each seeded usage count sits right now, and whether the day has been rolled up. */
+    function ledger(day: string) {
+      const folded = Number(one('SELECT coalesce(sum(count), 0) AS n FROM usage_daily WHERE day = ?', day)?.n);
+      const unfolded = Number(
+        one(
+          `SELECT coalesce(sum(json_extract(props, '$.count')), 0) AS n FROM events
+            WHERE day = ? AND event = 'usage_rollup'`,
+          day,
+        )?.n,
+      );
+      const rolledUsage = one(`SELECT count FROM daily_event_counts WHERE day = ? AND event = 'usage_rollup'`, day);
+      const rolledUp = one('SELECT machines FROM daily_machines WHERE day = ?', day) !== undefined;
+      return { folded, unfolded, rolledUsage: rolledUsage ? Number(rolledUsage.count) : null, rolledUp };
+    }
+
+    function expectConsistent(): void {
+      for (const day of MISSED) {
+        const l = ledger(day);
+        // Nothing lost and nothing counted twice, however far the fold got.
+        expect(l.folded + l.unfolded, day).toBe(LEGACY_ROWS[day]);
+        if (l.rolledUp) {
+          expect(l, day).toMatchObject({ unfolded: 0, rolledUsage: LEGACY_ROWS[day] });
+        } else {
+          // A day whose fold did not finish gets no rollup at all, so it stays "missed".
+          expect(l.rolledUsage, day).toBeNull();
+        }
+      }
+    }
+
+    beforeEach(() => {
+      for (const day of MISSED) seedLegacyDay(day, LEGACY_ROWS[day]!);
+      // Past the 90-day window: the purge must take these.
+      db.prepare(
+        `INSERT INTO events (received_at, ts, day, event, machine_id, props)
+         VALUES ('2026-06-01T10:00:00.000Z', NULL, ?1, 'install', ?2, '{}')`,
+      ).run(PAST_WINDOW, M3);
+      db.prepare(
+        `INSERT INTO usage_daily (day, machine_id, kind, name, count) VALUES (?, ?, 'cli_command', 'index', 2)`,
+      ).run(PAST_WINDOW, M3);
+    });
+
+    it('purges on schedule, stops before the limit, and resumes the backlog the next nights', async () => {
+      // The three days the run re-rolls every night have ordinary, current traffic.
+      at('2026-10-04T12:00:00Z');
+      expect(await post(M1, [install('2026-10-04T11:00:00Z'), usage('2026-10-03', 5)])).toBe(204);
+      expect(await post(M2, [index('2026-10-02T11:00:00Z')])).toBe(204);
+
+      const first = await nightly(NIGHT_1, CHUNK_MS);
+      expect(first.latestStartMs).toBeLessThanOrEqual(CRON_LIMIT_MS);
+      // The purge ran, and the summary line was written.
+      expect(one('SELECT count(*) AS n FROM events WHERE day < ?', '2026-07-07')?.n).toBe(0);
+      expect(one('SELECT count(*) AS n FROM usage_daily WHERE day < ?', '2026-07-07')?.n).toBe(0);
+      expect(first.summary).toMatchObject({ purged: 1, usage_purged: 1, failed: 0 });
+      // Tonight's regular days were rolled up first.
+      for (const day of ['2026-10-04', '2026-10-03', '2026-10-02']) {
+        expect(one('SELECT machines FROM daily_machines WHERE day = ?', day), day).toEqual({ machines: 1 });
+      }
+      // The backlog did not fit: Sep 21 was left part-folded and un-rolled, the rest untouched.
+      expect(ledger('2026-09-21')).toMatchObject({ folded: CHUNK_ROWS, unfolded: 3, rolledUp: false });
+      expect(MISSED.filter((day) => !ledger(day).rolledUp)).toEqual(MISSED.slice(2));
+      expect(first.summary).toMatchObject({ caught_up: 2, deferred: 4 });
+      expectConsistent();
+
+      // The next nights pick up exactly where this one stopped.
+      let nights = 1;
+      for (let day = 6; MISSED.some((d) => !ledger(d).rolledUp) && nights < 5; day++, nights++) {
+        const night = await nightly(`2026-10-0${day}T00:30:00Z`, CHUNK_MS);
+        expect(night.latestStartMs).toBeLessThanOrEqual(CRON_LIMIT_MS);
+        expect(night.summary).toMatchObject({ failed: 0 });
+        expectConsistent();
+      }
+      expect(nights).toBe(3);
+      for (const day of MISSED) expect(ledger(day), day).toMatchObject({ unfolded: 0, rolledUp: true });
+    });
+  });
+});
diff --git a/__tests__/telemetry.test.ts b/__tests__/telemetry.test.ts
index e73f7eae42..f6b1491619 100644
--- a/__tests__/telemetry.test.ts
+++ b/__tests__/telemetry.test.ts
@@ -186,6 +186,40 @@ describe('Telemetry', () => {
       expect(fs.readFileSync(t.queuePath, 'utf8')).toContain('"status"');
     });
 
+    // Each codegraph process aggregates in memory and appends on exit. The server
+    // wants ONE counter per machine × day × tool, so lines for the same counter from
+    // different processes must merge — not pile up one `count: 1` line per process.
+    it('merges the same counter across processes into one queued line', async () => {
+      const client = { name: 'Claude Code', version: '2.1' };
+      for (let process = 0; process < 3; process++) {
+        const t = make();
+        t.recordUsage('mcp_tool', 'codegraph_explore', process !== 1, client);
+        t.recordUsage('cli_command', 'serve', true);
+        t.persistSync();
+      }
+      const queued = fs.readFileSync(make().queuePath, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+      expect(queued).toHaveLength(2);
+      expect(queued.find((l) => l.n === 'codegraph_explore')).toMatchObject({ c: 3, e: 1, cn: 'Claude Code' });
+      expect(queued.find((l) => l.n === 'serve')).toMatchObject({ c: 3, e: 0 });
+
+      nowValue = new Date('2026-06-13T08:00:00.000Z');
+      await make().flushNow();
+      const events = calls[0]!.body.events as Array<{ props: Record<string, unknown> }>;
+      expect(events).toHaveLength(2);
+      expect(events.find((e) => e.props.name === 'serve')!.props).toMatchObject({ count: 3, error_count: 0 });
+    });
+
+    it('a queue left by an older version still sends one event per counter', async () => {
+      const t = make();
+      fs.mkdirSync(dir, { recursive: true });
+      const line = JSON.stringify({ v: 2, d: '2026-06-11', k: 'cli_command', n: 'serve', c: 1, e: 0 });
+      fs.writeFileSync(t.queuePath, `${line}\n${line}\n${line}\n`);
+      await t.flushNow();
+      const events = calls[0]!.body.events as Array<{ props: Record<string, unknown> }>;
+      expect(events).toHaveLength(1);
+      expect(events[0]!.props).toMatchObject({ name: 'serve', count: 3 });
+    });
+
     it('lifecycle events send on the next flush regardless of day', async () => {
       const t = make();
       t.recordLifecycle('install', { targets: ['claude'], scope: 'local', kind: 'fresh' });
@@ -274,6 +308,21 @@ describe('Telemetry', () => {
       expect(calls).toHaveLength(1);
       expect((calls[0]!.body.events as Array<{ event: string }>)[0]!.event).toBe('uninstall');
     });
+
+    it('merges a recovered claim into the queue instead of appending beside it', async () => {
+      const t = make();
+      t.setEnabled(true, 'cli');
+      const line = JSON.stringify({ v: 2, d: '2026-06-11', k: 'cli_command', n: 'serve', c: 2, e: 0 });
+      fs.writeFileSync(t.queuePath, `${line}\n`);
+      const stale = path.join(dir, 'telemetry-queue.sending.99998.jsonl');
+      fs.writeFileSync(stale, `${line}\n${line}\n`);
+      const old = new Date(nowValue.getTime() - 2 * 60 * 60_000);
+      fs.utimesSync(stale, old, old);
+      await t.flushNow();
+      const events = calls[0]!.body.events as Array<{ props: Record<string, unknown> }>;
+      expect(events).toHaveLength(1);
+      expect(events[0]!.props).toMatchObject({ name: 'serve', count: 6 });
+    });
   });
 
   describe('protocol safety', () => {
diff --git a/__tests__/test-double-unique-guess.test.ts b/__tests__/test-double-unique-guess.test.ts
new file mode 100644
index 0000000000..6cb384b03b
--- /dev/null
+++ b/__tests__/test-double-unique-guess.test.ts
@@ -0,0 +1,63 @@
+/**
+ * A receiver's method guessed from its name alone is never a test double's
+ * the calling file never names: django-allauth's `resp.json()` on a Django
+ * test-client response went to its `MockedResponse.json` 193 times, as the
+ * one `json` method in the project. A test that names the double keeps it.
+ */
+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-test-double-'));
+  const files: Record<string, string> = {
+    'tests/mocking.py': `class MockedResponse:
+    def __init__(self, data):
+        self.data = data
+
+    def json(self):
+        return self.data
+`,
+    'tests/test_api.py': `def test_profile(client):
+    resp = client.get("/profile")
+    assert resp.json()["ok"]
+`,
+    'tests/test_mocking.py': `from tests.mocking import MockedResponse
+
+
+def test_mocked():
+    resp = MockedResponse({"ok": True})
+    assert resp.json()["ok"]
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const callsTo = (file: string, name: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'calls' && cg.getNode(e.target)!.name === name).length;
+};
+
+describe('test doubles as guessed receivers', () => {
+  it('are not what an unrelated `resp.json()` calls', () => {
+    expect(callsTo('tests/test_api.py', 'json')).toBe(0);
+  });
+
+  it('are what a test that names them calls', () => {
+    expect(callsTo('tests/test_mocking.py', 'json')).toBe(1);
+  });
+});
diff --git a/__tests__/test-home-sandbox.test.ts b/__tests__/test-home-sandbox.test.ts
new file mode 100644
index 0000000000..f5ebb7a718
--- /dev/null
+++ b/__tests__/test-home-sandbox.test.ts
@@ -0,0 +1,65 @@
+/**
+ * The suite's home-dir sandbox (`setup-home-sandbox.ts`, #2275) is in force:
+ * nothing a test runs — in-process or spawned — resolves the developer's real
+ * home, Claude profile, daemon registry or git identity.
+ */
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { claudeTarget } from '../src/installer/targets/claude';
+import { getRegistryDir } from '../src/mcp/daemon-registry';
+
+const tmpRoot = fs.realpathSync(os.tmpdir());
+const under = (p: string, dir: string): boolean => path.resolve(p).startsWith(dir + path.sep);
+/** The sandbox home — asserted to be one, so the checks below can't pass on a real home. */
+function sandboxHome(): string {
+  const home = os.homedir();
+  expect(under(home, tmpRoot), home).toBe(true);
+  return home;
+}
+
+describe('test home sandbox', () => {
+  it('os.homedir() is a throwaway dir under the temp root, not the real home', () => {
+    const home = sandboxHome();
+    expect(path.basename(home)).toMatch(/^codegraph-test-home-/);
+    // The account's profile dir, which ignores HOME / USERPROFILE.
+    expect(home).not.toBe(os.userInfo().homedir);
+  });
+
+  it('the global Claude profile and the daemon registry resolve inside it', () => {
+    const home = sandboxHome();
+    expect(process.env.CLAUDE_CONFIG_DIR).toBeUndefined();
+    expect(under(claudeTarget.detect('global').configPath, home)).toBe(true);
+    expect(under(getRegistryDir(), home)).toBe(true);
+  });
+
+  it('a spawned child sees the same home', () => {
+    const childHome = execFileSync(process.execPath, ['-p', 'require("os").homedir()'], {
+      encoding: 'utf-8',
+      windowsHide: true,
+    }).trim();
+    expect(childHome).toBe(sandboxHome());
+  });
+
+  it("git's global config is the seeded sandbox file", () => {
+    const gitConfig = process.env.GIT_CONFIG_GLOBAL ?? '';
+    expect(under(gitConfig, sandboxHome())).toBe(true);
+    const name = execFileSync('git', ['config', '--global', '--get', 'user.name'], {
+      encoding: 'utf-8',
+      windowsHide: true,
+    }).trim();
+    expect(name).toBe('CodeGraph Test');
+  });
+
+  // os.homedir() reads USERPROFILE there, and git falls back to
+  // HOMEDRIVE+HOMEPATH — a HOME-only sandbox would not hold.
+  it.runIf(process.platform === 'win32')('covers the Windows home variables', () => {
+    const home = sandboxHome();
+    expect(process.env.USERPROFILE).toBe(home);
+    expect(`${process.env.HOMEDRIVE}${process.env.HOMEPATH}`).toBe(home);
+    expect(under(process.env.APPDATA ?? '', home)).toBe(true);
+    expect(under(process.env.LOCALAPPDATA ?? '', home)).toBe(true);
+  });
+});
diff --git a/__tests__/ts-ambient-exports.test.ts b/__tests__/ts-ambient-exports.test.ts
new file mode 100644
index 0000000000..a77a2f4d8e
--- /dev/null
+++ b/__tests__/ts-ambient-exports.test.ts
@@ -0,0 +1,208 @@
+/**
+ * A declaration inside `declare module 'x' { … }` or `declare global { … }` is
+ * exported, though nothing in it writes `export`:
+ *
+ *   declare module 'chart.js' {            // ghostfolio's chart.registry.ts
+ *     interface PluginOptionsByType<TType extends ChartType> { … }
+ *   }
+ *   declare global {                       // angular-realworld's app.config.ts
+ *     interface Window { __conduit_debug__?: ConduitDebug; }
+ *   }
+ *
+ * Both indexed as unexported file-level interfaces, so the dead-code report
+ * listed them: nothing in the repository names them, because chart.js and the
+ * browser read them through the type they merge into. TypeScript's binder
+ * makes an ambient module body an export context, and a namespace nested in
+ * one is ambient too, unless the body holds an export declaration of its own
+ * (`export {}`, `export =`, `export default x`). Both extractors now say what
+ * the compiler says. `declare namespace X` is unchanged: in a module file it
+ * is that file's own namespace and merges with nothing outside. Runs against
+ * the native kernel (when built) and the wasm extractor, which must agree.
+ */
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult, Language } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelAvailable = fs.existsSync(KERNEL_PATH) || process.env.CODEGRAPH_KERNEL_EXPECT === '1';
+
+/** A module file: augmentations, a global block, and the namespaces that are neither. */
+const MODULE_SOURCE = `import type { ChartType } from 'chart.js';
+
+declare module 'chart.js' {
+  interface PluginOptionsByType<TType extends ChartType> {
+    verticalHoverLine: TType;
+  }
+  export interface WrittenOut {}
+  namespace Plugins {
+    interface Nested {}
+  }
+  type Alias = string;
+  enum Position { Top }
+  class Positioner {}
+  const defaults: Alias;
+}
+
+declare global {
+  interface Window {
+    __conduit_debug__?: unknown;
+  }
+  namespace NodeJS {
+    interface ProcessEnv {
+      API_URL?: string;
+    }
+  }
+  var bitwardenContainerService: unknown;
+}
+
+declare namespace Settings {
+  interface OwnNamespace {}
+}
+
+namespace Plain {
+  interface Hidden {}
+  export interface Shown {}
+}
+
+interface FileLocal {}
+
+export const appConfig = {};
+`;
+
+/**
+ * A script file declaring a module whole, the way an untyped library's typings
+ * do. \`export =\` is an export declaration, so the body exports only that.
+ */
+const SCRIPT_SOURCE = `declare module 'legacy-lib' {
+  interface Options {}
+  const main: (options: Options) => void;
+  export = main;
+}
+
+declare module 'listed-lib' {
+  interface Unlisted {}
+  export interface Listed {}
+  export { Unlisted as Renamed };
+}
+
+declare module 'open-lib' {
+  interface Open {}
+}
+`;
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+
+/** Kinds a statement declares — the nodes that carry an export flag of their own. */
+const DECLARATION_KINDS = new Set(['interface', 'class', 'enum', 'type_alias', 'function', 'variable', 'constant', 'component']);
+
+/** `name` → isExported, for every declaration. */
+function exportFlags(result: ExtractionResult): Record<string, boolean> {
+  const flags: Record<string, boolean> = {};
+  for (const node of result.nodes) {
+    if (DECLARATION_KINDS.has(node.kind)) flags[node.name] = node.isExported === true;
+  }
+  return flags;
+}
+
+describe('TypeScript ambient module bodies export what they declare', () => {
+  let savedEnv: Record<string, string | undefined> = {};
+
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['typescript', 'tsx']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function extract(backend: 'kernel' | 'wasm', file: string, source: string, language: Language): ExtractionResult {
+    if (backend === 'wasm') {
+      process.env.CODEGRAPH_KERNEL = '0';
+      return extractFromSource(file, source, language);
+    }
+    delete process.env.CODEGRAPH_KERNEL;
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    const result = tryKernelExtract(file, source, language);
+    expect(result, `kernel extraction of ${file}`).not.toBeNull();
+    return result!;
+  }
+
+  const backends = kernelAvailable ? (['kernel', 'wasm'] as const) : (['wasm'] as const);
+
+  for (const crlf of [false, true]) {
+    const eol = (s: string) => (crlf ? s.replace(/\n/g, '\r\n') : s);
+    const label = crlf ? ' (CRLF)' : '';
+
+    it.each(backends)(`declare module and declare global export their declarations: %s${label}`, (backend) => {
+      const result = extract(backend, 'src/chart.registry.ts', eol(MODULE_SOURCE), 'typescript');
+      expect(exportFlags(result)).toEqual({
+        // declare module 'chart.js', and a namespace nested in it.
+        PluginOptionsByType: true,
+        WrittenOut: true,
+        Nested: true,
+        Alias: true,
+        Position: true,
+        Positioner: true,
+        defaults: true,
+        // declare global, and a namespace nested in it.
+        Window: true,
+        ProcessEnv: true,
+        bitwardenContainerService: true,
+        // Neither is an outside scope: a module file's own namespaces.
+        OwnNamespace: false,
+        Hidden: false,
+        Shown: true,
+        FileLocal: false,
+        appConfig: true,
+      });
+    });
+
+    it.each(backends)(`a body with an export declaration exports only what it names: %s${label}`, (backend) => {
+      const result = extract(backend, 'types/legacy.ts', eol(SCRIPT_SOURCE), 'typescript');
+      expect(exportFlags(result)).toEqual({
+        Options: false,
+        main: false,
+        Unlisted: false,
+        Listed: true,
+        Open: true,
+      });
+    });
+
+    it.each(backends)(`tsx reads the same blocks: %s${label}`, (backend) => {
+      const source = eol(`declare module '@tanstack/react-router' {\n  interface Register {\n    router: unknown;\n  }\n}\nexport const App = () => <main />;\n`);
+      const result = extract(backend, 'src/main.tsx', source, 'tsx');
+      expect(exportFlags(result).Register).toBe(true);
+    });
+  }
+
+  it.runIf(kernelAvailable)('the kernel and the wasm extractor agree on every node', () => {
+    for (const [file, source] of [['src/chart.registry.ts', MODULE_SOURCE], ['types/legacy.ts', SCRIPT_SOURCE]] as const) {
+      const canon = (r: ExtractionResult) =>
+        r.nodes.map(({ updatedAt: _u, ...n }) => JSON.stringify(n, Object.keys(n).sort())).sort();
+      expect(canon(extract('kernel', file, source, 'typescript'))).toEqual(
+        canon(extract('wasm', file, source, 'typescript'))
+      );
+    }
+  });
+});
diff --git a/__tests__/ts-this-field-call.test.ts b/__tests__/ts-this-field-call.test.ts
index 4a194fb8c1..e8fd233e83 100644
--- a/__tests__/ts-this-field-call.test.ts
+++ b/__tests__/ts-this-field-call.test.ts
@@ -114,9 +114,10 @@ describe('this.<field>.<method>() (#1496)', () => {
   });
 
   it('resolves a field typed `typeof <objectLiteral>` onto the literal\'s member', () => {
-    // The members are bare-named functions inside the constant's extent (#1573).
-    expect(calleesOf('Keeper::settings')).toEqual(['getSettings']);
-    expect(calleesOf('Keeper::get')).toEqual(['get']);
+    // The members are functions inside the constant's extent (#1573), qualified
+    // under it (#2300).
+    expect(calleesOf('Keeper::settings')).toEqual(['DraftHubStorage::getSettings']);
+    expect(calleesOf('Keeper::get')).toEqual(['DraftHubStorage::get']);
     const self = cg.getCallers(method('Keeper::get').id).some(({ node }) => node.id === method('Keeper::get').id);
     expect(self).toBe(false);
   });
diff --git a/__tests__/type-parameter-refs.test.ts b/__tests__/type-parameter-refs.test.ts
new file mode 100644
index 0000000000..0cbea64392
--- /dev/null
+++ b/__tests__/type-parameter-refs.test.ts
@@ -0,0 +1,180 @@
+/**
+ * A type parameter is not a project symbol that shares its name.
+ *
+ * cats' `def zipWith[A, B, C](fa: ISeq[A], …)` sent `A` to an `implicit def A`
+ * (4,916 dependents) and `B` to a `case class B()` declared inside a test;
+ * getx's `T` landed on a constant named `T`. A type declared inside a function
+ * is only in scope in there.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+const roots: string[] = [];
+afterAll(() => {
+  for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+});
+
+async function project(files: Record<string, string>): Promise<CodeGraph> {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-type-params-'));
+  roots.push(root);
+  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);
+  }
+  return CodeGraph.init(root, { index: true });
+}
+
+function typeTargets(cg: CodeGraph, name: string): string[] {
+  const from = cg.getNodesByName(name).filter((n) => n.kind === 'function' || n.kind === 'method');
+  return cg
+    .getOutgoingEdgesFrom(from.map((n) => n.id), ['references', 'type_of', 'returns', 'instantiates'])
+    .map((e) => cg.getNode(e.target))
+    .map((n) => `${n!.kind}:${n!.name}`)
+    .sort();
+}
+
+describe('type parameters', () => {
+  it('Scala: a def’s type parameters, and a case class local to another test', async () => {
+    const cg = await project({
+      'src/Inst.scala': `package app
+object Inst {
+  implicit def A: Int = 1
+}
+`,
+      'src/Seqs.scala': `package app
+object Seqs {
+  def zipWith[A, B, C](fa: List[A], fb: List[B])(f: (A, B) => C): List[C] = ???
+}
+`,
+      // Operator names are declared names too — and must not break the reading.
+      'src/Ops.scala': `package app
+object Ops {
+  def |+|[A](x: A, y: A): A = x
+  def *[B](b: B): B = b
+}
+trait Heyting[@sp(Int, Long) A] {
+  def and(a: A, b: A): A
+}
+final case class FlatMapped(f: Int => Int) {
+  type A = Int
+}
+trait Laws {
+  type L = Int
+}
+class MyLaws extends Laws {
+  def check(x: L): Boolean = true
+}
+object UsesImport {
+  import FlatMapped._
+  def viaImport(x: A): Int = 1
+}
+object Folds {
+  def foldMap[A](fa: List[A])(f: A => Int)(implicit G: Ordering[Int]): Int = { f(fa.head); G.max(1, 2) }
+}
+object TraverseLaws {
+  def updatedRef[A, B >: A](fa: List[A], b: B): Option[B] = None
+}
+trait UnorderedTraverseTests {
+  def unorderedTraverse[
+    A,
+    B,
+    C,
+    X,
+    Y
+  ](implicit
+    ArbXB: Option[X],
+    ArbYB: List[B]
+  ): Unit = ()
+}
+`,
+      'src/Elsewhere.scala': `package app
+object Elsewhere {
+  def combineAll(xs: List[A]): Int = 1
+  def lift(implicit F: FlatMap): Int = 1
+}
+`,
+      'src/FlatMap.scala': `package app
+trait FlatMap
+`,
+      'src/Eval.scala': `package app
+object Eval {
+  final case class FlatMap(x: Int)
+}
+`,
+      'src/SyntaxSuite.scala': `package app
+class SyntaxSuite {
+  def testOptionEmpty(): Unit = {
+    case class B()
+    val b: B = B()
+  }
+}
+`,
+    });
+    try {
+      expect(typeTargets(cg, 'zipWith')).toEqual([]);
+      expect(typeTargets(cg, '|+|')).toEqual([]);
+      expect(typeTargets(cg, '*')).toEqual([]);
+      // A specialized parameter of the enclosing trait.
+      expect(typeTargets(cg, 'and')).toEqual([]);
+      // A def's own value parameters: `f(…)` calls the argument, `G` is the implicit.
+      const folds = cg.getNodesByName('foldMap')[0]!;
+      const fromFolds = cg.getOutgoingEdgesFrom([folds.id], ['calls', 'references']).map((e) => cg.getNode(e.target)!.name);
+      expect(fromFolds).not.toContain('f');
+      expect(fromFolds).not.toContain('G');
+      // Another type's member is only in scope inside it, a subtype, or after an import.
+      expect(typeTargets(cg, 'combineAll')).toEqual([]);
+      // …and the one in scope is found instead.
+      const lift = cg.getNodesByName('lift')[0]!;
+      const liftTargets = cg.getOutgoingEdgesFrom([lift.id], ['references']).map((e) => cg.getNode(e.target)!);
+      expect(liftTargets.map((n) => `${n.kind}:${n.qualifiedName}`)).toContain('trait:FlatMap');
+      expect(liftTargets.map((n) => n.qualifiedName)).not.toContain('Eval::FlatMap');
+      expect(typeTargets(cg, 'check')).toContain('type_alias:L');
+      expect(typeTargets(cg, 'viaImport')).toContain('type_alias:A');
+      // A lower bound's `>:` is not a closing bracket.
+      expect(typeTargets(cg, 'updatedRef')).toEqual([]);
+      // A parameter list written one per line.
+      expect(typeTargets(cg, 'unorderedTraverse')).toEqual([]);
+      // Inside its own method, the local class is still the one meant.
+      expect(typeTargets(cg, 'testOptionEmpty')).toContain('class:B');
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('Java, TypeScript and Dart: declared before or after the name', async () => {
+    const cg = await project({
+      'src/T.java': `package app;
+public class T {}
+`,
+      'src/Foo.java': `package app;
+public class Foo {}
+`,
+      'src/Util.java': `package app;
+import java.util.List;
+import java.util.Map;
+public class Util {
+  public static <T extends Comparable<T>> T max(List<T> xs) { return null; }
+  public static Map<String, Foo> index(List<Foo> xs) { return null; }
+}
+`,
+      'src/wrap.ts': `export class T {}
+export function wrap<T>(x: T): T { return x; }
+`,
+      'lib/first.dart': `const T = 1;
+T first<T>(List<T> xs) => xs.first;
+`,
+    });
+    try {
+      expect(typeTargets(cg, 'max')).toEqual([]);
+      // A generic type's ARGUMENTS are not parameters: `Map<String, Foo>` still names Foo.
+      expect(typeTargets(cg, 'index')).toContain('class:Foo');
+      expect(typeTargets(cg, 'wrap')).toEqual([]);
+      expect(typeTargets(cg, 'first')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/ui-entrypoints-api.test.ts b/__tests__/ui-entrypoints-api.test.ts
index 6f7df223b3..6025b9dfb2 100644
--- a/__tests__/ui-entrypoints-api.test.ts
+++ b/__tests__/ui-entrypoints-api.test.ts
@@ -391,3 +391,51 @@ describe('splitting a route name', () => {
     });
   });
 });
+
+describe('entry points skip a vendored bundle', () => {
+  let app: Instance;
+  let payload: WireEntryPoints;
+
+  beforeAll(async () => {
+    resetEntryPointsCache();
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-ui-entry-bundle-'));
+    const root = path.join(dir, 'project');
+    fs.mkdirSync(root, { recursive: true });
+    write(
+      root,
+      'src/store.ts',
+      `export function insertNode(name: string): string {
+  return name.trim();
+}
+export function readNode(name: string): string {
+  return insertNode(name);
+}
+export function warm(): string {
+  return insertNode('a') + readNode('b');
+}
+`
+    );
+    // A docs site's bundle, not named .min.js: one-letter functions calling
+    // each other on a few enormous lines.
+    const body = Array.from({ length: 400 }, (_, i) => `function f${i}(e){return n(e,${i})+t(e)}`).join(';');
+    write(root, 'docs/assets/bundle.js', `function n(e,r){return e+r};function t(e){return n(e,1)};${body};\n`);
+    const cg = CodeGraph.initSync(root, {
+      config: { include: ['src/**/*.ts', 'docs/**/*.js'], exclude: [] },
+    });
+    await cg.indexAll();
+    cg.resolveReferences();
+    app = await serve(root, dir, cg);
+    payload = (await getJson(app, '/api/entrypoints')) as WireEntryPoints;
+  }, 120_000);
+
+  afterAll(async () => {
+    await stop(app);
+  });
+
+  it('lists the project’s own hubs, not the bundle’s', () => {
+    const names = payload.hubs.items.map((h) => h.name);
+    expect(names).toContain('insertNode');
+    expect(names).not.toContain('n');
+    expect(names).not.toContain('t');
+  });
+});
diff --git a/__tests__/ui-highlight-bounded.test.ts b/__tests__/ui-highlight-bounded.test.ts
new file mode 100644
index 0000000000..c0b497a5f9
--- /dev/null
+++ b/__tests__/ui-highlight-bounded.test.ts
@@ -0,0 +1,36 @@
+/**
+ * A grammar that never finishes a slice must not take the viewer's server
+ * down. The COBOL grammar's scanner once looped forever on a slice ending in a
+ * line like `    .` (fixed in the grammar since), which froze cobolcraft's Flow
+ * strip and every request behind it: a parse inside WebAssembly cannot be
+ * interrupted from JavaScript. Slices are classified in a worker the server
+ * ends past a deadline; the slice is served plain, and the next one gets a
+ * fresh worker. The deadline is forced here rather than found in a grammar.
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import { highlightLines, clearHighlightCache } from '../src/ui-server/highlight';
+import { stopHighlightWorker, tokenizeBounded } from '../src/ui-server/highlight/bounded-tokenize';
+
+afterAll(() => stopHighlightWorker());
+
+describe('highlighting a slice', () => {
+  it('gives up on a slice past the deadline, and the next slice gets a fresh worker', async () => {
+    const big = 'export const value: number = 1;\n'.repeat(2000);
+    const started = Date.now();
+    const timedOut = await tokenizeBounded(big, 'typescript', 1);
+    expect('timedOut' in timedOut).toBe(true);
+    expect(Date.now() - started).toBeLessThan(5_000);
+
+    const fine = await tokenizeBounded('const y = 2;', 'typescript');
+    expect('result' in fine && (fine.result?.spans.length ?? 0) > 0).toBe(true);
+  }, 20_000);
+
+  it('still highlights through the worker', async () => {
+    clearHighlightCache();
+    const fine = await highlightLines(['export const x: number = 1;'], { language: 'typescript' });
+    expect(fine.engine).toBe('tree-sitter');
+    // The slice that used to hang the COBOL grammar is classified now.
+    const cobol = await highlightLines(['    PERFORM AssertOk', '    .'], { language: 'cobol' });
+    expect(cobol.reason ?? '').not.toMatch(/took too long/);
+  }, 20_000);
+});
diff --git a/__tests__/ui-i18n.test.ts b/__tests__/ui-i18n.test.ts
index 6253b3fe54..2ed282c9ca 100644
--- a/__tests__/ui-i18n.test.ts
+++ b/__tests__/ui-i18n.test.ts
@@ -48,6 +48,26 @@ describe('Web UI i18n', () => {
     expect(i18n.t('nav.map')).toBe('地图');
   });
 
+  it('步骤页调用方入口随语言来回切换且不改变跳转目标', async () => {
+    const { i18n, localize } = await import('../ui/src/lib/i18n.svelte');
+    const root = document.createElement('main');
+    root.innerHTML = '<a href="#/symbol/entry">Its callers and callees →</a>';
+    document.body.append(root);
+    const action = localize(root);
+    try {
+      const link = root.querySelector('a')!;
+      expect(link.textContent).toBe('它的调用方与被调用方 →');
+      i18n.setLocale('en');
+      expect(link.textContent).toBe('Its callers and callees →');
+      i18n.setLocale('zh-CN');
+      expect(link.textContent).toBe('它的调用方与被调用方 →');
+      expect(link.getAttribute('href')).toBe('#/symbol/entry');
+    } finally {
+      action.destroy();
+      root.remove();
+    }
+  });
+
   it('读取已保存的英文偏好', async () => {
     storage.setItem('codegraph.ui.locale', 'en');
 
diff --git a/__tests__/ui-map-api.test.ts b/__tests__/ui-map-api.test.ts
index 75e083162c..fa73d07f4d 100644
--- a/__tests__/ui-map-api.test.ts
+++ b/__tests__/ui-map-api.test.ts
@@ -30,6 +30,7 @@ import {
   pickDefaultDepth,
   passThroughDirs,
   pickDefaultRoot,
+  pickDefaultView,
   resetMapCache,
 } from '../src/ui-server/api/map';
 
@@ -641,3 +642,37 @@ describe('GET /api/map', () => {
     expect(all.modules.map((m: any) => m.id)).not.toEqual(src.modules.map((m: any) => m.id));
   });
 });
+
+describe('the view the map opens on', () => {
+  it('counts files loose in the repository root as program', () => {
+    // git: hundreds of top-level `.c` files beside `builtin/`.
+    expect(
+      pickDefaultRoot([
+        { path: 'git.c', symbols: 60, test: false },
+        { path: 'refs.c', symbols: 50, test: false },
+        { path: 'builtin/add.c', symbols: 40, test: false },
+        { path: 'builtin/commit.c', symbols: 30, test: false },
+      ])
+    ).toBe('');
+  });
+
+  it('opens on the repository when the source folder is one flat folder', () => {
+    // Express: everything under `lib/` sits in `lib/` itself.
+    const files = [
+      ...Array.from({ length: 30 }, (_, i) => ({ path: `lib/f${i}.js`, symbols: 10, test: false })),
+      { path: 'index.js', symbols: 1, test: false },
+      { path: 'benchmarks/run.js', symbols: 3, test: false },
+      { path: 'test/app.js', symbols: 50, test: true },
+    ];
+    expect(pickDefaultView(files)).toEqual({ root: '', depth: 1 });
+  });
+
+  it('keeps a source folder that draws a picture of its own', () => {
+    const files = [
+      { path: 'src/a/x.ts', symbols: 40, test: false },
+      { path: 'src/b/y.ts', symbols: 40, test: false },
+      { path: 'scripts/z.ts', symbols: 2, test: false },
+    ];
+    expect(pickDefaultView(files).root).toBe('src');
+  });
+});
diff --git a/__tests__/ui-program-model.test.ts b/__tests__/ui-program-model.test.ts
index 467976bb28..3ea4d0852f 100644
--- a/__tests__/ui-program-model.test.ts
+++ b/__tests__/ui-program-model.test.ts
@@ -328,3 +328,33 @@ describe('the picture in the code’s order', () => {
     expect(stepEdgeVisible(model, sibling, 'inside')).toBe(true);
   });
 });
+
+describe('a body full of checks that draw nothing', () => {
+  it('reads in one pass, not one per combination of checks', () => {
+    // jsoup's `parse` inlines eighty-odd `if`s with no `else` and no step in
+    // them; each one doubled every way on, and the page died overflowing the
+    // stack. They are all one way on, under no condition of their own.
+    const checks: WireItem[] = Array.from({ length: 80 }, (_, i) => ({
+      kind: 'fork',
+      form: 'if',
+      on: `c${i}`,
+      arms: [arm(`c${i}`, [])],
+    }));
+    const root: WireBlock = [{ kind: 'step', step: 'a' }, ...checks, { kind: 'step', step: 'b' }];
+    expect(shape(root)).toEqual(['anchor → a', 'a → b']);
+    expect(buildOrderModel(payload([step('a'), step('b')], root))?.nodes.size).toBe(3);
+  });
+
+  it('claims no side when the code goes on either way', () => {
+    const root: WireBlock = [
+      {
+        kind: 'fork',
+        form: 'if',
+        on: 'user',
+        arms: [arm('user', [{ kind: 'fork', form: 'if', on: 'admin', arms: [arm('admin', [])] }])],
+      },
+      { kind: 'step', step: 'a' },
+    ];
+    expect(shape(root)).toEqual(['anchor → a']);
+  });
+});
diff --git a/__tests__/ui-repeated-keys.test.ts b/__tests__/ui-repeated-keys.test.ts
new file mode 100644
index 0000000000..e848f5348e
--- /dev/null
+++ b/__tests__/ui-repeated-keys.test.ts
@@ -0,0 +1,97 @@
+/**
+ * The viewer draws its lists keyed by id, and a repeated id stops the page
+ * from drawing at all — Entry points on hono, the Symbol view of every Vue /
+ * Svelte / Astro component. Two payloads repeated themselves:
+ *
+ * - the routes list was a row per (route, edge), so an inline handler came
+ *   back once per call in its body (`GET /stream/text` as `streamText`,
+ *   `writeln` and `sleep`). A route is one row: its bound handler, or the
+ *   route itself as an inline handler;
+ * - a component's members listed its script's symbols twice, and the
+ *   component and its file among them.
+ */
+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';
+import { buildRoutes } from '../src/ui-server/api/routes';
+import { buildNode } from '../src/ui-server/api/node';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-ui-repeated-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', private: true, dependencies: { express: '^4.0.0', astro: '^4.0.0' } }),
+    'server/app.js': `const express = require('express');
+const app = express();
+
+function loadUser(id) { return { id }; }
+function audit(id) { return id; }
+function render(user) { return user; }
+function listUsers(req, res) { res.json([]); }
+function showUser(req, res) { res.json(loadUser(req.params.id)); }
+
+app.get('/users/:id/card', async (req, res) => {
+  const user = loadUser(req.params.id);
+  audit(user.id);
+  res.send(render(user));
+});
+
+app.get('/users', listUsers);
+app.get('/users/:id', showUser);
+`,
+    'src/components/Card.astro': `---
+import Badge from './Badge.astro';
+import { format } from '../lib/format';
+const title = format('card');
+---
+<div><Badge />{title}</div>
+`,
+    'src/components/Badge.astro': `<span>badge</span>
+`,
+    'src/lib/format.ts': `export function format(s: string): string {
+  return s.trim();
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('the routes list', () => {
+  it('has one row per route', () => {
+    const { entries } = buildRoutes(cg, new URLSearchParams());
+    const ids = entries.map((e) => e.routeId);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it('names an inline handler as one, and a bound handler by its name', () => {
+    const { entries } = buildRoutes(cg, new URLSearchParams());
+    const card = entries.find((e) => e.url === 'GET /users/:id/card')!;
+    expect(card).toMatchObject({ handler: 'inline handler', inline: true, handlerId: card.routeId });
+    expect(entries.find((e) => e.url === 'GET /users/:id')).toMatchObject({ handler: 'showUser', inline: false });
+  });
+});
+
+describe('a component’s members', () => {
+  it('lists each symbol once, and never the component or a file', async () => {
+    const component = cg.getNodesByKind('component').find((n) => n.name === 'Card')!;
+    const payload = (await buildNode(cg, root, component.id)) as { members: { items: Array<{ id: string; kind: string }> } };
+    const ids = payload.members.items.map((m) => m.id);
+    expect(ids.length).toBeGreaterThan(0);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ids).not.toContain(component.id);
+    expect(payload.members.items.map((m) => m.kind)).not.toContain('file');
+  });
+});
diff --git a/__tests__/ui-server-api.test.ts b/__tests__/ui-server-api.test.ts
index e2d3646c19..a750e31e63 100644
--- a/__tests__/ui-server-api.test.ts
+++ b/__tests__/ui-server-api.test.ts
@@ -1047,7 +1047,11 @@ export default app;
 
 /**
  * The acceptance bar from the issue, against the engine's OWN index rather than
- * a fixture: `LRUCache.get` in `src/resolution/lru-cache.ts`, 500+ callers.
+ * a fixture: `LRUCache.get` in `src/resolution/lru-cache.ts`, a hub with
+ * hundreds of callers — past the 300-row cap, which is what this checks. (It
+ * had 500+ when the bar was set; sharper resolution has since taken away
+ * `get` calls on maps and caches that were never LRUCache's, so the count is
+ * held to the cap, not to that number.)
  *
  * `.codegraph/` is gitignored, so this only runs on a machine that has indexed
  * this repository. The fixture test above covers the same properties in CI; this
@@ -1089,14 +1093,21 @@ describe.runIf(CodeGraph.isInitialized(path.resolve(__dirname, '..')))(
 
       await repoGet(`/api/node/${hit.id}`); // warm
 
-      const started = performance.now();
-      const res = await repoGet(`/api/node/${hit.id}`);
-      const elapsed = performance.now() - started;
+      // The fastest of a few requests: one sample, taken while the rest of the
+      // suite runs in parallel, measured the machine's load (250–430 ms) as
+      // often as the endpoint. A real slowdown is slow on every request.
+      let res!: Response;
+      let elapsed = Infinity;
+      for (let i = 0; i < 5; i++) {
+        const started = performance.now();
+        res = await repoGet(`/api/node/${hit.id}`);
+        elapsed = Math.min(elapsed, performance.now() - started);
+      }
 
       expect(res.status).toBe(200);
       const body = JSON.parse(res.body);
 
-      expect(body.counts.fanIn).toBeGreaterThanOrEqual(500);
+      expect(body.counts.fanIn).toBeGreaterThan(300);
       expect(body.counts.hub).toBe(true);
       // Grouped by calling symbol, so the row count is the distinct-caller
       // count, never the edge count.
diff --git a/__tests__/ui-server.test.ts b/__tests__/ui-server.test.ts
index df25858a84..4b4e63fc8c 100644
--- a/__tests__/ui-server.test.ts
+++ b/__tests__/ui-server.test.ts
@@ -12,7 +12,7 @@
  * name in undici, and forging it is the whole point of half these cases.
  */
 
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
 import * as http from 'http';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -21,12 +21,14 @@ import {
   browserOpenCommand,
   cacheControlFor,
   contentTypeFor,
+  describeBindFailure,
   isAllowedHost,
   isAllowedOrigin,
   isSafeRequestPath,
   PathRefusalError,
   resolveProjectFile,
   resolveStaticAsset,
+  shouldTryNextPort,
   startUiServer,
   type UiServerHandle,
 } from '../src/ui-server';
@@ -69,6 +71,31 @@ function request(
   });
 }
 
+/** A failed `listen()` as node reports it. */
+function bindError(code: string, port: number): NodeJS.ErrnoException {
+  return Object.assign(new Error(`listen ${code}: 127.0.0.1:${port}`), { code, syscall: 'listen' });
+}
+
+/**
+ * Make `listen()` on `refused` fail with EACCES, the way Windows refuses a port
+ * another program holds exclusively or one inside a reserved range, without
+ * needing either on the machine running the test (#2299). Every other port is
+ * a real bind.
+ */
+function refuseListenOn(...refused: number[]): { mockRestore(): void } {
+  const realListen = http.Server.prototype.listen;
+  return vi
+    .spyOn(http.Server.prototype, 'listen')
+    .mockImplementation(function (this: http.Server, ...args: unknown[]) {
+      const port = args[0];
+      if (typeof port === 'number' && refused.includes(port)) {
+        process.nextTick(() => this.emit('error', bindError('EACCES', port)));
+        return this;
+      }
+      return (realListen as (...a: unknown[]) => http.Server).apply(this, args);
+    });
+}
+
 describe('codegraph ui server', () => {
   let tempDir: string;
   let viewerDir: string;
@@ -198,6 +225,50 @@ describe('codegraph ui server', () => {
         await new Promise<void>((resolve) => blocker.close(() => resolve()));
       }
     });
+
+    /**
+     * #2299: on Windows a port another program holds exclusively, or one in a
+     * reserved range, fails with EACCES rather than EADDRINUSE, and the walk
+     * used to stop there. Port N is really taken, N+1 is refused, so the server
+     * has to land beyond both. N+1 is an ephemeral port, above 1023, so this
+     * holds on every platform.
+     */
+    it('falls back past a port refused with EACCES', async () => {
+      const blocker = http.createServer(() => {});
+      await new Promise<void>((resolve) => blocker.listen(0, '127.0.0.1', resolve));
+      const taken = (blocker.address() as { port: number }).port;
+      const refusal = refuseListenOn(taken + 1);
+
+      try {
+        const second = await startUiServer({ projectRoot, viewerDir, port: taken });
+        try {
+          expect(second.port).toBeGreaterThan(taken + 1);
+          // …and it actually works on the port it landed on.
+          const res = await request(second.port, '/');
+          expect(res.status).toBe(200);
+        } finally {
+          await second.close();
+        }
+      } finally {
+        refusal.mockRestore();
+        await new Promise<void>((resolve) => blocker.close(() => resolve()));
+      }
+    });
+
+    it('blames a refused pinned port on what refused it, not on privileged ports', async () => {
+      // The port from the report: nowhere near 1024.
+      const refusal = refuseListenOn(49912);
+      try {
+        const failure = startUiServer({ projectRoot, viewerDir, port: 49912, portFallback: false });
+        await expect(failure).rejects.toThrow(/49912/);
+        const message = await failure.catch((err: Error) => err.message);
+        expect(message).not.toMatch(/below 1024|elevated privileges/);
+        expect(message).not.toMatch(/already in use/);
+        expect(message).toMatch(/refused/);
+      } finally {
+        refusal.mockRestore();
+      }
+    });
   });
 
   describe('Host allowlist (DNS rebinding)', () => {
@@ -538,6 +609,93 @@ describe('security helpers', () => {
   });
 });
 
+/**
+ * What a bind failure means depends on the platform (#2299): Windows has no
+ * privileged ports and refuses a taken or reserved one with EACCES, while
+ * elsewhere EACCES below 1024 is the privileged-port rule. The platform is a
+ * parameter, so every host checks every platform's answer.
+ */
+describe('port fallback on each platform', () => {
+  const LIST_RESERVED = 'netsh int ipv4 show excludedportrange protocol=tcp';
+
+  it('moves past a port in use everywhere, and past EACCES on Windows at any port', () => {
+    for (const platform of ['win32', 'linux', 'darwin'] as const) {
+      expect(shouldTryNextPort('EADDRINUSE', 80, platform), platform).toBe(true);
+      expect(shouldTryNextPort('EADDRINUSE', 4747, platform), platform).toBe(true);
+    }
+    expect(shouldTryNextPort('EACCES', 49912, 'win32')).toBe(true);
+    // Windows has no privileged-port rule: a low port is held, not forbidden.
+    expect(shouldTryNextPort('EACCES', 80, 'win32')).toBe(true);
+  });
+
+  it('stops at EACCES below 1024 elsewhere, where the next port needs the same privilege', () => {
+    expect(shouldTryNextPort('EACCES', 80, 'linux')).toBe(false);
+    expect(shouldTryNextPort('EACCES', 1023, 'darwin')).toBe(false);
+    // From 1024 up the refusal is about that port, and the next may be allowed.
+    expect(shouldTryNextPort('EACCES', 1024, 'linux')).toBe(true);
+    expect(shouldTryNextPort('EACCES', 4747, 'darwin')).toBe(true);
+  });
+
+  it('never moves past any other failure', () => {
+    for (const platform of ['win32', 'linux'] as const) {
+      expect(shouldTryNextPort('EADDRNOTAVAIL', 4747, platform), platform).toBe(false);
+      expect(shouldTryNextPort('EPERM', 4747, platform), platform).toBe(false);
+      expect(shouldTryNextPort(undefined, 4747, platform), platform).toBe(false);
+    }
+  });
+
+  it('says why Windows refused a pinned port, without the POSIX privileged-port story', () => {
+    for (const port of [49912, 80]) {
+      const message = describeBindFailure(bindError('EACCES', port), port, { port, fallback: false }, 'win32').message;
+      expect(message).toMatch(
+        new RegExp(`^Windows refused port ${port}: another program holds it, or it is in a reserved range`)
+      );
+      expect(message).toContain(LIST_RESERVED);
+      expect(message).toContain('omit --port');
+      expect(message).not.toMatch(/below 1024|elevated privileges/);
+    }
+  });
+
+  it('keeps the privileged-port explanation off Windows, and only below 1024', () => {
+    for (const fallback of [false, true]) {
+      const message = describeBindFailure(bindError('EACCES', 80), 80, { port: 80, fallback }, 'linux').message;
+      expect(message).toBe(
+        'Not allowed to listen on port 80. Ports below 1024 usually need elevated privileges — pick a higher one with --port.'
+      );
+    }
+    const high = describeBindFailure(bindError('EACCES', 4747), 4747, { port: 4747, fallback: false }, 'darwin').message;
+    expect(high).toMatch(/^Not allowed to listen on port 4747: the system refused permission\./);
+    expect(high).not.toMatch(/below 1024|elevated privileges|Windows|netsh/);
+  });
+
+  it('says a walk that ran out met refusals, not only ports in use', () => {
+    const walk = { port: 4747, fallback: true };
+    const inUse = bindError('EADDRINUSE', 4766);
+    const refused = bindError('EACCES', 4766);
+
+    // Nothing refused: the message it always gave.
+    expect(describeBindFailure(inUse, 4766, walk, 'win32').message).toBe(
+      'Ports 4747–4766 are all in use. Free one, or pick another with --port.'
+    );
+    const windows = describeBindFailure(refused, 4766, walk, 'win32').message;
+    expect(windows).toMatch(/^Ports 4747–4766 are all in use or reserved/);
+    expect(windows).toContain(LIST_RESERVED);
+    // An earlier port was refused even though the last one was only in use.
+    expect(describeBindFailure(inUse, 4766, walk, 'win32', true).message).toBe(windows);
+    const posix = describeBindFailure(refused, 4766, walk, 'linux').message;
+    expect(posix).toMatch(/^Ports 4747–4766 are all in use or not allowed\./);
+    expect(posix).not.toMatch(/reserved|netsh/);
+  });
+
+  it('leaves the pinned in-use message and other failures as they were', () => {
+    expect(
+      describeBindFailure(bindError('EADDRINUSE', 8080), 8080, { port: 8080, fallback: false }, 'win32').message
+    ).toBe('Port 8080 is already in use. Pick another with --port, or omit --port to let CodeGraph find a free one.');
+    const other = bindError('EADDRNOTAVAIL', 4747);
+    expect(describeBindFailure(other, 4747, { port: 4747, fallback: true }, 'linux')).toBe(other);
+  });
+});
+
 describe('browserOpenCommand', () => {
   it('uses the platform opener', () => {
     expect(browserOpenCommand('http://x', 'darwin')).toEqual({ command: 'open', args: ['http://x'] });
diff --git a/__tests__/ui-workspace-config.test.ts b/__tests__/ui-workspace-config.test.ts
index e61c2f16a5..111a93d6df 100644
--- a/__tests__/ui-workspace-config.test.ts
+++ b/__tests__/ui-workspace-config.test.ts
@@ -54,3 +54,15 @@ it('非缺失路径错误不当作离线项目忽略', () => {
     expect(() => loadWorkspaceConfig(config)).toThrow();
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 });
+
+it.each(['./file/child/grandchild', './alias/child/grandchild'])('非目录祖先的深层路径仍必须拒绝：%s', projectPath => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-config-file-ancestor-'));
+  try {
+    const ordinaryFile = path.join(dir, 'file');
+    fs.writeFileSync(ordinaryFile, '普通文件不能承载离线项目');
+    fs.symlinkSync(ordinaryFile, path.join(dir, 'alias'), 'file');
+    const config = path.join(dir, 'workspace.json');
+    fs.writeFileSync(config, JSON.stringify({ name: '错误配置', projects: [{ id: 'one', name: '项目', path: projectPath }] }));
+    expect(() => loadWorkspaceConfig(config)).toThrow();
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
diff --git a/__tests__/unittest-named-files.test.ts b/__tests__/unittest-named-files.test.ts
new file mode 100644
index 0000000000..69baff7d28
--- /dev/null
+++ b/__tests__/unittest-named-files.test.ts
@@ -0,0 +1,150 @@
+/**
+ * Google names its tests `foo_unittest.cc` (protobuf, Breakpad, glog,
+ * Chromium) and Chromium names its Python tests `foo_unittest.py`, where
+ * every other convention puts a separator right before `test`. The test-file
+ * check wanted that separator, so each of them read as production code and the
+ * resolver's test rules ran backwards for it. A unittest could not reach the
+ * test helpers it uses (`device.reboot()` on a fake from `tests/`), while
+ * production code resolved into a unittest's own declarations: Breakpad's
+ * `stack_frame_entries_.size()` went to a unittest's `StackHelper::size`, and
+ * a template's `AddressType()` to the `typedef` one unittest declares.
+ */
+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-unittest-named-'));
+  const files: Record<string, string> = {
+    // A test helper in a test suite, and a unittest that uses it.
+    'tests/__init__.py': '',
+    'tests/fake_device.py': `class FakeDevice:
+    def reboot(self):
+        return True
+`,
+    'tools/device/device_unittest.py': `from tests.fake_device import FakeDevice
+
+
+def test_reboot():
+    device = FakeDevice()
+    return device.reboot()
+`,
+    // The same in C++: protobuf's TestUtil, reached through the header.
+    'src/message.h': `#ifndef MESSAGE_H_
+#define MESSAGE_H_
+
+namespace protobuf {
+
+class Message {
+ public:
+  void Clear();
+};
+
+}  // namespace protobuf
+
+#endif
+`,
+    'src/message.cc': `#include "message.h"
+
+namespace protobuf {
+
+void Message::Clear() {}
+
+}  // namespace protobuf
+`,
+    'src/test_util.h': `#ifndef TEST_UTIL_H_
+#define TEST_UTIL_H_
+
+#include "message.h"
+
+namespace protobuf {
+namespace TestUtil {
+
+inline void SetAllFields(Message* message) { message->Clear(); }
+
+}  // namespace TestUtil
+}  // namespace protobuf
+
+#endif
+`,
+    'src/wire_format_unittest.cc': `#include "message.h"
+#include "test_util.h"
+
+namespace protobuf {
+
+void ParsesAllFields() {
+  Message message;
+  TestUtil::SetAllFields(&message);
+}
+
+}  // namespace protobuf
+`,
+    // Production code whose calls name nothing in the project.
+    'src/module.cc': `#include <vector>
+
+using std::vector;
+
+class Module {
+ public:
+  int CountEntries() const { return static_cast<int>(stack_frame_entries_.size()); }
+
+ private:
+  vector<int> stack_frame_entries_;
+};
+`,
+    'src/range_map-inl.h': `template <typename AddressType>
+bool StoreRange(const AddressType& base) {
+  AddressType high = AddressType();
+  return base < high;
+}
+`,
+    // A unittest's own declarations, named like what production code calls.
+    'src/ptrace_dumper_unittest.cc': `class StackHelper {
+ public:
+  unsigned size() const { return 0; }
+};
+
+unsigned Depth() {
+  StackHelper helper;
+  return helper.size();
+}
+`,
+    'src/address_map_unittest.cc': `typedef int AddressType;
+
+AddressType Lookup() { return 0; }
+`,
+  };
+  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 });
+}, 60_000);
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const edgesFrom = (file: string) => {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!);
+};
+
+describe("Google's unittest files are tests", () => {
+  it('a unittest reaches the test helpers it uses', () => {
+    expect(edgesFrom('tools/device/device_unittest.py').map((n) => n.qualifiedName)).toContain('FakeDevice::reboot');
+    expect(edgesFrom('src/wire_format_unittest.cc').map((n) => n.qualifiedName)).toContain('protobuf::TestUtil::SetAllFields');
+  });
+
+  it("production code never resolves into a unittest's own declarations", () => {
+    for (const file of ['src/module.cc', 'src/range_map-inl.h']) {
+      expect(edgesFrom(file).map((n) => n.filePath).filter((f) => f.endsWith('_unittest.cc')), file).toEqual([]);
+    }
+  });
+});
diff --git a/__tests__/upgrade.test.ts b/__tests__/upgrade.test.ts
index 244957af4e..ad46a17ad4 100644
--- a/__tests__/upgrade.test.ts
+++ b/__tests__/upgrade.test.ts
@@ -14,7 +14,10 @@ import {
   reindexAdvisory,
   runUpgrade,
   verifyResolvedVersion,
+  defaultWirePromptHook,
   buildWindowsUpgradeScript,
+  WINDOWS_SWAP_FUNCTION,
+  WINDOWS_UPGRADE_DAMAGED,
   NPM_PACKAGE,
   type InstallMethod,
   type UpgradeDeps,
@@ -210,17 +213,124 @@ describe('version helpers', () => {
     expect(a).toContain('codegraph index -f');
   });
 
-  it('buildWindowsUpgradeScript targets the right asset per arch and renames-not-deletes the exe', () => {
+  it('buildWindowsUpgradeScript targets the right asset per arch', () => {
     const arm = buildWindowsUpgradeScript('C:\\cg\\current', 'v1.2.3', 'arm64');
     expect(arm).toContain('releases/download/v1.2.3/codegraph-win32-arm64.zip');
     expect(arm).toContain("$dest='C:\\cg\\current'");
-    expect(arm).toContain('Rename-Item'); // never Remove-Item on the locked exe
-    expect(arm).not.toMatch(/Remove-Item[^;]*\$dest'?\s*;/); // doesn't delete current\
+    expect(arm).toContain("Join-Path $stage 'codegraph-win32-arm64'");
     const x64 = buildWindowsUpgradeScript('C:\\cg\\current', 'v1.2.3', 'x64');
     expect(x64).toContain('codegraph-win32-x64.zip');
   });
 });
 
+// ---------------------------------------------------------------------------
+// Windows file swap (#2185) — a running CodeGraph process (an agent session's
+// MCP server) keeps node.exe and the native kernel locked: they can be renamed
+// but not overwritten or deleted. The upgrade used to rename only node.exe and
+// then Copy-Item over the rest, so the locked kernel failed the copy halfway
+// and left the install with no node.exe. PowerShell can't run on the macOS
+// test host, so these pin the script's shape; the behavior is validated on a
+// real Windows machine.
+// ---------------------------------------------------------------------------
+
+describe('windows bundle swap script (#2185)', () => {
+  const INSTALL_PS1 = path.join(__dirname, '..', 'install.ps1');
+  const installPs1 = () => fs.readFileSync(INSTALL_PS1, 'utf-8').replace(/\r\n/g, '\n');
+  const script = () => buildWindowsUpgradeScript('C:\\Users\\me\\AppData\\Local\\codegraph\\current', 'v1.6.2', 'x64');
+  /** The swap function's own statements, comments dropped. */
+  const swapCode = () => WINDOWS_SWAP_FUNCTION.split('\n').filter((l) => !l.trim().startsWith('#')).join('\n');
+
+  it('install.ps1 carries the same swap function, verbatim', () => {
+    const m = /# >>> Install-CodeGraphFiles[^\n]*\n([\s\S]*?)# <<< Install-CodeGraphFiles/.exec(installPs1());
+    expect(m, 'install.ps1 lost its Install-CodeGraphFiles markers').not.toBeNull();
+    expect(m![1]).toBe(WINDOWS_SWAP_FUNCTION);
+  });
+
+  it('never copies over or deletes current\\ in place', () => {
+    for (const text of [script(), installPs1()]) {
+      expect(text).not.toMatch(/Copy-Item/);
+      expect(text).not.toMatch(/Remove-Item[^\n]*\$dest\b/);
+      expect(text).not.toMatch(/Expand-Archive[^\n]*\$dest\b/);
+    }
+  });
+
+  it('unpacks next to current\\ (same volume), not into %TEMP%, then swaps', () => {
+    const s = script();
+    expect(s).toContain(`$stage=Join-Path (Split-Path -Parent $dest) ('.staging-'`);
+    expect(s).toMatch(/Expand-Archive -Path \$zip -DestinationPath \$stage/);
+    expect(s.indexOf('Expand-Archive')).toBeLessThan(s.indexOf('Install-CodeGraphFiles $('));
+    // install.ps1 stages next to current\ too.
+    expect(installPs1()).toContain(`$stage = Join-Path $installDir ('.staging-'`);
+    expect(installPs1()).toMatch(/Install-CodeGraphFiles \$\(.*\) \$dest$/m);
+  });
+
+  it('renames every replaced file aside before moving the staged file in', () => {
+    const code = swapCode();
+    // Replaced files and files the new version drops are both renamed aside…
+    expect(code.match(/Move-Logged \$at "\$at\.old-\$token"/g)).toHaveLength(2);
+    // …and the aside-rename of a target comes before the staged file moves in.
+    const aside = code.indexOf('if ([IO.File]::Exists($at)) { Move-Logged $at "$at.old-$token" }');
+    const moveIn = code.indexOf('Move-Logged ($stageDir + $rel) $at');
+    expect(aside).toBeGreaterThan(0);
+    expect(moveIn).toBeGreaterThan(aside);
+    // No in-place overwrite or delete of a live file during the swap.
+    expect(code).not.toMatch(/\[IO\.File\]::(Copy|Replace)\(/);
+    expect(code).not.toMatch(/Move-Item|Rename-Item/);
+  });
+
+  it('rolls back on failure and on interruption, and says whether the install still works', () => {
+    const code = swapCode();
+    expect(code).toMatch(/catch \{[\s\S]*\$lost = Undo-Logged[\s\S]*\} finally \{\s*if \(-not \$done\) \{ \[void\]\(Undo-Logged\) \}/);
+    // Undo walks the log backwards, moving each file back to where it was.
+    expect(code).toContain('for ($n = $undo.Count - 1; $n -ge 0; $n--)');
+    expect(code).toContain('[IO.File]::Move($u[1], $u[0])');
+    expect(code).toContain('Nothing was changed: the existing install still works.');
+    expect(code).toContain("$e.Data['codegraphDamaged'] = [bool]$lost");
+    // The upgrade script maps that flag to the exit code runUpgrade reads.
+    expect(script()).toContain(`$code=if($_.Exception.Data['codegraphDamaged']){${WINDOWS_UPGRADE_DAMAGED}}else{1}`);
+    expect(script().trimEnd().endsWith('exit $code')).toBe(true);
+  });
+
+  it('refuses a download that is not a bundle before touching current\\', () => {
+    const code = swapCode();
+    expect(code).toContain("foreach ($need in 'node.exe', 'bin\\codegraph.cmd')");
+    expect(code.indexOf("foreach ($need in")).toBeLessThan(code.indexOf('try {'));
+  });
+
+  it('cleans up renamed-aside leftovers, including ones from earlier upgrades', () => {
+    const m = /\$asideName = '([^']+)'/.exec(WINDOWS_SWAP_FUNCTION);
+    expect(m).not.toBeNull();
+    const aside = new RegExp(m![1]!, 'i'); // PowerShell -match is case-insensitive
+    // The pre-fix upgrade left node.exe.old-<32-hex guid>; this one uses 8 hex.
+    expect(aside.test('node.exe.old-0123456789abcdef0123456789ABCDEF')).toBe(true);
+    expect(aside.test('codegraph-kernel.node.old-deadbeef')).toBe(true);
+    for (const shipped of ['node.exe', 'codegraph-kernel.node', 'old-deadbeef.js', 'x.old-1234567', 'a.old-deadbeef.js']) {
+      expect(aside.test(shipped), shipped).toBe(false);
+    }
+    // No file a bundle actually ships looks like a leftover.
+    const walk = (dir: string): string[] =>
+      fs.readdirSync(dir, { withFileTypes: true }).flatMap((e) => (e.isDirectory() ? walk(path.join(dir, e.name)) : [e.name]));
+    const distDir = path.join(__dirname, '..', 'dist');
+    if (fs.existsSync(distDir)) expect(walk(distDir).filter((n) => aside.test(n))).toEqual([]);
+    // Deleted only after a successful swap, and a still-locked one is skipped.
+    const code = swapCode();
+    expect(code.indexOf('[IO.File]::Delete($f.FullName)')).toBeGreaterThan(code.indexOf('$done = $true'));
+    expect(code).toContain('try { [IO.File]::Delete($f.FullName) } catch {}');
+  });
+
+  it('quotes the install path for PowerShell', () => {
+    const s = buildWindowsUpgradeScript("C:\\Users\\o'brien\\codegraph\\current", 'v1.6.2', 'x64');
+    expect(s).toContain("$dest='C:\\Users\\o''brien\\codegraph\\current'");
+  });
+
+  it('fits a Windows command line even for a long install path', () => {
+    const root = `C:\\${'very-long-directory-name\\'.repeat(8)}codegraph\\current`;
+    const encoded = Buffer.from(buildWindowsUpgradeScript(root, 'v10.20.30', 'arm64'), 'utf16le').toString('base64');
+    // CreateProcess caps the whole command line at 32,767 characters.
+    expect(encoded.length).toBeLessThan(24_000);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // runUpgrade orchestration — mocked side-effects
 // ---------------------------------------------------------------------------
@@ -230,13 +340,15 @@ interface Calls {
   captures: Array<{ cmd: string; args: string[] }>;
   logs: string[];
   errors: string[];
+  /** How many times the upgrade asked deps to wire the Claude prompt hook. */
+  promptHookWires: number;
 }
 
 function makeDeps(
   overrides: Partial<UpgradeDeps> & { method: InstallMethod; currentVersion: string },
   runExit = 0
 ): { deps: UpgradeDeps; calls: Calls } {
-  const calls: Calls = { runs: [], captures: [], logs: [], errors: [] };
+  const calls: Calls = { runs: [], captures: [], logs: [], errors: [], promptHookWires: 0 };
   const deps: UpgradeDeps = {
     currentVersion: overrides.currentVersion,
     method: overrides.method,
@@ -252,6 +364,12 @@ function makeDeps(
       return overrides.capture ? overrides.capture(cmd, args) : null;
     },
     hasCommand: overrides.hasCommand ?? ((c) => c === 'curl'),
+    // A recorder, never the real writer: that one edits the GLOBAL Claude
+    // profile, which here would be the developer's own (#2275).
+    wirePromptHook: async () => {
+      calls.promptHookWires += 1;
+      return overrides.wirePromptHook ? overrides.wirePromptHook() : false;
+    },
     log: (m) => calls.logs.push(m),
     warn: (m) => calls.logs.push(m),
     error: (m) => calls.errors.push(m),
@@ -326,11 +444,10 @@ describe('runUpgrade', () => {
     expect(calls.runs).toHaveLength(1);
     expect(calls.runs[0].cmd).toBe('powershell.exe');
     const decoded = decodeEncodedCommand(calls.runs[0].args);
-    // Downloads the right asset, renames the locked exe aside, copies over current\.
+    // Downloads the right asset and swaps it in with the shared rename-aside function.
     expect(decoded).toContain('releases/download/v0.9.9/codegraph-win32-');
-    expect(decoded).toContain('Rename-Item');
-    expect(decoded).toContain('node.exe.old-');
-    expect(decoded).toContain('Copy-Item');
+    expect(decoded).toContain(WINDOWS_SWAP_FUNCTION);
+    expect(decoded).toMatch(/^\s*Install-CodeGraphFiles .* \$dest$/m);
   });
 
   it('windows bundle: a non-zero installer exit is a failure', async () => {
@@ -344,7 +461,37 @@ describe('runUpgrade', () => {
     );
     const code = await runUpgrade({}, deps);
     expect(code).toBe(1);
-    expect(calls.errors.join('\n')).toMatch(/exited with code/i);
+    // Exit 1 is the script's "failed, install unchanged" code (#2185).
+    expect(calls.errors.join('\n')).toMatch(/did not complete; your existing install was left as it was/i);
+  });
+
+  it('windows bundle: an incomplete rollback points at the reinstall command', async () => {
+    const { deps, calls } = makeDeps(
+      {
+        method: { kind: 'bundle', os: 'windows', bundleRoot: 'C:/x/codegraph/current', installDir: 'C:/x/codegraph' },
+        currentVersion: '0.9.8',
+        platform: 'win32',
+      },
+      WINDOWS_UPGRADE_DAMAGED
+    );
+    const code = await runUpgrade({}, deps);
+    expect(code).toBe(1);
+    expect(calls.errors.join('\n')).toMatch(/could not be put back/i);
+    expect(calls.logs.join('\n')).toContain('install.ps1 | iex');
+    expect(calls.runs).toHaveLength(1); // no post-upgrade refresh/probe after a failure
+  });
+
+  it('windows bundle: any other exit code is reported as-is', async () => {
+    const { deps, calls } = makeDeps(
+      {
+        method: { kind: 'bundle', os: 'windows', bundleRoot: 'C:/x/codegraph/current', installDir: 'C:/x/codegraph' },
+        currentVersion: '0.9.8',
+        platform: 'win32',
+      },
+      -1
+    );
+    expect(await runUpgrade({}, deps)).toBe(1);
+    expect(calls.errors.join('\n')).toMatch(/exited with code -1/i);
   });
 
   it('npm global: shells out to npm install -g @pkg@latest', async () => {
@@ -473,6 +620,104 @@ describe('runUpgrade beta signup offer', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Post-upgrade prompt-hook self-heal — only ever through deps (#2275). The
+// real writer edits the GLOBAL Claude profile; while the upgrade called it
+// directly, every successful fake upgrade in this file could wire the hook
+// into the developer's own ~/.claude/settings.json.
+// ---------------------------------------------------------------------------
+
+describe('post-upgrade prompt-hook self-heal', () => {
+  // A configured global Claude profile the REAL writer would act on, so an
+  // upgrade that bypasses deps shows up as a settings.json written here.
+  const KEYS = ['CLAUDE_CONFIG_DIR', 'CODEGRAPH_NO_PROMPT_HOOK', 'CODEGRAPH_PROMPT_HOOK'] as const;
+  const saved: Partial<Record<(typeof KEYS)[number], string | undefined>> = {};
+  let profile: string;
+
+  function configureProfile(): void {
+    fs.writeFileSync(
+      path.join(profile, '.claude.json'),
+      JSON.stringify({ mcpServers: { codegraph: { command: 'codegraph', args: ['serve', '--mcp'] } } }),
+    );
+  }
+
+  beforeEach(() => {
+    for (const k of KEYS) saved[k] = process.env[k];
+    delete process.env.CODEGRAPH_NO_PROMPT_HOOK;
+    delete process.env.CODEGRAPH_PROMPT_HOOK;
+    profile = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-upgrade-claude-'));
+    process.env.CLAUDE_CONFIG_DIR = profile;
+  });
+  afterEach(() => {
+    for (const k of KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+    fs.rmSync(profile, { recursive: true, force: true });
+  });
+
+  it('a successful upgrade wires the hook through deps, never the real writer', async () => {
+    configureProfile();
+    const { deps, calls } = makeDeps({ method: { kind: 'npm', scope: 'global' }, currentVersion: '0.9.8' });
+    expect(await runUpgrade({}, deps)).toBe(0);
+    expect(fs.existsSync(path.join(profile, 'settings.json')), 'the real writer ran').toBe(false);
+    expect(calls.promptHookWires).toBe(1);
+  });
+
+  it('notes the hook only when the writer changed something', async () => {
+    const quiet = makeDeps({ method: { kind: 'npm', scope: 'global' }, currentVersion: '0.9.8' });
+    expect(await runUpgrade({}, quiet.deps)).toBe(0);
+    expect(quiet.calls.logs.join('\n')).not.toMatch(/front-load hook/);
+
+    const wired = makeDeps({
+      method: { kind: 'npm', scope: 'global' },
+      currentVersion: '0.9.8',
+      wirePromptHook: async () => true,
+    });
+    expect(await runUpgrade({}, wired.deps)).toBe(0);
+    expect(wired.calls.logs.join('\n')).toMatch(/Enabled the CodeGraph front-load hook/);
+  });
+
+  it('the kill-switch skips the writer entirely', async () => {
+    process.env.CODEGRAPH_NO_PROMPT_HOOK = '1';
+    const { deps, calls } = makeDeps({ method: { kind: 'npm', scope: 'global' }, currentVersion: '0.9.8' });
+    expect(await runUpgrade({}, deps)).toBe(0);
+    expect(calls.promptHookWires).toBe(0);
+  });
+
+  it('does not wire on --check, when up to date, or when the upgrade fails', async () => {
+    const check = makeDeps({ method: { kind: 'npm', scope: 'global' }, currentVersion: '0.9.8' });
+    expect(await runUpgrade({ check: true }, check.deps)).toBe(0);
+    const current = makeDeps({ method: { kind: 'npm', scope: 'global' }, currentVersion: '0.9.9' });
+    expect(await runUpgrade({}, current.deps)).toBe(0);
+    const failed = makeDeps({ method: { kind: 'npm', scope: 'global' }, currentVersion: '0.9.8' }, 1);
+    expect(await runUpgrade({}, failed.deps)).toBe(1);
+    for (const { calls } of [check, current, failed]) expect(calls.promptHookWires).toBe(0);
+  });
+
+  it('a throwing writer never fails the upgrade', async () => {
+    const { deps } = makeDeps({
+      method: { kind: 'npm', scope: 'global' },
+      currentVersion: '0.9.8',
+      wirePromptHook: async () => { throw new Error('EACCES'); },
+    });
+    expect(await runUpgrade({}, deps)).toBe(0);
+  });
+
+  // The production writer itself, pointed at the temp profile above.
+  it('the real writer wires a configured profile once, and leaves an unconfigured one alone', async () => {
+    const settings = path.join(profile, 'settings.json');
+    expect(await defaultWirePromptHook()).toBe(false);
+    expect(fs.existsSync(settings)).toBe(false);
+
+    configureProfile();
+    expect(await defaultWirePromptHook()).toBe(true);
+    const written = JSON.parse(fs.readFileSync(settings, 'utf-8'));
+    expect(JSON.stringify(written.hooks.UserPromptSubmit)).toMatch(/prompt-hook/);
+    expect(await defaultWirePromptHook()).toBe(false); // idempotent
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Post-upgrade self-heal of installed agent surfaces
 // ---------------------------------------------------------------------------
diff --git a/__tests__/vapor-closure-route-body.test.ts b/__tests__/vapor-closure-route-body.test.ts
new file mode 100644
index 0000000000..e0fcb080c5
--- /dev/null
+++ b/__tests__/vapor-closure-route-body.test.ts
@@ -0,0 +1,63 @@
+/**
+ * A Vapor route whose handler is a trailing closure — `app.get("hello") { req
+ * in … }` — has no handler symbol, so it linked to nothing and the viewer's
+ * Steps tab drew it alone (vapor's own repo: 76 of 80 routes). The closure is
+ * the handler: its calls are the route's, as an Express inline handler's are.
+ * A closure after a non-route call (`if let x = req.parameters.get("x") {`)
+ * is not a route body.
+ */
+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-vapor-closure-'));
+  const files: Record<string, string> = {
+    'Package.swift': `// swift-tools-version:5.9
+import PackageDescription
+let package = Package(name: "App", dependencies: [.package(url: "https://github.com/vapor/vapor.git", from: "4.0.0")])
+`,
+    'Sources/App/Greeter.swift': `import Vapor
+enum Greeter {
+    static func greeting(for name: String) -> String { "hi \\(name)" }
+    static func audit(_ name: String) {}
+}
+`,
+    'Sources/App/routes.swift': `import Vapor
+func routes(_ app: Application) throws {
+    app.get("hello", ":name") { req async throws -> String in
+        let name = req.parameters.get("name") ?? "world"
+        Greeter.audit(name)
+        return Greeter.greeting(for: name)
+    }
+    app.webSocket("echo") { req, ws in
+        ws.onText { ws, text in ws.send(text) }
+    }
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('a Vapor closure route', () => {
+  it('lends the route its closure’s calls', () => {
+    const route = cg.getNodesByKind('route').find((r) => r.name === 'GET /hello/:name')!;
+    expect(route).toBeDefined();
+    const callees = cg.getOutgoingEdgesFrom([route.id], ['calls']).map((e) => cg.getNode(e.target)!.qualifiedName).sort();
+    expect(callees).toEqual(['Greeter::audit', 'Greeter::greeting']);
+  });
+});
diff --git a/__tests__/vapor-closure-routes.test.ts b/__tests__/vapor-closure-routes.test.ts
new file mode 100644
index 0000000000..ba875649ee
--- /dev/null
+++ b/__tests__/vapor-closure-routes.test.ts
@@ -0,0 +1,70 @@
+/**
+ * A Vapor route whose handler is a trailing closure — `app.get("hello") { req
+ * in … }`, `app.webSocket("chat") { req, ws in … }` — and a `routes.on(.POST,
+ * "x", use:)` registration are routes too; only `use:` handlers were read.
+ * A `{` that opens an `if` (`if let v = req.parameters.get("x") {`) or an HTTP
+ * client's `req.client.get("https://…") { … }` is not one.
+ */
+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-vapor-closure-'));
+  const files: Record<string, string> = {
+    'Package.swift': `// swift-tools-version:5.9
+import PackageDescription
+let package = Package(name: "App", dependencies: [.package(url: "https://github.com/vapor/vapor.git", from: "4.0.0")])
+`,
+    'Sources/App/routes.swift': `import Vapor
+
+func routes(_ app: Application) throws {
+    app.get("hello", ":name") { req async throws -> String in
+        guard let name = req.parameters.get("name") else { throw Abort(.badRequest) }
+        return "Hello, \\(name)"
+    }
+    app.webSocket("chat") { req, client in
+        client.send("hi")
+    }
+    let todos = app.grouped("todos")
+    todos.on(.POST, "import", body: .collect(maxSize: "1mb"), use: importTodos)
+}
+
+func importTodos(req: Request) async throws -> HTTPStatus { .ok }
+
+func lookup(req: Request) async throws -> String {
+    if let owner = req.parameters.get("owner") {
+        return owner
+    }
+    let res = try await req.client.get("https://example.com") { out in
+        try out.query.encode(["q": "x"])
+    }
+    return "\\(res.status)"
+}
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('Vapor closure and on(…) routes', () => {
+  it('are routes; an if-let body and an HTTP client call are not', () => {
+    const names = cg.getNodesByKind('route').map((r) => r.name).sort();
+    expect(names).toEqual(['GET /hello/:name', 'POST /todos/import', 'WS /chat']);
+    const post = cg.getNodesByKind('route').find((r) => r.name === 'POST /todos/import')!;
+    expect(cg.getOutgoingEdges(post.id).map((e) => cg.getNode(e.target)!.name)).toContain('importTodos');
+  });
+});
diff --git a/__tests__/vbnet-bare-member-scope.test.ts b/__tests__/vbnet-bare-member-scope.test.ts
new file mode 100644
index 0000000000..a2601671b1
--- /dev/null
+++ b/__tests__/vbnet-bare-member-scope.test.ts
@@ -0,0 +1,100 @@
+/**
+ * A VB.NET call with no receiver — or with `Me` / `MyClass` / `MyBase`,
+ * which the extractor drops — is a member of the type it is written in, of a
+ * type around it, or of one they inherit; a `Module`'s members are reached
+ * from anywhere. Never another class's same-named member, however near its
+ * file: SCrawler's `{ToString()}` in the Instagram `UserData` (which
+ * `Inherits UserDataBase`) went to a nearby structure's `ToString`.
+ */
+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-vb-bare-'));
+  const files: Record<string, string> = {
+    'API/Base/UserDataBase.vb': `Namespace API.Base
+    Friend MustInherit Class UserDataBase
+        Public Overrides Function ToString() As String
+            Return "user"
+        End Function
+        Protected Sub Refresh()
+        End Sub
+    End Class
+End Namespace
+`,
+    'API/Instagram/MediaItem.vb': `Namespace API.Instagram
+    Friend Class MediaItem
+        Public Overrides Function ToString() As String
+            Return "media"
+        End Function
+        Friend Sub Refresh()
+        End Sub
+    End Class
+End Namespace
+`,
+    'API/Instagram/UserData.vb': `Namespace API.Instagram
+    Friend Class UserData : Inherits API.Base.UserDataBase
+        Friend Sub SetTagsLimit()
+            Dim aStr$ = $"Enter the number of posts from user {ToString()}"
+            Me.Refresh()
+            Log(aStr)
+        End Sub
+        Private Class Counter
+            Friend Sub Tick()
+                Report()
+            End Sub
+        End Class
+        Private Shared Sub Report()
+        End Sub
+    End Class
+End Namespace
+`,
+    'Tools/Logger.vb': `Public Module Logger
+    Public Sub Log(ByVal Text As String)
+    End Sub
+End Module
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of one method. */
+function callsOf(file: string, qualifiedName: string): string[] {
+  const from = cg.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName)!;
+  return cg
+    .getOutgoingEdgesFrom([from.id])
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('VB.NET receiver-less calls', () => {
+  it('reach the members the class inherits, not a nearer class’s, and a module’s', () => {
+    expect(callsOf('API/Instagram/UserData.vb', 'API.Instagram::UserData::SetTagsLimit')).toEqual([
+      'API.Base::UserDataBase::Refresh',
+      'API.Base::UserDataBase::ToString',
+      'Logger::Log',
+    ]);
+  });
+
+  it('reach a member of the class around a nested one', () => {
+    expect(callsOf('API/Instagram/UserData.vb', 'API.Instagram::UserData::Counter::Tick')).toEqual([
+      'API.Instagram::UserData::Report',
+    ]);
+  });
+});
diff --git a/__tests__/vbnet-instance-member-refs.test.ts b/__tests__/vbnet-instance-member-refs.test.ts
new file mode 100644
index 0000000000..b7199a1604
--- /dev/null
+++ b/__tests__/vbnet-instance-member-refs.test.ts
@@ -0,0 +1,338 @@
+/**
+ * VB.NET: a field or property read or written through a value — a parameter
+ * (`x.Normal = 3`), a local (`h.Normal`), a field (`_h.Title`), `Me._h.Normal`,
+ * `MyBase.Count`, a `With` block's `.Value`, an object initializer's
+ * `.Switch` — is a use of the member of the type that value is declared as.
+ * Before, calls through a typed receiver linked (#2351) and reads through a
+ * type's name (#2305), but no read through a value, so `codegraph callers` on
+ * an instance field or property listed almost none of its uses.
+ *
+ * The receiver is typed by the rules calls use — its declaration (`As`, `As
+ * New`, a cast, a `For Each` over a typed collection, a type parameter's
+ * constraint, a Module variable), the namespaces around the read, what the
+ * type inherits — and a path (`Me._h.Normal`, `n.Child.Value`) one link at a
+ * time. An outside type, `Object`, an untyped name or an index links nothing:
+ * a value's member is never guessed by name.
+ */
+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';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+
+let root = '';
+let cg: CodeGraph;
+
+const files: Record<string, string> = {
+  // The issue's two files, verbatim.
+  'Holder.vb': `Public Class Holder
+    Public Shared SharedCache As Integer
+    Public Normal As Integer
+    Public Property Title As String
+    Public Sub EndSession()
+    End Sub
+End Class
+`,
+  'User.vb': `Public Class User
+    Private _h As New Holder()
+    Public Sub Run(x As Holder)
+        Dim b As Integer = x.SharedCache
+        Dim n As Integer = x.Normal
+        x.Normal = 3
+        Dim t As String = _h.Title
+        Me._h.Normal = 4
+        Dim h As New Holder()
+        Dim m As Integer = h.Normal
+        x.EndSession()
+    End Sub
+End Class
+`,
+  'Node.vb': `Public Class Node
+    Public Value As Integer
+    Public Property Child As Node
+    Public Items As New List(Of String)
+    Public Event Changed As EventHandler
+    Public Sub Reset()
+    End Sub
+    Public Function Describe() As String
+        Return ""
+    End Function
+End Class
+`,
+  // Me, MyBase, a path through members, an inherited member; an index into a
+  // field, a method named without parentheses, an event, AddressOf.
+  'Views.vb': `Public Class BaseView
+    Protected Caption As String
+    Public Overridable Property Count As Integer
+End Class
+
+Public Class DerivedView
+    Inherits BaseView
+    Private _node As Node
+    Public Sub New(caption As String)
+        Me.Caption = caption
+    End Sub
+    Public Overrides Property Count As Integer
+        Get
+            Return MyBase.Count + Me._node.Child.Value
+        End Get
+        Set(value As Integer)
+            MyBase.Count = value
+        End Set
+    End Property
+    Public Sub Watch(n As Node)
+        Dim first = n.Items(0)
+        Dim text = n.Describe
+        AddHandler n.Changed, AddressOf OnChanged
+        Dim reset As Action = AddressOf n.Reset
+        Dim nodes As New List(Of Node)
+        For Each child In nodes
+            child.Value = 1
+        Next
+    End Sub
+    Private Sub OnChanged(sender As Object, e As EventArgs)
+    End Sub
+End Class
+`,
+  // With blocks (nested, through Me, through a cast), an object initializer, a
+  // cast; an anonymous type declares its own members.
+  'Builder.vb': `Public Class Builder
+    Private _node As New Node()
+    Property Seed As New Node With {.Value = 7}
+    Public Sub Fill(o As Object, n As Node)
+        With n
+            .Value = 1
+            Dim d = .Describe()
+            With .Child
+                .Reset()
+            End With
+        End With
+        With Me._node
+            .Child = Nothing
+        End With
+        With DirectCast(o, Node)
+            .Items.Clear()
+        End With
+        Dim v = TryCast(o, Node).Value
+        Dim anonymous = New With {.Value = 2}
+    End Sub
+End Class
+`,
+  // A Module variable, a type parameter's constraint.
+  'Globals.vb': `Public Module Globals
+    Public Current As Node
+End Module
+`,
+  'Repo.vb': `Public Class Repo(Of T As Node)
+    Private _item As T
+    Public Function Peek() As Integer
+        Return _item.Value + Current.Value
+    End Function
+End Class
+`,
+  // A field's type is the one the namespace around it declares.
+  'Sites/Reddit.vb': `Namespace API.Reddit
+    Friend Class SiteSettings
+        Friend Property Header As String
+    End Class
+    Friend Class UserData
+        Private _settings As SiteSettings
+        Friend Function Key() As String
+            Return _settings.Header
+        End Function
+    End Class
+End Namespace
+`,
+  'Sites/Twitter.vb': `Namespace API.Twitter
+    Friend Class SiteSettings
+        Friend Property Header As String
+    End Class
+End Namespace
+`,
+  // staxrip's encoder options: a property an initializer sets up, written later.
+  'Encoder.vb': `Public MustInherit Class CommandLineParam
+    Property Switch As String
+    Property Text As String
+End Class
+
+Public Class BoolParam
+    Inherits CommandLineParam
+    Property Value As Boolean
+End Class
+
+Public Class x265Enc
+    Property ConstVBV As New BoolParam With {
+        .Switch = "--const-vbv",
+        .Text = "Enable VBV algorithm to be consistent across runs"}
+    Sub Apply()
+        ConstVBV.Value = False
+    End Sub
+End Class
+`,
+  // "Color Color": a value named like its type reads an instance member
+  // through itself, a Shared member and an Enum case through the type. And
+  // staxrip names enums in lower case.
+  'Theme.vb': `Public Class Theme
+    Public Shared Current As Theme
+    Public Const Version As String = "1"
+    Public Property General As String
+End Class
+
+Public Enum Mode
+    Fast
+End Enum
+
+Public Enum x265RateMode
+    Bitrate
+End Enum
+
+Public Class Painter
+    Public Property Mode As Mode
+    Public Sub Paint(theme As Theme)
+        Dim g = theme.General
+        Dim c = theme.Current
+        Dim v = theme.Version
+        Dim f = Mode.Fast
+        Dim r = x265RateMode.Bitrate
+    End Sub
+End Class
+`,
+  // What links nothing: an outside type, Object, an untyped name, an index's
+  // element; and a parameter named like a type is read as the parameter.
+  'Lookalike.vb': `Public Class Lookalike
+    Public Length As Integer
+    Public Count As Integer
+    Public Value As Integer
+End Class
+`,
+  'Negatives.vb': `Public Class Negatives
+    Public Sub Go(s As String, o As Object, list As List(Of Node), ByVal untyped)
+        Dim a = s.Length
+        Dim b = list.Count
+        Dim c = o.Value
+        Dim d = untyped.Value
+        Dim e = list(0).Value
+    End Sub
+    Public Sub Shadowed(holder As Node)
+        Dim f = Holder.SharedCache
+        Dim g = holder.Value
+    End Sub
+End Class
+`,
+};
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadGrammarsForLanguages(['vbnet']);
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vb-instance-'));
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function nodeId(qualifiedName: string): string {
+  const found = cg.getNodesInFiles(Object.keys(files)).filter((n) => n.qualifiedName === qualifiedName);
+  if (found.length !== 1) throw new Error(`${found.length} nodes named ${qualifiedName}`);
+  return found[0]!.id;
+}
+
+/** The qualified names of what links to `qualifiedName` with an edge of `kind`, one per edge. */
+function linkedFrom(qualifiedName: string, kind: 'references' | 'calls'): string[] {
+  return cg
+    .getIncomingEdgesTo([nodeId(qualifiedName)], [kind])
+    .map((e) => cg.getNode(e.source)!.qualifiedName)
+    .sort();
+}
+
+describe('VB.NET members read and written through a value', () => {
+  it('link each read and write of the issue to the member', () => {
+    expect(linkedFrom('Holder::SharedCache', 'references')).toEqual(['User::Run']);
+    expect(linkedFrom('Holder::Normal', 'references')).toEqual(['User::Run', 'User::Run', 'User::Run', 'User::Run']);
+    expect(linkedFrom('Holder::Title', 'references')).toEqual(['User::Run']);
+    expect(linkedFrom('Holder::EndSession', 'calls')).toEqual(['User::Run']);
+    expect(cg.getCallers(nodeId('Holder::Normal')).map((c) => c.node.qualifiedName)).toEqual(['User::Run']);
+  });
+
+  it('link the member alone: the type is not written at the read', () => {
+    expect(linkedFrom('Holder', 'references')).toEqual([]);
+    expect(linkedFrom('Node', 'references')).toEqual([]);
+  });
+
+  it('read through Me, MyBase and a path of members, one link at a time', () => {
+    expect(linkedFrom('BaseView::Caption', 'references')).toEqual(['DerivedView::New']);
+    expect(linkedFrom('BaseView::Count', 'references')).toEqual(['DerivedView::Count', 'DerivedView::Count']);
+    expect(linkedFrom('DerivedView::_node', 'references')).toEqual(['DerivedView::Count']);
+    expect(linkedFrom('Node::Child', 'references')).toEqual(['Builder::Fill', 'Builder::Fill', 'DerivedView::Count']);
+  });
+
+  it('index a field, run a method named without parentheses, name an event and a method', () => {
+    expect(linkedFrom('Node::Items', 'references')).toEqual(['Builder::Fill', 'DerivedView::Watch']);
+    expect(linkedFrom('Node::Describe', 'calls')).toEqual(['Builder::Fill', 'DerivedView::Watch']);
+    expect(linkedFrom('Node::Changed', 'references')).toEqual(['DerivedView::Watch']);
+    expect(linkedFrom('Node::Reset', 'references')).toEqual(['DerivedView::Watch']);
+    expect(linkedFrom('Node::Reset', 'calls')).toEqual(['Builder::Fill']);
+  });
+
+  it('read through With blocks, an object initializer, a cast, a loop variable, a Module variable and a type parameter', () => {
+    expect(linkedFrom('Node::Value', 'references')).toEqual([
+      'Builder::Fill', 'Builder::Fill', 'Builder::Seed', 'DerivedView::Count', 'DerivedView::Watch',
+      'Negatives::Shadowed', 'Repo::Peek', 'Repo::Peek',
+    ]);
+  });
+
+  it('read the type the namespace around the declaration sees', () => {
+    expect(linkedFrom('API.Reddit::SiteSettings::Header', 'references')).toEqual(['API.Reddit::UserData::Key']);
+    expect(linkedFrom('API.Twitter::SiteSettings::Header', 'references')).toEqual([]);
+  });
+
+  it('link an initializer and a later write to the members the type declares or inherits', () => {
+    expect(linkedFrom('CommandLineParam::Switch', 'references')).toEqual(['x265Enc::ConstVBV']);
+    expect(linkedFrom('CommandLineParam::Text', 'references')).toEqual(['x265Enc::ConstVBV']);
+    expect(linkedFrom('BoolParam::Value', 'references')).toEqual(['x265Enc::Apply']);
+  });
+
+  it('read an instance member of a value named like its type through the value, a Shared one through the type', () => {
+    expect(linkedFrom('Theme::General', 'references')).toEqual(['Painter::Paint']);
+    expect(linkedFrom('Theme::Current', 'references')).toEqual(['Painter::Paint']);
+    expect(linkedFrom('Theme::Version', 'references')).toEqual(['Painter::Paint']);
+    // `theme.Current` and the Const `theme.Version`; not `theme.General`.
+    expect(linkedFrom('Theme', 'references')).toEqual(['Painter::Paint', 'Painter::Paint']);
+    expect(linkedFrom('Mode::Fast', 'references')).toEqual(['Painter::Paint']);
+    expect(linkedFrom('Mode', 'references')).toEqual(['Painter::Paint']);
+  });
+
+  it('read through a type whose name is in lower case', () => {
+    expect(linkedFrom('x265RateMode::Bitrate', 'references')).toEqual(['Painter::Paint']);
+    expect(linkedFrom('x265RateMode', 'references')).toEqual(['Painter::Paint']);
+  });
+
+  it('send no read for a qualified type after New, which the grammar splits into members', () => {
+    // `New System.Windows.Forms.ListBox()` parses as `.Windows.Forms` read through `New System`.
+    const reads = extractFromSource('Designer.vb', `Public Class Form1
+    Sub InitializeComponent()
+        Me.ListBox1 = New System.Windows.Forms.ListBox()
+        Dim h = New Sites.Holder
+        Dim n = New Holder().Normal
+        Dim p = DirectCast(sender, System.Windows.Forms.Control).Parent
+    End Sub
+End Class
+`).unresolvedReferences.filter((r) => r.referenceKind === 'references').map((r) => r.referenceName);
+    expect(reads).toEqual(['Me.ListBox1', '{Holder}.Normal']);
+  });
+
+  it('link nothing through an outside type, Object, an untyped name or an index', () => {
+    for (const member of ['Lookalike::Length', 'Lookalike::Count', 'Lookalike::Value']) {
+      expect(linkedFrom(member, 'references')).toEqual([]);
+    }
+    expect(linkedFrom('Holder::SharedCache', 'references')).not.toContain('Negatives::Shadowed');
+  });
+});
diff --git a/__tests__/vbnet-keyword-prefixed-names.test.ts b/__tests__/vbnet-keyword-prefixed-names.test.ts
new file mode 100644
index 0000000000..271e1dd642
--- /dev/null
+++ b/__tests__/vbnet-keyword-prefixed-names.test.ts
@@ -0,0 +1,242 @@
+/**
+ * VB.NET names that begin with a keyword.
+ *
+ * The vendored grammar lexed the member modifiers (`Public`, `Shared`, `Dim`,
+ * `Const`, …) as one token that outranked identifiers, so the lexer stopped at
+ * the end of a modifier spelled at the start of a name: `Public SharedCache As
+ * Integer` indexed a field `Cache`, `Public Dimension` a field `ension`,
+ * `Private FriendlyNameValue` (staxrip) a field `lyNameValue`, and `Public
+ * Shared Shared1` lost the field to a parse error. Inside a method `Dim` and
+ * `Const` did the same: `ConstVBV.Value = False` (staxrip) parsed as a
+ * declaration `Const VBV`, and `ConstructPath()` as `Const ructPath()`. And
+ * `Sub NewItem()` lexed as the constructor `Sub New` followed by `Item`.
+ *
+ * Two things the old lexing got right only by accident are pinned too: the
+ * attribute lines above a top-level declaration belong to it, and `Option`
+ * lines may follow a comment banner.
+ */
+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';
+import { extractFromSource } from '../src/extraction';
+import { getParser, initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+
+// The issue's class, verbatim.
+const HOLDER = `Public Class Holder
+    Public Shared Shared1 As Integer
+    Public Shared SharedCache As Integer
+    Public Dimension As Integer
+    Public Endpoint As String
+    Public PublicKey As String
+    Private Property1 As Integer
+    Public Shared Function SharedHelper() As Integer
+        Return 1
+    End Function
+    Public Sub EndSession()
+    End Sub
+    Public Normal As Integer
+End Class
+`;
+
+const MODIFIERS = [
+  'Public', 'Private', 'Protected', 'Friend', 'ReadOnly', 'WriteOnly', 'Shared', 'Shadows', 'MustInherit',
+  'NotInheritable', 'Overrides', 'NotOverridable', 'Overridable', 'Overloads', 'WithEvents', 'Widening',
+  'Narrowing', 'Partial', 'Async', 'Iterator', 'Dim', 'Const', 'Static', 'MustOverride',
+];
+
+function namesOf(source: string, kind: string): string[] {
+  return extractFromSource('Probe.vb', source).nodes.filter((n) => n.kind === kind).map((n) => n.name);
+}
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadGrammarsForLanguages(['vbnet']);
+});
+
+describe('VB.NET names that begin with a keyword', () => {
+  it('index the fields of the issue under their whole names', () => {
+    expect(namesOf(HOLDER, 'field'))
+      .toEqual(['Shared1', 'SharedCache', 'Dimension', 'Endpoint', 'PublicKey', 'Property1', 'Normal']);
+    expect(namesOf(HOLDER, 'method')).toEqual(['SharedHelper', 'EndSession']);
+  });
+
+  it('keep every member modifier out of a name it begins, in any case', () => {
+    const source = [
+      'Public Class Fields',
+      ...MODIFIERS.flatMap((m) => [
+        `    Private ${m}Field As Integer`,
+        `    PUBLIC SHARED ${m.toUpperCase()}UPPER As Integer`,
+        `    friend ${m.toLowerCase()}lower As Integer`,
+      ]),
+      'End Class',
+      '',
+    ].join('\n');
+    expect(namesOf(source, 'field')).toEqual(
+      MODIFIERS.flatMap((m) => [`${m}Field`, `${m.toUpperCase()}UPPER`, `${m.toLowerCase()}lower`]),
+    );
+  });
+
+  it('still read the modifiers themselves', () => {
+    const source = `Public Class Settings
+    Public Shared ReadOnly Limit As Integer = 1
+    Public Shared SharedCache As Integer
+    Protected Friend Inherited As Integer
+    Private Protected Derived As Integer
+    Friend FriendlyName As String
+    Private Const ConstantRate As Integer = 2
+End Class
+`;
+    const fields = new Map(extractFromSource('Probe.vb', source).nodes
+      .filter((n) => n.kind === 'field' || n.kind === 'constant')
+      .map((n) => [n.name, n]));
+    expect([...fields.keys()]).toEqual(['Limit', 'SharedCache', 'Inherited', 'Derived', 'FriendlyName', 'ConstantRate']);
+    expect(fields.get('SharedCache')?.isStatic).toBe(true);
+    expect(fields.get('Inherited')?.visibility).toBe('protected');
+    // `Private Protected` was one token that matched no visibility, so it read as public.
+    expect(fields.get('Derived')?.visibility).toBe('private');
+    expect(fields.get('FriendlyName')?.visibility).toBe('internal');
+  });
+
+  it('tell Sub New from a method whose name begins with New', () => {
+    const source = `Public Class Menu
+    Public Sub New()
+    End Sub
+    Shared Sub New()
+    End Sub
+    Private Sub NewFromDefaultsToolStripMenuItem_Click() Handles NewFromDefaultsToolStripMenuItem.Click
+    End Sub
+    Public Sub NewItem()
+    End Sub
+End Class
+`;
+    expect(namesOf(source, 'method')).toEqual(['New', 'New', 'NewFromDefaultsToolStripMenuItem_Click', 'NewItem']);
+  });
+
+  it('keep a statement that begins with Dim or Const a statement', () => {
+    const source = `Public Class Encoder
+    Private ConstVBV As New BoolParam()
+    Sub Apply()
+        ConstVBV.Value = False
+        ConstVBV.Reset()
+        ConstructPath()
+        DimSomething()
+        Constants.Reload()
+        Dim constructor As Object = Nothing
+        constructor = Nothing
+    End Sub
+End Class
+`;
+    const result = extractFromSource('Probe.vb', source);
+    expect(result.nodes.filter((n) => n.kind === 'field').map((n) => n.name)).toEqual(['ConstVBV']);
+    const refs = result.unresolvedReferences
+      .filter((r) => r.referenceKind === 'calls' || r.referenceKind === 'references')
+      .map((r) => `${r.referenceKind} ${r.referenceName}`);
+    expect(refs).toEqual([
+      'references ConstVBV.Value',
+      'calls ConstVBV.Reset',
+      'calls ConstructPath',
+      'calls DimSomething',
+      'calls Constants.Reload',
+    ]);
+  });
+});
+
+describe('VB.NET top-level lines', () => {
+  it('give a declaration every attribute line above it', () => {
+    const source = `Imports System
+
+<Serializable>
+<ComVisible(False)>
+Public Class Settings
+End Class
+
+<Serializable>
+Class Plain
+End Class
+`;
+    const classes = extractFromSource('Probe.vb', source).nodes.filter((n) => n.kind === 'class');
+    expect(classes.map((n) => [n.name, n.startLine])).toEqual([['Settings', 3], ['Plain', 8]]);
+  });
+
+  it('parse Option lines after a comment banner', () => {
+    const source = `'------------------------------------------------------------------------------
+' <auto-generated>
+'     This code was generated by a tool.
+' </auto-generated>
+'------------------------------------------------------------------------------
+
+Option Strict On
+Option Explicit On
+
+Namespace My.Resources
+    Friend Module Resources
+    End Module
+End Namespace
+`;
+    const tree = getParser('vbnet')!.parse(source)!;
+    try {
+      expect(tree.rootNode.hasError).toBe(false);
+      expect(tree.rootNode.descendantsOfType('option_statement')).toHaveLength(2);
+    } finally {
+      tree.delete();
+    }
+  });
+});
+
+describe('VB.NET references to keyword-prefixed names', () => {
+  let root = '';
+  let cg: CodeGraph;
+  const files: Record<string, string> = {
+    'Holder.vb': HOLDER.replace('    Public Normal As Integer\n', `    Public Normal As Integer
+    Public Sub NewItem()
+    End Sub
+`),
+    'Constants.vb': `Public Module Constants
+    Public Sub Reload()
+    End Sub
+End Module
+`,
+    'User.vb': `Public Class User
+    Public Sub Run(x As Holder)
+        Dim a As Integer = Holder.Dimension
+        Holder.SharedCache = 2
+        Dim c As Integer = Holder.Shared1 + Holder.SharedHelper()
+        Dim h As New Holder()
+        h.NewItem()
+        Constants.Reload()
+    End Sub
+End Class
+`,
+  };
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vb-keyword-names-'));
+    for (const [rel, content] of Object.entries(files)) fs.writeFileSync(path.join(root, rel), content);
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  function linkedFrom(qualifiedName: string, kind: 'references' | 'calls'): string[] {
+    const found = cg.getNodesInFiles(Object.keys(files)).filter((n) => n.qualifiedName === qualifiedName);
+    expect(found.map((n) => n.qualifiedName)).toEqual([qualifiedName]);
+    return cg.getIncomingEdgesTo([found[0]!.id], [kind]).map((e) => cg.getNode(e.source)!.qualifiedName);
+  }
+
+  it('link reads and writes through the class to the field', () => {
+    expect(linkedFrom('Holder::Dimension', 'references')).toEqual(['User::Run']);
+    expect(linkedFrom('Holder::SharedCache', 'references')).toEqual(['User::Run']);
+    expect(linkedFrom('Holder::Shared1', 'references')).toEqual(['User::Run']);
+  });
+
+  it('link calls to methods whose names begin with a keyword', () => {
+    expect(linkedFrom('Holder::SharedHelper', 'calls')).toEqual(['User::Run']);
+    expect(linkedFrom('Holder::NewItem', 'calls')).toEqual(['User::Run']);
+    expect(linkedFrom('Constants::Reload', 'calls')).toEqual(['User::Run']);
+  });
+});
diff --git a/__tests__/vbnet-member-access.test.ts b/__tests__/vbnet-member-access.test.ts
new file mode 100644
index 0000000000..668cc18aac
--- /dev/null
+++ b/__tests__/vbnet-member-access.test.ts
@@ -0,0 +1,122 @@
+/**
+ * VB.NET's extractor keeps only the last name of a member access, so
+ * `Me.Panel.Controls.Add(x)` and `New System.Drawing.Size(1, 2)` reach the
+ * resolver as bare `Add` / `Size`. A member reached that way must match what
+ * the line writes before the dot: `Me` / `MyBase` / `MyClass`, the member's
+ * own type or module (`Logger.Log(…)`), or a service locator's type argument
+ * (`GetService(Of Notifier).Notify()`). SCrawler's designer code sent
+ * `New System.Drawing.Size(…)` to a nested enum's `Size` case 713 times and
+ * `Controls.Add(…)` to a collection class's `Add` 547 times.
+ *
+ * The name read is the one the reference starts at (or after) — in
+ * `Me.Size = New System.Drawing.Size(…)` that is `System.Drawing.Size`, not
+ * `Me.Size` — and a type is one its written qualifier names: staxrip's
+ * designer `New System.Drawing.Point(…)` went to a nested `Point` class 550
+ * times. A type nested in a class is named bare only inside it.
+ */
+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-vb-member-'));
+  const files: Record<string, string> = {
+    'Editors/UsersInfoForm.vb': `Namespace Editors
+    Friend Class UsersInfoForm
+        Private Enum EComparers
+            Name
+            Size
+        End Enum
+    End Class
+End Namespace
+`,
+    'Collections/DataColorCollection.vb': `Friend Class DataColorCollection
+    Friend Sub Add(ByVal Item As Object)
+    End Sub
+End Class
+`,
+    'Services/Notifier.vb': `Public Class Notifier
+    Public Sub Notify(ByVal Text As String)
+    End Sub
+End Class
+`,
+    'Logger.vb': `Public Module Logger
+    Public Sub Log(ByVal Text As String)
+    End Sub
+End Module
+`,
+    'MainForm.vb': `Public Class MainForm
+    Private Sub InitializeComponent()
+        Me.Panel.Controls.Add(Me.Button1)
+        Me.Panel.Size = New System.Drawing.Size(184, 25)
+        Logger.Log("ready")
+        Application.GetService(Of Notifier).Notify("ready")
+        Me.Refresh()
+    End Sub
+
+    Private Sub Refresh()
+    End Sub
+End Class
+`,
+    'UI/ButtonEx.vb': `Public Class ButtonEx
+    Public Class SymbolDrawer
+        Public Class Point
+        End Class
+        Public Sub Draw()
+            Dim p As New Point()
+        End Sub
+    End Class
+End Class
+`,
+    'Forms/AppsForm.vb': `Public Class AppsForm
+    Private Sub InitializeComponent()
+        Me.Size = New System.Drawing.Size(315, 205)
+        Me.ToolStrip.Location = New System.Drawing.Point(473, 10)
+        Me.lDescription.Location = New Point(4, 285)
+    End Sub
+End Class
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('VB.NET member access', () => {
+  it('reaches a member only through what the line names', () => {
+    const ids = cg.getNodesInFile('MainForm.vb').map((n) => n.id);
+    const targets = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg.getNode(e.target)!.qualifiedName)
+      .sort();
+    expect(targets).not.toContain('Editors::UsersInfoForm::EComparers::Size');
+    expect(targets).not.toContain('DataColorCollection::Add');
+    expect(targets).toContain('Logger::Log');
+    expect(targets).toContain('Notifier::Notify');
+    expect(targets).toContain('MainForm::Refresh');
+  });
+
+  it('reads the name the reference starts at, and a type its qualifier names', () => {
+    const targetsOf = (file: string) => cg
+      .getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id))
+      .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+      .map((e) => `${e.kind} ${cg.getNode(e.target)!.qualifiedName}`)
+      .sort();
+    // `Me.Size = New System.Drawing.Size(…)`, `New System.Drawing.Point(…)`, `New Point(…)` outside ButtonEx.
+    expect(targetsOf('Forms/AppsForm.vb')).toEqual([]);
+    expect(targetsOf('UI/ButtonEx.vb')).toEqual(['instantiates ButtonEx::SymbolDrawer::Point']);
+  });
+});
diff --git a/__tests__/vbnet-member-bodies.test.ts b/__tests__/vbnet-member-bodies.test.ts
new file mode 100644
index 0000000000..8c280a5b55
--- /dev/null
+++ b/__tests__/vbnet-member-bodies.test.ts
@@ -0,0 +1,209 @@
+/**
+ * VB.NET member bodies the extractor used to skip:
+ *
+ *  - A `Structure` lists each member as its own `body` field, so reading the
+ *    field returned only the first member: SCrawler's `UserMedia` indexed its
+ *    nested `States` enum (declared first) and nothing else, and a structure
+ *    that opened with a field indexed no members at all.
+ *  - A property's `Get` / `Set` blocks, its `= initializer` and its
+ *    `As New T` were never walked, nor a `Custom Event`'s accessors.
+ *  - A field's `= initializer` and `As New T` were never walked.
+ *
+ * The calls, instantiations and reads in those places belong to the member
+ * that declares them.
+ */
+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';
+import type { Node } from '../src/types';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vb-bodies-'));
+  const files: Record<string, string> = {
+    'Helper.vb': `Public Class Helper
+    Public Sub New(ByVal n As Integer)
+    End Sub
+    Public Shared Function Compute(ByVal n As Integer) As Integer
+        Return n
+    End Function
+    Public Shared Sub Store(ByVal n As Integer)
+    End Sub
+    Public Shared Function Seed() As Integer
+        Return 1
+    End Function
+    Public Shared Function Format(ByVal o As Object) As String
+        Return ""
+    End Function
+    Public Shared Sub Log(ByVal s As String)
+    End Sub
+    Public Shared Sub Attach(ByVal h As EventHandler)
+    End Sub
+End Class
+`,
+    'Widget.vb': `Public Class Widget
+End Class
+`,
+    'UserMedia.vb': `Public Structure UserMedia
+    Public State As States
+    Private Count As Integer
+    Public Enum States
+        Unknown
+        Downloaded
+    End Enum
+    Public ReadOnly Property Name As String
+        Get
+            Return Helper.Format(State)
+        End Get
+    End Property
+    Public Sub New(ByVal s As States)
+        State = s
+        Helper.Log("created")
+    End Sub
+    Public Function IsDone() As Boolean
+        Return State = States.Downloaded
+    End Function
+End Structure
+`,
+    'Box.vb': `Public Class Box
+    Private _x As Integer
+    Private _items As New Widget
+    Private _helper As Helper = New Helper(1)
+    Private Shared ReadOnly Def As Integer = Helper.Compute(3), Other As Integer = Helper.Seed()
+    Public Property Value As Integer
+        Get
+            Return Helper.Compute(_x)
+        End Get
+        Set(ByVal v As Integer)
+            Helper.Store(v)
+            _x = v
+        End Set
+    End Property
+    Public Property Auto As Integer = Helper.Seed()
+    Public ReadOnly Property Lst As New Widget
+    Public Custom Event Changed As EventHandler
+        AddHandler(ByVal value As EventHandler)
+            Helper.Attach(value)
+        End AddHandler
+        RemoveHandler(ByVal value As EventHandler)
+        End RemoveHandler
+        RaiseEvent(ByVal sender As Object, ByVal e As EventArgs)
+        End RaiseEvent
+    End Event
+End Class
+`,
+    // The 1.6.2 receiver gate must hold in the newly walked places too:
+    // `Me.Panel.Controls.Add(…)` and `New System.Drawing.Size(…)` name no
+    // project member.
+    'Collections/DataColorCollection.vb': `Friend Class DataColorCollection
+    Friend Sub Add(ByVal Item As Object)
+    End Sub
+End Class
+`,
+    'Editors/UsersInfoForm.vb': `Friend Class UsersInfoForm
+    Private Enum EComparers
+        Name
+        Size
+    End Enum
+End Class
+`,
+    'MainForm.vb': `Public Class MainForm
+    Private ReadOnly DefaultSize As System.Drawing.Size = New System.Drawing.Size(184, 25)
+    Public ReadOnly Property Ready As Boolean
+        Get
+            Me.Panel.Controls.Add(Me.Button1)
+            Return True
+        End Get
+    End Property
+End Class
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function member(file: string, qualifiedName: string): Node {
+  const node = cg.getNodesInFile(file).find((n) => n.qualifiedName === qualifiedName);
+  expect(node, `${qualifiedName} in ${file}`).toBeDefined();
+  return node!;
+}
+
+/** `kind` edges leaving `node`, as target qualified names. */
+function targets(node: Node, kind: string): string[] {
+  return cg
+    .getOutgoingEdgesFrom([node.id])
+    .filter((e) => e.kind === kind)
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('VB.NET member bodies', () => {
+  it('indexes every member of a Structure, not just the first', () => {
+    const struct = member('UserMedia.vb', 'UserMedia');
+    expect(struct.kind).toBe('struct');
+    const contained = cg
+      .getOutgoingEdgesFrom([struct.id])
+      .filter((e) => e.kind === 'contains')
+      .map((e) => cg.getNode(e.target)!)
+      .map((n) => `${n.kind} ${n.qualifiedName}`)
+      .sort();
+    expect(contained).toEqual([
+      'enum UserMedia::States',
+      'field UserMedia::Count',
+      'field UserMedia::State',
+      'method UserMedia::IsDone',
+      'method UserMedia::New',
+      'property UserMedia::Name',
+    ]);
+    expect(member('UserMedia.vb', 'UserMedia::States::Downloaded').kind).toBe('enum_member');
+    expect(targets(member('UserMedia.vb', 'UserMedia::New'), 'calls')).toEqual(['Helper::Log']);
+  });
+
+  it("attributes a property's Get and Set blocks to the property", () => {
+    expect(targets(member('Box.vb', 'Box::Value'), 'calls')).toEqual(['Helper::Compute', 'Helper::Store']);
+    expect(targets(member('UserMedia.vb', 'UserMedia::Name'), 'calls')).toEqual(['Helper::Format']);
+  });
+
+  it("walks a property's initializer and its As New", () => {
+    expect(targets(member('Box.vb', 'Box::Auto'), 'calls')).toEqual(['Helper::Seed']);
+    expect(targets(member('Box.vb', 'Box::Lst'), 'instantiates')).toEqual(['Widget']);
+  });
+
+  it("walks each field's initializer and its As New, per declarator", () => {
+    expect(targets(member('Box.vb', 'Box::Def'), 'calls')).toEqual(['Helper::Compute']);
+    expect(targets(member('Box.vb', 'Box::Other'), 'calls')).toEqual(['Helper::Seed']);
+    expect(targets(member('Box.vb', 'Box::_items'), 'instantiates')).toEqual(['Widget']);
+    expect(targets(member('Box.vb', 'Box::_helper'), 'instantiates')).toEqual(['Helper']);
+  });
+
+  it("attributes a Custom Event's accessors to the event", () => {
+    expect(targets(member('Box.vb', 'Box::Changed'), 'calls')).toEqual(['Helper::Attach']);
+  });
+
+  it('keeps the class out of what its members do', () => {
+    expect(targets(member('Box.vb', 'Box'), 'calls')).toEqual([]);
+    expect(targets(member('Box.vb', 'Box'), 'instantiates')).toEqual([]);
+  });
+
+  it('still links nothing through a receiver no name resolves', () => {
+    const ids = cg.getNodesInFile('MainForm.vb').map((n) => n.id);
+    const linked = cg
+      .getOutgoingEdgesFrom(ids)
+      .filter((e) => e.kind !== 'contains')
+      .map((e) => cg.getNode(e.target)!.qualifiedName);
+    expect(linked).not.toContain('DataColorCollection::Add');
+    expect(linked).not.toContain('UsersInfoForm::EComparers::Size');
+  });
+});
diff --git a/__tests__/vbnet-project-ties.test.ts b/__tests__/vbnet-project-ties.test.ts
new file mode 100644
index 0000000000..9d8e2fcc0e
--- /dev/null
+++ b/__tests__/vbnet-project-ties.test.ts
@@ -0,0 +1,143 @@
+/**
+ * A VB.NET solution often carries the same type in two projects: staxrip's
+ * main app and its separate AutoCrop tool (its own AutoCrop.vbproj) each
+ * declare `ColorHSL`, `FrameServerFactory` and `DirectFrameServer`. A call
+ * in the main app means its own project's copy — about 90 calls such as
+ * `_backColor.AddLuminance(0.025)` went to the AutoCrop copy, whichever was
+ * indexed first. Between equally good guesses, the caller's project decides,
+ * then the nearer directory; when neither does, there is no guess.
+ */
+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;
+
+const VBPROJ = `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+  </PropertyGroup>
+</Project>
+`;
+
+const COLOR_HSL = `Public Class ColorHSL
+    Public Sub New(ByVal h As Double, ByVal s As Double, ByVal l As Double, ByVal a As Double)
+    End Sub
+    Public Function AddLuminance(ByVal offset As Single) As ColorHSL
+        Return Me
+    End Function
+End Class
+`;
+
+const FRAME_SERVER_FACTORY = `Public Class FrameServerFactory
+    Public Shared Function Create(ByVal path As String) As Object
+        Return Nothing
+    End Function
+End Class
+`;
+
+const HELPER = `Public Class Helper
+    Public Sub Run()
+    End Sub
+End Class
+`;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vb-ties-'));
+  const files: Record<string, string> = {
+    'Source/StaxRip.vbproj': VBPROJ,
+    'Source/Tools/AutoCrop/AutoCrop.vbproj': VBPROJ,
+    'Source/Tools/AutoCrop/Main.vb': COLOR_HSL + FRAME_SERVER_FACTORY,
+    'Source/UI/ColorHSL.vb': COLOR_HSL,
+    'Source/Video/FrameServer.vb': FRAME_SERVER_FACTORY,
+    'Source/General/ThemeManager.vb': `Public Class ThemeManager
+    Public Sub Apply(ByVal palette As Object)
+        Dim _backColor As ColorHSL = New ColorHSL(0, 0.01, 0.1, 1)
+        Dim _controlBackColor As ColorHSL = _backColor.AddLuminance(0.025)
+        For Each backgroundColor In palette
+            backgroundColor.AddLuminance(-0.1)
+        Next
+        Dim server = FrameServerFactory.Create("video.mkv")
+    End Sub
+End Class
+`,
+    'Source/UI/TipProvider.vb': `Public Class TipProvider
+    Public Sub SetTip(ByVal text As String)
+    End Sub
+    Public Sub SetTip(ByVal text As String, ByVal title As String)
+    End Sub
+End Class
+`,
+    'Source/General/Tips.vb': `Public Class Tips
+    Public Sub Apply(ByVal providers As Object)
+        For Each tipProvider In providers
+            tipProvider.SetTip("x")
+        Next
+    End Sub
+End Class
+`,
+    'Plugins/A/A.vbproj': VBPROJ,
+    'Plugins/A/Helper.vb': HELPER,
+    'Plugins/B/B.vbproj': VBPROJ,
+    'Plugins/B/Helper.vb': HELPER,
+    'App/App.vbproj': VBPROJ,
+    'App/Main.vb': `Public Class Main
+    Public Sub Start(ByVal helpers As Object)
+        For Each runHelper In helpers
+            runHelper.Run()
+        Next
+    End Sub
+End Class
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member @ file` of every call / instantiation edge out of a file. */
+function targetsFrom(file: string, kind: 'calls' | 'instantiates'): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === kind)
+    .map((e) => {
+      const target = cg.getNode(e.target)!;
+      return `${target.qualifiedName} @ ${target.filePath}`;
+    })
+    .sort();
+}
+
+describe('VB.NET duplicate types across projects', () => {
+  it('resolve a call to the caller’s own project’s copy', () => {
+    expect(targetsFrom('Source/General/ThemeManager.vb', 'calls')).toEqual([
+      'ColorHSL::AddLuminance @ Source/UI/ColorHSL.vb',
+      'ColorHSL::AddLuminance @ Source/UI/ColorHSL.vb',
+      'FrameServerFactory::Create @ Source/Video/FrameServer.vb',
+    ]);
+  });
+
+  it('resolve a construction to the caller’s own project’s copy', () => {
+    expect(targetsFrom('Source/General/ThemeManager.vb', 'instantiates')).toEqual([
+      'ColorHSL @ Source/UI/ColorHSL.vb',
+    ]);
+  });
+
+  it('make no guess between copies nothing tells apart', () => {
+    expect(targetsFrom('App/Main.vb', 'calls')).toEqual([]);
+  });
+
+  it('take one type’s overloads as one guess, not a tie', () => {
+    expect(targetsFrom('Source/General/Tips.vb', 'calls')).toEqual(['TipProvider::SetTip @ Source/UI/TipProvider.vb']);
+  });
+});
diff --git a/__tests__/vbnet-receiver-types.test.ts b/__tests__/vbnet-receiver-types.test.ts
new file mode 100644
index 0000000000..0a81309747
--- /dev/null
+++ b/__tests__/vbnet-receiver-types.test.ts
@@ -0,0 +1,465 @@
+/**
+ * A VB.NET call through a local, a parameter, a field or a property is a call
+ * on the type it is declared with — `Dim x As T`, `ByVal x As T`,
+ * `x As New T`, `Private File As SFile`, `Property File As SFile`, a type
+ * character (`Dim name$`), or what `Dim x = obj.GetString(…)` returns —
+ * never a guess at a same-named method of some project class. Keywords are
+ * matched without regard to case. A declared type the project does not define
+ * means nothing of the project's, except an extension method declared for it.
+ *
+ * - SCrawler's `ThumbnailFile.Delete(SFO.File, …)` on an `SFile` (from the
+ *   external PersonalUtilities library) went to a nested `TempFileConversion`
+ *   class's `Delete`, `GroupFile.Delete()` to a download group's,
+ *   `UserUpdatedEventHandlers.Add(e)` on a `List(Of …)` to `UserDataBind.Add`
+ *   and `TotalSize.CompareTo(…)` on a `Double` to a plugin's `VSize.CompareTo`;
+ * - staxrip's `timestampFontColorValue.ToColor(…)`, a String from
+ *   `settings.GetString(…)`, went to a `ColorHSL.ToColor()` instead of the
+ *   String extension `StringExtensions.ToColor`.
+ *
+ * The type a name means is the one VB.NET's lookup finds where it is written:
+ * the namespaces around it (SCrawler declares a `SiteSettings` and an `M3U8`
+ * per site namespace), a base class's nested types, the file's `Imports`
+ * aliases, and the type arguments a subclass gives its base. The declared
+ * type wins over whatever is assigned later, a `For Each` variable is an
+ * element of what it loops over, and an interface a class implements lends
+ * it no members to read bare.
+ */
+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-vb-receiver-'));
+  const files: Record<string, string> = {
+    'Download/Groups/DownloadGroup.vb': `Namespace DownloadObjects.Groups
+    Friend Class DownloadGroup
+        Friend Sub Delete()
+        End Sub
+    End Class
+End Namespace
+`,
+    'YouTube/Objects/YouTubeMediaContainerBase.vb': `Namespace API.YouTube.Objects
+    Public MustInherit Class YouTubeMediaContainerBase
+        Public ReadOnly Property ThumbnailFile As SFile
+        Private Class TempFileConversion
+            Friend Sub Delete(ByVal Mode As Integer)
+            End Sub
+        End Class
+    End Class
+End Namespace
+`,
+    'Download/Groups/DownloadGroupCollection.vb': `Namespace DownloadObjects.Groups
+    Friend Class DownloadGroupCollection
+        Private ReadOnly GroupFile As SFile = "Settings\\Groups.xml"
+        Friend Sub Update()
+            GroupFile.Delete()
+        End Sub
+        Friend Sub Reset(byval groupFile as SFile)
+            groupFile.Delete()
+        End Sub
+    End Class
+End Namespace
+`,
+    'Hosts/DownloadableMediaHost.vb': `Namespace Hosts
+    Friend Class DownloadableMediaHost : Inherits API.YouTube.Objects.YouTubeMediaContainerBase
+        Friend Sub Clean()
+            ThumbnailFile.Delete(1)
+        End Sub
+    End Class
+End Namespace
+`,
+    'API/UserDataBind.vb': `Namespace API
+    Friend Class UserDataBind
+        Friend Sub Add(ByVal User As Object)
+        End Sub
+    End Class
+End Namespace
+`,
+    'API/Base/UserDataBase.vb': `Namespace API.Base
+    Friend MustInherit Class UserDataBase
+        Private ReadOnly UserUpdatedEventHandlers As List(Of UserUpdatedEventHandler)
+        Friend Sub AddUpdateHandler(ByVal e As UserUpdatedEventHandler)
+            UserUpdatedEventHandlers.Add(e)
+        End Sub
+        Friend Sub Download()
+        End Sub
+    End Class
+End Namespace
+`,
+    'API/Instagram/UserData.vb': `Namespace API.Instagram
+    Friend Class UserData : Inherits API.Base.UserDataBase
+    End Class
+End Namespace
+`,
+    'API/Instagram/Downloader.vb': `Namespace API.Instagram
+    Friend Class Downloader
+        Friend Sub Run(ByVal u As UserData)
+            u.Download()
+        End Sub
+    End Class
+End Namespace
+`,
+    'Plugin/UserData.vb': `Friend Class VSize
+    Public Function CompareTo(ByVal Other As VSize) As Integer
+        Return 0
+    End Function
+End Class
+`,
+    'Editors/UsersInfoForm.vb': `Friend Class UsersInfoForm
+    Private NotInheritable Class UserOpt
+        Friend Property TotalSize As Double = 0
+        Friend Function CompareTo(ByVal Other As UserOpt) As Integer
+            Return TotalSize.CompareTo(Other.TotalSize) * -1
+        End Function
+    End Class
+End Class
+`,
+    'UI/ColorHSL.vb': `Public Class ColorHSL
+    Public Sub New(ByVal h As Double, ByVal s As Double, ByVal l As Double, ByVal a As Double)
+    End Sub
+    Public Function AddLuminance(ByVal offset As Single) As ColorHSL
+        Return Me
+    End Function
+    Public Function ToColor() As Integer
+        Return 0
+    End Function
+End Class
+`,
+    'UI/BackColorAdjuster.vb': `Public Class BackColorAdjuster
+    Public Function AddLuminance(ByVal offset As Single) As Integer
+        Return 0
+    End Function
+End Class
+`,
+    'UI/ThemeManager.vb': `Public Class ThemeManager
+    Public Sub Apply()
+        Dim _backColor As ColorHSL = New ColorHSL(0, 0.01, 0.1, 1)
+        Dim _controlBackColor As ColorHSL = _backColor.AddLuminance(0.025)
+    End Sub
+End Class
+`,
+    'UI/Popup.vb': `Public Class Popup
+    Public Sub Show()
+    End Sub
+End Class
+`,
+    'UI/MainForm.vb': `Public Class MainForm
+    Inherits Form
+
+    Public Sub OpenSettings()
+        Dim settingsForm As New MainForm
+        settingsForm.Show()
+    End Sub
+End Class
+`,
+    'General/Extensions.vb': `Imports System.Runtime.CompilerServices
+
+Module StringExtensions
+    <Extension>
+    Function ToColor(ByVal str As String, Optional ByVal defaultColor As Integer = 0) As Integer
+        Return 0
+    End Function
+    <Extension>
+    Function Join(ByVal instance As IEnumerable(Of String), ByVal delimiter As String) As String
+        Return ""
+    End Function
+    <Extension>
+    Function Sort(Of T)(ByVal instance As IEnumerable(Of T)) As IEnumerable(Of T)
+        Return instance
+    End Function
+End Module
+`,
+    'General/ObjectStorage.vb': `Public Class ObjectStorage
+    Public Function GetString(ByVal key As String, Optional ByVal defaultValue As String = Nothing) As String
+        Return defaultValue
+    End Function
+End Class
+`,
+    'General/Thumbnailer.vb': `Public Class Thumbnailer
+    Public Sub Run(ByVal settings As ObjectStorage)
+        Dim timestampFontColorValue = settings.GetString("TimestampFontColor", "#fff")
+        Dim timestampFontColor = timestampFontColorValue.ToColor(1)
+        Dim colorText As String = "#000"
+        Dim outline = colorText.ToColor()
+        Dim name$ = "x"
+        Dim named = name.ToColor()
+    End Sub
+End Class
+`,
+    'General/Lists.vb': `Public Class Lists
+    Public Sub Run()
+        Dim names As New List(Of String)
+        names.Sort()
+        Dim joined = names.Join(", ")
+    End Sub
+End Class
+`,
+    'Base/DownDetector.vb': `Namespace API.Base
+    Friend NotInheritable Class DownDetector
+        Friend MustInherit Class Checker(Of T)
+            Protected ReadOnly Property Source As T
+        End Class
+    End Class
+End Namespace
+`,
+    'Sites/Bluesky/SiteSettings.vb': `Namespace API.Bluesky
+    Friend Class SiteSettings
+        Friend Function IsMyUser(ByVal url As String) As Boolean
+            Return False
+        End Function
+        Friend Function AvailableTrueValue() As Boolean
+            Return False
+        End Function
+    End Class
+    Friend NotInheritable Class M3U8
+        Friend Shared Sub Download(ByVal url As String)
+        End Sub
+    End Class
+End Namespace
+`,
+    'Sites/Reddit/SiteSettings.vb': `Namespace API.Reddit
+    Friend Class SiteSettings
+        Friend Function IsMyUser(ByVal url As String) As Boolean
+            Return True
+        End Function
+        Friend Function AvailableTrueValue() As Boolean
+            Return True
+        End Function
+        Private Class MyDownDetector : Inherits API.Base.DownDetector.Checker(Of SiteSettings)
+            Friend Sub Check()
+                Source.AvailableTrueValue()
+            End Sub
+        End Class
+    End Class
+    Friend NotInheritable Class M3U8
+        Friend Shared Sub Download(ByVal url As String)
+        End Sub
+    End Class
+End Namespace
+`,
+    'Sites/Reddit/UserData.vb': `Namespace API.Reddit
+    Friend Class UserData
+        Private ReadOnly Property MySettings As SiteSettings
+        Friend Sub Check(ByVal url As String)
+            MySettings.IsMyUser(url)
+            M3U8.Download(url)
+        End Sub
+    End Class
+End Namespace
+`,
+    'Encoding/VideoEncoder.vb': `Public MustInherit Class VideoEncoder
+    Public Class MenuList
+        Public Sub Add(ByVal text As String)
+        End Sub
+    End Class
+End Class
+Public Class BatchEncoder
+    Inherits VideoEncoder
+    Public Function GetMenu() As Object
+        Dim ret As New MenuList
+        ret.Add("Codec Configuration")
+        Return ret
+    End Function
+End Class
+`,
+    'YouTube/YouTubeFunctions.vb': `Friend Interface IContainer
+    Sub Parse()
+End Interface
+Friend Class Channel : Implements IContainer
+    Friend Sub Parse() Implements IContainer.Parse
+    End Sub
+End Class
+Friend Module YouTubeFunctions
+    Friend Sub Load()
+        Dim item As IContainer
+        item = New Channel
+        item.Parse()
+    End Sub
+End Module
+`,
+    'UI/Labels.vb': `Public Class LabelUI
+    Public Function AddLabel(ByVal text As String) As Object
+        Return Nothing
+    End Function
+End Class
+Public Class SimpleUI
+    Public Function AddLabel(ByVal text As String) As Object
+        Return Nothing
+    End Function
+    Public Function AddLabel(ByVal text As String, ByVal width As Integer) As Object
+        Return Nothing
+    End Function
+End Class
+Public Class SimpleSettingsForm
+    Friend WithEvents SimpleUI As SimpleUI
+End Class
+`,
+    'UI/AudioForm.vb': `Public Class AudioForm
+    Public Sub ShowAdvanced()
+        Using form As New SimpleSettingsForm()
+            Dim ui = form.SimpleUI
+            ui.AddLabel("EBU R128")
+        End Using
+    End Sub
+End Class
+`,
+    'UI/Theme.vb': `Public Class ButtonLabel
+    Public Sub ApplyTheme()
+    End Sub
+End Class
+Public Class ToggleButtonLabel
+    Public Sub ApplyTheme()
+    End Sub
+End Class
+Public Class ThemeApplier
+    Public Sub Apply(ByVal controls As Object)
+        For Each control In controls.OfType(Of ToggleButtonLabel)
+            control.ApplyTheme()
+        Next
+    End Sub
+    Public Sub ApplyAll(ByVal labels As List(Of ToggleButtonLabel))
+        For Each label In labels
+            label.ApplyTheme()
+        Next
+    End Sub
+End Class
+`,
+    'Download/TDownloader.vb': `Namespace App.Download
+    Friend Class TDownloader
+        Friend Class Job
+            Friend Sub Start()
+            End Sub
+        End Class
+    End Class
+    Friend Class Worker
+        Friend Sub Start()
+        End Sub
+    End Class
+End Namespace
+`,
+    'Download/DownloadProgress.vb': `Imports TDJob = App.Download.TDownloader.Job
+
+Namespace App.Download
+    Friend Class DownloadProgress
+        Friend ReadOnly Property Worker As TDJob
+        Friend Sub Run()
+            Worker.Start()
+        End Sub
+    End Class
+End Namespace
+`,
+    'Plugin/IPluginContentProvider.vb': `Namespace Plugin
+    Public Interface ISiteSettings
+    End Interface
+    Public Interface IPluginContentProvider
+        Property Settings As ISiteSettings
+    End Interface
+End Namespace
+`,
+    'MainMod.vb': `Friend Module MainMod
+    Friend Settings As SettingsCLS
+End Module
+`,
+    'SettingsCLS.vb': `Friend Class SettingsCLS
+    Friend Sub UpdateUsersList()
+    End Sub
+End Class
+`,
+    'API/Base/UserDataProvider.vb': `Namespace API.Base
+    Friend MustInherit Class UserDataProvider : Implements Plugin.IPluginContentProvider
+        Friend Property MySettings As Plugin.ISiteSettings Implements Plugin.IPluginContentProvider.Settings
+        Friend Sub Delete()
+            Settings.UpdateUsersList()
+        End Sub
+    End Class
+End Namespace
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of a file. */
+function callsFrom(file: string): string[] {
+  const ids = cg.getNodesInFile(file).map((n) => n.id);
+  return cg
+    .getOutgoingEdgesFrom(ids)
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('VB.NET calls through declared receivers', () => {
+  it('reach nothing of the project on a type it does not define', () => {
+    expect(callsFrom('Download/Groups/DownloadGroupCollection.vb')).toEqual([]);
+    expect(callsFrom('Hosts/DownloadableMediaHost.vb')).toEqual([]);
+    expect(callsFrom('API/Base/UserDataBase.vb')).toEqual([]);
+  });
+
+  it('reach nothing of the project on a VB.NET built-in type', () => {
+    expect(callsFrom('Editors/UsersInfoForm.vb')).toEqual([]);
+  });
+
+  it('reach the declared type’s own method, or the one it inherits', () => {
+    expect(callsFrom('UI/ThemeManager.vb')).toEqual(['ColorHSL::AddLuminance']);
+    expect(callsFrom('API/Instagram/Downloader.vb')).toEqual(['API.Base::UserDataBase::Download']);
+  });
+
+  it('reach nothing of the project for a method the declared type inherits from outside it', () => {
+    expect(callsFrom('UI/MainForm.vb')).toEqual([]);
+  });
+
+  it('reach an extension method declared for the type, through what a call returns too', () => {
+    expect(callsFrom('General/Thumbnailer.vb')).toEqual([
+      'ObjectStorage::GetString',
+      'StringExtensions::ToColor',
+      'StringExtensions::ToColor',
+      'StringExtensions::ToColor',
+    ]);
+  });
+
+  it('reach a .NET type’s own method before an extension of that name, and an extension it lacks', () => {
+    // `List(Of T)` has its own `Sort()`, but no `Join`.
+    expect(callsFrom('General/Lists.vb')).toEqual(['StringExtensions::Join']);
+  });
+
+  it('name the type their declaration’s namespace sees, through a base class’s type argument too', () => {
+    // SCrawler declares a `SiteSettings` and an `M3U8` in each site's namespace.
+    expect(callsFrom('Sites/Reddit/UserData.vb')).toEqual([
+      'API.Reddit::M3U8::Download',
+      'API.Reddit::SiteSettings::IsMyUser',
+    ]);
+    // `Inherits DownDetector.Checker(Of SiteSettings)` makes its `Source As T` a SiteSettings.
+    expect(callsFrom('Sites/Reddit/SiteSettings.vb')).toEqual(['API.Reddit::SiteSettings::AvailableTrueValue']);
+    // A type nested in a base class is named bare in a subclass: staxrip's `Dim ret As New MenuList`.
+    expect(callsFrom('Encoding/VideoEncoder.vb')).toEqual(['VideoEncoder::MenuList::Add']);
+  });
+
+  it('take the declared type over what is assigned, and an import alias for what it names', () => {
+    expect(callsFrom('YouTube/YouTubeFunctions.vb')).toEqual(['IContainer::Parse']);
+    expect(callsFrom('Download/DownloadProgress.vb')).toEqual(['App.Download::TDownloader::Job::Start']);
+  });
+
+  it('read a field through what a call returns, and a loop variable through what it loops over', () => {
+    expect(callsFrom('UI/AudioForm.vb')).toEqual(['SimpleUI::AddLabel']);
+    // `For Each control In controls.OfType(Of ToggleButtonLabel)`, `For Each label In labels` over a `List(Of ToggleButtonLabel)`.
+    expect(callsFrom('UI/Theme.vb')).toEqual(['ToggleButtonLabel::ApplyTheme', 'ToggleButtonLabel::ApplyTheme']);
+  });
+
+  it('see a module’s field, not the property of an interface the class implements', () => {
+    expect(callsFrom('API/Base/UserDataProvider.vb')).toEqual(['SettingsCLS::UpdateUsersList']);
+  });
+});
diff --git a/__tests__/vbnet-shared-member-refs.test.ts b/__tests__/vbnet-shared-member-refs.test.ts
new file mode 100644
index 0000000000..21a5b40fd6
--- /dev/null
+++ b/__tests__/vbnet-shared-member-refs.test.ts
@@ -0,0 +1,221 @@
+/**
+ * VB.NET: a value read or written through a type or module name —
+ * `AppSession.SessionId`, `AppSession.CurrentUser = "demo"`, `Logger.Level`,
+ * `Mode.Fast` — is a use of the member and of the type (#2305). Before, only
+ * calls linked, so `codegraph callers` on a Shared field or property, and on
+ * the class itself, came back empty.
+ *
+ * The name is looked up as VB.NET does, without regard to case: a local, a
+ * parameter or a field of that name holds a value, read as the type it is
+ * declared as (vbnet-instance-member-refs.test.ts; a member typed as its own
+ * name's type, `Property Settings As Settings`, reads that type's members
+ * either way); a type is the one the namespaces around
+ * the read, its `Imports` and aliases see — SCrawler declares a
+ * `SiteSettings` in every site's namespace. A method named without
+ * parentheses is called, unless `AddressOf` only names it, and an index into
+ * a Shared field (`AppSession.Items(0)`), which VB.NET writes as a call, reads
+ * the field.
+ */
+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;
+
+const files: Record<string, string> = {
+  // The issue's three files.
+  'AppSession.vb': `Public Class AppSession
+    Public Shared SessionId As Guid = Guid.NewGuid()
+    Public Shared Property CurrentUser As String
+    Public Shared Items As New List(Of String)
+    Public Shared Function GetGreeting() As String
+        Return "Hello " & CurrentUser
+    End Function
+    Public Shared Sub OnTick(ByVal sender As Object, ByVal e As EventArgs)
+    End Sub
+    Public Shared Function Describe() As String
+        Return AppSession.CurrentUser
+    End Function
+End Class
+`,
+  'Consumer.vb': `Public Class Consumer
+    Public Sub Run()
+        Dim id As Guid = AppSession.SessionId
+        AppSession.CurrentUser = "demo"
+        Console.WriteLine(AppSession.GetGreeting())
+    End Sub
+End Class
+`,
+  'Consumer2.vb': `Public Class Consumer2
+    Public Function Describe() As String
+        Return AppSession.CurrentUser & AppSession.SessionId.ToString()
+    End Function
+End Class
+`,
+  'OtherSession.vb': `Public Class OtherSession
+    Public Shared SessionId As Guid = Guid.NewGuid()
+    Public Property Size As Integer
+End Class
+`,
+  'Size.vb': `Public Class Size
+End Class
+`,
+  'Logger.vb': `Public Module Logger
+    Public Level As Integer
+End Module
+`,
+  'Mode.vb': `Public Enum Mode
+    Fast
+    Slow
+End Enum
+`,
+  'Form1.vb': `Public Class Form1
+    Private Panel1 As Panel
+    Public Sub Setup()
+        Logger.Level = 3
+        Dim a = Panel1.Size
+        Me.Panel1.Size = New System.Drawing.Size(1, 2)
+        Dim speed = Mode.Fast
+        Dim greeting = AppSession.GetGreeting
+        AddHandler Timer1.Tick, AddressOf AppSession.OnTick
+        Dim first = AppSession.Items(0)
+        Dim empty = String.Empty
+    End Sub
+    Public Sub Shadowed(ByVal appSession As OtherSession)
+        Dim id = AppSession.SessionId
+    End Sub
+End Class
+`,
+  // A type declared in each site's namespace, and one read through an import alias.
+  'Sites/Reddit/SiteSettings.vb': `Namespace API.Reddit
+    Friend Class SiteSettings
+        Friend Const Header As String = "r"
+    End Class
+    Friend Class UserData
+        Friend Function Key() As String
+            Return SiteSettings.Header
+        End Function
+    End Class
+End Namespace
+`,
+  'Sites/Twitter/SiteSettings.vb': `Namespace API.Twitter
+    Friend Class SiteSettings
+        Friend Const Header As String = "t"
+    End Class
+    Friend Class UserData
+        Friend Function Key() As String
+            Return SiteSettings.Header
+        End Function
+    End Class
+End Namespace
+`,
+  'Sites/Facebook/UserData.vb': `Imports RS = API.Reddit.SiteSettings
+Namespace API.Facebook
+    Friend Class UserData
+        Friend Function Key() As String
+            Return RS.Header
+        End Function
+    End Class
+End Namespace
+`,
+  // A property typed as the type of its own name; a property initializer.
+  'Settings.vb': `Public Class Settings
+    Public Property Theme As String
+End Class
+`,
+  'Window.vb': `Public Class Window
+    Public Property Settings As Settings
+    Public Property Title As String = AppSession.CurrentUser
+    Public Function CurrentTheme() As String
+        Return Settings.Theme
+    End Function
+End Class
+`,
+  // CRLF line endings and multibyte text before the read.
+  'Weird.vb': [
+    'Public Class Weird',
+    '    Public Sub Go()',
+    '        Dim s = "SessionId éééé 😀" & AppSession.SessionId',
+    '    End Sub',
+    'End Class',
+    '',
+  ].join('\r\n'),
+};
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vb-shared-'));
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function nodeId(qualifiedName: string): string {
+  const found = cg.getNodesInFiles(Object.keys(files)).filter((n) => n.qualifiedName === qualifiedName);
+  if (found.length !== 1) throw new Error(`${found.length} nodes named ${qualifiedName}`);
+  return found[0]!.id;
+}
+
+/** The qualified names of what links to `qualifiedName` with an edge of `kind`. */
+function linkedFrom(qualifiedName: string, kind: 'references' | 'calls'): string[] {
+  return cg
+    .getIncomingEdgesTo([nodeId(qualifiedName)], [kind])
+    .map((e) => cg.getNode(e.source)!.qualifiedName)
+    .sort();
+}
+
+describe('VB.NET Shared members read through their type (#2305)', () => {
+  it('link a Shared field and property to the methods that read or write them', () => {
+    expect(linkedFrom('AppSession::SessionId', 'references')).toEqual(['Consumer2::Describe', 'Consumer::Run', 'Weird::Go']);
+    expect(linkedFrom('AppSession::CurrentUser', 'references'))
+      .toEqual(['AppSession::Describe', 'Consumer2::Describe', 'Consumer::Run', 'Window::Title']);
+  });
+
+  it('link the class to the code outside it that reads through it', () => {
+    expect(linkedFrom('AppSession', 'references'))
+      .toEqual(['Consumer2::Describe', 'Consumer2::Describe', 'Consumer::Run', 'Consumer::Run', 'Form1::Setup', 'Weird::Go', 'Window::Title']);
+    expect(cg.getCallers(nodeId('AppSession')).map((c) => c.node.qualifiedName).sort())
+      .toEqual(['Consumer2::Describe', 'Consumer::Run', 'Form1::Setup', 'Weird::Go', 'Window::Title']);
+  });
+
+  it('keep the call to a Shared method, and call one named without parentheses', () => {
+    expect(linkedFrom('AppSession::GetGreeting', 'calls')).toEqual(['Consumer::Run', 'Form1::Setup']);
+    expect(linkedFrom('AppSession::OnTick', 'references')).toEqual(['Form1::Setup']);
+    expect(linkedFrom('AppSession::OnTick', 'calls')).toEqual([]);
+  });
+
+  it('read a Shared field indexed like a call, a Module variable and an Enum value', () => {
+    expect(linkedFrom('AppSession::Items', 'references')).toEqual(['Form1::Setup']);
+    expect(linkedFrom('Logger::Level', 'references')).toEqual(['Form1::Setup']);
+    expect(linkedFrom('Mode::Fast', 'references')).toEqual(['Form1::Setup']);
+    expect(linkedFrom('Mode', 'references')).toEqual(['Form1::Setup']);
+  });
+
+  it('read through a local, parameter or field, whatever its case, the type it holds', () => {
+    // `AppSession.SessionId` in `Shadowed(ByVal appSession As OtherSession)`
+    // reads the parameter: OtherSession's field, never AppSession's.
+    expect(linkedFrom('OtherSession::SessionId', 'references')).toEqual(['Form1::Shadowed']);
+    expect(linkedFrom('OtherSession::Size', 'references')).toEqual([]);
+    expect(linkedFrom('Size', 'references')).toEqual([]);
+    expect(linkedFrom('OtherSession', 'references')).toEqual([]);
+  });
+
+  it('read the type the namespaces and imports around the read see', () => {
+    expect(linkedFrom('API.Reddit::SiteSettings::Header', 'references'))
+      .toEqual(['API.Facebook::UserData::Key', 'API.Reddit::UserData::Key']);
+    expect(linkedFrom('API.Twitter::SiteSettings::Header', 'references')).toEqual(['API.Twitter::UserData::Key']);
+  });
+
+  it('read through a member typed as the type of its own name', () => {
+    expect(linkedFrom('Settings::Theme', 'references')).toEqual(['Window::CurrentTheme']);
+  });
+});
diff --git a/__tests__/vbnet-std-methods.test.ts b/__tests__/vbnet-std-methods.test.ts
new file mode 100644
index 0000000000..8c29b1e775
--- /dev/null
+++ b/__tests__/vbnet-std-methods.test.ts
@@ -0,0 +1,75 @@
+/**
+ * VB.NET runs on the same .NET base library as C#, so a call such as
+ * `x.Contains(…)`, `x.Add(…)` or `x.Dispose()` on a receiver whose type is not
+ * known is far more likely the library's method than the one project method
+ * that happens to share the name. As in C#, such a guess is kept only when the
+ * receiver is named after the method's owner. staxrip's
+ * `SupportedInput.Contains(ret)` — a String array — went to `VideoScript`'s
+ * `Contains`.
+ */
+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-vb-std-'));
+  const files: Record<string, string> = {
+    'Video/VideoScript.vb': `Public Class VideoScript
+    Public Function Contains(ByVal value As String) As Boolean
+        Return False
+    End Function
+End Class
+`,
+    'Audio/AudioProfile.vb': `Public Class AudioProfile
+    Public Function IsInputSupported(ByVal inputs As Object, ByVal ext As String) As Boolean
+        For Each supported In inputs
+            If supported.Contains(ext) Then Return True
+        Next
+        Return False
+    End Function
+
+    Public Function HasScript(ByVal scripts As Object, ByVal name As String) As Boolean
+        For Each script In scripts
+            If script.Contains(name) Then Return True
+        Next
+        Return False
+    End Function
+End Class
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `Owner::member` of every call edge out of one method. */
+function callsOf(qualifiedName: string): string[] {
+  const from = cg.getNodesInFile('Audio/AudioProfile.vb').find((n) => n.qualifiedName === qualifiedName)!;
+  return cg
+    .getOutgoingEdgesFrom([from.id])
+    .filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!.qualifiedName)
+    .sort();
+}
+
+describe('VB.NET standard-library method names', () => {
+  it('are not a project method on a receiver that does not name its owner', () => {
+    expect(callsOf('AudioProfile::IsInputSupported')).toEqual([]);
+  });
+
+  it('still reach the project method when the receiver names its owner', () => {
+    expect(callsOf('AudioProfile::HasScript')).toEqual(['VideoScript::Contains']);
+  });
+});
diff --git a/__tests__/vue-options-api.test.ts b/__tests__/vue-options-api.test.ts
new file mode 100644
index 0000000000..ba4f9f2353
--- /dev/null
+++ b/__tests__/vue-options-api.test.ts
@@ -0,0 +1,115 @@
+/**
+ * A Vue Options API component's functions are symbols: `methods`, `computed`,
+ * `watch` entries and the lifecycle hooks, each owning the calls written in it.
+ * (`src/extraction/vue-options-api.ts`, wired in `vue-extractor.ts`.)
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { vueOptionsMembers } from '../src/extraction/vue-options-api';
+
+describe('vueOptionsMembers', () => {
+  it('names every function an options object declares', () => {
+    const script = `
+import { mapActions } from 'vuex'
+export default {
+  name: 'Login',
+  props: { redirect: String },
+  data() {
+    return { loading: false }
+  },
+  computed: {
+    title() { return 'Sign in' },
+    fullName: {
+      get() { return this.first },
+      set(v) { this.first = v }
+    },
+    ...mapGetters(['user'])
+  },
+  watch: {
+    $route: { handler(route) { this.redirect = route.query.redirect }, immediate: true },
+    'form.email'(value) { this.check(value) },
+    loading: 'onLoading'
+  },
+  created() { this.init() },
+  mounted: function () { this.focus() },
+  methods: {
+    ...mapActions(['login']),
+    async handleLogin() { await this.login() },
+    validate: (value) => value.length > 0,
+    reset: function () {},
+    [DYNAMIC]() {}
+  }
+}
+`;
+    expect(vueOptionsMembers(script).map((m) => m.name)).toEqual([
+      'data', 'title', 'fullName', '$route', 'form.email', 'created', 'mounted', 'handleLogin', 'validate', 'reset',
+    ]);
+  });
+
+  it('reads defineComponent, Vue.extend and Vue.component, and nothing without an options object', () => {
+    expect(vueOptionsMembers(`export default defineComponent({ setup() { return {} } })`).map((m) => m.name)).toEqual(['setup']);
+    expect(vueOptionsMembers(`export default Vue.extend({ methods: { go() {} } })`).map((m) => m.name)).toEqual(['go']);
+    expect(vueOptionsMembers(`export default Vue.component('x-btn', { methods: { tap() {} } })`).map((m) => m.name)).toEqual(['tap']);
+    expect(vueOptionsMembers(`const x = { methods: { go() {} } }\nexport default x`)).toEqual([]);
+  });
+});
+
+describe('a Vue Options API component, indexed', () => {
+  let root = '';
+  afterAll(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('gives each method its calls, and the template handler its method', async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vue-options-'));
+    fs.mkdirSync(path.join(root, 'src/views/login'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'admin', dependencies: { vue: '^2.6.0' } }));
+    fs.writeFileSync(
+      path.join(root, 'src/views/login/index.vue'),
+      `<template>
+  <form>
+    <button @click="handleLogin">Sign in</button>
+  </form>
+</template>
+
+<script>
+export default {
+  name: 'Login',
+  data() {
+    return { loading: false }
+  },
+  methods: {
+    handleLogin() {
+      if (this.validate()) {
+        this.loading = true
+      }
+    },
+    validate() {
+      return true
+    }
+  }
+}
+</script>
+`
+    );
+    const cg = await CodeGraph.init(root, { index: true });
+    try {
+      const nodes = cg.getNodesInFile('src/views/login/index.vue');
+      const method = (name: string) => nodes.find((n) => n.kind === 'method' && n.name === name)!;
+      expect(nodes.filter((n) => n.kind === 'method').map((n) => n.name).sort()).toEqual(['data', 'handleLogin', 'validate']);
+      expect(method('handleLogin').qualifiedName).toBe('index::handleLogin');
+      // The call inside handleLogin is handleLogin's, not the file's.
+      const calls = cg.getOutgoingEdges(method('handleLogin').id).filter((e) => e.kind === 'calls').map((e) => cg.getNode(e.target)!.name);
+      expect(calls).toContain('validate');
+      // `@click="handleLogin"` in the template runs the method.
+      const component = nodes.find((n) => n.kind === 'component')!;
+      const handlers = cg.getOutgoingEdges(component.id).filter((e) => e.target === method('handleLogin').id);
+      expect(handlers.length).toBeGreaterThan(0);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/vue-resolver-language.test.ts b/__tests__/vue-resolver-language.test.ts
new file mode 100644
index 0000000000..ccd416e370
--- /dev/null
+++ b/__tests__/vue-resolver-language.test.ts
@@ -0,0 +1,54 @@
+/**
+ * The Vue resolver's rules — compiler macros, Nuxt auto-imports, PascalCase
+ * components — are a Vue app's scripts', never another language's: mealie's
+ * Python `QueryFilterBuilder(...)` resolved to the `QueryFilterBuilder.vue`
+ * component instead of the Python class it constructs.
+ */
+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-vue-lang-'));
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ name: 'app', dependencies: { vue: '^3' } }),
+    'frontend/components/QueryFilterBuilder.vue': `<template><div /></template>
+<script setup lang="ts">
+const props = defineProps<{ value: string }>();
+</script>
+`,
+    'backend/query.py': `class QueryFilterBuilder:
+    def __init__(self, raw):
+        self.raw = raw
+`,
+    'backend/test_query.py': `from mealie.services.query_filter.builder import QueryFilterBuilder
+
+
+def test_builder():
+    return QueryFilterBuilder("x")
+`,
+  };
+  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 });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('the Vue resolver', () => {
+  it('leaves a Python call to its own class alone', () => {
+    const ids = cg.getNodesInFile('backend/test_query.py').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => cg.getNode(e.target)!.filePath);
+    expect(targets).not.toContain('frontend/components/QueryFilterBuilder.vue');
+  });
+});
diff --git a/__tests__/vue-router.test.ts b/__tests__/vue-router.test.ts
index abe0871866..de94f2989e 100644
--- a/__tests__/vue-router.test.ts
+++ b/__tests__/vue-router.test.ts
@@ -65,15 +65,18 @@ describe('vue-router: parseVueRoutes', () => {
       ['home', '/'],
       ['login', '/login'],
       ['settings', '/settings'],
+      [null, '/profile/:username/favorites'],
       ['profile', '/profile/:username'],
     ]);
   });
 
   it('reads the component from a lazy import and from an identifier', () => {
-    expect(entries.map((e) => e.component)).toEqual(['Home', 'Login', 'Settings', 'Profile']);
+    expect(entries.map((e) => e.component)).toEqual(['Home', 'Login', 'Settings', 'Favorites', 'Profile']);
   });
 
-  it('skips a child route, whose path is relative to a parent this does not compose', () => {
+  it('joins a child route onto its parent, which is the layout around it', () => {
+    const child = entries.find((e) => e.path === '/profile/:username/favorites')!;
+    expect(child.layouts.map((l) => l.component)).toEqual(['Profile']);
     expect(entries.some((e) => e.path === 'favorites')).toBe(false);
   });
 
@@ -299,3 +302,160 @@ describe('vue-router: a routed app end to end', () => {
     expect(screens.dropped).toBe(0);
   });
 });
+
+// =============================================================================
+// Admin-template route tables, and Nuxt's own file routes
+// =============================================================================
+
+describe('vue-router: route tables beyond an inline createRouter', () => {
+  const roots: string[] = [];
+  afterAll(() => {
+    for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
+  });
+
+  async function project(files: Record<string, string>): Promise<CodeGraph> {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vue-tables-'));
+    roots.push(root);
+    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);
+    }
+    return CodeGraph.init(root, { index: true });
+  }
+
+  const routeNames = (cg: CodeGraph): string[] => cg.getNodesByKind('route').map((n) => n.name).sort();
+  const edgesFrom = (cg: CodeGraph, routeName: string, kind: 'calls' | 'references') => {
+    const r = cg.getNodesByKind('route').find((n) => n.name === routeName)!;
+    return cg.getOutgoingEdges(r.id).filter((e) => e.kind === kind).map((e) => ({ edge: e, target: cg.getNode(e.target)! }));
+  };
+
+  it('vue-element-admin: named tables, `new Router`, module files, children and layouts', async () => {
+    const view = (name: string) => `<template><div>${name}</div></template>\n<script>\nexport default { name: '${name}' }\n</script>\n`;
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'admin', dependencies: { vue: '^2.6.0', 'vue-router': '^3.0.0' } }),
+      'src/router/index.js': `import Vue from 'vue'
+import Router from 'vue-router'
+import Layout from '@/layout'
+import tableRouter from './modules/table'
+Vue.use(Router)
+
+export const constantRoutes = [
+  { path: '/login', component: () => import('@/views/login/index'), hidden: true },
+  {
+    path: '/',
+    component: Layout,
+    redirect: '/dashboard',
+    children: [
+      { path: 'dashboard', component: () => import('@/views/dashboard/index'), name: 'Dashboard' }
+    ]
+  }
+]
+
+export const asyncRoutes = [tableRouter, { path: '*', redirect: '/404', hidden: true }]
+
+const createRouter = () => new Router({ routes: constantRoutes })
+export default createRouter()
+`,
+      'src/router/modules/table.js': `import Layout from '@/layout'
+
+const tableRouter = {
+  path: '/table',
+  component: Layout,
+  redirect: '/table/complex-table',
+  name: 'Table',
+  children: [
+    { path: 'complex-table', component: () => import('@/views/table/complex-table'), name: 'ComplexTable' }
+  ]
+}
+export default tableRouter
+`,
+      'src/layout/index.vue': view('Layout'),
+      'src/views/login/index.vue': `<template><button @click="go">in</button></template>
+<script>
+export default {
+  name: 'Login',
+  methods: {
+    go() { this.$router.push({ name: 'Dashboard' }) }
+  }
+}
+</script>
+`,
+      'src/views/dashboard/index.vue': view('Dashboard'),
+      'src/views/table/complex-table.vue': view('ComplexTable'),
+    });
+    try {
+      // `/` and `/table` redirect into their children: frames, not pages.
+      expect(routeNames(cg)).toEqual(['/dashboard', '/login', '/table/complex-table']);
+      // Each lazy view binds to ITS file's component, though every one is `index`.
+      expect(edgesFrom(cg, '/dashboard', 'calls').map((e) => e.target.filePath)).toEqual(['src/views/dashboard/index.vue']);
+      expect(edgesFrom(cg, '/login', 'calls').map((e) => e.target.filePath)).toEqual(['src/views/login/index.vue']);
+      // The parent's component is the layout around it.
+      const layouts = edgesFrom(cg, '/table/complex-table', 'references');
+      expect(layouts.map((e) => e.target.filePath)).toEqual(['src/layout/index.vue']);
+      expect(layouts[0]!.edge.metadata).toMatchObject({ layout: true });
+      // Navigation by name reaches the composed child.
+      const nav = cg
+        .getOutgoingEdgesFrom(cg.getNodesInFile('src/views/login/index.vue').map((n) => n.id), ['navigates' as never])
+        .filter((e) => e.kind === 'navigates');
+      expect(nav.map((e) => cg.getNode(e.target)!.name)).toEqual(['/dashboard']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('vben: a typed routes module with an alias the resolver cannot follow', async () => {
+    const cg = await project({
+      'package.json': JSON.stringify({ name: 'mono', private: true }),
+      'apps/web/package.json': JSON.stringify({ name: 'web', imports: { '#/*': './src/*' }, dependencies: { vue: '*', 'vue-router': '*' } }),
+      'apps/web/src/router/routes/modules/dashboard.ts': `import type { RouteRecordRaw } from 'vue-router';
+
+const routes: RouteRecordRaw[] = [
+  {
+    name: 'Dashboard',
+    path: '/dashboard',
+    children: [
+      { name: 'Analytics', path: 'analytics', component: () => import('#/views/dashboard/analytics/index.vue') },
+    ],
+  },
+];
+
+export default routes;
+`,
+      'apps/web/src/views/dashboard/analytics/index.vue': `<template><div>analytics</div></template>
+<script setup lang="ts">
+const title = 'Analytics';
+</script>
+`,
+    });
+    try {
+      expect(routeNames(cg)).toEqual(['/dashboard/analytics']);
+      expect(edgesFrom(cg, '/dashboard/analytics', 'calls').map((e) => e.target.filePath)).toEqual([
+        'apps/web/src/views/dashboard/analytics/index.vue',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('Nuxt pages at the repository root are routes; a plain Vue app’s pages/ folder is not', async () => {
+    const nuxt = await project({
+      'package.json': JSON.stringify({ name: 'site', dependencies: { nuxt: '*', vue: '*' } }),
+      'pages/index.vue': '<template><div/></template>\n',
+      'pages/users/[id].vue': '<template><div/></template>\n',
+    });
+    try {
+      expect(routeNames(nuxt)).toEqual(['/', '/users/:id']);
+    } finally {
+      nuxt.close();
+    }
+    const plain = await project({
+      'ui/package.json': JSON.stringify({ name: 'console', dependencies: { vue: '*', 'vue-router': '*' } }),
+      'ui/src/modules/contents/pages/SinglePageList.vue': '<template><div/></template>\n',
+    });
+    try {
+      expect(routeNames(plain)).toEqual([]);
+    } finally {
+      plain.close();
+    }
+  });
+});
diff --git a/__tests__/vue-store-extraction.test.ts b/__tests__/vue-store-extraction.test.ts
index 9fc2f9edaf..2354e6318e 100644
--- a/__tests__/vue-store-extraction.test.ts
+++ b/__tests__/vue-store-extraction.test.ts
@@ -10,7 +10,8 @@
  *   - Pinia options: `defineStore({ actions: {…}, getters: {…} })`.
  *   - Pinia setup: `defineStore('id', () => { const foo = …; return { foo } })`.
  * And the precision gate: a non-exported `const actions = {…}` in a file that
- * isn't a Vue store contributes nothing.
+ * isn't a Vue store is not treated as one. (Its members are nodes anyway, as
+ * every named object literal's are since #2300 — `actions::doThing`.)
  */
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs';
@@ -111,9 +112,11 @@ export const useChatStore = defineStore('chat', () => {
     cg.close?.();
   });
 
-  it('does not extract a non-exported `const actions = {…}` outside a Vue store file', async () => {
+  it('does not treat a non-exported `const actions = {…}` outside a Vue store file as a store', async () => {
     // A plain module that happens to hold a non-exported `const actions` object of
     // functions, but lacks any second Vue-store signal — the gate must not fire.
+    // The literal's members are its own nodes (#2300), and nothing reads the
+    // dynamic `actions[key]()` as a call to one of them.
     fs.writeFileSync(
       path.join(dir, 'commands.js'),
       `const actions = {
@@ -128,10 +131,15 @@ export function run(key) { return actions[key](); }
     await cg.indexAll();
     const db = (cg as any).db.db;
 
-    expect(db.prepare(`SELECT count(*) c FROM nodes WHERE name = 'doThing'`).get().c).toBe(0);
-    expect(db.prepare(`SELECT count(*) c FROM nodes WHERE name = 'doOther'`).get().c).toBe(0);
-    // The real exported function is still extracted normally.
-    expect(db.prepare(`SELECT count(*) c FROM nodes WHERE name = 'run' AND kind='function'`).get().c).toBeGreaterThan(0);
+    expect(db.prepare(`SELECT kind, qualified_name FROM nodes WHERE name IN ('doThing', 'doOther') ORDER BY qualified_name`).all())
+      .toEqual([
+        { kind: 'function', qualified_name: 'actions::doOther' },
+        { kind: 'function', qualified_name: 'actions::doThing' },
+      ]);
+    // The real exported function is still extracted normally, and calls nothing.
+    const run = cg.getNodesByQualifiedName('run');
+    expect(run.map((n) => n.kind)).toEqual(['function']);
+    expect(cg.getOutgoingEdges(run[0]!.id).filter((e) => e.kind === 'calls')).toEqual([]);
 
     cg.close?.();
   });
diff --git a/__tests__/vue-template-calls.test.ts b/__tests__/vue-template-calls.test.ts
new file mode 100644
index 0000000000..7bd7634390
--- /dev/null
+++ b/__tests__/vue-template-calls.test.ts
@@ -0,0 +1,252 @@
+/**
+ * A call is a call wherever a Vue component writes it (#2340): in the
+ * `<template>` (`{{ useBar(link) }}`, `:to="useBar(link.location)"`,
+ * `@click="save(item)"`), and in a destructuring declaration at module or
+ * `<script setup>` scope (`const { a } = useFoo(1)`). Neither used to record
+ * one, so `callers` on a Nuxt composable missed most of the components using
+ * it. (`src/extraction/vue-template-calls.ts`, wired in `vue-extractor.ts`;
+ * the destructuring walk is in `tree-sitter.ts` extractVariable and the
+ * kernel's `tsjs/extractors.rs`.)
+ */
+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 { vueTemplateCalls } from '../src/extraction/vue-template-calls';
+
+const names = (source: string) => vueTemplateCalls(source).map((c) => c.name);
+
+describe('vueTemplateCalls', () => {
+  it('finds calls in interpolations, bindings, directives and handlers, at their offsets', () => {
+    const source = `<template>
+  <NuxtLink :to="useBar(link.location)" v-if="canShow(link)">{{ useBar(link) }}</NuxtLink>
+  <li v-for="row in rowsFor(user)" v-show="visible()" v-my-dir="setup(1)">{{ label(row) }}</li>
+  <button @click="save(item)" v-on:keyup.enter="submit()" @input="onInput">go</button>
+  <Comp :style="{ color: tint() }" :title="\`#\${index(n)}\`" @change="(v) => update(v)" />
+</template>
+`;
+    const calls = vueTemplateCalls(source);
+    expect(calls.map((c) => c.name)).toEqual([
+      'useBar', 'canShow', 'useBar',
+      'rowsFor', 'visible', 'setup', 'label',
+      'save', 'submit',
+      'tint', 'index', 'update',
+    ]);
+    // Offsets point at the callee in the SFC source.
+    for (const c of calls) expect(source.slice(c.offset, c.offset + c.name.length)).toBe(c.name);
+  });
+
+  it('names a member call by its path, as a script call is named', () => {
+    expect(names(`<template>
+  <p @click="store.fetchUsers()" :a="user?.profile?.load()" :b="fn?.(1)">{{ props.format(v) }}</p>
+  <p :c="list[0].go()" :d="make().then(x => x.done())">{{ (a as B).run() }}</p>
+</template>`)).toEqual(['store.fetchUsers', 'user.profile.load', 'fn', 'props.format', 'make']);
+  });
+
+  it('skips names the template binds: v-for aliases and slot props in their subtree, arrow and function parameters', () => {
+    expect(names(`<template>
+  <ul>
+    <li v-for="(item, i) in items" :key="item.id" @click="item.select(i)">
+      {{ item.label() }} {{ format(item) }}
+      <Row #default="{ row, toggle }">{{ toggle(row) }} {{ rowLabel(row) }}</Row>
+    </li>
+  </ul>
+  <Comp :cb="function (x) { return x.go() }" :keys="(k) => k.trim()" @done="cb => cb()" />
+  <p>{{ toggle() }} {{ item() }}</p>
+</template>`)).toEqual(['format', 'rowLabel', 'toggle', 'item']);
+  });
+
+  it('skips what is never project code: strings, Vue template globals, $-helpers, keywords, new, object methods', () => {
+    expect(names(`<template>
+  <p :title="$t('x')" :class="'a(b)'">{{ Math.max(a(), 1) }} {{ JSON.stringify(c) }} {{ $route.query.x }}</p>
+  <p v-if="typeof x === 'function' && /f(o)/.test(s)">{{ new Date(stamp()).getTime() }} {{ "no()" }}</p>
+  <Chart :options="{ formatter(v) { return fmt(v) } }" @click="$emit('close')" />
+</template>`)).toEqual(['a', 'stamp', 'fmt']);
+  });
+
+  it('reads a CRLF file the same way', () => {
+    const lf = '<template>\n  <p\n    :title="label(\n      item)"\n  >{{ useBar(x) }}</p>\n</template>\n';
+    const crlf = lf.replace(/\n/g, '\r\n');
+    expect(names(crlf)).toEqual(['label', 'useBar']);
+    for (const c of vueTemplateCalls(crlf)) expect(crlf.slice(c.offset, c.offset + c.name.length)).toBe(c.name);
+  });
+
+  it('reads only the root template, and only what Vue compiles', () => {
+    expect(names(`<template>
+  <!-- {{ commented() }} -->
+  <div v-pre>{{ raw() }} <span :x="raw()"></span></div>
+  <template v-if="cond()"><span>{{ inner() }}</span></template>
+  <p data-x="plain(1)">{{ after() }}</p>
+</template>
+<script setup>
+const x = scriptCall()
+</script>
+<i18n>{ "en": { "a": "{{ notTemplate() }}" } }</i18n>`)).toEqual(['cond', 'inner', 'after']);
+    expect(names('<template lang="pug">\ndiv {{ pug() }}\n</template>')).toEqual([]);
+    expect(names('<script setup>\nconst a = b()\n</script>')).toEqual([]);
+  });
+});
+
+describe('calls written in Vue components, indexed (#2340)', () => {
+  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 {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-vue-calls-'));
+    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);
+    }
+  }
+
+  function callersOf(name: string, file: string): string[] {
+    const target = cg!.getNodesInFile(file).find((n) => n.name === name && (n.kind === 'function' || n.kind === 'method'));
+    expect(target, `${name} in ${file}`).toBeDefined();
+    return cg!.getCallers(target!.id).map(({ node }) => `${node.filePath}:${node.kind}`).sort();
+  }
+
+  it("finds every caller in the issue's repro", async () => {
+    write({
+      'package.json': JSON.stringify({ name: 'nuxt-app', dependencies: { nuxt: '^4.0.0' } }),
+      'composables/useFoo.ts': 'export function useFoo(n: number) { return { a: n }; }\n',
+      'composables/useBar.ts': 'export function useBar(x: unknown) { return String(x); }\n',
+      'components/A.vue': '<script setup lang="ts">\nconst { a } = useFoo(1)\n</script>\n',
+      'components/F.vue': '<script setup lang="ts">\nconst [b] = useFoo(1)\n</script>\n',
+      'components/B.vue': '<script setup lang="ts">\nconst x = useFoo(1)\n</script>\n',
+      'components/H.vue': '<template><div>{{ useBar(link) }}</div></template>\n',
+      'components/I.vue': '<template><NuxtLink :to="useBar(link.location)">x</NuxtLink></template>\n',
+      'G.ts': 'const { a } = useFoo(1)\nexport const g = a\n',
+      'D.ts': 'export function probe() { const { a } = useFoo(1); return a }\n',
+    });
+    cg = await CodeGraph.init(root, { index: true });
+
+    expect(callersOf('useFoo', 'composables/useFoo.ts')).toEqual([
+      'D.ts:function', // inside a function: already found
+      'G.ts:file', // module scope: the file is the caller
+      'components/A.vue:component',
+      'components/B.vue:component',
+      'components/F.vue:component',
+    ]);
+    expect(callersOf('useBar', 'composables/useBar.ts')).toEqual([
+      'components/H.vue:component',
+      'components/I.vue:component',
+    ]);
+  });
+
+  it('links a template call to an imported helper, a script-setup function and an Options API method', async () => {
+    write({
+      'utils/format.ts': 'export function formatPrice(n: number) { return `$${n}`; }\n',
+      'other/format.ts': 'export function formatPrice(n: number) { return n; }\n',
+      'components/Setup.vue': `<template>
+  <p>{{ formatPrice(item.price) }}</p>
+  <button @click="save(item)">save</button>
+</template>
+
+<script setup lang="ts">
+import { formatPrice } from '../utils/format';
+const props = defineProps<{ item: { price: number } }>();
+function save(item: unknown) { return item; }
+</script>
+`,
+      'components/Options.vue': `<template>
+  <p>{{ total(items) }}</p>
+  <button @click="submit(form)">send</button>
+</template>
+
+<script>
+export default {
+  methods: {
+    total(items) { return items.length },
+    submit(form) { return form }
+  }
+}
+</script>
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+
+    const edgesFrom = (file: string) => {
+      const comp = cg!.getNodesInFile(file).find((n) => n.kind === 'component')!;
+      return cg!.getOutgoingEdges(comp.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) => {
+          const t = cg!.getNode(e.target)!;
+          return `${t.name}@${t.filePath}:${e.line}`;
+        })
+        .sort();
+    };
+    // The import decides which `formatPrice`; each edge is on its template line.
+    expect(edgesFrom('components/Setup.vue')).toEqual([
+      'formatPrice@utils/format.ts:2',
+      'save@components/Setup.vue:3',
+    ]);
+    // A template calls the component's own methods without `this.`.
+    expect(edgesFrom('components/Options.vue')).toEqual([
+      'submit@components/Options.vue:3',
+      'total@components/Options.vue:2',
+    ]);
+  });
+
+  it("calls a component's own function even where Nuxt auto-imports one of that name", async () => {
+    write({
+      'package.json': JSON.stringify({ name: 'nuxt-app', dependencies: { nuxt: '^4.0.0' } }),
+      'pages/lists.vue': `<template>
+  <button @click="clearError(true)">x</button>
+</template>
+
+<script setup lang="ts">
+function clearError(focus: boolean) { return focus; }
+onDeactivated(() => clearError(false));
+</script>
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+
+    const nodes = cg.getNodesInFile('pages/lists.vue');
+    const comp = nodes.find((n) => n.kind === 'component')!;
+    const own = nodes.find((n) => n.kind === 'function' && n.name === 'clearError')!;
+    const calls = cg.getOutgoingEdges(comp.id).filter((e) => e.kind === 'calls');
+    // Both calls are the local function's — not Nuxt's `clearError`, which
+    // the framework rule used to answer with an edge from the component to itself.
+    expect(calls.filter((e) => e.target === own.id).map((e) => e.line).sort()).toEqual([2, 7]);
+    expect(calls.filter((e) => e.target === comp.id)).toEqual([]);
+  });
+
+  it('keeps a bare handler linked, and binds a handler expression only through its own call', async () => {
+    write({
+      'lib/bus.ts': 'export class Bus {\n  emit(event: string) { return event; }\n}\n',
+      'components/Dialog.vue': `<template>
+  <button @click="close">x</button>
+  <button @click="emit('cancel')">cancel</button>
+  <button @click="open = !open">toggle</button>
+</template>
+
+<script setup lang="ts">
+const emit = defineEmits(['cancel']);
+let open = false;
+function close() { open = false; }
+</script>
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+
+    const comp = cg.getNodesInFile('components/Dialog.vue').find((n) => n.kind === 'component')!;
+    const targets = cg.getOutgoingEdges(comp.id)
+      .filter((e) => e.kind === 'calls')
+      .map((e) => cg!.getNode(e.target)!)
+      .map((n) => `${n.kind}:${n.name}`);
+    // `@click="close"` is still the handler it names.
+    expect(targets).toContain('function:close');
+    // `emit('cancel')` is the component's `defineEmits` binding, and `open =
+    // !open` calls nothing: neither reaches Bus.emit.
+    expect(targets).not.toContain('method:emit');
+  });
+});
diff --git a/__tests__/worker-teardown.test.ts b/__tests__/worker-teardown.test.ts
new file mode 100644
index 0000000000..22d63bc830
--- /dev/null
+++ b/__tests__/worker-teardown.test.ts
@@ -0,0 +1,131 @@
+/**
+ * On Windows, a worker thread that ends while V8's concurrent marker is
+ * marking its heap can crash the whole process (0xC0000005, no error, no
+ * dump) — most of all while it is still loading its modules. Owners wait for a
+ * worker's first message before terminating it, and workers collect garbage
+ * before exiting (worker-teardown.ts). These pin both halves, then end real
+ * resolver and store workers right after starting them and record whether
+ * each had started when it was terminated.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { Worker } from 'worker_threads';
+import CodeGraph from '../src/index';
+import { terminateOnceStarted, workerStarted } from '../src/worker-teardown';
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+class FakeWorker extends EventEmitter {
+  terminate = vi.fn(async () => 0);
+}
+
+describe('terminating a worker once it has started', () => {
+  it('waits for the first message', async () => {
+    const w = new FakeWorker();
+    const started = workerStarted(w as unknown as Worker);
+    const ending = terminateOnceStarted(w, started);
+    await sleep(30);
+    expect(w.terminate).not.toHaveBeenCalled();
+    w.emit('message', { type: 'ready' });
+    await ending;
+    expect(w.terminate).toHaveBeenCalledOnce();
+  });
+
+  it('counts an error or an exit as started', async () => {
+    for (const event of ['error', 'exit'] as const) {
+      const w = new FakeWorker();
+      w.on('error', () => {});
+      const started = workerStarted(w as unknown as Worker);
+      w.emit(event, event === 'error' ? new Error('boom') : 1);
+      await terminateOnceStarted(w, started);
+      expect(w.terminate).toHaveBeenCalledOnce();
+    }
+  });
+
+  it('stops waiting after the cap, and never rejects', async () => {
+    const w = new FakeWorker();
+    w.terminate.mockRejectedValue(new Error('already gone'));
+    const t0 = Date.now();
+    await terminateOnceStarted(w, new Promise<void>(() => {}), 60);
+    expect(w.terminate).toHaveBeenCalledOnce();
+    expect(Date.now() - t0).toBeGreaterThanOrEqual(55);
+  });
+});
+
+describe('collecting garbage before a worker exits', () => {
+  it('runs a full collection in a real worker, and leaves no global gc behind', async () => {
+    const teardown = path.resolve(__dirname, '../dist/worker-teardown.js');
+    const run = (code: string) => new Promise<unknown>((resolve, reject) => {
+      const w = new Worker(code, { eval: true });
+      w.once('message', resolve);
+      w.once('error', reject);
+    });
+    const ran = await run(`
+      const { collectBeforeExit } = require(${JSON.stringify(teardown)});
+      let junk = Array.from({ length: 200000 }, (_, i) => ({ i, s: 'x'.repeat(32) }));
+      junk = null;
+      const before = process.memoryUsage().heapUsed;
+      const collected = collectBeforeExit();
+      const after = process.memoryUsage().heapUsed;
+      require('worker_threads').parentPort.postMessage({ collected, freed: before - after, gc: typeof globalThis.gc });
+    `) as { collected: boolean; freed: number; gc: string };
+    expect(ran.collected).toBe(true);
+    expect(ran.freed).toBeGreaterThan(0);
+    expect(ran.gc).toBe('undefined');
+    // A worker created afterwards doesn't get a global gc either.
+    expect(await run(`require('worker_threads').parentPort.postMessage(typeof globalThis.gc)`)).toBe('undefined');
+  }, 30_000);
+});
+
+describe('real workers are never terminated before they have started', () => {
+  let root: string;
+  let dbPath: string;
+  const seen = new WeakSet<object>();
+  const startedWhenEnded: boolean[] = [];
+
+  beforeEach(async () => {
+    root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-worker-start-')));
+    fs.writeFileSync(path.join(root, 'app.ts'), 'export function alpha() { return beta(); }\nexport function beta() { return 1; }\n');
+    const cg = await CodeGraph.init(root);
+    try { await cg.indexAll(); } finally { cg.close(); }
+    dbPath = path.join(root, '.codegraph', 'codegraph.db');
+    startedWhenEnded.length = 0;
+    // A worker re-emits each message it posts; note which have, and what each
+    // had done by the time it was terminated.
+    const emit = Worker.prototype.emit;
+    vi.spyOn(Worker.prototype, 'emit').mockImplementation(function (this: Worker, event: string | symbol, ...args: unknown[]) {
+      if (event === 'message') seen.add(this);
+      return emit.call(this, event, ...args);
+    });
+    const terminate = Worker.prototype.terminate;
+    vi.spyOn(Worker.prototype, 'terminate').mockImplementation(function (this: Worker) {
+      startedWhenEnded.push(seen.has(this));
+      return terminate.call(this);
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  });
+
+  it('the resolver pool, torn down while its workers boot', async () => {
+    vi.stubEnv('CODEGRAPH_RESOLVE_WORKERS', '2');
+    const { ResolverPool } = require('../dist/resolution/resolver-pool') as typeof import('../src/resolution/resolver-pool');
+    const pool = ResolverPool.tryCreate(dbPath, root);
+    expect(pool).not.toBeNull();
+    await pool!.destroy(0); // the close fallback fires at once, mid-boot
+    expect(startedWhenEnded).toEqual([true, true]);
+  }, 30_000);
+
+  it('the store writer, closed while its worker boots', async () => {
+    const { StoreWriter } = require('../dist/extraction/store-writer') as typeof import('../src/extraction/store-writer');
+    const writer = new StoreWriter(path.resolve(__dirname, '../dist/extraction/store-worker.js'), dbPath, false);
+    await writer.close(0);
+    expect(startedWhenEnded.every(Boolean)).toBe(true);
+  }, 30_000);
+});
diff --git a/codegraph-kernel/build.rs b/codegraph-kernel/build.rs
index 8e620ee99b..e52d8209c8 100644
--- a/codegraph-kernel/build.rs
+++ b/codegraph-kernel/build.rs
@@ -9,6 +9,9 @@ fn main() {
     // against the crates.io tarball (kotlin checklist §Grammar prep):
     //   parser.c  54104a7ef1555c265b746c790e0f8bb953cc17806e9df0c3af82f7f62c06a70a
     //   scanner.c 27f73337ec357fc341fa57538f34c14277b0346980c3405dc30beab6202ec6d0
+    // scanner.c carries docs/grammars/tree-sitter-kotlin.patch (same-line
+    // `e`-word semicolon fix), shared with the wasm build:
+    //   scanner.c 2ca842dd04b60b0a6df59a03e9ad01209d8c5641f079a79a84d65708669b6cb6 (patched)
     // Flags crib the tarball's own bindings/rust/build.rs.
     let mut c = cc::Build::new();
     c.include("grammars/kotlin");
diff --git a/codegraph-kernel/grammars/kotlin/scanner.c b/codegraph-kernel/grammars/kotlin/scanner.c
index a9979ade8b..aa3c60a599 100644
--- a/codegraph-kernel/grammars/kotlin/scanner.c
+++ b/codegraph-kernel/grammars/kotlin/scanner.c
@@ -285,9 +285,11 @@ static bool scan_automatic_semicolon(TSLexer *lexer) {
 
   if (sameline) {
     switch (lexer->lookahead) {
-      // Don't insert a semicolon before an else
+      // Don't insert a semicolon before an else — nor before any other word
+      // starting with `e` on the same line: that is an infix call
+      // (`Users.id eq id1`), which continues the expression. (codegraph patch)
       case 'e':
-        return !scan_for_word(lexer, "lse", 3);
+        return false;
 
       case 'i':
         return scan_for_word(lexer, "mport", 5);
diff --git a/codegraph-kernel/src/ccpp/brace_scopes.rs b/codegraph-kernel/src/ccpp/brace_scopes.rs
new file mode 100644
index 0000000000..072c14113e
--- /dev/null
+++ b/codegraph-kernel/src/ccpp/brace_scopes.rs
@@ -0,0 +1,416 @@
+//! C++ scopes read from the source's braces, for a file whose parse tree has
+//! errors — a port of src/extraction/languages/cpp-brace-scopes.ts (read its
+//! header for why). Byte offsets here, UTF-16 code units there; columns go
+//! through `col16` so positions match the wasm walker's.
+//!
+//! Only reachable under the `CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT=1` sweep
+//! hatch: every other erroring file defers to wasm before the walk starts.
+
+use crate::textutil as util;
+use std::collections::HashMap;
+
+/// Intervals that nest properly, added in order of their opening offset.
+pub struct NestedIntervals<T: Clone> {
+    opens: Vec<usize>,
+    closes: Vec<usize>,
+    parents: Vec<Option<usize>>,
+    values: Vec<T>,
+}
+
+impl<T: Clone> NestedIntervals<T> {
+    pub fn new() -> Self {
+        NestedIntervals { opens: Vec::new(), closes: Vec::new(), parents: Vec::new(), values: Vec::new() }
+    }
+
+    /// Adds the interval `(open, close)`. One that opens before the last one
+    /// added, or crosses one that holds it, is refused (false).
+    pub fn add(&mut self, open: usize, close: usize, value: T) -> bool {
+        if close <= open || self.opens.last().is_some_and(|&last| open <= last) {
+            return false;
+        }
+        let parent = self.innermost(open);
+        if let Some(p) = parent {
+            if close >= self.closes[p] {
+                return false;
+            }
+        }
+        self.opens.push(open);
+        self.closes.push(close);
+        self.parents.push(parent);
+        self.values.push(value);
+        true
+    }
+
+    /// The values of the intervals holding `offset` (open < offset < close), outermost first.
+    pub fn at(&self, offset: usize) -> Vec<T> {
+        let mut out = Vec::new();
+        let mut k = self.innermost(offset);
+        while let Some(i) = k {
+            out.push(self.values[i].clone());
+            k = self.parents[i];
+        }
+        out.reverse();
+        out
+    }
+
+    /// The innermost interval holding `offset`: the last interval opening
+    /// before `offset` or one of the intervals around that one.
+    fn innermost(&self, offset: usize) -> Option<usize> {
+        let count = self.opens.partition_point(|&o| o < offset);
+        let mut k = if count == 0 { None } else { Some(count - 1) };
+        while let Some(i) = k {
+            if self.closes[i] > offset {
+                break;
+            }
+            k = self.parents[i];
+        }
+        k
+    }
+}
+
+pub struct BraceScopes {
+    closes: HashMap<usize, usize>,
+    namespaces: NestedIntervals<String>,
+}
+
+impl BraceScopes {
+    /// The offset of the `}` that closes the `{` at `open`.
+    pub fn close_of(&self, open: usize) -> Option<usize> {
+        self.closes.get(&open).copied()
+    }
+
+    /// The named namespaces whose braces hold `offset`, outermost first, as written.
+    pub fn namespaces_at(&self, offset: usize) -> Vec<String> {
+        self.namespaces.at(offset)
+    }
+
+    /// The 1-based line and the UTF-16 column of `offset`.
+    pub fn position_of(src: &str, line_starts: &[usize], offset: usize) -> (u32, u32) {
+        let row = line_starts.partition_point(|&s| s <= offset).saturating_sub(1);
+        (row as u32 + 1, util::col16(src, line_starts, row, offset))
+    }
+}
+
+fn is_blank(c: u8) -> bool {
+    matches!(c, b' ' | b'\t' | b'\r' | 0x0c | 0x0b)
+}
+fn is_word_start(c: u8) -> bool {
+    c.is_ascii_alphabetic() || c == b'_' || c == b'$' || c >= 0x80
+}
+fn is_word_char(c: u8) -> bool {
+    is_word_start(c) || c.is_ascii_digit()
+}
+fn at(s: &[u8], i: usize) -> u8 {
+    s.get(i).copied().unwrap_or(0)
+}
+fn find(src: &str, from: usize, pat: &str) -> Option<usize> {
+    src.get(from..).and_then(|rest| rest.find(pat)).map(|k| from + k)
+}
+
+/// The end of a `//` comment starting at `i`: its newline (a `\` before it continues the comment).
+fn line_comment_end(src: &str, mut i: usize) -> usize {
+    let s = src.as_bytes();
+    loop {
+        let Some(nl) = find(src, i, "\n") else { return s.len() };
+        let mut k = nl as isize - 1;
+        if k >= 0 && s[k as usize] == b'\r' {
+            k -= 1;
+        }
+        if k < 0 || s[k as usize] != b'\\' {
+            return nl;
+        }
+        i = nl + 1;
+    }
+}
+
+/// Past whitespace and comments from `i`.
+fn skip_blank(src: &str, mut i: usize) -> usize {
+    let s = src.as_bytes();
+    while i < s.len() {
+        let c = s[i];
+        if is_blank(c) || c == b'\n' {
+            i += 1;
+        } else if c == b'/' && at(s, i + 1) == b'/' {
+            i = line_comment_end(src, i + 2);
+        } else if c == b'/' && at(s, i + 1) == b'*' {
+            i = find(src, i + 2, "*/").map_or(s.len(), |e| e + 2);
+        } else {
+            break;
+        }
+    }
+    i
+}
+
+/// The end of the identifier at `i`, if one starts there.
+fn word_end(s: &[u8], i: usize) -> Option<usize> {
+    if i >= s.len() || !is_word_start(s[i]) {
+        return None;
+    }
+    let mut j = i + 1;
+    while j < s.len() && is_word_char(s[j]) {
+        j += 1;
+    }
+    Some(j)
+}
+
+/// Past the string or character literal whose quote is at `i` (it stops at a newline).
+fn quoted_end(s: &[u8], i: usize) -> usize {
+    let quote = s[i];
+    let mut j = i + 1;
+    while j < s.len() {
+        let c = s[j];
+        if c == b'\\' {
+            j += if at(s, j + 1) == b'\r' && at(s, j + 2) == b'\n' { 3 } else { 2 };
+        } else if c == quote {
+            return j + 1;
+        } else if c == b'\n' {
+            return j;
+        } else {
+            j += 1;
+        }
+    }
+    s.len()
+}
+
+/// Past the `(…)` group at `i` (strings inside skipped).
+fn paren_group_end(s: &[u8], i: usize) -> Option<usize> {
+    let mut depth = 0usize;
+    let mut j = i;
+    while j < s.len() {
+        let c = s[j];
+        if c == b'"' || c == b'\'' {
+            j = quoted_end(s, j);
+            continue;
+        }
+        if c == b'(' {
+            depth += 1;
+        } else if c == b')' {
+            depth = depth.saturating_sub(1);
+            if depth == 0 {
+                return Some(j + 1);
+            }
+        }
+        j += 1;
+    }
+    None
+}
+
+/// namespaceHead: after the `namespace` keyword ending at `from`, the name as
+/// written and the offset of the body's `{`.
+fn namespace_head(src: &str, from: usize) -> Option<(String, usize)> {
+    let s = src.as_bytes();
+    let mut i = skip_blank(src, from);
+    while src.get(i..).is_some_and(|r| r.starts_with("[[")) {
+        let end = find(src, i + 2, "]]")?;
+        i = skip_blank(src, end + 2);
+    }
+    let mut name: Option<(usize, usize)> = None;
+    while let Some(end) = word_end(s, i) {
+        name = Some((name.map_or(i, |(start, _)| start), end));
+        i = skip_blank(src, end);
+        if !src.get(i..).is_some_and(|r| r.starts_with("::")) {
+            break;
+        }
+        i = skip_blank(src, i + 2);
+        if let Some(inline) = word_end(s, i) {
+            if &src[i..inline] == "inline" {
+                i = skip_blank(src, inline);
+            }
+        }
+    }
+    if name.is_some() {
+        while let Some(end) = word_end(s, i) {
+            let paren = skip_blank(src, end);
+            if at(s, paren) != b'(' {
+                return None;
+            }
+            i = skip_blank(src, paren_group_end(s, paren)?);
+        }
+    }
+    if at(s, i) != b'{' {
+        return None;
+    }
+    Some((name.map_or(String::new(), |(start, end)| src[start..end].to_string()), i))
+}
+
+fn is_raw_delimiter(d: &[u8]) -> bool {
+    d.len() <= 16 && d.iter().all(|&b| (0x21..=0x7e).contains(&b) && !matches!(b, b'"' | b'(' | b')' | b'\\'))
+}
+
+fn is_raw_prefix(w: &[u8]) -> bool {
+    matches!(w, b"R" | b"uR" | b"UR" | b"LR" | b"u8R")
+}
+
+struct Branch {
+    at_if: Vec<usize>,
+    after_first: Option<Vec<usize>>,
+}
+
+/// scanCppBraceScopes: `src` as the parser saw it (after preParse). None when
+/// the braces don't balance.
+pub fn scan(src: &str) -> Option<BraceScopes> {
+    let s = src.as_bytes();
+    let n = s.len();
+    let mut closes: HashMap<usize, usize> = HashMap::new();
+    let mut open: Vec<usize> = Vec::new();
+    let mut branches: Vec<Branch> = Vec::new();
+    let mut namespace_at: Vec<(usize, String)> = Vec::new();
+    let mut pending_namespace: Option<(String, usize)> = None;
+    let mut balanced = true;
+    let mut line_start = true;
+    let mut word_start: usize = 0;
+    let mut word_end_at: Option<usize> = None;
+    // Past a byte-order mark, so line 1 can be a directive.
+    let mut i = if src.starts_with('\u{feff}') { 3 } else { 0 };
+    while i < n {
+        let c = s[i];
+        if c == b'\n' {
+            line_start = true;
+            i += 1;
+            continue;
+        }
+        if is_blank(c) {
+            i += 1;
+            continue;
+        }
+        if c == b'/' && at(s, i + 1) == b'/' {
+            i = line_comment_end(src, i + 2);
+            continue;
+        }
+        if c == b'/' && at(s, i + 1) == b'*' {
+            i = find(src, i + 2, "*/").map_or(n, |e| e + 2);
+            continue;
+        }
+        if c == b'#' && line_start {
+            let mut j = i + 1;
+            while j < n && is_blank(s[j]) {
+                j += 1;
+            }
+            let directive: &[u8] = match word_end(s, j) {
+                Some(e) => &s[j..e],
+                None => b"",
+            };
+            while j < n {
+                let d = s[j];
+                if d == b'\n' {
+                    let mut k = j as isize - 1;
+                    if k >= 0 && s[k as usize] == b'\r' {
+                        k -= 1;
+                    }
+                    if k < 0 || s[k as usize] != b'\\' {
+                        break;
+                    }
+                    j += 1;
+                } else if d == b'/' && at(s, j + 1) == b'/' {
+                    j = line_comment_end(src, j + 2);
+                } else if d == b'/' && at(s, j + 1) == b'*' {
+                    j = find(src, j + 2, "*/").map_or(n, |e| e + 2);
+                } else if d == b'"' {
+                    j = quoted_end(s, j);
+                } else {
+                    j += 1;
+                }
+            }
+            match directive {
+                b"if" | b"ifdef" | b"ifndef" => branches.push(Branch { at_if: open.clone(), after_first: None }),
+                b"else" | b"elif" | b"elifdef" | b"elifndef" => {
+                    if let Some(group) = branches.last_mut() {
+                        let at_if = group.at_if.clone();
+                        let current = std::mem::replace(&mut open, at_if);
+                        if group.after_first.is_none() {
+                            group.after_first = Some(current);
+                        }
+                    }
+                }
+                b"endif" => {
+                    if let Some(group) = branches.pop() {
+                        if let Some(after) = group.after_first {
+                            open = after;
+                        }
+                    }
+                }
+                _ => {}
+            }
+            i = j;
+            continue;
+        }
+        line_start = false;
+        if c == b'"' {
+            if word_end_at == Some(i) && is_raw_prefix(&s[word_start..i]) {
+                if let Some(paren) = find(src, i + 1, "(") {
+                    let delimiter = &src[i + 1..paren];
+                    if is_raw_delimiter(delimiter.as_bytes()) {
+                        let close = format!("){delimiter}\"");
+                        i = find(src, paren + 1, &close).map_or(n, |e| e + delimiter.len() + 2);
+                        continue;
+                    }
+                }
+            }
+            i = quoted_end(s, i);
+            continue;
+        }
+        if c == b'\'' {
+            i = quoted_end(s, i);
+            continue;
+        }
+        if c.is_ascii_digit() || (c == b'.' && at(s, i + 1).is_ascii_digit()) {
+            let mut j = i + 1;
+            while j < n {
+                let d = s[j];
+                if is_word_char(d) || d == b'.' {
+                    j += 1;
+                } else if d == b'\'' && is_word_char(at(s, j + 1)) {
+                    j += 2;
+                } else if (d == b'+' || d == b'-') && matches!(s[j - 1], b'e' | b'E' | b'p' | b'P') {
+                    j += 1;
+                } else {
+                    break;
+                }
+            }
+            word_start = i;
+            word_end_at = Some(j);
+            i = j;
+            continue;
+        }
+        if is_word_start(c) {
+            let end = word_end(s, i).unwrap_or(i + 1);
+            word_start = i;
+            word_end_at = Some(end);
+            if &s[i..end] == b"namespace" {
+                if let Some(head) = namespace_head(src, end) {
+                    pending_namespace = Some(head);
+                }
+            }
+            i = end;
+            continue;
+        }
+        if c == b'{' {
+            open.push(i);
+            if pending_namespace.as_ref().is_some_and(|(_, brace)| *brace == i) {
+                let (name, _) = pending_namespace.take().unwrap();
+                if !name.is_empty() {
+                    namespace_at.push((i, name));
+                }
+            }
+        } else if c == b'}' {
+            match open.pop() {
+                None => balanced = false,
+                Some(from) => {
+                    closes.entry(from).or_insert(i);
+                }
+            }
+        }
+        i += 1;
+    }
+    if !balanced || !open.is_empty() {
+        return None;
+    }
+    namespace_at.sort_by_key(|(brace, _)| *brace);
+    let mut namespaces = NestedIntervals::new();
+    for (brace, name) in namespace_at {
+        if let Some(&close) = closes.get(&brace) {
+            namespaces.add(brace, close, name);
+        }
+    }
+    Some(BraceScopes { closes, namespaces })
+}
diff --git a/codegraph-kernel/src/ccpp/mod.rs b/codegraph-kernel/src/ccpp/mod.rs
index ef546e7261..415ca3bca0 100644
--- a/codegraph-kernel/src/ccpp/mod.rs
+++ b/codegraph-kernel/src/ccpp/mod.rs
@@ -14,6 +14,10 @@
 //!  - cpp namespace prefix stack (#1291): named `namespace a::b {` pushes the
 //!    name AS WRITTEN onto the qualifiedName prefix; anonymous falls through.
 //!    No namespace NODE is minted (#1093 crowd-out).
+//!  - cpp brace scopes (brace_scopes.rs): when the tree has errors, each node
+//!    is walked in the namespaces, and at declaration level the classes, the
+//!    source's braces put it in, not the tree's (error recovery closes scopes
+//!    at the wrong `}`). Only the error-extract hatch reaches it here.
 //!  - out-of-line `Cls::method` defs: name = LAST `::` segment of the
 //!    declarator's qualified_identifier (BFS that skips parameter_list +
 //!    trailing_return_type), receiver = the template-stripped qualifier,
@@ -33,11 +37,13 @@
 //!    (loses uninit scalars by design); cpp declarations instead take the TS
 //!    GENERIC fallback (direct identifier children only → `int x;` extracts,
 //!    `int x = 5;` does not — bug-for-bug).
-//!  - inheritance quirk: extractInheritance recurses into
-//!    field_declaration_list, where a field_declaration with no DIRECT
-//!    field_identifier child (pointer/array/method members) but a direct
-//!    type_identifier emits an `extends` ref to that type (the Go-embedding
-//!    branch matching c/cpp shapes). Kept: the parity gate pins today's graph.
+//!  - a class/struct/union/enum defined in a declaration's `type`
+//!    (`struct Foo { … } foo;`) is walked before the variables — in C, and in
+//!    C++ unless the tree has errors and no brace scopes (walkDeclaredTypes);
+//!    an unnamed one takes the name of the first declarator identifier
+//!    (`static struct { … } SPT;` → `SPT`, in function bodies too), and the
+//!    comment above the declaration is its docstring (c/cpp
+//!    getDeclarationWrapper).
 //!  - static-member/value-read pass (cpp only): `field_expression` is in
 //!    MEMBER_ACCESS_TYPES (listed for Scala, same node kind in cpp), so
 //!    `Capitalized.member` / `Capitalized->member` VALUE reads emit
@@ -80,6 +86,9 @@ use std::collections::{HashMap, HashSet, VecDeque};
 use std::sync::OnceLock;
 use tree_sitter::{Node, Parser};
 
+mod brace_scopes;
+use brace_scopes::{BraceScopes, NestedIntervals};
+
 const MAX_VALUE_REF_NODES: usize = 20_000;
 
 // --- compiled regexes (JS \w/\s spelled as ASCII classes for parity) ---------
@@ -287,6 +296,7 @@ pub enum Variant {
     Cpp,
 }
 
+#[derive(Clone)]
 struct Scope {
     row: u32,
     kind: &'static str,
@@ -302,6 +312,8 @@ struct Extra {
     is_abstract: Option<bool>,
     return_type: Option<String>,
     qualified_name: Option<String>,
+    /// (endLine, endColumn) in place of the node's own (brace scopes).
+    end: Option<(u32, u32)>,
 }
 
 struct ValueScope<'t> {
@@ -358,6 +370,16 @@ pub struct Walker<'t> {
     fs_values: HashMap<String, u32>,
     fs_value_counts: HashMap<String, u32>,
     value_scopes: Vec<ValueScope<'t>>,
+    /// A cpp file whose tree has errors is walked in the scopes its braces
+    /// open (visit_in_brace_scope; only under the error-extract hatch): the
+    /// scan, and the class-like nodes extracted so far by their bodies' braces.
+    brace_scopes: Option<BraceScopes>,
+    class_scopes: NestedIntervals<Scope>,
+    class_scope_rows: HashSet<u32>,
+    /// walkDeclaredTypes (tree-sitter.ts): a class-like type defined in a
+    /// declaration is walked in C, and in C++ unless the tree has errors and
+    /// its braces don't balance (no brace scopes; only under the hatch).
+    walk_declared_types: bool,
 }
 
 pub fn extract(file_path: &str, source: &str, language: &str) -> Result<EmitOut, String> {
@@ -383,6 +405,13 @@ pub fn extract(file_path: &str, source: &str, language: &str) -> Result<EmitOut,
         return Err("defer: parse tree contains errors — wasm recovery is canonical".to_string());
     }
 
+    let brace_scopes = if variant == Variant::Cpp && tree.root_node().has_error() {
+        brace_scopes::scan(source)
+    } else {
+        None
+    };
+    let walk_declared_types =
+        variant == Variant::C || !tree.root_node().has_error() || brace_scopes.is_some();
     let mut w = Walker {
         src: source,
         file_path,
@@ -402,6 +431,10 @@ pub fn extract(file_path: &str, source: &str, language: &str) -> Result<EmitOut,
         fs_values: HashMap::new(),
         fs_value_counts: HashMap::new(),
         value_scopes: Vec::new(),
+        brace_scopes,
+        class_scopes: NestedIntervals::new(),
+        class_scope_rows: HashSet::new(),
+        walk_declared_types,
     };
 
     let line_count = source.bytes().filter(|b| *b == b'\n').count() as u32 + 1;
@@ -500,8 +533,10 @@ impl<'t> Walker<'t> {
         let column = self.col_of(node);
         let id = self.node_id_allocator.generate(self.file_path, kind, name, start_line, column);
         // (c/cpp define no resolveBody hook, so createNode's endLine extension
-        // for sibling-body grammars never fires — endLine is the node's own.)
-        let end_line = node.end_position().row as u32 + 1;
+        // for sibling-body grammars never fires — endLine is the node's own,
+        // or the `}` of its body in brace scopes.)
+        let (end_line, end_column) =
+            extra.end.unwrap_or_else(|| (node.end_position().row as u32 + 1, self.end_col_of(node)));
 
         let qualified = extra.qualified_name.unwrap_or_else(|| {
             let mut parts: Vec<&str> = self.namespace_prefix.iter().map(|s| s.as_str()).collect();
@@ -538,7 +573,7 @@ impl<'t> Walker<'t> {
             start_line,
             end_line,
             start_column: self.col_of(node),
-            end_column: self.end_col_of(node),
+            end_column,
             name: name_ref,
             qualified_name: qn_ref,
             id: id_ref,
@@ -610,6 +645,9 @@ impl<'t> Walker<'t> {
                 return hook;
             }
         }
+        if let Some(name) = self.unnamed_type_variable_name(node) {
+            return name;
+        }
         if let Some(name_node) = node.child_by_field_name("declarator") {
             let mut resolved = name_node;
             // Unwrap pointer/reference declarators (`int* f()`, `T& f()`).
@@ -650,6 +688,21 @@ impl<'t> Walker<'t> {
         "<anonymous>".to_string()
     }
 
+    /// unnamedTypeVariableName (languages/c-cpp.ts): an unnamed class, struct,
+    /// union or enum defined in a declaration takes the name of the first
+    /// variable the declaration declares (`static struct { … } SPT;` → `SPT`).
+    fn unnamed_type_variable_name(&self, node: Node) -> Option<String> {
+        if node.child_by_field_name("name").is_some() {
+            return None;
+        }
+        let declaration = defining_declaration(node)?;
+        let mut cursor = declaration.walk();
+        let identifier = declaration
+            .children_by_field_name("declarator", &mut cursor)
+            .find_map(c_declarator_identifier)?;
+        Some(self.text(identifier).to_string())
+    }
+
     /// extractCppQualifiedMethodName (languages/c-cpp.ts:75).
     fn extract_cpp_qualified_method_name(&self, node: Node) -> Option<String> {
         if let Some(n) = self.recover_cpp_macro_defined_name(node) {
@@ -904,6 +957,59 @@ impl<'t> Walker<'t> {
     // --- visitNode -----------------------------------------------------------
 
     fn visit_node(&mut self, node: Node<'t>) {
+        if self.brace_scopes.is_some() {
+            self.visit_in_brace_scope(node);
+        } else {
+            self.dispatch_node(node);
+        }
+    }
+
+    /// visitInCppBraceScope: walk `node` in the namespaces and classes its
+    /// source braces put it in (see brace_scopes.rs). The namespaces apply
+    /// everywhere; the enclosing classes only at declaration level, where the
+    /// stack above the file node holds nothing but class scopes.
+    fn visit_in_brace_scope(&mut self, node: Node<'t>) {
+        let at = node.start_byte();
+        let namespaces = self.brace_scopes.as_ref().map(|s| s.namespaces_at(at)).unwrap_or_default();
+        let saved = std::mem::replace(&mut self.namespace_prefix, namespaces);
+        let mut base = self.stack.len();
+        while base > 1 && self.class_scope_rows.contains(&self.stack[base - 1].row) {
+            base -= 1;
+        }
+        let mut walked: Option<Vec<Scope>> = None;
+        if base == 1 {
+            let classes = self.class_scopes.at(at);
+            let same = classes.len() == self.stack.len() - base
+                && classes.iter().zip(&self.stack[base..]).all(|(c, s)| c.row == s.row);
+            if !same {
+                walked = Some(self.stack.split_off(base));
+                self.stack.extend(classes);
+            }
+        }
+        self.dispatch_node(node);
+        if let Some(walked) = walked {
+            self.stack.truncate(base);
+            self.stack.extend(walked);
+        }
+        self.namespace_prefix = saved;
+    }
+
+    /// cppBodyEnd: where a class-like node ends in brace scopes — the `}`
+    /// that closes its body — or None to keep the tree's.
+    fn brace_body_end(&self, body: Node<'t>) -> Option<(u32, u32)> {
+        let close = self.brace_scopes.as_ref()?.close_of(body.start_byte())?;
+        Some(BraceScopes::position_of(self.src, &self.line_starts, close + 1))
+    }
+
+    /// openCppClassScope: a class-like node's body as a scope for visit_in_brace_scope.
+    fn open_class_scope(&mut self, scope: &Scope, body: Node<'t>) {
+        let Some(close) = self.brace_scopes.as_ref().and_then(|s| s.close_of(body.start_byte())) else { return };
+        if self.class_scopes.add(body.start_byte(), close, scope.clone()) {
+            self.class_scope_rows.insert(scope.row);
+        }
+    }
+
+    fn dispatch_node(&mut self, node: Node<'t>) {
         stack_guard!();
         let kind = node.kind();
         let mut skip_children = false;
@@ -970,8 +1076,33 @@ impl<'t> Walker<'t> {
         {
             skip_children = self.extract_type_alias(node);
         } else if kind == "declaration" && !self.inside_class_like() {
+            // A class, struct, union or enum defined in the declaration's type
+            // (`struct Foo { … } foo;`) is a definition like one written on its
+            // own, and the variables keep their nodes beside it — so is, in
+            // brace scopes, a class the tree reads as a declaration's type
+            // (glued to the tokens after it by error recovery). The fn-ref
+            // scan skips the walked type, which captured its own (the TS
+            // walked set).
+            let defined_type = node
+                .child_by_field_name("type")
+                .filter(|t| self.walk_declared_types && is_class_like_definition(*t));
+            if let Some(t) = defined_type {
+                self.visit_node(t);
+            }
             self.extract_variable(node);
-            self.scan_fn_ref_subtree(node, 0);
+            match defined_type {
+                Some(t) => {
+                    self.maybe_capture_fn_refs(node);
+                    for i in 0..node.named_child_count() {
+                        if let Some(c) = node.named_child(i) {
+                            if c.id() != t.id() {
+                                self.scan_fn_ref_subtree(c, 1);
+                            }
+                        }
+                    }
+                }
+                None => self.scan_fn_ref_subtree(node, 0),
+            }
             skip_children = true;
         } else if self.variant == Variant::Cpp
             && kind == "field_declaration"
@@ -1118,19 +1249,28 @@ impl<'t> Walker<'t> {
         self.stack.pop();
     }
 
+    /// docstringFor a class-like node: the comment above the declaration it is
+    /// defined in (the c/cpp getDeclarationWrapper), else above the node.
+    fn class_like_docstring(&self, node: Node<'t>) -> Option<String> {
+        preceding_docstring(defining_declaration(node).unwrap_or(node), self.src)
+    }
+
     /// extractClass for cpp class_specifier (skipBodilessClass, #1093).
     fn extract_class(&mut self, node: Node<'t>) {
         stack_guard!();
         let Some(body) = node.child_by_field_name("body") else { return };
         let name = self.extract_name(node);
         let extra = Extra {
-            docstring: preceding_docstring(node, self.src),
+            docstring: self.class_like_docstring(node),
             visibility: self.visibility_of(node),
+            end: self.brace_body_end(body),
             ..Extra::default()
         };
         let Some(row) = self.create_node("class", &name, node, extra) else { return };
+        let scope = Scope { row, kind: "class", name };
+        self.open_class_scope(&scope, body);
         self.extract_inheritance(node, row);
-        self.stack.push(Scope { row, kind: "class", name });
+        self.stack.push(scope);
         for i in 0..body.named_child_count() {
             if let Some(c) = body.named_child(i) {
                 self.visit_node(c);
@@ -1145,13 +1285,16 @@ impl<'t> Walker<'t> {
         let Some(body) = node.child_by_field_name("body") else { return };
         let name = self.extract_name(node);
         let extra = Extra {
-            docstring: preceding_docstring(node, self.src),
+            docstring: self.class_like_docstring(node),
             visibility: if self.variant == Variant::Cpp { self.visibility_of(node) } else { None },
+            end: self.brace_body_end(body),
             ..Extra::default()
         };
         let Some(row) = self.create_node(kind, &name, node, extra) else { return };
+        let scope = Scope { row, kind, name };
+        self.open_class_scope(&scope, body);
         self.extract_inheritance(node, row);
-        self.stack.push(Scope { row, kind, name });
+        self.stack.push(scope);
         for i in 0..body.named_child_count() {
             if let Some(c) = body.named_child(i) {
                 self.visit_node(c);
@@ -1165,7 +1308,7 @@ impl<'t> Walker<'t> {
         let Some(body) = node.child_by_field_name("body") else { return };
         let name = self.extract_name(node);
         let extra = Extra {
-            docstring: preceding_docstring(node, self.src),
+            docstring: self.class_like_docstring(node),
             visibility: if self.variant == Variant::Cpp { self.visibility_of(node) } else { None },
             ..Extra::default()
         };
@@ -1866,8 +2009,10 @@ impl<'t> Walker<'t> {
     // --- inheritance ---------------------------------------------------------
 
     /// extractInheritance — the branches whose node kinds occur in the c/cpp
-    /// grammars: base_class_clause (#1043), the field_declaration Go-embedding
-    /// shape, and the field_declaration_list recursion that reaches it.
+    /// grammars: base_class_clause (#1043) and the field_declaration_list
+    /// recursion. A member `field_declaration` is never a supertype: the TS
+    /// Go-embedding check is gated to Go, since c/cpp members nest their
+    /// field_identifier inside a pointer/array/function declarator.
     fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) {
         stack_guard!();
         let extends_kind = edge_kind_index("extends").unwrap();
@@ -1886,20 +2031,6 @@ impl<'t> Walker<'t> {
                         }
                     }
                 }
-                "field_declaration" => {
-                    let has_field_identifier = (0..child.named_child_count())
-                        .filter_map(|j| child.named_child(j))
-                        .any(|c| c.kind() == "field_identifier");
-                    if !has_field_identifier {
-                        let type_id = (0..child.named_child_count())
-                            .filter_map(|j| child.named_child(j))
-                            .find(|c| c.kind() == "type_identifier");
-                        if let Some(type_id) = type_id {
-                            let name = self.text(type_id).to_string();
-                            self.push_ref_at(class_row, &name, extends_kind, type_id);
-                        }
-                    }
-                }
                 "field_declaration_list" | "class_heritage" => {
                     self.extract_inheritance(child, class_row);
                 }
@@ -2216,7 +2347,7 @@ fn find_declarator_qualified_id(declarator: Node) -> Option<Node> {
     None
 }
 
-/// cDeclaratorIdentifier (tree-sitter.ts:234): resolve the declared identifier
+/// cDeclaratorIdentifier (languages/c-cpp.ts): resolve the declared identifier
 /// through init/pointer/array/parenthesized declarator wrappers; a
 /// function_declarator means prototype/fn-ptr — null. (The C grammar's
 /// parenthesized_declarator exposes no `declarator` field, so that arm always
@@ -2242,6 +2373,26 @@ fn c_declarator_identifier(node: Node) -> Option<Node> {
     None
 }
 
+/// isClassLikeDefinition (languages/c-cpp.ts): a class/struct/union/enum
+/// specifier that carries a body defines the type; `struct Foo *p` and the
+/// forward declaration `class Foo;` only name it.
+fn is_class_like_definition(node: Node) -> bool {
+    matches!(node.kind(), "class_specifier" | "struct_specifier" | "union_specifier" | "enum_specifier")
+        && node.child_by_field_name("body").is_some()
+}
+
+/// definingDeclaration (languages/c-cpp.ts): the `declaration` a class-like
+/// definition is the type of (`struct Foo { … } foo;`). Its comment documents
+/// the type, and an unnamed type takes the name of its first variable.
+fn defining_declaration(node: Node) -> Option<Node> {
+    if !is_class_like_definition(node) {
+        return None;
+    }
+    let parent = node.parent()?;
+    let is_type = parent.child_by_field_name("type").map(|t| t.id()) == Some(node.id());
+    (parent.kind() == "declaration" && is_type).then_some(parent)
+}
+
 /// isMacroMisparsedTypeDecl (languages/c-cpp.ts:261): `class MACRO Name {…}`
 /// misparse residue — bodyless class/struct specifier in `type` + a
 /// non-function_declarator declarator.
diff --git a/codegraph-kernel/src/csharp.rs b/codegraph-kernel/src/csharp.rs
index 75f9e0f8e8..c10696ec99 100644
--- a/codegraph-kernel/src/csharp.rs
+++ b/codegraph-kernel/src/csharp.rs
@@ -5,8 +5,8 @@
 //! path, bug-for-bug, verified by scripts/kernel-parity.mjs and the full-index
 //! dump-diff gate. The authoritative quirk list is
 //! docs/design/csharp-kernel-port-checklist.md — including every deliberate
-//! emission hole (property/accessor bodies, constructor initializers,
-//! delegates/events/operators/indexers, top-level locals) and garbage ref
+//! emission hole (constructor initializers, delegates/events/operators/
+//! indexers, top-level locals) and garbage ref
 //! (`(repo)` primary-ctor extends, `: byte` enum extends, `nameof` calls)
 //! this file preserves on purpose. Positions in UTF-16 code units. Files whose
 //! parse tree contains ERRORS defer to the wasm extractor.
@@ -205,34 +205,21 @@ pub fn extract(file_path: &str, source: &str) -> Result<EmitOut, String> {
     w.node_ids.push(ids::file_node_id(file_path));
     w.stack.push(Scope { row: 0, kind: "file", name: base_name.to_string() });
 
-    // extractFilePackage: the FIRST top-level namespace declaration mints ONE
-    // `namespace` node that stays pushed for the ENTIRE file — a second
-    // top-level namespace's types nest under the first's node/QN, nested
-    // namespaces leave no trace, and every import ref in a namespaced file
-    // hangs off this node (checklist §namespace).
+    // extractFilePackage: a top-level file-scoped `namespace X;` mints ONE
+    // `namespace` node that stays pushed for the ENTIRE file, so every import
+    // ref in the file hangs off it (checklist §namespace). A block namespace
+    // scopes only its own body — visit_node.
     let root = tree.root_node();
     let mut pkg_pushed = false;
     for i in 0..root.named_child_count() {
         let Some(child) = root.named_child(i) else { continue };
-        if child.kind() != "namespace_declaration"
-            && child.kind() != "file_scoped_namespace_declaration"
-        {
+        if child.kind() != "file_scoped_namespace_declaration" {
             continue;
         }
-        // csharpExtractor.extractPackage: `name` field ?? first
-        // qualified_name/identifier named child. No trim.
-        let name_node = child.child_by_field_name("name").or_else(|| {
-            (0..child.named_child_count())
-                .filter_map(|j| child.named_child(j))
-                .find(|c| matches!(c.kind(), "qualified_name" | "identifier"))
-        });
-        if let Some(name_node) = name_node {
-            let pkg = w.text(name_node).to_string();
-            if !pkg.is_empty() {
-                if let Some(row) = w.create_node("namespace", &pkg, child, Extra::default()) {
-                    w.stack.push(Scope { row, kind: "namespace", name: pkg });
-                    pkg_pushed = true;
-                }
+        if let Some(pkg) = namespace_name(&w, child) {
+            if let Some(row) = w.create_node("namespace", &pkg, child, Extra::default()) {
+                w.stack.push(Scope { row, kind: "namespace", name: pkg });
+                pkg_pushed = true;
             }
         }
         break;
@@ -265,6 +252,18 @@ fn record_is_struct(node: Node) -> bool {
         .any(|c| c.kind() == "struct")
 }
 
+/// csharpExtractor.extractPackage: `name` field ?? first qualified_name /
+/// identifier named child. No trim; None when empty.
+fn namespace_name(w: &Walker, node: Node) -> Option<String> {
+    let name_node = node.child_by_field_name("name").or_else(|| {
+        (0..node.named_child_count())
+            .filter_map(|j| node.named_child(j))
+            .find(|c| matches!(c.kind(), "qualified_name" | "identifier"))
+    })?;
+    let name = w.text(name_node);
+    (!name.is_empty()).then(|| name.to_string())
+}
+
 impl<'t> Walker<'t> {
     fn text(&self, node: Node) -> &'t str {
         &self.src[node.byte_range()]
@@ -418,7 +417,8 @@ impl<'t> Walker<'t> {
     // Java-style `modifiers` wrapper (probed).
 
     /// getVisibility: FIRST `modifier` child whose text is one of the four
-    /// levels wins; none → private (the C# default).
+    /// levels wins; none → public in an interface, internal in a namespace
+    /// or the file, private in a class or struct (the C# defaults).
     fn visibility_of(&self, node: Node) -> u8 {
         for i in 0..node.child_count() {
             let Some(child) = node.child(i) else { continue };
@@ -432,7 +432,17 @@ impl<'t> Walker<'t> {
                 }
             }
         }
-        2 // C# defaults to private
+        let parent = node.parent();
+        let container = match parent {
+            Some(p) if p.kind() == "declaration_list" => p.parent(),
+            other => other,
+        };
+        match container.map(|c| c.kind()) {
+            Some("interface_declaration") => 1,
+            None | Some("compilation_unit") | Some("namespace_declaration")
+            | Some("file_scoped_namespace_declaration") => 4,
+            _ => 2,
+        }
     }
 
     fn is_static(&self, node: Node) -> bool {
@@ -507,6 +517,38 @@ impl<'t> Walker<'t> {
         let kind = node.kind();
         let mut skip_children = false;
 
+        // A block namespace scopes only its body (tree-sitter.ts visitNode):
+        // one written inside another is `Outer.Inner`, taking the outer's
+        // place on the stack while its body is walked.
+        if kind == "namespace_declaration" {
+            if let Some(ns_name) = namespace_name(self, node) {
+                let outer = match self.stack.last() {
+                    Some(top) if top.kind == "namespace" => self.stack.pop(),
+                    _ => None,
+                };
+                let full = match &outer {
+                    Some(o) => format!("{}.{}", o.name, ns_name),
+                    None => ns_name,
+                };
+                let row = self.create_node("namespace", &full, node, Extra::default());
+                if let Some(row) = row {
+                    self.stack.push(Scope { row, kind: "namespace", name: full });
+                }
+                for i in 0..node.named_child_count() {
+                    if let Some(c) = node.named_child(i) {
+                        self.visit_node(c);
+                    }
+                }
+                if row.is_some() {
+                    self.stack.pop();
+                }
+                if let Some(o) = outer {
+                    self.stack.push(o);
+                }
+                return;
+            }
+        }
+
         self.maybe_capture_fn_refs(node);
 
         if kind == "class_declaration" || kind == "record_declaration" {
@@ -530,21 +572,41 @@ impl<'t> Walker<'t> {
             self.extract_enum(node);
             skip_children = true;
         } else if kind == "property_declaration" && self.inside_class_like() {
-            // Property accessor/expression bodies are NEVER walked (calls
-            // inside are lost by design) — candidates-only scan.
-            self.extract_property(node);
-            self.scan_fn_ref_subtree(node, 0);
+            // The code a property runs — its accessor bodies, `=> expr` and
+            // `= initializer` — is walked with the property on the stack
+            // (propertyBodies). The candidates-only scan covers the rest,
+            // skipping what the body walk captured.
+            let walked: Vec<usize> = match self.extract_property(node) {
+                Some((row, name)) => {
+                    let bodies = property_bodies(node);
+                    if !bodies.is_empty() {
+                        self.stack.push(Scope { row, kind: "property", name });
+                        let declared = node.child_by_field_name("type");
+                        for body in &bodies {
+                            self.extract_target_typed_new(Some(*body), declared);
+                            self.visit_function_body(*body);
+                        }
+                        self.stack.pop();
+                    }
+                    bodies.iter().map(|b| b.id()).collect()
+                }
+                None => Vec::new(),
+            };
+            self.scan_fn_ref_subtree(node, 0, &walked);
             skip_children = true;
         } else if kind == "field_declaration" && self.inside_class_like() {
-            self.extract_field(node);
-            self.scan_fn_ref_subtree(node, 0);
+            // Each declarator, `= initializer` included, is walked with its
+            // field on the stack (extract_field); the candidates-only scan
+            // covers the rest, skipping the declarators that walk captured.
+            let walked = self.extract_field(node);
+            self.scan_fn_ref_subtree(node, 0, &walked);
             skip_children = true;
         } else if kind == "local_declaration_statement" && !self.inside_class_like() {
             // Top-level statements: extractVariable's generic fallback finds no
             // direct identifier/variable_declarator children (C# nests them in
             // variable_declaration) → ZERO nodes, zero refs. Candidates only.
             self.extract_variable(node);
-            self.scan_fn_ref_subtree(node, 0);
+            self.scan_fn_ref_subtree(node, 0, &[]);
             skip_children = true;
         } else if kind == "using_directive" {
             self.extract_import(node);
@@ -747,9 +809,9 @@ impl<'t> Walker<'t> {
     }
 
     /// extractProperty (1986) — property_declaration only (dispatch-gated to
-    /// class-like scopes). Accessor bodies and `=>` value clauses are never
-    /// walked; type refs DO come from the `type` field.
-    fn extract_property(&mut self, node: Node<'t>) {
+    /// class-like scopes). Type refs come from the `type` field; the caller
+    /// walks the bodies (property_bodies) with the returned row on the stack.
+    fn extract_property(&mut self, node: Node<'t>) -> Option<(u32, String)> {
         let docstring = preceding_docstring(node, self.src);
         let visibility = Some(self.visibility_of(node));
         let is_static = Some(self.is_static(node)); // ?? false — always concrete
@@ -762,10 +824,10 @@ impl<'t> Walker<'t> {
                     .filter_map(|i| node.named_child(i))
                     .find(|c| c.kind() == "identifier")
             });
-        let Some(name_node) = name_node else { return };
+        let name_node = name_node?;
         let name = self.text(name_node).to_string();
         if name.is_empty() {
-            return;
+            return None;
         }
 
         // Generic scan (isTsJsField=false): FIRST namedChild that isn't a
@@ -800,16 +862,18 @@ impl<'t> Walker<'t> {
             &name,
             node,
             Extra { docstring, signature: Some(signature), visibility, is_static, ..Extra::default() },
-        );
-        if let Some(row) = row {
-            // decorators: none for C#; then the csharp type-ref path.
-            self.extract_csharp_type_refs(node, row);
-        }
+        )?;
+        // decorators: none for C#; then the csharp type-ref path.
+        self.extract_csharp_type_refs(node, row);
+        Some((row, name))
     }
 
     /// extractField (2046) — field_declaration; each declarator becomes a
-    /// field/constant node anchored at the DECLARATOR.
-    fn extract_field(&mut self, node: Node<'t>) {
+    /// field/constant node anchored at the DECLARATOR, and the declarator —
+    /// its `= initializer` — is walked with that node on the stack. Returns
+    /// the walked declarators, for the fn-ref scan to skip.
+    fn extract_field(&mut self, node: Node<'t>) -> Vec<usize> {
+        let mut walked = Vec::new();
         let docstring = preceding_docstring(node, self.src);
         let visibility = Some(self.visibility_of(node));
         let is_static = Some(self.is_static(node));
@@ -876,6 +940,15 @@ impl<'t> Walker<'t> {
                     // multi-declarator fields emit the type refs once PER
                     // declarator, each from its own field node.
                     self.extract_csharp_type_refs(node, row);
+                    // The initializer is the declarator's last, unnamed child:
+                    // its calls, instantiations, static reads and fn-ref
+                    // candidates (varinit included) are the field's.
+                    self.stack.push(Scope { row, kind: field_kind, name });
+                    let declared = var_decl.and_then(|vd| vd.child_by_field_name("type"));
+                    self.extract_target_typed_new(last_named_child(decl), declared);
+                    self.visit_function_body(decl);
+                    self.stack.pop();
+                    walked.push(decl.id());
                 }
             }
         } else {
@@ -895,6 +968,44 @@ impl<'t> Walker<'t> {
                 );
             }
         }
+        walked
+    }
+
+    /// extractTargetTypedNew (tree-sitter.ts) — a target-typed `new()`
+    /// (implicit_object_creation_expression) names no type, so it is no
+    /// instantiation kind; as a field's or property's initializer it
+    /// constructs the declared type (`List<Foo> _items = new();` → List).
+    /// Emitted from the stack top (the member) at the `new()`.
+    fn extract_target_typed_new(&mut self, value: Option<Node<'t>>, declared: Option<Node<'t>>) {
+        let Some(value) = value else { return };
+        if value.kind() != "implicit_object_creation_expression" || self.stack.is_empty() {
+            return;
+        }
+        let Some(class_name) = declared.and_then(|t| self.class_type_name(t)) else { return };
+        let from = self.top_row();
+        self.push_ref_at(from, &class_name, edge_kind_index("instantiates").unwrap(), value);
+    }
+
+    /// csharpClassTypeName (tree-sitter.ts) — the class a declared type
+    /// names, as `new T()` would name it: `List<Foo>` → List, `Ns.Foo` /
+    /// `global::Foo` → Foo, `Foo?` → Foo. Predefined, array, tuple and pointer
+    /// types name no class.
+    fn class_type_name(&self, node: Node) -> Option<String> {
+        match node.kind() {
+            "identifier" => {
+                let text = self.text(node);
+                (!text.is_empty()).then(|| text.to_string())
+            }
+            "generic_name" => {
+                let ident = (0..node.named_child_count())
+                    .filter_map(|i| node.named_child(i))
+                    .find(|c| c.kind() == "identifier")?;
+                self.class_type_name(ident)
+            }
+            "qualified_name" | "alias_qualified_name" => self.class_type_name(node.child_by_field_name("name")?),
+            "nullable_type" => self.class_type_name(node.child_by_field_name("type")?),
+            _ => None,
+        }
     }
 
     /// extractMethod (1737) — method_declaration + constructor_declaration.
@@ -1086,7 +1197,8 @@ impl<'t> Walker<'t> {
         let Some(ctor) = ctor else { return };
         // `new List<Foo>()` → `List`; `new Ns.Foo()` → `Foo`. Target-typed
         // `new()` / anonymous `new { }` / arrays `new T[n]` never reach here
-        // (not in INSTANTIATION_KINDS) — invisible by design.
+        // (not in INSTANTIATION_KINDS) — invisible by design, except a `new()`
+        // that initializes a field or property (extract_target_typed_new).
         let class_name = strip_generic_and_qualifier(self.text(ctor));
         if !class_name.is_empty() {
             let from = self.top_row();
@@ -1426,14 +1538,19 @@ impl<'t> Walker<'t> {
         });
     }
 
-    fn scan_fn_ref_subtree(&mut self, node: Node<'t>, depth: u32) {
+    fn scan_fn_ref_subtree(&mut self, node: Node<'t>, depth: u32, walked: &[usize]) {
         stack_guard!();
         if depth > 12 {
             return;
         }
+        // Subtrees the body walker has already been through.
+        if walked.contains(&node.id()) {
+            return;
+        }
         // functionTypes is EMPTY for C#; the literal halt list applies —
-        // lambda_expression IS C#'s lambda, so initializer lambdas stop the
-        // scan; anonymous_method_expression is NOT listed and scans through.
+        // lambda_expression IS C#'s lambda, so a lambda the scan reaches (a
+        // top-level statement's) stops it; anonymous_method_expression is NOT
+        // listed and scans through. Member initializers are walked instead.
         if depth > 0
             && matches!(
                 node.kind(),
@@ -1445,7 +1562,7 @@ impl<'t> Walker<'t> {
         self.maybe_capture_fn_refs(node);
         for i in 0..node.named_child_count() {
             if let Some(c) = node.named_child(i) {
-                self.scan_fn_ref_subtree(c, depth + 1);
+                self.scan_fn_ref_subtree(c, depth + 1, walked);
             }
         }
     }
@@ -1582,6 +1699,33 @@ impl<'t> Walker<'t> {
     }
 }
 
+/// propertyBodies (tree-sitter.ts) — the parts of a property that run code:
+/// each accessor's `body` (a block or `=> expr`), then the property's
+/// `value` — an expression body's `=> …` or an `= initializer`. Attributes
+/// are not walked.
+fn property_bodies(node: Node) -> Vec<Node> {
+    let mut bodies = Vec::new();
+    if let Some(accessors) = node.child_by_field_name("accessors") {
+        for i in 0..accessors.named_child_count() {
+            let Some(accessor) = accessors.named_child(i) else { continue };
+            if accessor.kind() != "accessor_declaration" {
+                continue;
+            }
+            if let Some(body) = accessor.child_by_field_name("body") {
+                bodies.push(body);
+            }
+        }
+    }
+    if let Some(value) = node.child_by_field_name("value") {
+        bodies.push(value);
+    }
+    bodies
+}
+
+fn last_named_child(node: Node) -> Option<Node> {
+    node.named_child(node.named_child_count().checked_sub(1)?)
+}
+
 fn find_anonymous_class_body(node: Node) -> Option<Node> {
     for i in 0..node.named_child_count() {
         if let Some(child) = node.named_child(i) {
diff --git a/codegraph-kernel/src/dart.rs b/codegraph-kernel/src/dart.rs
index 8182069b01..78bc8a5db9 100644
--- a/codegraph-kernel/src/dart.rs
+++ b/codegraph-kernel/src/dart.rs
@@ -18,9 +18,12 @@
 //! `.`); `ConfigT.load()` double-emits (calls + a static-member references
 //! ref — no callee-of-call skip in the dart branch); operator methods mint
 //! `method "<anonymous>"`; the unnamed constructor is skipped
-//! (isMisparsedFunction) while named ctors/factories are named by the CTOR
-//! name with the class as returnType; instance fields mint NO nodes (only
-//! static_final_declaration → constant, via the hook); prefixed return
+//! (isMisparsedFunction) while named ctors/factories — `const` ones and
+//! redirecting factories included — are named by the CTOR name with the
+//! class as returnType; instance fields mint NO nodes (only
+//! static_final_declaration → constant, via the hook); every initializer is
+//! body-walked once — a constant's from the constant, a field's or a
+//! top-level variable's from the class or the file; prefixed return
 //! types keep the PREFIX (`other.OtherClass f()` → returnType `other` —
 //! bug, preserved); enum `with` mixins emit nothing while enum `implements`
 //! works; deferred imports are invisible; named-argument callbacks are NOT
@@ -33,7 +36,7 @@ use crate::buffers::{
     RefRow, StrRef, Tables, FLAG_IS_ASYNC, FLAG_IS_EXPORTED, FLAG_IS_STATIC, FUNCTION_REF_CODE,
     NONE, NONE_STR,
 };
-use crate::docstring::preceding_docstring;
+use crate::docstring::preceding_docstring_stepping_over;
 use crate::ids;
 use crate::textutil as util;
 use regex::Regex;
@@ -43,6 +46,17 @@ use tree_sitter::{Node, Parser};
 
 const MAX_VALUE_REF_NODES: usize = 20_000;
 
+/// docstringStepOverTypes (dart.ts) — a member's annotations stand between it
+/// and the dartdoc written above them (`/// Builds the widget.` `@override`
+/// `Widget build(…)`), so the docstring walk steps over them.
+const DOCSTRING_STEP_OVER: &[&str] = &["annotation"];
+
+/// decoratorStepOverTypes (dart.ts) — an annotation belongs to the next
+/// declaration, whatever comments come between them (`@override`
+/// `// ignore: must_call_super` `void f()`), so the decorator scan steps over
+/// them.
+const DECORATOR_STEP_OVER: &[&str] = &["comment", "documentation_comment"];
+
 /// NAME_STOPLIST (function-ref.ts).
 fn is_stoplisted(name: &str) -> bool {
     matches!(
@@ -88,6 +102,60 @@ fn angle_args_re() -> &'static Regex {
     RE.get_or_init(|| Regex::new(r"<[^>]*>").unwrap())
 }
 
+/// The UpperCamel test of isDartTypeName (`/^[_$]*[A-Z]/`) — how Dart writes
+/// a type, `_Private` and `$Generated` ones included.
+fn is_upper_camel(text: &str) -> bool {
+    text.trim_start_matches(&['_', '$'][..])
+        .chars()
+        .next()
+        .map(|c| c.is_ascii_uppercase())
+        .unwrap_or(false)
+}
+
+/// DART_BODILESS_CTORS (dart.ts) — `const Foo.bar();` and a redirecting
+/// factory `const factory Foo.bar() = _Bar;`, each a signature kind of its
+/// own inside a `declaration`.
+fn is_bodiless_ctor(kind: &str) -> bool {
+    matches!(kind, "constant_constructor_signature" | "redirecting_factory_constructor_signature")
+}
+
+/// DART_LOWERCASE_TYPES (dart.ts) — Dart's lowercase built-in types, which a
+/// type argument can name: `<int>`, `<void>`.
+fn is_lowercase_type(name: &str) -> bool {
+    matches!(name, "int" | "double" | "num" | "bool" | "dynamic" | "void")
+}
+
+/// DART_PREFIXED (dart.ts) — what a callee can sit under in front of a
+/// generic call: `await`, `-`, `!`.
+fn is_prefixed(kind: &str) -> bool {
+    matches!(kind, "unary_expression" | "await_expression")
+}
+
+/// DART_COMMENTS (dart.ts) — line and block comments, and dartdoc.
+fn is_comment(node: Node) -> bool {
+    matches!(node.kind(), "comment" | "documentation_comment")
+}
+
+/// dartPrevNamed (dart.ts) — the named sibling before `node`, past comments:
+/// `tester //` + newline + `.state(…)` puts the comment, not `tester`, right
+/// before the `.state` selector.
+fn prev_named<'t>(node: Node<'t>) -> Option<Node<'t>> {
+    let mut prev = node.prev_named_sibling();
+    while let Some(p) = prev.filter(|p| is_comment(*p)) {
+        prev = p.prev_named_sibling();
+    }
+    prev
+}
+
+/// dartNextNamed (dart.ts) — the named sibling after `node`, past comments.
+fn next_named<'t>(node: Node<'t>) -> Option<Node<'t>> {
+    let mut next = node.next_named_sibling();
+    while let Some(n) = next.filter(|n| is_comment(*n)) {
+        next = n.next_named_sibling();
+    }
+    next
+}
+
 struct Scope {
     row: u32,
     kind: &'static str,
@@ -383,7 +451,9 @@ impl<'t> Walker<'t> {
 
     /// dartConstructorSignature (dart.ts:25-35).
     fn constructor_signature(&self, node: Node<'t>) -> Option<Node<'t>> {
-        if matches!(node.kind(), "factory_constructor_signature" | "constructor_signature") {
+        if matches!(node.kind(), "factory_constructor_signature" | "constructor_signature")
+            || is_bodiless_ctor(node.kind())
+        {
             return Some(node);
         }
         if node.kind() == "method_signature" {
@@ -413,9 +483,12 @@ impl<'t> Walker<'t> {
     /// dartCtorInfo (dart.ts:61-70).
     fn ctor_info(&self, node: Node<'t>) -> Option<(String, String)> {
         let ctor = self.constructor_signature(node)?;
+        // The names before the parameters: a redirecting factory names its
+        // target after them (`factory Foo() = _Impl.named;`).
         let mut cursor = ctor.walk();
         let ids: Vec<Node<'t>> = ctor
             .named_children(&mut cursor)
+            .take_while(|c| c.kind() != "formal_parameter_list")
             .filter(|c| c.kind() == "identifier")
             .collect();
         let class_name = self.enclosing_type_name(node)?;
@@ -446,11 +519,13 @@ impl<'t> Walker<'t> {
         Some(last.to_string())
     }
 
-    /// isMisparsedFunction (dart.ts:177-188) — skip the UNNAMED constructor.
-    fn is_unnamed_ctor(&self, node: Node<'t>) -> bool {
+    /// isMisparsedFunction (dart.ts:177-188) — skip the UNNAMED constructor,
+    /// and a `const` ctor / redirecting factory that names no enclosing type
+    /// (error recovery's).
+    fn is_misparsed_function(&self, node: Node<'t>) -> bool {
         match self.ctor_info(node) {
             Some((class_name, ctor_name)) => ctor_name == class_name,
-            None => false,
+            None => is_bodiless_ctor(node.kind()),
         }
     }
 
@@ -461,10 +536,15 @@ impl<'t> Walker<'t> {
         let params = sig
             .named_children(&mut c1)
             .find(|c| c.kind() == "formal_parameter_list");
+        // A constructor has no return type: the type a redirecting factory
+        // names is its target (`= _Impl`).
         let mut c2 = sig.walk();
-        let ret = sig
-            .named_children(&mut c2)
-            .find(|c| matches!(c.kind(), "type_identifier" | "void_type"));
+        let ret = if is_bodiless_ctor(sig.kind()) {
+            None
+        } else {
+            sig.named_children(&mut c2)
+                .find(|c| matches!(c.kind(), "type_identifier" | "void_type"))
+        };
         if params.is_none() && ret.is_none() {
             return None;
         }
@@ -538,6 +618,33 @@ impl<'t> Walker<'t> {
         false
     }
 
+    /// getDeclarationWrapper (dart.ts) — a member with no body (`Foo._();`,
+    /// `const Foo.c();`, an abstract `void m();`) is a `declaration` wrapping
+    /// its signature, and the member's `///` dartdoc and `@annotation`s come
+    /// before the wrapper. A signature that opens the declaration takes both
+    /// from there.
+    fn declaration_wrapper(&self, node: Node<'t>) -> Option<Node<'t>> {
+        let parent = node.parent()?;
+        if parent.kind() != "declaration" {
+            return None;
+        }
+        if parent.named_child(0)? == node {
+            Some(parent)
+        } else {
+            None
+        }
+    }
+
+    /// docstringFor (tree-sitter.ts) — the preceding comment run, looked up
+    /// from the declaration wrapper when there is one, past annotations.
+    fn docstring_of(&self, node: Node<'t>) -> Option<String> {
+        preceding_docstring_stepping_over(
+            self.declaration_wrapper(node).unwrap_or(node),
+            self.src,
+            DOCSTRING_STEP_OVER,
+        )
+    }
+
     /// resolveBody (dart.ts:158-171).
     fn resolve_body(&self, node: Node<'t>) -> Option<Node<'t>> {
         if matches!(node.kind(), "function_signature" | "method_signature") {
@@ -567,6 +674,18 @@ impl<'t> Walker<'t> {
                 return ctor_name;
             }
         }
+        // `class A = B with C;` — the mixin application's own identifier.
+        if node.kind() == "class_definition" {
+            let mut cursor = node.walk();
+            let application = node.named_children(&mut cursor).find(|c| c.kind() == "mixin_application_class");
+            if let Some(application) = application {
+                let mut ac = application.walk();
+                let id = application.named_children(&mut ac).find(|c| c.kind() == "identifier");
+                if let Some(id) = id {
+                    return self.text(id).to_string();
+                }
+            }
+        }
         if let Some(name_node) = node.child_by_field_name("name") {
             return self.text(name_node).to_string();
         }
@@ -616,12 +735,61 @@ impl<'t> Walker<'t> {
                     }
                 });
                 let name = self.text(name_node).to_string();
-                self.create_node("constant", &name, node, Extra { signature, ..Default::default() });
+                let constant = self.create_node("constant", &name, node, Extra { signature, ..Default::default() });
+                // The initializer is code the constant runs — its calls,
+                // instantiations, reads and the types it names (#2327) are
+                // the constant's. walkInitializer: the body walk, and the
+                // dispatcher's fn-ref scan skips what it walked.
+                if let Some(constant) = constant {
+                    self.stack.push(Scope { row: constant, kind: "constant", name });
+                    self.visit_body(node);
+                    self.stack.pop();
+                    return;
+                }
             }
             self.scan_fn_ref_subtree(node, 0);
             return;
         }
 
+        // A field's or top-level variable's initializer is code its class or
+        // the file runs (neither mints a node) — the hook's
+        // `initialized_identifier` row, walked like a body (walkInitializer).
+        if node.kind() == "initialized_identifier" && self.is_field_or_top_level_entry(node) {
+            self.visit_body(node);
+            return;
+        }
+
+        // A field's declared type is its class's (Dart fields mint no nodes);
+        // a top-level variable's is the file's (#2327). The visitNode hook's
+        // `declaration` / `program` rows (dart.ts). (Parent lookups walk down
+        // from the root, so only the node kinds that can be these positions
+        // ask for theirs.)
+        if node.kind() == "declaration" {
+            let in_body = node
+                .parent()
+                .map(|p| matches!(p.kind(), "class_body" | "extension_body" | "enum_body"))
+                .unwrap_or(false);
+            let mut cursor = node.walk();
+            let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+            let is_field = in_body
+                && kids
+                    .iter()
+                    .any(|c| matches!(c.kind(), "initialized_identifier_list" | "static_final_declaration_list"));
+            if is_field {
+                let owner = self.top_row();
+                for child in kids {
+                    if !matches!(child.kind(), "initialized_identifier_list" | "static_final_declaration_list") {
+                        self.type_refs_dart(child, owner);
+                    }
+                }
+            }
+        } else if matches!(node.kind(), "type_identifier" | "type_arguments" | "function_type" | "record_type")
+            && node.parent().map(|p| p.kind() == "program").unwrap_or(false)
+        {
+            let owner = self.top_row();
+            self.type_refs_dart(node, owner);
+        }
+
         // maybeCaptureFnRefs (:990) — the double-walk fn-ref twin source.
         self.maybe_capture_fn_refs(node);
 
@@ -641,7 +809,10 @@ impl<'t> Walker<'t> {
                 self.extract_class(node);
                 return;
             }
-            "method_signature" | "constructor_signature" => {
+            "method_signature"
+            | "constructor_signature"
+            | "constant_constructor_signature"
+            | "redirecting_factory_constructor_signature" => {
                 self.extract_method(node);
                 return;
             }
@@ -655,9 +826,13 @@ impl<'t> Walker<'t> {
                     return;
                 }
             }
-            "import_or_export" => {
+            // importTypes (dart.ts): `import` / `export`, and `part
+            // 'x.g.dart';`, which links the library to the part's file. The
+            // TS ladder goes on into the directive's children, so this does
+            // too: an annotation's arguments are fn-ref capture points
+            // (`@Tag(bar) import 'a.dart';` captures `bar`).
+            "import_or_export" | "part_directive" => {
                 self.extract_import(node);
-                return;
             }
             "new_expression" => {
                 // INSTANTIATION_KINDS row — from the FILE/CLASS on the
@@ -690,13 +865,13 @@ impl<'t> Walker<'t> {
         }
         // isMisparsedFunction: the unnamed constructor is skipped — node
         // suppressed, body still walked (attributed to the current stack top).
-        if self.is_unnamed_ctor(node) {
+        if self.is_misparsed_function(node) {
             if let Some(body) = self.resolve_body(node) {
                 self.visit_body(body);
             }
             return;
         }
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         let signature = self.signature_of(node);
         let visibility = self.visibility_of(node);
         let is_async = self.is_async_of(node);
@@ -737,13 +912,13 @@ impl<'t> Walker<'t> {
         }
         let name = self.extract_name(node);
         // isMisparsedFunction — the unnamed ctor: body-only walk.
-        if self.is_unnamed_ctor(node) {
+        if self.is_misparsed_function(node) {
             if let Some(body) = self.resolve_body(node) {
                 self.visit_body(body);
             }
             return;
         }
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         let signature = self.signature_of(node);
         let visibility = self.visibility_of(node);
         let is_async = self.is_async_of(node);
@@ -785,7 +960,7 @@ impl<'t> Walker<'t> {
         // fallback finds the ON type's type_identifier — a class named after
         // the extended type (preserved).
         let name = self.extract_name(node);
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         let visibility = self.visibility_of(node);
         let row = self.create_node(
             "class",
@@ -816,7 +991,7 @@ impl<'t> Walker<'t> {
             None => return,
         };
         let name = self.extract_name(node);
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         let visibility = self.visibility_of(node);
         let row = self.create_node(
             "enum",
@@ -858,14 +1033,14 @@ impl<'t> Walker<'t> {
         if name == "<anonymous>" {
             return false;
         }
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         // `value` field is null (type_alias has no fields) → no refs from
         // the aliased type; returns false → children re-visited.
         self.create_node("type_alias", &name, node, Extra { docstring, ..Default::default() });
         false
     }
 
-    // --- extractImport (:3170; hook dart.ts:261-304) ----------------------
+    // --- extractImport (:3170; hook dart.ts extractImport) -----------------
 
     fn extract_import(&mut self, node: Node<'t>) {
         let find_child = |parent: Node<'t>, kind: &str| -> Option<Node<'t>> {
@@ -879,6 +1054,12 @@ impl<'t> Walker<'t> {
             find_child(uri, "string_literal")
         };
         let mut module: Option<String> = None;
+        // A part: `part 'x.g.dart';` holds its `uri` directly.
+        if node.kind() == "part_directive" {
+            if let Some(sl) = find_child(node, "uri").and_then(|uri| find_child(uri, "string_literal")) {
+                module = Some(self.text(sl).replace(['\'', '"'], ""));
+            }
+        }
         if let Some(li) = find_child(node, "library_import") {
             if let Some(spec) = find_child(li, "import_specification") {
                 if let Some(sl) = uri_of(spec) {
@@ -951,57 +1132,17 @@ impl<'t> Walker<'t> {
             if !has_arg_part {
                 return None;
             }
-            let prev = node.prev_named_sibling()?;
-            if prev.kind() == "identifier" {
-                return Some(self.text(prev).to_string());
-            }
-            if prev.kind() == "selector" {
-                let mut pc = prev.walk();
-                let accessor = prev.named_children(&mut pc).find(|c| {
-                    matches!(
-                        c.kind(),
-                        "unconditional_assignable_selector" | "conditional_assignable_selector"
-                    )
-                });
-                if let Some(accessor) = accessor {
-                    let mut ac = accessor.walk();
-                    let method_id = accessor.named_children(&mut ac).find(|c| c.kind() == "identifier");
-                    if let Some(method_id) = method_id {
-                        let accessor_prev = prev.prev_named_sibling();
-                        if let Some(ap) = accessor_prev {
-                            if ap.kind() == "identifier" {
-                                return Some(format!("{}.{}", self.text(ap), self.text(method_id)));
-                            }
-                            // Chained static-factory: the receiver is itself
-                            // a call — re-encode `<inner>().<method>` when
-                            // the chain starts capitalized (#750).
-                            if ap.kind() == "selector" {
-                                let mut apc = ap.walk();
-                                if ap.named_children(&mut apc).any(|c| c.kind() == "argument_part") {
-                                    if let Some(inner) = self.callee_of_arg_part(ap) {
-                                        if starts_upper_re().is_match(&inner) {
-                                            return Some(format!("{}().{}", inner, self.text(method_id)));
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        return Some(self.text(method_id).to_string());
-                    }
-                }
-            }
-            // super.method() / this.method(): prev is a bare accessor.
-            if matches!(
-                prev.kind(),
-                "unconditional_assignable_selector" | "conditional_assignable_selector"
-            ) {
-                let mut pc = prev.walk();
-                let id = prev.named_children(&mut pc).find(|c| c.kind() == "identifier");
-                if let Some(id) = id {
-                    return Some(self.text(id).to_string());
-                }
-            }
-            return None;
+            // Past comments: `box.grow /* by */ (3)` calls `box.grow`.
+            let prev = prev_named(node)?;
+            return self.callee_name(prev);
+        }
+
+        // A generic call the grammar read as two comparisons
+        // (`ref.read<Repo>(p)`), named at its `<`, where a parsed call's
+        // argument part starts.
+        if node.kind() == "relational_operator" {
+            let (callee, _) = self.misparsed_generic_call(node)?;
+            return self.callee_name(callee);
         }
 
         // new_expression arm — DEAD in practice (the INSTANTIATION branch
@@ -1028,12 +1169,212 @@ impl<'t> Walker<'t> {
             };
         }
 
+        // `=> BlocProvider<CounterCubit>.value(…)` — a constructor called
+        // with type arguments, as most expressions parse it. The type is the
+        // LAST type_identifier: an import prefix (`p.X<T>.named`) is one too.
+        if node.kind() == "constructor_invocation" {
+            let mut c1 = node.walk();
+            let type_id = node.named_children(&mut c1).filter(|c| c.kind() == "type_identifier").last();
+            let mut c2 = node.walk();
+            let name_id = node.named_children(&mut c2).find(|c| c.kind() == "identifier");
+            return match (type_id, name_id) {
+                (Some(t), Some(n)) => Some(format!("{}.{}", self.text(t), self.text(n))),
+                (Some(t), None) => Some(self.text(t).to_string()),
+                _ => None,
+            };
+        }
+
+        None
+    }
+
+    /// dartReceiverOf (dart.ts) — the receiver of the member access
+    /// `selector`: the node in front of it, past comments, or the end of an
+    /// arrow function's body when the grammar ended the arrow in front of a
+    /// generic call (`(ref) => ref.watch<int>(p)` → `((ref) => ref).watch<int>(p)`).
+    fn receiver_of(&self, selector: Node<'t>) -> Option<Node<'t>> {
+        let prev = prev_named(selector);
+        let body = prev
+            .filter(|p| p.kind() == "function_expression")
+            .and_then(|p| p.named_child(p.named_child_count().checked_sub(1)?));
+        match body {
+            Some(body) if body.kind() == "function_expression_body" => {
+                body.named_child(body.named_child_count().checked_sub(1)?)
+            }
+            _ => prev,
+        }
+    }
+
+    /// dartCallee (dart.ts) — the callee name of the call whose argument part
+    /// follows `prev`.
+    fn callee_name(&self, prev: Node<'t>) -> Option<String> {
+        if prev.kind() == "identifier" {
+            return Some(self.text(prev).to_string());
+        }
+        if prev.kind() == "selector" {
+            let mut pc = prev.walk();
+            let accessor = prev.named_children(&mut pc).find(|c| {
+                matches!(
+                    c.kind(),
+                    "unconditional_assignable_selector" | "conditional_assignable_selector"
+                )
+            });
+            if let Some(accessor) = accessor {
+                let mut ac = accessor.walk();
+                let method_id = accessor.named_children(&mut ac).find(|c| c.kind() == "identifier");
+                if let Some(method_id) = method_id {
+                    let accessor_prev = self.receiver_of(prev);
+                    if let Some(ap) = accessor_prev {
+                        if ap.kind() == "identifier" {
+                            return Some(format!("{}.{}", self.text(ap), self.text(method_id)));
+                        }
+                        // A constructor called with type arguments names
+                        // its type all the same (`BlocProvider<T>.value`).
+                        if let Some(type_name) = self.type_arguments_receiver(ap) {
+                            return Some(format!("{}.{}", type_name, self.text(method_id)));
+                        }
+                        // Chained static-factory: the receiver is itself
+                        // a call — re-encode `<inner>().<method>` when
+                        // the chain starts capitalized (#750).
+                        if ap.kind() == "selector" {
+                            let mut apc = ap.walk();
+                            if ap.named_children(&mut apc).any(|c| c.kind() == "argument_part") {
+                                if let Some(inner) = self.callee_of_arg_part(ap) {
+                                    if starts_upper_re().is_match(&inner) {
+                                        return Some(format!("{}().{}", inner, self.text(method_id)));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return Some(self.text(method_id).to_string());
+                }
+            }
+        }
+        // super.method() / this.method(): prev is a bare accessor.
+        if matches!(
+            prev.kind(),
+            "unconditional_assignable_selector" | "conditional_assignable_selector"
+        ) {
+            let mut pc = prev.walk();
+            let id = prev.named_children(&mut pc).find(|c| c.kind() == "identifier");
+            if let Some(id) = id {
+                return Some(self.text(id).to_string());
+            }
+        }
         None
     }
 
+    /// dartMisparsedGenericCall (dart.ts) — a generic call tree-sitter-dart
+    /// parsed as two comparisons, `(ref.read < Repo) > (p)`, found from its
+    /// `<`: the node its callee ends with (under any `await` or prefix
+    /// operator) and the identifier naming its type argument. Recovered when
+    /// the type argument names a type and the code is laid out as a call —
+    /// `<` against the callee, `(` against the `>`. A call chained on it keeps
+    /// its bare name, which the resolver types from the chain written before
+    /// it, as it types a parsed chain's `X().m` (#750).
+    fn misparsed_generic_call(&self, lt: Node<'t>) -> Option<(Node<'t>, Node<'t>)> {
+        if lt.kind() != "relational_operator" || lt.child(0)?.kind() != "<" {
+            return None;
+        }
+        let inner = lt.parent()?;
+        let outer = inner.parent()?;
+        if inner.kind() != "relational_expression" || outer.kind() != "relational_expression" {
+            return None;
+        }
+        let left = outer.named_child(0)?;
+        if left.start_byte() != inner.start_byte() || left.end_byte() != inner.end_byte() {
+            return None;
+        }
+        let gt = outer.named_child(1)?;
+        if gt.kind() != "relational_operator" || gt.child(0)?.kind() != ">" {
+            return None;
+        }
+        let args = outer.named_child(2)?;
+        if !matches!(args.kind(), "parenthesized_expression" | "record_literal") || args.start_byte() != gt.end_byte() {
+            return None;
+        }
+        // A comment against the `<` (`ref.read /* c */<Repo>(p)`) is a
+        // sibling of its own, so the callee is not against it.
+        let before = lt.prev_named_sibling()?;
+        if is_comment(before) || before.end_byte() != lt.start_byte() {
+            return None;
+        }
+        // The type argument: `T`, `p.T`, `T<…>` or `p.T<…>`, and nothing else.
+        let head = lt.next_named_sibling()?;
+        if head.kind() != "identifier" {
+            return None;
+        }
+        let mut type_name = head;
+        let mut rest = head.next_named_sibling();
+        if let Some(sel) = rest {
+            let accessor = sel.named_child(0).filter(|a| a.kind() == "unconditional_assignable_selector");
+            if sel.kind() == "selector" {
+                if let Some(accessor) = accessor {
+                    let mut ac = accessor.walk();
+                    let name = accessor.named_children(&mut ac).find(|c| c.kind() == "identifier");
+                    type_name = name?;
+                    rest = sel.next_named_sibling();
+                }
+            }
+        }
+        if let Some(sel) = rest {
+            let only_type_args = sel.named_child_count() == 1
+                && sel.named_child(0).map(|t| t.kind() == "type_arguments").unwrap_or(false);
+            if sel.kind() == "selector" && only_type_args {
+                rest = sel.next_named_sibling();
+            }
+        }
+        if rest.is_some() {
+            return None;
+        }
+        let name = self.text(type_name);
+        if !is_upper_camel(name) && !is_lowercase_type(name) {
+            return None;
+        }
+        // `await repo.load<User>(id)` and `-x.size<int>(y)` put the callee
+        // under the prefix.
+        let mut callee = before;
+        while is_prefixed(callee.kind()) {
+            let count = callee.named_child_count();
+            callee = callee.named_child(count.checked_sub(1)?)?;
+        }
+        Some((callee, type_name))
+    }
+
+    /// dartInMisparsedGenericCall (dart.ts) — whether a member access
+    /// (`.member` on `receiver`, followed by `next` under `parent`) belongs to
+    /// a misparsed generic call: its callee is called, and a prefixed type
+    /// argument (`p.Repo`) names a type.
+    fn in_misparsed_generic_call(
+        &self,
+        receiver: Node<'t>,
+        next: Option<Node<'t>>,
+        parent: Option<Node<'t>>,
+    ) -> bool {
+        let mut after = next;
+        let mut up = parent;
+        while after.is_none() {
+            let Some(u) = up.filter(|u| is_prefixed(u.kind())) else { break };
+            after = u.next_named_sibling();
+            up = if after.is_some() { None } else { u.parent() };
+        }
+        if let Some(a) = after {
+            if a.kind() == "relational_operator" && self.misparsed_generic_call(a).is_some() {
+                return true;
+            }
+        }
+        if parent.map(|p| p.kind()) != Some("relational_expression") {
+            return false;
+        }
+        receiver
+            .prev_named_sibling()
+            .map(|b| b.kind() == "relational_operator" && self.misparsed_generic_call(b).is_some())
+            .unwrap_or(false)
+    }
+
     /// dartCalleeOfArgPart (dart.ts:100-116).
     fn callee_of_arg_part(&self, arg_part: Node<'t>) -> Option<String> {
-        let prev = arg_part.prev_named_sibling()?;
+        let prev = prev_named(arg_part)?;
         if prev.kind() == "identifier" {
             return Some(self.text(prev).to_string());
         }
@@ -1051,11 +1392,14 @@ impl<'t> Walker<'t> {
                 found
             });
             if let Some(method_id) = method_id {
-                let accessor_prev = prev.prev_named_sibling();
+                let accessor_prev = prev_named(prev);
                 if let Some(ap) = accessor_prev {
                     if ap.kind() == "identifier" {
                         return Some(format!("{}.{}", self.text(ap), self.text(method_id)));
                     }
+                    if let Some(type_name) = self.type_arguments_receiver(ap) {
+                        return Some(format!("{}.{}", type_name, self.text(method_id)));
+                    }
                 }
                 return Some(self.text(method_id).to_string());
             }
@@ -1063,6 +1407,23 @@ impl<'t> Walker<'t> {
         None
     }
 
+    /// dartTypeArgumentsReceiver (dart.ts) — `BlocProvider` in
+    /// `BlocProvider<CounterCubit>.value(…)`, when `selector` is the `<…>`
+    /// between the type and `.value`. Only a constructor is called that way.
+    fn type_arguments_receiver(&self, selector: Node<'t>) -> Option<&'t str> {
+        if selector.kind() != "selector" || selector.named_child_count() != 1 {
+            return None;
+        }
+        if selector.named_child(0)?.kind() != "type_arguments" {
+            return None;
+        }
+        let type_node = prev_named(selector)?;
+        if type_node.kind() != "identifier" {
+            return None;
+        }
+        Some(self.text(type_node))
+    }
+
     // --- extractStaticMemberRef — the dart branch (:4759-4767) ------------
 
     fn extract_static_member_ref(&mut self, node: Node<'t>) {
@@ -1077,8 +1438,15 @@ impl<'t> Walker<'t> {
         if node.named_children(&mut cursor).any(|c| c.kind() == "argument_part") {
             return;
         }
-        let Some(prev) = node.prev_named_sibling() else { return };
+        let Some(prev) = self.receiver_of(node) else { return };
         if prev.kind() == "identifier" && cap_ident_re().is_match(self.text(prev)) {
+            // `Map` in `x.read<Map<K, V>>(y)` parsed as comparisons is a type
+            // argument, which the body walker references as a type.
+            if let Some(before) = prev.prev_named_sibling() {
+                if before.kind() == "relational_operator" && self.misparsed_generic_call(before).is_some() {
+                    return;
+                }
+            }
             let name = self.text(prev).to_string();
             // NO callee-of-call skip — `ConfigT.load()` double-emits
             // (references + calls). Position = the IDENTIFIER (receiver).
@@ -1105,8 +1473,11 @@ impl<'t> Walker<'t> {
         }
         // Scan 2: preceding siblings, backward, stop at the first
         // non-annotation — stacked annotations emit in REVERSE source order.
-        if let Some(parent) = decl.parent() {
-            let decl_start = decl.start_byte();
+        // A `declaration`-wrapped member's annotations precede the wrapper,
+        // and the comments between annotations and declaration are stepped over.
+        let anchor = self.declaration_wrapper(decl).unwrap_or(decl);
+        if let Some(parent) = anchor.parent() {
+            let decl_start = anchor.start_byte();
             let mut decl_idx: Option<usize> = None;
             for i in 0..parent.named_child_count() {
                 if let Some(sib) = parent.named_child(i) {
@@ -1119,6 +1490,9 @@ impl<'t> Walker<'t> {
             if let Some(di) = decl_idx {
                 for j in (0..di).rev() {
                     let Some(sib) = parent.named_child(j) else { continue };
+                    if DECORATOR_STEP_OVER.contains(&sib.kind()) {
+                        continue;
+                    }
                     if !matches!(sib.kind(), "decorator" | "annotation" | "marker_annotation") {
                         break;
                     }
@@ -1178,10 +1552,45 @@ impl<'t> Walker<'t> {
     // --- extractInheritance — the dart rows (:5368-5393, :5437-5459) ------
 
     fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) {
+        // The type an extension is `on` — a `references` edge (#2327).
+        if node.kind() == "extension_declaration" {
+            let mut oc = node.walk();
+            let on_types: Vec<Node<'t>> = node.children_by_field_name("class", &mut oc).collect();
+            for on_type in on_types {
+                self.type_refs_dart(on_type, class_row);
+            }
+        }
         let mut cursor = node.walk();
         let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
         for child in kids {
-            if child.kind() == "superclass" {
+            if child.kind() == "mixin_application_class" {
+                // `class A = B with M implements I;` — extends B, implements
+                // each mixin and interface, in source order.
+                let mut cc = child.walk();
+                let application = child.named_children(&mut cc).find(|c| c.kind() == "mixin_application");
+                let Some(application) = application else { continue };
+                let mut ac = application.walk();
+                let parts: Vec<Node<'t>> = application.named_children(&mut ac).collect();
+                for t in parts {
+                    match t.kind() {
+                        "type_identifier" => {
+                            let name = self.text(t).to_string();
+                            self.push_ref_at(class_row, &name, "extends", t);
+                        }
+                        "mixins" | "interfaces" => {
+                            let mut mc = t.walk();
+                            let targets: Vec<Node<'t>> = t.named_children(&mut mc).collect();
+                            for m in targets {
+                                if t.kind() == "interfaces" || m.kind() == "type_identifier" {
+                                    let name = self.text(m).to_string();
+                                    self.push_ref_at(class_row, &name, "implements", m);
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            } else if child.kind() == "superclass" {
                 // extends type + `with` mixins (implements) — dart branch.
                 let mut cc = child.walk();
                 let targets: Vec<Node<'t>> = child.named_children(&mut cc).collect();
@@ -1228,6 +1637,20 @@ impl<'t> Walker<'t> {
         } else {
             node
         };
+        // A redirecting factory names the class it constructs after `=`, then
+        // perhaps that class's constructor (`= _$QuestionImpl.fromJson`, two
+        // type_identifiers). Neither the constructor nor an import prefix is
+        // a type, and Dart writes types UpperCamel.
+        if sig.kind() == "redirecting_factory_constructor_signature" {
+            let mut cursor = sig.walk();
+            let kids: Vec<Node<'t>> = sig.named_children(&mut cursor).collect();
+            for child in kids {
+                if child.kind() != "type_identifier" || is_upper_camel(self.text(child)) {
+                    self.type_refs_from_subtree(child, row);
+                }
+            }
+            return;
+        }
         self.type_refs_from_subtree(sig, row);
     }
 
@@ -1248,6 +1671,102 @@ impl<'t> Walker<'t> {
         }
     }
 
+    // --- type positions outside signatures (#2327; dart.ts pushDartTypeRefs) ---
+
+    /// isDartTypeName (dart.ts) — UpperCamelCase (`/^[_$]*[A-Z]/`: lowercase
+    /// is a built-in or an error-recovery artifact), not a built-in, not an
+    /// import prefix (`p` in `p.Foo`), not the class a `new`/`const`
+    /// constructor call names.
+    fn is_type_name_dart(&self, node: Node<'t>) -> bool {
+        let text = self.text(node);
+        if !is_upper_camel(text) || is_builtin_type(text) {
+            return false;
+        }
+        if node.next_sibling().map(|s| s.kind() == ".").unwrap_or(false) {
+            return false;
+        }
+        !node
+            .parent()
+            .map(|p| matches!(p.kind(), "new_expression" | "const_object_expression"))
+            .unwrap_or(false)
+    }
+
+    /// pushDartTypeRefs (dart.ts) — every type named inside `node`.
+    fn type_refs_dart(&mut self, node: Node<'t>, from_row: u32) {
+        stack_guard!();
+        if node.kind() == "type_identifier" {
+            if self.is_type_name_dart(node) {
+                let name = self.text(node).to_string();
+                self.push_ref_at(from_row, &name, "references", node);
+            }
+            return;
+        }
+        let mut cursor = node.walk();
+        let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+        for c in kids {
+            self.type_refs_dart(c, from_row);
+        }
+    }
+
+    /// isDartFieldOrTopLevelEntry (dart.ts) — an `initialized_identifier`
+    /// declaring a field or a top-level variable, not the second variable of
+    /// a local declaration (`for (var i = 0, j = n(); …)`).
+    fn is_field_or_top_level_entry(&self, node: Node<'t>) -> bool {
+        let Some(list) = node.parent() else { return false };
+        if list.kind() != "initialized_identifier_list" {
+            return false;
+        }
+        let Some(owner) = list.parent() else { return false };
+        if owner.kind() == "program" {
+            return true;
+        }
+        owner.kind() == "declaration"
+            && owner
+                .parent()
+                .map(|p| matches!(p.kind(), "class_body" | "extension_body" | "enum_body"))
+                .unwrap_or(false)
+    }
+
+    /// dartMemberRead (dart.ts) — `x.area` / `x?.area` not followed by a call's
+    /// argument part, receiver a plain name: a `references` ref `x.area` on
+    /// `area`, which the resolver links to a getter only (#2338).
+    fn extract_member_read(&mut self, node: Node<'t>) {
+        if node.kind() != "selector" {
+            return;
+        }
+        let mut cursor = node.walk();
+        let accessor = node.named_children(&mut cursor).find(|c| {
+            matches!(c.kind(), "unconditional_assignable_selector" | "conditional_assignable_selector")
+        });
+        let member = accessor.and_then(|a| {
+            let mut ac = a.walk();
+            let found = a.named_children(&mut ac).find(|c| c.kind() == "identifier");
+            found
+        });
+        let Some(member) = member else { return };
+        let Some(receiver) = prev_named(node) else { return };
+        if receiver.kind() != "identifier" {
+            return;
+        }
+        let next = next_named(node);
+        if let Some(next) = next {
+            if next.kind() == "selector" {
+                let mut nc = next.walk();
+                if next.named_children(&mut nc).any(|c| c.kind() == "argument_part") {
+                    return;
+                }
+            }
+        }
+        // The callee of a generic call the grammar read as comparisons
+        // (`ref.read<Repo>(p)`) is called; a prefixed type argument names a type.
+        if self.in_misparsed_generic_call(receiver, next, node.parent()) {
+            return;
+        }
+        let name = format!("{}.{}", self.text(receiver), self.text(member));
+        let reader = self.top_row();
+        self.push_ref_at(reader, &name, "references", member);
+    }
+
     // --- visitFunctionBody (:5129-5286) — dart rows -----------------------
 
     fn visit_body(&mut self, node: Node<'t>) {
@@ -1269,6 +1788,20 @@ impl<'t> Walker<'t> {
 
         self.extract_static_member_ref(node);
 
+        // A getter read `x.area` (#2338); a type the body names (#2327) — the
+        // type argument of a generic call parsed as comparisons included.
+        self.extract_member_read(node);
+        let type_node = match kind {
+            "type_identifier" => Some(node),
+            "relational_operator" => self.misparsed_generic_call(node).map(|(_, type_name)| type_name),
+            _ => None,
+        };
+        if let Some(type_node) = type_node.filter(|t| self.is_type_name_dart(*t)) {
+            let name = self.text(type_node).to_string();
+            let owner = self.top_row();
+            self.push_ref_at(owner, &name, "references", type_node);
+        }
+
         if kind == "function_signature" {
             // Nested named functions (:5245) — extractFunction walks the
             // nested body itself; the enclosing walker ALSO revisits the
diff --git a/codegraph-kernel/src/docstring.rs b/codegraph-kernel/src/docstring.rs
index de9a55afcd..22e499c23c 100644
--- a/codegraph-kernel/src/docstring.rs
+++ b/codegraph-kernel/src/docstring.rs
@@ -131,6 +131,36 @@ pub fn clean_comment_markers(comment: &str) -> String {
 /// Returns None when there is no preceding comment (a PRESENT-but-empty
 /// docstring after cleaning still returns Some(""), matching the TS helper).
 pub fn preceding_docstring(node: Node, src: &str) -> Option<String> {
+    preceding_docstring_stepping_over(node, src, &[])
+}
+
+/// getPrecedingDocstring's `stepOver` — sibling kinds that may stand between
+/// the declaration and its comments without ending the run (Dart's
+/// `annotation`: `/// Builds it.` `@override` `Widget build(…)`). They are not
+/// part of the docstring; the comments on either side of one still join.
+pub fn preceding_docstring_stepping_over(
+    node: Node,
+    src: &str,
+    step_over: &[&str],
+) -> Option<String> {
+    preceding_docstring_with(node, src, step_over, false)
+}
+
+/// getPrecedingDocstring's `skipTrailing` (Go) — the comments the run opens
+/// with that belong to the line above are left out: one written after code on
+/// its line (`const n = 4 // four.`), and any that begins on the line such a
+/// comment ends. Go reads them as that line's comment, never the next
+/// declaration's doc.
+pub fn preceding_docstring_skipping_trailing(node: Node, src: &str) -> Option<String> {
+    preceding_docstring_with(node, src, &[], true)
+}
+
+fn preceding_docstring_with(
+    node: Node,
+    src: &str,
+    step_over: &[&str],
+    skip_trailing: bool,
+) -> Option<String> {
     let mut anchor = node;
     while let Some(parent) = anchor.parent() {
         if is_wrapper(parent.kind()) {
@@ -140,24 +170,43 @@ pub fn preceding_docstring(node: Node, src: &str) -> Option<String> {
         }
     }
 
-    let mut comments: Vec<&str> = Vec::new();
+    let mut comments: Vec<Node> = Vec::new();
     let mut sibling = anchor.prev_named_sibling();
     while let Some(s) = sibling {
         if is_comment(s.kind()) {
-            comments.push(&src[s.byte_range()]);
+            comments.push(s);
+            sibling = s.prev_named_sibling();
+        } else if step_over.contains(&s.kind()) {
             sibling = s.prev_named_sibling();
         } else {
             break;
         }
     }
-    if comments.is_empty() {
+    comments.reverse(); // collected nearest-first; TS unshifts to keep source order
+
+    let mut first = 0;
+    if skip_trailing {
+        let mut end_row = 0;
+        for c in &comments {
+            let trails = if first == 0 {
+                follows_code_on_its_line(*c, src)
+            } else {
+                c.start_position().row == end_row
+            };
+            if !trails {
+                break;
+            }
+            end_row = c.end_position().row;
+            first += 1;
+        }
+    }
+    if first == comments.len() {
         return None;
     }
-    comments.reverse(); // collected nearest-first; TS unshifts to keep source order
     Some(
-        comments
+        comments[first..]
             .iter()
-            .map(|c| clean_comment_markers(c))
+            .map(|c| clean_comment_markers(&src[c.byte_range()]))
             .collect::<Vec<_>>()
             .join("\n")
             .trim()
@@ -165,6 +214,13 @@ pub fn preceding_docstring(node: Node, src: &str) -> Option<String> {
     )
 }
 
+/// followsCodeOnItsLine (tree-sitter-helpers.ts) — whether code comes before
+/// `node` on the line it starts on.
+fn follows_code_on_its_line(node: Node, src: &str) -> bool {
+    let before = src[..node.start_byte()].trim_end_matches([' ', '\t']);
+    !before.is_empty() && !before.ends_with(['\n', '\r'])
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -194,4 +250,53 @@ mod tests {
             "a\r\nb"
         );
     }
+
+    /// A `step_over` kind is passed without ending the run, and the comments
+    /// on either side of it join; any other node still ends it. With no
+    /// step-over kinds the walk stops at the first non-comment, as before.
+    #[test]
+    fn steps_over_only_the_listed_kinds() {
+        let grammar = crate::langs::grammar_for("dart").expect("dart grammar");
+        let mut parser = tree_sitter::Parser::new();
+        parser.set_language(&grammar).unwrap();
+        let src = "void g() {}\n/// a\n@x\n// b\nvoid f() {}\n";
+        let tree = parser.parse(src, None).unwrap();
+        let root = tree.root_node();
+        let f = (0..root.named_child_count())
+            .filter_map(|i| root.named_child(i))
+            .filter(|n| n.kind() == "function_signature")
+            .nth(1)
+            .expect("f's signature");
+        assert_eq!(preceding_docstring(f, src).as_deref(), Some("b"));
+        assert_eq!(
+            preceding_docstring_stepping_over(f, src, &["annotation"]).as_deref(),
+            Some("a\nb")
+        );
+    }
+
+    /// Skipping trailing comments leaves out one written after code on its
+    /// line and one beginning on the line it ends; a comment on a line of its
+    /// own still opens the run. Without it, nothing is left out.
+    #[test]
+    fn skips_the_comments_that_trail_code() {
+        let grammar = crate::langs::grammar_for("go").expect("go grammar");
+        let mut parser = tree_sitter::Parser::new();
+        parser.set_language(&grammar).unwrap();
+        let src = "package p\n\nconst n = 4 /* a */ // b\n// c\nfunc f() {}\n\nvar m = 1 // d\nfunc g() {}\n";
+        let tree = parser.parse(src, None).unwrap();
+        let root = tree.root_node();
+        let func = |name: &str| {
+            (0..root.named_child_count())
+                .filter_map(|i| root.named_child(i))
+                .find(|n| {
+                    n.kind() == "function_declaration"
+                        && n.child_by_field_name("name").map(|id| &src[id.byte_range()]) == Some(name)
+                })
+                .expect(name)
+        };
+        assert_eq!(preceding_docstring(func("f"), src).as_deref(), Some("a\nb\nc"));
+        assert_eq!(preceding_docstring_skipping_trailing(func("f"), src).as_deref(), Some("c"));
+        assert_eq!(preceding_docstring(func("g"), src).as_deref(), Some("d"));
+        assert_eq!(preceding_docstring_skipping_trailing(func("g"), src), None);
+    }
 }
diff --git a/codegraph-kernel/src/go.rs b/codegraph-kernel/src/go.rs
index 239c788a6e..6d54047ebb 100644
--- a/codegraph-kernel/src/go.rs
+++ b/codegraph-kernel/src/go.rs
@@ -4,8 +4,8 @@
 //! Go's shape quirks, mirrored exactly: methods are top-level with a receiver
 //! (qualifiedName override `Recv::name` + a contains edge to the FIRST
 //! earlier-in-file struct of that name), structs/interfaces arrive as
-//! `type_spec` and classify via the inner type node (struct embedding →
-//! extends; interface method_elems become method nodes), composite literals
+//! `type_spec` and classify via the inner type node (struct and interface
+//! embedding → extends; interface method_elems become method nodes), composite literals
 //! (`pkga.Widget{}`) keep their package qualifier as `instantiates` refs,
 //! top-level var/const specs walk their initializers ATTRIBUTED to the
 //! declared symbol (#693), 2-hop field chains (`t.conn.Exec`) keep the chain
@@ -16,7 +16,7 @@ use crate::buffers::{
     build_meta, edge_kind_index, node_kind_index, Arena, BoolFlags, EdgeRow, EmitOut, NodeRow,
     RefRow, StrRef, Tables, FLAG_IS_EXPORTED, FUNCTION_REF_CODE, NONE, NONE_STR,
 };
-use crate::docstring::preceding_docstring;
+use crate::docstring::preceding_docstring_skipping_trailing;
 use crate::ids;
 use crate::textutil as util;
 use regex::Regex;
@@ -380,6 +380,31 @@ impl<'t> Walker<'t> {
         receiver_re().captures(text).map(|c| c[1].to_string())
     }
 
+    /// goExtractor.getDeclarationWrapper: a type declared on its own, `type
+    /// Foo struct{…}`, is a `type_declaration` holding one spec, and its doc
+    /// comment comes before the declaration, outside the spec. A member of a
+    /// `type ( … )` group has its comment beside it, and the comment above the
+    /// group is the group's. A group of one is that type's declaration, as go
+    /// doc reads it, unless its member has a comment of its own.
+    fn declaration_wrapper(&self, node: Node<'t>) -> Option<Node<'t>> {
+        let parent = node.parent()?;
+        if parent.kind() != "type_declaration" || parent.named_child(0)? != node {
+            return None;
+        }
+        let specs = (0..parent.named_child_count())
+            .filter_map(|i| parent.named_child(i))
+            .filter(|c| matches!(c.kind(), "type_spec" | "type_alias"))
+            .count();
+        (specs == 1).then_some(parent)
+    }
+
+    /// docstringFor (tree-sitter.ts) — the preceding comment run, looked up
+    /// from the declaration wrapper when there is one, without the comments
+    /// that trail the code above it (docstringSkipsTrailingComments).
+    fn docstring_of(&self, node: Node<'t>) -> Option<String> {
+        preceding_docstring_skipping_trailing(self.declaration_wrapper(node).unwrap_or(node), self.src)
+    }
+
     // --- visitNode ------------------------------------------------------------
 
     fn visit_node(&mut self, node: Node<'t>) {
@@ -395,7 +420,7 @@ impl<'t> Walker<'t> {
         } else if kind == "method_declaration" {
             self.extract_method(node);
             skip_children = true;
-        } else if kind == "type_spec" {
+        } else if kind == "type_spec" || kind == "type_alias" {
             skip_children = self.extract_type_alias(node);
         } else if matches!(kind, "var_declaration" | "short_var_declaration" | "const_declaration")
             && !self.inside_class_like()
@@ -465,7 +490,7 @@ impl<'t> Walker<'t> {
             return;
         }
         let extra = Extra {
-            docstring: preceding_docstring(node, self.src),
+            docstring: self.docstring_of(node),
             signature: self.signature_of(node),
             is_exported: Some(self.is_exported(node)),
             return_type: self.return_type_of(node),
@@ -487,7 +512,7 @@ impl<'t> Walker<'t> {
         let receiver_type = self.receiver_type_of(node);
         let name = self.extract_name(node);
         let extra = Extra {
-            docstring: preceding_docstring(node, self.src),
+            docstring: self.docstring_of(node),
             signature: self.signature_of(node),
             return_type: self.return_type_of(node),
             qualified_name: receiver_type.as_ref().map(|r| format!("{r}::{name}")),
@@ -529,14 +554,15 @@ impl<'t> Walker<'t> {
         self.stack.pop();
     }
 
-    /// extractTypeAlias for Go: type_spec → struct / interface / plain alias.
+    /// extractTypeAlias for Go: type_spec (`type A B`) and type_alias
+    /// (`type A = B`) → struct / interface / plain alias.
     fn extract_type_alias(&mut self, node: Node<'t>) -> bool {
         stack_guard!();
         let name = self.extract_name(node);
         if name == "<anonymous>" {
             return false;
         }
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         let is_exported = Some(self.is_exported(node));
         let type_child = node.child_by_field_name("type");
         let resolved = type_child.map(|t| t.kind());
@@ -582,14 +608,22 @@ impl<'t> Walker<'t> {
             return true;
         }
 
-        self.create_node(
+        let row = self.create_node(
             "type_alias",
             &name,
             node,
             Extra { docstring, is_exported, ..Extra::default() },
         );
-        // (go type_spec has no `value` field — no type-ref walk; TS/tsx member
-        // extraction is TS-family-only)
+        // (go has no `value` field — no TS-style type-ref walk or member
+        // extraction.) An alias and a defined type (`type_spec`) alike
+        // reference what their `type` field names.
+        if let Some(row) = row {
+            let references = edge_kind_index("references").unwrap();
+            for ty in self.alias_type_names(node) {
+                let text = self.text(ty).to_string();
+                self.push_ref_at(row, &text, references, ty);
+            }
+        }
         false
     }
 
@@ -614,7 +648,7 @@ impl<'t> Walker<'t> {
 
     /// extractVariable's Go branch: var/const specs + short_var_declaration.
     fn extract_variable(&mut self, node: Node<'t>) {
-        let docstring = preceding_docstring(node, self.src);
+        let docstring = self.docstring_of(node);
         let is_const_decl = node.kind() == "const_declaration";
 
         for i in 0..node.named_child_count() {
@@ -846,20 +880,92 @@ impl<'t> Walker<'t> {
         }
     }
 
-    /// extractInheritance — the Go branches: interface embedding
-    /// (constraint_elem) and struct embedding (field_declaration without a
-    /// field_identifier), plus the field_declaration_list recursion.
+    /// goEmbeddedTypeName (languages/go.ts): the name node of the type an
+    /// embedding names — `T`, `*T` (the `*` is a sibling token), `pkg.T` and
+    /// `T[X]` all embed `T`. A qualified type yields its name; resolution reads
+    /// the package back from the source at that position. None for any other
+    /// type and for a predeclared one.
+    fn embedded_type_name(&self, ty: Option<Node<'t>>) -> Option<Node<'t>> {
+        let mut ty = ty?;
+        if ty.kind() == "generic_type" {
+            ty = ty.child_by_field_name("type")?;
+        }
+        match ty.kind() {
+            "qualified_type" => ty.child_by_field_name("name"),
+            "type_identifier" if !is_go_predeclared_type(self.text(ty)) => Some(ty),
+            _ => None,
+        }
+    }
+
+    /// goAliasTypeNames (languages/go.ts): the name nodes of the types an
+    /// alias's or a defined type's `type` field names, in source order, but
+    /// its own type parameters, the predeclared types and its own name written
+    /// bare (a recursive type's, `type stateFn func(*Lexer) stateFn`). A
+    /// generic alias, which tree-sitter-go 0.23 parses as a `type_spec`
+    /// around an error, never reaches the kernel (its file defers to wasm).
+    fn alias_type_names(&self, node: Node<'t>) -> Vec<Node<'t>> {
+        let mut names = Vec::new();
+        let Some(ty) = node.child_by_field_name("type") else { return names };
+        let own = node.child_by_field_name("name").map(|n| self.text(n));
+        let mut params: HashSet<&str> = HashSet::new();
+        if let Some(list) = node.child_by_field_name("type_parameters") {
+            for decl in (0..list.named_child_count()).filter_map(|i| list.named_child(i)) {
+                for c in (0..decl.named_child_count()).filter_map(|j| decl.named_child(j)) {
+                    if c.kind() == "identifier" {
+                        params.insert(self.text(c));
+                    }
+                }
+            }
+        }
+        self.collect_alias_type_names(ty, &params, own, false, &mut names);
+        names
+    }
+
+    /// `qualified`: the name of a `pkg.Name`, which is that package's
+    /// whatever this one declares.
+    fn collect_alias_type_names(
+        &self,
+        node: Node<'t>,
+        params: &HashSet<&str>,
+        own: Option<&str>,
+        qualified: bool,
+        out: &mut Vec<Node<'t>>,
+    ) {
+        stack_guard!();
+        if node.kind() == "type_identifier" {
+            let text = self.text(node);
+            if !is_go_predeclared_type(text) && (qualified || (!params.contains(text) && own != Some(text))) {
+                out.push(node);
+            }
+            return;
+        }
+        let qualified = node.kind() == "qualified_type";
+        for i in 0..node.named_child_count() {
+            if let Some(c) = node.named_child(i) {
+                self.collect_alias_type_names(c, params, own, qualified, out);
+            }
+        }
+    }
+
+    /// extractInheritance — the Go branches: interface embedding (a type_elem
+    /// holding one named type; a union, `~T` or basic type is a constraint)
+    /// and struct embedding (field_declaration without a field_identifier),
+    /// plus the field_declaration_list recursion.
     fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) {
         stack_guard!();
         let extends_kind = edge_kind_index("extends").unwrap();
         for i in 0..node.named_child_count() {
             let Some(child) = node.named_child(i) else { continue };
             match child.kind() {
-                "constraint_elem" => {
-                    let type_id = (0..child.named_child_count())
+                "type_elem" => {
+                    let mut terms = (0..child.named_child_count())
                         .filter_map(|j| child.named_child(j))
-                        .find(|c| c.kind() == "type_identifier");
-                    if let Some(type_id) = type_id {
+                        .filter(|c| c.kind() != "comment");
+                    let only = match (terms.next(), terms.next()) {
+                        (Some(term), None) => Some(term),
+                        _ => None,
+                    };
+                    if let Some(type_id) = self.embedded_type_name(only) {
                         let name = self.text(type_id).to_string();
                         self.push_ref_at(class_row, &name, extends_kind, type_id);
                     }
@@ -869,10 +975,7 @@ impl<'t> Walker<'t> {
                         .filter_map(|j| child.named_child(j))
                         .any(|c| c.kind() == "field_identifier");
                     if !has_field_identifier {
-                        let type_id = (0..child.named_child_count())
-                            .filter_map(|j| child.named_child(j))
-                            .find(|c| c.kind() == "type_identifier");
-                        if let Some(type_id) = type_id {
+                        if let Some(type_id) = self.embedded_type_name(child.child_by_field_name("type")) {
                             let name = self.text(type_id).to_string();
                             self.push_ref_at(class_row, &name, extends_kind, type_id);
                         }
@@ -1009,18 +1112,20 @@ impl<'t> Walker<'t> {
                     row: p.row,
                 });
             }
-            // #1820: preserve the receiver of a method value.
+            // #1820: preserve the receiver of a method value. The name is
+            // rebuilt from operand and field, as normalizeSpecial does, so a
+            // comment or line break beside the dot keeps the candidate.
+            // NAME_STOPLIST applies to the whole name and holds no dotted
+            // word, so it never drops one: `raft.None` is a candidate even
+            // though a bare `None` is not.
             "selector_expression" => {
-                let field = v
-                    .child_by_field_name("field")
-                    .or_else(|| v.named_child(v.named_child_count().saturating_sub(1)));
-                let Some(field) = field else { return };
-                let name = self.text(field);
-                if name.is_empty() || is_stoplisted(name) {
+                let (Some(operand), Some(field)) =
+                    (v.child_by_field_name("operand"), v.child_by_field_name("field"))
+                else {
                     return;
-                }
-                let value = self.text(v);
-                if !value.split('.').all(|part| {
+                };
+                let name = format!("{}.{}", self.text(operand), self.text(field));
+                if !name.split('.').all(|part| {
                     !part.is_empty() && part.chars().enumerate().all(|(i, c)| {
                         c == '_' || c.is_ascii_alphabetic() || (i > 0 && c.is_ascii_digit())
                     })
@@ -1028,7 +1133,7 @@ impl<'t> Walker<'t> {
                 let p = field.start_position();
                 self.fn_ref_cands.push(Cand {
                     from,
-                    name: value.to_string(),
+                    name,
                     line: p.row as u32 + 1,
                     column_byte: field.start_byte(),
                     row: p.row,
@@ -1253,6 +1358,17 @@ fn is_builtin_type(name: &str) -> bool {
     )
 }
 
+/// GO_PREDECLARED_TYPES (languages/go.ts): never a node in the graph, and as
+/// the lone term of an interface a basic type is a constraint, not an embedding.
+fn is_go_predeclared_type(name: &str) -> bool {
+    matches!(
+        name,
+        "any" | "bool" | "byte" | "comparable" | "complex64" | "complex128" | "error" | "float32"
+            | "float64" | "int" | "int8" | "int16" | "int32" | "int64" | "rune" | "string" | "uint"
+            | "uint8" | "uint16" | "uint32" | "uint64" | "uintptr"
+    )
+}
+
 fn opt_str(arena: &mut Arena, s: Option<&str>) -> StrRef {
     match s {
         Some(s) => arena.put(s),
diff --git a/codegraph-kernel/src/java.rs b/codegraph-kernel/src/java.rs
index d5947ac528..daaf49de0e 100644
--- a/codegraph-kernel/src/java.rs
+++ b/codegraph-kernel/src/java.rs
@@ -267,7 +267,7 @@ impl<'t> Walker<'t> {
     fn inside_class_like(&self) -> bool {
         self.stack
             .last()
-            .map(|s| matches!(s.kind, "class" | "struct" | "interface" | "trait" | "enum" | "module"))
+            .map(|s| matches!(s.kind, "class" | "struct" | "interface" | "trait" | "enum" | "module" | "enum_member"))
             .unwrap_or(false)
     }
 
@@ -695,7 +695,8 @@ impl<'t> Walker<'t> {
         for i in 0..body.named_child_count() {
             let Some(child) = body.named_child(i) else { continue };
             if child.kind() == "enum_constant" {
-                self.extract_enum_members(child);
+                let member = self.extract_enum_members(child);
+                self.visit_enum_constant_body(child, member);
             } else {
                 self.visit_node(child);
             }
@@ -703,12 +704,26 @@ impl<'t> Walker<'t> {
         self.stack.pop();
     }
 
-    fn extract_enum_members(&mut self, node: Node<'t>) {
-        if let Some(name_node) = node.child_by_field_name("name") {
-            let name = self.text(name_node).to_string();
-            self.create_node("enum_member", &name, node, Extra::default());
-        }
+    fn extract_enum_members(&mut self, node: Node<'t>) -> Option<(u32, String)> {
+        let name_node = node.child_by_field_name("name")?;
+        let name = self.text(name_node).to_string();
+        let row = self.create_node("enum_member", &name, node, Extra::default())?;
         // (identifier-children / leaf fallbacks are other grammars' shapes)
+        Some((row, name))
+    }
+
+    /// `PLUS { int apply(…) { … } }`: a constant's own class_body declares
+    /// members of its own, scoped under the constant.
+    fn visit_enum_constant_body(&mut self, node: Node<'t>, member: Option<(u32, String)>) {
+        let Some((row, name)) = member else { return };
+        let Some(body) = (0..node.named_child_count()).filter_map(|i| node.named_child(i)).find(|c| c.kind() == "class_body") else { return };
+        self.stack.push(Scope { row, kind: "enum_member", name });
+        for i in 0..body.named_child_count() {
+            if let Some(c) = body.named_child(i) {
+                self.visit_node(c);
+            }
+        }
+        self.stack.pop();
     }
 
     /// extractField — each declarator becomes a field/constant node.
diff --git a/codegraph-kernel/src/kotlin.rs b/codegraph-kernel/src/kotlin.rs
index 9d4a0afec6..a224cb7265 100644
--- a/codegraph-kernel/src/kotlin.rs
+++ b/codegraph-kernel/src/kotlin.rs
@@ -330,7 +330,7 @@ impl<'t> Walker<'t> {
     fn inside_class_like(&self) -> bool {
         self.stack
             .last()
-            .map(|s| matches!(s.kind, "class" | "struct" | "interface" | "trait" | "enum" | "module"))
+            .map(|s| matches!(s.kind, "class" | "struct" | "interface" | "trait" | "enum" | "module" | "enum_member"))
             .unwrap_or(false)
     }
 
@@ -862,6 +862,8 @@ impl<'t> Walker<'t> {
             self.extract_import(node);
         } else if kind == "call_expression" {
             self.extract_call(node);
+        } else if kind == "infix_expression" {
+            self.extract_infix_call(node);
         }
         // companion_object, anonymous_initializer, secondary_constructor,
         // getter/setter siblings, file_annotation, object_literal, if/when at
@@ -890,6 +892,8 @@ impl<'t> Walker<'t> {
 
         if kind == "call_expression" {
             self.extract_call(node);
+        } else if kind == "infix_expression" {
+            self.extract_infix_call(node);
         }
         // (INSTANTIATION_KINDS has no kotlin members; extractBareCall absent.)
 
@@ -1085,7 +1089,8 @@ impl<'t> Walker<'t> {
         for i in 0..body.named_child_count() {
             let Some(child) = body.named_child(i) else { continue };
             if child.kind() == "enum_entry" {
-                self.extract_enum_members(child);
+                let member = self.extract_enum_members(child);
+                self.visit_enum_entry_body(child, member);
             } else {
                 self.visit_node(child);
             }
@@ -1093,18 +1098,36 @@ impl<'t> Walker<'t> {
         self.stack.pop();
     }
 
-    fn extract_enum_members(&mut self, node: Node<'t>) {
+    fn extract_enum_members(&mut self, node: Node<'t>) -> Option<(u32, String)> {
         // name field → null (zero fields) → the identifier-children scan: one
         // enum_member per direct simple_identifier, positioned AT the
-        // identifier. Entry value_arguments and entry class_bodies (override
-        // methods!) are never visited — invisible (quirk).
+        // identifier. Entry value_arguments are never visited.
+        let mut first: Option<(u32, String)> = None;
         for i in 0..node.named_child_count() {
             let Some(child) = node.named_child(i) else { continue };
             if matches!(child.kind(), "simple_identifier" | "identifier" | "property_identifier") {
                 let name = self.text(child).to_string();
-                self.create_node("enum_member", &name, child, Extra::default());
+                let row = self.create_node("enum_member", &name, child, Extra::default());
+                if first.is_none() {
+                    first = row.map(|r| (r, name));
+                }
             }
         }
+        first
+    }
+
+    /// `NewBuffer { override fun pipe() … }`: an entry's own class_body
+    /// declares members of its own, scoped under the entry.
+    fn visit_enum_entry_body(&mut self, node: Node<'t>, member: Option<(u32, String)>) {
+        let Some((row, name)) = member else { return };
+        let Some(body) = (0..node.named_child_count()).filter_map(|i| node.named_child(i)).find(|c| c.kind() == "class_body") else { return };
+        self.stack.push(Scope { row, kind: "enum_member", name });
+        for i in 0..body.named_child_count() {
+            if let Some(c) = body.named_child(i) {
+                self.visit_node(c);
+            }
+        }
+        self.stack.pop();
     }
 
     /// extractTypeAlias — plain node; the alias-value ref walk reads the
@@ -1149,6 +1172,28 @@ impl<'t> Walker<'t> {
     /// extractCall — the kotlin paths: navigation member branch (+ the #750
     /// re-encode) and the raw-text else (paren-then-lambda / glued-invoke
     /// garbage preserved).
+    /// extractKotlinInfixCall — `Users.id eq id1` / `a to b`: a call of the
+    /// middle simple_identifier, `lhs.fn` when the left operand is a plain
+    /// name, else the bare name; literal left operands emit nothing.
+    fn extract_infix_call(&mut self, node: Node<'t>) {
+        if self.stack.is_empty() || node.named_child_count() != 3 {
+            return;
+        }
+        let (Some(lhs), Some(func)) = (node.named_child(0), node.named_child(1)) else { return };
+        if func.kind() != "simple_identifier" || is_literal_receiver(lhs.kind()) {
+            return;
+        }
+        let caller = self.top_row();
+        let name = self.text(func);
+        let receiver = if lhs.kind() == "simple_identifier" { self.text(lhs) } else { "" };
+        let callee = if !receiver.is_empty() && receiver != "this" && receiver != "super" {
+            format!("{receiver}.{name}")
+        } else {
+            name.to_string()
+        };
+        self.push_ref_at(caller, &callee, edge_kind_index("calls").unwrap(), node);
+    }
+
     fn extract_call(&mut self, node: Node<'t>) {
         if self.stack.is_empty() {
             return;
diff --git a/codegraph-kernel/src/rustlang.rs b/codegraph-kernel/src/rustlang.rs
index 1dbc689b41..64b8923ddc 100644
--- a/codegraph-kernel/src/rustlang.rs
+++ b/codegraph-kernel/src/rustlang.rs
@@ -66,6 +66,11 @@ fn simple_ident_re() -> &'static Regex {
     static RE: OnceLock<Regex> = OnceLock::new();
     RE.get_or_init(|| Regex::new(r"^[A-Za-z_][0-9A-Za-z_]*$").unwrap())
 }
+/// extractStaticMemberRef's capitalized-receiver test.
+fn capitalized_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"^[A-Z][A-Za-z0-9_]*$").unwrap())
+}
 
 struct Scope {
     row: u32,
@@ -1056,9 +1061,9 @@ impl<'t> Walker<'t> {
 
     /// extractInheritance — the rust-reachable cases: trait_bounds
     /// (supertraits; a scoped `fmt::Debug` bound matches NO case and is
-    /// dropped), the Go embedding check on field_declaration (inert in rust —
-    /// every field has a field_identifier), and the field_declaration_list
-    /// recursion that reaches it.
+    /// dropped) and the field_declaration_list recursion. The TS Go-embedding
+    /// check on field_declaration is gated to Go (and was inert here anyway —
+    /// every rust field has a field_identifier).
     fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) {
         stack_guard!();
         let extends_kind = edge_kind_index("extends").unwrap();
@@ -1097,20 +1102,6 @@ impl<'t> Walker<'t> {
                         }
                     }
                 }
-                "field_declaration" => {
-                    let has_field_identifier = (0..child.named_child_count())
-                        .filter_map(|j| child.named_child(j))
-                        .any(|c| c.kind() == "field_identifier");
-                    if !has_field_identifier {
-                        let type_id = (0..child.named_child_count())
-                            .filter_map(|j| child.named_child(j))
-                            .find(|c| c.kind() == "type_identifier");
-                        if let Some(type_id) = type_id {
-                            let name = self.text(type_id).to_string();
-                            self.push_ref_at(class_row, &name, extends_kind, type_id);
-                        }
-                    }
-                }
                 "field_declaration_list" | "class_heritage" => {
                     self.extract_inheritance(child, class_row);
                 }
@@ -1183,10 +1174,12 @@ impl<'t> Walker<'t> {
 
     fn visit_function_body(&mut self, body: Node<'t>) {
         stack_guard!();
-        self.visit_for_calls_and_structure(body);
+        self.visit_for_calls_and_structure(body, None);
     }
 
-    fn visit_for_calls_and_structure(&mut self, node: Node<'t>) {
+    /// `parent` is `node`'s parent, handed down by the walk (None at a body's
+    /// root): `Node::parent()` walks down from the tree's root on every call.
+    fn visit_for_calls_and_structure(&mut self, node: Node<'t>, parent: Option<Node<'t>>) {
         stack_guard!();
         let kind = node.kind();
         self.maybe_capture_fn_refs(node);
@@ -1201,6 +1194,7 @@ impl<'t> Walker<'t> {
         } else if kind == "struct_expression" {
             self.extract_instantiation(node);
         }
+        self.extract_static_member_ref(node, parent);
 
         // Nested NAMED fns become their own nodes (a nested fn inside an impl
         // method walks up to the impl and indexes as a METHOD).
@@ -1232,11 +1226,69 @@ impl<'t> Walker<'t> {
 
         for i in 0..node.named_child_count() {
             if let Some(c) = node.named_child(i) {
-                self.visit_for_calls_and_structure(c);
+                self.visit_for_calls_and_structure(c, Some(node));
             }
         }
     }
 
+    /// extractStaticMemberRef — the rust branch (#2328): an enum variant
+    /// written as a path (`Mode::A`, `mode::Mode::B`, a `Mode::C(x)` /
+    /// `Mode::D { .. }` pattern, `Self::A` in an impl) references the receiver
+    /// — the segment before the member, at the place it is written; the
+    /// resolver keeps it only on an enum that declares the member. A lowercase
+    /// receiver (module) or member (fn), a call's callee or a struct literal's
+    /// name (both already linked to their member), a path's prefix and a `use`
+    /// tree emit nothing. Mirrored byte-for-byte — change both.
+    fn extract_static_member_ref(&mut self, node: Node<'t>, parent: Option<Node<'t>>) {
+        let kind = node.kind();
+        if (kind != "scoped_identifier" && kind != "scoped_type_identifier") || self.stack.is_empty() {
+            return;
+        }
+        // Looked up only at a body's root (a `const X: M = M::A;` value).
+        let Some(parent) = parent.or_else(|| node.parent()) else { return };
+        let member_path = if kind == "scoped_identifier" {
+            !matches!(
+                parent.kind(),
+                "scoped_identifier"
+                    | "scoped_type_identifier"
+                    | "use_declaration"
+                    | "use_list"
+                    | "scoped_use_list"
+                    | "use_as_clause"
+                    | "use_wildcard"
+            )
+        } else {
+            parent.kind() == "struct_pattern"
+        };
+        if !member_path {
+            return;
+        }
+        if parent.kind() == "call_expression"
+            && parent.child_by_field_name("function").map(|f| f.start_byte()) == Some(node.start_byte())
+        {
+            return;
+        }
+        let Some(member) = node.child_by_field_name("name") else { return };
+        let mut recv = node.child_by_field_name("path");
+        if let Some(r) = recv {
+            if r.kind() == "scoped_identifier" {
+                recv = r.child_by_field_name("name");
+            }
+        }
+        let Some(recv) = recv else { return };
+        if recv.kind() != "identifier" || !self.text(member).starts_with(|c: char| c.is_ascii_uppercase()) {
+            return;
+        }
+        let mut text = self.text(recv).to_string();
+        if text == "Self" {
+            text = self.receiver_type_of(node).unwrap_or_default();
+        }
+        if capitalized_re().is_match(&text) {
+            let owner = self.top_row();
+            self.push_ref_at(owner, &text, edge_kind_index("references").unwrap(), recv);
+        }
+    }
+
     // --- fn refs (RUST_SPEC) ----------------------------------------------------
 
     /// maybeCaptureFnRefs with RUST_SPEC's dispatch: arguments→args,
diff --git a/codegraph-kernel/src/swift.rs b/codegraph-kernel/src/swift.rs
index 1613888c3e..f1d3ae4ac9 100644
--- a/codegraph-kernel/src/swift.rs
+++ b/codegraph-kernel/src/swift.rs
@@ -110,6 +110,24 @@ fn strip_js_ws(s: &str) -> String {
     s.chars().filter(|c| !is_js_space(*c)).collect()
 }
 
+/// SWIFT_TYPE_PATH_RECEIVER (tree-sitter.ts): `API.PackageController.GetRoute` —
+/// two segments or more, each an ASCII capital then `[A-Za-z0-9_]*` (JS `\w`),
+/// not led by `Self.`.
+fn is_type_path(s: &str) -> bool {
+    if s.starts_with("Self.") {
+        return false;
+    }
+    let mut segments = 0;
+    for seg in s.split('.') {
+        let b = seg.as_bytes();
+        if b.is_empty() || !b[0].is_ascii_uppercase() || !b[1..].iter().all(|c| c.is_ascii_alphanumeric() || *c == b'_') {
+            return false;
+        }
+        segments += 1;
+    }
+    segments >= 2
+}
+
 struct Scope {
     row: u32,
     kind: &'static str,
@@ -1061,8 +1079,16 @@ impl<'t> Walker<'t> {
                     } else {
                         method_name.to_string()
                     };
+                } else if let Some(path) = receiver
+                    .filter(|r| r.kind() == "navigation_expression")
+                    .map(|r| strip_js_ws(self.text(r)))
+                    .filter(|p| is_type_path(p))
+                {
+                    // A type path, `API.PackageController.GetRoute.query(on:)`:
+                    // keep it for the resolver (tree-sitter.ts SWIFT_TYPE_PATH_RECEIVER).
+                    callee_name = format!("{path}.{method_name}");
                 } else {
-                    // self_expression / super_expression / inner nav /
+                    // self_expression / super_expression / instance nav /
                     // postfix / multi_line_string_literal → bare method name.
                     callee_name = method_name.to_string();
                 }
diff --git a/codegraph-kernel/src/textutil.rs b/codegraph-kernel/src/textutil.rs
index d322a19905..69f5aea824 100644
--- a/codegraph-kernel/src/textutil.rs
+++ b/codegraph-kernel/src/textutil.rs
@@ -55,7 +55,7 @@ pub fn is_generated_file(file_path: &str) -> bool {
             r"\.pb\.[jt]s$",
             r"_pb\.[jt]s$",
             r"_grpc_pb\.[jt]s$",
-            r"\.min\.m?js$",
+            r"[.-]min\.m?js$",
             r"_pb2(_grpc)?\.py$",
             r"_pb2\.pyi$",
             r"\.pb\.(cc|h)$",
@@ -78,6 +78,56 @@ pub fn is_generated_file(file_path: &str) -> bool {
     patterns.iter().any(|p| p.is_match(file_path))
 }
 
+// isMinifiedContent's WEBPACK_RUNTIME (`\b` ASCII, as in JS).
+re!(webpack_runtime, r"(?-u:\b)function __webpack_require__\s*\(");
+
+/// isMinifiedContent (src/extraction/generated-detection.ts): a `.js` / `.mjs`
+/// / `.cjs` file of at least 4000 UTF-16 units whose text sits mostly on lines
+/// of 1000 units or more, dense with `;{}(),` — or that carries a webpack
+/// runtime. Lengths are counted in UTF-16 units, as the JS string ops count
+/// them, so both extractors agree on every file.
+pub fn is_minified_content(file_path: &str, content: &str) -> bool {
+    const LINE: usize = 1000;
+    let lower = file_path.to_ascii_lowercase();
+    if !(lower.ends_with(".js") || lower.ends_with(".mjs") || lower.ends_with(".cjs")) {
+        return false;
+    }
+    // UTF-16 units never outnumber UTF-8 bytes: a short file is out at once.
+    if content.len() < 4 * LINE {
+        return false;
+    }
+    let total = content.encode_utf16().count();
+    if total < 4 * LINE {
+        return false;
+    }
+    if webpack_runtime().is_match(content) {
+        return true;
+    }
+    let (mut long, mut punctuation) = (0usize, 0usize);
+    let (mut line_len, mut line_punct) = (0usize, 0usize);
+    for unit in content.encode_utf16() {
+        if unit == 10 {
+            if line_len >= LINE {
+                long += line_len;
+                punctuation += line_punct;
+            }
+            line_len = 0;
+            line_punct = 0;
+            continue;
+        }
+        line_len += 1;
+        // ; { } ( ) ,
+        if matches!(unit, 59 | 123 | 125 | 40 | 41 | 44) {
+            line_punct += 1;
+        }
+    }
+    if line_len >= LINE {
+        long += line_len;
+        punctuation += line_punct;
+    }
+    long as f64 >= total as f64 * 0.5 && punctuation as f64 >= long as f64 * 0.03
+}
+
 /// Byte offsets of each line start, for UTF-16 column conversion.
 pub fn line_starts(src: &str) -> Vec<usize> {
     let mut out = vec![0usize];
diff --git a/codegraph-kernel/src/tsjs/extractors.rs b/codegraph-kernel/src/tsjs/extractors.rs
index 6426db3156..1c84f8c33a 100644
--- a/codegraph-kernel/src/tsjs/extractors.rs
+++ b/codegraph-kernel/src/tsjs/extractors.rs
@@ -5,8 +5,8 @@
 
 use crate::textutil as util;
 use super::{
-    body_of, is_builtin_type, is_literal_receiver, is_react_hoc, is_variable_type,
-    is_vue_collection_name, Extra, Scope, Walker,
+    body_of, is_builtin_type, is_host_global_root, is_literal_receiver, is_object_member_function,
+    is_react_hoc, is_static_object_key, is_variable_type, is_vue_collection_name, Extra, Scope, Walker,
 };
 use crate::buffers::edge_kind_index;
 use tree_sitter::Node;
@@ -103,6 +103,9 @@ impl<'t> Walker<'t> {
     /// inner is the inline render function, or None for `styled.x`/`memo(Ref)`.
     /// Outer None = not a component wrapper.
     fn react_component_hoc(&self, value: Node<'t>) -> Option<Option<Node<'t>>> {
+        if self.is_typed_styled_template(value) {
+            return Some(None);
+        }
         if value.kind() != "call_expression" {
             return None;
         }
@@ -128,6 +131,35 @@ impl<'t> Walker<'t> {
         Some(inner)
     }
 
+    /// A typed styled tag, `styled.div<Props>` before a template literal, which
+    /// parses as comparisons: `(styled.div < Props) > template`. The leftmost
+    /// operand is the `styled` tag against a `<`; the rightmost is the
+    /// template_string against a `>` (`>>` when the type argument ends in its
+    /// own `<…>`). Mirrors TreeSitterExtractor.isTypedStyledTemplate.
+    fn is_typed_styled_template(&self, value: Node<'t>) -> bool {
+        if value.kind() != "binary_expression" {
+            return false;
+        }
+        let (mut tag_parent, mut tag) = (value, value.child_by_field_name("left"));
+        while let Some(t) = tag.filter(|t| t.kind() == "binary_expression") {
+            (tag_parent, tag) = (t, t.child_by_field_name("left"));
+        }
+        let (mut template_parent, mut template) = (value, value.child_by_field_name("right"));
+        while let Some(t) = template.filter(|t| t.kind() == "binary_expression") {
+            (template_parent, template) = (t, t.child_by_field_name("right"));
+        }
+        let (Some(tag), Some(template)) = (tag, template) else {
+            return false;
+        };
+        let operator = |n: Node<'t>| n.child_by_field_name("operator").map(|o| o.kind()).unwrap_or("");
+        let closing = operator(template_parent);
+        template.kind() == "template_string"
+            && operator(tag_parent) == "<"
+            && !closing.is_empty()
+            && closing.bytes().all(|b| b == b'>')
+            && util::styled_callee().is_match(self.text(tag))
+    }
+
     fn extract_react_component_node(
         &mut self,
         name: &str,
@@ -363,8 +395,15 @@ impl<'t> Walker<'t> {
             return false;
         }
         let n = regex::escape(name);
+        // `R` (CRLF mode): JS's multiline `^`/`$` treat `\r` as a line end as
+        // well as `\n`; `(?m)` alone sees only `\n`, and would miss `export
+        // default NAME;\r\n` on every Windows autocrlf checkout.
+        // Inside `{ … }` the name is bounded by a character that can't
+        // continue an identifier, not by `\b`, which takes a `$` for a
+        // separator. The crate has no look-around, so the bounds consume.
+        // ASCII classes, not `\w`: this crate's `\w` is Unicode, JS's is not.
         let pattern = format!(
-            r"(?m)^[ \t]*export\s+(?:default\s+{n}\s*;?[ \t]*$|\{{[^}}]*\b{n}\b[^}}]*\}})",
+            r"(?mR)^[ \t]*export\s+(?:default\s+{n}\s*;?[ \t]*$|\{{(?:[^}}]*[^0-9A-Za-z_$}}])?{n}(?:[^0-9A-Za-z_$}}][^}}]*)?\}})",
             n = n
         );
         match regex::Regex::new(&pattern) {
@@ -387,7 +426,7 @@ impl<'t> Walker<'t> {
             let Some(name_node) = child.child_by_field_name("name") else { continue };
             let value = child.child_by_field_name("value");
 
-            // Destructured patterns are skipped — except RTK Query generated
+            // Destructured patterns mint no node — except RTK Query generated
             // hooks (`export const { useGetXQuery } = api`).
             if matches!(name_node.kind(), "object_pattern" | "array_pattern") {
                 if name_node.kind() == "object_pattern"
@@ -395,6 +434,11 @@ impl<'t> Walker<'t> {
                 {
                     self.extract_rtk_hook_bindings(name_node, is_exported);
                 }
+                // The initializer (and any default in the pattern) still runs:
+                // walk the declarator as a function body walks it, with the
+                // enclosing scope on the stack (#2340). Mirrors
+                // TreeSitterExtractor.extractVariable.
+                self.visit_function_body(child);
                 continue;
             }
             let name = self.text(name_node).to_string();
@@ -444,6 +488,15 @@ impl<'t> Walker<'t> {
                 self.extract_variable_type_annotation(child, row);
             }
 
+            // A named object literal owns its function members, exported or
+            // not (#2300): `const api = { load() {…} }` gives `api::load`. The
+            // rest of the literal is walked under the owner (#693). Mirrors
+            // the ownedObject branch of TreeSitterExtractor.extractVariable.
+            if let (Some(row), Some(obj)) = (var_row, self.owned_object_value(value)) {
+                self.extract_owned_object_members(obj, row, kind, &name, true, false);
+                continue;
+            }
+
             // Exported const object-of-functions / store shapes.
             let object_of_fns: Option<Node> = match value {
                 Some(v) if matches!(v.kind(), "object" | "object_expression") => Some(v),
@@ -547,6 +600,189 @@ impl<'t> Walker<'t> {
         }
     }
 
+    // --- owned object literals (#2300) ------------------------------------------------
+
+    /// ownsObjectLiterals: a generated or minified bundle — named so or not —
+    /// keeps the old shape. (Every tsjs variant is TS/JS, so only that check
+    /// remains; it is computed once per file.)
+    fn owns_object_literals(&self) -> bool {
+        self.owns_objects
+    }
+
+    /// ownedMemberFunction: the function an owned literal's member becomes,
+    /// named by its static key — `load() {…}`, `load: () => {…}`,
+    /// `load: function () {…}`, `load: function* () {…}`. None for every other
+    /// member (a computed key, a value, a shorthand, a spread).
+    fn owned_member_function(&self, member: Node<'t>) -> Option<(Node<'t>, String)> {
+        if member.kind() == "method_definition" {
+            let key = member.child_by_field_name("name")?;
+            if !is_static_object_key(key.kind()) {
+                return None;
+            }
+            return Some((member, util::object_key_name(self.text(key))));
+        }
+        if member.kind() != "pair" {
+            return None;
+        }
+        let key = member.child_by_field_name("key")?;
+        let value = member.child_by_field_name("value")?;
+        if !is_static_object_key(key.kind()) || !is_object_member_function(value.kind()) {
+            return None;
+        }
+        Some((value, util::object_key_name(self.text(key))))
+    }
+
+    /// ownedObjectValue: `value` when it is an object literal owning at least
+    /// one function member.
+    pub(super) fn owned_object_value(&self, value: Option<Node<'t>>) -> Option<Node<'t>> {
+        let value = value?;
+        if !matches!(value.kind(), "object" | "object_expression") || !self.owns_object_literals() {
+            return None;
+        }
+        for i in 0..value.named_child_count() {
+            if let Some(member) = value.named_child(i) {
+                if self.owned_member_function(member).is_some() {
+                    return Some(value);
+                }
+            }
+        }
+        None
+    }
+
+    /// Put an owner on the stack — on top of the file alone for one on the
+    /// global object — returning what was set aside for leave_owner.
+    fn enter_owner(&mut self, row: u32, kind: &'static str, name: &str, global: bool) -> Vec<Scope> {
+        let rest = if global { self.stack.split_off(1) } else { Vec::new() };
+        self.stack.push(Scope { row, kind, name: name.to_string() });
+        rest
+    }
+
+    fn leave_owner(&mut self, rest: Vec<Scope>) {
+        self.stack.pop();
+        self.stack.extend(rest);
+    }
+
+    /// extractOwnedObjectMembers: each function member becomes its own node,
+    /// qualified under the owner (at file scope for one on the global object).
+    /// Every other member runs where the literal is written: under the owner
+    /// for a module-scope declaration (`values_under_owner`, #693), under the
+    /// enclosing scope for a local or an assignment. The literal's shorthand
+    /// members go to the function-as-value capture the same way.
+    fn extract_owned_object_members(&mut self, obj: Node<'t>, row: u32, kind: &'static str, name: &str, values_under_owner: bool, global: bool) {
+        let held = values_under_owner.then(|| self.enter_owner(row, kind, name, global));
+        self.maybe_capture_fn_refs(obj);
+        for i in 0..obj.named_child_count() {
+            let Some(member) = obj.named_child(i) else { continue };
+            if let Some((func, member_name)) = self.owned_member_function(member) {
+                if values_under_owner {
+                    self.extract_function(func, Some(member_name));
+                } else {
+                    let rest = self.enter_owner(row, kind, name, global);
+                    self.extract_function(func, Some(member_name));
+                    self.leave_owner(rest);
+                }
+            } else {
+                self.visit_function_body(member);
+            }
+        }
+        if let Some(rest) = held {
+            self.leave_owner(rest);
+        }
+    }
+
+    /// extractLocalObjectOwner: `const api = { load() {…} }` in a function body
+    /// or an IIFE gets the node a module-scope declaration would, with its
+    /// members under it. False when the declarator holds no owned literal.
+    pub(super) fn extract_local_object_owner(&mut self, declarator: Node<'t>) -> bool {
+        let Some(name_node) = declarator.child_by_field_name("name") else { return false };
+        if name_node.kind() != "identifier" {
+            return false;
+        }
+        let Some(obj) = self.owned_object_value(declarator.child_by_field_name("value")) else {
+            return false;
+        };
+        let is_const = declarator.parent().map(|d| self.is_const_decl(d)).unwrap_or(false);
+        let kind: &'static str = if is_const { "constant" } else { "variable" };
+        let name = self.text(name_node).to_string();
+        // A local: never the target of another scope's value read.
+        let extra = Extra {
+            docstring: crate::docstring::preceding_docstring(declarator, self.src),
+            signature: Some(util::init_signature(self.text(obj))),
+            is_exported: Some(false),
+            not_value_target: true,
+            ..Extra::default()
+        };
+        let Some(row) = self.create_node(kind, &name, declarator, extra) else { return false };
+        self.extract_variable_type_annotation(declarator, row);
+        self.extract_owned_object_members(obj, row, kind, &name, false, false);
+        true
+    }
+
+    /// extractAssignedObjectOwner: `window.App = {…}` / `App.utils = {…}` /
+    /// `dw_page = {…}`. A plain identifier target is qualified like a
+    /// declaration. A path's owner is named by its last link and qualified by
+    /// the path as written, and so are its members (`window.App::init`); a
+    /// path on the global object is global wherever it is written, so it is
+    /// contained by the file. False (nothing extracted) for any other assignment.
+    pub(super) fn extract_assigned_object_owner(&mut self, node: Node<'t>, module_level: bool) -> bool {
+        let Some(obj) = self.owned_object_value(node.child_by_field_name("right")) else { return false };
+        let Some(path) = self.object_owner_path(node.child_by_field_name("left")) else { return false };
+        // A plain name assigned at module level is a global (`dw_page = {…}`);
+        // in a function it is a local being reassigned.
+        if path.len() == 1 && !module_level {
+            return false;
+        }
+        let qualified_name = (path.len() > 1).then(|| path.join("."));
+        let global = path.len() > 1 && is_host_global_root(&path[0]);
+        let rest = if global { self.stack.split_off(1) } else { Vec::new() };
+        let statement = node.parent().filter(|p| p.kind() == "expression_statement").unwrap_or(node);
+        let name = path.last().cloned().unwrap_or_default();
+        // `App.utils` is read as `App.utils`, never as a bare `utils`.
+        let extra = Extra {
+            docstring: crate::docstring::preceding_docstring(statement, self.src),
+            signature: Some(util::init_signature(self.text(obj))),
+            is_exported: Some(false),
+            qualified_name: qualified_name.clone(),
+            not_value_target: !(path.len() == 1 || global),
+            ..Extra::default()
+        };
+        let row = self.create_node("variable", &name, node, extra);
+        self.stack.extend(rest);
+        let Some(row) = row else { return false };
+        if let Some(qualified_name) = qualified_name {
+            self.object_path_owners.insert(row, qualified_name);
+        }
+        self.extract_owned_object_members(obj, row, "variable", &name, false, global);
+        true
+    }
+
+    /// objectOwnerPath: an assignment target's links written as plain names
+    /// (`dw_page` → [dw_page], `App.utils.dom` → [App, utils, dom]), or None
+    /// for anything else — `this.x`, `a[k]`, a call, CommonJS's
+    /// `module.exports` / `exports.x`, or a prototype.
+    fn object_owner_path(&self, left: Option<Node<'t>>) -> Option<Vec<String>> {
+        let mut path: Vec<String> = Vec::new();
+        let mut cur = left?;
+        while cur.kind() == "member_expression" {
+            let property = cur.child_by_field_name("property")?;
+            if property.kind() != "property_identifier" {
+                return None;
+            }
+            path.push(self.text(property).to_string());
+            cur = cur.child_by_field_name("object")?;
+        }
+        if cur.kind() != "identifier" {
+            return None;
+        }
+        let root = self.text(cur);
+        if root == "module" || root == "exports" || path.iter().any(|p| p == "prototype") {
+            return None;
+        }
+        path.push(root.to_string());
+        path.reverse();
+        Some(path)
+    }
+
     // --- object-literal / store helpers -------------------------------------------------
 
     pub(super) fn extract_object_literal_functions(&mut self, obj: Node<'t>) {
diff --git a/codegraph-kernel/src/tsjs/mod.rs b/codegraph-kernel/src/tsjs/mod.rs
index bdc88e8aba..dc5d333524 100644
--- a/codegraph-kernel/src/tsjs/mod.rs
+++ b/codegraph-kernel/src/tsjs/mod.rs
@@ -136,6 +136,24 @@ fn is_vue_collection_name(name: &str) -> bool {
     matches!(name, "actions" | "mutations" | "getters")
 }
 
+/// OBJECT_MEMBER_FUNCTION_TYPES (tree-sitter.ts, #2300): the function values an
+/// owned object literal's member can hold.
+fn is_object_member_function(kind: &str) -> bool {
+    matches!(kind, "arrow_function" | "function_expression" | "generator_function")
+}
+
+/// STATIC_OBJECT_KEY_TYPES (tree-sitter.ts, #2300): keys that name a member — a
+/// computed `[expr]` key names nothing static.
+fn is_static_object_key(kind: &str) -> bool {
+    matches!(kind, "property_identifier" | "string" | "number")
+}
+
+/// HOST_GLOBAL_ROOTS (tree-sitter.ts, #2300): `window.App = {…}` defines the
+/// global `App`. (`self` is usually `var self = this` in page code, not the global.)
+fn is_host_global_root(name: &str) -> bool {
+    matches!(name, "window" | "globalThis")
+}
+
 /// One scope-stack entry (TS keeps node IDs; rows are our equivalent).
 struct Scope {
     row: u32,
@@ -153,6 +171,9 @@ struct Extra {
     is_async: Option<bool>,
     is_static: Option<bool>,
     qualified_name: Option<String>,
+    /// Never a value-read target: a local, or an object hung on a dotted path
+    /// (createNode's `valueTarget = false`, #2300).
+    not_value_target: bool,
 }
 
 struct ValueScope<'t> {
@@ -185,6 +206,12 @@ pub struct Walker<'t> {
     fs_value_counts: HashMap<String, u32>,
     value_scopes: Vec<ValueScope<'t>>,
     vue_store_file: Option<bool>,
+    /// An object literal hung on a path (`window.App = {…}`) is qualified by
+    /// the path, and so is what it holds (#2300): row → that qualified name.
+    /// Mirrors TreeSitterExtractor.objectPathOwners.
+    object_path_owners: HashMap<u32, String>,
+    /// ownsObjectLiterals: false for a generated or minified bundle (#2300).
+    owns_objects: bool,
 }
 
 const MAX_VALUE_REF_NODES: usize = 20_000;
@@ -234,6 +261,8 @@ pub fn extract(file_path: &str, source: &str, language: &str) -> Result<EmitOut,
         fs_value_counts: HashMap::new(),
         value_scopes: Vec::new(),
         vue_store_file: None,
+        object_path_owners: HashMap::new(),
+        owns_objects: !util::is_generated_file(file_path) && !util::is_minified_content(file_path, source),
     };
 
     // File node (TreeSitterExtractor.extract): id `file:<path>`, endLine =
@@ -352,6 +381,7 @@ impl<'t> Walker<'t> {
         let start_line = self.line_of(node);
         let column = self.col_of(node);
         let id = self.node_id_allocator.generate(self.file_path, kind, name, start_line, column);
+        let value_target = !extra.not_value_target;
 
         // endLine body extension: resolveBody only (TS/JS: function-valued
         // class fields whose body nests in the arrow / HOF-wrapped arrow).
@@ -369,6 +399,13 @@ impl<'t> Walker<'t> {
         let qualified = extra.qualified_name.unwrap_or_else(|| {
             let mut parts: Vec<&str> = Vec::new();
             for s in &self.stack {
+                // A path-hung object literal qualifies what it holds by its
+                // path (`window.App::init`), which carries its own scope.
+                if let Some(path) = self.object_path_owners.get(&s.row) {
+                    parts.clear();
+                    parts.push(path);
+                    continue;
+                }
                 if s.kind != "file" {
                     parts.push(&s.name);
                 }
@@ -434,18 +471,19 @@ impl<'t> Walker<'t> {
         if kind == "function" || kind == "method" {
             self.defined_fn_names.insert(name.to_string());
         }
-        self.capture_value_ref_scope(kind, name, row, node);
+        self.capture_value_ref_scope(kind, name, row, node, value_target);
         Some(row)
     }
 
     // --- value references (captureValueRefScope / flushValueRefs) --------------
 
-    fn capture_value_ref_scope(&mut self, kind: &'static str, name: &str, row: u32, node: Node<'t>) {
+    fn capture_value_ref_scope(&mut self, kind: &'static str, name: &str, row: u32, node: Node<'t>, value_target: bool) {
         if !self.variant.value_refs() {
             return;
         }
         let target_kind_ok = kind == "constant" || kind == "variable";
-        if target_kind_ok
+        if value_target
+            && target_kind_ok
             && util::utf16_len(name) >= 3
             && util::has_upper_or_underscore().is_match(name)
         {
@@ -640,6 +678,12 @@ impl<'t> Walker<'t> {
         // Function-as-value capture — independent of the dispatch ladder.
         self.maybe_capture_fn_refs(node);
 
+        // `window.App = {…}` / `App.utils = {…}`: the object's functions are
+        // the path's members (#2300). Its whole subtree is handled there.
+        if kind == "assignment_expression" && self.extract_assigned_object_owner(node, true) {
+            return;
+        }
+
         if is_function_type(kind) {
             // (the isInsideClassLike + methodTypes overlap is Python/Ruby-only)
             self.extract_function(node, None);
@@ -729,6 +773,16 @@ impl<'t> Walker<'t> {
         let kind = node.kind();
         self.maybe_capture_fn_refs(node);
 
+        // A named object literal in a body (an IIFE's `const App = {…}`) owns
+        // its function members as one at module scope does, and so does
+        // `window.App = {…}` written in here (#2300). Each handles its subtree.
+        if kind == "variable_declarator" && self.extract_local_object_owner(node) {
+            return;
+        }
+        if kind == "assignment_expression" && self.extract_assigned_object_owner(node, false) {
+            return;
+        }
+
         if kind == "call_expression" {
             self.extract_call(node);
         } else if kind == "new_expression" {
@@ -976,7 +1030,8 @@ impl<'t> Walker<'t> {
         None
     }
 
-    /// isExported: walk the parent chain for an export_statement.
+    /// isExported: walk the parent chain for an export_statement, then ask
+    /// whether a `declare module '…'` / `declare global` body exports it.
     fn is_exported(&self, node: Node) -> bool {
         let mut cur = node.parent();
         while let Some(p) = cur {
@@ -985,7 +1040,7 @@ impl<'t> Walker<'t> {
             }
             cur = p.parent();
         }
-        false
+        is_ambient_export(node)
     }
 
     fn has_keyword_child(&self, node: Node, kw: &str) -> bool {
@@ -1082,6 +1137,48 @@ fn body_of(node: Node) -> Option<Node> {
     resolve_field_body(node).or_else(|| node.child_by_field_name("body"))
 }
 
+/// isAmbientExport (languages/typescript.ts): declared in a `declare module
+/// 'x' { … }` or `declare global { … }` body, which TypeScript exports without
+/// an `export` keyword unless the body holds an export declaration of its own.
+fn is_ambient_export(node: Node) -> bool {
+    let mut cur = node.parent();
+    while let Some(p) = cur {
+        if p.kind() == "statement_block" && has_export_declaration(p) {
+            return false;
+        }
+        if p.kind() == "ambient_declaration" {
+            // `declare global` is the keyword and a bare block, with no field names.
+            for i in 0..p.child_count() {
+                if p.child(i).is_some_and(|c| c.kind() == "global") {
+                    return true;
+                }
+            }
+            if let Some(declared) = p.named_child(0) {
+                if declared.kind() == "module"
+                    && declared.child_by_field_name("name").is_some_and(|n| n.kind() == "string")
+                {
+                    return true;
+                }
+            }
+        }
+        cur = p.parent();
+    }
+    false
+}
+
+/// hasExportDeclaration: a statement that exports by name or by assignment
+/// (`export {…}`, `export =`, `export default x`), not by declaring.
+fn has_export_declaration(block: Node) -> bool {
+    for i in 0..block.named_child_count() {
+        if let Some(statement) = block.named_child(i) {
+            if statement.kind() == "export_statement" && statement.child_by_field_name("declaration").is_none() {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 fn opt_str(arena: &mut Arena, s: Option<&str>) -> StrRef {
     match s {
         Some(s) => arena.put(s),
diff --git a/docs/benchmarks/index-drift-cg33.md b/docs/benchmarks/index-drift-cg33.md
index 58fdce46a3..2778beaf08 100644
--- a/docs/benchmarks/index-drift-cg33.md
+++ b/docs/benchmarks/index-drift-cg33.md
@@ -125,6 +125,69 @@ named `push`, or a Rust method named `join`. **The full rebuild is the wrong one
 here** — converging would mean teaching sync to manufacture thousands of wrong
 edges. Left as is, deliberately.
 
+### Navigation waits on a route, not a name (2026-10)
+
+A router's navigation call — `history.push('/login')`, `navigate('/login')`,
+`router.push('/x')`, `goto('/x')` — names its route by path and its reference
+by the router's method, so a route that changes in another file is invisible
+to every pass above:
+
+- **A call parked while its route was missing.** The #1240 retry looks failed
+  refs up by the names the synced files define, and a call's name tail is
+  `push`, never a path. On proshop_mern, deleting and restoring
+  `<Route path='/login'>` left six `history.push('/login')` calls failed and
+  their six `navigates` edges missing.
+- **A call that bound elsewhere meanwhile.** It resolved, so nothing revisits
+  it: to a catch-all screen (Obytes' Expo starter: `router.replace('/login')`
+  stayed on `[...messing].tsx` after `login.tsx` came back), to a parameter
+  route (`/users/new` on `/users/:id`), or to the other arm of a conditional
+  (sveltekit-realworld's `redirect` lost its `/login` arm for good).
+- **A route renamed in place.** `runPostExtract` renames a route whose path is
+  built from a constant another file holds, an Angular route under its mount,
+  or a React Router table route, and keeps its node, so the calls bound to it
+  keep pointing at a path it no longer has. `definitionDelta` is read before
+  that pass.
+- **A link in markup.** `<Link to>`, `routerLink` and the like are a
+  synthesizer's edges, and a routes file that matches none of the synthesis
+  triggers (an Angular `Routes` array, Ghostfolio's `home-page.routes.ts`)
+  does not send a sync to the synthesizers.
+
+Sync now reads every route node at its first file change, only when a router
+that resolves navigation calls is detected, and again after `runPostExtract`.
+When a route is on one side only (`changedRoutes`), the calls that routers'
+`navigation` hooks say it can answer go back to the pending set for the
+orphan sweep: the failed ones, found by their method tails through
+`idx_unresolved_failed_tail`, and the resolved ones, whose `navigates` edges
+are turned back into the references that made them, as the rebind does. A
+call counts when the router's `claimsReference` accepts its whole name and its
+file is in an app whose table holds the route, and a name more such calls
+share than the same 500 ceiling is skipped. The sync also refreshes synthesis.
+A sync that changes no route reads the routes twice and stops there.
+
+Measured by deleting a route (or renaming it), syncing, restoring it and
+syncing again, with both states diffed against a fresh index of the same tree.
+On `main` each of ten scenarios drifted in one of the two states; with the fix
+all twenty match: proshop_mern (`<Route path='/login'>`), next-saas-starter
+(the `/sign-in` and `/pricing` pages), create-t3-turbo (`/`), vue-realworld
+(`/login` in the router config), sveltekit-realworld (`login/+page.svelte`),
+angular-realworld (`login` in `app.routes.ts`), Obytes' Expo starter
+(`app/login.tsx`), Ghostfolio (`home-page.routes.ts`), and bulletproof-react
+with its `/auth/login` path constant renamed and back — the one that drifts
+while the route is renamed rather than after it returns. CleanArchitecture's
+React client, whose routes are a table `App.jsx` maps into `<Route>`, drifted
+when `App.jsx` stopped mapping it and started again: its two
+`navigate('/login')` calls stayed failed, though `AppRoutes.jsx` itself never
+changed. With the fix every step of that replay matches. A sync that changes
+no route spends 0–3 ms on the two reads (proshop's 49 routes, Ghostfolio's
+203); a route change on Ghostfolio spends 12–17 ms putting 40–50 calls back.
+
+Known limits, deliberate: a call bound by name to a method while its route
+was missing (a `redirect` that matched a project method called `redirect`) is
+not revisited, since only `navigates` edges are looked at; a project's own
+wrapper (Expo's `safePush`) is not looked up, since its tail is its own name
+and the failed-tail index cannot find a suffix; and a Vue route whose `name:`
+alone changes changes no route node.
+
 ### `codegraph status` — decided: no drift metric
 
 The issue asked whether `status` should surface divergence. Decision: **no**.
diff --git a/docs/design/ccpp-kernel-port-checklist.md b/docs/design/ccpp-kernel-port-checklist.md
index 3fe0562b31..79201b130a 100644
--- a/docs/design/ccpp-kernel-port-checklist.md
+++ b/docs/design/ccpp-kernel-port-checklist.md
@@ -178,7 +178,7 @@ type_identifier + ≥2 params + NO other lone-identifier param; gtest
 recoverMangledCppName (line 406 — only already-mangled names, `Ret (name)`
 idiom left alone, last token before `(`, primitive/keyword guard);
 stripCppTemplateArgs (line 157 — depth-counted removal of every balanced
-`<…>`); cDeclaratorIdentifier (tree-sitter.ts:234 — declarator chain walk,
+`<…>`); cDeclaratorIdentifier (languages/c-cpp.ts — declarator chain walk,
 function_declarator → null, 12-hop guard).
 
 ## tree-sitter.ts branches (anchors as of `705e501`)
@@ -186,7 +186,9 @@ function_declarator → null, 12-hop guard).
 | Line | Mechanism | Must-mirror details |
 |---|---|---|
 | 962 | cpp namespace prefix stack (#1291) | named `namespace_definition` pushes its name (C++17 `a::b` as written) onto the QN prefix while walking children; anonymous falls through bare |
+| — | cpp brace scopes (erroring trees only) | when the tree has errors, every visitNode takes its namespace prefix from the source's braces, and at declaration level (only class scopes above the file node) its enclosing classes: `languages/cpp-brace-scopes.ts` ↔ `ccpp/brace_scopes.rs`. A class-like node's end is its body's `}`; a class-like `type` of a namespace-level `declaration` is walked as a class. Reachable in the kernel only under `CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT=1` (every other erroring file defers) — kept parity-true there |
 | 2795 | C file-scope variables | only when NO function ancestor; iterate declarators; accept ONLY init_declarator / pointer_declarator / array_declarator — a BARE identifier declarator is a macro-prototype misparse, skip (loses uninit scalars by design); name via cDeclaratorIdentifier; signature `= <first 100 chars>`; kind constant/variable via isConst |
+| — | class-like types defined in declarations | a `declaration` outside any body whose `type` is a class/struct/union/enum specifier WITH a body: visit the type before extracting the variables, in C always and in C++ when the tree has no errors or the file is walked in brace scopes (the row above) — not in an erroring C++ file whose braces don't balance (`walkDeclaredTypes` ↔ `walk_declared_types`); the declaration's fn-ref scan skips the walked type. An unnamed specifier whose parent declaration has it as `type` takes the first declarator's cDeclaratorIdentifier name — in function bodies too (the c/cpp `resolveName` ↔ `extract_name_raw`) — and the declaration's preceding comment is its docstring (`getDeclarationWrapper` ↔ `class_like_docstring`) |
 | 4313 | explicit operator calls (#1247) | callee = `function` field + ERROR-wrapped `operator_name` sibling; compact symbolic spacing (`operator *`→`operator*`, word forms keep space); receiver `->`→`.`; DROP unless receiver is `this` (bare name) or simple identifier/member chain (silent miss over wrong edge) |
 | ~4340 | field_expression method calls | `recv.method`/`ptr->method` → `recv.method`; SKIP_RECEIVERS {self,this,cls,super} → bare name; LITERAL receiver → emit nothing (#1230) |
 | 4398 | call-result receivers (#645/#608) | receiver is call_expression → `<innerCallee>().<method>` re-encode (c AND cpp in the gate list) |
@@ -194,7 +196,7 @@ function_declarator → null, 12-hop guard).
 | 4545 | local fn-ptr call fan-out (#932-adjacent) | bare-identifier callee found in cppLocalFnPtrs[callerId] → emit one `calls` ref PER recorded target, suppress the local name |
 | 5173 | stack construction (#1035) | cpp `declaration` where `type` ∈ {type_identifier, template_type, qualified_identifier} and any init_declarator has `value` ∈ {argument_list, initializer_list} → extractInstantiation |
 | 5183 | fn-ptr binding recording | inside a body: `declaration>init_declarator` (identifier declarator) or `assignment_expression` (identifier left); value must be pointer_expression whose child(0) is `&`; target ∈ {identifier, template_function, qualified_identifier}, template-stripped; per-callerId map of per-local Sets (branch reassignments accumulate) |
-| 5408 | base_class_clause → extends (#1043) | per base: type_identifier / qualified_identifier / template_type, stripCppTemplateArgs'd; access-specifier keywords skipped |
+| 5408 | base_class_clause → extends (#1043) | per base: type_identifier / qualified_identifier / template_type, stripCppTemplateArgs'd; access-specifier keywords skipped. The only c/cpp supertype source: the Go struct-embedding branch (`field_declaration` with no direct `field_identifier`) runs for Go only, so a pointer/array/reference/function member (`Cache* cache_;`) is never an `extends` |
 | 4740 | static member refs — **cpp only** (c not in STATIC_MEMBER_LANGS, line 345) | `Foo::BAR` value reads → `references` edge; VERIFY the MEMBER_ACCESS_TYPES shapes for qualified_identifier + the call-callee skip during the port |
 | — | value-reference edges | **c: YES** (VALUE_REF_LANGS line 401), **cpp: NO**. Port the value-ref machinery for C only (crib go.rs / tsjs — shadow prune, scope stack, MAX_VALUE_REF_NODES cap, CODEGRAPH_VALUE_REFS=0 kill) |
 | — | fn-ref capture (#756) | function-ref.ts:376: `c: cFamilySpec()`, `cpp: cFamilySpec({ addressOfOnly: true })`; note line ~582: `&Cls::m` exemption from the bare-ids-are-free-functions rule — read cFamilySpec fully when porting |
diff --git a/docs/design/codegraph-ui-design-spec.md b/docs/design/codegraph-ui-design-spec.md
index 6ea050dbb3..538b4290be 100644
--- a/docs/design/codegraph-ui-design-spec.md
+++ b/docs/design/codegraph-ui-design-spec.md
@@ -356,7 +356,7 @@ entry-points panel.
 
 **The caveat is part of the screen, not a note on it.** A persistent 11.5px `--ink-3` line sits above the rows, between two
 hairline rules, and never collapses or dismisses: *"No static reference in the index — dynamic use is possible."* Under the list,
-every reason a candidate was left off is printed with its count ("1 677 in test files", "378 exported, or declared in a header",
+every reason a candidate was left off is printed with its count ("1 677 in test files", "378 exported, declared in a header, or merged into a library or global type",
 "40 overriding a member declared further up"), preceded by the scale — *"2 494 symbols in this index carry no incoming reference
 at all; 2 474 of them were left off this list."* Twenty rows drawn from twenty candidates and twenty drawn from two and a half
 thousand are different screens and only that sentence tells them apart.
@@ -379,8 +379,10 @@ modules are not dimmed — a module with one `.pb.go` in it is still one somebod
 
 **What the list refuses to claim** is the whole design. Behind it, `src/graph/dead-code.ts` starts from "no incoming edge
 other than `contains`" and subtracts every candidate there is any reason to believe something reaches: exported symbols and
-header declarations, test and generated files, abstract and interface members, anything carrying a `decorates` edge, overrides
-of an ancestor's member, names the language calls by itself, vendored directories, files nothing in the index reaches (those are
+header declarations, test and generated files, abstract and interface members, anything carrying a decorator (a `decorates`
+edge, or a decorator from outside the index the resolver could not follow), overrides of an ancestor's member, a TypeScript
+hook its framework calls by name on a decorated class that skips the `implements` clause (which names are hooks is read off the
+classes that do write the interface out), names the language calls by itself, vendored directories, files nothing in the index reaches (those are
 islands — the Map's job, not this list's), names the resolver failed to resolve somewhere, names shared with a symbol that IS
 referenced, and — the only rule that reads a file — names written more than once in a file that can reach them.
 
diff --git a/docs/design/csharp-kernel-port-checklist.md b/docs/design/csharp-kernel-port-checklist.md
index 41894cb067..919e767687 100644
--- a/docs/design/csharp-kernel-port-checklist.md
+++ b/docs/design/csharp-kernel-port-checklist.md
@@ -234,8 +234,8 @@ all PRESERVE):
 | `enum_declaration` | enumTypes:1064 → extractEnum:1914 | body `enum_member_declaration_list` required (bodiless → no node); extractInheritance sees `base_list` → **the underlying type `: byte` emits an `extends` ref named `byte`** (quirk, §inheritance); `enum_member_declaration` children → extractEnumMembers:1958 — `name` field path: ONE `enum_member` node per member, positioned at the member node (attributes included in its span), values/attributes ignored; non-member children (preproc_*, comment) → visitNode (no-op) |
 | `method_declaration` | methodTypes:1027 → extractMethod:1737 | classifyMethodNode absent → always extractMethod. Gate 1747 passes via class-like (a method_declaration outside a type does not occur in non-erroring C# — top-level `void M(){}` parses as local_function_statement, probed); bodyless interface/partial signatures mint nodes with no body walk; **expression-bodied methods have `body: arrow_expression_clause` (a real body FIELD, probed) → walked** |
 | `constructor_declaration` | methodTypes → extractMethod | name field = the class-name identifier → **method node named like the class**; returnType undefined; **`constructor_initializer` (`: base(args)` / `: this(args)`) is a sibling of the body field → NEVER walked → calls inside initializer args are LOST** (probed); expression-bodied ctor body = arrow_expression_clause → walked |
-| `property_declaration` (inside class-like) | propertyTypes:1075 → extractProperty:1986 | property node + scanFnRefSubtree (capture-only) + skipChildren → **accessor bodies (`get { … }`, `get => …`) and the `=> expr` value clause are NEVER walked — calls inside property getters/setters/expression bodies emit NOTHING** (only fn-ref candidates). §property below |
-| `field_declaration` (inside class-like) | fieldTypes:1084 → extractField:2046 | field/constant nodes per declarator + scanFnRefSubtree + skipChildren → **field initializers emit no calls/instantiates/static-member refs** (fn-ref candidates only). §field below |
+| `property_declaration` (inside class-like) | propertyTypes:1075 → extractProperty:1986 | property node, then **propertyBodies — each accessor's `body` (`get { … }`, `set => …`), then the `value:` (an expression body's `=> expr` or an `= initializer`) — walked by visitFunctionBody with the property pushed** (calls, instantiates, static reads and fn-ref candidates attribute to the property; accessor/arrow bodies changed 2026-10-04, `= initializer` 2026-10-05 — previously never walked); a target-typed `= new()` value instantiates the declared type (extractTargetTypedNew); then scanFnRefSubtree (capture-only, attributed to the class) over the rest (attributes, type) skipping the walked bodies, + skipChildren. §property below |
+| `field_declaration` (inside class-like) | fieldTypes:1084 → extractField:2046 | field/constant nodes per declarator, **each declarator walked whole by visitFunctionBody with its field pushed** (its `= initializer`: calls, instantiates, static reads, fn-ref candidates incl. varinit attribute to the field; changed 2026-10-05, previously never walked); a target-typed `= new()` instantiates the declared type; then scanFnRefSubtree (capture-only, attributed to the class) skipping the walked declarators, + skipChildren. §field below |
 | `local_declaration_statement` | variableTypes:1098 (only reachable at top level — global statements; body locals go through visitFunctionBody instead) | not class-like → extractVariable:2538 → **generic fallback (2863-2881) finds no direct `identifier`/`variable_declarator` children (the declarator nests inside `variable_declaration`, probed) → ZERO nodes minted**; isClassScopeConstantAssignment (1508) needs node.type `assignment` → never true. skipChildren=true + scanFnRefSubtree → **a top-level `var builder = WebApplication.CreateBuilder(args);` produces NO node, NO calls ref, NO instantiates** — only fn-ref candidates. PRESERVE |
 | `using_directive` | importTypes:1209 → extractImport:3170 | hook (§config) → import node + ONE generic `imports` ref {fromNodeId: nodeStack top (namespace node if present, else file), referenceName: moduleName, line/col of the directive}; **no per-binding emitter** (the TS/py/rust/php/ruby ladder at 3197-3234 excludes csharp) |
 | `invocation_expression` (top level — global statements) | callTypes:1248 → extractCall:3684 | fires with caller = file/namespace node; children still visited (no skipChildren) so nested invocations recurse |
@@ -305,15 +305,35 @@ for C#) or bare `name`. QUIRKS (probed, PRESERVE):
 - An expression-bodied property (`public int Computed => MaxItems + 1;`) has
   children [modifier, predefined_type, identifier, **arrow_expression_clause
   (`value:` field)**] → typeNode = predefined_type → signature `"int Computed"`;
-  the arrow clause is NEVER walked (calls inside lost).
-- `{ get; } = new();` initializers: the `value:` implicit_object_creation and
-  the accessor_list are both skipped/excluded → no refs, no instantiates.
+  the arrow clause is a property body (walked as the property, below).
+- `{ get; } = new();` initializers: the `value:` is the
+  implicit_object_creation_expression itself (no type child) → walked as a
+  body, and extractTargetTypedNew emits `instantiates` named for the
+  declared `type` (below); the accessor_list is excluded from the type scan.
 
 Then extractDecoratorsFor (no-op) and **extractTypeAnnotations (2037) →
 extractCsharpTypeRefs** — the `type` field IS walked for refs (so `public
 List<Foo> Items` emits references `List` + `Foo` even though the signature
-kept the raw text). Return value feeds no body walk (the classifyMethodNode
-initializer-walk path at 1031-1047 is TS-only).
+kept the raw text). The returned node is pushed while propertyBodies
+(tree-sitter.ts; csharp.rs `property_bodies`) are walked: every
+`accessor_declaration`'s `body` field (block or arrow_expression_clause, in
+accessor order), then the property's `value:` whatever it is (an
+arrow_expression_clause or an `= initializer` expression). Each body is
+preceded by **extractTargetTypedNew(body, `type` field)** (csharp.rs
+`extract_target_typed_new`): when the body IS an
+`implicit_object_creation_expression` it emits ONE `instantiates` ref from
+the property at the `new()`'s position, named by csharpClassTypeName
+(csharp.rs `class_type_name`): `identifier` → its text; `generic_name` → its
+identifier (`List<Foo>` → `List`); `qualified_name` / `alias_qualified_name`
+→ recurse into the `name` field (`Ns.Foo<T>` → `Foo`, `global::Foo` →
+`Foo`, `Outer<int>.Inner` → `Inner`); `nullable_type` → recurse into `type`
+(`Foo?` → `Foo`); anything else (predefined/array/tuple/pointer) → nothing.
+Only a `new()` that IS the value counts — `(new())`, `c ? new() : null` and
+nested `new()`s emit nothing. The fn-ref scan that follows skips the walked
+bodies by node id, so a candidate is captured once — from the property; only
+what is left (attribute arguments, e.g. `[Attr(Make(H))]` → `H` from the
+class) is the class's. Attributes are never walked for calls. (The
+classifyMethodNode initializer-walk path at 1031-1047 is TS-only.)
 
 ### extractField (2046) — field_declaration
 
@@ -335,6 +355,23 @@ initializer-walk path at 1031-1047 is TS-only).
   the variable_declaration's `type` field (5905-5909) → **multi-declarator
   fields (`Foo A, B;`) emit the type refs ONCE PER DECLARATOR**, each from its
   own field node.
+- Then, per created field node (changed 2026-10-05 — initializers used to
+  emit nothing but fn-ref candidates, attributed to the class): push the
+  field, **extractTargetTypedNew(the declarator's LAST named child, the
+  variable_declaration's `type` field)** (§property above — a target-typed
+  `private readonly List<Foo> _items = new();` instantiates `List`), then
+  **visitFunctionBody(the whole declarator)**, pop. The C# declarator has no
+  `value` field — the initializer is its last, unnamed child (probed:
+  [name, expression]; a fixed buffer is [name, bracketed_argument_list]) —
+  so the declarator is walked whole, like VB.NET's: maybeCaptureFnRefs fires
+  on it first (varinit: `Del d = Handler;` → candidate `Handler` FROM THE
+  FIELD), then the name (inert) and the initializer — calls, instantiates,
+  static reads (`Defaults.Name` → `Defaults`) and lambda bodies (no halt:
+  `Func<int,int> f = x => Compute(x)` → the field calls `Compute`) attribute
+  to the field. extractField returns the walked declarator ids and the
+  dispatcher's scanFnRefSubtree skips them, so each candidate is captured
+  once, by the field. (Java's walk of its `value` field reports nothing back
+  — its class-level scan still captures those candidates too, unchanged.)
 - docstring/visibility/isStatic computed once from the outer declaration,
   shared by all declarators. The PHP property_element and bare-fallback
   branches (2078-2154) are unreachable for C#.
@@ -418,16 +455,20 @@ statements at top level) AND visitFunctionBody:5145. QUIRKS, PRESERVE:
 **`implicit_object_creation_expression` (`new()`) and
 `anonymous_object_creation_expression` (`new { X = 1 }`) and
 `array_creation_expression` (`new Widget[10]`) are NOT in INSTANTIATION_KINDS
-→ no instantiates refs** (target-typed `new()` — everywhere in modern C# — is
-invisible); object/collection initializer args and `new[] { Mk() }` contents
-still recurse to their own calls. Top-level `var w = new Widget();` emits
-nothing at all (§local_declaration_statement).
+→ no instantiates refs** (a target-typed `new()` in a body — `Widget c =
+new();`, an argument, a return — is invisible); the one exception is a
+`new()` that IS a field's or property's initializer, which
+extractTargetTypedNew names for the declared type (§property, §field).
+Object/collection initializer args and `new[] { Mk() }` contents still
+recurse to their own calls. Top-level `var w = new Widget();` emits nothing
+at all (§local_declaration_statement).
 
 ### extractStaticMemberRef (4750) — csharp ∈ STATIC_MEMBER_LANGS (345)
 
 Called for EVERY node in visitFunctionBody (5218) — body walker only (never
-visitNode, so class-level field initializers and top-level statements emit no
-static refs). Node gate: MEMBER_ACCESS_TYPES (323) contains
+visitNode, so top-level statements emit no static refs; field and property
+initializers ARE body-walked, so `= Defaults.Name` reads attribute to the
+member). Node gate: MEMBER_ACCESS_TYPES (323) contains
 `member_access_expression`. Skip when the access IS a call's callee (4772-4779:
 parent ∈ callTypes && callee.startIndex === node.startIndex — so
 `Console.WriteLine(…)`'s access is skipped but `DoThing(Constants.MAX)`'s
@@ -614,14 +655,17 @@ layers: `argument`→null (descend named children). special:
   nothing (not idTypes/special).
 - Capture fires from visitNode:990, visitFunctionBody:5137, and
   scanFnRefSubtree (property/field/variable declarations + top-level
-  statements, depth ≤12, capture-only). **scanFnRefSubtree's halt list
-  (tree-sitter.ts:606-612) includes the literal type `lambda_expression` —
-  which IS C#'s lambda node** — so at depth>0 the scan STOPS at a lambda in a
-  field/property initializer (`Action A = () => Register(H);` yields no
-  candidates from inside the lambda), while `anonymous_method_expression`
-  (`delegate() { … }`) is NOT in the list and is scanned through. Method-BODY
-  lambdas are unaffected (visitFunctionBody recursion has no halt — capture
-  fires per node).
+  statements, depth ≤12, capture-only — skipping the subtrees the body
+  walker already went through: property bodies/initializers and field
+  declarators, whose candidates are the member's). **scanFnRefSubtree's halt
+  list (tree-sitter.ts:606-612) includes the literal type `lambda_expression`
+  — which IS C#'s lambda node** — so at depth>0 the scan STOPS at a lambda it
+  reaches (a top-level statement's), while `anonymous_method_expression`
+  (`delegate() { … }`) is NOT in the list and is scanned through. Body-walked
+  lambdas — methods, accessors, and since 2026-10-05 field/property
+  initializers (`Action A = () => Register(H);` → candidate `H` from `A`) —
+  are unaffected (visitFunctionBody recursion has no halt — capture fires per
+  node).
 - Flush gate (flushFnRefCandidates:639): generated-file skip; `this.`-prefixed
   names skip the gate (C# never produces them — its this-forms are bare);
   otherwise name ∈ definedHere ∪ importedNames. **definedHere = same-file
@@ -755,10 +799,15 @@ AspNetCore refs / Program.cs / Startup.cs / controller-source scan.
   `struct Fwd;` (NO node); interface with bodyless method + property +
   default-impl arrow method; enum with `: byte` (extends `byte` quirk),
   attributed member, valued members; const + static-readonly (→ `constant`)
-  + multi-declarator + instance fields (signatures `Type name`);
+  + multi-declarator + instance fields (signatures `Type name`), field
+  initializers (→ the field: `= new() { TargetCb }` instantiates the declared
+  `List` and the list candidate is the field's);
   `protected internal` (→ protected); property shapes: predefined-type,
   bare-identifier type (signature loses type), generic type, expression-bodied
-  (`=>` calls LOST), `{ get; } = new();`, accessor bodies with calls (LOST);
+  (`=>` calls → the property), `{ get; } = new();` (→ the property,
+  instantiates the declared `Widget`), `{ get; } = () => Register(H)` (the
+  lambda's call and candidate → the property),
+  accessor bodies with calls (→ the property);
   event_field_declaration + event_declaration with add/remove bodies (no
   nodes; accessor calls → class); operator + conversion operator + indexer +
   destructor (no nodes; body calls → class); constructor with
@@ -771,7 +820,7 @@ AspNetCore refs / Program.cs / Startup.cs / controller-source scan.
   `Foo.Create(1).Bar()` (re-encode + inner both) + `GetThing().Bar()`,
   `(myDel)(x)` (conv regex → `myDel`), `nameof(Widget)` (calls ref `nameof`);
   `new Widget(…) { … }` (instantiates + initializer calls) + `new Ns.Foo<T>()`
-  (strip both) + `new()` / `new { }` / `new Widget[10]` (all NOTHING);
+  (strip both) + body `new()` / `new { }` / `new Widget[10]` (all NOTHING);
   static value reads (`ReadType.ReadAsDouble` → `ReadType`; `Outer.Inner.DEEP`
   → `Outer`; skip-as-callee; lowercase skip); type refs: params
   (nullable/array/tuple-element/generic/qualified/`dynamic`), returns
@@ -784,7 +833,8 @@ AspNetCore refs / Program.cs / Startup.cs / controller-source scan.
   function + trailing `partial class Program`; fn-refs: `Register(HandleThing)`,
   `Register(this.HandleThing)` (bare name), `Register(C.StaticHandler)`
   (nothing), `Click += OnClick`, initializer_expression list, varinit
-  (`Action g = () => …` no candidate; `Del d = Handler;` candidate),
+  (`Action g = () => …` no candidate; `Del d = Handler;` candidate — from
+  the method for a local, from the field for a field initializer),
   `this.x = x` param-storage skip; value-refs: const target + reader methods +
   a `var MaxItems = …` local shadow (prune) + `static readonly` multi-target;
   preprocessor: `#region`/`#endregion`/`#pragma`/`#nullable`/`#define`
diff --git a/docs/design/dart-kernel-port-checklist.md b/docs/design/dart-kernel-port-checklist.md
index d354281eb9..0386b419a2 100644
--- a/docs/design/dart-kernel-port-checklist.md
+++ b/docs/design/dart-kernel-port-checklist.md
@@ -190,10 +190,12 @@ change dart's grammar, which is exactly the hazard this vendor kills.
 
 Types: functionTypes=[`function_signature`] (:119); classTypes=
 [`class_definition`] (:120); methodTypes=[`method_signature`,
-`constructor_signature`] (:126); interfaceTypes=[] ; structTypes=[];
+`constructor_signature`, `constant_constructor_signature`,
+`redirecting_factory_constructor_signature`] (:126 — the last two since
+2026-10-06); interfaceTypes=[] ; structTypes=[];
 enumTypes=[`enum_declaration`] (:129); enumMemberTypes=[`enum_constant`]
-(:130); typeAliasTypes=[`type_alias`] (:131); importTypes=[`import_or_export`]
-(:132); **callTypes=[] (:133 — extractCall NEVER runs for dart; all call refs
+(:130); typeAliasTypes=[`type_alias`] (:131); importTypes=[`import_or_export`,
+`part_directive`] (:132 — the second since 2026-10-06); **callTypes=[] (:133 — extractCall NEVER runs for dart; all call refs
 ride `extractBareCall` in the body walker)**; variableTypes=[] (:134 —
 extractVariable never runs); extraClassNodeTypes=[`mixin_declaration`,
 `extension_declaration`] (:135). nameField=`name` (:172), bodyField=`body`
@@ -237,9 +239,18 @@ Grammar-shape facts the config leans on (all probed, `mini-cst.txt` /
   initializers]`) — reached by the walker via plain recursion into
   `declaration`. `const` constructors are `declaration >
   constant_constructor_signature` and redirecting factories are
-  `declaration > redirecting_factory_constructor_signature` — **NEITHER is
-  in methodTypes → const ctors and `const factory X.r() = Impl;` are
-  INVISIBLE (no node, no refs)**. Fields are `declaration >
+  `declaration > redirecting_factory_constructor_signature` — both carry
+  NO fields (children: `const_builtin`? `"factory"`? identifier [`.`
+  identifier] formal_parameter_list, then for a redirect `=` and the
+  target: `type_identifier` [type_arguments] [`.` name], where the target
+  constructor's name is a `type_identifier` without type arguments and an
+  `identifier` after them). Until 2026-10-06 neither was in methodTypes
+  (no node, no refs); now both mint methods exactly like the bare
+  `constructor_signature` (§isMisparsedFunction, §resolveName). Abstract and
+  `external` members are `declaration > function_signature` too (an anon
+  `external`/`static` keyword may precede the signature). In every one of
+  these the member's dartdoc and annotations are siblings of the
+  `declaration`, not of the signature — §getDeclarationWrapper. Fields are `declaration >
   (static)? (final|const|type|var) > initialized_identifier_list |
   static_final_declaration_list` (§Constants).
 - **Statements/expressions:** calls have NO call node — a postfix chain is
@@ -269,12 +280,31 @@ Hooks PRESENT (port each exactly — anchors into languages/dart.ts):
   expression node); initValue = its text `.slice(0,100)` (UTF-16);
   `ctx.createNode('constant', name, node, { signature: initValue ? \`=
   ${initValue}${initValue.length >= 100 ? '...' : ''}\` : undefined })`.
-  Return **true** (consumed — even when nameNode missing? NO: name found is
-  required for createNode but the hook returns true for EVERY
+  When the constant is minted, the hook pushes it and walks the WHOLE
+  declaration with the body walker (`ctx.walkInitializer(node)` —
+  visitFunctionBody that records the node as walked), then pops: the
+  initializer's calls, instantiations, static and member reads, types,
+  closures (block bodies and local functions included) and fn-ref
+  candidates (the `varinit` capture of the declaration itself included) are
+  the CONSTANT's. Return **true** (consumed — even when nameNode missing? NO:
+  name found is required for createNode but the hook returns true for EVERY
   static_final_declaration reached, node minted or not — transcribe the
-  early-return shape exactly: `if (nameNode) {…}; return true`). The
-  dispatcher then runs `scanFnRefSubtree(node, 0)` and never descends →
-  §Function-as-value for what still gets captured. Everything else → false.
+  early-return shape exactly: `if (nameNode) {…; if (constant) walk}; return
+  true`). The dispatcher then runs `scanFnRefSubtree(node, 0, walked)` —
+  which skips a walked declaration outright, so only an unminted one is
+  scanned — and never descends.
+- **visitNode — the field / top-level variable branch.** `node.type ===
+  'initialized_identifier'` whose parent is an `initialized_identifier_list`
+  directly under `program`, or under a `declaration` in a
+  class_body/extension_body/enum_body → `ctx.walkInitializer(node)` with no
+  push (the stack top is the file or the class/enum), return **true**. These
+  declarations mint no node, so their initializers are the FILE's or the
+  CLASS's. An `initialized_identifier` anywhere else — the second variable of
+  a local `for (var i = 0, j = n(); …)`, under `initialized_variable_definition`
+  — is left to its function's body walk (the double-walk's pass 2a reaches it
+  too, so the parent check is load-bearing). The `declaration` and `program`
+  type rows push only the DECLARED type's refs; initializer types come from
+  the walk. Everything else → false.
   **Reality of the node type (probed, `probe2-cst.txt`):**
   `static_final_declaration` = a `final`/`const` declaration WITH an
   initializer that is **top-level** (`const SHARED_MAX = 10;`, `final
@@ -301,6 +331,16 @@ Hooks PRESENT (port each exactly — anchors into languages/dart.ts):
   **LIVE and load-bearing for dart**: the comment there names Dart; a
   method/function node's endLine extends to the sibling body's end, e.g.
   `named` L123-125 spans its body).
+- **getDeclarationWrapper** — node's parent is a `declaration` AND node is
+  that declaration's FIRST named child (`firstNamedChild.equals(node)`;
+  kernel `named_child(0) == node` — an anon `external`/`static` keyword
+  before the signature doesn't count) → the `declaration`, else undefined.
+  Read by tree-sitter.ts's `docstringFor` (every docstring lookup, so the
+  kernel's `docstring_of` wraps all five `preceding_docstring` calls) and
+  by extractDecoratorsFor's scan #2 (§Decorators); scan #1 and
+  `getBodyDocstring` keep the node itself. Only Dart defines it — never add
+  `declaration` to DOCSTRING_WRAPPER_TYPES / docstring.rs `is_wrapper`,
+  which C/C++ (whose `declaration` wraps declarators) share.
 - **getReturnType = extractDartReturnType (:80-92)** — ctor = dartCtorInfo
   (§below): a validated ctor returns the CLASS name (named ctors, factories
   → ret = enclosing class). Else sig = dartInnerSignature (:9 —
@@ -330,7 +370,12 @@ Hooks PRESENT (port each exactly — anchors into languages/dart.ts):
   extension_declaration/enum_declaration and reads ITS name field) and
   `reduce` ≠ `Action` → treated as the method it is (pinned:
   `extract-probe4.txt` — method `reduce`, position starting AT `reduce`,
-  sig/ret undefined, decorates override intact).
+  sig/ret undefined, decorates override intact). dartCtorInfo reads only the
+  identifiers BEFORE the formal_parameter_list, so a redirecting factory's
+  target (`factory Foo() = _Impl.named;`) never names it. A
+  `constant_constructor_signature` / `redirecting_factory_constructor_signature`
+  that dartCtorInfo rejects (names no enclosing type — error recovery) is
+  skipped too: it can be nothing else.
 - **getSignature (:189-208)** — method_signature unwraps to
   function/getter/setter signature (NOT ctor/factory/operator); params =
   find namedChild `formal_parameter_list`; retType = find namedChild
@@ -346,7 +391,9 @@ Hooks PRESENT (port each exactly — anchors into languages/dart.ts):
   formal_parameter_list on method_signature); **bodiless named ctor
   (declaration > constructor_signature) → `"()"`-style params-only sig**
   (node IS the ctor signature; its formal_parameter_list is found by type) —
-  pin BOTH ctor sig shapes; operators → undefined.
+  pin BOTH ctor sig shapes; operators → undefined. `const` ctors and
+  redirecting factories → params only too: no retType is looked up for them
+  (a redirect's `= _Impl` type_identifier is its target, not a return type).
 - **getVisibility (:209-222)** — method_signature → unwrap to
   function/getter/setter signature → its first `identifier` child; other
   nodes → childForFieldName('name'). Name starts `_` → 'private', else
@@ -367,26 +414,32 @@ Hooks PRESENT (port each exactly — anchors into languages/dart.ts):
   children for type `'static'` → true; else false. `static WidgetT make()`
   → true ✓ (the `static` keyword is an anon child of method_signature);
   bare constructor_signature → false. Top-level functions → false.
-- **resolveName (:244-260)** — dartCtorInfo: named ctor/factory → the ctor
-  name (`named`, `create`, `_`); unnamed ctor or non-ctor → undefined (falls
-  to extractName §below).
+- **resolveName (:244-260)** — dartCtorInfo: named ctor/factory (`const`
+  and redirecting ones included) → the ctor name (`named`, `create`, `_`);
+  unnamed ctor or non-ctor → undefined (falls to extractName §below).
 - **extractImport (:261-304)** — importText = trimmed full node slice;
   moduleName = the URI string content: `library_import >
   import_specification > configurable_uri > uri > string_literal` (else the
-  same chain under `library_export`), quotes stripped via
-  `.replace(/['"]/g,'')`. Returns {moduleName, signature} (no handledRefs)
+  same chain under `library_export`; a `part_directive` holds its `uri`
+  directly), quotes stripped via `.replace(/['"]/g,'')` (dartUriText).
+  Returns {moduleName, signature} (no handledRefs)
   → import NODE (name = the URI, e.g. `package:torture/other.dart`,
-  `dart:async`, `src/reexported.dart`) + the generic `imports` ref
+  `dart:async`, `src/reexported.dart`, `x.g.dart`) + the generic `imports` ref
   (tree-sitter.ts:3183-3194) {from: file node (no namespace exists), name =
-  URI, line/col of the import_or_export node}. `as alias`, `show`/`hide`
+  URI, line/col of the directive node — at its first annotation when it has
+  one}. `as alias`, `show`/`hide`
   combinators: IGNORED (not read). **`import 'x.dart' deferred as y;` is
   INVISIBLE** — the deferred form's import_specification holds a bare `uri`
   (NO configurable_uri wrapper) → hook returns null → falls through the
   multi-import inline handlers (none match import_or_export) → no node, no
-  ref (pinned, `extract-mini.txt`). `part`/`part of`/`library` directives
-  are different node types (part_directive, part_of_directive, library_name)
-  in NO type list → invisible. None of the TS/py/rust/php/ruby binding
-  emitters (:3197-3234) fire for dart.
+  ref (pinned, `extract-mini.txt`). **`part 'x.g.dart';` is an import since
+  2026-10-06** (signature `part 'x.g.dart';`): the resolver reads its URI by
+  the import/export rules (`dartDirectiveFile`), so the library's file links
+  the part's file and a change to the part reaches the library's dependents.
+  `part of` and `library` (part_of_directive, library_name) are in NO type
+  list → invisible: the library's `part` edge already joins the two files.
+  None of the TS/py/rust/php/ruby binding emitters (:3197-3234) fire for
+  dart.
 - **extractBareCall (:305-379)** — §Calls, the full matrix.
 
 Hooks ABSENT (the walker must NOT do these): `preParse`, `recoverMangledName`,
@@ -412,7 +465,7 @@ Registration: `EXTRACTORS.dart` (languages/index.ts:56), `FN_REF_SPECS.dart`
 
 | Node | Branch | Behavior |
 |---|---|---|
-| every node | visitNode hook first (:943) | `static_final_declaration` consumed (§Constants); handled → scanFnRefSubtree + STOP |
+| every node | visitNode hook first (:943) | `static_final_declaration` consumed and body-walked for its constant; a field's or top-level variable's `initialized_identifier` consumed and body-walked for the class/file (§Constants); handled → scanFnRefSubtree (skipping what was walked) + STOP |
 | every node | maybeCaptureFnRefs (:990) | fires for `arguments`/`assignment_expression`/`pair`/`list_literal`/`static_final_declaration` in visitNode context — the source of the file/class-attributed fn-ref twins (§double-walk) |
 | `function_signature` | functionTypes:994 | methodTypes does NOT include it → **always extractFunction:1517**, even inside a class (isInsideClassLike && !methodTypes.includes → else-arm). In-class function_signatures occur only for ABSTRACT/bodiless methods, reached via their `declaration` wrapper (`declaration > function_signature`, probed) → **kind `function` contained by the class** (pinned: `AbstractT::mustImpl` is a function; the sibling `declaration > getter_signature` abstract getter stays invisible). skipChildren |
 | `class_definition` | classTypes:1005 | no classifyClassNode → always extractClass:1679 (abstract/sealed/base/etc. included) |
@@ -420,12 +473,12 @@ Registration: `EXTRACTORS.dart` (languages/index.ts:56), `FN_REF_SPECS.dart`
 | `method_signature`, `constructor_signature` | methodTypes:1027 | **NOT class-gated at the ladder** — extractMethod:1737 runs anywhere; its own gate :1747 (not class-like, no methodsAreTopLevel, no receiver) falls back: parent `object`/`object_expression`? (never in dart) else **extractFunction** — this is how extension-TYPE members and any stray non-class method_signature become plain `function` nodes (pinned: `extension type MetersT` → function `km`, bare QN) |
 | `enum_declaration` | enumTypes:1064 → extractEnum:1914 | §Class family |
 | `type_alias` | typeAliasTypes:1071 → extractTypeAlias:2890 | plain type_alias node; `getChildByField(node,'value')` → **null** (no fields) → **NO refs from the aliased type** (`typedef MapAlias = Map<String, WidgetT>` emits nothing); returns false → children re-visited (function_type/formal_parameter_list children match nothing) |
-| `import_or_export` | importTypes:1209 → extractImport:3170 | §Extractor config |
+| `import_or_export`, `part_directive` | importTypes:1209 → extractImport:3170 | §Extractor config. No skipChildren: the directive's children are still recursed, so an annotated directive's arguments are fn-ref capture points (`@Tag(f) import 'a.dart';` captures `f`). The kernel arm recurses too — since 2026-10-06; before, its `import_or_export` arm returned and missed those (TortureDirectives.dart pins both) |
 | `new_expression` | INSTANTIATION_KINDS:1255 (`new_expression` ∈ :354-361) | extractInstantiation:4610 → ctor field lookups null → namedChild(0) = type_identifier → `instantiates` ref from stack top; `<`-strip + last-`.`-segment apply (`new p.Foo<T>()` → `Foo`). findAnonymousClassBody → always null for dart. Children still recursed |
 | `function_body` (sibling of a consumed signature) | **no branch** | recursed → THE DOUBLE-WALK (§below) |
-| `declaration` (fields, bodiless ctors) | no branch | recursed → constructor_signature hits methodTypes; initialized_identifier/list, constant_constructor_signature, redirecting_factory_constructor_signature, initializers, annotations-in-place: nothing |
+| `declaration` (fields, bodiless ctors) | no branch | recursed → constructor_signature, constant_constructor_signature and redirecting_factory_constructor_signature hit methodTypes; each field `initialized_identifier` hits the hook (body-walked for the class); initializers, annotations-in-place: nothing |
 | `getter_signature` / `setter_signature` BARE (top level) | no branch | **top-level getters/setters are INVISIBLE** (no node; their sibling function_body is visitNode-recursed where calls don't extract) — in classes they're method_signature-wrapped → methods |
-| `const_object_expression`, `selector`, `cascade_section`, `assignment_expression`, `local_variable_declaration`, patterns, `extension_type_declaration`, `part_directive`, `library_name`, lambdas | no branch | recursed; calls only extract in the BODY walker (`extractBareCall` is not consulted by visitNode!) — §Calls for the consequences |
+| `const_object_expression`, `selector`, `cascade_section`, `assignment_expression`, `local_variable_declaration`, patterns, `extension_type_declaration`, `part_of_directive`, `library_name`, lambdas | no branch | recursed; calls only extract in the BODY walker (`extractBareCall` is not consulted by visitNode!) — §Calls for the consequences |
 | `property_signature`/`method_signature` TS branch (:1282) | **shadowed** | method_signature is consumed at :1027 first; property_signature isn't a dart kind — branch unreachable |
 
 ### THE DOUBLE-WALK (sibling bodies) — reproduce it exactly
@@ -624,15 +677,22 @@ chain → FIRST value child only); `static final sharedInst = WidgetT(0)` →
 constant under the class, sig `= WidgetT`; multi-declarations → one node
 each with own columns. **NO nodes ever**: instance fields (typed/untyped/
 late/var), `static var`, top-level var/typed vars, top-level getters/
-setters, const constructors, redirecting factories, extension_type
-containers, `part`/`part of`/`library`/deferred imports. **Initializer
-side-effects:** hook-consumed constants' initializers are NOT walked → no
-calls/instantiates from them (only scanFnRefSubtree capture — §fn-refs);
-initialized_identifier fields' initializers ARE recursed by visitNode but
-only INSTANTIATION_KINDS fires there → `int counter = 0;` emits nothing,
-but a field `final w = new Widget();` would emit `instantiates Widget` from
-the CLASS (and a top-level `var w = new Widget();` from the FILE). No
-static-member refs from any of these contexts (body-walker only).
+setters, extension_type containers, `part of`/`library`/deferred
+imports. (Named `const` constructors and redirecting factories mint
+methods since 2026-10-06, and a `part` directive an import; the unnamed
+constructors still mint nothing.) **Initializers
+are code:** every initializer is walked with the body walker — a
+constant's for the constant (riverpod's `final repoProvider =
+Provider((ref) => Repository(ref.watch(dioProvider)));` → calls
+`Provider`, `Repository`, `ref.watch` from `repoProvider`), a field's
+(instance, `static var`, typed, `late`) for its class, a top-level
+`var`/typed/`late final` one for the FILE. The full body matrix applies:
+calls, instantiates, static-member and member reads, type refs, closures
+with block bodies (a local function inside one mints a `function` under
+the constant, with the double-walk's pass 2b on its body), interpolation
+calls, fn-ref candidates. Each is walked ONCE: the hook consumes the entry,
+so the visitNode recursion that used to reach `new_expression` /
+maybeCaptureFnRefs inside a field initializer no longer does.
 
 ### Calls — extractBareCall (dart.ts:305-379) in the body walker (:5159-5173)
 
@@ -658,24 +718,86 @@ extract-mini.txt):
 | `w?.render()` | conditional_assignable_selector | `w.render` — **`?.` is encoded exactly like `.`** |
 | `y2..add(1)..add(2)` (cascades) | cascade_section (argument_part NOT inside a selector) | **NOTHING — cascade calls are completely invisible** |
 | `new WidgetT(2)` | new_expression → INSTANTIATION branch :5145 FIRST | `instantiates WidgetT` (extractBareCall's new_expression arm :363-367 is DEAD — the else-if never reaches it); args still recursed |
-| `pad(const EdgeInsetsT.all(8.0))` | const_object_expression :369-376 | `EdgeInsetsT.all` at the CONST node position (typeId + '.' + nameId; type-only form → `EdgeInsetsT`); children recursed after |
+| `pad(const EdgeInsetsT.all(8.0))` | const_object_expression :369-376 | `EdgeInsetsT.all` at the CONST node position (typeId + '.' + nameId; type-only form → `EdgeInsetsT`); children recursed after. The FIRST type_identifier: `const p.X.named()` → `p.named` (prefix bug, preserved) |
+| `BlocProviderT<CounterT>.value(…);` as a statement | args selector; prev = `.value` selector; accessorPrev = a selector holding only `type_arguments`, whose prev is the identifier | `BlocProviderT.value` (dartTypeArgumentsReceiver, since 2026-10-06 — bare `value` before); the `.value().tail` re-encode reads it the same way |
+| `=> BlocProviderT<CounterT>.value(…)`, and as an initializer, argument or `return` value | `constructor_invocation` (type_identifier [`.` type_identifier] type_arguments `.` identifier arguments) | `BlocProviderT.value` at the node position — the LAST type_identifier, so `p.X<T>.named()` → `X.named` (since 2026-10-06; nothing before) |
 | `generic<int>(5)` | args selector (type args ride argument_part) | bare `generic` |
+| `ref.read<Repo>(p)`, `Provider<int>((ref) => 0)`, `X<T>(name: v)` parsed as two comparisons, `(ref.read < Repo) > (p)` (§Misparsed generic calls) | the `<` relational_operator (dartMisparsedGenericCall) | the parsed call's ref — `ref.read` / `Provider` / `X`, at the `<` |
 | `await fetch()` | recursion through unary/await_expression | `fetch` at the selector |
 | `throw StateError('bad')` | recursion | `StateError` |
 | `'sum ${a + compute()}'` | template_substitution recursion | `compute` (interpolation calls EMIT); `$name` → identifier_dollar_escaped → nothing |
 | local-lambda body `final lam = (int a) { helper(a); }` | function_expression recursed transparently | `helper` attributed to the ENCLOSING function; `lam(5)` → `lam` |
-| ctor initializers (`: size = seed()`), enum-constant args (`ok(200)`), default param values, hook-consumed constant initializers | never body-walked | NOTHING |
+| `final p = Provider((ref) => Repo(ref.watch(d)))`, `static var s = make()`, `final _c = Controller();` in a class, `var v = load();` | the hook's walkInitializer (§Constants) | the full matrix, from the constant / the class / the file |
+| ctor initializers (`: size = seed()`), enum-constant args (`ok(200)`), default param values | never body-walked | NOTHING |
+| `tester //` + newline + `.state(x)`, `box.grow /* by */ (3)` | comments are named SIBLINGS between the chain's parts | `tester.state` / `box.grow` — every sibling step skips `comment` and `documentation_comment` (dartPrevNamed / dartNextNamed; kernel `prev_named` / `next_named`), so a comment changes nothing |
+
+Every sibling step along a member chain goes past comments: the callee before
+an argument part, dartReceiverOf / receiver_of, dartCalleeOfArgPart's two,
+dartTypeArgumentsReceiver's type, and dartMemberRead's receiver and its
+next-selector check. tree-sitter-dart keeps a comment as a named node wherever
+it is written, so before (2026-10-06) a comment between a member and its
+arguments lost the call and emitted a member read, a getter read or static
+access after a comment (`Config //`, dart format's line-break idiom) was lost,
+and a call after one kept only its bare name. The misparsed-generic-call
+layout checks below still read the raw siblings: a comment there means the
+code is not laid out as a call.
 
 extractCall (:3684), LITERAL_RECEIVER_TYPES (:373-388), SKIP_RECEIVERS, the
 parenthesized-conversion regex (:4530), template-strip — ALL UNREACHABLE for
 dart (callTypes empty). Do not port them.
 
+#### Misparsed generic calls (dartMisparsedGenericCall / misparsed_generic_call)
+
+tree-sitter-dart parses a generic call with arguments as two comparisons about
+as often as it parses it as a call — the GLR tie goes either way with the code
+around it: `final a = ref.watch<int>(p);`, `ref.read<Repo>(p);`, `int g(Ref
+ref) => ref.read<int>(1);` and `Provider<int>((ref) => 0)` come out as
+`relational_expression(relational_expression(<callee> < <type>) > <args>)`,
+while `print(ref.watch<int>(p) + 1)`, `obj.a.b<Repo>(p)` and
+`ref.read<Repo>(a, b)` parse as calls (2,853 nests vs 2,836 parsed generic
+calls with arguments across bloc, riverpod and flutter/samples). The args are
+a `parenthesized_expression`, or a `record_literal` when named
+(`DropdownButton<String>(items: …)`); the type part is `identifier`, a `.Name`
+selector (`p.Repo`) and/or a type_arguments-only selector (`Map<K, V>`); the
+callee part sits under `unary_expression` / `await_expression` for `await` and
+prefix operators. Recovered at the `<` when the type names a type (`/^[_$]*[A-Z]/`
+or `int double num bool dynamic void`), `<` touches the callee and `(` touches
+the `>`; `a < B > (c)`, `a<b>(c)` and `a <B>(c)` stay comparisons, and so does
+`a.b /* c */<B>(c)`: the comment is a sibling of its own against the `<`, so
+it is rejected as the callee (else the gate passed with no call, and the
+comment-skipping member read was suppressed). The
+recovered form emits what the parsed call does:
+
+- `calls` at the `<` (the parsed call's argument_part starts there);
+- `references <Type>` for the type argument, via isDartTypeName (§Type refs);
+  the static-member path skips `Map` in `<Map<K, V>>` so it is not doubled;
+- no member read of the callee (`ref.read`, also under `await`) or of a
+  prefixed type (`p.Repo`).
+
+A call chained on a recovered one keeps its bare name (`increment` in
+`BlocProvider.of<CounterCubit>(context).increment()`), unlike the parsed
+chain's `BlocProvider.of().increment`. The resolver gives both the same
+method: a bare link is typed from the chain written before it, and so is an
+encoded chain whose inner call declares no type of its own to return — a
+generic factory's type parameter (`static T of<T>`) or a factory outside the
+project (#750). Nothing is gained by re-encoding the recovered chain.
+
+The grammar can also end an arrow function in front of a generic call:
+`(ref) => ref.watch<int>(p)` → `((ref) => ref).watch<int>(p)`, in the
+relational and the selector form alike. dartReceiverOf / receiver_of read a
+receiver in that place from the end of the arrow's body (Dart writes a member
+access on an arrow itself in parentheses), for callee names and static-member
+refs: `ref.watch`, `BlocProvider.of`. dartCalleeOfArgPart / callee_of_arg_part
+do not, so `() => BlocProvider.of<CounterCubit>(context).increment()` keeps
+`increment` bare, which resolves as above.
+
 ### Static-member / value-read refs — dart branch (:4759-4767), STATIC_MEMBER_LANGS:346
 
 Called from the body walker only (:5218). The DART-SPECIFIC branch (the
 shared MEMBER_ACCESS_TYPES path is never reached — it returns first):
-node.type === `selector` AND it has NO `argument_part` child AND
-previousNamedSibling is an `identifier` matching `/^[A-Z][A-Za-z0-9_]*$/` →
+node.type === `selector` AND it has NO `argument_part` child AND the
+receiver (dartReceiverOf: the previous named sibling past comments) is an
+`identifier` matching `/^[A-Z][A-Za-z0-9_]*$/` →
 `references <identifier text>` from the enclosing symbol at the
 **IDENTIFIER's (receiver's) position** (pushStaticMemberRef :4800). Pins:
 
@@ -690,7 +812,8 @@ previousNamedSibling is an `identifier` matching `/^[A-Z][A-Za-z0-9_]*$/` →
 - `this.x` → prev is a `this` node → nothing. Case patterns (`case
   ColorT.blue:`) → `constant_pattern > qualified` shape, no selector →
   NOTHING (pinned gap). Cascade sections → no selector → nothing.
-  Class-field/constant initializers and visitNode contexts → never called.
+  visitNode contexts → never called; initializers are body-walked, so a
+  read written in one emits from its constant / class / file.
 
 ### Type-annotation references — dart ∈ TYPE_ANNOTATION_LANGUAGES (:5753), the dart branch (:5819-5833) is LIVE
 
@@ -720,7 +843,12 @@ BUILTIN_TYPES (:5768-5782), at each leaf's position. Consequences (pinned):
   = constructor_signature → param types emit (`Widget.named(WidgetT w)` →
   references WidgetT); `this.`-params (constructor_param) hold no
   type_identifier → nothing. Bodiless declaration-wrapped ctors: extractMethod
-  runs on the bare constructor_signature → sig = node → same.
+  runs on the bare constructor_signature → sig = node → same; so do `const`
+  ctors. A redirecting factory walks its named children one by one and
+  skips a DIRECT type_identifier that is not UpperCamel (`/^[_$]*[A-Z]/`):
+  after `=` those are an import prefix (`= p.Impl`) or the target
+  constructor's name (`= _$QuestionImpl.fromJson`, where `fromJson` is a
+  type_identifier) — `references _$QuestionImpl` only.
 - Getters: references from the getter's TYPE (suppressed if builtin —
   `int get area` → nothing; `WidgetT get w` → references WidgetT).
 - extractVariableTypeAnnotation (:6074) needs a `type_annotation` child —
@@ -734,35 +862,116 @@ BUILTIN_TYPES (:5768-5782), at each leaf's position. Consequences (pinned):
 Dart annotations are `annotation` (with `name:` field; args form has an
 `arguments` child) or `marker_annotation`-free — probed: both `@override`
 (bare) and `@Deprecated('x')` (args) are node type `annotation`, PRECEDING
-SIBLINGS of the declaration they decorate (inside program / class_body).
+SIBLINGS of the function or method they decorate (inside program /
+class_body); a class-like declaration's annotations open its own node
+instead (scan #1).
 extractDecoratorsFor (:4897) is called for classes (:1710), functions
 (:1599), methods (:1819) — NOT for hook-minted constants, enums(!), or
 type aliases (extractEnum/extractTypeAlias never call it — an annotated
 enum emits nothing). Mechanics for dart:
 
 - Scan #1 (direct children :4976-4988): annotations are never children of
-  the signature → inert (no `modifiers` node either).
+  the signature → inert for functions and methods (no `modifiers` node
+  either). A class-like declaration is different: class, mixin, extension
+  and extension type nodes START at their first annotation, which is the
+  node's own leading child, so scan #1 emits it (`@immutable class Foo` →
+  decorates `immutable`). Enums and typedefs are built the same way, but
+  nothing scans them.
 - Scan #2 (preceding siblings :5002-5023): walk BACKWARD from the
-  declaration; `annotation` is in the accepted set (:5017); stop at the
-  first non-annotation sibling. consider(): target = first namedChild of
-  accepted types → the `identifier` (`override`, `deprecated`, `pragma`,
-  `immutable`, `Deprecated`) → `<`-strip + last-`.`-segment (`@ui.Widget`
-  style would strip to `Widget`) → **`decorates` ref {from the decorated
-  node, name, line/col of the ANNOTATION node}**. With-args annotations
+  declaration; `annotation` is in the accepted set (:5017); step over
+  `comment` / `documentation_comment` siblings (since 2026-10-06, below);
+  stop at the first other non-annotation sibling. consider(): target =
+  first namedChild of accepted types → the `identifier` (`override`,
+  `deprecated`, `pragma`, `immutable`, `Deprecated`) or `scoped_identifier`
+  (`meta.immutable`, `Foo.named`, `p.Foo.named`) → `<`-strip + last-`.`-segment
+  (`@meta.immutable` → `immutable`, `@p.Foo.named(…)` → `named`; the strip
+  runs first, so `@Foo<int>.named(…)`, which parses with an ERROR inside the
+  name, → `Foo`) → **`decorates` ref {from the decorated node, name,
+  line/col of the ANNOTATION node, i.e. its `@`}**. With-args annotations
   emit their NAME; the argument expressions are never visited (no refs from
   `@Deprecated('use other')`'s string).
 - **Stacked annotations emit in REVERSE source order** (the backward walk):
   `@Deprecated('x')\n@pragma('vm:entry-point')\nvoid f()` → decorates
   `pragma` FIRST, then `Deprecated` (pinned).
 - For a method: the previous member's function_body (or any declaration)
-  breaks the chain correctly. The annotation-BETWEEN-doc-and-decl also
-  breaks the DOCSTRING chain (§Docstrings).
-- Bodiless ctors (declaration-wrapped): extractMethod runs on
-  constructor_signature whose PARENT is the `declaration` node — the
-  backward scan runs over declaration's children (constructor_signature is
-  namedChild(0) → declIdx 0 → no siblings scanned) → an annotation before
-  the declaration attaches to NOTHING. Annotated fields likewise emit
-  nothing (no extractor runs).
+  breaks the chain correctly. (The docstring walk steps OVER annotations
+  since 2026-10-06 — §Docstrings.)
+- **Comments between the annotations and the declaration are stepped over**
+  (since 2026-10-06). An annotation always belongs to the next declaration,
+  so dart.ts sets `decoratorStepOverTypes: ['comment',
+  'documentation_comment']`, which scan #2 skips, and the kernel's
+  `extract_decorators_for` skips the same `DECORATOR_STEP_OVER` list. No
+  other language sets one. Until then the comment ended the scan and the
+  annotation above it attached to nothing. Now these all attach: `@override`
+  `// ignore: must_call_super` `void f()`, `@x` `/// Doc below.` `void f()`,
+  `@x /* c */ void f()`, a comment on the annotation's own line, and comments
+  between stacked annotations (still in reverse order). Pinned in
+  TortureAnnotatedComments.dart and dart-annotation-comments.test.ts.
+  - Still ends the scan, comments or not: a field's `declaration`, a
+    top-level variable, an import, the previous member's body (`void a() {}
+    // note` `@x void b()` gives `b` only `x`), a class-like declaration.
+  - Class-likes are unaffected. Their leading annotations are scan #1's,
+    which reads every child, comments among them included.
+  - Validation (bloc @b9be1e2 / riverpod @4ba1be2, kernel loaded, on top of
+    the annotation resolution below): `decorates` refs +7 / +54, edges +0 /
+    +16, nothing else in the dumps changed. bloc's 7 are all `@override`.
+    riverpod's 54 (on 48 declarations) are `@override` 32, `@internal` 6 and
+    `@riverpod` 16 (lint fixtures and one website snippet), and each
+    `@riverpod` links `const riverpod`. Kernel and wasm full-index dumps are
+    byte-identical, and the parity sweeps show 0 diffs.
+  - The AST scan's 55th riverpod site is `@override` `// ignore: …` on a
+    FIELD, which no extractor records. A scan that also counts annotation →
+    comment runs INSIDE class-like nodes finds riverpod's 24 `@riverpod`
+    `// ignore: …` `class X` lint fixtures and bloc's `@JsonEnum(…)` `/// …`
+    `enum`. Scan #1 already reads those (an enum's, never: see above).
+- Members with no body (declaration-wrapped ctors, const ctors, redirecting
+  factories, abstract and `external` members): the signature's PARENT is the
+  `declaration`, so until 2026-10-06 the backward scan ran over the
+  declaration's own children (the signature is namedChild(0) → declIdx 0 →
+  nothing scanned) and an annotation before the declaration attached to
+  NOTHING (`@visibleForTesting Foo._();`, `@protected void m();`). Now scan
+  #2 starts at getDeclarationWrapper's `declaration`: same backward walk,
+  same reverse order, and a field's `declaration` in between still stops
+  it. Annotated fields themselves emit nothing (no extractor runs).
+  Validation (bloc @b9be1e2 / riverpod @4ba1be2): +10 / +186 `decorates`
+  refs, all SDK or package:meta names (`useResult`, `override`, `internal`,
+  `visibleForTesting`, …), so no edges; before #2380, riverpod's 23 new
+  `@internal` refs on `X.internal(…)` ctors resolved to the ctor itself.
+- **Resolution is TS-side and Dart-specific** (since 2026-10-06):
+  resolveOneInner hands every Dart `decorates` ref to name-matcher.ts's
+  `matchDartAnnotation` before any other strategy, and nothing falls
+  through. A Dart annotation is a const variable or a const constructor
+  call, never a method, getter or function, so the shared decorator ranking
+  (findBestMatch: +25 function/method, +15 class, nothing for a constant)
+  never sees one. That ranking sent riverpod's 506 `@riverpod` to the
+  analyzer's extension getter `RiverpodAnnotatedAnnotatedNodeOfX::riverpod`
+  (0.4) instead of `const riverpod = Riverpod();`.
+  - The matcher re-reads the written form from the `@` in comment-blanked
+    source. It is a call only when `(` follows on the same line, so a record
+    return type on the next line is not taken for arguments.
+  - `@x`: on a member, the enclosing type's own static `constant` /
+    `enum_member` `x` (a class-like's own annotations stand outside its
+    body); else a top-level `constant` the library can see (#2386's model,
+    the own library shadowing imports). `@X(…)`: a visible class `X`, not
+    an extension.
+  - `@p.x` / `@p.X(…)`, when `p` is an import prefix (dart-libraries.ts
+    `dartImportPrefixes`, the imports of the file's whole library): the same
+    through that prefix. Otherwise `@T.x` → T's own `constant` /
+    `enum_member` `x`, and `@T.named(…)` → T's named constructor (#2380's
+    `isDartConstructor`); `@p.T.x` / `@p.T.named(…)` likewise through `p`.
+  - A sole candidate links at 0.9 (`exact-match`, or `qualified-name`
+    through a type). Several (only where the library model can't establish
+    the library) fall back to findBestMatch's proximity at 0.7 / 0.4.
+  - Not modelled: a `final` is not told apart from a `const` (compiling code
+    never annotates with a visible `final`), nor a typedef used to call a
+    constructor.
+  - Validation (main 99246848, kernel loaded): bloc 0 edges changed (no
+    annotation there names a project declaration); riverpod exactly the 506
+    `@riverpod` edges retargeted to `const riverpod` at 0.9, every other
+    `decorates` edge (`$internal`, `Riverpod`, `Dependencies`, …) identical,
+    nodes, refs and files identical. Every extracted annotation in both
+    repos is written with one name, so the prefixed and `T.x` forms are
+    pinned by dart-annotation-targets.test.ts only.
 
 ### Docstrings (tree-sitter-helpers.ts:95-127) — dartdoc is KEPT, both forms
 
@@ -776,10 +985,59 @@ plain `//` comments all become docstrings and accumulate together** (pinned:
 strip + `^\/\/[/!]?\s?` + `^\s*\*\s?` gm strips fire — **all `gm` strips
 ride `js_multiline_strip` in docstring.rs (#1329 CRLF semantics) — call the
 shared code, port nothing**. DOCSTRING_WRAPPER_TYPES contains no dart kinds
-→ no anchor climbing. **An `annotation` between the comment run and the
-declaration BREAKS the chain** (pinned: `/// Broken by annotation.`
-`@deprecated` `void annotated()` → doc undefined — the dominant real-world
-loss since `@override` is ubiquitous). Docstrings attach to: functions,
+→ no anchor climbing; instead `docstringFor` starts from
+getDeclarationWrapper's `declaration` for a member with no body (until
+2026-10-06 those looked inside the wrapper and found nothing, e.g.
+`const BlocProvider.value(…)`'s dartdoc; validation added 32 docstrings on
+bloc and 126 on riverpod, none changed or removed).
+
+**The walk steps OVER `annotation` siblings** (since 2026-10-06). Until then
+an annotation between the comment run and the declaration ended the walk:
+`/// Builds it.` `@override` `Widget build(…)` lost its dartdoc, the
+dominant real-world loss since `@override` is everywhere. Now dart.ts sets
+`docstringStepOverTypes: ['annotation']`, which docstringFor hands to
+getPrecedingDocstring's `stepOver`. The kernel's `docstring_of` calls
+docstring.rs's `preceding_docstring_stepping_over(…, &["annotation"])`.
+`preceding_docstring` and every other language keep the empty list.
+- Stepped over: stacked annotations, multi-line ones (`@Deprecated(` …
+  `)`), inline ones (`/* c */ @x void f()`, freezed's `@optionalTypeArgs
+  TResult maybeMap…` on the declaration line), and blank lines, which are
+  not nodes. This works from a `declaration` wrapper too.
+- Comments on either side of an annotation keep the join semantics:
+  `/// a` `@x` `// b` `void f()` → `a\nb` (was `b`), and `/// Doc.`
+  `@override` `// ignore: …` → `Doc.\nignore: …`.
+- Still ends the walk: any other named sibling, such as the previous
+  member's `function_body`, a field's or a bodiless member's `declaration`,
+  a top-level variable (`static_final_declaration_list` /
+  `initialized_identifier_list`), an `import_or_export` or `part_directive`,
+  or a class-like declaration. A comment trailing the previous member on its
+  line (`void a() {} // note`) is collected, as it already was for a member
+  with no annotation.
+- Class-like declarations needed nothing. A class, mixin, extension,
+  extension type, enum or typedef node starts at its first annotation
+  (§Decorators), so the dartdoc above the annotations is the node's previous
+  sibling and was always kept. A comment written BETWEEN such an annotation
+  and the keyword (`@JsonEnum(…)` `/// The state…` `enum LinterRuleState`)
+  is inside the node and is NOT read (pinned). bloc has 1 such dartdoc,
+  riverpod none (23 `// ignore:` lines and 1 plain comment). A member's
+  comment below its annotation IS read: it is the signature's previous
+  sibling.
+- Local functions get no docstring with or without annotations: the
+  signature sits in `local_function_declaration > lambda_expression`, with
+  no previous sibling.
+- Validation (bloc @b9be1e2 / riverpod @4ba1be2, 3f96f80f plus the
+  declaration-wrapper fix, kernel loaded): docstrings +26 / +1,072, changed
+  0 / 9 (each a `// ignore:` line below the annotation, now joined after
+  the dartdoc above), removed 0. Everything else in the dumps (nodes,
+  edges, refs, files) is byte-identical; kernel and wasm full-index dumps
+  are byte-identical; the parity sweeps show 0 diffs. bloc's 26 are all
+  hand-written dartdoc, mostly behind `@mustCallSuper` / `@override`. Of
+  riverpod's 1,072, 667 runs hold a dartdoc (401 in generated
+  `.freezed.dart` / `.g.dart` files, 266 hand-written) and 405 are plain
+  comments only (`// ignore: riverpod_lint/…` in the lint fixtures, the
+  website's snippet markers).
+
+Docstrings attach to: functions,
 methods (incl. `<anonymous>` operators), classes/mixins/extensions, enums,
 type aliases. NOT to: hook-minted constants (extra carries only signature —
 pinned drop), enum members, imports, the file node. No comment-gluing into
@@ -857,14 +1115,17 @@ NO unwrap, NO ungatedModes, NO addressOfOnly. Pins:
 - `[topLevel, blockDoc]` list ✓ (locals' list_literals capture too — the
   dispatch fires wherever the node is walked); `{'k': topLevel}` pair ✓;
   `final aliasTop = aliased;` top-level/static → varinit bare-identifier ✓
-  (pinned from=file / from=class); a LOCAL `final alias = topLevel;` →
+  (from the constant `aliasTop` — the hook walks the declaration with it
+  pushed); a LOCAL `final alias = topLevel;` →
   initialized_variable_definition NOT in dispatch → not captured.
 - obj.method member values (`final g = obj.method`) → the last child is a
   selector → normalizeValue [] → nothing (no member special for dart).
-- Capture points: visitFunctionBody:5137 (bodies), visitNode:990 (the
-  §double-walk twins from file/class scope), scanFnRefSubtree (hook-consumed
-  constant initializers — halts at `function_expression` :609, so lambdas
-  inside a constant's initializer don't leak candidates).
+- Capture points: visitFunctionBody:5137 (bodies, and every initializer
+  the hook walks — from the constant / class / file, lambdas included),
+  visitNode:990 (the §double-walk twins from file/class scope),
+  scanFnRefSubtree (only a `static_final_declaration` whose constant wasn't
+  minted — the scan skips what the hook walked, so nothing is captured
+  twice; it halts at `function_expression` :609).
 - **Flush gate (:639-728): effectively "defined in this file" ONLY** — dart
   import refs are URIs (`package:foo/util.dart`, `dart:async`) which match
   neither SIMPLE_NAME nor QUALIFIED_IMPORT (`:` and `/` excluded) →
@@ -1016,8 +1277,10 @@ NO unwrap, NO ungatedModes, NO addressOfOnly. Pins:
    `svy-dart/torture.dart` (231 lines, parses clean; its
    `extract-torture.txt` is the expected-output pin). Inventory by branch:
    imports (dart:, package: with `as`+`show`, export with `hide`,
-   **deferred → invisible**, part → invisible); doc shapes (`///` run,
-   `/** */` kept, `//` kept, annotation-broken chain); annotations (bare,
+   **deferred → invisible**, part → invisible — an import since
+   2026-10-06, pinned with every directive form in TortureDirectives.dart,
+   and `part of` by library name in TorturePartOfName.dart); doc shapes (`///` run,
+   `/** */` kept, `//` kept, a `///` above an annotation); annotations (bare,
    with-args, stacked → reverse order, on class); top-level constants
    (CAPS/lowercase/multi/typed/derived, sig truncation ≥100 chars);
    top-level var/typed-var/getter/setter (all invisible); async vs
diff --git a/docs/design/framework-coverage.md b/docs/design/framework-coverage.md
index abf6a2346b..14218f3069 100644
--- a/docs/design/framework-coverage.md
+++ b/docs/design/framework-coverage.md
@@ -1,6 +1,6 @@
 # Framework & language coverage — what is done, what is left
 
-**Last verified: 2026-08-29** against the build at that date. Re-verify with the
+**Last verified: 2026-08-29** (Angular row: 2026-10-06; React Router row: 2026-10-07) against the build at that date. Re-verify with the
 queries in [Checking this file is still true](#checking-this-file-is-still-true)
 before trusting a row; this is a snapshot, not a live view.
 
@@ -30,7 +30,7 @@ to write. That is why "add a router" is a small, self-contained job.
 
 ## Routers — routes AND navigation (done)
 
-Six. Each reads a literal destination and leaves a computed one, a path no
+Seven. Each reads a literal destination and leaves a computed one, a path no
 route serves, and a conditional whose arms disagree unresolved rather than
 guessed.
 
@@ -38,18 +38,57 @@ guessed.
 |---|---|---|---|---|
 | Expo Router | `frameworks/expo-router.ts` | `expo-router-synthesizer.ts` | `expo-router.test.ts` | — |
 | Next.js | `frameworks/nextjs.ts` | `next-router-synthesizer.ts` | `nextjs.test.ts` | next-saas-starter |
-| React Router | `frameworks/react-router.ts` | `react-router-synthesizer.ts` | `react-router.test.ts` | proshop (44 edges) |
+| React Router | `frameworks/react-router.ts` | `react-router-synthesizer.ts` | `react-router.test.ts` | proshop (44 edges), proshop-v2 (28), react-redux-realworld (22), react-boilerplate (`styled(Link)`), takenote (v5 `<Redirect>`), bulletproof-react (nested `children`, `lazy` routes, `paths.x.path` constants through an app's own tsconfig alias: 0 → 9 named, linked routes), and its `paths.x.getHref(id)` links and `navigate(paths.x.getHref())` calls (0 → 11 navigates). Route tables another file hands the router (`tableRoutes` in `frameworks/react.ts`, trap 13): the ASP.NET Core React template's `AppRoutes.map(… <Route {...rest}>)` on jasontaylordev/CleanArchitecture's `ClientApp-React` (0 → 6 routes, 11 navigates), replaysMike/Binner (0 → 46, 87), GavinLonDigital/RankingApp, GarrettHays/PaydirtPickem, charlessolar/eShopOnContainersDDD; `useRoutes(routes)` from another file and `[...sessionRoutes]` on uilibrary/matx-react (0 → 7, 16); codedthemes' `createBrowserRouter([MainRoutes, LoginRoutes])` on berry and mantis (9 and 8 routes, no navigation they can resolve); a table `.map`ped inside `<Route path="/dashboard">` on RADeveloping/chickadeeinvest; `useRoutes([...])` in place on minimal-ui-kit/material-kit-react (0 → 7, bound through `lazy(() => import(…))` to each page). JSX index routes and layouts (trap 14): proshop-v2's `createRoutesFromElements` (`/` is HomeScreen inside App, not App; 30 layout edges, the `path=''` guards included; Screens 30 → 74 transitions, the guards' redirects drawn from the screens they guard), chickadeeinvest's table inside `<Route element={<DashboardLayout/>}>` (its 4 routes get the layout), React Router 6.29's own examples and tests, refine's 281 examples (one `/` per app, 191 layout edges, 21 new navigations), crwn-clothing, the vanlife course app, volun-mern (105 layout edges, six levels deep), spotify/vispana, react_persist_login, chushi (`path={"agents"}`: 2 → 6 routes), hathor-explorer (`path=""` at the root), cboard, react-router-auth-v6: 578 of 581 new layout edges name a component of an enclosing `<Route>` (vanlife's 3 inherit a default-import resolution bug that already misbinds its pages), 27 of 27 new navigations precise, no navigation lost, 16 control repos byte-identical. Lazy route modules that are barrels (`exportedComponent` in `frameworks/react.ts`): luci-go's milo/ui (`export * from './x'` index files and `export { X as Component }` clauses: 0 → 51 lazy routes linked; the other 40 load a file under `src/build/`, which the default ignore skips, export only a `loader` or a `handle`, or pick a named export in an async `lazy`), Medusa's admin dashboard (all 193 route-map modules resolve through its `export { X as Component } from` barrels, but its routes are not extracted: `getRouteMap()` returns the table), four more apps (9 routes), 16 control repos byte-identical |
 | TanStack Router | `frameworks/tanstack-router.ts` | `tanstack-router-synthesizer.ts` | `tanstack-router.test.ts` | TanStack examples, fastapi-template frontend |
-| Vue Router / Nuxt | `frameworks/vue-router.ts` | `vue-router-synthesizer.ts` | `vue-router.test.ts` | vue-realworld (23 edges) |
-| SvelteKit | `frameworks/sveltekit-router.ts` | `sveltekit-synthesizer.ts` | `sveltekit-router.test.ts` | sveltekit-realworld (31 edges) |
+| Vue Router / Nuxt | `frameworks/vue-router.ts` (Nuxt file routes: `nuxtResolver` in `frameworks/vue.ts`) | `vue-router-synthesizer.ts` | `vue-router.test.ts` | vue-realworld (23 edges); vue-element-admin (62 routes), vue-admin-template (14), vben (192), halo console (34) — named tables, module files, `children` + layouts; Nuxt: mealie, elk, nuxt/movies |
+| SvelteKit | `frameworks/sveltekit-router.ts` | `sveltekit-synthesizer.ts` | `sveltekit-router.test.ts`, `sveltekit-route-names.test.ts` | sveltekit-realworld (31 edges); shadcn-svelte and skeleton (`(group)` layouts: 13 and 23 edges), svelte.dev (74), kit's test apps (47) |
+| Angular | `frameworks/angular-router.ts` | `angular-template-synthesizer.ts` | `angular-router.test.ts` | angular-realworld (31 edges, 18 renders, 32 bindings), Ghostfolio (189 edges, 170 renders, 215 bindings), ngx-admin (routes and renders; its menus are config; 13 bindings), CleanArchitecture's `src/Web/ClientApp` (signals; 12 bindings), angular-spotify (Nx libs behind barrels: 14 routes), jira-clone (class-constant paths, mount-only redirects), jhipster (60), ionic-conference (18), Angular-JumpStart (18) |
 
-Shared machinery all six use, in `frameworks/expo-router.ts`: `RouteTable` /
+Shared machinery all seven use, in `frameworks/expo-router.ts`: `RouteTable` /
 `RootedRouteTable`, `routesForFile`, `addRouteTo`, `matchRoute`, `appRootFor`,
 `parseHrefExpression`, `readHrefViaLocal`, `nthArgumentText`, `readStringAt`,
 `toHref`. Plus `pageForHref` in `frameworks/nextjs.ts` (framework-agnostic
 despite where it lives) and the object-literal walker in
 `frameworks/object-literal.ts`.
 
+Angular is the one whose markup is not indexed: a component's template is a
+`templateUrl` file (or an inline `template:` string) read at synthesis time,
+which also yields the component tree (`<app-foo>` by element selector) — the
+edge a navigation in a child component rides to its screen. A `routerLink:`
+field written in a component's class (a tab bar's or a menu's config, bound
+in a loop elsewhere) counts as a link from that component. An event binding
+(`(click)="save()"`) is a `calls` edge from the component to its own method
+carrying `metadata.trigger`, which Steps uses in place of reading a trigger
+at the edge's line (the binding is in the template, not the source there).
+A property binding, an interpolation, a structural directive or a
+control-flow block that calls one of the component's own members
+(`[name]="icon()"`, `{{ label() }}`, `*matRowDef="let row; columns:
+displayedColumns()"`, `@if (loading())`, `@let total = price();`) is a
+`calls` edge too (`angular-binding`, the binding as `via`), with no trigger:
+it runs when the template renders, so Steps folds it into the screen rather
+than drawing a handler the user fires — a trigger there drew `computed`
+signals as user actions. A member read without a call counts only when it is
+method-kind: a getter is called, a method handed to a child
+(`[displayWith]="displayFn"`, `trackBy: trackById`) is a `references` edge
+with `fnRef`, and a field a call filled (`days = Array.from(…)`) a plain
+`references`. A property read (`[value]="title"`) links nothing, as in
+TypeScript, which records no property reads either; on angular-realworld,
+ngx-admin, Ghostfolio and CleanArchitecture it would have added four times
+the edges and taken nothing off the Dead code list, which never asks about
+properties. A pipe, an object key, a
+microsyntax key (`of`, `trackBy:`, `index`), a template's own names (`let
+item`, `as user`, `#ref`, `@let x`, `let-row`) and a commented-out binding
+link nothing. A route with
+`children` is a layout: its component carries a `references` edge marked
+`layout: true` from each screen nested in it, and `routeLayouts` in
+`route-roots.ts` gives Screens every screen a layout serves. Known limits: a
+route with a custom `matcher` has no static address, a relative navigation
+(`relativeTo`) is left unresolved, an edit to a template file alone is
+picked up at the next sync of any source file (templates are not watched), a
+member a component inherits from a base class is not linked from its
+template, and a template's local hides a same-named member for the rest of
+the template rather than only inside its block.
+
 ---
 
 ## What is left
@@ -174,6 +213,10 @@ Each of these cost real debugging time; they are not hypothetical.
    `name` is written above its `path`, so a text window handed every entry its
    predecessor's name — silently, for every route in the file. Use
    `frameworks/object-literal.ts`.
+   A lazy view binds by the FILE it imports, never by the import's last
+   segment: vue-element-admin's views are all `…/index.vue`.
+   Nuxt's `pages/` convention belongs to a Nuxt app only — a plain Vue app's
+   `pages/` folder (halo's console) holds components a router config names.
 5. **A receiver is required for a generic verb.** `push` and `replace` are two
    of the most common method names in JavaScript; claiming a bare one puts every
    `paths.push('/tmp/x')` one string-match away from a route.
@@ -210,6 +253,83 @@ Each of these cost real debugging time; they are not hypothetical.
    per file-count for exactly this reason — an earlier version cached the empty
    pre-index answer and every framework whose dependency lived one directory
    down stayed undetected.
+12. **An app's manifest can sit three or more levels down.** An ASP.NET
+   solution keeps its single-page app in `src/Web/ClientApp/`, and prometheus
+   keeps its React apps in `web/ui/mantine-ui/` under a workspace root at
+   `web/ui/` that declares only tooling. `declaredDependencies` reads the root
+   and the first two levels, then gives the slots left to the directories
+   above JS/TS code, shallowest first. Read only two levels deep, Angular
+   Router never ran on jasontaylordev/CleanArchitecture, and every
+   template-bound handler there was listed as dead code. A new detector that
+   gates on a dependency should ask `dependsOn`, not read a `package.json`
+   itself, so it sees the same manifests every other detector does.
+13. **A route table can be named only by another file.** The ASP.NET Core
+   React template keeps its routes in `AppRoutes.js`, a file that never names
+   the router, and renders them from `App.js` with `AppRoutes.map(({ element,
+   ...rest }) => <Route {...rest} element={element} />)`; codedthemes' admin
+   kits put one route object per file and list them in
+   `createBrowserRouter([MainRoutes, LoginRoutes])`. Read on its own, such a
+   file cannot be told from a menu's `{ path, element }` list, and per-file
+   extraction cannot see the file that hands it over, nor run again when that
+   file changes. So React keeps those routes in the cross-file pass
+   (`FrameworkResolver.crossFileNodes`, reconciled in `runPostExtract` on every
+   index and sync, removals included): it starts from the files that import
+   React Router, takes only a `useRoutes` / `create*Router` argument or a
+   `.map` whose callback renders a `<Route>` from the item's own fields
+   (`{...route}`, `{...rest}`, `path={route.path}` — never
+   `path={r.layout + r.path}`), follows the import to the table and the tables
+   it names in turn, and owns its routes by id (`…:table:<path>`). One limit
+   it shares with every router: a table rendered by a component that is
+   itself mounted under another file's `<Route path="/admin/*">` reads as if
+   at the root. A sync that changes such a route resolves the calls it can
+   answer again (16), as for any other route.
+14. **An index route is at its parent's address, so it needs that address
+   written down.** `<Route index element={<Home />} />` inside `<Route
+   path="/" element={<Layout />}>` is the page at `/`, and Layout is the
+   layout of every route nested in it (trap 2: emitting Layout as a second
+   `/` page drew the app's chrome as the home screen and its header's links
+   from `/` alone). A `<Route path>` with no element only groups its children
+   and yields its address the same way. But a `<Routes>` inside a component
+   is mounted wherever another file's `<Route path="shop/*" element={<Shop
+   />}>` puts it: read as `/`, crwn-clothing's `Shop` index made a second
+   home page. So an index route at the top of a `<Routes>` is read only
+   inside the router itself (`createRoutesFromElements(…)`, `<BrowserRouter>`),
+   and one under a path the file does not spell out (`path={paths.agents}`)
+   not at all; `path={"agents"}` is spelled out. Reading what an element
+   renders has three traps of its own: skip elements written in an attribute
+   unless the attribute hands over a page (`component`, `element`, `page`) —
+   `<Suspense fallback={<Loader />}>` bound fifteen routes of one app to the
+   spinner; trim the line break Prettier writes after `element={`, which hid
+   every long element; and read `<Outlet />` as rendering nothing of its own.
+   Version 5's `<Route path="" component={NotFound} />` is a catch-all, not
+   the page at its parent's address. A table written in another file and
+   mapped inside a `<Route element>` gets no layout edge: the layout's name
+   would be looked up in the table's file, and the cross-file pass compares
+   only route names, so a changed layout would never reach the table's routes.
+15. **`resolve()` sees only references written in the framework's own
+   languages** (`getResolvingFrameworks`): Express's `logger` middleware rule
+   once took etcd's Go `*zap.Logger` result types for a method. A navigation
+   written in markup (`.svelte`, `.vue`) needs that language in `languages`.
+   A resolver that reads a language it extracts nothing from lists it in
+   `resolveLanguages` instead — Svelte's `$lib/…` imports in `.ts` route
+   modules, ASP.NET's Razor `@model` — because widening `languages` also runs
+   `extract()` on those files. `claimsReference()` is asked of the same
+   frameworks. It used to be asked of every detected one, because protobuf's
+   C++ `::_pbi::…` calls got past the name pre-filter only on the Swift ↔
+   Objective-C bridge's claim of any name with a `:` in it. The pre-filter
+   now reads a leading `::` as the global scope.
+16. **A navigation call waits for a route, not for a name.** A call indexed
+   before its route existed is parked as failed (or bound to a catch-all, a
+   parameter route, the other arm of a conditional), and sync revisits a
+   failed reference only by matching its last name segment against the names
+   the synced files define — never `push` or `navigate`. Set the resolver's
+   `navigation`: `tails`, the method names its calls end in, and `scope`, the
+   apps whose calls one of its routes can answer (its own app's table, or every
+   file for a table the whole project shares). A sync that adds, removes or
+   renames a route — a cross-file table route included — then resolves those
+   calls again, failed or not; without it the synced index keeps an answer a
+   full index does not have. `sync-navigation-retry.test.ts` runs all seven
+   routers through it, and asserts each router's calls end in a declared tail.
 
 ---
 
diff --git a/docs/design/rust-lang-kernel-port-checklist.md b/docs/design/rust-lang-kernel-port-checklist.md
index 6b44e6ed9c..e086eb0899 100644
--- a/docs/design/rust-lang-kernel-port-checklist.md
+++ b/docs/design/rust-lang-kernel-port-checklist.md
@@ -317,10 +317,10 @@ trait_item — supertraits `trait Sub: Super + Display`). Per bound child:
 
 Each yields an `extends` ref from the trait node at the bound's position.
 Struct/enum extraction also calls extractInheritance; rust struct_item children
-include `field_declaration_list` → the 5652 recursion descends, but rust
-`field_declaration` always carries a `field_identifier` name so the Go
-struct-embedding branch (5496) never fires. Verify with the torture fixture
-anyway.
+include `field_declaration_list` → the 5652 recursion descends and finds
+nothing: the Go struct-embedding branch (5496) runs for Go only (it was inert
+here anyway — rust `field_declaration` always carries a `field_identifier`
+name), so rustlang.rs has no `field_declaration` arm.
 
 ### impl Trait for Type — extractRustImplItem (5690)
 
@@ -370,12 +370,19 @@ while `Vec`/`Option`/`Box`/`Self` are NOT. QUIRKS, PRESERVE:
 - property_signature/method_signature branch (1283) — TS-only node types,
   never rust.
 
-### Static-member refs, cpp-isms — NOT rust
-
-`rust` ∉ STATIC_MEMBER_LANGS (345) → extractStaticMemberRef no-ops (its call
-in the body walker at 5218 must be a no-op in the walker too — cheap early
-return). namespacePrefix, cppLocalFnPtrs, stack-construction, operator calls,
-template strip: all c/cpp-gated, none apply.
+### Static-member refs (rust since #2328); cpp-isms — NOT rust
+
+`rust` ∈ STATIC_MEMBER_LANGS since #2328, with its own branch in
+extractStaticMemberRef (body walker only; the kernel's
+`extract_static_member_ref`, called at the same point of the walk): a
+`scoped_identifier` whose member is capitalized — unless it is a call's
+callee, the prefix of a longer path or part of a `use` tree — and a
+`struct_pattern`'s `scoped_type_identifier` emit one `references` ref named by
+the receiver (the segment before the member; `Self` → the impl's type via
+getReceiverType, nothing inside a trait), positioned at the receiver. The
+resolver keeps it only on an enum that declares the member as a variant.
+namespacePrefix, cppLocalFnPtrs, stack-construction, operator calls, template
+strip: all c/cpp-gated, none apply.
 
 ### Docstrings (tree-sitter-helpers.ts:95)
 
diff --git a/docs/design/telemetry.md b/docs/design/telemetry.md
index 71c85b6f4c..bf5deed9cc 100644
--- a/docs/design/telemetry.md
+++ b/docs/design/telemetry.md
@@ -195,7 +195,7 @@ with the npm package (excluded by the `files` allowlist):
   The Worker makes **no outbound requests** — nothing is forwarded to a third-party
   analytics vendor, so there is no vendor-side privacy setting to get wrong and no second
   copy of the data anywhere. The complete stored schema is
-  [`telemetry-worker/migrations/0001_init.sql`](../../telemetry-worker/migrations/0001_init.sql),
+  [`telemetry-worker/migrations/`](../../telemetry-worker/migrations/),
   checked in for the same reason the Worker's source is public.
 - The write is off the response path (`ctx.waitUntil`, one `batch()` = one transaction) and
   deliberately **fail-silent**: a D1 error is logged as counts only, never the payload, and
@@ -205,8 +205,10 @@ with the npm package (excluded by the `files` allowlist):
   counts (`daily_machines`, `daily_event_counts`, `daily_dim_counts`) and re-runs the two
   days before it, since offline clients ship completed-day rollups late. Aggregation is
   `INSERT … SELECT … ON CONFLICT DO UPDATE` inside D1 — no event row crosses the wire, and
-  re-running a day is a no-op rather than a double count. The same job **purges raw
-  `events` older than `RETENTION_DAYS`** (90; a var in `wrangler.jsonc`). Rollups and
+  re-running a day is a no-op rather than a double count. Usage counters are stored one
+  row per machine × day × tool (`usage_daily`), each upload adding to its row, so storage
+  does not depend on how often a client uploads. The same job **purges raw `events` and
+  `usage_daily` rows older than `RETENTION_DAYS`** (90; a var in `wrangler.jsonc`). Rollups and
   `machine_days`/`machine_first_seen` are kept forever, so shortening the window costs
   ad-hoc drill-back, never a chart.
 - The Worker remains the seam: changing storage later is a Worker change, not a client
@@ -230,9 +232,9 @@ Full documentation is [`telemetry-dashboard/README.md`](../../telemetry-dashboar
   `telemetry-worker/scripts/smoke-cutover.sh` exists to cover — a mismatch there is silent,
   showing up as a panel that reads zero forever rather than as an error.
 - **Reads rollups, not raw events**, so a chart stays correct for days whose raw rows have
-  been purged. `/api/activation` is the one exception — "did this machine ever run an index"
-  is not a daily aggregate — so it reads raw `events` and is bounded by the retention window,
-  which it reports as `raw_events_from`.
+  been purged. The activation funnel's "did this machine ever run an index" is not a daily
+  aggregate, so it reads `machine_first_seen.first_index_day` instead, which the ingest Worker
+  lowers as each index event is stored and the nightly cron re-derives from raw `events`.
 - **Auth is a shared password and a signed cookie**, sized for exactly two people:
   `ADMIN_PASSWORD` + `SESSION_SECRET` as Worker secrets, constant-time compare, HMAC-signed
   cookie with no session store, everything except `/login` and `robots.txt` gated. Rotating
diff --git a/docs/grammars/tree-sitter-cobol.md b/docs/grammars/tree-sitter-cobol.md
index 02df0ed870..b2cf6aa975 100644
--- a/docs/grammars/tree-sitter-cobol.md
+++ b/docs/grammars/tree-sitter-cobol.md
@@ -54,6 +54,15 @@ mainframe and GnuCOBOL code:
    `SECURITY.` headers.
 10. **`CALL ... GIVING`** — upstream *intended* to support it but a misnested
     `field()` call swallowed the GIVING alternative entirely.
+11. **No hang when the input ends inside the sequence area.** The scanner
+    skips columns 1-6 by advancing until column 7, but `advance()` is a no-op
+    at end of input, so a file whose last line stops in that area (`    .`,
+    `X\n    .`, a sentence closed by a short `    .` line) spun forever inside
+    the scanner — parse timeouts and a zero-symbol file when indexing. The
+    loop now also stops at `eof()`. The loop is upstream code (present at
+    `e99dbdc3`), so this is a standalone upstream fix; inputs that parsed
+    before are unaffected (the NIST + ocesql test sources, 412 files, give
+    byte-identical trees before and after).
 
 ## Measured parse health (at vendoring time)
 
@@ -100,7 +109,9 @@ Sent as [yutaro-sakamoto/tree-sitter-cobol#41](https://github.com/yutaro-sakamot
 (branch `real-world-cobol-sources` on the colbymchenry fork). If upstream
 merges it, the vendored wasm can track upstream releases instead of this
 patch. Until then, `git apply tree-sitter-cobol.patch` on upstream commit
-`e99dbdc3` reproduces the fork exactly. The PR body as sent:
+`e99dbdc3` reproduces the vendored grammar exactly. Item 11 (the
+end-of-input hang) came after the PR was sent and is not on that branch
+yet. The PR body as sent:
 
 > **Parse real-world CICS/DB2 and GnuCOBOL sources**
 >
diff --git a/docs/grammars/tree-sitter-cobol.patch b/docs/grammars/tree-sitter-cobol.patch
index 72191bd147..15540a0c5a 100644
--- a/docs/grammars/tree-sitter-cobol.patch
+++ b/docs/grammars/tree-sitter-cobol.patch
@@ -303,7 +303,7 @@ index 6d48b47..e700a18 100644
      _NOT_GREATER: $ => /([nN][oO][tT][ \t]+(>|[gG][rR][eE][aA][tT][eE][rR]))/,
  
 diff --git a/src/scanner.c b/src/scanner.c
-index 6c1ae90..b69cf53 100644
+index 6c1ae90..3382988 100644
 --- a/src/scanner.c
 +++ b/src/scanner.c
 @@ -1,4 +1,5 @@
@@ -372,14 +372,18 @@ index 6c1ae90..b69cf53 100644
      if(valid_symbols[WHITE_SPACES]) {
          if(is_white_space(lexer->lookahead)) {
              while(is_white_space(lexer->lookahead)) {
-@@ -106,9 +121,20 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
+@@ -106,9 +121,23 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
      }
  
      if(valid_symbols[LINE_PREFIX_COMMENT] && lexer->get_column(lexer) <= 5) {
+-        while(lexer->get_column(lexer) <= 5) {
 +        // The sequence area is ignored content — but the free-format
 +        // preprocessor plants the CGWIDE sentinel here on the first line.
++        // Stop at end of input: advance() is a no-op there, so a file that
++        // ends inside the sequence area (e.g. a last line "    .") would
++        // never reach column 6 and the loop would spin forever.
 +        int match = 0;
-         while(lexer->get_column(lexer) <= 5) {
++        while(lexer->get_column(lexer) <= 5 && !lexer->eof(lexer)) {
 +            if(match >= 0 && match < 6 && lexer->lookahead == CG_WIDE_SENTINEL[match]) {
 +                match++;
 +            } else {
@@ -393,7 +397,7 @@ index 6c1ae90..b69cf53 100644
          lexer->result_symbol = LINE_PREFIX_COMMENT;
          lexer->mark_end(lexer);
          return true;
-@@ -132,7 +158,7 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
+@@ -132,7 +161,7 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
      }
  
      if(valid_symbols[LINE_SUFFIX_COMMENT]) {
@@ -402,7 +406,7 @@ index 6c1ae90..b69cf53 100644
              while(lexer->lookahead != '\n' && lexer->lookahead != 0) {
                  lexer->advance(lexer, true);
              }
-@@ -143,7 +169,7 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
+@@ -143,7 +172,7 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
      }
  
      if(valid_symbols[COMMENT_ENTRY]) {
@@ -411,7 +415,7 @@ index 6c1ae90..b69cf53 100644
              lexer->mark_end(lexer);
              lexer->result_symbol = COMMENT_ENTRY;
              return true;
-@@ -152,18 +178,66 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
+@@ -152,18 +181,66 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
          }
      }
  
@@ -482,7 +486,7 @@ index 6c1ae90..b69cf53 100644
                  lexer->mark_end(lexer);
                  return true;
              }
-@@ -187,7 +261,7 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
+@@ -187,7 +264,7 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
              }
  
              lexer->advance(lexer, true);
@@ -491,7 +495,7 @@ index 6c1ae90..b69cf53 100644
                  lexer->advance(lexer, true);
              }
          }
-@@ -197,11 +271,19 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
+@@ -197,11 +274,19 @@ bool tree_sitter_COBOL_external_scanner_scan(void *payload, TSLexer *lexer,
  }
  
  unsigned tree_sitter_COBOL_external_scanner_serialize(void *payload, char *buffer) {
diff --git a/docs/grammars/tree-sitter-kotlin.md b/docs/grammars/tree-sitter-kotlin.md
new file mode 100644
index 0000000000..6bec8c2cc1
--- /dev/null
+++ b/docs/grammars/tree-sitter-kotlin.md
@@ -0,0 +1,49 @@
+# tree-sitter-kotlin.wasm — provenance & rebuild
+
+`src/extraction/wasm/tree-sitter-kotlin.wasm` and the kernel's vendored C
+(`codegraph-kernel/grammars/kotlin/`) are both built from
+[fwcd/tree-sitter-kotlin](https://github.com/fwcd/tree-sitter-kotlin) (MIT)
+tag `0.3.8` (commit `e1a2d5ad1f61f5740677183cd4125bb071cd2f30`), from the
+tag's checked-in `src/parser.c` — never `tree-sitter generate` — with the
+patch in `tree-sitter-kotlin.patch` applied to `src/scanner.c`.
+
+| file | upstream sha256 | patched sha256 |
+|---|---|---|
+| `src/parser.c` | `54104a7ef1555c265b746c790e0f8bb953cc17806e9df0c3af82f7f62c06a70a` | unchanged |
+| `src/scanner.c` | `27f73337ec357fc341fa57538f34c14277b0346980c3405dc30beab6202ec6d0` | `2ca842dd04b60b0a6df59a03e9ad01209d8c5641f079a79a84d65708669b6cb6` |
+| `tree-sitter-kotlin.wasm` | `c80c88867a589a1a0959bcea89de84b7e9684b3693b2cdb2944812458e62ff48` | `e2ef7c0c83e5fd4bece547d2acd41b9f89da2fed5644d74be139b9765d4c74af` |
+
+## What the patch fixes
+
+The external scanner decides where to insert an automatic semicolon. On the
+same line as the end of an expression it inserted one before any word
+starting with `e` that was not `else` — so an infix call with such a name
+(Exposed's `Users.id eq id1`, used in nearly every Exposed query) ended the
+statement early and the rest became a parse error. On a file with many of
+them, error recovery could swallow the whole class: Exposed's r2dbc
+`UpsertTests` came out as one loose function nesting every test.
+
+On the same line nothing but `;` or `import` starts a new statement, so the
+patched scanner inserts no semicolon before any `e` word. Measured on
+Exposed, files with a parse error went from 229 to 71 of 1,004; koin,
+nowinandroid, moshi, okio, okhttp and kotlinx.coroutines parsed exactly as
+before (one okhttp file fixed, none broken).
+
+## Rebuild
+
+```
+git clone --depth 1 --branch 0.3.8 https://github.com/fwcd/tree-sitter-kotlin
+cd tree-sitter-kotlin
+git apply /path/to/codegraph/docs/grammars/tree-sitter-kotlin.patch
+# the 0.3.8 tag predates tree-sitter.json, which cli 0.25.10 requires —
+# add the METADATA-ONLY shim (grammar name/scope; nothing regenerated):
+#   {"grammars":[{"name":"kotlin","scope":"source.kotlin","path":".",
+#     "file-types":["kt","kts"]}],"metadata":{"version":"0.3.8","license":"MIT"}}
+npx -y tree-sitter-cli@0.25.10 build --wasm -o tree-sitter-kotlin.wasm .
+cp src/scanner.c /path/to/codegraph/codegraph-kernel/grammars/kotlin/scanner.c
+```
+
+Built without the patch, the same command reproduces the upstream wasm above
+byte for byte. After updating either side, rebuild the kernel
+(`npm run build:kernel`) and check `scripts/kernel-parity.mjs` on a Kotlin
+repo: the wasm and the kernel must parse the same.
diff --git a/docs/grammars/tree-sitter-kotlin.patch b/docs/grammars/tree-sitter-kotlin.patch
new file mode 100644
index 0000000000..45bf4762ad
--- /dev/null
+++ b/docs/grammars/tree-sitter-kotlin.patch
@@ -0,0 +1,16 @@
+--- a/src/scanner.c	2026-09-30 10:25:12
++++ b/src/scanner.c	2026-09-30 10:25:12
+@@ -285,9 +285,11 @@
+ 
+   if (sameline) {
+     switch (lexer->lookahead) {
+-      // Don't insert a semicolon before an else
++      // Don't insert a semicolon before an else — nor before any other word
++      // starting with `e` on the same line: that is an infix call
++      // (`Users.id eq id1`), which continues the expression. (codegraph patch)
+       case 'e':
+-        return !scan_for_word(lexer, "lse", 3);
++        return false;
+ 
+       case 'i':
+         return scan_for_word(lexer, "mport", 5);
diff --git a/docs/grammars/tree-sitter-vbnet.md b/docs/grammars/tree-sitter-vbnet.md
index 3de667d35f..4aa84e257d 100644
--- a/docs/grammars/tree-sitter-vbnet.md
+++ b/docs/grammars/tree-sitter-vbnet.md
@@ -82,6 +82,31 @@ on those repos plus SCrawler and PCL:
 12. **LINQ queries** — query expressions no longer require a trailing
     `Select`/`Group` clause, `Aggregate`-led queries, and
     `Distinct`/`Skip`/`Take` clauses.
+13. **Names that begin with a keyword** — upstream lexed every member
+    modifier as one `token(prec(10, choice(…)))` and `Sub New` as one
+    `token(prec(100, …))`. A token that outranks the `prec(-1)` identifier
+    ends where its text ends, so `Public SharedCache` lexed as `Shared` +
+    `Cache`, `Public Dimension` as `Dim` + `ension`, and `Sub NewItem()` as a
+    constructor followed by `Item`. `Dim` and `Const` also appeared inside
+    that token, which kept the local-declaration `Dim`/`Const` out of keyword
+    extraction too, so `Constants.X = 1` in a method lexed as `Const ants.X`.
+    The modifiers and `Sub New` are now plain keywords, which the `word`
+    lexer matches only after it has read the whole identifier. `Protected
+    Friend` and `Private Protected` parse as two modifiers, and `prec(1)` on
+    `member_modifier` keeps a line that could start either a member or a
+    local declaration read as a member, as before.
+    The high-precedence tokens had also let the lexer fold a newline into the
+    keyword after it. Two parses depended on that by accident, so they are
+    now part of the grammar. `option_statements` may begin with newlines (an
+    `Option` line under a comment banner, as in every `My Project`
+    designer file). Upstream's top-level `file_attribute_section` is gone, so
+    every attribute line above a top-level declaration belongs to that
+    declaration, as one inside a class or namespace already did.
+    Measured on all five corpora below: clean parses rose on staxrip (138 →
+    141 of 145) and fell nowhere. Apart from the fixed names and the
+    positions of the newlines no longer folded into a keyword, the trees
+    changed only where `Protected Friend` became two modifiers and where an
+    attribute line now attaches to its declaration.
 
 ### External scanner (`src/scanner.c`, new)
 
@@ -130,6 +155,16 @@ Known remaining gap (localized ERROR regions, deliberately unpatched):
   `word:` stays and column-0 labels keep a localized error; indented labels
   parse fine. Worth an upstream tree-sitter investigation eventually.
 
+Before changing a keyword rule, run `tree-sitter generate --log` and read the
+`Keywords - exclude …` lines. A keyword-shaped token that is left out of
+keyword extraction is lexed with its own precedence, and if that precedence is
+above the identifier's it splits every identifier that starts with it. Those
+lines name the tokens left out and the reason: a token that matches the same
+string as another one, or that conflicts with a token, such as `"\n"`. Four
+remain: `Inherits`, plain `Implements` and both spellings of `IsNot`. Valid VB
+never starts a name where one of them can appear, so they split nothing in
+valid code.
+
 ## Rebuild
 
 ```bash
@@ -156,6 +191,14 @@ npx tree-sitter generate              # src/scanner.c from the patch is picked u
 npx tree-sitter build --wasm -o tree-sitter-vbnet.wasm   # needs emscripten or Docker
 ```
 
+The CLI's Docker fallback uses emscripten 4.0.4. A local emsdk at the same
+version works too, including on Windows (`emsdk install 4.0.4`,
+`emsdk activate 4.0.4`, then `emsdk_env`). Built that way from this patch,
+the vendored wasm's sha256 is
+`5a8aa2911e28e43e22b077ae56c8143ccfe52485bb6719152b60e2e66a1a9e53`. The
+wasm this one replaced did not rebuild byte for byte with that toolchain, but
+the rebuild parsed every file in SCrawler and staxrip to the same tree.
+
 Upstream's checked-in `test/corpus` expectations predate its own grammar.js
 (every corpus test fails at the pinned commit, before any patching), so the
 five-repo parse-health sweep above — plus 16 construct repros and the
diff --git a/docs/grammars/tree-sitter-vbnet.patch b/docs/grammars/tree-sitter-vbnet.patch
index 8caba699fb..37918d81ed 100644
--- a/docs/grammars/tree-sitter-vbnet.patch
+++ b/docs/grammars/tree-sitter-vbnet.patch
@@ -1,5 +1,5 @@
 diff --git a/grammar.js b/grammar.js
-index 21c8523..00bf2b1 100644
+index 21c8523..c9c1d85 100644
 --- a/grammar.js
 +++ b/grammar.js
 @@ -21,10 +21,14 @@ const PRECEDENCE = {
@@ -53,14 +53,46 @@ index 21c8523..00bf2b1 100644
      [
        $.class_declaration,
        $.structure_declaration,
-@@ -89,7 +88,6 @@ module.exports = grammar({
+@@ -89,30 +88,29 @@ module.exports = grammar({
      ],
    ],
  
 -  word: ($) => $._identifier_token,
  
    rules: {
++    // An attribute list on the line above a top-level declaration belongs to
++    // it: VB continues the line after the closing `>`. With no standalone
++    // attribute-line rule, the newline after the list is an extra here, as it
++    // already is inside a class or namespace.
      source_file: ($) =>
+       seq(
+         optional($.option_statements),
+         repeat(choice(
+           prec(10, $.imports_statement),
+           prec(10, $.global_attribute_section),
+-          prec(10, $.file_attribute_section),
+           $._declaration,
+           $._statement,
+           $._block_terminator
+         ))
+       ),
+ 
+-    file_attribute_section: ($) =>
+-      seq(
+-        $.attribute_list,
+-        $._terminator
+-      ),
+-
+-
+-    option_statements: ($) => repeat1($.option_statement),
++    // Files often open with a comment banner, so newlines may come before the
++    // first `Option` line. Only this path can be followed by `Option`, so it
++    // needs no precedence against a top-level empty line.
++    option_statements: ($) =>
++      seq(optional($._block_terminator), repeat1($.option_statement)),
+ 
+     option_statement: ($) =>
+       seq(
 @@ -157,13 +155,14 @@ module.exports = grammar({
        ),
  
@@ -79,15 +111,87 @@ index 21c8523..00bf2b1 100644
  
      identifier: ($) =>
        choice(
-@@ -194,7 +193,6 @@ module.exports = grammar({
-             ci("MustInherit"),
-             ci("NotInheritable"),
-             ci("Overrides"),
+@@ -174,41 +173,45 @@ module.exports = grammar({
+     _implements_keyword: ($) => token(prec(10, ci("Implements"))),
+     _inherits_keyword: ($) => token(prec(10, ci("Inherits"))),
+ 
+-    _sub_new: ($) => token(prec(100, seq(ci("Sub"), /\s+/, ci("New")))),
+-
++    // `Sub New` as two keywords rather than one token(prec(100, ...)). The
++    // single token ended at `New`, so `Sub NewItem()` lexed as a constructor
++    // followed by a stray `Item`. The keyword lexer reads `NewItem` whole.
++    _sub_new: ($) => seq(ci("Sub"), ci("New")),
++
++    // Each modifier is its own keyword, not one token(prec(10, choice(...))).
++    // That token outranked the prec(-1) identifier, so the lexer stopped at the
++    // end of a modifier spelled at the start of a name: `Public SharedCache`
++    // lexed as Shared + Cache, `Public Dimension` as Dim + ension. Keywords go
++    // through the `word` lexer, which reads the whole identifier first.
++    // `Protected Friend` and `Private Protected` are two modifiers. `Dim` and
++    // `Const` are now the same tokens as local_declaration_modifier's, so
++    // `Constants.X = 1` no longer lexes as `Const ants.X = 1`; prec(1) keeps
++    // the old reading (a member modifier) where a line could start either.
+     member_modifier: ($) =>
+-      token(
+-        prec(
+-          10,
+-          choice(
+-            ci("Public"),
+-            ci("Private"),
+-            ci("Protected"),
+-            ci("Friend"),
+-            ci("Protected Friend"),
+-            ci("Private Protected"),
+-            ci("ReadOnly"),
+-            ci("WriteOnly"),
+-            ci("Shared"),
+-            ci("Shadows"),
+-            ci("MustInherit"),
+-            ci("NotInheritable"),
+-            ci("Overrides"),
 -            ci("MustOverride"),
-             ci("NotOverridable"),
-             ci("Overridable"),
-             ci("Overloads"),
-@@ -225,43 +223,6 @@ module.exports = grammar({
+-            ci("NotOverridable"),
+-            ci("Overridable"),
+-            ci("Overloads"),
+-            ci("WithEvents"),
+-            ci("Widening"),
+-            ci("Narrowing"),
+-            ci("Partial"),
+-            ci("Async"),
+-            ci("Iterator"),
+-            ci("Dim"),
+-            ci("Const")
+-          )
+-        )
+-      ),
++      prec(1, choice(
++        ci("Public"),
++        ci("Private"),
++        ci("Protected"),
++        ci("Friend"),
++        ci("ReadOnly"),
++        ci("WriteOnly"),
++        ci("Shared"),
++        ci("Shadows"),
++        ci("MustInherit"),
++        ci("NotInheritable"),
++        ci("Overrides"),
++        ci("NotOverridable"),
++        ci("Overridable"),
++        ci("Overloads"),
++        ci("WithEvents"),
++        ci("Widening"),
++        ci("Narrowing"),
++        ci("Partial"),
++        ci("Async"),
++        ci("Iterator"),
++        ci("Dim"),
++        ci("Const")
++      )),
+ 
+     _method_body_statement: ($) =>
+       choice(
+@@ -225,43 +228,6 @@ module.exports = grammar({
          $._statement  // Fallback to regular statements
        ),
  
@@ -131,7 +235,7 @@ index 21c8523..00bf2b1 100644
      local_declaration_modifier: ($) =>
        choice(ci("Dim"), ci("Const"), ci("Static")),
  
-@@ -300,6 +261,8 @@ module.exports = grammar({
+@@ -300,6 +266,8 @@ module.exports = grammar({
      _primary_expression: ($) =>
        choice(
          $._literal,
@@ -140,7 +244,7 @@ index 21c8523..00bf2b1 100644
          $.identifier,
          $.parenthesized_expression,
          $.generic_invocation_expression,  // Add this before regular invocation
-@@ -320,17 +283,26 @@ module.exports = grammar({
+@@ -320,17 +288,26 @@ module.exports = grammar({
        ),
  
      generic_invocation_expression: ($) =>
@@ -170,7 +274,7 @@ index 21c8523..00bf2b1 100644
      member_access_expression: ($) =>
        prec.left(
          PRECEDENCE.MEMBER_ACCESS,
-@@ -350,20 +322,23 @@ module.exports = grammar({
+@@ -350,20 +327,23 @@ module.exports = grammar({
          )
        ),
  
@@ -199,7 +303,7 @@ index 21c8523..00bf2b1 100644
            ")"
          )
        ),
-@@ -471,16 +446,53 @@ module.exports = grammar({
+@@ -471,16 +451,53 @@ module.exports = grammar({
        ),
  
      lambda_expression: ($) =>
@@ -258,7 +362,7 @@ index 21c8523..00bf2b1 100644
  
      typeof_is_expression: ($) =>
        prec.left(
-@@ -488,7 +500,7 @@ module.exports = grammar({
+@@ -488,7 +505,7 @@ module.exports = grammar({
          seq(
            ci("TypeOf"),
            field("expression", $._expression),
@@ -267,7 +371,7 @@ index 21c8523..00bf2b1 100644
            field("type", $._type)
          )
        ),
-@@ -504,29 +516,12 @@ module.exports = grammar({
+@@ -504,29 +521,12 @@ module.exports = grammar({
              "initializer",
              choice(
                $.object_initializer, 
@@ -298,7 +402,7 @@ index 21c8523..00bf2b1 100644
  
  
      object_initializer: ($) =>
-@@ -551,6 +546,8 @@ module.exports = grammar({
+@@ -551,6 +551,8 @@ module.exports = grammar({
      collection_initializer: ($) =>
        seq(ci("From"), "{", commaSep($._expression), "}"),
  
@@ -307,7 +411,7 @@ index 21c8523..00bf2b1 100644
  
      array_creation_expression: ($) =>
        seq(
-@@ -646,6 +643,9 @@ module.exports = grammar({
+@@ -646,6 +648,9 @@ module.exports = grammar({
        seq(field("object", $._expression), "!", field("member", $.identifier)),
      _literal: ($) =>
        choice(
@@ -317,7 +421,7 @@ index 21c8523..00bf2b1 100644
          $.string_literal,
          $.character_literal,
          $.integer_literal,
-@@ -654,16 +654,49 @@ module.exports = grammar({
+@@ -654,16 +659,49 @@ module.exports = grammar({
          $.nothing_literal,
          $.date_literal
        ),
@@ -371,7 +475,7 @@ index 21c8523..00bf2b1 100644
          )
        ),
      boolean_literal: ($) => choice(ci("True"), ci("False")),
-@@ -672,7 +705,7 @@ module.exports = grammar({
+@@ -672,7 +710,7 @@ module.exports = grammar({
  
      // Names and types
      _name_reference: ($) =>
@@ -380,7 +484,7 @@ index 21c8523..00bf2b1 100644
  
      simple_name: ($) => $.identifier,
  
-@@ -682,7 +715,7 @@ module.exports = grammar({
+@@ -682,7 +720,7 @@ module.exports = grammar({
          seq(
            field("qualifier", $._name_reference),
            ".",
@@ -389,7 +493,7 @@ index 21c8523..00bf2b1 100644
          )
        ),
      global_qualified_name: ($) =>
-@@ -694,6 +727,7 @@ module.exports = grammar({
+@@ -694,6 +732,7 @@ module.exports = grammar({
          $.simple_name,
          $.qualified_name,
          $.generic_name,
@@ -397,7 +501,7 @@ index 21c8523..00bf2b1 100644
          $.predefined_type,
          $.array_type,
          $.tuple_type
-@@ -720,7 +754,8 @@ module.exports = grammar({
+@@ -720,7 +759,8 @@ module.exports = grammar({
        ),
  
      generic_name: ($) => seq(field("name", $.identifier), $.type_argument_list),
@@ -407,7 +511,7 @@ index 21c8523..00bf2b1 100644
      array_type: ($) =>
        seq(field("element_type", $._type), $.array_rank_specifier),
      array_rank_specifier: ($) => seq("(", repeat(","), ")"),
-@@ -742,10 +777,14 @@ module.exports = grammar({
+@@ -742,10 +782,14 @@ module.exports = grammar({
          field("type", $._type)
        ),
  
@@ -426,7 +530,7 @@ index 21c8523..00bf2b1 100644
  
      implements_member_clause: ($) =>
        seq(ci("Implements"), commaSep1($._name_reference)),
-@@ -856,7 +895,7 @@ module.exports = grammar({
+@@ -856,7 +900,7 @@ module.exports = grammar({
  
      enum_member_declaration: ($) =>
        seq(
@@ -435,7 +539,7 @@ index 21c8523..00bf2b1 100644
          field("name", $.identifier),
          optional(seq("=", field("value", $._expression))),
          $._terminator
-@@ -882,6 +921,10 @@ module.exports = grammar({
+@@ -882,6 +926,10 @@ module.exports = grammar({
          prec(10, $.inherits_statement),
          prec(10, $.implements_statement),
          prec(100, $.constructor_declaration),
@@ -446,7 +550,7 @@ index 21c8523..00bf2b1 100644
          // Explicitly add statements that can appear at class level
          prec(200, $.try_statement),      // Very high precedence
          prec(200, $.select_statement),   // Very high precedence
-@@ -936,33 +979,21 @@ module.exports = grammar({
+@@ -936,33 +984,21 @@ module.exports = grammar({
      variable_declarator: ($) =>
        seq(
          field("name", $.identifier),
@@ -483,7 +587,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))),
          commaSep1($.variable_declarator),
          $._terminator
-@@ -970,7 +1001,8 @@ module.exports = grammar({
+@@ -970,7 +1006,8 @@ module.exports = grammar({
  
      field_variable_declarator: ($) =>
        seq(
@@ -493,7 +597,7 @@ index 21c8523..00bf2b1 100644
          optional($.array_rank_specifier),
          optional($.as_clause),
          optional(seq("=", field("initializer", $._expression)))
-@@ -978,12 +1010,13 @@ module.exports = grammar({
+@@ -978,12 +1015,13 @@ module.exports = grammar({
  
      property_declaration: ($) =>
        seq(
@@ -509,7 +613,7 @@ index 21c8523..00bf2b1 100644
          optional($.implements_member_clause),
          optional(seq("=", field("initializer", $._expression))),
          choice(
-@@ -1001,7 +1034,7 @@ module.exports = grammar({
+@@ -1001,7 +1039,7 @@ module.exports = grammar({
  
      property_getter: ($) =>
        seq(
@@ -518,7 +622,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))),
          ci("Get"),
          $._block_terminator,
-@@ -1013,7 +1046,7 @@ module.exports = grammar({
+@@ -1013,7 +1051,7 @@ module.exports = grammar({
  
      property_setter: ($) =>
        seq(
@@ -527,7 +631,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))),
          ci("Set"),
          optional(seq("(", field("parameter", $.parameter), ")")),
-@@ -1028,7 +1061,7 @@ module.exports = grammar({
+@@ -1028,7 +1066,7 @@ module.exports = grammar({
        prec(
          1,
          seq(
@@ -536,7 +640,7 @@ index 21c8523..00bf2b1 100644
            optional(field("modifiers", repeat1($.member_modifier))),
            choice(
              seq(
-@@ -1063,7 +1096,7 @@ module.exports = grammar({
+@@ -1063,7 +1101,7 @@ module.exports = grammar({
        prec(
          100,
          seq(
@@ -545,7 +649,7 @@ index 21c8523..00bf2b1 100644
            optional(field("modifiers", repeat1($.member_modifier))),
            $._sub_new,
            optional(field("parameters", $.parameter_list)),
-@@ -1087,7 +1120,7 @@ module.exports = grammar({
+@@ -1087,7 +1125,7 @@ module.exports = grammar({
  
      event_declaration: ($) =>
        seq(
@@ -554,7 +658,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))), // Changed
          ci("Event"),
          field("name", $.identifier),
-@@ -1098,7 +1131,7 @@ module.exports = grammar({
+@@ -1098,7 +1136,7 @@ module.exports = grammar({
  
      operator_declaration: ($) =>
        seq(
@@ -563,7 +667,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))), // Changed
          ci("Operator"),
          field(
-@@ -1152,7 +1185,7 @@ module.exports = grammar({
+@@ -1152,7 +1190,7 @@ module.exports = grammar({
  
      interface_method_declaration: ($) =>
        seq(
@@ -572,7 +676,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))), // Changed
          choice(ci("Sub"), ci("Function")),
          field("name", $.identifier),
-@@ -1164,7 +1197,7 @@ module.exports = grammar({
+@@ -1164,7 +1202,7 @@ module.exports = grammar({
  
      interface_property_declaration: ($) =>
        seq(
@@ -581,7 +685,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))), // Changed
          ci("Property"),
          field("name", $.identifier),
-@@ -1175,7 +1208,7 @@ module.exports = grammar({
+@@ -1175,7 +1213,7 @@ module.exports = grammar({
  
      interface_event_declaration: ($) =>
        seq(
@@ -590,7 +694,7 @@ index 21c8523..00bf2b1 100644
          optional(field("modifiers", repeat1($.member_modifier))), // Changed
          ci("Event"),
          field("name", $.identifier),
-@@ -1209,7 +1242,7 @@ module.exports = grammar({
+@@ -1209,7 +1247,7 @@ module.exports = grammar({
  
      parameter: ($) =>
        seq(
@@ -599,7 +703,7 @@ index 21c8523..00bf2b1 100644
          optional(
            field(
              "modifiers",
-@@ -1273,7 +1306,7 @@ module.exports = grammar({
+@@ -1273,7 +1311,7 @@ module.exports = grammar({
  
      declaration_statement: ($) =>
        prec(1, seq(  // Add precedence
@@ -608,7 +712,7 @@ index 21c8523..00bf2b1 100644
          field("modifiers", choice(
            $.local_declaration_modifier,
            repeat1($.local_declaration_modifier)
-@@ -1282,6 +1315,65 @@ module.exports = grammar({
+@@ -1282,6 +1320,65 @@ module.exports = grammar({
          $._terminator
        )),
  
@@ -674,7 +778,7 @@ index 21c8523..00bf2b1 100644
      expression_statement: ($) => seq($._expression, $._terminator),
  
      assignment_statement: ($) =>
-@@ -1301,21 +1393,96 @@ module.exports = grammar({
+@@ -1301,21 +1398,96 @@ module.exports = grammar({
            $._terminator
          )
        ),
@@ -775,7 +879,7 @@ index 21c8523..00bf2b1 100644
              $._block_terminator,
              field("then_branch", repeat($._statement)),
              repeat($.elseif_clause),
-@@ -1331,7 +1498,7 @@ module.exports = grammar({
+@@ -1331,7 +1503,7 @@ module.exports = grammar({
        seq(
          ci("ElseIf"),
          field("condition", $._expression),
@@ -784,7 +888,7 @@ index 21c8523..00bf2b1 100644
          $._block_terminator,
          field("body", repeat($._statement))
        ),
-@@ -1445,7 +1612,7 @@ module.exports = grammar({
+@@ -1445,7 +1617,7 @@ module.exports = grammar({
      using_statement: ($) =>
        seq(
          ci("Using"),
@@ -793,7 +897,7 @@ index 21c8523..00bf2b1 100644
          $._block_terminator,
          field("body", repeat($._statement)),
          ci("End"),
-@@ -1590,14 +1757,25 @@ module.exports = grammar({
+@@ -1590,14 +1762,25 @@ module.exports = grammar({
          $._terminator
        ), // LINQ Query expressions
      query_expression: ($) =>
@@ -826,7 +930,7 @@ index 21c8523..00bf2b1 100644
        ),
      query_body_clause: ($) =>
        choice(
-@@ -1606,48 +1784,62 @@ module.exports = grammar({
+@@ -1606,48 +1789,62 @@ module.exports = grammar({
          $.where_clause,
          $.join_clause,
          $.order_by_clause,
@@ -914,7 +1018,7 @@ index 21c8523..00bf2b1 100644
      aggregate_function: ($) =>
        seq(
          field(
-@@ -1668,42 +1860,44 @@ module.exports = grammar({
+@@ -1668,42 +1865,44 @@ module.exports = grammar({
      select_or_group_clause: ($) => choice($.select_clause, $.group_by_clause),
      select_clause: ($) => seq(ci("Select"), commaSep1($.select_element)),
      select_element: ($) =>
@@ -973,7 +1077,7 @@ index 21c8523..00bf2b1 100644
  
      // Comments
      comment: ($) => token(prec(100, choice(
-@@ -1714,7 +1908,7 @@ module.exports = grammar({
+@@ -1714,7 +1913,7 @@ module.exports = grammar({
      ))),
  
      // Preprocessor Directives
diff --git a/docs/viewer-launch-changelog.md b/docs/viewer-launch-changelog.md
index 74687d5929..be57f4842c 100644
--- a/docs/viewer-launch-changelog.md
+++ b/docs/viewer-launch-changelog.md
@@ -5,7 +5,7 @@ These describe `codegraph ui` and its screens. They were taken out of `## [Unrel
 ## Highlights, as written for the viewer launch
 
 - **`codegraph ui` — your graph in a browser.** A local, read-only viewer for the project you already indexed: your code with its callers and callees in the margin, a map of the whole repository, and a strip that shows how one symbol reaches another.
-- **See your app the way its users meet it.** A Screens tab draws every screen and the navigation between them, for Expo Router, React Router, Next.js, TanStack Router, Vue Router / Nuxt and SvelteKit apps.
+- **See your app the way its users meet it.** A Screens tab draws every screen and the navigation between them, for Expo Router, React Router, Next.js, TanStack Router, Vue Router / Nuxt, SvelteKit and Angular apps.
 - **See what happens from a screen or an endpoint.** A Steps tab draws what one action sets in motion — the handlers it fires, the state it writes, the calls that leave your code, and every way it can answer — with the condition on each arrow.
 - **APIs too, and across tiers.** Endpoints in Express, NestJS, Fastify, Koa, Hono, FastAPI, Flask, Django, Spring, ASP.NET, Vapor and Gin, with a page's `fetch` following through to the route that serves it, a queued job to its consumer, an event to its handler.
 - **Read a handler in the order its code runs.** The same picture laid out by when things happen rather than by distance, so a reply sits below the token it carries. Where the code chooses, the condition is said once and each arrow answers it.
@@ -15,6 +15,10 @@ These describe `codegraph ui` and its screens. They were taken out of `## [Unrel
 
 ## New Features
 
+- **The Steps tab draws what an Angular screen does.** Each handler a template binds is drawn with the event that fires it, like `submitForm` on the form's `(ngSubmit)` or `toggleFavorite` on a button's `(click)`, followed by the requests it sends and the screen it opens. That includes handlers in child components the screen renders. Re-index Angular projects after upgrading.
+
+- **The Screens tab draws Angular apps.** Every screen in an Angular app's routes, with the navigation between them: `router.navigate(…)`, a guard's redirect and each template's `routerLink`, under the condition the code checks first. A button in a child component, like an article's favorite button, is drawn from the screen that renders it. A layout's tabs and buttons are drawn from every screen inside that layout. Re-index Angular projects after upgrading.
+
 - **A big screen's picture stops wrapping into a column.** How wide a screen's lines run before they wrap was worked out with a formula, and the formula was wrong for the way these pictures are actually drawn: a part of a screen spends lines on its own structure — a step that fires things gets a line to itself, and what it fires starts another — so estimating the lines from the boxes alone badly undercounted them, and one screen's 98 boxes wrapped into a 4,356px column. Laying a picture out is cheap and exact, so the widths are now simply tried and the one that comes out closest to the shape of a window is kept. Across one app's 51 screens the tallest picture went from 4,356px to 3,796px, total height fell 8%, and — because a shorter picture is also a picture whose lines have less far to go — lines running over other boxes fell by a third and lines crossing each other went from 13 to 5.
 
 - **A screen's picture stops being mostly empty.** The parts of a screen were tiled a row at a time, each row as tall as its tallest member — so one short region beside a tall one left the whole rest of that row blank. Measured across one app: the median screen's canvas was only 55% picture and 45% nothing, and its busiest screen was 44% — 4,860px tall to hold about 2,160px of content, all of which a reader has to scroll through. Each part now goes as high as it can and then as far left as it can, so a short one tucks under another short one instead of waiting for the tall one beside it. Reading order is unchanged: parts are still placed in the screen's own source order, and an earlier one is never pushed below a later one. That screen is now 3,584px instead of 4,860px, and close to square rather than a ribbon.
@@ -121,6 +125,8 @@ These describe `codegraph ui` and its screens. They were taken out of `## [Unrel
 
 ## Fixes — Screens, links and navigation
 
+- **Routes served by a component are listed.** Entry points and the Steps picker listed a route only when a function, method or class served it. A Vue Router, Nuxt, Svelte or Astro screen is served by a component, so those apps' routes weren't listed at all. They are now, each with the component that serves it.
+
 - **Where the app goes after login is a fork, not two always-es.** A navigation whose destination comes back from a helper — `router.replace(await resolvePostLoginRoute())` over `return (await hasSeenWelcome(…)) ? '/home/' : '/welcome/'` — drew both screens with no condition, reading as if the welcome screen always shows. The two arms share a line, and only a column can tell them apart; each synthesized edge now carries its literal's own position, so the guard reader says which arm it is: `WHEN await hasSeenWelcome(…)` → home, and its negation → welcome. And the scan starts at the helper's body, so a literal-union return type — `Promise<'/welcome/' | '/home/'>`, whose routes are string literals too, written first — no longer stands in for the navigation itself. Re-index after upgrading to pick the positions up.
 
 - **A screen that talks to native code keeps its own navigations.** In a React Native or Expo app, a `router.push` written inside a listener for a native event was credited to whichever screen had *started* that round trip, not to the screen the push is written on. In one app that moved seven transitions off the capture screen and onto the review screen it opens — leaving the review screen looking as though nothing in the app could reach it, stranded in the "no transition reaches this" band at the bottom of the Screens tab, and printing Swift conditions like `Thread.isMainThread` on a JavaScript navigation. A navigation now belongs to the screen whose file it is written in; an event arriving from native code, from an HTTP call or off a queue is no longer read backwards as if it were a caller.
@@ -135,8 +141,16 @@ These describe `codegraph ui` and its screens. They were taken out of `## [Unrel
 
 - **A server action written through a wrapper starts its transition on the right page.** `export const signIn = validatedAction(schema, async (data) => { … redirect('/dashboard') })` — the arrow inside is no symbol of its own — now belongs to `signIn` on the Screens tab, and `signIn` is attributed to the page whose component hands it to `useActionState(signIn, …)`, read from the source when the graph holds no such edge.
 
+- **React Router apps that keep their routes in a table get a Screens picture.** The ASP.NET Core React template's `AppRoutes` array, a `routes` array handed to `useRoutes` or `createBrowserRouter` from another file, and admin kits' `[MainRoutes, LoginRoutes]` route objects drew no screens, because their routes were never read. They are now, with the links and `navigate(…)` calls between them. A parent route object's component is drawn as the layout around the screens inside it: its own links count from each of those screens, and when an `index: true` child claims its address, that child is the screen there. Re-index React projects after upgrading.
+
+- **A React Router layout written as JSX is drawn around every screen inside it.** In `<Route path="/" element={<Layout />}><Route index element={<Home />} />…</Route>`, the screen at `/` is Home rather than Layout, and the links in Layout's header count from each screen nested in it instead of only from `/`. A guard with no path of its own, like `<Route element={<PrivateRoute />}>`, does the same for its redirect to the login page. Re-index React projects after upgrading.
+
 ## Fixes — Steps — what a call does, and when
 
+- **A Steps picture with nothing past its anchor says why.** Starting Steps from a helper that only computes drew one box and no explanation. The panel now says that nothing it sets in motion is a step the picture draws, explains that calls between plain functions fold into the lines, and links to the symbol's callers and callees.
+
+- **Steps no longer goes blank on a function full of checks.** Reading a function in its code's order doubled the ways forward at every `if` with no `else`. A body with dozens of checks that draw nothing, like jsoup's `parse`, never finished, and the page died with a stack overflow. Ways that arrive at the same place are now one way, carrying only the conditions they all share.
+
 - **A Swift app's Steps picture labels what a call leaves for correctly.** `rawValue.data(using: .utf8)` was drawn as a network call, Foundation's `Timer` as telemetry, `Calendar` and a SiriKit `intent` as device calls, and `viewModel.votes.firstIndex(of:)` as a database read. Now only a session's `data`, `upload` and `download` are network, `Timer`, `Calendar` and `intent` are no effect at all, a view model is not a table, and a keychain is storage. A call through a type the app declares itself, like IceCubes' `Notifications` endpoint enum, is no longer read as the library of the same name.
 
 - **A server-rendered endpoint's Steps picture shows how it answers.** A Spring MVC handler answers by what it returns: a view name, a constant holding one, `"redirect:/owners/" + id`, a `ModelAndView` or a `RedirectView`. Each is now a reply, a render (`200`) or a redirect (`302`), under the condition it's returned in. petclinic's `POST /owners/new` draws the form re-rendered `WHEN result.hasErrors()` and the redirect otherwise. A Laravel controller's `view(…)`, `redirect(…)`, `redirect()->back()`, `back()`, `to_route(…)` and `response()->json(…)` are replies too, so BookStack's book page draws the page it renders beside its `404` and its old-slug redirect. PHP's own programming-error exceptions (`InvalidArgumentException`, `LogicException`, …) thrown deep in a helper are no longer drawn as one of the endpoint's answers.
@@ -165,6 +179,22 @@ These describe `codegraph ui` and its screens. They were taken out of `## [Unrel
 
 ## Fixes — Symbols, tests and the viewer
 
+- **Dead code no longer lists methods a framework calls for you.** A method with a framework's decorator on it — Angular's `@HostListener` or `@HostBinding`, NestJS's `@Cron`, `@OnEvent` or `@Process`, TypeORM's `@BeforeInsert`, Spring's `@InitBinder` — was listed as unused whenever the decorator came from a package outside your project. So was a lifecycle hook like Angular's `ngOnInit` or NestJS's `onModuleInit` on a class that skips the `implements` clause, though the framework calls it by name all the same. Both are now left off and counted under the list. What counts as a hook is learned from your own classes that do write the interface out, not from a built-in list, so an unused helper on the same component is still listed. Nothing needs a re-index.
+
+- **Dead code no longer lists the types you add to a library's or the browser's.** An interface written inside `declare module 'chart.js' { … }` or `declare global { … }`, like chart.js's `PluginOptionsByType`, TanStack Router's `Register`, the browser's `Window`, or a custom element's entry in `HTMLElementTagNameMap`, merges into a type declared outside your project. The library or the browser reads it from there, so nothing in your code names it, and every one was listed as unused. TypeScript exports what these blocks declare without an `export` keyword, and CodeGraph now records them the same way, so they are left off and counted with the exported symbols. A `declare namespace` in an ordinary module file still belongs to that file and is checked as before. Re-index TypeScript projects after upgrading.
+
+- **One slow file can no longer freeze the viewer.** Code is highlighted with the same grammars the index uses. The COBOL grammar never finishes a line like `    .`, which free-format COBOL paragraphs end with, so opening a Flow through cobolcraft froze `codegraph ui`, and every page after it waited forever. Highlighting now runs where it can be stopped: a piece of code that takes too long is shown unhighlighted, and everything else keeps working.
+
+- **The Map opens on a picture, not a single box.** A project whose code sits in one flat folder, like Express's `lib/`, an R package's `R/`, an Erlang app's `src/` or fmt's `include/fmt/`, opened as one box with nothing to say. It now opens on the whole repository when that draws more. Files at the repository's top level also count when the Map picks where the program lives: git's hundreds of top-level `.c` files had made `builtin/` look like most of the code.
+
+- **A Flow between two symbols finds names of any shape.** A Flow opened from a Steps link, an entry point or the search box names its two ends by the symbols' own names, and names that don't look like plain identifiers were dropped: an Objective-C selector like `initWithFrame:`, a Ruby method like `save!` or `valid?`, and any name shorter than three letters, like `ok`. The strip then said the other end "names nothing in this index", even though it was there. Both ends are now looked up exactly as written.
+
+- **Entry points and the Symbol view no longer go blank.** The Symbol view of every Vue, Svelte and Astro component stayed on "Loading…", because its member list held the component's script symbols twice, along with the component and its file. Entry points went blank on apps with inline route handlers like `app.get('/x', async (c) => { … })`, which came back once per call in the handler, each call listed as if it were the handler. Each member is now listed once, and each route is one row: the handler it is bound to, or "inline handler" when the handler is written at the registration.
+
+- **Entry points' most-depended-on list shows your code, not a vendored bundle's.** A minified library or bundled docs script (`n`, `t`, `Buffer` with thousands of callers, all from inside the bundle) could top the list. Symbols in generated files are now left out of it, like test files.
+
+- **Stopping `codegraph ui` stops the server.** Killing the command by its process id, as a process manager, an editor task or `kill` does, left the server running on its port with no way to reach it, until the machine restarted. The server now notices it has been left behind and shuts down, closing the index first. Ctrl+C was never affected.
+
 - **A SwiftUI view with a preview is no longer listed as a file that runs something.** A `#Preview { … }` sits at the top level of a view's file, so every view with one showed up under entry points as if it ran code. A preview is Xcode's canvas, not code the app runs: its calls no longer count, and a file whose only top-level code is previews leaves the list.
 
 - **The Map opens a Maven or Gradle project on its packages.** A Java project keeps every file under `src/main/java/org/<company>/<app>/`, and those folders hold nothing but the next one, so the Map drew the whole program as one `src/main/java/org` box and no grouping option reached further. A folder with one subfolder and no files of its own no longer counts as a level: petclinic opens on `owner`, `vet`, `model` and `system`, each labelled `src/main/java/…/petclinic/owner`, with the full path on hover.
@@ -183,6 +213,12 @@ These describe `codegraph ui` and its screens. They were taken out of `## [Unrel
 
 - A viewer trail now holds up to 64 hops everywhere — the trail bar, saved trails and "Read as flow". Thanks @inth3shadows for the report and @danusha2345. (#1976)
 
+- **`codegraph ui` on Windows moves on from a port another program holds.** Windows refuses a port that another program keeps for itself, or one inside a range it reserves, with a different error than a port that is simply in use, so the viewer gave up at the first such port instead of trying the next one, and blamed ports below 1024 needing elevated privileges — a rule Windows doesn't have. It now moves on to the next free port, and when none is left, or the port you pinned with `--port` is refused, it says what Windows did and how to list the reserved ranges. Thanks @ijbranch for the report and @sx4im. (#2299)
+
+- **A file's outside imports are listed in more languages.** The file screen lists the imports that name nothing in your project, like a third-party package or a system header. In C and C++, Objective-C, JavaScript and TypeScript, Python, C#, Lua, R, Solidity, Svelte and Vue, an import that named no file had been linked to its own import statement, so it was listed nowhere. Re-index after upgrading.
+
+- **What an Angular template uses is no longer dead code.** A signal, `computed` value, getter or method that a component's template calls from a property binding, an interpolation, a structural directive or a control-flow block — `[name]="icon()"`, `{{ label() }}`, `*matRowDef="let row; columns: displayedColumns()"`, `@if (loading())` — or hands to a child, like `[displayWith]="displayFn"`, now counts as reached, so it leaves the Dead code tab. Steps draws it as part of what the screen renders, not as something the user does. Re-index Angular projects after upgrading.
+
 ## Entries whose graph and `codegraph_explore` half already shipped
 
 The release notes carry a reworded version of each of these. Keep only the viewer half at launch.
diff --git a/install.ps1 b/install.ps1
index 7c0b523caf..a079205b46 100644
--- a/install.ps1
+++ b/install.ps1
@@ -5,7 +5,8 @@
 #
 #   irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex
 #
-# Upgrade with `codegraph upgrade` (or just re-run this). To uninstall: remove
+# Upgrade with `codegraph upgrade` (or just re-run this -- safe even while agent
+# sessions are running CodeGraph). To uninstall: remove
 # $env:LOCALAPPDATA\codegraph and drop its \current\bin entry from your user PATH.
 #
 # Environment:
@@ -13,6 +14,81 @@
 #   CODEGRAPH_INSTALL_DIR  install location (default: %LOCALAPPDATA%\codegraph)
 
 $ErrorActionPreference = 'Stop'
+
+# >>> Install-CodeGraphFiles -- keep identical to WINDOWS_SWAP_FUNCTION in src/upgrade/index.ts
+function Install-CodeGraphFiles([string]$Stage, [string]$Dest) {
+  # Move an unpacked bundle into $Dest. Windows can't overwrite or delete a
+  # running node.exe or a loaded .node addon, but it can rename one, so every
+  # file being replaced (or dropped by the new version) is first renamed aside
+  # to <name>.old-<token>. Any failure puts every file back, so the install is
+  # never left half-replaced or without its node.exe.
+  $ErrorActionPreference = 'Stop'
+  $stageDir = (Resolve-Path -LiteralPath $Stage).ProviderPath.TrimEnd('\')
+  foreach ($need in 'node.exe', 'bin\codegraph.cmd') {
+    if (-not (Test-Path -LiteralPath (Join-Path $stageDir $need))) { throw "The CodeGraph download is incomplete (no $need); nothing was changed." }
+  }
+  $token = [guid]::NewGuid().ToString('N').Substring(0, 8)
+  $asideName = '\.old-[0-9a-f]{8,32}$'
+  $files = @{}; $dirs = @{}
+  foreach ($i in @(Get-ChildItem -LiteralPath $stageDir -Recurse -Force)) {
+    $rel = $i.FullName.Substring($stageDir.Length)
+    if ($i.PSIsContainer) { $dirs[$rel] = $true } else { $files[$rel] = $true }
+  }
+  $undo = New-Object System.Collections.ArrayList
+  function Move-Logged([string]$From, [string]$To) { [IO.File]::Move($From, $To); [void]$undo.Add(@($From, $To)) }
+  function Undo-Logged {
+    $lost = 0
+    for ($n = $undo.Count - 1; $n -ge 0; $n--) {
+      $u = $undo[$n]
+      try { if ($u.Count -eq 2) { [IO.File]::Move($u[1], $u[0]) } else { [IO.Directory]::Delete($u[0]) } } catch { if ($u.Count -eq 2) { $lost++ } }
+    }
+    $undo.Clear()
+    $lost
+  }
+  $done = $false; $at = $Dest
+  try {
+    if (-not (Test-Path -LiteralPath $Dest)) { [void][IO.Directory]::CreateDirectory($Dest); [void]$undo.Add(@($Dest)) }
+    $destDir = (Resolve-Path -LiteralPath $Dest).ProviderPath.TrimEnd('\')
+    foreach ($f in @(Get-ChildItem -LiteralPath $destDir -Recurse -Force -File)) {
+      if (-not $files.ContainsKey($f.FullName.Substring($destDir.Length)) -and $f.Name -notmatch $asideName) {
+        $at = $f.FullName; Move-Logged $at "$at.old-$token"
+      }
+    }
+    foreach ($rel in @($dirs.Keys | Sort-Object Length)) {
+      $at = $destDir + $rel
+      if (-not [IO.Directory]::Exists($at)) { [void][IO.Directory]::CreateDirectory($at); [void]$undo.Add(@($at)) }
+    }
+    foreach ($rel in @($files.Keys)) {
+      $at = $destDir + $rel
+      if ([IO.File]::Exists($at)) { Move-Logged $at "$at.old-$token" }
+      Move-Logged ($stageDir + $rel) $at
+    }
+    $done = $true
+  } catch {
+    $x = $_.Exception; while ($x.InnerException) { $x = $x.InnerException }
+    $lost = Undo-Logged
+    $msg = "Could not replace $at ($($x.Message))."
+    if ($lost) {
+      $msg += " $lost file(s) could not be put back, so the install may not start. Close your agent sessions and any running codegraph commands, then reinstall: irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex"
+    } else {
+      $msg += " Nothing was changed: the existing install still works. If another program has CodeGraph's files open, close your agent sessions (they run the CodeGraph MCP server) and any running codegraph commands, then try again."
+    }
+    $e = New-Object System.Exception($msg); $e.Data['codegraphDamaged'] = [bool]$lost; throw $e
+  } finally {
+    # Interrupted (Ctrl+C) without reaching catch: still put everything back.
+    if (-not $done) { [void](Undo-Logged) }
+  }
+  # Delete what this run and earlier ones renamed aside. A file a running
+  # process still holds can't be deleted yet; the next install retries it.
+  foreach ($f in @(Get-ChildItem -LiteralPath $destDir -Recurse -Force -File -ErrorAction SilentlyContinue)) {
+    if ($f.Name -match $asideName) { try { [IO.File]::Delete($f.FullName) } catch {} }
+  }
+  foreach ($d in @(Get-ChildItem -LiteralPath $destDir -Recurse -Force -Directory -ErrorAction SilentlyContinue | Sort-Object { $_.FullName.Length } -Descending)) {
+    if (-not $dirs.ContainsKey($d.FullName.Substring($destDir.Length))) { try { [IO.Directory]::Delete($d.FullName) } catch {} }
+  }
+}
+# <<< Install-CodeGraphFiles
+
 $repo = 'colbymchenry/codegraph'
 $installDir = if ($env:CODEGRAPH_INSTALL_DIR) { $env:CODEGRAPH_INSTALL_DIR } else { Join-Path $env:LOCALAPPDATA 'codegraph' }
 
@@ -27,25 +103,28 @@ if (-not $version) {
 }
 if (-not $version) { throw "codegraph: could not resolve latest version; set CODEGRAPH_VERSION." }
 
-# 3. Download + extract the bundle into a stable 'current' dir (overwritten on upgrade).
+# 3. Download the bundle and unpack it next to the stable 'current' dir (same
+# volume, so moving it in is renames, not copies), then move it into 'current'.
+# 'current' is never deleted wholesale: a CodeGraph process that is still
+# running (an agent session's MCP server) holds node.exe and the native kernel,
+# which can't be deleted -- Install-CodeGraphFiles renames them aside instead.
 $url = "https://github.com/$repo/releases/download/$version/codegraph-$target.zip"
 Write-Host "Installing CodeGraph $version ($target)..."
 $tmp = Join-Path $env:TEMP ("cg-" + [guid]::NewGuid().ToString())
 New-Item -ItemType Directory -Force -Path $tmp | Out-Null
 $zip = Join-Path $tmp 'cg.zip'
-Invoke-WebRequest -Uri $url -OutFile $zip
-
 $dest = Join-Path $installDir 'current'
-if (Test-Path $dest) { Remove-Item -Recurse -Force $dest }
-New-Item -ItemType Directory -Force -Path $dest | Out-Null
-Expand-Archive -Path $zip -DestinationPath $dest -Force
-# Archives contain a top-level codegraph-<target>\ dir; flatten it.
-$inner = Join-Path $dest "codegraph-$target"
-if (Test-Path $inner) {
-  Get-ChildItem -Force $inner | Move-Item -Destination $dest -Force
-  Remove-Item -Recurse -Force $inner
+$stage = Join-Path $installDir ('.staging-' + [guid]::NewGuid().ToString('N').Substring(0, 8))
+try {
+  Invoke-WebRequest -Uri $url -OutFile $zip
+  New-Item -ItemType Directory -Force -Path $stage | Out-Null
+  Expand-Archive -Path $zip -DestinationPath $stage -Force
+  # Archives contain a top-level codegraph-<target>\ dir.
+  $inner = Join-Path $stage "codegraph-$target"
+  Install-CodeGraphFiles $(if (Test-Path $inner) { $inner } else { $stage }) $dest
+} finally {
+  Remove-Item -LiteralPath $stage, $tmp -Recurse -Force -ErrorAction SilentlyContinue
 }
-Remove-Item -Recurse -Force $tmp
 
 # 4. Put the launcher dir on the user's PATH.
 $binDir = Join-Path $dest 'bin'
diff --git a/package-lock.json b/package-lock.json
index bdc0bdffa8..c0de86886b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@colbymchenry/codegraph",
-      "version": "1.6.1",
+      "version": "1.6.2",
       "license": "MIT",
       "workspaces": [
         "ui"
@@ -3863,7 +3863,7 @@
     },
     "ui": {
       "name": "@colbymchenry/codegraph-ui",
-      "version": "1.6.1",
+      "version": "1.6.2",
       "license": "MIT",
       "dependencies": {
         "@antv/g6": "5.1.1",
diff --git a/package.json b/package.json
index 92d1aa6c7f..ab8ba5cca6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Supercharge AI coding agents with semantic code intelligence — surgical context, fewer tool calls, faster answers. 100% local.",
   "repository": {
     "type": "git",
diff --git a/scripts/kernel-parity.mjs b/scripts/kernel-parity.mjs
index db7cfa04c1..98c347eefd 100644
--- a/scripts/kernel-parity.mjs
+++ b/scripts/kernel-parity.mjs
@@ -25,7 +25,7 @@
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const dist = (p) => path.join(ROOT, 'dist', p);
@@ -88,9 +88,12 @@ function collect(p, out) {
     const lang = EXTS.get(path.extname(p).toLowerCase());
     // 'detect' (.h) resolves per file in the run loop; under --lang it rides
     // along whenever either C-family language is requested.
+    // A Flow-typed `.js` routes as tsx (detectLanguage reads its pragma), so
+    // it rides along when tsx is requested and is re-detected per file below.
     const passes =
       !langFilter ||
-      (lang === 'detect' ? langFilter.has('c') || langFilter.has('cpp') : langFilter.has(lang));
+      (lang === 'detect' ? langFilter.has('c') || langFilter.has('cpp') : langFilter.has(lang)) ||
+      ((lang === 'javascript' || lang === 'jsx') && langFilter.has('tsx'));
     if (passes) out.push({ file: p, lang });
   }
 }
@@ -103,9 +106,11 @@ if (files.length === 0) {
 }
 
 // --- load the built engine ---------------------------------------------------
-const { extractFromSource } = await import(dist('extraction/tree-sitter.js'));
-const { initGrammars, loadGrammarsForLanguages, detectLanguage } = await import(dist('extraction/grammars.js'));
-const kernel = await import(dist('extraction/kernel/index.js'));
+// As file:// URLs: import() rejects a bare `C:\...` path on Windows
+// (ERR_UNSUPPORTED_ESM_URL_SCHEME).
+const { extractFromSource } = await import(pathToFileURL(dist('extraction/tree-sitter.js')).href);
+const { initGrammars, loadGrammarsForLanguages, detectLanguage } = await import(pathToFileURL(dist('extraction/grammars.js')).href);
+const kernel = await import(pathToFileURL(dist('extraction/kernel/index.js')).href);
 
 await initGrammars();
 await loadGrammarsForLanguages([...KERNEL_LANGS]);
@@ -195,8 +200,12 @@ process.env.CODEGRAPH_KERNEL_LANGS = 'all';
 for (const { file, lang: extLang } of files) {
   const source = fs.readFileSync(file, 'utf8');
   const rel = path.relative(ROOT, file);
-  // `.h` resolves C vs C++ by content — the same call the indexer makes.
-  const lang = extLang === 'detect' ? detectLanguage(rel, source) : extLang;
+  // `.h` resolves C vs C++ by content — the same call the indexer makes; so
+  // does `.inc` (PHP vs Pascal, #2279 — a Pascal include is not a kernel file).
+  const lang =
+    extLang === 'detect' || extLang === 'javascript' || extLang === 'jsx' || path.extname(file).toLowerCase() === '.inc'
+      ? detectLanguage(rel, source)
+      : extLang;
   if (!KERNEL_LANGS.has(lang)) continue;
   if (langFilter && !langFilter.has(lang)) continue;
   processed++;
diff --git a/src/bin/codegraph.ts b/src/bin/codegraph.ts
index 730fc06461..c05a37f816 100644
--- a/src/bin/codegraph.ts
+++ b/src/bin/codegraph.ts
@@ -53,7 +53,7 @@ try {
 import { Command } from 'commander';
 import * as path from 'path';
 import * as fs from 'fs';
-import { getCodeGraphDir, isInitialized, hasSchemalessDb, hasForeignDbFile, unsafeIndexRootReason, findNearestCodeGraphRoot, planFrontload, isTaskNotification, hasStructuralKeyword, extractCodeTokens, capPromptHookInjection, codeGraphDirName, DEFAULT_CODEGRAPH_DIR } from '../directory';
+import { getCodeGraphDir, isInitialized, hasSchemalessDb, hasForeignDbFile, unsafeIndexRootReason, findNearestCodeGraphRoot, planFrontload, isTaskNotification, isAgentMessage, hasStructuralKeyword, extractCodeTokens, capPromptHookInjection, codeGraphDirName, DEFAULT_CODEGRAPH_DIR } from '../directory';
 import { extractProseCandidates } from '../search/identifier-segments';
 import { detectWorktreeIndexMismatch, worktreeMismatchWarning } from '../sync/worktree';
 import { createShimmerProgress } from '../ui/shimmer-progress';
@@ -63,7 +63,7 @@ import { ansiColorsEnabled } from '../ui/color';
 import { buildNode25BlockBanner, buildNodeTooOldBanner, MIN_NODE_MAJOR } from './node-version-check';
 import { installFatalHandlers } from './fatal-handler';
 import { relaunchWithWasmRuntimeFlagsIfNeeded } from '../extraction/wasm-runtime-flags';
-import { installCommandSupervision } from './command-supervision';
+import { installCommandSupervision, watchParent } from './command-supervision';
 import { EXTRACTION_VERSION } from '../extraction/extraction-version';
 import { getTelemetry, TELEMETRY_DOCS, recordIndexEvent } from '../telemetry';
 // Value import, but dependency-free by design so `--help` text can name the
@@ -1056,6 +1056,33 @@ program
     }
   });
 
+/**
+ * The `status` warnings for indexed files whose symbols are missing although
+ * their content is current (#2335, #2336): one line per group, saying what is
+ * wrong, what to do, and naming up to three of the files.
+ */
+function describeFilesMissingSymbols(health: { needsReindex: string[]; parseErrors: string[] }): string[] {
+  const dash = getGlyphs().dash;
+  const sample = (paths: string[]): string =>
+    paths.slice(0, 3).join(', ') + (paths.length > 3 ? ` (+${formatNumber(paths.length - 3)} more)` : '');
+  const lines: string[] = [];
+  const reindex = health.needsReindex.length;
+  if (reindex > 0) {
+    lines.push(
+      `${formatNumber(reindex)} ${reindex === 1 ? 'file is missing its' : 'files are missing their'} symbols ${dash} ` +
+      `run "codegraph sync" to re-index ${reindex === 1 ? 'it' : 'them'}: ${sample(health.needsReindex)}`
+    );
+  }
+  const unparsed = health.parseErrors.length;
+  if (unparsed > 0) {
+    lines.push(
+      `${formatNumber(unparsed)} ${unparsed === 1 ? 'file could not be parsed, so its symbols are' : 'files could not be parsed, so their symbols are'} ` +
+      `missing: ${sample(health.parseErrors)} ${dash} "codegraph files --json" shows the errors`
+    );
+  }
+  return lines;
+}
+
 /**
  * codegraph status [path]
  */
@@ -1103,6 +1130,9 @@ program
       // Zero on a healthy index; non-zero at rest means a resolution pass was
       // interrupted, so some files' call edges are missing (#1187).
       const pendingRefs = cg.getPendingReferenceCount();
+      // Files whose content is current but whose symbols are missing — the
+      // content-hash check behind "up to date" cannot see them (#2336).
+      const health = cg.getIndexHealth();
 
       // JSON output mode
       if (options.json) {
@@ -1143,6 +1173,12 @@ program
             // interrupted resolution pass left edges missing; the next
             // sync sweeps them (#1187).
             pendingRefs,
+            // Files stored without their symbols (e.g. while their grammar
+            // could not load, #2335); the next sync re-indexes them.
+            filesNeedingReindex: health.needsReindex.length,
+            // Files with a recorded parse error and no symbols from it
+            // (#2336); unchanged until the file or the parser changes.
+            filesWithParseErrors: health.parseErrors.length,
           },
         }));
         cg.destroy();
@@ -1235,7 +1271,10 @@ program
           console.log(`  Removed:   ${changes.removed.length} files`);
         }
         info('Run "codegraph sync" to update the index');
-      } else {
+      }
+      const missingSymbols = describeFilesMissingSymbols(health);
+      for (const line of missingSymbols) warn(line);
+      if (totalChanges === 0 && missingSymbols.length === 0) {
         success('Index is up to date');
       }
       console.log();
@@ -1473,9 +1512,10 @@ program
       let input: { prompt?: string; cwd?: string } = {};
       try { input = JSON.parse(raw); } catch { return; }
       const prompt = String(input.prompt || '');
-      // System-injected task notifications are not user prompts: exit before
-      // any project lookup or explore work (#1832).
-      if (isTaskNotification(prompt)) return;
+      // System-injected task notifications and subagent hand-backs are not
+      // user prompts: exit before any project lookup or explore work (#1832,
+      // #2184).
+      if (isTaskNotification(prompt) || isAgentMessage(prompt)) return;
 
       // Gate telemetry: how often each tier fires vs. no-ops — counter names
       // only, NEVER prompt content (see TELEMETRY.md). This is the data that
@@ -1750,6 +1790,14 @@ program
           language: f.language,
           nodeCount: f.nodeCount,
           size: f.size,
+          // What extraction recorded for the file — a parse error, a skip
+          // reason — so a health check needn't read the database (#2336).
+          errors: (f.errors ?? []).map((e) => ({
+            severity: e.severity,
+            code: e.code,
+            message: e.message,
+            line: e.line,
+          })),
         }));
         console.log(JSON.stringify(output, null, 2));
         cg.destroy();
@@ -2142,6 +2190,10 @@ ${BROWSER_ENV}=none to never open one.
     };
     process.once('SIGINT', shutdown);
     process.once('SIGTERM', shutdown);
+    // Killing the command the user started (its pid, not Ctrl+C's process
+    // group) leaves this re-exec'd server with no parent to forward the
+    // signal: shut down the same way instead of serving the port forever.
+    watchParent(shutdown);
   });
 
 /**
@@ -2856,6 +2908,7 @@ program
         run: up.defaultRun,
         capture: up.defaultCapture,
         hasCommand: up.hasCommand,
+        wirePromptHook: up.defaultWirePromptHook,
         log: (m: string) => console.log(m),
         warn: (m: string) => warn(m),
         error: (m: string) => error(m),
diff --git a/src/bin/command-supervision.ts b/src/bin/command-supervision.ts
index 6031a49991..a55bbffb14 100644
--- a/src/bin/command-supervision.ts
+++ b/src/bin/command-supervision.ts
@@ -59,38 +59,50 @@ export function installCommandSupervision(label: string, watchdog: WatchdogOptio
 
   // PPID watchdog: detect that the parent (or the host threaded past the
   // relaunch shim) died and we've been orphaned, then exit instead of leaking.
-  // Baseline from the CLI entry's earliest-possible capture — reading
-  // process.ppid here would miss a launcher killed during startup (#1185).
-  const originalPpid = EARLY_PPID;
-  const hostPpid = parseHostPpid(process.env[HOST_PPID_ENV]);
-  const pollMs = parsePpidPollMs(process.env.CODEGRAPH_PPID_POLL_MS);
-  let ppidTimer: ReturnType<typeof setInterval> | null = null;
-  if (pollMs > 0) {
-    ppidTimer = setInterval(() => {
-      const reason = supervisionLostReason({
-        originalPpid,
-        currentPpid: process.ppid,
-        hostPpid,
-        isAlive: isProcessAlive,
-      });
-      if (reason) {
-        try {
-          process.stderr.write(`[CodeGraph ${label}] Parent process exited (${reason}); aborting.\n`);
-        } catch { /* stderr gone with the parent — exit anyway */ }
-        process.exit(1);
-      }
-    }, pollMs);
-    // Never let the watchdog itself keep the process alive past its real work.
-    ppidTimer.unref();
-  }
+  const stopParentWatch = watchParent((reason) => {
+    try {
+      process.stderr.write(`[CodeGraph ${label}] Parent process exited (${reason}); aborting.\n`);
+    } catch { /* stderr gone with the parent — exit anyway */ }
+    process.exit(1);
+  });
 
   let stopped = false;
   return {
     stop(): void {
       if (stopped) return;
       stopped = true;
-      if (ppidTimer) clearInterval(ppidTimer);
+      stopParentWatch();
       liveness?.stop();
     },
   };
 }
+
+/**
+ * Call `onLost` once, when the parent — or the host threaded past the
+ * relaunch shim — goes away. The shim blocks in `spawnSync` and cannot forward
+ * a signal, so this is how a re-exec'd child learns it was orphaned. Returns a
+ * stop function. `CODEGRAPH_PPID_POLL_MS=0` disables it.
+ */
+export function watchParent(onLost: (reason: string) => void): () => void {
+  // Baseline from the CLI entry's earliest-possible capture — reading
+  // process.ppid here would miss a launcher killed during startup (#1185).
+  const originalPpid = EARLY_PPID;
+  const hostPpid = parseHostPpid(process.env[HOST_PPID_ENV]);
+  const pollMs = parsePpidPollMs(process.env.CODEGRAPH_PPID_POLL_MS);
+  if (pollMs <= 0) return () => {};
+  const timer = setInterval(() => {
+    const reason = supervisionLostReason({
+      originalPpid,
+      currentPpid: process.ppid,
+      hostPpid,
+      isAlive: isProcessAlive,
+    });
+    if (reason) {
+      clearInterval(timer);
+      onLost(reason);
+    }
+  }, pollMs);
+  // Never let the watchdog itself keep the process alive past its real work.
+  timer.unref();
+  return () => clearInterval(timer);
+}
diff --git a/src/context/index.ts b/src/context/index.ts
index 6cea28c2d1..acf1cf5c35 100644
--- a/src/context/index.ts
+++ b/src/context/index.ts
@@ -27,6 +27,14 @@ import { logDebug } from '../errors';
 import { validatePathWithinRoot, isConfigLeafNode } from '../utils';
 import { isTestFile, extractSearchTerms, scorePathRelevance, getStemVariants, isDistinctiveIdentifier } from '../search/query-utils';
 import { LOW_CONFIDENCE_MARKER } from './markers';
+import { findNamedCopybooks, isCopybookInclude } from '../graph/cobol-copybooks';
+
+/**
+ * Most top-level declarations of one copybook that become entry points — its
+ * record layouts, or the first paragraphs of a procedure copybook. The rest of
+ * the copybook is one hop away (explore pins the whole file).
+ */
+const MAX_COPYBOOK_DECLARATION_ENTRIES = 3;
 
 /**
  * Extract likely symbol names from a natural language query
@@ -619,13 +627,32 @@ export class ContextBuilder {
       }
     }
 
+    // Step 2d: COBOL copybook members (#2342). `COPY CVACT01Y` / `EXEC SQL
+    // INCLUDE MYCOPYBOOK` are `import` nodes, which the default kind filter
+    // drops — so a query naming a copybook found nothing at all, though the
+    // include statement and the copybook are exactly what it asks for. Gathered
+    // apart from the kind-filtered channels and admitted ahead of them below,
+    // like an exact filename. Honors an explicit kind filter that leaves
+    // imports out.
+    const allowsIncludes = options.nodeKinds === undefined
+      || options.nodeKinds.length === 0
+      || options.nodeKinds.includes('import');
+    const copybooks = allowsIncludes
+      ? this.findCopybookEntries(query)
+      : { entries: [], members: new Set<string>() };
+
     // Step 3: Run text search for natural language term matching
     // This catches file-name and node-name matches that semantic search may miss,
     // which is critical for template-heavy codebases (e.g., Liquid/Shopify themes)
     // where file names are the primary identifiers.
     let textResults: SearchResult[] = [];
     try {
-      const searchTerms = extractSearchTerms(query);
+      // A copybook member Step 2d resolved is not searched again as text: its
+      // only FTS hits are the import nodes this channel excludes, so the search
+      // fell through to the fuzzy fallback and returned whatever program name
+      // sat within edit distance (`CVACT01Y` → `CBACT01C`).
+      const searchTerms = extractSearchTerms(query)
+        .filter((term) => !copybooks.members.has(term.toUpperCase()));
       if (searchTerms.length > 0) {
         // Search each term individually to get broader coverage,
         // then boost results that match multiple terms
@@ -1026,6 +1053,30 @@ export class ContextBuilder {
       ];
     }
 
+    // A named copybook leads too: its own declarations, then its include
+    // statements. When the query also matched other things, the copybook takes
+    // at most half the entry slots so they are not capped away.
+    const copybookIds = new Set(copybooks.entries.map((r) => r.node.id));
+    const leafEntryIds = new Set<string>();
+    if (copybooks.entries.length > 0) {
+      const matchedElsewhere = new Set(filteredResults.map((r) => r.node.id));
+      const others = filteredResults.filter((r) => !copybookIds.has(r.node.id));
+      // Include statements in a file the rest of the query also matched come
+      // first ("COACTUPC CVACT01Y" wants COACTUPC's COPY, not the first one by
+      // path). Stable, so the declarations stay ahead of every include.
+      const otherFiles = new Set(others.map((r) => r.node.filePath));
+      const rank = (r: SearchResult): number =>
+        !isCopybookInclude(r.node) ? 0 : otherFiles.has(r.node.filePath) ? 1 : 2;
+      const ordered = [...copybooks.entries].sort((a, b) => rank(a) - rank(b));
+      const kept = others.length > 0 ? ordered.slice(0, Math.ceil(opts.searchLimit / 2)) : ordered;
+      // The copybook's own entries are not walked: an include statement has
+      // nothing to walk but the program around it, and a record layout's
+      // neighbourhood is whichever program happens to MOVE into it — walking
+      // either spent the answer on unrelated paragraphs of an including program.
+      for (const r of kept) if (!matchedElsewhere.has(r.node.id)) leafEntryIds.add(r.node.id);
+      filteredResults = [...kept, ...others];
+    }
+
     // Cap entry points so traversal budget isn't spread too thin.
     // With 36 entry points and maxNodes=120, each gets only 3 nodes — useless.
     // Cap to searchLimit so each entry point gets a meaningful traversal budget.
@@ -1048,6 +1099,8 @@ export class ContextBuilder {
         symbolsFromQuery.filter(isDistinctiveIdentifier).map(s => s.toLowerCase())
       );
       const anyStrong = filteredResults.some(r => {
+        // A copybook the query named is an exact identifier match, not prose.
+        if (copybookIds.has(r.node.id)) return true;
         if (distinctive.has(r.node.name.toLowerCase())) return true;
         const nameLower = r.node.name.toLowerCase();
         const dirSegs = path.dirname(r.node.filePath).toLowerCase().split('/');
@@ -1127,6 +1180,7 @@ export class ContextBuilder {
 
     // Traverse from each entry point
     for (const result of filteredResults) {
+      if (leafEntryIds.has(result.node.id)) continue;
       const traversalResult = this.traverser.traverseBFS(result.node.id, {
         maxDepth: opts.traversalDepth,
         edgeKinds: opts.edgeKinds && opts.edgeKinds.length > 0 ? opts.edgeKinds : undefined,
@@ -1272,6 +1326,45 @@ export class ContextBuilder {
     return { nodes: finalNodes, edges: finalEdges, roots, confidence };
   }
 
+  /**
+   * Entry points for the COBOL copybooks a query names (#2342): each indexed
+   * copybook's top-level declarations (its record layouts, or the paragraphs
+   * of a procedure copybook), then the include statements themselves — taken
+   * round-robin across the named members, so one widely-included copybook
+   * cannot crowd out another the query also names. `members` holds the
+   * matched member names, upper-cased. Both are empty when the query names no
+   * copybook, which is every query on a project without COBOL.
+   */
+  private findCopybookEntries(query: string): { entries: SearchResult[]; members: Set<string> } {
+    const named = findNamedCopybooks(this.queries, query);
+    const members = new Set(named.map((c) => c.member.toUpperCase()));
+    const entries: SearchResult[] = [];
+    const seen = new Set<string>();
+    const add = (node: Node): void => {
+      if (seen.has(node.id)) return;
+      seen.add(node.id);
+      entries.push({ node, score: 1 });
+    };
+    for (const copybook of named) {
+      for (const file of copybook.files) {
+        const declarationIds = this.queries.getOutgoingEdges(file.id, ['contains']).map((e) => e.target);
+        [...this.queries.getNodesByIds(declarationIds).values()]
+          .filter((n) => n.kind !== 'import' && n.kind !== 'export')
+          .sort((a, b) => a.startLine - b.startLine || a.id.localeCompare(b.id))
+          .slice(0, MAX_COPYBOOK_DECLARATION_ENTRIES)
+          .forEach(add);
+      }
+    }
+    const longest = Math.max(0, ...named.map((c) => c.includes.length));
+    for (let i = 0; i < longest; i++) {
+      for (const copybook of named) {
+        const include = copybook.includes[i];
+        if (include) add(include);
+      }
+    }
+    return { entries, members };
+  }
+
   /**
    * Get the source code for a node
    *
diff --git a/src/db/index.ts b/src/db/index.ts
index cfe7c10a72..3e360782d4 100644
--- a/src/db/index.ts
+++ b/src/db/index.ts
@@ -186,7 +186,9 @@ export class DatabaseConnection {
     if (options.readOnly) return conn;
     const currentVersion = getCurrentVersion(db);
 
-    if (currentVersion < CURRENT_SCHEMA_VERSION) {
+    // A current upstream database can still lack fork-only cursor indexes.
+    // Read-only connections returned above; never repair a newer schema here.
+    if (currentVersion <= CURRENT_SCHEMA_VERSION) {
       runMigrations(db, currentVersion);
     }
 
diff --git a/src/db/migrations.ts b/src/db/migrations.ts
index 8cb733e1e2..b9c3a25a08 100644
--- a/src/db/migrations.ts
+++ b/src/db/migrations.ts
@@ -5,11 +5,13 @@
  */
 
 import { SqliteDatabase } from './sqlite-adapter';
+import { referenceNameTail } from './reference-tail';
+import { repairPinableSchema } from './pinable-schema';
 
 /**
  * Current schema version
  */
-export const CURRENT_SCHEMA_VERSION = 12;
+export const CURRENT_SCHEMA_VERSION = 15;
 
 /**
  * Migration definition
@@ -20,28 +22,6 @@ interface Migration {
   up: (db: SqliteDatabase) => void;
 }
 
-/** Shared repair for upstream v10 and the fork that already used that version. */
-function migrateSynthesisInputs(db: SqliteDatabase): void {
-  db.exec(`
-    DROP INDEX IF EXISTS idx_nodes_kind;
-    CREATE INDEX idx_nodes_kind ON nodes(kind, file_path, start_line, id);
-    CREATE TABLE IF NOT EXISTS synthesis_inputs (
-      file_path TEXT PRIMARY KEY REFERENCES files(path) ON DELETE CASCADE
-    );
-    CREATE INDEX IF NOT EXISTS idx_edges_synthesis_site ON edges(CASE WHEN json_valid(metadata) THEN json_extract(metadata, '$.registeredAt') END)
-      WHERE CASE WHEN json_valid(metadata) THEN json_extract(metadata, '$.synthesizedBy') END IS NOT NULL;
-    UPDATE edges SET metadata = json_set(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy', 'go-method-contains')
-      WHERE kind = 'contains' AND provenance IS NULL AND EXISTS (
-        SELECT 1 FROM nodes s JOIN nodes t ON t.id = edges.target
-        WHERE s.id = edges.source AND s.language = 'go' AND t.language = 'go'
-          AND s.kind IN ('struct', 'class', 'interface', 'enum', 'type_alias') AND t.kind = 'method'
-          AND s.file_path != t.file_path
-      );
-    INSERT OR REPLACE INTO project_metadata(key, value, updated_at)
-      VALUES ('synthesis_pending', '1', 0);
-  `);
-}
-
 /**
  * All migrations in order
  *
@@ -202,7 +182,26 @@ const migrations: Migration[] = [
   {
     version: 10,
     description: 'Track synthesis inputs and stabilize synthesis traversal for incremental refresh (#1988)',
-    up: migrateSynthesisInputs,
+    up: (db) => {
+      db.exec(`
+        DROP INDEX IF EXISTS idx_nodes_kind;
+        CREATE INDEX idx_nodes_kind ON nodes(kind, file_path, start_line, id);
+        CREATE TABLE IF NOT EXISTS synthesis_inputs (
+          file_path TEXT PRIMARY KEY REFERENCES files(path) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_edges_synthesis_site ON edges(CASE WHEN json_valid(metadata) THEN json_extract(metadata, '$.registeredAt') END)
+          WHERE CASE WHEN json_valid(metadata) THEN json_extract(metadata, '$.synthesizedBy') END IS NOT NULL;
+        UPDATE edges SET metadata = json_set(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy', 'go-method-contains')
+          WHERE kind = 'contains' AND provenance IS NULL AND EXISTS (
+            SELECT 1 FROM nodes s JOIN nodes t ON t.id = edges.target
+            WHERE s.id = edges.source AND s.language = 'go' AND t.language = 'go'
+              AND s.kind IN ('struct', 'class', 'interface', 'enum', 'type_alias') AND t.kind = 'method'
+              AND s.file_path != t.file_path
+          );
+        INSERT OR REPLACE INTO project_metadata(key, value, updated_at)
+          VALUES ('synthesis_pending', '1', 0);
+      `);
+    },
   },
   {
     version: 11,
@@ -221,19 +220,83 @@ const migrations: Migration[] = [
   },
   {
     version: 12,
-    description: 'Reconcile legacy Pinable v10 and retain workbench cursor indexes',
+    description: 'Retry a failed import when sync adds the file it names: path tails and failed-import indexes',
     up: (db) => {
-      // Pinable used v10 for pagination before upstream assigned v10 to
-      // synthesis. Its recorded version therefore skips upstream's v10.
-      // Inspect the schema rather than changing an already-applied history row.
-      const hasSynthesisInputs = db.prepare(
-        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'synthesis_inputs'"
-      ).get();
-      if (!hasSynthesisInputs) migrateSynthesisInputs(db);
+      // Partial over failed imports, so both stay small. Keep the definitions
+      // in lockstep with schema.sql.
       db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_edges_source_id ON edges(source, id);
-        CREATE INDEX IF NOT EXISTS idx_edges_target_id ON edges(target, id);
-        CREATE INDEX IF NOT EXISTS idx_nodes_file_id ON nodes(file_path, id);
+        CREATE INDEX IF NOT EXISTS idx_unresolved_failed_import_tail ON unresolved_refs(reference_kind, name_tail) WHERE status = 'failed' AND reference_kind = 'imports';
+        CREATE INDEX IF NOT EXISTS idx_unresolved_failed_import_name ON unresolved_refs(reference_kind, reference_name) WHERE status = 'failed' AND reference_kind = 'imports';
+      `);
+      // A path import parked before this version carries its dotted tail —
+      // the extension or a path fragment — which no file's keys match.
+      // Rewrite it to the path tail a failed import is parked under now.
+      // Idempotent: a rewritten tail rewrites to itself.
+      const update = db.prepare('UPDATE unresolved_refs SET name_tail = ? WHERE id = ?');
+      const rows = db
+        .prepare("SELECT id, reference_name FROM unresolved_refs WHERE status = 'failed' AND reference_kind = 'imports' AND reference_name LIKE '%/%'")
+        .all() as Array<{ id: number; reference_name: string }>;
+      for (const row of rows) update.run(referenceNameTail(row.reference_name, 'imports'), row.id);
+    },
+  },
+  {
+    version: 13,
+    description: 'Retry a failed path reference when sync adds the file it names: file-name tails',
+    up: (db) => {
+      // A path reference parked before this version — a Liquid
+      // `snippets/price.liquid` — carries its extension as its tail, which no
+      // node is named. Rewrite it to the file name a failed path reference is
+      // parked under now. Idempotent: a rewritten tail rewrites to itself.
+      const update = db.prepare('UPDATE unresolved_refs SET name_tail = ? WHERE id = ?');
+      const rows = db
+        .prepare("SELECT id, reference_name, name_tail FROM unresolved_refs WHERE status = 'failed' AND reference_kind = 'references' AND reference_name LIKE '%/%.%'")
+        .all() as Array<{ id: number; reference_name: string; name_tail: string }>;
+      for (const row of rows) {
+        const tail = referenceNameTail(row.reference_name, 'references');
+        if (tail !== row.name_tail) update.run(tail, row.id);
+      }
+    },
+  },
+  {
+    version: 14,
+    description: 'Retry a failed route module reference when sync adds or changes its file: module tails',
+    up: (db) => {
+      // A route's reference to the module it lazily loads, parked before this
+      // version — React Router's `lazy-import:./pages/Team`, Vue Router's and
+      // Angular's `import:./home/home.component#HomeComponent`, each also
+      // behind `layout:` — carries a fragment of its path as its tail
+      // ('/pages/Team', 'component#HomeComponent'), which no file's keys
+      // match. Rewrite it to the module tail it is parked under now.
+      // Idempotent: a rewritten tail rewrites to itself.
+      //
+      // Each prefix is a range of idx_unresolved_name. The `+` keeps the
+      // planner off idx_unresolved_status, which it otherwise picks although
+      // 'failed' is nearly every row: on vscode's index that read 830K rows,
+      // about a second, to select none.
+      const update = db.prepare('UPDATE unresolved_refs SET name_tail = ? WHERE id = ?');
+      const rows = db
+        .prepare(`SELECT id, reference_name, reference_kind, name_tail FROM unresolved_refs
+          WHERE (reference_name GLOB 'lazy-import:*' OR reference_name GLOB 'import:*' OR reference_name GLOB 'layout:*')
+            AND +status = 'failed' AND +reference_kind IN ('references', 'calls')`)
+        .all() as Array<{ id: number; reference_name: string; reference_kind: string; name_tail: string }>;
+      for (const row of rows) {
+        const tail = referenceNameTail(row.reference_name, row.reference_kind);
+        if (tail !== row.name_tail) update.run(tail, row.id);
+      }
+    },
+  },
+  {
+    version: 15,
+    description: 'Retry a failed reference through an import binding by its whole name: module-tail name index',
+    up: (db) => {
+      // A failed reference through an import binding the module declares
+      // under another name is parked under the module's key from this
+      // version on, and still looked up by its whole name. Rows parked before
+      // keep the tail their name gives, which the name lookup already finds;
+      // a re-index parks them under their modules. Keep the definition in
+      // lockstep with schema.sql.
+      db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_unresolved_failed_module_name ON unresolved_refs(status, reference_name) WHERE status = 'failed' AND name_tail GLOB 'module:*';
       `);
     },
   },
@@ -267,6 +330,16 @@ function recordMigration(db: SqliteDatabase, version: number, description: strin
  * Run all pending migrations
  */
 export function runMigrations(db: SqliteDatabase, fromVersion: number): void {
+  // Fork repairs inspect schema features rather than consuming upstream version
+  // numbers. Existing Pinable v10/v12 history rows must stay intact.
+  if (fromVersion <= CURRENT_SCHEMA_VERSION) {
+    repairPinableSchema(db, fromVersion, (version) => {
+      const migration = migrations.find((item) => item.version === version);
+      if (!migration) throw new Error(`Missing upstream migration ${version} for Pinable repair`);
+      migration.up(db);
+    });
+  }
+
   const pending = migrations.filter((m) => m.version > fromVersion);
 
   if (pending.length === 0) {
diff --git a/src/db/pinable-schema.ts b/src/db/pinable-schema.ts
new file mode 100644
index 0000000000..19be2b16f8
--- /dev/null
+++ b/src/db/pinable-schema.ts
@@ -0,0 +1,50 @@
+import type { SqliteDatabase } from './sqlite-adapter';
+
+// Fork-only schema additions must not allocate another upstream migration
+// number. These feature guards also handle databases created by upstream at
+// the current version, where there is no pending numbered migration to run.
+const cursorIndexes = {
+  idx_edges_source_id: 'CREATE INDEX IF NOT EXISTS idx_edges_source_id ON edges(source, id)',
+  idx_edges_target_id: 'CREATE INDEX IF NOT EXISTS idx_edges_target_id ON edges(target, id)',
+  idx_nodes_file_id: 'CREATE INDEX IF NOT EXISTS idx_nodes_file_id ON nodes(file_path, id)',
+} as const;
+
+/**
+ * Reconcile the two historical version collisions without rewriting history.
+ *
+ * Pinable v10 meant cursor indexes, not upstream synthesis inputs; Pinable
+ * v12 meant the v10 repair, not upstream failed-import retry. Reuse the actual
+ * upstream migration bodies for those missed changes instead of copying SQL
+ * or renumbering already-applied migrations. Healthy opens do no writes.
+ */
+export function repairPinableSchema(
+  db: SqliteDatabase,
+  fromVersion: number,
+  replayUpstream: (version: number) => void,
+): void {
+  const names = new Set((db.prepare(`
+    SELECT name FROM sqlite_master
+    WHERE (type = 'table' AND name = 'synthesis_inputs')
+       OR (type = 'index' AND name IN (
+         'idx_unresolved_failed_import_tail', 'idx_unresolved_failed_import_name',
+         'idx_edges_source_id', 'idx_edges_target_id', 'idx_nodes_file_id'
+       ))
+  `).all() as Array<{ name: string }>).map((row) => row.name));
+  // Earlier versions run these changes through the normal migration chain.
+  const missedSynthesis = fromVersion >= 10 && !names.has('synthesis_inputs');
+  const missedImports = fromVersion >= 12 && (
+    !names.has('idx_unresolved_failed_import_tail') ||
+    !names.has('idx_unresolved_failed_import_name')
+  );
+  const missingCursors = Object.entries(cursorIndexes).filter(([name]) => !names.has(name));
+  if (!missedSynthesis && !missedImports && missingCursors.length === 0) return;
+
+  // DDL and the legacy data rewrite must roll back together on any failure.
+  // The presence checks make retries and repeated opens idempotent; do not
+  // change schema_versions or re-mark a healthy graph as synthesis_pending.
+  db.transaction(() => {
+    if (missedSynthesis) replayUpstream(10);
+    if (missedImports) replayUpstream(12);
+    for (const [, ddl] of missingCursors) db.exec(ddl);
+  })();
+}
diff --git a/src/db/queries.ts b/src/db/queries.ts
index 8a7b299732..72f9d5f443 100644
--- a/src/db/queries.ts
+++ b/src/db/queries.ts
@@ -22,6 +22,7 @@ import { kindBonus, nameMatchBonus, scorePathRelevance } from '../search/query-u
 import { parseQuery, boundedEditDistance } from '../search/query-parser';
 import { isGeneratedFile } from '../extraction/generated-detection';
 import { splitIdentifierSegments } from '../search/identifier-segments';
+import { referenceNameTail } from './reference-tail';
 
 /**
  * Files that should not be candidates for "dominant file" detection: test/spec
@@ -90,6 +91,15 @@ const IS_INTERFACE_MEMBER = (alias: string): string => `EXISTS (
  */
 export const DEPRIORITIZED_NAME_BONUS_SCALE = 0.75;
 
+/**
+ * The fields that tell one node of a file from another across a re-index of
+ * that file, whose node ids change with every line shift (#2276).
+ */
+export type NodeIdentity = Pick<
+  Node,
+  'id' | 'kind' | 'name' | 'qualifiedName' | 'signature' | 'startLine' | 'startColumn'
+>;
+
 /**
  * Database row types (snake_case from SQLite)
  */
@@ -155,21 +165,6 @@ interface UnresolvedRefRow {
   name_tail: string;
 }
 
-/**
- * Last segment of a (possibly dotted/qualified) reference name — the part a
- * new symbol's plain node name could match: 'util.greet' → 'greet',
- * 'mod::fn' → 'fn', 'greet' → 'greet'. Written to unresolved_refs.name_tail
- * when a ref is marked failed, so the #1240 retry lookup can match dotted
- * refs against newly-added node names.
- */
-function referenceNameTail(referenceName: string): string {
-  // Erlang refs carry a written arity (`f/1`, `mod::fn/2` — #1610); the tail a
-  // new symbol's plain name could match is the arity-less function name.
-  const base = referenceName.replace(/\/\d{1,3}$/, '') || referenceName;
-  const idx = Math.max(base.lastIndexOf('.'), base.lastIndexOf(':'));
-  return idx >= 0 ? base.slice(idx + 1) : base;
-}
-
 /**
  * Convert database row to Node object
  */
@@ -280,6 +275,7 @@ export class QueryBuilder {
     deleteFile?: SqliteStatement;
     getFileByPath?: SqliteStatement;
     getAllFiles?: SqliteStatement;
+    hasFilesUnder?: SqliteStatement;
     insertUnresolved?: SqliteStatement;
     deleteUnresolvedByNode?: SqliteStatement;
     getUnresolvedByName?: SqliteStatement;
@@ -289,9 +285,13 @@ export class QueryBuilder {
     existingNodeIdsFull?: SqliteStatement;
     getExportedNodesByFile?: SqliteStatement;
     getNodesByFileAndName?: SqliteStatement;
+    getNodeIdentitiesByFile?: SqliteStatement;
     getFileNodesByNamePrefix?: SqliteStatement;
     getNodesByQualifiedNameExact?: SqliteStatement;
     getNodesByLowerName?: SqliteStatement;
+    hasFilesOfLanguage?: SqliteStatement;
+    getCobolIncludesByMember?: SqliteStatement;
+    getCobolFilesByStem?: SqliteStatement;
     getUnresolvedCount?: SqliteStatement;
     getUnresolvedBatch?: SqliteStatement;
     getUnresolvedBatchAfter?: SqliteStatement;
@@ -300,6 +300,7 @@ export class QueryBuilder {
     deleteRefsByRowIdsFull?: SqliteStatement;
     getAllFilePaths?: SqliteStatement;
     getAllNodeNames?: SqliteStatement;
+    getCppIncludeNodes?: SqliteStatement;
     getDominantFile?: SqliteStatement;
     getChangeStamp?: SqliteStatement;
     getTopRouteFile?: SqliteStatement;
@@ -598,6 +599,15 @@ export class QueryBuilder {
     })();
   }
 
+  /**
+   * Run `fn` as one transaction. The write helpers called inside join it
+   * rather than committing on their own, so a crash part-way leaves none of
+   * `fn`'s writes behind.
+   */
+  runInTransaction<T>(fn: () => T): T {
+    return this.db.transaction(fn)();
+  }
+
   /**
    * Store one file's whole extraction bundle — nodes, edges, unresolved refs,
    * and the file record — in a SINGLE transaction. The bulk-index path calls
@@ -1032,6 +1042,31 @@ export class QueryBuilder {
     return rows.map(rowToNode);
   }
 
+  /**
+   * The {@link NodeIdentity} of every node in a file, without decoding whole
+   * nodes. Read before a re-index deletes the file, so each incoming
+   * cross-file edge can follow its target to the node that replaces it (#2276).
+   */
+  getNodeIdentitiesByFile(filePath: string): NodeIdentity[] {
+    if (!this.stmts.getNodeIdentitiesByFile) {
+      this.stmts.getNodeIdentitiesByFile = this.db.prepare(
+        'SELECT id, kind, name, qualified_name, signature, start_line, start_column FROM nodes WHERE file_path = ?'
+      );
+    }
+    const rows = this.stmts.getNodeIdentitiesByFile.all(filePath) as Array<
+      Pick<NodeRow, 'id' | 'kind' | 'name' | 'qualified_name' | 'signature' | 'start_line' | 'start_column'>
+    >;
+    return rows.map((row) => ({
+      id: row.id,
+      kind: row.kind as NodeKind,
+      name: row.name,
+      qualifiedName: row.qualified_name,
+      signature: row.signature ?? undefined,
+      startLine: row.start_line,
+      startColumn: row.start_column,
+    }));
+  }
+
   /**
    * Get all nodes in several files at once — one chunked `IN` query rather than
    * one {@link getNodesByFile} per file (#1975).
@@ -1204,7 +1239,8 @@ export class QueryBuilder {
     if (!this.stmts.getRoutingManifest) {
       // Edge kind varies across framework resolvers: Spring/Rails/
       // Laravel/Drupal emit `references`, Express emits `calls`. Accept
-      // both — the semantic is the same (route → its handler).
+      // both — the semantic is the same (route → its handler). A screen in
+      // a Vue / Svelte / Astro app is served by a `component`.
       this.stmts.getRoutingManifest = this.db.prepare(`
         SELECT
           r.name AS url,
@@ -1220,7 +1256,7 @@ export class QueryBuilder {
         JOIN nodes h ON e.target = h.id
         WHERE r.kind = 'route'
           AND e.kind IN ('references', 'calls')
-          AND h.kind IN ('function', 'method', 'class', 'constant', 'variable')
+          AND h.kind IN ('function', 'method', 'class', 'constant', 'variable', 'component')
         ORDER BY r.file_path, r.start_line
         LIMIT ?
       `);
@@ -1298,14 +1334,18 @@ export class QueryBuilder {
    * order — the ORDER BY is total (`id` is unique), so this yields exactly the
    * nodes a caller filtering iterateNodesByKind by language would keep, in the
    * same sequence. A Go pass on a TypeScript monorepo otherwise materialized
-   * every method in the project to find a couple of Go ones.
+   * every method in the project to find a couple of Go ones. Several kinds
+   * come interleaved in that one order (the sort then holds only the rows
+   * the language filter keeps).
    */
-  *iterateNodesByKindIn(kind: NodeKind, languages: readonly string[]): IterableIterator<Node> {
-    if (languages.length === 0) return;
+  *iterateNodesByKindIn(kind: NodeKind | readonly NodeKind[], languages: readonly string[]): IterableIterator<Node> {
+    const kinds: readonly NodeKind[] = typeof kind === 'string' ? [kind] : kind;
+    if (kinds.length === 0 || languages.length === 0) return;
+    const kindTest = kinds.length === 1 ? 'kind = ?' : `kind IN (${kinds.map(() => '?').join(', ')})`;
     const stmt = this.db.prepare(
-      `SELECT * FROM nodes WHERE kind = ? AND language IN (${languages.map(() => '?').join(', ')}) ORDER BY file_path, start_line, id`
+      `SELECT * FROM nodes WHERE ${kindTest} AND language IN (${languages.map(() => '?').join(', ')}) ORDER BY file_path, start_line, id`
     );
-    for (const row of stmt.iterate(kind, ...languages)) {
+    for (const row of stmt.iterate(...kinds, ...languages)) {
       yield rowToNode(row as NodeRow);
     }
   }
@@ -1505,6 +1545,52 @@ export class QueryBuilder {
     return rows.map(rowToNode);
   }
 
+  /** Does the index hold any file of this language? One seek on idx_files_language. */
+  hasFilesOfLanguage(language: string): boolean {
+    if (!this.stmts.hasFilesOfLanguage) {
+      this.stmts.hasFilesOfLanguage = this.db.prepare('SELECT 1 FROM files WHERE language = ? LIMIT 1');
+    }
+    return this.stmts.hasFilesOfLanguage.get(language) !== undefined;
+  }
+
+  /**
+   * COBOL copybook includes naming `member`: the `import` node the COBOL
+   * extractor makes for every `COPY member` and `EXEC SQL INCLUDE member`,
+   * matched case-insensitively (COBOL names ignore case), in file/line order.
+   *
+   * Seeks idx_nodes_lower_name. The unary `+` keeps the planner off the kind
+   * and language indexes, which would otherwise read every import (or every
+   * COBOL node) in the project to find the few with this name.
+   */
+  getCobolIncludesByMember(member: string, limit: number): Node[] {
+    if (!this.stmts.getCobolIncludesByMember) {
+      this.stmts.getCobolIncludesByMember = this.db.prepare(
+        "SELECT * FROM nodes WHERE lower(name) = lower(?) AND +kind = 'import' AND +language = 'cobol'"
+        + ' ORDER BY file_path, start_line, id LIMIT ?'
+      );
+    }
+    const rows = this.stmts.getCobolIncludesByMember.all(member, limit) as NodeRow[];
+    return rows.map(rowToNode);
+  }
+
+  /**
+   * COBOL file nodes whose basename stem is `member`, case-insensitively —
+   * `member.cpy`, `MEMBER.CPY`, `member.cbl`. Every such basename sorts into
+   * [`member.`, `member/`) under lower(), so this is a range seek on
+   * idx_nodes_lower_name; the unary `+` stops the planner from preferring a
+   * walk of every file node in idx_nodes_kind to save the (tiny) sort.
+   */
+  getCobolFilesByStem(member: string): Node[] {
+    if (!this.stmts.getCobolFilesByStem) {
+      this.stmts.getCobolFilesByStem = this.db.prepare(
+        "SELECT * FROM nodes WHERE lower(name) >= lower(?) || '.' AND lower(name) < lower(?) || '/'"
+        + " AND +kind = 'file' AND +language = 'cobol' ORDER BY file_path"
+      );
+    }
+    const rows = this.stmts.getCobolFilesByStem.all(member, member) as NodeRow[];
+    return rows.map(rowToNode);
+  }
+
   /**
    * Search nodes by name using FTS with fallback to LIKE for better matching
    *
@@ -2408,19 +2494,69 @@ export class QueryBuilder {
    * Chunked probe over `idx_unresolved_from_node`.
    */
   getUnresolvedSupertypeSourcesAmong(nodeIds: Iterable<string>): Set<string> {
+    return new Set(this.getUnresolvedReferenceNamesFrom(nodeIds, ['extends', 'implements']).keys());
+  }
+
+  /**
+   * The names each of `nodeIds` holds an unresolved reference of `kinds` to.
+   *
+   * A reference into code outside the index leaves no edge, only this row: a
+   * decorator imported from a framework (`@HostListener`, `@Cron`) or an
+   * interface named in an `implements` clause. Pending rows count with failed
+   * ones, as in {@link getUnresolvedSupertypeSourcesAmong}. Ids with no such row
+   * are absent from the map. Chunked probe over `idx_unresolved_from_node`.
+   */
+  getUnresolvedReferenceNamesFrom(nodeIds: Iterable<string>, kinds: readonly string[]): Map<string, string[]> {
     const unique = [...new Set(nodeIds)];
-    const found = new Set<string>();
+    const found = new Map<string, string[]>();
+    if (unique.length === 0 || kinds.length === 0) return found;
+    const kindPlaceholders = kinds.map(() => '?').join(',');
     for (let i = 0; i < unique.length; i += SQLITE_PARAM_CHUNK_SIZE) {
       const chunk = unique.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
       const placeholders = chunk.map(() => '?').join(',');
       const rows = this.db
         .prepare(
-          `SELECT DISTINCT from_node_id AS id FROM unresolved_refs
+          `SELECT DISTINCT from_node_id AS id, reference_name AS name FROM unresolved_refs
             WHERE from_node_id IN (${placeholders})
-              AND reference_kind IN ('extends', 'implements')`
+              AND reference_kind IN (${kindPlaceholders})`
+        )
+        .all(...chunk, ...kinds) as Array<{ id: string; name: string }>;
+      for (const row of rows) {
+        const names = found.get(row.id);
+        if (names) names.push(row.name);
+        else found.set(row.id, [row.name]);
+      }
+    }
+    return found;
+  }
+
+  /**
+   * Every node holding an unresolved reference of `kinds` to each of `names` —
+   * the mirror of {@link getUnresolvedReferenceNamesFrom}, keyed by the name:
+   * for `implements`, every class that names an interface outside the index.
+   * Names nothing refers to are absent from the map. Chunked probe over
+   * `idx_unresolved_name`.
+   */
+  getUnresolvedReferenceSourcesNamed(names: Iterable<string>, kinds: readonly string[]): Map<string, Set<string>> {
+    const unique = [...new Set(names)].filter((name) => name.length > 0);
+    const found = new Map<string, Set<string>>();
+    if (unique.length === 0 || kinds.length === 0) return found;
+    const kindPlaceholders = kinds.map(() => '?').join(',');
+    for (let i = 0; i < unique.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+      const chunk = unique.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+      const placeholders = chunk.map(() => '?').join(',');
+      const rows = this.db
+        .prepare(
+          `SELECT DISTINCT reference_name AS name, from_node_id AS id FROM unresolved_refs
+            WHERE reference_name IN (${placeholders})
+              AND reference_kind IN (${kindPlaceholders})`
         )
-        .all(...chunk) as Array<{ id: string }>;
-      for (const row of rows) found.add(row.id);
+        .all(...chunk, ...kinds) as Array<{ name: string; id: string }>;
+      for (const row of rows) {
+        const ids = found.get(row.name);
+        if (ids) ids.add(row.id);
+        else found.set(row.name, new Set([row.id]));
+      }
     }
     return found;
   }
@@ -3029,13 +3165,14 @@ export class QueryBuilder {
 
   /**
    * Cross-file edges whose TARGET is a node in `filePath` and whose SOURCE is a
-   * node in a *different* file, paired with the target node's (name, kind) so a
-   * caller can re-resolve the edge to the re-indexed target's new ID (node IDs
-   * are `sha256(filePath:kind:name:line)`, so any line shift in the callee file
-   * changes target IDs and a naive re-insert by old ID silently drops them).
-   * Used by `storeExtractionResult` to preserve incoming edges across a file
-   * re-index (issue #899). Same edge-kind rules as
-   * {@link getDependentFilePaths}: all kinds except `contains`.
+   * node in a *different* file, paired with the target node's (name, kind).
+   * Node IDs are `sha256(filePath:kind:name:line)`, so any line shift in the
+   * callee file changes target IDs and a naive re-insert by old ID silently
+   * drops them; `storeExtractionResult` instead follows each old target to the
+   * re-indexed node that replaces it (see {@link getNodeIdentitiesByFile}) to
+   * preserve incoming edges across a file re-index (issue #899). Same
+   * edge-kind rules as {@link getDependentFilePaths}: all kinds except
+   * `contains`.
    */
   getCrossFileIncomingEdgesWithTarget(
     filePath: string
@@ -3294,6 +3431,18 @@ export class QueryBuilder {
     return row ? rowToFileRecord(row) : null;
   }
 
+  /**
+   * Whether any tracked file lives under the project-relative POSIX directory
+   * `dir`. A range scan on the `path` primary key — `dir/` up to `dir0` ('0'
+   * is the byte after '/') — so it costs one index probe at any repo size.
+   */
+  hasFilesUnder(dir: string): boolean {
+    if (!this.stmts.hasFilesUnder) {
+      this.stmts.hasFilesUnder = this.db.prepare('SELECT 1 FROM files WHERE path >= ? AND path < ? LIMIT 1');
+    }
+    return this.stmts.hasFilesUnder.get(`${dir}/`, `${dir}0`) !== undefined;
+  }
+
   /**
    * Get all tracked files
    */
@@ -3305,6 +3454,18 @@ export class QueryBuilder {
     return rows.map(rowToFileRecord);
   }
 
+  /**
+   * Files stored with no nodes or with recorded extraction errors — the only
+   * rows that can be missing their symbols (`CodeGraph.getIndexHealth`). A
+   * healthy index returns few or none, so this stays cheap on a large one.
+   */
+  getFilesWithoutNodesOrWithErrors(): FileRecord[] {
+    const rows = this.db
+      .prepare('SELECT * FROM files WHERE node_count = 0 OR errors IS NOT NULL ORDER BY path')
+      .all() as FileRow[];
+    return rows.map(rowToFileRecord);
+  }
+
   /**
    * Most recent index timestamp (ms since epoch) across all tracked files, or
    * null when nothing is indexed yet. One indexed aggregate, no per-row scan. (#329)
@@ -3578,6 +3739,21 @@ export class QueryBuilder {
     return rows.map((r) => r.name);
   }
 
+  /**
+   * The import node of every C / C++ `#include`, narrowed to the path it
+   * spells and where it is written: the include graph reads nothing else, and
+   * decoding every import node of a large C++ project costs several times more.
+   */
+  getCppIncludeNodes(): Array<Pick<Node, 'id' | 'name' | 'filePath' | 'language' | 'startLine' | 'startColumn'>> {
+    if (!this.stmts.getCppIncludeNodes) {
+      this.stmts.getCppIncludeNodes = this.db.prepare(
+        `SELECT id, name, file_path AS filePath, language, start_line AS startLine, start_column AS startColumn
+           FROM nodes WHERE kind = 'import' AND language IN ('c', 'cpp')`
+      );
+    }
+    return this.stmts.getCppIncludeNodes.all() as Array<Pick<Node, 'id' | 'name' | 'filePath' | 'language' | 'startLine' | 'startColumn'>>;
+  }
+
   /**
    * Stream the distinct node names one row at a time — the incremental
    * counterpart to {@link getAllNodeNames} for callers that need to yield
@@ -3720,9 +3896,10 @@ export class QueryBuilder {
    * terminate) but stay queryable by name_tail so a later sync can retry them
    * when a changed file introduces a symbol that could satisfy them. name_tail
    * is (re)written here so rows inserted before the v8 migration get their
-   * tail the first time they're attempted.
+   * tail the first time they're attempted. A ref's own `nameTail`, when the
+   * resolver gave it one, replaces the tail its name gives.
    */
-  markReferencesFailed(refs: Array<{ fromNodeId: string; referenceName: string; referenceKind: string }>): number {
+  markReferencesFailed(refs: Array<{ fromNodeId: string; referenceName: string; referenceKind: string; nameTail?: string }>): number {
     if (refs.length === 0) return 0;
     const stmt = this.db.prepare(
       "UPDATE unresolved_refs SET status = 'failed', name_tail = ? WHERE from_node_id = ? AND reference_name = ? AND reference_kind = ?"
@@ -3730,7 +3907,7 @@ export class QueryBuilder {
     let changed = 0;
     const markMany = this.db.transaction((items: typeof refs) => {
       for (const ref of items) {
-        changed += stmt.run(referenceNameTail(ref.referenceName), ref.fromNodeId, ref.referenceName, ref.referenceKind).changes;
+        changed += stmt.run(ref.nameTail ?? referenceNameTail(ref.referenceName, ref.referenceKind), ref.fromNodeId, ref.referenceName, ref.referenceKind).changes;
       }
     });
     markMany(refs);
@@ -3745,7 +3922,7 @@ export class QueryBuilder {
    * can differ per call site (receiver-type inference reads the ref's line),
    * so a sibling must not inherit this row's failure.
    */
-  markReferencesFailedByRowIds(refs: Array<{ rowId: number; referenceName: string }>): number {
+  markReferencesFailedByRowIds(refs: Array<{ rowId: number; referenceName: string; referenceKind: string; nameTail?: string }>): number {
     if (refs.length === 0) return 0;
     const stmt = this.db.prepare(
       "UPDATE unresolved_refs SET status = 'failed', name_tail = ? WHERE id = ?"
@@ -3753,7 +3930,7 @@ export class QueryBuilder {
     let changed = 0;
     const markMany = this.db.transaction((items: typeof refs) => {
       for (const ref of items) {
-        changed += stmt.run(referenceNameTail(ref.referenceName), ref.rowId).changes;
+        changed += stmt.run(ref.nameTail ?? referenceNameTail(ref.referenceName, ref.referenceKind), ref.rowId).changes;
       }
     });
     markMany(refs);
@@ -3768,41 +3945,114 @@ export class QueryBuilder {
    * (`get`, `map`, …) that one new definition won't resolve — the same
    * rationale as resolution's AMBIGUOUS_NAME_CEILING (#999) — and retrying an
    * arbitrary subset would be both wasted work and incoherent coverage.
+   *
+   * A name can also be one of a changed file's `moduleReferenceKeys`, which a
+   * route's reference to the module it lazily loads is parked under, and so
+   * is a reference through an import binding of the module. Such a binding's
+   * reference still waits for its own name too, looked up by its whole name:
+   * a fresh index links a binding whose module never resolves it by that
+   * name alone, to whichever declaration carries it.
    */
   getRetryableFailedReferences(names: string[], perNameCeiling: number = 500): UnresolvedReference[] {
     if (names.length === 0) return [];
 
-    // Pass 1: per-tail counts, chunked under the SQLite parameter limit.
-    const retryNames: string[] = [];
-    for (let i = 0; i < names.length; i += SQLITE_PARAM_CHUNK_SIZE) {
-      const chunk = names.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
-      const placeholders = chunk.map(() => '?').join(',');
-      const counts = this.db
-        .prepare(
-          `SELECT name_tail, COUNT(*) as count FROM unresolved_refs WHERE status = 'failed' AND name_tail IN (${placeholders}) GROUP BY name_tail`
-        )
-        .all(...chunk) as Array<{ name_tail: string; count: number }>;
-      for (const row of counts) {
-        if (row.count <= perNameCeiling) retryNames.push(row.name_tail);
+    const lookups = [
+      { column: 'name_tail', where: "status = 'failed'" },
+      // idx_unresolved_failed_module_name; its leading `status` is the
+      // equality term that keeps the planner off idx_unresolved_status and
+      // idx_unresolved_name, which read hundreds of thousands of rows here.
+      { column: 'reference_name', where: "status = 'failed' AND name_tail GLOB 'module:*'" },
+    ];
+    const rows = new Map<number, UnresolvedRefRow>();
+    for (const { column, where } of lookups) {
+      // Pass 1: per-key counts, chunked under the SQLite parameter limit.
+      const retryKeys: string[] = [];
+      for (let i = 0; i < names.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+        const chunk = names.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(',');
+        const counts = this.db
+          .prepare(`SELECT ${column} AS key, COUNT(*) AS count FROM unresolved_refs WHERE ${where} AND ${column} IN (${placeholders}) GROUP BY ${column}`)
+          .all(...chunk) as Array<{ key: string; count: number }>;
+        for (const row of counts) {
+          if (row.count <= perNameCeiling) retryKeys.push(row.key);
+        }
+      }
+
+      // Pass 2: load the surviving rows; a row both lookups find is kept once.
+      for (let i = 0; i < retryKeys.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+        const chunk = retryKeys.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(',');
+        const chunkRows = this.db
+          .prepare(`SELECT * FROM unresolved_refs WHERE ${where} AND ${column} IN (${placeholders})`)
+          .all(...chunk) as UnresolvedRefRow[];
+        // Loop, not spread — same V8 argument-limit hazard as
+        // getUnresolvedReferencesByFiles (#1558): a large definition delta can
+        // select an unbounded number of failed rows per chunk.
+        for (const row of chunkRows) rows.set(row.id, row);
       }
     }
-    if (retryNames.length === 0) return [];
 
-    // Pass 2: load the surviving rows.
-    const rows: UnresolvedRefRow[] = [];
-    for (let i = 0; i < retryNames.length; i += SQLITE_PARAM_CHUNK_SIZE) {
-      const chunk = retryNames.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
-      const placeholders = chunk.map(() => '?').join(',');
-      const chunkRows = this.db
-        .prepare(`SELECT * FROM unresolved_refs WHERE status = 'failed' AND name_tail IN (${placeholders})`)
-        .all(...chunk) as UnresolvedRefRow[];
-      // Loop, not spread — same V8 argument-limit hazard as
-      // getUnresolvedReferencesByFiles (#1558): a large definition delta can
-      // select an unbounded number of failed rows per chunk.
-      for (const row of chunkRows) rows.push(row);
+    return [...rows.values()].map((row) => ({
+      fromNodeId: row.from_node_id,
+      referenceName: row.reference_name,
+      referenceKind: row.reference_kind as EdgeKind,
+      line: row.line,
+      column: row.col,
+      candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined,
+      filePath: row.file_path,
+      language: row.language as Language,
+      rowId: row.id,
+    }));
+  }
+
+  /**
+   * Failed `imports` refs a sync should retry once files appear. An import
+   * names a file, a folder or a namespace, which the symbol lookup above
+   * cannot match, so it is found two ways:
+   *  - by `pathKeys` (`importPathKeys` of each added file), as its tail or its
+   *    whole name: `package:app/b.dart` waits for a file named `b.dart`, a
+   *    bare `#include "b.h"` or `require 'db.php'` is the file's whole name;
+   *  - by `names` (the changed files' namespaces and modules), as its whole
+   *    name when its tail is something else: a C# `using Foo.Bar` waits for
+   *    the namespace node `Foo.Bar`. An import whose tail is the name is the
+   *    symbol lookup's, under that lookup's ceiling.
+   * Same per-name ceiling as {@link getRetryableFailedReferences}, counted
+   * per key.
+   */
+  getRetryableFailedImports(pathKeys: string[], names: string[] = [], perNameCeiling: number = 500): UnresolvedReference[] {
+    const failedImports = "status = 'failed' AND reference_kind = 'imports'";
+    const lookups = [
+      { keys: pathKeys, column: 'name_tail', where: failedImports },
+      { keys: pathKeys, column: 'reference_name', where: failedImports },
+      { keys: names, column: 'reference_name', where: `${failedImports} AND name_tail != reference_name` },
+    ];
+    const rows = new Map<number, UnresolvedRefRow>();
+    for (const { keys, column, where } of lookups) {
+      const unique = [...new Set(keys)].filter((key) => key.length > 0);
+      // Pass 1: per-key counts, chunked under the SQLite parameter limit.
+      const retryKeys: string[] = [];
+      for (let i = 0; i < unique.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+        const chunk = unique.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(',');
+        const counts = this.db
+          .prepare(`SELECT ${column} AS key, COUNT(*) AS count FROM unresolved_refs WHERE ${where} AND ${column} IN (${placeholders}) GROUP BY ${column}`)
+          .all(...chunk) as Array<{ key: string; count: number }>;
+        for (const row of counts) {
+          if (row.count <= perNameCeiling) retryKeys.push(row.key);
+        }
+      }
+      // Pass 2: load the surviving rows; a row two lookups find is kept once.
+      for (let i = 0; i < retryKeys.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+        const chunk = retryKeys.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(',');
+        const chunkRows = this.db
+          .prepare(`SELECT * FROM unresolved_refs WHERE ${where} AND ${column} IN (${placeholders})`)
+          .all(...chunk) as UnresolvedRefRow[];
+        for (const row of chunkRows) rows.set(row.id, row);
+      }
     }
 
-    return rows.map((row) => ({
+    return [...rows.values()].map((row) => ({
       fromNodeId: row.from_node_id,
       referenceName: row.reference_name,
       referenceKind: row.reference_kind as EdgeKind,
@@ -3815,6 +4065,70 @@ export class QueryBuilder {
     }));
   }
 
+  /**
+   * Failed `calls` refs whose name tail is one of `tails` — the navigation
+   * calls (`history.push`, `navigate`) a sync looks through after a route
+   * appeared or went away. Read through the failed-tail index; the caller
+   * decides on each whole name.
+   */
+  getFailedCallsByTail(tails: string[]): Array<{ rowId: number; referenceName: string; filePath: string }> {
+    const out: Array<{ rowId: number; referenceName: string; filePath: string }> = [];
+    const unique = [...new Set(tails)];
+    for (let i = 0; i < unique.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+      const chunk = unique.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+      const placeholders = chunk.map(() => '?').join(',');
+      const rows = this.db
+        .prepare(
+          `SELECT id, reference_name, file_path FROM unresolved_refs
+            WHERE status = 'failed' AND reference_kind = 'calls' AND name_tail IN (${placeholders})`
+        )
+        .all(...chunk) as Array<{ id: number; reference_name: string; file_path: string }>;
+      for (const row of rows) out.push({ rowId: row.id, referenceName: row.reference_name, filePath: row.file_path });
+    }
+    return out;
+  }
+
+  /**
+   * The `navigates` edges a router's resolver made (not a synthesizer's), with
+   * the source file and language a resurrection needs — the navigation calls
+   * a sync re-resolves after a route appeared or went away.
+   */
+  getResolvedNavigations(): Array<Edge & { edgeId: number; sourceFilePath: string; sourceLanguage: Language }> {
+    const rows = this.db
+      .prepare(
+        `SELECT e.*, src.file_path AS source_file_path, src.language AS source_language
+           FROM edges e
+           JOIN nodes src ON src.id = e.source
+          WHERE e.kind = 'navigates' AND (e.provenance IS NULL OR e.provenance != 'heuristic')`
+      )
+      .all() as Array<EdgeRow & { source_file_path: string; source_language: Language }>;
+    return rows.map((row) => ({
+      ...rowToEdge(row),
+      edgeId: row.id,
+      sourceFilePath: row.source_file_path,
+      sourceLanguage: row.source_language,
+    }));
+  }
+
+  /**
+   * Put failed refs back in the pending set, for the next resolution pass —
+   * the sync's orphan sweep — to try again. Returns the number re-opened.
+   */
+  reopenFailedReferences(rowIds: number[]): number {
+    if (rowIds.length === 0) return 0;
+    let changed = 0;
+    this.db.transaction(() => {
+      for (let i = 0; i < rowIds.length; i += SQLITE_PARAM_CHUNK_SIZE) {
+        const chunk = rowIds.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(',');
+        changed += this.db
+          .prepare(`UPDATE unresolved_refs SET status = 'pending' WHERE status = 'failed' AND id IN (${placeholders})`)
+          .run(...chunk).changes;
+      }
+    })();
+    return changed;
+  }
+
   /**
    * Resolution edges whose TARGET symbol is named one of `names` — the edges a
    * sync must re-resolve after `names` gained or lost a definition (CG-33).
@@ -3926,16 +4240,18 @@ export class QueryBuilder {
   /**
    * Distinct node names present in the given files — the symbol names a sync
    * pass uses to look up retryable failed refs after those files changed.
+   * `kinds` narrows them to nodes of those kinds.
    */
-  getNodeNamesByFiles(filePaths: string[]): string[] {
+  getNodeNamesByFiles(filePaths: string[], kinds?: readonly NodeKind[]): string[] {
     if (filePaths.length === 0) return [];
+    const kindFilter = kinds ? ` AND kind IN (${kinds.map(() => '?').join(',')})` : '';
     const names = new Set<string>();
     for (let i = 0; i < filePaths.length; i += SQLITE_PARAM_CHUNK_SIZE) {
       const chunk = filePaths.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
       const placeholders = chunk.map(() => '?').join(',');
       const rows = this.db
-        .prepare(`SELECT DISTINCT name FROM nodes WHERE file_path IN (${placeholders})`)
-        .all(...chunk) as Array<{ name: string }>;
+        .prepare(`SELECT DISTINCT name FROM nodes WHERE file_path IN (${placeholders})${kindFilter}`)
+        .all(...chunk, ...(kinds ?? [])) as Array<{ name: string }>;
       for (const row of rows) names.add(row.name);
     }
     return [...names];
diff --git a/src/db/reference-tail.ts b/src/db/reference-tail.ts
new file mode 100644
index 0000000000..a0b954c596
--- /dev/null
+++ b/src/db/reference-tail.ts
@@ -0,0 +1,131 @@
+/**
+ * The keys sync's failed-ref retry (#1240) matches on: the tail a failed ref
+ * is parked under, and the names a newly added file can be imported as.
+ * Shared by the query layer, which writes and reads them, and the migrations
+ * that rewrote the tails parked before path imports, path references and
+ * module references had ones of their own.
+ */
+
+/**
+ * Last segment of a (possibly dotted/qualified) reference name — the part a
+ * new symbol's plain node name could match: 'util.greet' → 'greet',
+ * 'mod::fn' → 'fn', 'greet' → 'greet'. Written to unresolved_refs.name_tail
+ * when a ref is marked failed, so the #1240 retry lookup can match dotted
+ * refs against newly-added node names.
+ *
+ * An import written as a path names a FILE, so its tail is the path's last
+ * segment cut at its first dot — `package:app/b.dart` → 'b', `./foo` → 'foo',
+ * `inc/db.php` → 'db' — the stem {@link importPathKeys} takes from a file
+ * that could satisfy it. The dotted tail was the extension ('dart', 'php') or
+ * a path fragment ('/foo'), which no file ever matched.
+ *
+ * A route's reference to the module it lazily loads names a file the same
+ * way, by the module's path with or without its extension: React Router's
+ * `lazy-import:./pages/Team`, Vue Router's and Angular's
+ * `import:./home/home.component#HomeComponent`. It is parked under that
+ * path's stem behind 'module:' — 'module:Team', 'module:home' — the key
+ * {@link moduleReferenceKeys} gives a file that could be the module. A bare
+ * stem would be any symbol's name, which a module reference does not wait
+ * for: 'index' and 'types' are the tails of thousands of failed calls. Its
+ * dotted tail was a path fragment ('/pages/Team') or what follows the
+ * module's own dot ('component#HomeComponent'), which no file ever matched.
+ *
+ * Any other reference written as a path to a file names it by the file's own
+ * name: Liquid's `{% render 'price' %}` is `snippets/price.liquid`, parked as
+ * 'price.liquid' — the name path matching looks the file up by, and the name
+ * of the node a file that appears later is given. Its dotted tail was the
+ * extension, 'liquid'. A call's slashes are in its arguments, a comment or a
+ * division, so only a `references` ref is read as a path.
+ */
+export function referenceNameTail(referenceName: string, referenceKind?: string): string {
+  if (referenceKind === 'imports' && referenceName.replace(/\/+$/, '').includes('/')) {
+    const stem = pathStem(referenceName);
+    if (stem) return stem;
+  }
+  // Vue Router's route names the component it renders as a call.
+  if (referenceKind === 'references' || referenceKind === 'calls') {
+    const route = MODULE_REFERENCE.exec(referenceName);
+    const tail = route ? moduleTail(route[1] ?? route[2]!) : '';
+    if (tail) return tail;
+  }
+  if (referenceKind === 'references') {
+    const fileName = referenceName.slice(referenceName.lastIndexOf('/') + 1);
+    if (fileName !== referenceName && FILE_NAME.test(fileName)) return fileName;
+  }
+  // Erlang refs carry a written arity (`f/1`, `mod::fn/2` — #1610); the tail a
+  // new symbol's plain name could match is the arity-less function name.
+  const base = referenceName.replace(/\/\d{1,3}$/, '') || referenceName;
+  const idx = Math.max(base.lastIndexOf('.'), base.lastIndexOf(':'));
+  return idx >= 0 ? base.slice(idx + 1) : base;
+}
+
+/** A file name with an extension: 'price.liquid', 'icon.logo.liquid', 'about.tsx' — not 'x.component#Name'. */
+const FILE_NAME = /^[\w$@+~.-]+\.[A-Za-z][A-Za-z0-9]*$/;
+
+/**
+ * A route's reference to the module it lazily loads, capturing the module's
+ * path: React Router's `lazy-import:<path>`, Vue Router's and Angular's
+ * `import:<path>#<export>` — a path may hold a `#` itself, as vben's `#/views/…`
+ * alias does — each also behind `layout:`, for a layout route's module.
+ */
+const MODULE_REFERENCE = /^(?:layout:)?(?:lazy-import:(.+)|import:(.+)#[^#]+)$/;
+
+/** What a module reference's tail starts with. No symbol's name does, so a lookup by symbol names never finds one. */
+const MODULE_KEY = 'module:';
+
+/**
+ * The tail of a reference that waits for a module rather than for a name: the
+ * module path's stem behind 'module:' — `./pages/Team` → 'module:Team',
+ * `@/views/error/404.vue` → 'module:404' — the key
+ * {@link moduleReferenceKeys} gives each file that could be the module, or ''
+ * when the path's last segment is only dots.
+ */
+export function moduleTail(modulePath: string): string {
+  const stem = pathStem(modulePath);
+  return stem ? MODULE_KEY + stem : '';
+}
+
+/** A path's last segment up to its first dot — `./pages/Team` → 'Team', `a/b.dart` → 'b' — or '' when that is only dots. */
+function pathStem(path: string): string {
+  const trimmed = path.replace(/\/+$/, '');
+  const stem = fileNameStem(trimmed.slice(trimmed.lastIndexOf('/') + 1));
+  // `..` and `.` name a folder only through the referring file's location.
+  return /^\.*$/.test(stem) ? '' : stem;
+}
+
+/** A file or folder name up to its first dot: 'b.dart' → 'b', 'types.d.ts' → 'types', '.eslintrc.js' → '.eslintrc'. */
+function fileNameStem(name: string): string {
+  const dot = name.indexOf('.', 1);
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+
+/**
+ * What an import of the file at `filePath` can be written as, for the failed
+ * imports a sync that adds the file retries: its name (`b.h`, a bare include)
+ * and stem (`b`, the tail of `a/b.h`, `./b`, `pkg.b`), and the same two for
+ * its folder, which an import names for its index file (`./ui` →
+ * `ui/index.ts`, `pkg` → `pkg/__init__.py`) or as a Go package.
+ */
+export function importPathKeys(filePath: string): string[] {
+  const parts = filePath.split('/');
+  const keys = new Set<string>();
+  for (const name of parts.slice(-2)) {
+    keys.add(name);
+    keys.add(fileNameStem(name));
+  }
+  return [...keys];
+}
+
+/**
+ * The keys a module reference the file at `filePath` could satisfy is parked
+ * under: its {@link importPathKeys} behind 'module:' — `src/pages/Team.tsx`
+ * is the module of `lazy-import:./pages/Team`, `pages/Team/index.tsx` of the
+ * same path through its folder. A sync looks them up for the files it adds
+ * AND the ones it changes: a route renders the component its module exports,
+ * so an edit that gives the module one is what the route waited for. So does
+ * a reference through an import binding the module declares under another
+ * name (`importBindingTail`), which is parked under the same keys.
+ */
+export function moduleReferenceKeys(filePath: string): string[] {
+  return importPathKeys(filePath).map((key) => MODULE_KEY + key);
+}
diff --git a/src/db/schema.sql b/src/db/schema.sql
index 6b8c394f8b..adc80b8309 100644
--- a/src/db/schema.sql
+++ b/src/db/schema.sql
@@ -197,6 +197,16 @@ CREATE INDEX IF NOT EXISTS idx_unresolved_file_path ON unresolved_refs(file_path
 CREATE INDEX IF NOT EXISTS idx_unresolved_from_name ON unresolved_refs(from_node_id, reference_name);
 CREATE INDEX IF NOT EXISTS idx_unresolved_status ON unresolved_refs(status);
 CREATE INDEX IF NOT EXISTS idx_unresolved_failed_tail ON unresolved_refs(name_tail) WHERE status = 'failed';
+-- Sync's failed-import retry looks failed imports up by tail and by whole
+-- name. The leading reference_kind is what makes the planner pick these over
+-- idx_unresolved_failed_tail / idx_unresolved_name, whose per-key averages
+-- hide how many failed calls a common tail (`index`, `types`) has.
+CREATE INDEX IF NOT EXISTS idx_unresolved_failed_import_tail ON unresolved_refs(reference_kind, name_tail) WHERE status = 'failed' AND reference_kind = 'imports';
+CREATE INDEX IF NOT EXISTS idx_unresolved_failed_import_name ON unresolved_refs(reference_kind, reference_name) WHERE status = 'failed' AND reference_kind = 'imports';
+-- A failed ref through an import binding is parked under its module
+-- (`module:tag`) and looked up by its whole name as well. The leading status
+-- is the equality term that keeps the planner on this small index.
+CREATE INDEX IF NOT EXISTS idx_unresolved_failed_module_name ON unresolved_refs(status, reference_name) WHERE status = 'failed' AND name_tail GLOB 'module:*';
 CREATE INDEX IF NOT EXISTS idx_edges_provenance ON edges(provenance);
 -- Sync's third-file wiring lookup must not scan every synthesized edge.
 -- CASE short-circuits malformed metadata; keep these expressions identical
diff --git a/src/directory.ts b/src/directory.ts
index 0a08df9521..c458457e4e 100644
--- a/src/directory.ts
+++ b/src/directory.ts
@@ -303,6 +303,40 @@ export function statInode(p: string): string | null {
   }
 }
 
+/**
+ * Canonicalize a project root for IDENTITY: hashing it into a rendezvous key
+ * (the daemon's named pipe / tmpdir socket, a registry record). Not for display
+ * — the caller-visible root keeps its own spelling.
+ *
+ * The contract is that two spellings of ONE directory yield ONE string, because
+ * a client that derives a different key silently fails to meet the daemon that
+ * is already running: it probes a socket nobody bound, spawns a redundant
+ * daemon, and that daemon dies on the lock the first one holds, so the session
+ * degrades to a single-process engine. `path.resolve` alone does NOT satisfy
+ * that contract — NTFS is case-insensitive, so `d:\work\codegraph` and
+ * `D:\work\codegraph` name one directory but two strings, and non-native
+ * `fs.realpathSync` keeps whichever casing the caller passed (only `.native`
+ * asks the filesystem for the on-disk name — the same reason
+ * {@link isSameIndexRoot} uses it). Both spellings really do occur: a
+ * cwd-derived root is the on-disk case, while a client-supplied
+ * `rootUri`/`workspaceFolders` path arrives as `file:///d%3A/…`.
+ *
+ * The Windows lowercase is belt-and-braces on top of the native realpath — NTFS
+ * can't hold two directories differing only by case, and it also absorbs a
+ * `\\?\`-prefixed native result diverging from a plain one.
+ */
+export function canonicalProjectRoot(projectRoot: string): string {
+  const resolved = path.resolve(projectRoot);
+  let canonical = resolved;
+  try {
+    canonical = fs.realpathSync.native(resolved);
+  } catch {
+    // ENOENT/EACCES/ELOOP — the root is normally there (`.codegraph/` lives in
+    // it), so this is a fallback rather than a path we expect to take.
+  }
+  return process.platform === 'win32' ? canonical.toLowerCase() : canonical;
+}
+
 /**
  * Whether two resolved index roots are one index spelled two ways — a symlinked
  * checkout, or a case-variant on a case-insensitive mount (macOS, NTFS, WSL
@@ -1079,3 +1113,13 @@ export function validateDirectory(projectRoot: string): {
 export function isTaskNotification(prompt: string): boolean {
   return /^\s*<task-notification>[\s\S]*<\/task-notification>\s*$/.test(prompt);
 }
+
+/**
+ * Claude Code hands a subagent's report back to the parent session as a
+ * `<agent-message from="…">…</agent-message>` prompt, which UserPromptSubmit
+ * hooks also receive (#2184). Same rule as {@link isTaskNotification}: only a
+ * prompt that is entirely that envelope is skipped.
+ */
+export function isAgentMessage(prompt: string): boolean {
+  return /^\s*<agent-message(?:\s[^>]*)?>[\s\S]*<\/agent-message>\s*$/.test(prompt);
+}
diff --git a/src/extraction/astro-extractor.ts b/src/extraction/astro-extractor.ts
index e38989375f..efdc33f795 100644
--- a/src/extraction/astro-extractor.ts
+++ b/src/extraction/astro-extractor.ts
@@ -2,6 +2,7 @@ import { Node, Edge, ExtractionResult, ExtractionError, UnresolvedReference } fr
 import { generateNodeId } from './tree-sitter-helpers';
 import { TreeSitterExtractor } from './tree-sitter';
 import { isLanguageSupported } from './grammars';
+import { foldScriptResult, sfcFileNode } from './sfc-script';
 
 /**
  * Astro built-in components — compiler-provided (`<Fragment>`) or shipped by
@@ -45,8 +46,10 @@ export class AstroExtractor {
     const startTime = Date.now();
 
     try {
-      // Create component node for the .astro file itself
+      // The file, holding the component the .astro file is
+      this.nodes.push(sfcFileNode(this.filePath, this.source, 'astro'));
       const componentNode = this.createComponentNode();
+      this.edges.push({ source: `file:${this.filePath}`, target: componentNode.id, kind: 'contains' });
 
       // Extract and process the frontmatter block (--- fenced, TypeScript)
       const frontmatter = this.extractFrontmatter();
@@ -199,45 +202,13 @@ export class AstroExtractor {
     const extractor = new TreeSitterExtractor(this.filePath, block.content, 'typescript');
     const result = extractor.extract();
 
-    // Offset line numbers from the block back to .astro file positions
-    for (const node of result.nodes) {
-      node.startLine += block.startLine;
-      node.endLine += block.startLine;
-      node.language = 'astro'; // Mark as astro, not TS
-
-      this.nodes.push(node);
-
-      // Add containment edge from component to this node
-      this.edges.push({
-        source: componentNodeId,
-        target: node.id,
-        kind: 'contains',
-      });
-    }
-
-    // Offset edges (they reference line numbers)
-    for (const edge of result.edges) {
-      if (edge.line) {
-        edge.line += block.startLine;
-      }
-      this.edges.push(edge);
-    }
-
-    // Offset unresolved references
-    for (const ref of result.unresolvedReferences) {
-      ref.line += block.startLine;
-      ref.filePath = this.filePath;
-      ref.language = 'astro';
-      this.unresolvedReferences.push(ref);
-    }
-
-    // Carry over errors
-    for (const error of result.errors) {
-      if (error.line) {
-        error.line += block.startLine;
-      }
-      this.errors.push(error);
-    }
+    // Frontmatter runs on every render of the component, and a <script> is
+    // the page's own client code: both are the component's doing.
+    foldScriptResult(
+      result,
+      { filePath: this.filePath, componentNodeId, lineOffset: block.startLine, language: 'astro', perInstance: true },
+      { nodes: this.nodes, edges: this.edges, unresolvedReferences: this.unresolvedReferences, errors: this.errors }
+    );
   }
 
   /**
diff --git a/src/extraction/cfml-extractor.ts b/src/extraction/cfml-extractor.ts
index 8395940c10..a1a668706a 100644
--- a/src/extraction/cfml-extractor.ts
+++ b/src/extraction/cfml-extractor.ts
@@ -4,6 +4,55 @@ import { generateNodeId, NodeIdAllocator } from './tree-sitter-helpers';
 import { TreeSitterExtractor } from './tree-sitter';
 import { getParser } from './grammars';
 
+/** Tags whose own children include an expression: `<cfset …>`, `<cfif …>`, `<cfelseif …>`, `<cfreturn …>`, and `#…#`. */
+const TAG_EXPRESSION_PARENTS: ReadonlySet<string> = new Set([
+  'cf_set_tag',
+  'cf_if_tag',
+  'cf_elseif_tag',
+  'cf_return_tag',
+  'hash_expression',
+]);
+
+/**
+ * The expression node types (shared with the cfscript grammar) that can
+ * contain a call. A positive list, so a tag's markup — body content, its
+ * `var` keyword, an ERROR — is never mistaken for an expression; a bare
+ * identifier or literal can't call anything and is skipped.
+ */
+const TAG_EXPRESSION_TYPES: ReadonlySet<string> = new Set([
+  'call_expression',
+  'member_expression',
+  'subscript_expression',
+  'new_expression',
+  'assignment_expression',
+  'augmented_assignment_expression',
+  'binary_expression',
+  'unary_expression',
+  'update_expression',
+  'ternary_expression',
+  'elvis_expression',
+  'parenthesized_expression',
+  'sequence_expression',
+  'string',
+  'array',
+  'object',
+  'ordered_struct',
+  'function_expression',
+  'arrow_function',
+]);
+
+/** An expression in tag markup and the scope (function, component or file node) that owns its calls. */
+interface TagExpression {
+  startIndex: number;
+  endIndex: number;
+  /** Where it starts in the file — the same line in the source extractTagExpressions synthesizes. */
+  row: number;
+  column: number;
+  /** Its start column in the synthesized source. */
+  textColumn: number;
+  scopeId: string;
+}
+
 /**
  * CfmlExtractor - Extracts code relationships from CFML source (.cfc/.cfm).
  *
@@ -15,7 +64,9 @@ import { getParser } from './grammars';
  * raw AST, so this extractor replicates it: a file whose first real token
  * isn't `<` is delegated wholesale to the cfscript grammar (the dominant
  * modern style); otherwise the file is walked tag-by-tag with the cfml
- * grammar, delegating any `<cfscript>` tag bodies the same way.
+ * grammar, delegating any `<cfscript>` tag bodies the same way — and the
+ * expressions written in tags themselves (`<cfset>`, `<cfif>`, `#hash#`, …)
+ * through the same cfscript extraction (see extractTagExpressions).
  */
 export class CfmlExtractor {
   private filePath: string;
@@ -26,6 +77,7 @@ export class CfmlExtractor {
   private edges: Edge[] = [];
   private unresolvedReferences: UnresolvedReference[] = [];
   private errors: ExtractionError[] = [];
+  private tagExpressions: TagExpression[] = [];
 
   /** `language` is the file's detected language — `'cfml'` for `.cfc`/`.cfm`, `'cfscript'` for `.cfs`. Both dialect-switch internally; this only controls the language tag stamped onto emitted nodes/refs. */
   constructor(filePath: string, source: string, language: Language = 'cfml') {
@@ -95,10 +147,12 @@ export class CfmlExtractor {
   private extractTagBased(): void {
     const parser = getParser('cfml');
     if (!parser) {
+      // Same code as TreeSitterExtractor's missing parser, so a grammar that
+      // failed to load is never stored as this file's index data (#2335).
       this.errors.push({
         message: 'cfml grammar not loaded',
         severity: 'error',
-        code: 'unsupported_language',
+        code: 'parser_error',
       });
       return;
     }
@@ -113,8 +167,14 @@ export class CfmlExtractor {
       return;
     }
 
-    const fileNode = this.createFileNode();
-    this.walkProgram(tree.rootNode, fileNode.id);
+    try {
+      const fileNode = this.createFileNode();
+      this.walkProgram(tree.rootNode, fileNode.id);
+    } finally {
+      // Trees hold wasm heap memory V8's GC never sees — free it per file.
+      tree.delete();
+    }
+    this.extractTagExpressions();
   }
 
   /** Build the file's own `kind:'file'` node, spanning the whole source. Tag-based files need this explicitly — unlike `extractBareScript` (which delegates the whole file to `TreeSitterExtractor` and inherits its file node), `extractTagBased` walks the tree itself and has no other source of one. */
@@ -151,17 +211,11 @@ export class CfmlExtractor {
       if (child.type === 'cf_component_open_tag') {
         child = this.extractComponent(child, fileNodeId).nextSibling;
         continue;
-      } else if (child.type === 'cf_function_tag') {
-        // A cffunction outside any cfcomponent wrapper (rare, but legal in a
-        // .cfm template) — extract as a top-level function, contained by the file.
-        this.extractFunctionTag(child, undefined, fileNodeId);
-      } else if (child.type === 'cf_script_tag') {
-        this.delegateScriptTag(child, fileNodeId);
-      } else if (child.type === 'cf_query_tag') {
-        this.delegateQueryTag(child, fileNodeId);
-      } else {
-        this.delegateNestedTags(child, fileNodeId);
       }
+      // Template scope: a cffunction outside any cfcomponent wrapper (rare,
+      // but legal in a .cfm template) is a top-level function contained by
+      // the file, and template code's calls are the file's.
+      this.visitTag(child, root.type, fileNodeId, undefined, true);
       child = child.nextSibling;
     }
   }
@@ -208,20 +262,7 @@ export class CfmlExtractor {
         language: this.language,
       });
     }
-    const implementsAttr = this.tagAttr(openTag, 'implements');
-    if (implementsAttr) {
-      for (const iface of implementsAttr.split(',').map((s) => s.trim()).filter(Boolean)) {
-        this.unresolvedReferences.push({
-          fromNodeId: classNode.id,
-          referenceName: iface,
-          referenceKind: 'implements',
-          filePath: this.filePath,
-          line: openTag.startPosition.row + 1,
-          column: openTag.startPosition.column,
-          language: this.language,
-        });
-      }
-    }
+    this.pushInheritanceRefs(classNode.id, this.tagAttr(openTag, 'implements'), 'implements', openTag);
 
     // Walk siblings between the open tag and its close tag.
     let sibling = openTag.nextSibling;
@@ -231,15 +272,9 @@ export class CfmlExtractor {
         lastNode = sibling;
         break;
       }
-      if (sibling.type === 'cf_function_tag') {
-        this.extractFunctionTag(sibling, classNode.id, classNode.id, classNode.name);
-      } else if (sibling.type === 'cf_script_tag') {
-        this.delegateScriptTag(sibling, classNode.id, classNode.name);
-      } else if (sibling.type === 'cf_query_tag') {
-        this.delegateQueryTag(sibling, classNode.id);
-      } else {
-        this.delegateNestedTags(sibling, classNode.id, classNode.name);
-      }
+      // Component scope: cffunctions are its methods, pseudo-constructor
+      // code's calls (a component-level `<cfset init()>`) are the component's.
+      this.visitTag(sibling, openTag.parent?.type ?? '', classNode.id, classNode.name, true);
       lastNode = sibling;
       sibling = sibling.nextSibling;
     }
@@ -247,6 +282,54 @@ export class CfmlExtractor {
     return lastNode;
   }
 
+  /**
+   * `<cfinterface extends="IBase,IOther">...</cfinterface>` (#2091). Unlike
+   * `<cfcomponent>` (see the implicit-end-tag note on `extractComponent`) the
+   * grammar has no dedicated rule for it: it is a generic `cf_tag` whose body
+   * — the `<cffunction>` signatures — is ordinary nested children. Named like
+   * a component (the file name, unless a `name` attribute says otherwise), so
+   * `<cfcomponent implements="ISearchable">` resolves to it. An interface may
+   * extend several interfaces, comma-separated.
+   */
+  private extractInterfaceTag(tag: SyntaxNode, containerId: string): void {
+    const startTag = this.cfStartTag(tag) ?? tag;
+    const name = this.tagAttr(startTag, 'name') ?? this.componentNameFromPath();
+    const id = this.nodeIds.generate(this.filePath, 'interface', name, tag.startPosition.row + 1, tag.startPosition.column);
+    this.nodes.push({
+      id,
+      kind: 'interface',
+      name,
+      qualifiedName: `${this.filePath}::${name}`,
+      filePath: this.filePath,
+      language: this.language,
+      startLine: tag.startPosition.row + 1,
+      endLine: tag.endPosition.row + 1,
+      startColumn: tag.startPosition.column,
+      endColumn: tag.endPosition.column,
+      isExported: true,
+      updatedAt: Date.now(),
+    });
+    this.edges.push({ source: containerId, target: id, kind: 'contains' });
+    this.pushInheritanceRefs(id, this.tagAttr(startTag, 'extends'), 'extends', startTag);
+    this.delegateNestedTags(tag, id, name, true);
+  }
+
+  /** One unresolved `extends`/`implements` ref per name in a comma-separated tag attribute. */
+  private pushInheritanceRefs(fromNodeId: string, list: string | undefined, kind: 'extends' | 'implements', tag: SyntaxNode): void {
+    if (!list) return;
+    for (const name of list.split(',').map((s) => s.trim()).filter(Boolean)) {
+      this.unresolvedReferences.push({
+        fromNodeId,
+        referenceName: name,
+        referenceKind: kind,
+        filePath: this.filePath,
+        line: tag.startPosition.row + 1,
+        column: tag.startPosition.column,
+        language: this.language,
+      });
+    }
+  }
+
   /**
    * `<cffunction name="..." access="..." returntype="...">...</cffunction>`.
    * `parentClassId` decides `method` vs top-level `function`; `containerId` is
@@ -290,36 +373,190 @@ export class CfmlExtractor {
       this.edges.push({ source: containerId, target: fnNode.id, kind: 'contains' });
     }
 
-    // Delegate any <cfscript>/<cfquery> bodies nested inside this function, at
-    // any depth (e.g. inside <cfif>/<cfloop>/<cftry> control-flow tags).
+    // Walk the body, at any depth (e.g. inside <cfif>/<cfloop>/<cftry>
+    // control-flow tags): its <cfscript>/<cfquery> bodies and tag
+    // expressions are this function's.
     this.delegateNestedTags(tag, fnNode.id);
   }
 
   /**
-   * Recursively delegates any `cf_script_tag`/`cf_query_tag` found within
-   * `node`'s subtree — e.g. a `<cfscript>`/`<cfquery>` nested inside
-   * `<cfif>`/`<cfloop>`/`<cftry>` control-flow tags, which (unlike
-   * `<cfcomponent>`'s body — see the implicit-end-tag note on `extractComponent`)
-   * ARE normal children, just possibly several levels deep, so a direct-children
-   * check misses them. Does not descend into a nested `cf_function_tag` — that
-   * has its own scope and is walked separately. `parentClassName` rides along
-   * so a `<cfscript>` at component scope classifies its functions as methods
-   * scoped under the component.
+   * Visit one node of tag markup. `containerId` is the scope the node sits in
+   * — the function whose body it is, else the component, else the file — and
+   * owns whatever calls it makes. `declScope` is true outside function bodies
+   * (component/interface/template scope), where a `<cffunction>` declares a
+   * function of that scope; `parentClassName` is set at component/interface
+   * scope, where those functions are methods.
+   *
+   * - `<cfscript>`/`<cfquery>` bodies go to their own grammars (see
+   *   delegateScriptTag / delegateQueryTag).
+   * - A `<cffunction>` is extracted when reached at declaration scope, at any
+   *   depth: `<cfprocessingdirective>` around Application.cfc's handlers
+   *   (#2091) or `<cfsilent>` around a template's helpers doesn't make them
+   *   any less the scope's functions. Never through an ERROR node — at file
+   *   scope that is typically a `<cfcomponent>` the parser lost (behind an
+   *   unclosed `<cfsetting>`), whose methods must not be misfiled as
+   *   top-level functions. Inside a function body a `<cffunction>` would be
+   *   its own scope; CFML rejects that, so it is skipped.
+   * - An expression in tag position — the value of `<cfset>`, the condition
+   *   of `<cfif>`/`<cfelseif>`, the operand of `<cfreturn>`, a `#hash#`
+   *   anywhere in markup, attributes and strings included — is recorded for
+   *   extractTagExpressions. The grammar parses these structurally (the same
+   *   expression rules as cfscript), so `parentType` (the node's parent) is
+   *   enough to tell the expression from the tag around it.
+   */
+  private visitTag(node: SyntaxNode, parentType: string, containerId: string, parentClassName: string | undefined, declScope: boolean): void {
+    switch (node.type) {
+      case 'cf_script_tag':
+        this.delegateScriptTag(node, containerId, parentClassName);
+        return;
+      case 'cf_query_tag':
+        // The SQL body is opaque to this grammar; the walk below only reaches
+        // the tag's attributes (`datasource="#dsn()#"`), never the body twice.
+        this.delegateQueryTag(node, containerId);
+        break;
+      case 'cf_function_tag':
+        if (declScope) this.extractFunctionTag(node, parentClassName ? containerId : undefined, containerId, parentClassName);
+        return;
+      case 'cf_tag': {
+        const name = this.cfTagName(node);
+        if (name === 'interface' && declScope && !parentClassName) {
+          this.extractInterfaceTag(node, containerId);
+          return;
+        }
+        // `<cfloop condition="hasNext()">` — the one common tag attribute whose
+        // plain-text value is a CFML expression rather than a literal.
+        if (name === 'loop') {
+          const condition = this.tagAttrValueNode(this.cfStartTag(node) ?? node, 'condition');
+          if (condition) this.addTagExpression(condition, containerId);
+        }
+        break;
+      }
+      default:
+        if (TAG_EXPRESSION_PARENTS.has(parentType) && TAG_EXPRESSION_TYPES.has(node.type)) {
+          this.addTagExpression(node, containerId);
+          return;
+        }
+    }
+    this.delegateNestedTags(node, containerId, parentClassName, declScope && node.type !== 'ERROR');
+  }
+
+  /**
+   * Visit `node`'s children (see visitTag) — e.g. a `<cfscript>`/`<cfquery>`
+   * nested inside `<cfif>`/`<cfloop>`/`<cftry>` control-flow tags, which
+   * (unlike `<cfcomponent>`'s body — see the implicit-end-tag note on
+   * `extractComponent`) ARE normal children, just possibly several levels
+   * deep, so a direct-children check misses them. `parentClassName` rides
+   * along so a `<cfscript>` at component scope classifies its functions as
+   * methods scoped under the component.
    */
-  private delegateNestedTags(node: SyntaxNode, containerId: string | undefined, parentClassName?: string): void {
+  private delegateNestedTags(node: SyntaxNode, containerId: string, parentClassName?: string, declScope = false): void {
     for (let i = 0; i < node.namedChildCount; i++) {
       const child = node.namedChild(i);
-      if (!child) continue;
-      if (child.type === 'cf_script_tag') {
-        this.delegateScriptTag(child, containerId, parentClassName);
-      } else if (child.type === 'cf_query_tag') {
-        this.delegateQueryTag(child, containerId);
-      } else if (child.type === 'cf_function_tag') {
-        continue;
+      if (child) this.visitTag(child, node.type, containerId, parentClassName, declScope);
+    }
+  }
+
+  /** Record an expression in tag markup, owned by `scopeId`, for extractTagExpressions. */
+  private addTagExpression(node: SyntaxNode, scopeId: string): void {
+    if (node.endIndex <= node.startIndex) return;
+    this.tagExpressions.push({
+      startIndex: node.startIndex,
+      endIndex: node.endIndex,
+      row: node.startPosition.row,
+      column: node.startPosition.column,
+      textColumn: 0,
+      scopeId,
+    });
+  }
+
+  /**
+   * Extract calls from the expressions visitTag recorded, through the same
+   * cfscript extraction a `<cfscript>` body gets — one parse per file, not
+   * one per expression: the expressions are copied out in order, each on its
+   * own line (the line breaks between them are kept, so every line number is
+   * the file's) and ended with a `;`, and the result is read with the
+   * cfscript grammar. Each reference is handed back to the scope whose
+   * expression contains it, its column shifted back to the file's. Only
+   * references are kept: an expression declares nothing (`<cfset var x = …>`
+   * is a function local, and its `var` isn't copied), so a closure written in
+   * one is part of its scope's code.
+   */
+  private extractTagExpressions(): void {
+    const exprs = this.tagExpressions;
+    if (exprs.length === 0) return;
+    exprs.sort((a, b) => a.startIndex - b.startIndex);
+
+    const parts: string[] = [];
+    let pos = 0;
+    let column = 0; // column in the synthesized source
+    for (const expr of exprs) {
+      if (pos > 0) {
+        parts.push(';');
+        column++;
+      }
+      let breaks = 0;
+      for (let at = this.source.indexOf('\n', pos); at !== -1 && at < expr.startIndex; at = this.source.indexOf('\n', at + 1)) breaks++;
+      if (breaks > 0) {
+        parts.push('\n'.repeat(breaks));
+        column = 0;
+      }
+      expr.textColumn = column;
+      const text = this.source.slice(expr.startIndex, expr.endIndex);
+      parts.push(text);
+      const lastBreak = text.lastIndexOf('\n');
+      column = lastBreak === -1 ? column + text.length : text.length - lastBreak - 1;
+      pos = expr.endIndex;
+    }
+
+    const result = new TreeSitterExtractor(this.filePath, parts.join(''), 'cfscript').extract();
+    for (const ref of result.unresolvedReferences) {
+      const expr = this.tagExpressionAt(ref.line - 1, ref.column);
+      // Only an expression's first line moved; its later lines are verbatim.
+      if (ref.line - 1 === expr.row) ref.column += expr.column - expr.textColumn;
+      ref.fromNodeId = expr.scopeId;
+      ref.filePath = this.filePath;
+      ref.language = this.language;
+      this.unresolvedReferences.push(ref);
+    }
+    // A broken expression is routine in hand-written markup and the file's
+    // symbols came from the tag walk, so only a genuine failure is reported —
+    // not the extractor's "no symbols" warning, which an expressions-only
+    // source always earns.
+    for (const error of result.errors) {
+      if (error.severity === 'error') this.errors.push(error);
+    }
+  }
+
+  /** The recorded expression containing a synthesized-source position: the last one starting at or before it. */
+  private tagExpressionAt(row: number, column: number): TagExpression {
+    const exprs = this.tagExpressions;
+    let lo = 0;
+    let hi = exprs.length - 1;
+    let found = 0;
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1;
+      const e = exprs[mid]!;
+      if (e.row < row || (e.row === row && e.textColumn <= column)) {
+        found = mid;
+        lo = mid + 1;
       } else {
-        this.delegateNestedTags(child, containerId, parentClassName);
+        hi = mid - 1;
       }
     }
+    return exprs[found]!;
+  }
+
+  /** A generic `cf_tag`'s start tag — where its name and attributes live. */
+  private cfStartTag(tag: SyntaxNode): SyntaxNode | undefined {
+    return tag.namedChildren.find(
+      (c: SyntaxNode) => c.type === 'cf_start_tag' || c.type === 'cf_start_tag_with_selfclose'
+    );
+  }
+
+  /** A generic `cf_tag`'s name, lowercased, without the `cf` prefix (`<cfLoop>` → `loop`). */
+  private cfTagName(tag: SyntaxNode): string | undefined {
+    const nameNode = this.cfStartTag(tag)?.namedChildren.find((c: SyntaxNode) => c.type === 'cf_tag_name');
+    return nameNode ? this.source.substring(nameNode.startIndex, nameNode.endIndex).toLowerCase() : undefined;
   }
 
   /**
@@ -445,6 +682,18 @@ export class CfmlExtractor {
 
   /** Read a `cf_attribute`'s value by name from a tag node's direct `cf_attribute`/`cf_tag_attributes` children. */
   private tagAttr(tag: SyntaxNode, attrName: string): string | undefined {
+    const valueNode = this.tagAttrValueNode(tag, attrName);
+    if (valueNode === undefined) return undefined;
+    if (!valueNode) return '';
+    return this.source.substring(valueNode.startIndex, valueNode.endIndex);
+  }
+
+  /**
+   * The `attribute_value` node of a tag attribute — `undefined` when the tag
+   * has no such attribute, `null` when its value isn't plain text (empty, or
+   * a `#hash#` expression).
+   */
+  private tagAttrValueNode(tag: SyntaxNode, attrName: string): SyntaxNode | null | undefined {
     const attrs: SyntaxNode[] = [];
     for (let i = 0; i < tag.namedChildCount; i++) {
       const child = tag.namedChild(i);
@@ -467,9 +716,7 @@ export class CfmlExtractor {
       const valueWrapper = attr.namedChildren.find(
         (c: SyntaxNode) => c.type === 'quoted_cf_attribute_value' || c.type === 'cf_attribute_value'
       );
-      const valueNode = valueWrapper?.namedChildren.find((c: SyntaxNode) => c.type === 'attribute_value');
-      if (!valueNode) return '';
-      return this.source.substring(valueNode.startIndex, valueNode.endIndex);
+      return valueWrapper?.namedChildren.find((c: SyntaxNode) => c.type === 'attribute_value') ?? null;
     }
     return undefined;
   }
diff --git a/src/extraction/commonjs-requires.ts b/src/extraction/commonjs-requires.ts
new file mode 100644
index 0000000000..436a03385c
--- /dev/null
+++ b/src/extraction/commonjs-requires.ts
@@ -0,0 +1,68 @@
+/**
+ * CommonJS `require('…')` as an import.
+ *
+ * An ESM `import … from './application'` is an `import_statement` the
+ * extractor turns into an `imports` reference from the file, which the import
+ * resolver lands on the module's file. A `require('./application')` is just a
+ * call, so a CommonJS file depended on nothing at file level: Express's
+ * `lib/express.js` requires `./application`, `./request` and `./response` and
+ * the index said it imports nothing — an empty Imports rail in the viewer, no
+ * link on the Map, and no file dependency for impact. A binding used only as a
+ * value (`mixin(app, proto)`) never made a call edge to stand in for it either.
+ *
+ * Read from the source after extraction rather than in a walker, so the wasm
+ * extractor and the native kernel get it alike — including the kernel's
+ * deferred-decode transport, which carries these beside its buffers. Only the
+ * module's own file reference is emitted — the names a binding is called
+ * through already resolve through the require binding (import-resolver's
+ * CommonJS reader).
+ */
+
+import type { Language, UnresolvedReference } from '../types';
+import { stripCommentsForRegex } from '../resolution/strip-comments';
+
+const COMMONJS_LANGUAGES: ReadonlySet<Language> = new Set(['javascript', 'jsx', 'typescript', 'tsx']);
+
+/**
+ * `require('x')` with a literal specifier, not a member's (`foo.require(…)`)
+ * or a property (`require.resolve(…)`). A template literal counts only when
+ * it has no `${…}` hole.
+ */
+const REQUIRE_CALL = /(?<![\w$.])require\s*\(\s*(?:'([^'\n]+)'|"([^"\n]+)"|`([^`$\n]+)`)\s*\)/g;
+
+/**
+ * A module of this project: a relative or rooted path, or a project alias
+ * (`@/lib/x`, `~/x`, `#internal`). A package (`express`, `lodash/fp`) is
+ * outside the index — as a name it would only match some same-named symbol.
+ */
+const LOCAL_SPECIFIER = /^(?:\.{1,2}(?:\/|$)|\/|[@~]\/|#)/;
+
+/** `import x = require('y')` is TypeScript's import-equals: an `import_statement` already. */
+const IMPORT_EQUALS = /\bimport\s+(?:type\s+)?[\w$]+\s*=\s*$/;
+
+/** The file node both extractors mint: `file:<path>`. */
+export function commonJsRequireRefs(filePath: string, source: string, language: Language): UnresolvedReference[] {
+  if (!COMMONJS_LANGUAGES.has(language) || !source.includes('require')) return [];
+  const safe = stripCommentsForRegex(source, language === 'javascript' || language === 'jsx' ? 'javascript' : 'typescript');
+  const out: UnresolvedReference[] = [];
+  const seen = new Set<string>();
+  REQUIRE_CALL.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = REQUIRE_CALL.exec(safe)) !== null) {
+    const specifier = (m[1] ?? m[2] ?? m[3] ?? '').trim();
+    if (!LOCAL_SPECIFIER.test(specifier) || seen.has(specifier)) continue;
+    const lineStart = safe.lastIndexOf('\n', m.index - 1) + 1;
+    if (IMPORT_EQUALS.test(safe.slice(lineStart, m.index))) continue;
+    seen.add(specifier);
+    out.push({
+      fromNodeId: `file:${filePath}`,
+      referenceName: specifier,
+      referenceKind: 'imports',
+      line: safe.slice(0, m.index).split('\n').length,
+      column: m.index - lineStart,
+      filePath,
+      language,
+    });
+  }
+  return out;
+}
diff --git a/src/extraction/extraction-version.ts b/src/extraction/extraction-version.ts
index 3691e95f0a..e41b5f6149 100644
--- a/src/extraction/extraction-version.ts
+++ b/src/extraction/extraction-version.ts
@@ -21,4 +21,4 @@
  * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty
  * in the product is load-bearing").
  */
-export const EXTRACTION_VERSION = 27;
+export const EXTRACTION_VERSION = 28;
diff --git a/src/extraction/generated-detection.ts b/src/extraction/generated-detection.ts
index b92ab860bd..83ec2b1aad 100644
--- a/src/extraction/generated-detection.ts
+++ b/src/extraction/generated-detection.ts
@@ -64,7 +64,7 @@ const GENERATED_PATTERNS: ReadonlyArray<RegExp> = [
   /_grpc_pb\.[jt]s$/,
   // Minified bundles vendored into a repo (docs sites, examples). Their
   // single-letter symbols make name-based edges pure noise.
-  /\.min\.m?js$/,
+  /[.-]min\.m?js$/,
   // Python — protobuf / gRPC / openapi-codegen
   /_pb2(_grpc)?\.py$/,
   /_pb2\.pyi$/,
@@ -249,5 +249,42 @@ export function hasGeneratedHeader(content: string): boolean {
  * indexer persists to `files.generated`.
  */
 export function detectGeneratedFile(filePath: string, content: string): boolean {
-  return isGeneratedFile(filePath) || hasGeneratedHeader(content);
+  return isGeneratedFile(filePath) || hasGeneratedHeader(content) || isMinifiedContent(filePath, content);
+}
+
+/** Scripts a bundler or minifier writes as a few enormous lines. */
+const MINIFIABLE_SCRIPT = /\.(?:m?js|cjs)$/i;
+/** The loader every webpack bundle defines for its modules. */
+const WEBPACK_RUNTIME = /\bfunction __webpack_require__\s*\(/;
+/** A line this long is not written by hand. */
+const MINIFIED_LINE_CHARS = 1000;
+
+/**
+ * A minified or bundled script that is not NAMED so — a docs site's
+ * `bundle.js`, a sample's vendored `app.js`: most of its text sits on lines of
+ * a thousand characters or more, and that text is code, dense with `;{}(),`,
+ * not one long string literal (a base64 fixture) in an ordinary file. Its
+ * one-letter functions (`n`, `t`, `e`) otherwise topped the most-depended-on
+ * lists of the projects that vendor it.
+ */
+export function isMinifiedContent(filePath: string, content: string): boolean {
+  if (!MINIFIABLE_SCRIPT.test(filePath) || content.length < 4 * MINIFIED_LINE_CHARS) return false;
+  // A webpack build carries its module loader, however readable its lines.
+  if (WEBPACK_RUNTIME.test(content)) return true;
+  let long = 0;
+  let punctuation = 0;
+  for (let start = 0; start < content.length; ) {
+    let end = content.indexOf('\n', start);
+    if (end < 0) end = content.length;
+    if (end - start >= MINIFIED_LINE_CHARS) {
+      long += end - start;
+      for (let i = start; i < end; i++) {
+        const c = content.charCodeAt(i);
+        // ; { } ( ) ,
+        if (c === 59 || c === 123 || c === 125 || c === 40 || c === 41 || c === 44) punctuation++;
+      }
+    }
+    start = end + 1;
+  }
+  return long >= content.length * 0.5 && punctuation >= long * 0.03;
 }
diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts
index 84596d81c5..ed1966c705 100644
--- a/src/extraction/grammars.ts
+++ b/src/extraction/grammars.ts
@@ -7,9 +7,10 @@
  */
 
 import * as path from 'path';
+import * as fs from 'fs';
 import * as fsp from 'fs/promises';
 import { Parser, Language as WasmLanguage } from 'web-tree-sitter';
-import { Language } from '../types';
+import { ExtractionError, Language } from '../types';
 
 export type GrammarLanguage = Exclude<Language, 'svelte' | 'vue' | 'astro' | 'liquid' | 'razor' | 'yaml' | 'twig' | 'xml' | 'properties' | 'unknown'>;
 
@@ -241,10 +242,14 @@ export function hasMpegTsExtension(filePath: string): boolean {
  * `overrides` is the project's validated custom extension → language map (from
  * `codegraph.json`); when present its extensions count as indexable in addition
  * to the built-ins. Omitting it is byte-identical to the zero-config behavior.
+ *
+ * `rootDir` is the project root `filePath` is relative to. A Shopify theme's
+ * JSON templates count only when it is given, since telling a theme apart takes
+ * a look at the files beside them (see `isShopifyLiquidJson`).
  */
-export function isSourceFile(filePath: string, overrides?: Record<string, Language>): boolean {
+export function isSourceFile(filePath: string, overrides?: Record<string, Language>, rootDir?: string): boolean {
   if (isPlayRoutesFile(filePath)) return true; // Play `conf/routes` is extensionless
-  if (isShopifyLiquidJson(filePath)) return true; // Shopify OS 2.0 JSON templates / section groups
+  if (isShopifyLiquidJson(filePath, rootDir)) return true; // Shopify OS 2.0 JSON templates / section groups
   if (isErlangAppFile(filePath)) return true; // OTP `.app`/`.app.src` resource files
   const dot = filePath.lastIndexOf('.');
   if (dot < 0) return false;
@@ -252,15 +257,55 @@ export function isSourceFile(filePath: string, overrides?: Record<string, Langua
   return ext in EXTENSION_MAP || (!!overrides && ext in overrides);
 }
 
+/**
+ * What marks a Shopify theme's root, beside its `templates/` and `sections/`:
+ * the `layout/theme.liquid` every theme must have, or its settings schema.
+ */
+const SHOPIFY_THEME_MARKERS = ['layout/theme.liquid', 'config/settings_schema.json'];
+
+/** The folders a Shopify theme is made of. */
+const SHOPIFY_THEME_FOLDERS = /^(assets|blocks|config|layout|locales|sections|snippets|templates)$/i;
+
+/**
+ * The root of the Shopify theme `filePath` is in: the directory holding the
+ * theme folder (one `folders` matches) the file sits in, when that directory
+ * also holds one of `SHOPIFY_THEME_MARKERS`. Project-relative and
+ * `/`-separated, '' for the project root; undefined when the file is in no
+ * theme. `exists` says whether a project-relative path exists. The folder
+ * nearest the file is tried first.
+ */
+export function shopifyThemeRoot(
+  filePath: string,
+  exists: (relativePath: string) => boolean,
+  folders: RegExp = SHOPIFY_THEME_FOLDERS,
+): string | undefined {
+  const segments = filePath.split('/');
+  for (let i = segments.length - 2; i >= 0; i--) {
+    if (!folders.test(segments[i]!)) continue;
+    const themeDir = segments.slice(0, i).join('/');
+    if (SHOPIFY_THEME_MARKERS.some((marker) => exists(themeDir ? `${themeDir}/${marker}` : marker))) return themeDir;
+  }
+  return undefined;
+}
+
 /**
  * Shopify OS 2.0 JSON template (`templates/*.json`) or section group
  * (`sections/*.json`) — these reference sections by `"type"`, so the Liquid
  * extractor links them. (config/ + locales/ JSON have no section refs.)
- */
-export function isShopifyLiquidJson(filePath: string): boolean {
+ *
+ * Only inside a Shopify theme: the directory holding that `templates/` or
+ * `sections/` must also hold one of `SHOPIFY_THEME_MARKERS`. Plenty of other
+ * projects keep JSON in folders with those names — a .NET project template's
+ * `templates/<name>/.template.config/template.json`, schematics, CMS content —
+ * and it is not Liquid. The theme is looked for under `rootDir`, the project
+ * root `filePath` is relative to; without one there is no theme to find.
+ */
+export function isShopifyLiquidJson(filePath: string, rootDir?: string): boolean {
   // Allow nested template dirs (`templates/customers/login.json`), not just
   // top-level (`templates/product.json`).
-  return /(^|\/)(templates|sections)\/.+\.json$/i.test(filePath);
+  if (rootDir === undefined || !/(^|\/)(templates|sections)\/.+\.json$/i.test(filePath)) return false;
+  const exists = (relativePath: string): boolean => fs.existsSync(path.join(rootDir, relativePath));
+  return shopifyThemeRoot(filePath, exists, /^(templates|sections)$/i) !== undefined;
 }
 
 /**
@@ -390,6 +435,8 @@ const VENDORED_WASM_LANGS: ReadonlySet<GrammarLanguage> = new Set([
   // crate is UNUSABLE by the kernel (pins tree-sitter <0.23) and
   // tree-sitter-kotlin-ng is a different grammar — the kernel compiles the
   // same vendored C sources instead (codegraph-kernel/grammars/kotlin).
+  // Both carry docs/grammars/tree-sitter-kotlin.patch (scanner: no automatic
+  // semicolon before a same-line `e` word, e.g. an `eq` infix call).
   'kotlin',
   // R7b batch 4 (Dart kernel port prep): the byte-copied tree-sitter-wasms
   // 0.1.13 artifact (sha256 7f5364e4…, built from UserNobody14/
@@ -534,29 +581,136 @@ export function getParser(language: Language): Parser | null {
  * `overrides` is the project's validated custom extension → language map (from
  * `codegraph.json`); when present its mappings take precedence over the built-in
  * `EXTENSION_MAP`. Omitting it is byte-identical to the zero-config behavior.
+ *
+ * `rootDir` is the project root `filePath` is relative to, as for
+ * `isSourceFile`: a Shopify theme's JSON templates are Liquid only with it.
  */
-export function detectLanguage(filePath: string, source?: string, overrides?: Record<string, Language>): Language {
+export function detectLanguage(filePath: string, source?: string, overrides?: Record<string, Language>, rootDir?: string): Language {
   // Play `conf/routes` has no grammar — route through the no-symbol path; the
   // Play framework resolver extracts route nodes from it.
   if (isPlayRoutesFile(filePath)) return 'yaml';
   const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
-  // Shopify OS 2.0 JSON templates / section groups → the Liquid extractor (it
-  // links each section `"type"` to its `sections/<type>.liquid`).
-  if (isShopifyLiquidJson(filePath)) return 'liquid';
+  // A Shopify theme's OS 2.0 JSON templates / section groups → the Liquid
+  // extractor (it links each section `"type"` to its `sections/<type>.liquid`).
+  if (isShopifyLiquidJson(filePath, rootDir)) return 'liquid';
   // OTP `.app`/`.app.src` resource files — Erlang terms the grammar parses as
   // top-level expressions (last-dot ext `.src` is too generic for the map).
   if (isErlangAppFile(filePath)) return 'erlang';
   const lang = (overrides && overrides[ext]) || EXTENSION_MAP[ext] || 'unknown';
 
+  // A Flow-typed `.js` (`// @flow` in its leading comments) parses as TSX:
+  // the JavaScript grammar can't read its annotations — `render(): React.Node`
+  // cut a class short — and TypeScript's syntax covers most of Flow's.
+  if ((lang === 'javascript' || lang === 'jsx') && source && hasFlowPragma(source)) return 'tsx';
+
   // .h files could be C, C++, or Objective-C — check source content
   if (lang === 'c' && ext === '.h' && source) {
     if (looksLikeCpp(source)) return 'cpp';
     if (looksLikeObjc(source)) return 'objc';
   }
 
+  // `.inc` is PHP's include extension (Drupal) and Pascal/Delphi's too
+  // (`{$I defs.inc}`: directive blocks, declaration fragments), so it is
+  // decided per file by content (#2279). An explicit codegraph.json mapping
+  // for `.inc` is the user's answer and is not second-guessed.
+  if (lang === 'php' && ext === '.inc' && source && !(overrides && overrides[ext]) && looksLikePascalInclude(source)) {
+    return 'pascal';
+  }
+
   return lang;
 }
 
+/** A PHP open tag: `<?php` in any case, or the short echo `<?=` (never `<?xml`). */
+const PHP_OPEN_TAG_RE = /<\?(?:php|=)/i;
+
+// Building blocks for the Pascal line shapes below. A line start allows
+// indentation and the BOM Windows editors write (a BOM'd Delphi include must
+// not drop back to PHP). A section keyword's break runs to the end of its line
+// and over blank / comment-only lines, up to the first declaration.
+const PAS_LINE = String.raw`^[ \t\uFEFF]*`;
+const PAS_NAME = String.raw`[a-z_]\w*(?:<[^>\n]*>)?`;
+const PAS_QNAME = String.raw`[a-z_][\w.]*(?:<[^>\n]*>)?`;
+const PAS_COMMENT = String.raw`(?:\/\/[^\n]*|\{[^$}\n][^}\n]*\}[ \t]*)?`;
+const PAS_SECTION_BREAK = String.raw`[ \t]*${PAS_COMMENT}(?:\r?\n[ \t]*${PAS_COMMENT})+`;
+const pascalLine = (shape: string): RegExp => new RegExp(PAS_LINE + shape, 'im');
+
+/**
+ * Line shapes only Pascal writes, any one of which makes an untagged `.inc`
+ * Pascal. Each leans on Pascal's own punctuation, so the dialects that share a
+ * keyword with it stay out: JavaScript `const x = 1;` / `function f() {`,
+ * SourcePawn `function void (int client);`, C++ `const T X::Y = …`, VBScript
+ * `Const X = 1` / `Function F(a)`, Smarty `{$var}`, Makefile `X := y`, prose
+ * with `Begin` on a line of its own. Every pattern stays linear on a long
+ * whitespace run: no run can be split two ways between neighbouring
+ * quantifiers.
+ */
+const PASCAL_INCLUDE_SIGNALS: readonly RegExp[] = [
+  // A compiler directive: a name and an argument (`{$IFDEF X}`, `{$DEFINE X}`,
+  // `{$I file.inc}`, `{$WARN X OFF}`), a bare `{$ELSE}` / `{$ENDIF}` /
+  // `{$IFEND}`, or a switch (`{$R-}`, `{$A+,B-}`) — or the `{%MainUnit x.pp}`
+  // line Lazarus opens its include files with.
+  pascalLine(String.raw`\{(?:\$(?:[a-z]\w*[ \t]+[^\s}]|(?:else|endif|ifend)[ \t]*\}|[a-z][+-][,}])|%MainUnit\b)`),
+  // A routine header, closed by `;`: `procedure Foo;`, `procedure TForm1.Click(Sender: TObject);`,
+  // `class constructor Create;` — and a function's result type after its
+  // parameters (`function Bar(A: Integer): string;`; bare `function Bar;` is
+  // the implementation-section short form). The parameter list stops at any
+  // parenthesis, so a file of unclosed `procedure X(` lines stays linear.
+  pascalLine(
+    String.raw`(?:class[ \t]+)?(?:(?:procedure|constructor|destructor)[ \t]+${PAS_QNAME}[ \t]*(?:\([^()]*\)[ \t]*)?` +
+      String.raw`|function[ \t]+${PAS_QNAME}[ \t]*(?:(?:\([^()]*\)[ \t]*)?:[ \t]*[\w.]+(?:<[^>\n]*>)?[ \t]*)?);`
+  ),
+  // `unit Foo;` and a `uses A, B;` clause.
+  pascalLine(String.raw`unit[ \t]+[a-z_][\w.]*[ \t]*;`),
+  pascalLine(String.raw`uses\s+[a-z_][\w.]*(?:\s*,\s*[a-z_][\w.]*)*\s*;`),
+  // A `const` section, then `X = …` / `X: T = …`; or a typed constant on one
+  // line (`const Max: Integer = 10;`). The type never holds a `:`.
+  pascalLine(
+    String.raw`(?:const|resourcestring)(?:${PAS_SECTION_BREAK}[a-z_]\w*[ \t]*(?::[^=;:\n]+)?=|[ \t]+[a-z_]\w*[ \t]*:[^=;:\n]+=)`
+  ),
+  // A `var` section: `G, H: Integer;`, on the keyword's line or below it.
+  pascalLine(
+    String.raw`(?:var|threadvar)(?:${PAS_SECTION_BREAK}|[ \t]+)[a-z_]\w*(?:[ \t]*,[ \t]*[a-z_]\w*)*[ \t]*:(?!:)[^;\n]*;`
+  ),
+  // A `type` section, then `TFoo =`; or `type TFoo = class…` (record /
+  // interface / set of / array / procedure type) on one line.
+  pascalLine(
+    String.raw`type(?:${PAS_SECTION_BREAK}${PAS_NAME}[ \t]*=|[ \t]+${PAS_NAME}[ \t]*=[ \t]*(?:packed[ \t]+)?` +
+      String.raw`(?:class|record|object|interface|dispinterface|set[ \t]+of|array|reference[ \t]+to|procedure|function)\b)`
+  ),
+];
+
+/** A `begin` … `end;` block: both halves needed, so neither alone flips a file. */
+const PASCAL_BEGIN_RE = pascalLine(String.raw`begin\b`);
+const PASCAL_END_RE = pascalLine(String.raw`end[ \t]*[;.][ \t]*$`);
+
+/**
+ * Whether an `.inc` file is a Pascal include rather than a PHP one (#2279).
+ *
+ * A PHP include always opens a PHP tag somewhere, so a tag anywhere keeps the
+ * file PHP. Without one, a Pascal-only line shape (`PASCAL_INCLUDE_SIGNALS`,
+ * or a `begin` … `end;` pair) makes it Pascal. Anything else keeps the PHP
+ * mapping — untagged text is inline HTML to PHP, so nothing is extracted —
+ * rather than handing a C / assembly / POV-Ray / ASP `.inc` to the Pascal
+ * grammar's error recovery.
+ *
+ * Deliberately per file, not "does this project have `.pas` files": the
+ * answer depends only on the file's own bytes, so a full index, a sync of one
+ * edited include, and a fresh re-index always agree — a project-level gate
+ * would flip an untouched include whenever the last `.pas` file came or went.
+ */
+function looksLikePascalInclude(source: string): boolean {
+  if (PHP_OPEN_TAG_RE.test(source)) return false;
+  if (PASCAL_INCLUDE_SIGNALS.some((re) => re.test(source))) return true;
+  return PASCAL_BEGIN_RE.test(source) && PASCAL_END_RE.test(source);
+}
+
+/** Whether a JavaScript file's leading comments carry Flow's `@flow` pragma (and not `@noflow`). */
+export function hasFlowPragma(source: string): boolean {
+  const head = source.slice(0, 4096).replace(/^#![^\n]*\n/, '');
+  const lead = /^(?:\s*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/))*/.exec(head)?.[0] ?? '';
+  return /@flow\b/.test(lead) && !/@noflow\b/.test(lead);
+}
+
 /**
  * A class/struct BASE CLAUSE — `struct Derived : Base {`, `class Foo final :
  * public Bar, private Baz {`, `struct D : ns::B<T> {` — which is never valid
@@ -722,6 +876,21 @@ export function getUnavailableGrammarErrors(): Partial<Record<Language, string>>
   return out;
 }
 
+/**
+ * Whether these extraction errors say the file was never parsed because its
+ * grammar was not available (`parser_error`, recorded by the extractor when
+ * `getParser` has nothing for the language).
+ *
+ * That is a fact about the running process, not about the file: a daemon whose
+ * install was upgraded or deleted underneath it fails every lazy grammar load
+ * (#2335). Such a result must never replace a file's index data, and a row an
+ * older engine stored that way must be re-indexed — not treated as current
+ * because its content hash still matches.
+ */
+export function hasGrammarLoadFailure(errors: readonly ExtractionError[] | undefined): boolean {
+  return !!errors && errors.some((e) => e.code === 'parser_error');
+}
+
 /**
  * Get language display name
  */
diff --git a/src/extraction/index.ts b/src/extraction/index.ts
index dfa41ef25a..8566e03988 100644
--- a/src/extraction/index.ts
+++ b/src/extraction/index.ts
@@ -15,26 +15,26 @@ import {
   FileRecord,
   ExtractionResult,
   ExtractionError,
-  Node,
   Edge,
   UnresolvedReference,
-  ReferenceKind,
 } from '../types';
-import { QueryBuilder } from '../db/queries';
+import { QueryBuilder, NodeIdentity } from '../db/queries';
 import { extractFromSource } from './tree-sitter';
 import { ParseWorkerPool, resolveParsePoolSize, resolveParseTimeoutMs } from './parse-pool';
 import { StoreWriter, StoreBundle, finalizeStoreBundle } from './store-writer';
 import { materializeKernelResult } from './kernel';
 import { detectGeneratedFile } from './generated-detection';
-import { detectLanguage, isSourceFile, isLanguageSupported, isFileLevelOnlyLanguage, initGrammars, loadGrammarsForLanguages, readGrammarWasmBytes, isMpegTransportStream, hasMpegTsExtension, MPEG_TS_SNIFF_BYTES } from './grammars';
+import { detectLanguage, isSourceFile, isLanguageSupported, isFileLevelOnlyLanguage, initGrammars, loadGrammarsForLanguages, readGrammarWasmBytes, isMpegTransportStream, hasMpegTsExtension, MPEG_TS_SNIFF_BYTES, hasGrammarLoadFailure } from './grammars';
 import { loadExtensionOverrides, loadIncludeIgnoredPatterns, loadExcludePatterns, loadIncludePatterns, PROJECT_CONFIG_FILENAME } from '../project-config';
 import { isCodeGraphDataDir } from '../directory';
 import { logDebug, logWarn } from '../errors';
 import { validatePathWithinRoot, normalizePath } from '../utils';
 import ignore, { Ignore } from 'ignore';
-import { detectFrameworks } from '../resolution/frameworks';
+import { detectFrameworks, getFrameworkResolver } from '../resolution/frameworks';
+import { declaredDependencies } from '../resolution/frameworks/package-deps';
 import type { ResolutionContext } from '../resolution/types';
 import { createYielder, type MaybeYield } from '../resolution/cooperative-yield';
+import { resurrectRefFromDroppedEdge } from '../resolution/resurrect-ref';
 import { MAX_SOURCE_FILE_SIZE_BYTES, oversizeStamp, readBoundedSource, readBoundedSourceSync } from '../file-limits';
 export { oversizeStamp };
 
@@ -114,6 +114,12 @@ export interface IndexResult {
   nodesCreated: number;
   edgesCreated: number;
   errors: ExtractionError[];
+  /**
+   * Wall time in milliseconds. `CodeGraph.indexAll` reports the whole run —
+   * scanning, parsing and storing, then resolving references and linking —
+   * as it does the node and edge totals; the orchestrator's own result
+   * covers only the files' extraction.
+   */
   durationMs: number;
 }
 
@@ -132,8 +138,15 @@ export interface SyncResult {
   filesModified: number;
   filesRemoved: number;
   nodesUpdated: number;
+  /**
+   * Wall time in milliseconds. `CodeGraph.sync` reports the whole sync,
+   * resolution and linking included; the orchestrator's own result covers
+   * only reconciling and re-extracting the files.
+   */
   durationMs: number;
   changedFilePaths?: string[];
+  /** The part of `changedFilePaths` that was not indexed before this sync. */
+  addedFilePaths?: string[];
   /** Paths not absorbed because reading or extraction failed; retain for status/retry. */
   failedFilePaths?: string[];
   /**
@@ -589,7 +602,7 @@ function collectIncludedFiles(
       if (defaults.ignores(rel)) return;
       if (!include.ignores(rel)) return;
       if (exclude && exclude.ignores(rel)) return;
-      if (!isSourceFile(rel, overrides)) return;
+      if (!isSourceFile(rel, overrides, rootDir)) return;
       out.add(rel);
     }
   };
@@ -798,14 +811,26 @@ function findNestedGitRepos(absDir: string, relPrefix: string): string[] {
  */
 export function preloadLanguagesForFiles(
   files: string[],
-  overrides?: Record<string, Language>
+  overrides?: Record<string, Language>,
+  rootDir?: string
 ): Language[] {
-  const languages = [...new Set(files.map((f) => detectLanguage(f, undefined, overrides)))];
+  const languages = [...new Set(files.map((f) => detectLanguage(f, undefined, overrides, rootDir)))];
+  // A Flow-typed `.js` is read with the TSX grammar (see detectLanguage).
+  if ((languages.includes('javascript') || languages.includes('jsx')) && !languages.includes('tsx')) languages.push('tsx');
   if (languages.includes('c')) {
     for (const ambiguous of ['cpp', 'objc'] as const) {
       if (!languages.includes(ambiguous)) languages.push(ambiguous);
     }
   }
+  // An `.inc` path-detects as PHP but may read as Pascal (#2279) — unless
+  // codegraph.json maps `.inc` explicitly, which detectLanguage never overrides.
+  if (
+    !languages.includes('pascal') &&
+    !(overrides && overrides['.inc']) &&
+    files.some((f) => f.toLowerCase().endsWith('.inc'))
+  ) {
+    languages.push('pascal');
+  }
   return languages;
 }
 
@@ -1334,7 +1359,8 @@ export function getGitChangedFiles(rootDir: string, sinceCommit?: string | null)
     // Custom extension → language overrides from the project's codegraph.json,
     // so change detection sees the same custom-extension files the full index does.
     const overrides = loadExtensionOverrides(rootDir);
-    collectGitStatus(rootDir, '', changes, overrides, loadIncludeIgnoredMatcher(rootDir), loadExcludeMatcher(rootDir), sinceCommit ?? undefined);
+    const isSource = (filePath: string): boolean => isSourceFile(filePath, overrides, rootDir);
+    collectGitStatus(rootDir, '', changes, isSource, loadIncludeIgnoredMatcher(rootDir), loadExcludeMatcher(rootDir), sinceCommit ?? undefined);
     return changes;
   } catch {
     return null;
@@ -1406,7 +1432,7 @@ export function canTrustGitFastPath(rootDir: string, sinceCommit?: string | null
   }
 }
 
-function collectGitStatus(repoDir: string, prefix: string, out: GitChanges, overrides?: Record<string, Language>, includeIgnored: Ignore | null = null, exclude: Ignore | null = null, sinceCommit?: string): void {
+function collectGitStatus(repoDir: string, prefix: string, out: GitChanges, isSource: (filePath: string) => boolean, includeIgnored: Ignore | null = null, exclude: Ignore | null = null, sinceCommit?: string): void {
   const output = execFileSync(
     'git',
     // `-uall` lists individual untracked files instead of collapsing an
@@ -1435,7 +1461,7 @@ function collectGitStatus(repoDir: string, prefix: string, out: GitChanges, over
   // filtered by exactly the rules a working-tree change is (#766, #999, #1829).
   const classify = (statusCode: string, rel: string): void => {
     const filePath = normalizePath(prefix + rel);
-    if (!isSourceFile(filePath, overrides)) return;
+    if (!isSource(filePath)) return;
 
     if (statusCode.includes('D')) {
       // Deletions stay unfiltered: getChangedFiles acts on one only when the
@@ -1499,11 +1525,11 @@ function collectGitStatus(repoDir: string, prefix: string, out: GitChanges, over
   // and they are left alone (#970, #976), mirroring the full-index scan.
   for (const rel of untrackedDirs) {
     for (const repoRel of findNestedGitRepos(path.join(repoDir, rel), rel)) {
-      collectGitStatus(path.join(repoDir, repoRel), prefix + repoRel, out, overrides, includeIgnored, exclude);
+      collectGitStatus(path.join(repoDir, repoRel), prefix + repoRel, out, isSource, includeIgnored, exclude);
     }
   }
   for (const rel of findIgnoredEmbeddedRepos(repoDir, includeIgnored, prefix)) {
-    collectGitStatus(path.join(repoDir, rel), prefix + rel, out, overrides, includeIgnored, exclude);
+    collectGitStatus(path.join(repoDir, rel), prefix + rel, out, isSource, includeIgnored, exclude);
   }
 }
 
@@ -1527,7 +1553,7 @@ export function scanDirectory(
     const files: string[] = [];
     let count = 0;
     for (const filePath of gitFiles) {
-      if (isSourceFile(filePath, overrides)) {
+      if (isSourceFile(filePath, overrides, rootDir)) {
         files.push(filePath);
         count++;
         onProgress?.(count, filePath);
@@ -1578,7 +1604,7 @@ export async function scanDirectoryAsync(
     const files: string[] = [];
     let count = 0;
     for (const filePath of gitFiles) {
-      if (isSourceFile(filePath, overrides)) {
+      if (isSourceFile(filePath, overrides, rootDir)) {
         files.push(filePath);
         count++;
         onProgress?.(count, filePath);
@@ -1686,7 +1712,7 @@ function scanDirectoryWalk(
             }
           } else if (stat.isFile()) {
             if (!isIgnored(fullPath, false, active)) {
-              if (isSourceFile(relativePath, overrides)) {
+              if (isSourceFile(relativePath, overrides, rootDir)) {
                 files.push(relativePath);
                 count++;
                 onProgress?.(count, relativePath);
@@ -1707,7 +1733,7 @@ function scanDirectoryWalk(
         }
       } else if (entry.isFile()) {
         if (!isIgnored(fullPath, false, active)) {
-          if (isSourceFile(relativePath, overrides)) {
+          if (isSourceFile(relativePath, overrides, rootDir)) {
             files.push(relativePath);
             count++;
             onProgress?.(count, relativePath);
@@ -1746,35 +1772,68 @@ function scanDirectoryWalk(
 }
 
 /**
- * Resurrect a resolution edge that is about to be dropped (its target symbol
- * was removed, renamed, or its whole file deleted) as the ORIGINAL unresolved
- * reference that created it, read from the refName/refKind stamp
- * `createEdges` writes into edge metadata. Inserted as status='pending', the
- * ref is consumed by the same sync's resolution sweep: it rebinds to an
- * alternative definition if one exists, or parks as status='failed' where the
- * #1240 retry finds it if the symbol later reappears.
- *
- * Returns null — drop silently, the pre-#1240 behavior — for edges without a
- * refName stamp (created before the stamp existed, or synthesized): rebuilding
- * a ref from the target's plain node name would strip the receiver/qualifier
- * context the original text carried (`h.greet` → `greet`) and could rebind
- * somewhere a full re-index never would. Silent beats wrong.
+ * What tells a file's nodes apart across a re-index, coarsest first. (kind,
+ * name) is the #899 key and settles every name a file defines once; a name it
+ * defines more than once — the same method on two classes, a method's
+ * overloads — is split further by qualified name, then by signature (#2276).
+ */
+const REINDEX_IDENTITY_TIERS: ReadonlyArray<(n: NodeIdentity) => string> = [
+  (n) => `${n.kind}\0${n.name}`,
+  (n) => n.qualifiedName,
+  (n) => n.signature ?? '',
+];
+
+function groupNodeIdentities(
+  nodes: readonly NodeIdentity[],
+  key: (n: NodeIdentity) => string
+): Map<string, NodeIdentity[]> {
+  const groups = new Map<string, NodeIdentity[]>();
+  for (const n of nodes) {
+    const k = key(n);
+    const group = groups.get(k);
+    if (group) group.push(n);
+    else groups.set(k, [n]);
+  }
+  return groups;
+}
+
+/**
+ * Pair each node a file had before a re-index with the node that replaces it,
+ * old id → new id. Ids embed the start line, so they can't be compared across
+ * an edit. Each tier of {@link REINDEX_IDENTITY_TIERS} splits the groups the
+ * one before left ambiguous, and a group down to one node on each side is a
+ * pair. Nodes still identical after every tier (overloads in a language that
+ * records no signature) pair by position, but only when both sides have the
+ * same number of them. Anything else stays unpaired: the caller re-resolves
+ * its edges from their original reference instead of handing them all to
+ * whichever same-named node happens to come last (#2276).
  */
-function resurrectRefFromDroppedEdge(
-  e: Edge & { sourceFilePath: string; sourceLanguage: Language }
-): UnresolvedReference | null {
-  const refName = e.metadata?.refName;
-  if (typeof refName !== 'string' || refName.length === 0) return null;
-  const refKind = typeof e.metadata?.refKind === 'string' ? (e.metadata.refKind as ReferenceKind) : e.kind;
-  return {
-    fromNodeId: e.source,
-    referenceName: refName,
-    referenceKind: refKind,
-    line: e.line ?? 0,
-    column: e.column ?? 0,
-    filePath: e.sourceFilePath,
-    language: e.sourceLanguage,
+function pairReindexedNodes(
+  prior: readonly NodeIdentity[],
+  next: readonly NodeIdentity[]
+): Map<string, string> {
+  const pairs = new Map<string, string>();
+  const byPosition = (a: NodeIdentity, b: NodeIdentity) =>
+    a.startLine - b.startLine || a.startColumn - b.startColumn;
+  const pairGroups = (before: readonly NodeIdentity[], after: readonly NodeIdentity[], tier: number): void => {
+    const key = REINDEX_IDENTITY_TIERS[tier]!;
+    const afterGroups = groupNodeIdentities(after, key);
+    for (const [k, group] of groupNodeIdentities(before, key)) {
+      const match = afterGroups.get(k);
+      if (!match) continue;
+      if (group.length === 1 && match.length === 1) {
+        pairs.set(group[0]!.id, match[0]!.id);
+      } else if (tier + 1 < REINDEX_IDENTITY_TIERS.length) {
+        pairGroups(group, match, tier + 1);
+      } else if (group.length === match.length) {
+        const a = [...group].sort(byPosition);
+        const b = [...match].sort(byPosition);
+        for (let i = 0; i < a.length; i++) pairs.set(a[i]!.id, b[i]!.id);
+      }
+    }
   };
+  pairGroups(prior, next, 0);
+  return pairs;
 }
 
 /**
@@ -1909,9 +1968,78 @@ export class ExtractionOrchestrator {
     const fileList = files ?? scanDirectory(this.rootDir);
     const context = this.buildDetectionContext(fileList);
     this.detectedFrameworkNames = detectFrameworks(context).map((r) => r.name);
+    const declared = declaredDependencies(context);
+    this.gatedFrameworks = new Map();
+    for (const name of this.detectedFrameworkNames) {
+      const deps = getFrameworkResolver(name)?.appDependencies;
+      // Gated only when some manifest names the framework: otherwise detection
+      // found it by other evidence and every file is its app's.
+      if (deps && deps.some((d) => declared.has(d))) this.gatedFrameworks.set(name, deps);
+    }
+    this.appFrameworkMemo.clear();
+    this.manifestDependencies.clear();
     return this.detectedFrameworkNames;
   }
 
+  /** Detected frameworks whose extractors run only inside their own apps, with the packages that mark one. */
+  private gatedFrameworks = new Map<string, readonly string[]>();
+  /** `<dir>|<framework>` → does the package.json at or above `dir` declare the framework. */
+  private appFrameworkMemo = new Map<string, boolean>();
+  /** Directory → the dependency names its package.json declares, null without one. */
+  private manifestDependencies = new Map<string, Set<string> | null>();
+
+  /**
+   * The detected frameworks whose extractors apply to `filePath`: all of them,
+   * except one with `appDependencies` when neither the file's package.json nor
+   * an enclosing one declares any of them.
+   */
+  private frameworksForFile(filePath: string, names: string[]): string[] {
+    if (this.gatedFrameworks.size === 0) return names;
+    const slash = filePath.lastIndexOf('/');
+    const dir = slash < 0 ? '' : filePath.slice(0, slash);
+    const kept = names.filter((name) => this.frameworkAppliesIn(dir, name));
+    return kept.length === names.length ? names : kept;
+  }
+
+  private frameworkAppliesIn(dir: string, name: string): boolean {
+    const deps = this.gatedFrameworks.get(name);
+    if (!deps) return true;
+    const key = `${dir}|${name}`;
+    const memo = this.appFrameworkMemo.get(key);
+    if (memo !== undefined) return memo;
+    // The nearest manifest that names ANY gated framework decides: true-sheet's
+    // root package.json declares expo-router for its example app, and its
+    // `docs/` Next.js app — whose own package.json declares `next` — is not
+    // an Expo app for it.
+    let applies = false;
+    for (let d: string | null = dir; d !== null; d = d === '' ? null : d.includes('/') ? d.slice(0, d.lastIndexOf('/')) : '') {
+      const declared = this.dependenciesDeclaredIn(d);
+      if (!declared) continue;
+      if (deps.some((dep) => declared.has(dep))) {
+        applies = true;
+        break;
+      }
+      if ([...this.gatedFrameworks].some(([other, otherDeps]) => other !== name && otherDeps.some((dep) => declared.has(dep)))) break;
+    }
+    this.appFrameworkMemo.set(key, applies);
+    return applies;
+  }
+
+  private dependenciesDeclaredIn(dir: string): Set<string> | null {
+    if (this.manifestDependencies.has(dir)) return this.manifestDependencies.get(dir)!;
+    let declared: Set<string> | null = null;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(this.rootDir, dir, 'package.json'), 'utf8')) as Record<string, unknown>;
+      declared = new Set();
+      for (const field of ['dependencies', 'devDependencies', 'peerDependencies']) {
+        const group = pkg[field];
+        if (group && typeof group === 'object') for (const name of Object.keys(group)) declared.add(name);
+      }
+    } catch { /* no or unreadable manifest */ }
+    this.manifestDependencies.set(dir, declared);
+    return declared;
+  }
+
   /**
    * Index all files in the project
    */
@@ -2028,7 +2156,7 @@ export class ExtractionOrchestrator {
     await new Promise(resolve => setImmediate(resolve));
 
     // Detect needed languages and load grammars in the parse worker
-    const neededLanguages = preloadLanguagesForFiles(files, overrides);
+    const neededLanguages = preloadLanguagesForFiles(files, overrides, this.rootDir);
 
     // Parse files on a pool of worker threads (keeps the main thread free for UI
     // and uses every core). Falls back to in-process parsing when the compiled
@@ -2099,9 +2227,10 @@ export class ExtractionOrchestrator {
      * here on the main thread, where the codegraph.json overrides are loaded.
      */
     const parseFile = (filePath: string, content: string): Promise<ExtractionResult> => {
-      const language = detectLanguage(filePath, content, overrides);
-      if (!pool) return Promise.resolve(extractFromSource(filePath, content, language, frameworkNames));
-      return pool.requestParse({ filePath, content, language, frameworkNames });
+      const language = detectLanguage(filePath, content, overrides, this.rootDir);
+      const names = this.frameworksForFile(filePath, frameworkNames);
+      if (!pool) return Promise.resolve(extractFromSource(filePath, content, language, names));
+      return pool.requestParse({ filePath, content, language, frameworkNames: names });
     };
 
     // --- Bounded rolling-window dispatch, ordered commit ---
@@ -2143,11 +2272,17 @@ export class ExtractionOrchestrator {
       const nodeCount = result.kernelCounts?.nodes ?? result.nodes.length;
       const edgeCount = result.kernelCounts?.edges ?? result.edges.length;
 
+      // A file whose grammar failed to load was never parsed (#2335).
+      const grammarUnavailable = hasGrammarLoadFailure(result.errors);
+
       // Store: on the writer thread when active (fresh DB — bundles applied
       // in the same file order this chain dispatches them), else on the main
       // thread (SQLite connections are per-thread).
-      const language = detectLanguage(filePath, content, overrides);
-      if (storeWriter) {
+      const language = detectLanguage(filePath, content, overrides, this.rootDir);
+      if (grammarUnavailable) {
+        // Store nothing: a row from an earlier run keeps its data, and with no
+        // row (or an older hash) the next sync or index retries the file.
+      } else if (storeWriter) {
         if (result.kernelBuffers) {
           // Buffers go to the writer as-is; the worker decodes + finalizes.
           // The main thread's only per-file work stays O(1) + the content hash.
@@ -2157,6 +2292,7 @@ export class ExtractionOrchestrator {
             language,
             buffers: result.kernelBuffers,
             file: this.buildFileRecord(filePath, content, language, stats, nodeCount, result.errors),
+            ...(result.unresolvedReferences.length > 0 ? { extraRefs: result.unresolvedReferences } : {}),
           });
         } else {
           storeWriter.send(this.buildFreshStoreBundle(filePath, content, language, stats, result));
@@ -2174,7 +2310,9 @@ export class ExtractionOrchestrator {
         errors.push(...result.errors);
       }
 
-      if (nodeCount > 0) {
+      if (grammarUnavailable) {
+        filesErrored++;
+      } else if (nodeCount > 0) {
         filesIndexed++;
         totalNodes += nodeCount;
         totalEdges += edgeCount;
@@ -2184,7 +2322,7 @@ export class ExtractionOrchestrator {
         // Files with no symbols but no errors (yaml, twig, properties) are
         // tracked at the file level — count them as indexed so the CLI doesn't
         // misleadingly report "No files found to index".
-        const lang = detectLanguage(filePath, content, overrides);
+        const lang = detectLanguage(filePath, content, overrides, this.rootDir);
         if (isFileLevelOnlyLanguage(lang)) {
           filesIndexed++;
         } else {
@@ -2472,7 +2610,7 @@ export class ExtractionOrchestrator {
         // so decode here — otherwise a kernel-language retry passes the gate
         // below via `errors.length === 0`, stores nothing, and the file is
         // permanently recorded as "(0 symbols)" with the error erased (#1541).
-        const language = detectLanguage(filePath, content, overrides);
+        const language = detectLanguage(filePath, content, overrides, this.rootDir);
         result = materializeKernelResult(result, filePath, language);
 
         if (result.nodes.length > 0 || result.errors.length === 0) {
@@ -2527,7 +2665,7 @@ export class ExtractionOrchestrator {
           }
 
           // Same undecoded-transport hazard as the first retry pass (#1541).
-          const language = detectLanguage(filePath, fullContent, overrides);
+          const language = detectLanguage(filePath, fullContent, overrides, this.rootDir);
           result = materializeKernelResult(result, filePath, language);
 
           if (result.nodes.length > 0 || result.errors.length === 0) {
@@ -2588,7 +2726,9 @@ export class ExtractionOrchestrator {
         errors.push(...result.errors);
       }
 
-      if (result.nodes.length > 0) {
+      if (hasGrammarLoadFailure(result.errors)) {
+        filesErrored++; // nothing was stored (#2335)
+      } else if (result.nodes.length > 0) {
         filesIndexed++;
         totalNodes += result.nodes.length;
         totalEdges += result.edges.length;
@@ -2687,7 +2827,7 @@ export class ExtractionOrchestrator {
       };
     }
 
-    const language = detectLanguage(relativePath, content, loadExtensionOverrides(this.rootDir));
+    const language = detectLanguage(relativePath, content, loadExtensionOverrides(this.rootDir), this.rootDir);
 
     // Check file size
     if (stats.size > MAX_SOURCE_FILE_SIZE_BYTES) {
@@ -2723,7 +2863,7 @@ export class ExtractionOrchestrator {
     // Extract from source. Use cached framework names if indexAll has run,
     // otherwise detect on the spot so single-file re-index paths still emit
     // route nodes / middleware / etc.
-    const frameworkNames = this.ensureDetectedFrameworks();
+    const frameworkNames = this.frameworksForFile(relativePath, this.ensureDetectedFrameworks());
     const result = extractFromSource(relativePath, content, language, frameworkNames);
 
     // Store in database
@@ -2771,6 +2911,12 @@ export class ExtractionOrchestrator {
     result: ExtractionResult,
     onYield?: MaybeYield
   ): Promise<void> {
+    // The file was never parsed: its grammar failed to load (#2335). Storing
+    // this would replace the file's symbols with an empty row under the new
+    // content hash, which no hash-based sync revisits. Keep whatever the index
+    // has; the stale (or missing) row makes the next sync retry the file.
+    if (hasGrammarLoadFailure(result.errors)) return;
+
     // A kernel result can arrive as an undecoded buffer transport (empty
     // node/edge arrays, tables riding in kernelBuffers). Decode it before
     // storing — persisting the transport as-is records the file as having no
@@ -2780,9 +2926,9 @@ export class ExtractionOrchestrator {
     // Bulk inserts run in bounded sub-transactions with a yield between, so a
     // giant generated file (tens of thousands of symbols) can't block the
     // event loop — and the #850 watchdog heartbeat — for the whole store.
-    // The file was NEVER one atomic transaction (each insert call has its
-    // own), and the files-table record still lands last, so crash recovery
-    // is unchanged: a partially-stored file has no record and re-indexes.
+    // That chunked path is not one atomic transaction (each insert call has
+    // its own), and the files-table record still lands last, so a
+    // partially-stored file has no record and re-indexes.
     const STORE_CHUNK = 2000;
     const contentHash = hashContent(content);
 
@@ -2797,7 +2943,10 @@ export class ExtractionOrchestrator {
       const existingIsMarker =
         existingFile.nodeCount === 0 && (existingFile.errors?.length ?? 0) > 0;
       const incomingHasContent = result.nodes.length > 0;
-      if (!existingIsMarker || !incomingHasContent) {
+      // A row an older engine stored while the grammar could not load
+      // (#2335) records no parse at all: any real result replaces it.
+      const existingNeverParsed = hasGrammarLoadFailure(existingFile.errors);
+      if (!existingNeverParsed && (!existingIsMarker || !incomingHasContent)) {
         return; // No changes
       }
     }
@@ -2816,21 +2965,21 @@ export class ExtractionOrchestrator {
     // `references` edges from callers that import it via module-attribute
     // access (`pkg.mod.fn(...)`).
     //
-    // We snapshot the edge plus the target node's (name, kind) so we can
-    // re-resolve to the re-indexed target's NEW id. Node ids are
-    // `sha256(filePath:kind:name:line)`, so any line shift in the callee file
-    // (e.g. a docstring-only edit above the symbol) changes every target id and
-    // a naive re-insert by old id would silently drop every edge. Matching by
-    // (filePath, kind, name) is stable across line shifts; if the symbol was
-    // renamed/removed, no match is found and the edge stays dropped (correct).
+    // We snapshot the edges plus the identity of every node the file had, so
+    // each edge can follow its old target to the re-indexed node that replaces
+    // it. Node ids are `sha256(filePath:kind:name:line)`, so any line shift in
+    // the callee file (e.g. a docstring-only edit above the symbol) changes
+    // every target id and a naive re-insert by old id would silently drop
+    // every edge. Pairing by (kind, name) — then qualified name, signature and
+    // position when the file defines a name more than once (#2276) — is stable
+    // across line shifts; if the symbol was renamed/removed, no pair is found
+    // and the edge is re-resolved from its original reference (see below).
     const crossFileIncomingEdges = existingFile
       ? this.queries.getCrossFileIncomingEdgesWithTarget(filePath)
       : [];
-
-    // Delete existing data for this file
-    if (existingFile) {
-      this.queries.deleteFile(filePath);
-    }
+    const priorNodes = crossFileIncomingEdges.length > 0
+      ? this.queries.getNodeIdentitiesByFile(filePath)
+      : [];
 
     // Filter out nodes with missing required fields before insertion.
     // This prevents FK violations when edges reference nodes that would
@@ -2849,38 +2998,52 @@ export class ExtractionOrchestrator {
       }));
 
     // Fast path for the common case (everything fits one chunk): the whole
-    // file — nodes, edges, refs, file record — lands in ONE transaction with
-    // no event-loop yields in between. Giant generated files keep the chunked
-    // + yielding path below so the #850 watchdog heartbeat stays serviced.
+    // re-store — deleting the old rows, the new nodes, edges, refs and file
+    // record, and the re-attached incoming edges — lands in ONE transaction
+    // with no event-loop yields in between. Committed separately, a crash
+    // after the delete left the file looking new (no snapshot next time) and
+    // a crash before the re-attach left it looking current: either way other
+    // files' edges into it were lost for good. Giant generated files keep the
+    // chunked + yielding path below so the #850 watchdog heartbeat stays
+    // serviced.
     const fitsOneChunk =
       validNodes.length <= STORE_CHUNK &&
       validEdges.length <= STORE_CHUNK &&
       validRefs.length <= STORE_CHUNK;
     if (fitsOneChunk) {
-      // Snapshot/re-resolution of cross-file incoming edges (below) still runs
-      // for the sync path; on a fresh bulk index crossFileIncomingEdges is [].
-      this.queries.storeFileBundle({
-        nodes: validNodes,
-        edges: validEdges,
-        refs: validRefs,
-        file: {
-          path: filePath,
-          contentHash,
-          language,
-          size: stats.size,
-          modifiedAt: stats.mtimeMs,
-          indexedAt: Date.now(),
-          nodeCount: result.nodes.length,
-          errors: result.errors.length > 0 ? result.errors : undefined,
-          generated,
-        },
+      this.queries.runInTransaction(() => {
+        if (existingFile) {
+          this.queries.deleteFile(filePath);
+        }
+        this.queries.storeFileBundle({
+          nodes: validNodes,
+          edges: validEdges,
+          refs: validRefs,
+          file: {
+            path: filePath,
+            contentHash,
+            language,
+            size: stats.size,
+            modifiedAt: stats.mtimeMs,
+            indexedAt: Date.now(),
+            nodeCount: result.nodes.length,
+            errors: result.errors.length > 0 ? result.errors : undefined,
+            generated,
+          },
+        });
+        // On a fresh bulk index crossFileIncomingEdges is [].
+        if (crossFileIncomingEdges.length > 0) {
+          this.reattachCrossFileEdges(crossFileIncomingEdges, priorNodes, validNodes);
+        }
       });
-      if (crossFileIncomingEdges.length > 0) {
-        this.reattachCrossFileEdges(crossFileIncomingEdges, validNodes);
-      }
       return;
     }
 
+    // Delete existing data for this file
+    if (existingFile) {
+      this.queries.deleteFile(filePath);
+    }
+
     // Insert nodes (chunked — see STORE_CHUNK above)
     for (let i = 0; i < validNodes.length; i += STORE_CHUNK) {
       this.queries.insertNodes(validNodes.slice(i, i + STORE_CHUNK));
@@ -2896,25 +3059,26 @@ export class ExtractionOrchestrator {
     }
 
     // Re-insert cross-file incoming edges snapshotted before the delete,
-    // re-resolving each edge's target to the re-indexed node's new id by
-    // (filePath, kind, name). Node ids include the source line, so any line
+    // moving each edge's target to the re-indexed node that replaces it (see
+    // pairReindexedNodes). Node ids include the source line, so any line
     // shift in the callee file (e.g. a docstring-only edit above the symbol)
     // changes every target id and a naive re-insert by old id would drop them
     // all. `insertEdges` still filters to endpoints that exist. This closes
     // the #899 edge-drop on `sync`.
     //
-    // Edges whose callee (target) was renamed/removed during the re-index (no
-    // match in `newNodesByKindName`) are not silently dropped anymore: each is
-    // resurrected as its ORIGINAL unresolved ref (stamped on the edge as
-    // metadata.refName/refKind at creation) so the same sync's resolution
-    // sweep can rebind it to an alternative definition elsewhere, or park it
-    // as status='failed' to be retried when the symbol reappears — the
-    // removal-side counterpart of #1240. Edges without refName (built before
-    // the stamp existed, or synthesized) still drop silently: reconstructing
-    // a ref from the target's plain name would strip receiver/qualifier
-    // context and risk a rebind a full re-index would never make.
+    // Edges whose callee (target) was renamed/removed during the re-index, or
+    // can't be told apart from a same-named sibling (#2276), are not silently
+    // dropped or guessed at: each is resurrected as its ORIGINAL unresolved
+    // ref (stamped on the edge as metadata.refName/refKind at creation) so
+    // the same sync's resolution sweep can rebind it to the right definition
+    // here or an alternative one elsewhere, or park it as status='failed' to
+    // be retried when the symbol reappears — the removal-side counterpart of
+    // #1240. Edges without refName (built before the stamp existed, or
+    // synthesized) still drop silently: reconstructing a ref from the
+    // target's plain name would strip receiver/qualifier context and risk a
+    // rebind a full re-index would never make.
     if (crossFileIncomingEdges.length > 0) {
-      this.reattachCrossFileEdges(crossFileIncomingEdges, validNodes);
+      this.reattachCrossFileEdges(crossFileIncomingEdges, priorNodes, validNodes);
     }
 
     // Insert unresolved references in batch with denormalized filePath/language
@@ -2985,23 +3149,22 @@ export class ExtractionOrchestrator {
 
   /**
    * Re-attach cross-file incoming edges snapshotted before a re-index delete
-   * (#899): re-resolve each edge's target to the re-indexed node's new id by
-   * (kind, name); targets that vanished are resurrected as their original
-   * unresolved ref (#1240's removal-side counterpart) when the edge carries
-   * its refName stamp.
+   * (#899): move each edge's target to the re-indexed node that replaces it
+   * ({@link pairReindexedNodes}). Targets that vanished, or that can't be
+   * told apart from a same-named sibling (#2276), are resurrected as their
+   * original unresolved ref (#1240's removal-side counterpart) when the edge
+   * carries its refName stamp, so resolution picks the target afresh.
    */
   private reattachCrossFileEdges(
-    crossFileIncomingEdges: Array<Edge & { targetKind: string; targetName: string; sourceFilePath: string; sourceLanguage: Language }>,
-    validNodes: Node[]
+    crossFileIncomingEdges: Array<Edge & { sourceFilePath: string; sourceLanguage: Language }>,
+    priorNodes: readonly NodeIdentity[],
+    validNodes: readonly NodeIdentity[]
   ): void {
-    const newNodesByKindName = new Map<string, string>();
-    for (const n of validNodes) {
-      newNodesByKindName.set(`${n.kind}\0${n.name}`, n.id);
-    }
+    const replacementOf = pairReindexedNodes(priorNodes, validNodes);
     const reinserted: Edge[] = [];
     const resurrected: UnresolvedReference[] = [];
     for (const e of crossFileIncomingEdges) {
-      const newTargetId = newNodesByKindName.get(`${e.targetKind}\0${e.targetName}`);
+      const newTargetId = replacementOf.get(e.target);
       if (newTargetId) {
         reinserted.push({ source: e.source, target: newTargetId, kind: e.kind, metadata: e.metadata, line: e.line, column: e.column, provenance: e.provenance });
       } else {
@@ -3111,6 +3274,7 @@ export class ExtractionOrchestrator {
     let filesRemoved = 0;
     let nodesUpdated = 0;
     const changedFilePaths: string[] = [];
+    const addedFilePaths: string[] = [];
     // `file\0name` definition pairs for the files this sync touches, sampled
     // BEFORE their nodes are replaced/deleted. Compared against the post-store
     // pairs below to derive `definitionDelta` (CG-33).
@@ -3156,7 +3320,7 @@ export class ExtractionOrchestrator {
       const overrides = loadExtensionOverrides(this.rootDir);
       currentFiles = unique.filter(
         (p) =>
-          isSourceFile(p, overrides) &&
+          isSourceFile(p, overrides, this.rootDir) &&
           !scope.ignores(p) &&
           fs.existsSync(path.join(this.rootDir, p))
       );
@@ -3239,13 +3403,18 @@ export class ExtractionOrchestrator {
       }
       const fullPath = path.join(this.rootDir, filePath);
       const tracked = trackedMap.get(filePath);
+      // A row an older engine stored while the file's grammar could not load
+      // (#2335) holds no parse of these bytes: re-index it even though its
+      // size, mtime and hash all match. Rows with a real parse error are
+      // deterministic and are not retried.
+      const neverParsed = tracked !== undefined && hasGrammarLoadFailure(tracked.errors);
 
       // Cheap pre-filter: an already-indexed file whose size AND mtime both match
       // the DB is unchanged — skip it without reading or hashing. (A content
       // change that preserves both exactly is the blind spot every mtime-based
       // incremental tool accepts; `index --force` is the escape hatch. Git bumps
       // mtime on every file it writes during checkout/merge, so pulls are caught.)
-      if (tracked) {
+      if (tracked && !neverParsed) {
         try {
           const stat = fs.statSync(fullPath);
           if (stat.size === tracked.size && Math.floor(stat.mtimeMs) === Math.floor(tracked.modifiedAt)) {
@@ -3280,8 +3449,9 @@ export class ExtractionOrchestrator {
         onFileChange?.(filePath, content);
         filesToIndex.push(filePath);
         changedFilePaths.push(filePath);
+        addedFilePaths.push(filePath);
         filesAdded++;
-      } else if (tracked.contentHash !== contentHash) {
+      } else if (tracked.contentHash !== contentHash || neverParsed) {
         onFileChange?.(filePath, content);
         filesToIndex.push(filePath);
         changedFilePaths.push(filePath);
@@ -3300,7 +3470,7 @@ export class ExtractionOrchestrator {
     // Load only grammars needed for changed files
     if (filesToIndex.length > 0) {
       const overrides = loadExtensionOverrides(this.rootDir);
-      await loadGrammarsForLanguages(preloadLanguagesForFiles(filesToIndex, overrides));
+      await loadGrammarsForLanguages(preloadLanguagesForFiles(filesToIndex, overrides, this.rootDir));
     }
 
     // Index changed files
@@ -3316,7 +3486,7 @@ export class ExtractionOrchestrator {
 
       const result = await this.indexFile(filePath);
       if (result.errors.some(e => e.severity === 'error')) failedFilePaths.push(filePath);
-      nodesUpdated += result.nodes.length;
+      if (!hasGrammarLoadFailure(result.errors)) nodesUpdated += result.nodes.length; // else nothing was stored (#2335)
 
       const pause = backpressure?.();
       if (pause) await pause;
@@ -3349,6 +3519,7 @@ export class ExtractionOrchestrator {
       nodesUpdated,
       durationMs: Date.now() - startTime,
       changedFilePaths: changedFilePaths.length > 0 ? changedFilePaths : undefined,
+      ...(addedFilePaths.length > 0 ? { addedFilePaths } : {}),
       ...(failedFilePaths.length > 0 ? { failedFilePaths } : {}),
       definitionDelta: definitionDelta.length > 0 ? definitionDelta : undefined,
     };
@@ -3426,7 +3597,7 @@ export class ExtractionOrchestrator {
       for (const filePath of candidates) {
         const tracked = this.queries.getFileByPath(filePath);
         const fullPath = path.join(this.rootDir, filePath);
-        if (!isSourceFile(filePath, overrides) || scope.ignores(filePath) || !fs.existsSync(fullPath)) {
+        if (!isSourceFile(filePath, overrides, this.rootDir) || scope.ignores(filePath) || !fs.existsSync(fullPath)) {
           if (tracked) removed.push(filePath);
           continue;
         }
diff --git a/src/extraction/kernel/index.ts b/src/extraction/kernel/index.ts
index c4337a0912..1e71d170c3 100644
--- a/src/extraction/kernel/index.ts
+++ b/src/extraction/kernel/index.ts
@@ -15,6 +15,7 @@
  */
 
 import type { ExtractionResult, Language } from '../../types';
+import { commonJsRequireRefs } from '../commonjs-requires';
 import { EXTRACTORS } from '../languages';
 import { getKernel, kernelSupports } from './loader';
 import { decodeExtractBuffers } from './decode';
@@ -269,6 +270,8 @@ export function materializeKernelResult(
     language
   );
   decoded.durationMs = result.durationMs;
+  // References read beside the tables (a CommonJS `require`) ride on the transport.
+  if (result.unresolvedReferences.length > 0) decoded.unresolvedReferences.push(...result.unresolvedReferences);
   return decoded;
 }
 
@@ -294,6 +297,8 @@ export function tryKernelExtract(
     const buffers = kernel.extractFile(filePath, pre, language);
     const result = decodeExtractBuffers(buffers, filePath, language);
     POST_PASSES[language]?.(result, source);
+    // Read beside the tables, as TreeSitterExtractor does (a CommonJS `require`).
+    result.unresolvedReferences.push(...commonJsRequireRefs(filePath, source, language));
     result.durationMs = Date.now() - t0;
     return result;
   } catch (err) {
diff --git a/src/extraction/languages/c-cpp.ts b/src/extraction/languages/c-cpp.ts
index c4aa31a4f8..f2161c6fa9 100644
--- a/src/extraction/languages/c-cpp.ts
+++ b/src/extraction/languages/c-cpp.ts
@@ -2,6 +2,77 @@ import type { Node as SyntaxNode } from 'web-tree-sitter';
 import { getChildByField, getNodeText } from '../tree-sitter-helpers';
 import type { LanguageExtractor } from '../tree-sitter-types';
 
+/**
+ * Resolve the declared identifier inside a C declarator. A `declaration`'s
+ * `declarator` field nests the name through `init_declarator` (with value),
+ * `pointer_declarator`/`array_declarator`/`parenthesized_declarator`
+ * wrappers (each via their own `declarator` field) down to an `identifier`.
+ * A `function_declarator` means the declaration is a function prototype (or a
+ * function-pointer var) — return null so it isn't extracted as a variable.
+ */
+export function cDeclaratorIdentifier(node: SyntaxNode | null): SyntaxNode | null {
+  let cur: SyntaxNode | null = node;
+  let guard = 0;
+  while (cur && guard++ < 12) {
+    switch (cur.type) {
+      case 'identifier':
+        return cur;
+      case 'function_declarator':
+        return null;
+      case 'init_declarator':
+      case 'pointer_declarator':
+      case 'array_declarator':
+      case 'parenthesized_declarator':
+        cur = getChildByField(cur, 'declarator');
+        break;
+      default:
+        return null;
+    }
+  }
+  return null;
+}
+
+/** C and C++ specifiers that define a class-like type, or an enum, when they carry a body (C has no `class_specifier`). */
+const CLASS_LIKE_SPECIFIERS = new Set(['class_specifier', 'struct_specifier', 'union_specifier', 'enum_specifier']);
+
+/**
+ * Whether a C/C++ type specifier defines a class, struct, union or enum, as
+ * opposed to naming one (`struct Foo *p`, the forward declaration `class Foo;`).
+ */
+export function isClassLikeDefinition(node: SyntaxNode): boolean {
+  return CLASS_LIKE_SPECIFIERS.has(node.type) && getChildByField(node, 'body') !== null;
+}
+
+/**
+ * The `declaration` a class, struct, union or enum is defined in the type of —
+ * `struct Foo { … } foo;` — or null for one written on its own, in a typedef or
+ * in a member's type.
+ */
+function definingDeclaration(node: SyntaxNode): SyntaxNode | null {
+  if (!isClassLikeDefinition(node)) return null;
+  const parent = node.parent;
+  return parent?.type === 'declaration' && getChildByField(parent, 'type')?.id === node.id ? parent : null;
+}
+
+/**
+ * The name of an unnamed class, struct, union or enum that a declaration
+ * defines: the first variable the declaration declares. No code can name the
+ * type of `static struct { … } SPT;` (only `SPT`), so the struct is indexed as
+ * `SPT`, the way `typedef struct { … } Name;` is indexed as `Name`. Undefined
+ * for a named type, and when the declaration declares no variable (a
+ * function's return type). Mirrored in the kernel (ccpp/mod.rs).
+ */
+function unnamedTypeVariableName(node: SyntaxNode, source: string): string | undefined {
+  if (getChildByField(node, 'name')) return undefined;
+  const declaration = definingDeclaration(node);
+  if (!declaration) return undefined;
+  for (const declarator of declaration.childrenForFieldName('declarator')) {
+    const identifier = cDeclaratorIdentifier(declarator);
+    if (identifier) return getNodeText(identifier, source);
+  }
+  return undefined;
+}
+
 /**
  * Find the function NAME's `qualified_identifier` (`Foo::bar`) inside a
  * declarator, skipping the `parameter_list` — a parameter with a qualified type
@@ -256,7 +327,11 @@ function extractCppReturnType(node: SyntaxNode, source: string): string | undefi
 }
 
 export const cExtractor: LanguageExtractor = {
-  resolveName: recoverSingleArgMacroDefinedName,
+  resolveName: (node, source) =>
+    recoverSingleArgMacroDefinedName(node, source) ?? unnamedTypeVariableName(node, source),
+  // A struct, union or enum defined in a declaration's type is documented by
+  // the comment above the declaration.
+  getDeclarationWrapper: (node) => definingDeclaration(node) ?? undefined,
   // CUDA in C-detected headers (content-gated blank; see preParseCSource).
   preParse: preParseCSource,
   // Universal net: recover a real name from any macro-mangled function name.
@@ -378,13 +453,389 @@ function isMacroMisparsedTypeDecl(node: SyntaxNode): boolean {
  * declarations (`struct FOO var;`, `class FOO obj = …`) untouched, since those
  * end in `;` / `=` / `[`, never `:` / `{`. C++-only (wired into cppExtractor),
  * so C's heavier use of `struct TAG var;` never reaches it.
+ *
+ * The head may carry several macros, and a macro may take arguments: protobuf's
+ * generated `class PROTOBUF_EXPORT PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Any
+ * final : public Message`, `class ABSL_ATTRIBUTE_WARN_UNUSED
+ * PROTOBUF_DECLSPEC_EMPTY_BASES RepeatedField final`, rocksdb's `struct
+ * ALIGN_AS(64U) HandleImpl : public ClockHandle`. The whole run is blanked; the
+ * last name before the guard is the class. The name may be followed by template
+ * arguments, for a specialization (`class PROTOBUF_DECLSPEC_EMPTY_BASES
+ * RepeatedFieldProxyWithSet<ElementType, …> {`). Matched on the code alone, so
+ * a comment or string never takes part.
  */
+const CPP_CLASS_HEAD_MACROS_RE =
+  /\b(?:class|struct)\s+((?:[A-Z][A-Z0-9_]+(?:\s*\((?:[^()]|\([^()]*\))*\))?\s+)+)(?!final\b)[A-Za-z_]\w*(?:\s*::\s*[A-Za-z_]\w*)*/g;
 export function blankCppExportMacros(source: string): string {
   if (source.indexOf('class') === -1 && source.indexOf('struct') === -1) return source;
-  return source.replace(
-    /\b(class|struct)(\s+)([A-Z][A-Z0-9_]+)(?=\s+[A-Za-z_]\w*(?:\s+final)?\s*[:{])/g,
-    (_m, kw, ws, macro) => kw + ws + ' '.repeat(macro.length)
-  );
+  if (!/\b(?:class|struct)\s+[A-Z][A-Z0-9_]/.test(source)) return source;
+  const code = maskCppCode(source);
+  const spans: Array<[number, number]> = [];
+  const re = new RegExp(CPP_CLASS_HEAD_MACROS_RE.source, 'g');
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(code)) !== null) {
+    let i = skipCppSpace(code, m.index + m[0].length);
+    if (code[i] === '<') {
+      i = skipCppAngleArgs(code, i);
+      if (i < 0) continue;
+      i = skipCppSpace(code, i);
+    }
+    if (/^final\b/.test(code.slice(i, i + 6))) i = skipCppSpace(code, i + 5);
+    if (code[i] !== '{' && !(code[i] === ':' && code[i + 1] !== ':')) continue;
+    const run = m[1] as string;
+    const start = m.index + m[0].indexOf(run);
+    pushCppRunTokens(spans, run, start);
+  }
+  return blankCppSpans(source, spans, code);
+}
+
+// Comments and string/char literals (raw strings are masked beforehand by
+// maskCppRawStrings). The char-literal boundary leaves digit separators alone.
+const CPP_COMMENT_OR_LITERAL_RE =
+  /\/\/(?:\\\r?\n|[^\r\n])*|\/\*[\s\S]*?(?:\*\/|$)|"(?:\\[\s\S]|[^"\\])*(?:"|$)|(?<!\w)(?:u8|[LuU])?'(?:\\[\s\S]|[^'\\])*(?:'|$)/g;
+
+/**
+ * The source with comments and string/char literals turned to spaces, line
+ * endings kept. The macro scans below match on this, so a word in a comment or
+ * a literal (`* NOTE: …` in a doc comment) is never blanked, and every offset
+ * still lines up with the source.
+ */
+function maskCppCommentsAndLiterals(source: string): string {
+  return source.replace(CPP_COMMENT_OR_LITERAL_RE, (m) => m.replace(/[^\r\n]/g, ' '));
+}
+
+/**
+ * The code the macro scans below match on, at the source's offsets: comments
+ * are spaces, a string or char literal keeps its place as `\x01`s (it is a
+ * token, not space: in `"… using " GTEST_NAME_` the macro does not start a
+ * line, and a run of macros never reaches across a literal), and
+ * preprocessor directives with their `\` continuation lines are spaces — the
+ * `)` ending `#if !defined(__MINGW32__)` closes no parameter list, so the
+ * `TEST(file_test, open_windows_file) {` under it is not a trailing macro.
+ */
+function maskCppCode(source: string): string {
+  if (cppMaskMemo !== null && cppMaskMemo.source === source) return cppMaskMemo.code;
+  const code = source
+    .replace(CPP_COMMENT_OR_LITERAL_RE, (m) => m.replace(/[^\r\n]/g, m.startsWith('/') ? ' ' : '\x01'))
+    .replace(/^[ \t]*#(?:\\\r?\n|[^\r\n])*/gm, (m) => m.replace(/[^\r\n]/g, ' '));
+  cppMaskMemo = { source, code };
+  return code;
+}
+
+// The last source maskCppCode masked. The passes run one after another on
+// the same text: one that blanks nothing hands the next the same string, and
+// one that blanks hands it a mask blanked the same way (blankCppSpans), so a
+// file is masked once rather than once per pass.
+let cppMaskMemo: { source: string; code: string } | null = null;
+
+// One macro, with its arguments, inside a run matched on the masked code.
+const CPP_RUN_TOKEN_RE = /[A-Z][A-Z0-9_]*(?:\s*\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))?/g;
+
+/** Add a span for each macro of `run` (found at `start`), leaving what lies between them. */
+function pushCppRunTokens(spans: Array<[number, number]>, run: string, start: number): void {
+  for (const t of run.matchAll(CPP_RUN_TOKEN_RE)) spans.push([start + t.index, start + t.index + t[0].length]);
+}
+
+/**
+ * Replace each [start, end) span of `source` with spaces, keeping line
+ * endings. Given the mask the spans were found on, blank it the same way and
+ * keep it for the next pass: a span holds whole macros (with their arguments),
+ * so the result is what masking the new source would give.
+ */
+function blankCppSpans(source: string, spans: ReadonlyArray<readonly [number, number]>, code?: string): string {
+  if (spans.length === 0) return source;
+  const blank = (text: string): string => {
+    const chars = text.split('');
+    for (const [start, end] of spans) {
+      for (let k = start; k < end; k++) {
+        if (chars[k] !== '\n' && chars[k] !== '\r') chars[k] = ' ';
+      }
+    }
+    return chars.join('');
+  };
+  const out = blank(source);
+  if (code !== undefined) cppMaskMemo = { source: out, code: blank(code) };
+  return out;
+}
+
+function skipCppSpace(code: string, i: number): number {
+  while (i < code.length && /\s/.test(code[i] as string)) i++;
+  return i;
+}
+
+/**
+ * The index just past the template argument list opening at `code[open]`
+ * (`<`), or -1 when it doesn't close before a `;`, `{` or `}` — then it was a
+ * comparison, not template arguments. Angle brackets inside parentheses don't
+ * count (`Foo<sizeof(a) < 4>`).
+ */
+function skipCppAngleArgs(code: string, open: number): number {
+  let angles = 0;
+  let parens = 0;
+  const limit = Math.min(code.length, open + 4000);
+  for (let i = open; i < limit; i++) {
+    const c = code[i];
+    if (c === '(') parens++;
+    else if (c === ')') {
+      if (--parens < 0) return -1;
+    } else if (c === ';' || c === '{' || c === '}') return -1;
+    else if (parens === 0 && c === '<') angles++;
+    else if (parens === 0 && c === '>' && code[i - 1] !== '-') {
+      if (--angles === 0) return i + 1;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Blank attribute macros between a pointer or reference and the name it
+ * declares: protobuf's nullability annotations (`const Descriptor*
+ * PROTOBUF_NONNULL descriptor()`, `Any* PROTOBUF_RESTRICT PROTOBUF_NONNULL
+ * other`, `const FieldDescriptor* PROTOBUF_NULLABLE* PROTOBUF_NONNULL field`).
+ * tree-sitter takes the macro for the declared name and the real name for an
+ * error: a member keeps a broken declarator, an out-of-line definition gets the
+ * macro glued into its qualified name (`PROTOBUF_NONNULL Any::mutable_type_url`),
+ * and a definition whose parameter carries one (`void Any::Swap(Any*
+ * PROTOBUF_NONNULL other) { … }`) parses as a variable and drops out of the
+ * index. Generated `.pb.h`/`.pb.cc` files carry thousands of them.
+ *
+ * Matched on the code alone: the macro is ALL-CAPS with an underscore, right
+ * after `*` or `&`, and followed by the name (or, after `*`, by another `*`).
+ * C++ never puts two names in a row there, and a product (`a * MAX_LEN + 1`)
+ * or a bit test (`flags & FOO_BIT)`) is followed by an operator or a closer
+ * instead; a `*` after `)`, `]` or a number is a product too (`sizeof(int) *
+ * CHAR_BIT * 3`). A trailing macro with nothing after it (`Foo*
+ * PROTOBUF_NONNULL)`) parses as the parameter name and is left alone.
+ * C++-only.
+ */
+const CPP_POINTER_ANNOTATION_RE =
+  /([*&])\s*((?:[A-Z][A-Z0-9]*_[A-Z0-9_]*(?:\s+|(?=\*)))+)(?=\*|::|(?!(?:and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|xor|xor_eq)\b)[A-Za-z_~])/g;
+export function blankCppPointerAnnotationMacros(source: string): string {
+  if (!/[*&]\s*[A-Z][A-Z0-9]*_/.test(source)) return source;
+  const code = maskCppCode(source);
+  const spans: Array<[number, number]> = [];
+  const re = new RegExp(CPP_POINTER_ANNOTATION_RE.source, 'g');
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(code)) !== null) {
+    const run = m[2] as string;
+    const start = m.index + m[0].length - run.length;
+    // After `&`, only a name: `flags & FOO_BIT\n  && ok` is an expression.
+    if (m[1] === '&' && code[start + run.length] === '*') continue;
+    // A `*` after a closing bracket or a number multiplies: `sizeof(int) * CHAR_BIT * 3`.
+    if (/(?:[)\]]|\b\d[\w.]*)\s*$/.test(code.slice(Math.max(0, m.index - 40), m.index))) continue;
+    pushCppRunTokens(spans, run, start);
+  }
+  return blankCppSpans(source, spans, code);
+}
+
+// Keywords that take a parenthesized operand: a `)` closing one of these is
+// not a parameter list, so a token after it is not a trailing attribute.
+// `constexpr` / `consteval` stand before the condition of `if constexpr (…)`.
+const CPP_PAREN_KEYWORDS = new Set([
+  'if', 'while', 'for', 'switch', 'catch', 'return', 'sizeof', 'alignof', 'alignas', 'decltype',
+  'typeid', 'noexcept', 'throw', 'static_assert', 'new', 'delete', 'case', 'requires', 'co_await',
+  'co_yield', 'co_return', 'asm', '__asm__', '__attribute__', '__attribute', '__declspec', '_Pragma',
+  'else', 'do', 'constexpr', 'consteval', 'explicit', 'typeof', '__typeof__', '__typeof', '_Alignof',
+  '__alignof__', 'volatile', '__volatile__',
+]);
+
+/**
+ * Blank attribute macros after a function's parameter list: protobuf's
+ * `unknown_fields() const\n ABSL_ATTRIBUTE_LIFETIME_BOUND {` and `~Any()
+ * PROTOBUF_FINAL;`, and the thread-safety annotations of leveldb, rocksdb and
+ * abseil (`void Wait() LOCKS_EXCLUDED(mu_) {`, `void Lock()
+ * EXCLUSIVE_LOCK_FUNCTION();`). tree-sitter reads the macro as the start of a
+ * new declaration, so the method loses its `;` or its body: an inline body
+ * becomes a stray block, and in a long run of members the class can end early.
+ *
+ * Matched on the code alone, so it can't touch an expression:
+ *  - the `)` closes a parameter list: the `(` it matches follows a function
+ *    name (`name(`, `~Name(`, `operator==(`, `operator()(`), not a keyword
+ *    (`if (x) FOO;`), a cast (`= (int) MAX_VALUE;`) or a macro call
+ *    (`FMT_PRAGMA_CLANG(…)` above `TEST(std_test, bitint) {`);
+ *  - between `)` and the macro only `const`, `volatile`, `&`, `&&`,
+ *    `noexcept`, `override` or `final` may stand, and no blank line;
+ *  - the macro (ALL-CAPS, optionally with balanced arguments; several may
+ *    stack) is followed by what may end a declarator: `{`, `;`, `=`, a
+ *    constructor's `:`, `->`, or `override`/`final`/`const`/`noexcept`.
+ * C++-only.
+ */
+const CPP_TRAILING_ATTR_CANDIDATE_RE =
+  /\)((?:\s*(?:const|volatile|noexcept|override|final|&&|&)(?![\w]))*)\s*(?=[A-Z][A-Z0-9_]{2,}\b)/g;
+const CPP_TRAILING_ATTR_RUN_RE =
+  /(?:[A-Z][A-Z0-9_]{2,}\b(?:\s*\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))?\s*)+/y;
+const CPP_TRAILING_ATTR_FOLLOW_RE = /(?:\{|;|=(?!=)|:(?!:)|->|(?:override|final|const|noexcept)\b)/y;
+export function blankCppTrailingAttributeMacros(source: string): string {
+  if (!/\)[\s\w&]*?\b[A-Z][A-Z0-9_]{2,}\b/.test(source)) return source;
+  const code = maskCppCode(source);
+  const spans: Array<[number, number]> = [];
+  const re = new RegExp(CPP_TRAILING_ATTR_CANDIDATE_RE.source, 'g');
+  const run = new RegExp(CPP_TRAILING_ATTR_RUN_RE.source, 'y');
+  const follow = new RegExp(CPP_TRAILING_ATTR_FOLLOW_RE.source, 'y');
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(code)) !== null) {
+    const macroStart = m.index + m[0].length;
+    if (/\n[ \t]*\r?\n/.test(m[0])) continue;
+    run.lastIndex = macroStart;
+    const r = run.exec(code);
+    if (!r) continue;
+    follow.lastIndex = macroStart + r[0].length;
+    if (!follow.test(code)) continue;
+    if (!closesParameterList(code, m.index)) continue;
+    pushCppRunTokens(spans, r[0], macroStart);
+    re.lastIndex = macroStart + r[0].length;
+  }
+  return blankCppSpans(source, spans, code);
+}
+
+// Type keywords that may stand right before a declared name (`int count_ …`).
+const CPP_TYPE_KEYWORDS = new Set([
+  'void', 'bool', 'char', 'char8_t', 'char16_t', 'char32_t', 'wchar_t', 'short', 'int', 'long', 'float',
+  'double', 'signed', 'unsigned', 'auto',
+]);
+const CPP_KEYWORDS = new Set([
+  ...CPP_TYPE_KEYWORDS, ...CPP_PAREN_KEYWORDS, 'const', 'volatile', 'static', 'extern', 'inline', 'virtual',
+  'explicit', 'constexpr', 'consteval', 'constinit', 'friend', 'mutable', 'thread_local', 'register',
+  'typedef', 'using', 'template', 'typename', 'class', 'struct', 'union', 'enum', 'namespace', 'operator',
+  'goto', 'break', 'continue', 'default', 'public', 'private', 'protected', 'this', 'true', 'false',
+  'nullptr', 'and', 'or', 'not', 'xor', 'bitand', 'bitor', 'compl', 'and_eq', 'or_eq', 'xor_eq', 'not_eq',
+]);
+
+/**
+ * Blank attribute macros after the name a declaration declares, or after its
+ * array brackets: thread-safety annotations on fields (leveldb's `port::CondVar
+ * cv GUARDED_BY(mu);`, abseil's `ABSL_GUARDED_BY`), annotated parameters
+ * (`const absl::Cord* cord ABSL_ATTRIBUTE_LIFETIME_BOUND)`), and the section
+ * attributes of protobuf's generated globals (`Any_globals_
+ * PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);`, `offsets[]
+ * ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {`). tree-sitter reads
+ * the macro as a second declarator and errors.
+ *
+ * Matched on the code alone, so it can't touch a variable named in capitals:
+ *  - the macro is ALL-CAPS with an underscore, optionally with balanced
+ *    arguments, and is followed by `;`, `=`, `,` or `)`;
+ *  - before it stands `]`, or a name with a lowercase letter that itself
+ *    follows a type: a type name, a type keyword, `*`, `&`, `>`, or `const`
+ *    after a pointer. `Foo DEFAULT_OPTIONS;` and `const Foo kMAX_SIZE;`
+ *    declare those capitals (nothing names a type before `Foo`), `typedef Foo
+ *    BAR_T;` names a type, and `return x FOO;` or `f(a, b FOO)` have no type
+ *    before the name.
+ * C++-only.
+ */
+const CPP_DECLARATOR_ATTR_CANDIDATE_RE = /(?<![\w$])[A-Z][A-Z0-9]*_[A-Z0-9_]*\b/g;
+const CPP_DECLARATOR_ATTR_RUN_RE =
+  /(?:[A-Z][A-Z0-9]*_[A-Z0-9_]*\b(?:\s*\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))?\s*)+/y;
+export function blankCppDeclaratorAttributeMacros(source: string): string {
+  if (!/[\w\]]\s+[A-Z][A-Z0-9]*_[A-Z0-9_]*\s*[(;=,)]/.test(source)) return source;
+  const code = maskCppCode(source);
+  const spans: Array<[number, number]> = [];
+  const re = new RegExp(CPP_DECLARATOR_ATTR_CANDIDATE_RE.source, 'g');
+  const run = new RegExp(CPP_DECLARATOR_ATTR_RUN_RE.source, 'y');
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(code)) !== null) {
+    const macroStart = m.index;
+    // Whitespace before the macro, and before that a name or `]`.
+    let last = macroStart - 1;
+    while (last >= 0 && /\s/.test(code[last] as string)) last--;
+    if (last === macroStart - 1 || last < 0 || !/[\w\]]/.test(code[last] as string)) continue;
+    run.lastIndex = macroStart;
+    const r = run.exec(code);
+    if (!r || !/^[;,)]|^=(?!=)/.test(code.slice(macroStart + r[0].length, macroStart + r[0].length + 2))) continue;
+    if (code[last] !== ']' && !followsDeclaredName(code, last)) continue;
+    pushCppRunTokens(spans, r[0], macroStart);
+    re.lastIndex = macroStart + r[0].length;
+  }
+  return blankCppSpans(source, spans, code);
+}
+
+/** True when the identifier ending at `code[last]` is a name a declaration declares. */
+function followsDeclaredName(code: string, last: number): boolean {
+  let start = last;
+  while (start > 0 && /\w/.test(code[start - 1] as string)) start--;
+  const name = code.slice(start, last + 1);
+  if (!/^[A-Za-z_]\w*$/.test(name) || !/[a-z]/.test(name) || CPP_KEYWORDS.has(name)) return false;
+  let i = start - 1;
+  while (i >= 0 && /\s/.test(code[i] as string)) i--;
+  const c = code[i];
+  if (c === '*' || c === '&') return true;
+  if (c === '>') return code[i - 1] !== '-';
+  if (!c || !/\w/.test(c)) return false;
+  let j = i;
+  while (j > 0 && /\w/.test(code[j - 1] as string)) j--;
+  const before = code.slice(j, i + 1);
+  if (before === 'const' || before === 'volatile') {
+    let k = j - 1;
+    while (k >= 0 && /\s/.test(code[k] as string)) k--;
+    return code[k] === '*' || code[k] === '&';
+  }
+  if (CPP_TYPE_KEYWORDS.has(before)) return true;
+  return /^[A-Za-z_]\w*$/.test(before) && !CPP_KEYWORDS.has(before);
+}
+
+/** True when the `)` at `code[close]` closes a function declarator's parameter list. */
+function closesParameterList(code: string, close: number): boolean {
+  let depth = 0;
+  let open = -1;
+  for (let i = close; i >= 0 && close - i < 4000; i--) {
+    const c = code[i];
+    if (c === ')') depth++;
+    else if (c === '(') {
+      if (--depth === 0) { open = i; break; }
+    } else if (c === ';' || c === '{' || c === '}') return false;
+  }
+  if (open < 0) return false;
+  const before = code.slice(Math.max(0, open - 200), open);
+  // `operator()(…)`, `operator==(…)`, `operator bool(…)`
+  if (/\boperator\s*(?:\(\s*\)|\[\s*\]|[^\s\w()[\]]{1,3}|\s+[A-Za-z_][\w\s:<>*&]*)\s*$/.test(before)) return true;
+  const name = /([A-Za-z_]\w*)\s*$/.exec(before)?.[1];
+  return !!name && !CPP_PAREN_KEYWORDS.has(name) && !/^[A-Z][A-Z0-9_]*$/.test(name);
+}
+
+/**
+ * Blank attribute macros that open a declaration, at the start of a line or
+ * after a `[[…]]` attribute: protobuf's `PROTOBUF_FUTURE_ADD_EARLY_NODISCARD
+ * absl::string_view name() const {` (250 members of descriptor.h alone),
+ * `ABSL_ATTRIBUTE_REINITIALIZES void Clear()`, `[[nodiscard]]
+ * PROTOBUF_NDEBUG_INLINE Ptr<T> Make(…)`, googletest's `GTEST_API_
+ * std::string JoinAsTuple(…)`, {fmt}'s `FMT_EXPORT struct …`. tree-sitter
+ * takes the macro for the type and everything after it for an error, which
+ * swallows the members that follow. `blankCLeadingAttrMacros` only knows a
+ * plain `MACRO Ret name(`; C++ adds qualified and template types, specifiers
+ * and keywords.
+ *
+ * The macro (ALL-CAPS with an underscore; several may stack) must be followed
+ * by what can't follow a type name: a declaration keyword (`static`,
+ * `inline`, `virtual`, `void`, `struct`, `template`, `return`, `[[`, …) or a
+ * whole declaration of its own, a type and then the declared name (`Type
+ * name(`, `ns::Type<T>* name;`). A type is followed by the name alone
+ * (`DWORD_PTR value = 0;`, `HANDLE_T Open(…)`), so it never matches. `const`
+ * after the token could be either (`SIZE_T const n`), so it only counts with a
+ * type and name after it. Matched on the code alone. C++-only.
+ */
+const CPP_TYPE_ARGS = '<(?:[^<>;{}]|<(?:[^<>;{}]|<[^<>;{}]*>)*>)*>';
+const CPP_TYPE_NAME = `(?:::\\s*)?(?!(?:const|volatile|operator|return)\\b)[A-Za-z_]\\w*(?:\\s*${CPP_TYPE_ARGS})?(?:\\s*::\\s*[A-Za-z_]\\w*(?:\\s*${CPP_TYPE_ARGS})?)*`;
+const CPP_DECLARED_NAME = '(?:(?:::\\s*)?~?[A-Za-z_]\\w*(?:\\s*::\\s*~?[A-Za-z_]\\w*)*\\s*[(;=[{]|operator\\b)';
+const CPP_LEADING_ATTR_RE = new RegExp(
+  '(^[ \\t]*|\\]\\][ \\t]*)((?:[A-Z][A-Z0-9]*_[A-Z0-9_]*\\s+)+)(?=' +
+    '(?:static|inline|virtual|explicit|constexpr|consteval|constinit|friend|extern|thread_local|mutable|' +
+    'typedef|using|template|typename|class|struct|union|enum|void|bool|char|char8_t|char16_t|char32_t|' +
+    'wchar_t|short|int|long|float|double|signed|unsigned|auto|decltype|return)\\b|\\[\\[|' +
+    // An out-of-line constructor or destructor: `Any::Impl_::Impl_(`, `Any::~Any(`.
+    '(?:[A-Za-z_]\\w*\\s*::\\s*)*([A-Za-z_]\\w*)\\s*::\\s*~?\\3\\s*\\(|' +
+    `(?:(?:const|volatile)\\s+)*${CPP_TYPE_NAME}(?:\\s*(?:const|volatile)\\b)?(?:\\s*[*&]+\\s*|\\s+)(?:(?:const|volatile)\\s+)?${CPP_DECLARED_NAME})`,
+  'gm'
+);
+export function blankCppLeadingAttributeMacros(source: string): string {
+  if (!/(?:^|\]\])[ \t]*[A-Z][A-Z0-9]*_[A-Z0-9_]*\s/m.test(source)) return source;
+  const code = maskCppCode(source);
+  const spans: Array<[number, number]> = [];
+  const re = new RegExp(CPP_LEADING_ATTR_RE.source, 'gm');
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(code)) !== null) {
+    const start = m.index + (m[1] as string).length;
+    pushCppRunTokens(spans, m[2] as string, start);
+  }
+  return blankCppSpans(source, spans, code);
 }
 
 /**
@@ -680,9 +1131,11 @@ export function blankCppAnnotationMacroCalls(source: string): string {
  *    continuation) — so an ALL-CAPS operand split onto its own line inside a
  *    multi-line expression (`int x =\n  SOME_CONST\n  | OTHER;`) is left
  *    alone; and
- *  - the NEXT non-blank line starts like a declaration/scope token
+ *  - the NEXT line of code starts like a declaration/scope token
  *    (letter, `_`, `#`, `{`, `}`, or `~`) or the file ends — an operator,
- *    string literal, or `;` continuation rejects the match.
+ *    string literal, or `;` continuation rejects the match. Comments in
+ *    between are skipped: {fmt}'s `FMT_BEGIN_EXPORT` sits above `// A
+ *    generic formatting context …` and then the class it opens.
  * Shared by C and C++ (the idiom is identical in both).
  */
 const LONE_MACRO_LINE_RE = /^[ \t]*([A-Z][A-Z0-9_]{3,})[ \t]*(?:\/\/[^\n\r]*|\/\*[^\n\r]*\*\/[ \t]*)?\r?$/;
@@ -701,13 +1154,16 @@ export function blankLoneMacroLines(source: string): string {
     if (!(m[1] as string).includes('_')) continue;
     let prev = i - 1;
     while (prev >= 0 && content(lines[prev] as string) === '') prev--;
-    if (prev >= 0 && LONE_MACRO_CONTINUATION_END_RE.test(content(lines[prev] as string))) continue;
-    let next = i + 1;
-    while (next < lines.length && content(lines[next] as string) === '') next++;
-    if (next < lines.length) {
-      const first = content(lines[next] as string)[0];
-      if (!first || !/[A-Za-z_#{}~]/.test(first)) continue;
-    }
+    // Judged on the line's code: a comment — `/// @sa https://…/meta/`, a
+    // block comment's `*/` — ends in whatever it likes but continues nothing,
+    // while `CURLE_TOO_LARGE, /* 100 */` continues with its comma. A template
+    // head (`template<typename T, typename... Args>`) before a declaration
+    // continues nothing either.
+    const prevText = prev >= 0 ? content(lines[prev] as string) : '';
+    const prevCode = /^(?:\/\/|\/\*|\*)/.test(prevText) ? '' : prevText.replace(/\/\*.*?\*\/|\/\/.*$/g, '').trim();
+    if (prevCode !== '' && !/^template\s*</.test(prevCode) && LONE_MACRO_CONTINUATION_END_RE.test(prevCode)) continue;
+    const first = firstCodeCharAfter(lines, i + 1);
+    if (first !== undefined && !/[A-Za-z_#{}~]/.test(first)) continue;
     const start = line.indexOf(m[1] as string);
     lines[i] =
       line.slice(0, start) + ' '.repeat((m[1] as string).length) + line.slice(start + (m[1] as string).length);
@@ -716,6 +1172,28 @@ export function blankLoneMacroLines(source: string): string {
   return changed ? lines.join('\n') : source;
 }
 
+/** The first character of code at or after line `from`, past blank lines and
+ * comments; undefined at the end of the file. */
+function firstCodeCharAfter(lines: readonly string[], from: number): string | undefined {
+  let inBlock = false;
+  for (let k = from; k < lines.length; k++) {
+    let text = (lines[k] as string).trim();
+    for (;;) {
+      if (inBlock) {
+        const end = text.indexOf('*/');
+        if (end < 0) { text = ''; break; }
+        text = text.slice(end + 2).trim();
+        inBlock = false;
+      }
+      if (text.startsWith('//')) text = '';
+      else if (text.startsWith('/*')) { inBlock = true; text = text.slice(2); continue; }
+      break;
+    }
+    if (text !== '') return text[0];
+  }
+  return undefined;
+}
+
 /**
  * Blank an export/visibility macro sitting in front of a *member* or *method*
  * declaration inside a class/namespace (`ENGINE_API virtual void Tick(…)`,
@@ -924,10 +1402,7 @@ function restoreDirectiveLines(original: string, blanked: string): string {
 function normalizeCppComInterfaces(source: string): string {
   if (!source.includes('interface')) return source;
   // Raw strings have already been masked by preParseCppSource.
-  let code = source.replace(
-    /\/\/(?:\\\r?\n|[^\r\n])*|\/\*[\s\S]*?(?:\*\/|$)|"(?:\\[\s\S]|[^"\\])*(?:"|$)|(?<!\w)(?:u8|[LuU])?'(?:\\[\s\S]|[^'\\])*(?:'|$)/g,
-    (m) => m.replace(/[^\r\n]/g, ' ')
-  );
+  let code = maskCppCommentsAndLiterals(source);
   const hasAlias = /^[ \t]*#[ \t]*define[ \t]+interface[ \t]+struct\b/m.test(code);
   code = code.replace(/^[ \t]*#(?:\\\r?\n|[^\r\n])*/gm, (m) => m.replace(/[^\r\n]/g, '\0'));
   const declaration = /(^|[;{}])\s*\binterface\s+[A-Za-z_]\w*\s*(:[^;{}]+)?\{/gm;
@@ -953,17 +1428,128 @@ function normalizeCppComInterfaces(source: string): string {
  * annotations, and CUDA specifiers + launch syntax (by `.cu`/`.cuh` extension
  * or by content, for CUDA living in `.h`/`.hpp` headers). Offset-preserving;
  * directive lines are restored at the end (see restoreDirectiveLines). */
+/**
+ * An access specifier spelled as a macro — nlohmann/json's
+ * `JSON_PRIVATE_UNLESS_TESTED:` (private, or public under test), Qt's
+ * `Q_SIGNALS:` — is rewritten to the keyword it stands for, padded to the
+ * same length. tree-sitter-cpp reads `NAME:` inside a class as an error, and
+ * json.hpp's recovery lost members around each one.
+ */
+const ACCESS_MACRO_LINE = /^([ \t]*)([A-Z][A-Z0-9]*_[A-Z0-9_]*)([ \t]*):(?!:)(?=[ \t]*(?:\/\/[^\n]*)?\r?$)/gm;
+export function rewriteCppAccessMacros(source: string): string {
+  if (!/_[A-Z0-9_]*[ \t]*:(?!:)/.test(source)) return source;
+  return source.replace(ACCESS_MACRO_LINE, (m, indent: string, name: string, gap: string) => {
+    const keyword = /PRIVATE/.test(name) ? 'private' : /PROTECTED/.test(name) ? 'protected'
+      : /PUBLIC|^Q_SIGNALS$|^Q_SLOTS$/.test(name) ? 'public' : null;
+    if (!keyword || keyword.length > name.length + gap.length) return m;
+    return `${indent}${keyword}${' '.repeat(name.length + gap.length - keyword.length)}:`;
+  });
+}
+
+/**
+ * A preprocessor conditional in the middle of a declaration or expression —
+ * inside a constructor's member-initializer list (nlohmann/json's
+ * `noexcept\n#ifdef JSON_NO_THREAD_LOCAL\n : m_okay(false)\n#else\n :
+ * m_okay(…)\n#endif`), between a template head and its function
+ * (`template <…>\n#if defined(JSON_HAS_CPP_14)\n constexpr\n#endif\n auto
+ * get()`), inside an argument list — is an error to tree-sitter-cpp, and
+ * json.hpp's recovery took the whole `basic_json` class with it. Where the
+ * code before the `#if` has not ended a statement or declaration (`;`, `{`,
+ * `}`, a label's `:`), its directives are blanked and so is every branch
+ * after the first: one consistent configuration, every newline and offset
+ * kept. A conditional between whole declarations is left alone.
+ */
+export function flattenMidStatementConditionals(source: string): string {
+  if (!source.includes('#')) return source;
+  const lines = source.split('\n');
+  const directive = (i: number) => /^[ \t]*#[ \t]*(\w+)/.exec(lines[i] ?? '')?.[1] ?? null;
+  const code = (i: number) => (lines[i] ?? '').replace(/\/\/.*$/, '').replace(/\/\*.*?\*\//g, '').trim();
+  let changed = false;
+  const blank = (i: number) => {
+    lines[i] = (lines[i] ?? '').replace(/[^\r]/g, ' ');
+    changed = true;
+  };
+  let lastCode = '';          // the last non-directive code line, trimmed
+  let inBlockComment = false;
+  let region = 0;             // #if depth inside a flattened conditional (0 = none)
+  let skipFrom = 0;           // the depth whose later branches are blanked (0 = none)
+  let continued = false;      // inside a `\`-continued directive (a multi-line #define)
+  for (let i = 0; i < lines.length; i++) {
+    if (continued) {
+      continued = /\\\s*$/.test(lines[i] ?? '');
+      continue;
+    }
+    const d = directive(i);
+    if (d !== null && !inBlockComment) {
+      // A directive continued with `\` spans lines; its body is not code.
+      if (/\\\s*$/.test(lines[i]!)) {
+        continued = true;
+        if (region === 0) continue;
+      }
+      const opens = /^if/.test(d);
+      if (region === 0) {
+        // Not after a statement macro written without its `;`
+        // (`RAPIDJSON_DIAG_OFF(padded)`), either.
+        const mid = opens && lastCode !== '' && !/[;{}]$|^[\w\s]*:$|\*\/$/.test(lastCode) &&
+          !/^(?:public|private|protected)\s*:$/.test(lastCode) && !/^[A-Z][A-Z0-9_]*(?:\s*\(.*\))?$/.test(lastCode);
+        if (!mid) continue;
+        region = 1;
+        blank(i);
+        continue;
+      }
+      if (opens) region++;
+      else if ((d === 'else' || d === 'elif') && skipFrom === 0) skipFrom = region;
+      else if (d === 'endif') {
+        if (skipFrom === region) skipFrom = 0;
+        region--;
+      }
+      if (/^(?:if|ifdef|ifndef|else|elif|elifdef|elifndef|endif)$/.test(d)) blank(i);
+      continue;
+    }
+    const text = lines[i] ?? '';
+    if (region > 0 && skipFrom > 0) {
+      if (text.trim() !== '') blank(i);
+      continue;
+    }
+    // Track block comments so a `#` or `;` inside one is not read as code.
+    const trimmed = code(i);
+    if (inBlockComment) {
+      if (text.includes('*/')) inBlockComment = false;
+      continue;
+    }
+    if (/\/\*(?!.*\*\/)/.test(text.replace(/\/\/.*$/, ''))) {
+      inBlockComment = true;
+      const before = trimmed.split('/*')[0]!.trim();
+      if (before !== '') lastCode = before;
+      continue;
+    }
+    if (trimmed !== '') lastCode = trimmed;
+  }
+  return changed ? lines.join('\n') : source;
+}
+
 function preParseCppSource(source: string, filePath?: string): string {
   const rawStrings = maskCppRawStrings(source);
-  source = rawStrings.source;
+  source = flattenMidStatementConditionals(rewriteCppAccessMacros(rawStrings.source));
   // blankCLeadingAttrMacros runs AFTER the api-prefix blank so a stacked
   // `FMT_NORETURN FMT_API void f(…)` reduces to the `MACRO Ret name(` shape
-  // it matches (the _API token is already spaces by then).
+  // it matches (the _API token is already spaces by then). The C++ leading
+  // blank runs after the pointer, trailing and declarator ones, so the
+  // declaration it looks for (`Type* name(`, `Type name;`) is already free of
+  // their macros.
   let blanked = blankLoneMacroLines(
-    blankCLeadingAttrMacros(
-      blankCppAnnotationMacroCalls(
-        blankCppInlineAnnotationMacros(
-          blankCppApiPrefixMacros(blankCppInlineMacros(blankCppExportMacros(normalizeCppComInterfaces(source))))
+    blankCppLeadingAttributeMacros(
+      blankCLeadingAttrMacros(
+        blankCppAnnotationMacroCalls(
+          blankCppDeclaratorAttributeMacros(
+            blankCppTrailingAttributeMacros(
+              blankCppPointerAnnotationMacros(
+                blankCppInlineAnnotationMacros(
+                  blankCppApiPrefixMacros(blankCppInlineMacros(blankCppExportMacros(normalizeCppComInterfaces(source))))
+                )
+              )
+            )
+          )
         )
       )
     )
@@ -1813,7 +2399,9 @@ export const cppExtractor: LanguageExtractor = {
   nameField: 'declarator',
   bodyField: 'body',
   paramsField: 'parameters',
-  resolveName: extractCppQualifiedMethodName,
+  resolveName: (node, source) =>
+    extractCppQualifiedMethodName(node, source) ?? unnamedTypeVariableName(node, source),
+  getDeclarationWrapper: (node) => definingDeclaration(node) ?? undefined,
   getReceiverType: extractCppReceiverType,
   getReturnType: extractCppReturnType,
   // Constructors (definitions and class-body declarations) carry their
diff --git a/src/extraction/languages/cpp-brace-scopes.ts b/src/extraction/languages/cpp-brace-scopes.ts
new file mode 100644
index 0000000000..f83968117e
--- /dev/null
+++ b/src/extraction/languages/cpp-brace-scopes.ts
@@ -0,0 +1,360 @@
+/**
+ * C++ scopes read from the source's braces, for a file whose parse tree has
+ * errors.
+ *
+ * tree-sitter recovers from a construct it can't parse by inserting the token
+ * it expected, and inside a class body that token is often a `}`: an unknown
+ * macro in front of a member (`PROTOBUF_FUTURE_ADD_EARLY_NODISCARD
+ * absl::string_view name() const`, `struct ALIGN_AS(64U) HandleImpl`) closes
+ * the class there. Every `}` after it then closes the scope one level out, so
+ * the rest of the class, and of each namespace around it, parses as
+ * declarations of an outer scope: protobuf's `FieldDescriptor` indexed as
+ * `FieldDescriptor` instead of `google::protobuf::FieldDescriptor`, rocksdb's
+ * `struct Opts` outside the class it is declared in. Recovery also runs the
+ * other way and keeps a scope open past its own `}`.
+ *
+ * The braces are rarely what the parser misread, so the walker takes each
+ * declaration's namespaces and enclosing classes from them instead
+ * (TreeSitterExtractor.visitInCppBraceScope; mirrored in the kernel,
+ * ccpp/mod.rs). The scan skips comments, string and character literals (raw
+ * strings and digit separators too) and preprocessor lines. Each branch of an
+ * `#if` is read from the braces open at the `#if`, and the scan continues
+ * after `#endif` with the first branch's — so `#if A` `struct X : B {`
+ * `#else` `struct X {` `#endif` opens one scope, not two. A file whose braces
+ * don't balance gets no scopes and keeps the tree's.
+ */
+
+/** Intervals that nest properly, added in order of their opening offset. */
+export class NestedIntervals<T> {
+  private readonly opens: number[] = [];
+  private readonly closes: number[] = [];
+  private readonly parents: number[] = [];
+  private readonly values: T[] = [];
+
+  /**
+   * Adds the interval `(open, close)`. One that opens before the last one
+   * added, or crosses one that holds it, is refused (false).
+   */
+  add(open: number, close: number, value: T): boolean {
+    const count = this.opens.length;
+    if (close <= open || (count > 0 && open <= this.opens[count - 1]!)) return false;
+    const parent = this.innermost(open);
+    if (parent >= 0 && close >= this.closes[parent]!) return false;
+    this.opens.push(open);
+    this.closes.push(close);
+    this.parents.push(parent);
+    this.values.push(value);
+    return true;
+  }
+
+  /** The values of the intervals holding `offset` (open < offset < close), outermost first. */
+  at(offset: number): T[] {
+    const out: T[] = [];
+    for (let k = this.innermost(offset); k >= 0; k = this.parents[k]!) out.push(this.values[k]!);
+    return out.reverse();
+  }
+
+  /**
+   * The innermost interval holding `offset`, or -1. It is the last interval
+   * opening before `offset` or one of the intervals around that one.
+   */
+  private innermost(offset: number): number {
+    let lo = 0;
+    let hi = this.opens.length - 1;
+    let k = -1;
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1;
+      if (this.opens[mid]! < offset) {
+        k = mid;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    while (k >= 0 && this.closes[k]! <= offset) k = this.parents[k]!;
+    return k;
+  }
+}
+
+export interface CppBraceScopes {
+  /** The offset of the `}` that closes the `{` at `open`. */
+  closeOf(open: number): number | undefined;
+  /** The named namespaces whose braces hold `offset`, outermost first, as written (`a::b`). */
+  namespacesAt(offset: number): string[];
+  /** The 1-based line and the column of `offset`. */
+  positionOf(offset: number): { line: number; column: number };
+}
+
+const NEWLINE = 10;
+const isBlank = (c: number): boolean => c === 32 || c === 9 || c === 13 || c === 12 || c === 11;
+const isWordStart = (c: number): boolean =>
+  (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c === 95 || c === 36 || c >= 128;
+const isDigit = (c: number): boolean => c >= 48 && c <= 57;
+const isWordChar = (c: number): boolean => isWordStart(c) || isDigit(c);
+const RAW_STRING_PREFIX = /^(?:u8|[uUL])?R$/;
+// A raw string's delimiter: up to 16 printable ASCII characters but `"`, `(`, `)` and `\`.
+const RAW_STRING_DELIMITER = /^[!#-'*-[\]-~]{0,16}$/;
+
+/** The end of a `//` comment starting at `i`: its newline (a `\` before it continues the comment). */
+function lineCommentEnd(source: string, i: number): number {
+  for (;;) {
+    const nl = source.indexOf('\n', i);
+    if (nl < 0) return source.length;
+    let k = nl - 1;
+    if (source.charCodeAt(k) === 13) k--;
+    if (source.charCodeAt(k) !== 92) return nl;
+    i = nl + 1;
+  }
+}
+
+/** Past whitespace and comments from `i`. */
+function skipBlank(source: string, i: number): number {
+  const n = source.length;
+  while (i < n) {
+    const c = source.charCodeAt(i);
+    if (isBlank(c) || c === NEWLINE) i++;
+    else if (c === 47 && source.charCodeAt(i + 1) === 47) i = lineCommentEnd(source, i + 2);
+    else if (c === 47 && source.charCodeAt(i + 1) === 42) {
+      const end = source.indexOf('*/', i + 2);
+      i = end < 0 ? n : end + 2;
+    } else break;
+  }
+  return i;
+}
+
+/** The end of the identifier at `i`, or -1 when none starts there. */
+function wordEnd(source: string, i: number): number {
+  if (!isWordStart(source.charCodeAt(i))) return -1;
+  let j = i + 1;
+  while (j < source.length && isWordChar(source.charCodeAt(j))) j++;
+  return j;
+}
+
+/** Past the `(…)` group at `i` (strings inside skipped), or -1. */
+function parenGroupEnd(source: string, i: number): number {
+  let depth = 0;
+  for (let j = i; j < source.length; j++) {
+    const c = source.charCodeAt(j);
+    if (c === 34 || c === 39) j = quotedEnd(source, j) - 1;
+    else if (c === 40) depth++;
+    else if (c === 41 && --depth === 0) return j + 1;
+  }
+  return -1;
+}
+
+/** Past the string or character literal whose quote is at `i` (it stops at a newline). */
+function quotedEnd(source: string, i: number): number {
+  const quote = source.charCodeAt(i);
+  let j = i + 1;
+  while (j < source.length) {
+    const c = source.charCodeAt(j);
+    if (c === 92) j += source.charCodeAt(j + 1) === 13 && source.charCodeAt(j + 2) === NEWLINE ? 3 : 2;
+    else if (c === quote) return j + 1;
+    else if (c === NEWLINE) return j;
+    else j++;
+  }
+  return source.length;
+}
+
+/**
+ * After the `namespace` keyword ending at `from`: the name as written and the
+ * offset of the `{` that opens the body. Null for anything else, such as
+ * `using namespace std;` or `namespace fs = std::filesystem;`. Takes C++17
+ * attributes (`namespace [[deprecated]] old {`), nested and inline names
+ * (`namespace a::inline b {`), and an attribute macro after the name
+ * (`namespace std _GLIBCXX_VISIBILITY(default) {`).
+ */
+function namespaceHead(source: string, from: number): { name: string; brace: number } | null {
+  let i = skipBlank(source, from);
+  while (source.startsWith('[[', i)) {
+    const end = source.indexOf(']]', i + 2);
+    if (end < 0) return null;
+    i = skipBlank(source, end + 2);
+  }
+  let nameStart = -1;
+  let nameEnd = -1;
+  for (let end = wordEnd(source, i); end >= 0; end = wordEnd(source, i)) {
+    if (nameStart < 0) nameStart = i;
+    nameEnd = end;
+    i = skipBlank(source, end);
+    if (!source.startsWith('::', i)) break;
+    i = skipBlank(source, i + 2);
+    const inline = wordEnd(source, i);
+    if (inline >= 0 && source.slice(i, inline) === 'inline') i = skipBlank(source, inline);
+  }
+  for (let end = wordEnd(source, i); end >= 0 && nameStart >= 0; end = wordEnd(source, i)) {
+    const paren = skipBlank(source, end);
+    const after = source.charCodeAt(paren) === 40 ? parenGroupEnd(source, paren) : -1;
+    if (after < 0) return null;
+    i = skipBlank(source, after);
+  }
+  if (source.charCodeAt(i) !== 123) return null;
+  return { name: nameStart < 0 ? '' : source.slice(nameStart, nameEnd), brace: i };
+}
+
+/**
+ * Scan `source` (a C++ file as the parser saw it, after preParse) for its
+ * braces and namespaces. Null when the braces don't balance.
+ */
+export function scanCppBraceScopes(source: string): CppBraceScopes | null {
+  const n = source.length;
+  const closes = new Map<number, number>();
+  let open: number[] = [];
+  // Per `#if` group: the braces open at the `#if`, and those open after its
+  // first branch (null until a second branch starts).
+  const branches: Array<{ atIf: number[]; afterFirst: number[] | null }> = [];
+  const namespaceAt = new Map<number, string>(); // `{` offset → name, for named namespaces
+  let pendingNamespace: { name: string; brace: number } | null = null;
+  let balanced = true;
+  let lineStart = true;
+  let wordStart = -1; // the last identifier or number read
+  let wordEndAt = -1;
+  let i = source.charCodeAt(0) === 0xfeff ? 1 : 0; // past a byte-order mark, so line 1 can be a directive
+  while (i < n) {
+    const c = source.charCodeAt(i);
+    if (c === NEWLINE) {
+      lineStart = true;
+      i++;
+      continue;
+    }
+    if (isBlank(c)) {
+      i++;
+      continue;
+    }
+    if (c === 47 && source.charCodeAt(i + 1) === 47) {
+      i = lineCommentEnd(source, i + 2);
+      continue;
+    }
+    if (c === 47 && source.charCodeAt(i + 1) === 42) {
+      const end = source.indexOf('*/', i + 2);
+      i = end < 0 ? n : end + 2;
+      continue;
+    }
+    if (c === 35 && lineStart) {
+      // A directive runs to the end of its line, through `\` continuations
+      // and comments. Only `"` strings are skipped in it: an apostrophe in
+      // `#error Don't …` is no character literal.
+      let j = i + 1;
+      while (j < n && isBlank(source.charCodeAt(j))) j++;
+      const nameEnd = wordEnd(source, j);
+      const directive = nameEnd < 0 ? '' : source.slice(j, nameEnd);
+      while (j < n) {
+        const d = source.charCodeAt(j);
+        if (d === NEWLINE) {
+          let k = j - 1;
+          if (source.charCodeAt(k) === 13) k--;
+          if (source.charCodeAt(k) !== 92) break;
+          j++;
+        } else if (d === 47 && source.charCodeAt(j + 1) === 47) {
+          j = lineCommentEnd(source, j + 2);
+        } else if (d === 47 && source.charCodeAt(j + 1) === 42) {
+          const end = source.indexOf('*/', j + 2);
+          j = end < 0 ? n : end + 2;
+        } else if (d === 34) {
+          j = quotedEnd(source, j);
+        } else {
+          j++;
+        }
+      }
+      if (directive === 'if' || directive === 'ifdef' || directive === 'ifndef') {
+        branches.push({ atIf: open.slice(), afterFirst: null });
+      } else if (
+        (directive === 'else' || directive === 'elif' || directive === 'elifdef' || directive === 'elifndef') &&
+        branches.length > 0
+      ) {
+        const group = branches[branches.length - 1]!;
+        if (group.afterFirst === null) group.afterFirst = open;
+        open = group.atIf.slice();
+      } else if (directive === 'endif' && branches.length > 0) {
+        const group = branches.pop()!;
+        if (group.afterFirst !== null) open = group.afterFirst;
+      }
+      i = j;
+      continue;
+    }
+    lineStart = false;
+    if (c === 34) {
+      // A raw string (`R"x(…)x"`) can hold any brace and quote; its prefix is
+      // the word that ends right at the quote.
+      if (wordEndAt === i && i - wordStart <= 3 && RAW_STRING_PREFIX.test(source.slice(wordStart, i))) {
+        const paren = source.indexOf('(', i + 1);
+        const delimiter = paren < 0 ? '' : source.slice(i + 1, paren);
+        if (paren >= 0 && RAW_STRING_DELIMITER.test(delimiter)) {
+          const end = source.indexOf(`)${delimiter}"`, paren + 1);
+          i = end < 0 ? n : end + delimiter.length + 2;
+          continue;
+        }
+      }
+      i = quotedEnd(source, i);
+      continue;
+    }
+    if (c === 39) {
+      i = quotedEnd(source, i);
+      continue;
+    }
+    if (isDigit(c) || (c === 46 && isDigit(source.charCodeAt(i + 1)))) {
+      // A number, digit separators (`1'000'000`) and exponent signs included.
+      let j = i + 1;
+      while (j < n) {
+        const d = source.charCodeAt(j);
+        if (isWordChar(d) || d === 46) j++;
+        else if (d === 39 && isWordChar(source.charCodeAt(j + 1))) j += 2;
+        else if ((d === 43 || d === 45) && /[eEpP]/.test(source[j - 1]!)) j++;
+        else break;
+      }
+      wordStart = i;
+      wordEndAt = j;
+      i = j;
+      continue;
+    }
+    if (isWordStart(c)) {
+      const end = wordEnd(source, i);
+      wordStart = i;
+      wordEndAt = end;
+      if (end - i === 9 && source.startsWith('namespace', i)) {
+        const head = namespaceHead(source, end);
+        if (head) pendingNamespace = head;
+      }
+      i = end;
+      continue;
+    }
+    if (c === 123) {
+      open.push(i);
+      if (pendingNamespace && pendingNamespace.brace === i) {
+        if (pendingNamespace.name) namespaceAt.set(i, pendingNamespace.name);
+        pendingNamespace = null;
+      }
+    } else if (c === 125) {
+      const from = open.pop();
+      if (from === undefined) balanced = false;
+      else if (!closes.has(from)) closes.set(from, i);
+    }
+    i++;
+  }
+  if (!balanced || open.length > 0) return null;
+
+  const namespaces = new NestedIntervals<string>();
+  for (const [brace, name] of [...namespaceAt].sort((a, b) => a[0] - b[0])) {
+    const close = closes.get(brace);
+    if (close !== undefined) namespaces.add(brace, close, name);
+  }
+  let lineStarts: number[] | null = null;
+  return {
+    closeOf: (at) => closes.get(at),
+    namespacesAt: (offset) => namespaces.at(offset),
+    positionOf: (offset) => {
+      if (!lineStarts) {
+        lineStarts = [0];
+        for (let k = source.indexOf('\n'); k >= 0; k = source.indexOf('\n', k + 1)) lineStarts.push(k + 1);
+      }
+      let lo = 0;
+      let hi = lineStarts.length - 1;
+      while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineStarts[mid]! <= offset) lo = mid;
+        else hi = mid - 1;
+      }
+      return { line: lo + 1, column: offset - lineStarts[lo]! };
+    },
+  };
+}
diff --git a/src/extraction/languages/csharp.ts b/src/extraction/languages/csharp.ts
index 14757de246..a88b01f817 100644
--- a/src/extraction/languages/csharp.ts
+++ b/src/extraction/languages/csharp.ts
@@ -52,6 +52,9 @@ function extractCsharpReturnType(node: SyntaxNode, source: string): string | und
   return last;
 }
 
+/** Where a C# declaration with no access modifier defaults to `internal`. */
+const CSHARP_TYPE_SCOPES = new Set(['compilation_unit', 'namespace_declaration', 'file_scoped_namespace_declaration']);
+
 export const csharpExtractor: LanguageExtractor = {
   preParse: blankCsharpPreprocessorDirectives,
   functionTypes: [],
@@ -79,10 +82,10 @@ export const csharpExtractor: LanguageExtractor = {
   typeAliasTypes: [],
   // Namespaces qualify type names so same-named types in different namespaces are
   // distinguishable (e.g. `ApplicationCore.Entities.CatalogBrand` vs
-  // `BlazorShared.Models.CatalogBrand`). Both block (`namespace Foo { … }`, which
-  // nests its types) and file-scoped (`namespace Foo;`) forms — extractFilePackage
-  // pushes the namespace onto the scope so nested/top-level types pick it up.
-  packageTypes: ['namespace_declaration', 'file_scoped_namespace_declaration'],
+  // `BlazorShared.Models.CatalogBrand`). A file-scoped `namespace Foo;` covers the
+  // whole file (extractFilePackage); a block `namespace Foo { … }` only its body
+  // (the visitor scopes it).
+  packageTypes: ['file_scoped_namespace_declaration'],
   extractPackage: (node: SyntaxNode, source: string) => {
     const name =
       node.childForFieldName('name') ??
@@ -110,7 +113,12 @@ export const csharpExtractor: LanguageExtractor = {
         if (text === 'internal') return 'internal';
       }
     }
-    return 'private'; // C# defaults to private
+    // No modifier: an interface's members are public, a type declared in a
+    // namespace (or the file) is internal, and a class or struct member is private.
+    const container = node.parent?.type === 'declaration_list' ? node.parent.parent : node.parent;
+    if (container?.type === 'interface_declaration') return 'public';
+    if (!container || CSHARP_TYPE_SCOPES.has(container.type)) return 'internal';
+    return 'private';
   },
   isStatic: (node) => {
     for (let i = 0; i < node.childCount; i++) {
diff --git a/src/extraction/languages/dart.ts b/src/extraction/languages/dart.ts
index 5ba07a0f0c..6f68fb234e 100644
--- a/src/extraction/languages/dart.ts
+++ b/src/extraction/languages/dart.ts
@@ -1,7 +1,234 @@
 import type { Node as SyntaxNode } from 'web-tree-sitter';
-import { getNodeText } from '../tree-sitter-helpers';
+import type { UnresolvedReference } from '../../types';
+import { getNodeText, BUILTIN_TYPE_NAMES } from '../tree-sitter-helpers';
 import type { LanguageExtractor } from '../tree-sitter-types';
 
+/**
+ * Whether a Dart `type_identifier` names a type a reference should point at.
+ * Dart writes types in UpperCamelCase (`_Private`, `$Generated` too), so a
+ * lowercase one is a built-in like `num` or `dynamic` — or no type at all:
+ * error recovery around syntax the grammar predates (dot shorthands like
+ * `.leading`) turns argument names into `type_identifier`s. Two more are not
+ * types of their own: the import prefix of `p.Foo` (it names a library), and
+ * the class a `new` / `const` constructor call names (the call links it).
+ */
+export function isDartTypeName(node: SyntaxNode): boolean {
+  if (!/^[_$]*[A-Z]/.test(node.text) || BUILTIN_TYPE_NAMES.has(node.text)) return false;
+  if (node.nextSibling?.type === '.') return false;
+  const parent = node.parent;
+  return parent?.type !== 'new_expression' && parent?.type !== 'const_object_expression';
+}
+
+/**
+ * A `references` ref from `fromNodeId` for every type named inside `node` — a
+ * declared type, a generic argument, a cast or a type test (#2327).
+ */
+export function pushDartTypeRefs(
+  node: SyntaxNode,
+  fromNodeId: string,
+  push: (ref: UnresolvedReference) => void,
+): void {
+  if (node.type === 'type_identifier') {
+    if (isDartTypeName(node)) {
+      push({
+        fromNodeId,
+        referenceName: node.text,
+        referenceKind: 'references',
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column,
+      });
+    }
+    return;
+  }
+  for (const child of node.namedChildren) pushDartTypeRefs(child, fromNodeId, push);
+}
+
+/** The bodies a Dart field `declaration` can sit in: a class's or mixin's, an extension's, an enum's. */
+const DART_MEMBER_BODIES: ReadonlySet<string> = new Set(['class_body', 'extension_body', 'enum_body']);
+
+/** The named nodes a top-level variable's declared type is written as (`Report? x;`, `List<Report> xs = [];`). */
+const DART_TOP_LEVEL_TYPES: ReadonlySet<string> = new Set(['type_identifier', 'type_arguments', 'function_type', 'record_type']);
+
+/**
+ * Whether an `initialized_identifier` declares a field or a top-level
+ * variable — `var cache = load();`, `final _ctl = TextEditingController();`
+ * in a class — rather than the second variable of a local declaration
+ * (`for (var i = 0, j = n(); …)`), which a function body's walk covers.
+ */
+function isDartFieldOrTopLevelEntry(node: SyntaxNode): boolean {
+  const list = node.parent;
+  if (list?.type !== 'initialized_identifier_list') return false;
+  const owner = list.parent;
+  if (owner?.type === 'program') return true;
+  return owner?.type === 'declaration' && owner.parent !== null && DART_MEMBER_BODIES.has(owner.parent.type);
+}
+
+/** The comments tree-sitter-dart keeps as named nodes: line and block comments, and dartdoc. */
+const DART_COMMENTS: ReadonlySet<string> = new Set(['comment', 'documentation_comment']);
+
+/**
+ * The named sibling before `node`, past any comments. A Dart member chain is
+ * an identifier followed by sibling selectors, and the grammar keeps a comment
+ * as a sibling wherever it is written, so in `tester //` + newline +
+ * `.state(…)` (the empty `//` keeps dart format from joining the lines) the
+ * comment, not `tester`, is right before the `.state` selector.
+ */
+function dartPrevNamed(node: SyntaxNode): SyntaxNode | null {
+  let prev = node.previousNamedSibling;
+  while (prev && DART_COMMENTS.has(prev.type)) prev = prev.previousNamedSibling;
+  return prev;
+}
+
+/** The named sibling after `node`, past any comments (see dartPrevNamed). */
+function dartNextNamed(node: SyntaxNode): SyntaxNode | null {
+  let next = node.nextNamedSibling;
+  while (next && DART_COMMENTS.has(next.type)) next = next.nextNamedSibling;
+  return next;
+}
+
+/**
+ * The receiver of the member access `selector`: the node in front of it, past
+ * any comments, or the end of an arrow function's body when the grammar ended
+ * the arrow in front of a generic call — `(ref) => ref.watch<int>(p)` comes
+ * out as `((ref) => ref).watch<int>(p)`. Dart writes a member access on the
+ * arrow itself in parentheses, so a receiver in that place is never the
+ * arrow. It names the call (`ref.watch`) and a static member's class; a call
+ * chained on that call keeps its bare name (see dartMisparsedGenericCall).
+ */
+export function dartReceiverOf(selector: SyntaxNode): SyntaxNode | null {
+  const prev = dartPrevNamed(selector);
+  const body = prev?.type === 'function_expression' ? prev.lastNamedChild : null;
+  return body?.type === 'function_expression_body' ? body.lastNamedChild : prev;
+}
+
+/** Dart's lowercase built-in types, which a type argument can name: `<int>`, `<void>`. */
+const DART_LOWERCASE_TYPES: ReadonlySet<string> = new Set(['int', 'double', 'num', 'bool', 'dynamic', 'void']);
+
+/** What a callee can sit under in front of a generic call: `await`, `-`, `!`. */
+const DART_PREFIXED: ReadonlySet<string> = new Set(['unary_expression', 'await_expression']);
+
+/** A generic call tree-sitter-dart parsed as two comparisons (dartMisparsedGenericCall). */
+interface DartMisparsedCall {
+  /** The node the callee ends with: what a parsed call's argument part follows. */
+  callee: SyntaxNode;
+  /** The identifier naming the type argument (`Repo` in `<Repo>` and `<p.Repo>`). */
+  typeName: SyntaxNode;
+}
+
+/**
+ * A generic call tree-sitter-dart parsed as two comparisons, found from its
+ * `<`. `ref.read<Repo>(repoProvider)`, `Provider<int>((ref) => 0)` and
+ * `DropdownButton<String>(items: items)` come out as `(ref.read < Repo) >
+ * (repoProvider)`: a `relational_expression` inside another, with the
+ * arguments as a `parenthesized_expression`, or a `record_literal` when they
+ * are named. That happens about as often as the call parses as one, because
+ * the grammar breaks the tie by the code around it. Dart reads it as a call,
+ * and so does this when the type argument names a type (`Repo`, `p.Repo`,
+ * `Map<K, V>`, `int`, `void`) and the code is laid out as a call: `<` against
+ * the callee and `(` against the `>`. A comparison is written `a < b`.
+ *
+ * A call chained on it keeps the bare name it had (`increment` in
+ * `BlocProvider.of<CounterCubit>(context).increment()`), where a parsed
+ * chain gets `BlocProvider.of().increment`. The resolver gives both the same
+ * method: it types a bare link from the chain written before it, and an
+ * encoded chain the same way when `of` declares no type of its own to return
+ * (`static T of<T>(…)`, or a factory outside the project) (#750).
+ */
+export function dartMisparsedGenericCall(lt: SyntaxNode): DartMisparsedCall | undefined {
+  if (lt.type !== 'relational_operator' || lt.firstChild?.type !== '<') return undefined;
+  const inner = lt.parent;
+  const outer = inner?.parent;
+  if (inner?.type !== 'relational_expression' || outer?.type !== 'relational_expression') return undefined;
+  const left = outer.namedChild(0);
+  if (left?.startIndex !== inner.startIndex || left.endIndex !== inner.endIndex) return undefined;
+  const gt = outer.namedChild(1);
+  if (gt?.type !== 'relational_operator' || gt.firstChild?.type !== '>') return undefined;
+  const args = outer.namedChild(2);
+  if (args?.type !== 'parenthesized_expression' && args?.type !== 'record_literal') return undefined;
+  if (args.startIndex !== gt.endIndex) return undefined;
+  // A comment against the `<` (`ref.read /* c */<Repo>(p)`) is a sibling of
+  // its own, so the callee is not against it: not laid out as a call.
+  const before = lt.previousNamedSibling;
+  if (!before || DART_COMMENTS.has(before.type) || before.endIndex !== lt.startIndex) return undefined;
+  // The type argument: `T`, `p.T`, `T<…>` or `p.T<…>`, and nothing else.
+  const head = lt.nextNamedSibling;
+  if (head?.type !== 'identifier') return undefined;
+  let typeName = head;
+  let rest = head.nextNamedSibling;
+  if (rest?.type === 'selector' && rest.firstNamedChild?.type === 'unconditional_assignable_selector') {
+    const name = rest.firstNamedChild.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+    if (!name) return undefined;
+    typeName = name;
+    rest = rest.nextNamedSibling;
+  }
+  if (rest?.type === 'selector' && rest.namedChildCount === 1 && rest.firstNamedChild?.type === 'type_arguments') {
+    rest = rest.nextNamedSibling;
+  }
+  if (rest) return undefined;
+  if (!/^[_$]*[A-Z]/.test(typeName.text) && !DART_LOWERCASE_TYPES.has(typeName.text)) return undefined;
+  // `await repo.load<User>(id)` and `-x.size<int>(y)` put the callee under the prefix.
+  let callee: SyntaxNode = before;
+  while (DART_PREFIXED.has(callee.type)) {
+    const last: SyntaxNode | null = callee.lastNamedChild;
+    if (!last) return undefined;
+    callee = last;
+  }
+  return { callee, typeName };
+}
+
+/**
+ * Whether a member access — `.member` on `receiver`, followed by `next` under
+ * `parent` — belongs to a misparsed generic call instead of reading a member:
+ * its callee (`ref.read` in `ref.read<Repo>(p)`, after an `await` too) is
+ * called, and the prefixed type argument (`p.Repo` in `x.read<p.Repo>(y)`)
+ * names a type.
+ */
+function dartInMisparsedGenericCall(
+  receiver: SyntaxNode,
+  next: SyntaxNode | null,
+  parent: SyntaxNode | null,
+): boolean {
+  let after = next;
+  let up = parent;
+  while (!after && up && DART_PREFIXED.has(up.type)) {
+    after = up.nextNamedSibling;
+    up = after ? null : up.parent;
+  }
+  if (after?.type === 'relational_operator' && dartMisparsedGenericCall(after)) return true;
+  if (parent?.type !== 'relational_expression') return false;
+  const before = receiver.previousNamedSibling;
+  return before?.type === 'relational_operator' && dartMisparsedGenericCall(before) !== undefined;
+}
+
+/**
+ * A Dart member read — `x.area`, `s?.label`, `Config.instance` — as the ref
+ * `<receiver>.<member>`, positioned on the member's name. Reading a getter runs
+ * it, so the resolver links the read to a getter, as a call, and to nothing
+ * else (#2338). The receiver must be a plain name, the one shape whose type the
+ * resolver can look up; a member that is called (`x.grow()`, or `x.grow<T>(y)`
+ * parsed as comparisons) is the call's. `parent` is the node's parent when the
+ * walker has it: reading `.parent` walks down from the root.
+ */
+export function dartMemberRead(
+  node: SyntaxNode,
+  parent: SyntaxNode | null = node.parent,
+): { name: string; node: SyntaxNode } | undefined {
+  if (node.type !== 'selector') return undefined;
+  const accessor = node.namedChildren.find((c: SyntaxNode) =>
+    c.type === 'unconditional_assignable_selector' || c.type === 'conditional_assignable_selector'
+  );
+  const member = accessor?.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+  if (!member) return undefined;
+  const receiver = dartPrevNamed(node);
+  if (receiver?.type !== 'identifier') return undefined;
+  const next = dartNextNamed(node);
+  if (next?.type === 'selector' && next.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part')) {
+    return undefined;
+  }
+  if (dartInMisparsedGenericCall(receiver, next, parent)) return undefined;
+  return { name: `${receiver.text}.${member.text}`, node: member };
+}
+
 /**
  * The `function_signature` carrying a method's return type — unwrapped from a
  * `method_signature` wrapper (Dart nests the signature one level for methods).
@@ -16,6 +243,16 @@ function dartInnerSignature(node: SyntaxNode): SyntaxNode {
   return node;
 }
 
+/**
+ * The constructors that never have a body — `const Foo.bar();` and a
+ * redirecting factory `const factory Foo.bar() = _Bar;` — each parse as a
+ * signature kind of its own, inside a `declaration`.
+ */
+const DART_BODILESS_CTORS: ReadonlySet<string> = new Set([
+  'constant_constructor_signature',
+  'redirecting_factory_constructor_signature',
+]);
+
 /**
  * The factory/named-constructor signature inside a node, if any. A constructor
  * parses as `method_signature > {factory_,}constructor_signature` (e.g.
@@ -23,7 +260,10 @@ function dartInnerSignature(node: SyntaxNode): SyntaxNode {
  * and — for a named ctor — the constructor-name identifier.
  */
 function dartConstructorSignature(node: SyntaxNode): SyntaxNode | undefined {
-  if (node.type === 'factory_constructor_signature' || node.type === 'constructor_signature') {
+  if (
+    node.type === 'factory_constructor_signature' || node.type === 'constructor_signature' ||
+    DART_BODILESS_CTORS.has(node.type)
+  ) {
     return node;
   }
   if (node.type === 'method_signature') {
@@ -62,7 +302,13 @@ function dartEnclosingTypeName(node: SyntaxNode): string | undefined {
 function dartCtorInfo(node: SyntaxNode): { className: string; ctorName: string } | undefined {
   const ctor = dartConstructorSignature(node);
   if (!ctor) return undefined;
-  const ids = ctor.namedChildren.filter((c: SyntaxNode) => c.type === 'identifier');
+  // The names before the parameters: a redirecting factory names its target
+  // after them (`factory Foo() = _Impl.named;`).
+  const ids: SyntaxNode[] = [];
+  for (const c of ctor.namedChildren) {
+    if (c.type === 'formal_parameter_list') break;
+    if (c.type === 'identifier') ids.push(c);
+  }
   const className = dartEnclosingTypeName(node);
   if (!className || !ids[0]) return undefined;
   if (ids[0].text !== className) return undefined; // misparsed method, not a ctor
@@ -92,6 +338,19 @@ function extractDartReturnType(node: SyntaxNode, source: string): string | undef
   return last;
 }
 
+/**
+ * The type a call written with type arguments goes through — `BlocProvider`
+ * in `BlocProvider<CounterCubit>.value(…)`, when `selector` is the `<…>`
+ * between the type and `.value`. Only a constructor is called that way.
+ */
+function dartTypeArgumentsReceiver(selector: SyntaxNode | null): string | undefined {
+  if (selector?.type !== 'selector' || selector.namedChildCount !== 1 || selector.namedChild(0)?.type !== 'type_arguments') {
+    return undefined;
+  }
+  const type = dartPrevNamed(selector);
+  return type?.type === 'identifier' ? type.text : undefined;
+}
+
 /**
  * The callee name of the Dart call whose `argument_part` selector is `argPart`
  * — mirrors the main extractBareCall accessor logic so a chained receiver
@@ -99,7 +358,7 @@ function extractDartReturnType(node: SyntaxNode, source: string): string | undef
  * `Foo.create`, a bare `create`, or `Foo` (constructor) — or undefined.
  */
 function dartCalleeOfArgPart(argPart: SyntaxNode): string | undefined {
-  const prev = argPart.previousNamedSibling;
+  const prev = dartPrevNamed(argPart);
   if (!prev) return undefined;
   if (prev.type === 'identifier') return prev.text; // bare `Foo()` / `create()`
   if (prev.type === 'selector') {
@@ -108,14 +367,79 @@ function dartCalleeOfArgPart(argPart: SyntaxNode): string | undefined {
     );
     const methodId = accessor?.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
     if (methodId) {
-      const accessorPrev = prev.previousNamedSibling;
+      const accessorPrev = dartPrevNamed(prev);
       if (accessorPrev?.type === 'identifier') return accessorPrev.text + '.' + methodId.text;
+      const typeName = dartTypeArgumentsReceiver(accessorPrev);
+      if (typeName) return typeName + '.' + methodId.text;
       return methodId.text;
     }
   }
   return undefined;
 }
 
+/**
+ * The callee name of the Dart call whose argument part follows `prev`: `run`
+ * for `run(…)`, `obj.method` for `obj.method(…)`, `Foo.create().bar` for a
+ * chain off a capitalized call (#750), and a bare `method` otherwise.
+ */
+function dartCallee(prev: SyntaxNode): string | undefined {
+  // Simple function/constructor call: prev is identifier (e.g., runApp(...), MyWidget(...))
+  if (prev.type === 'identifier') {
+    return prev.text;
+  }
+
+  // Method call: prev is selector with accessor (e.g., obj.method(...), Navigator.push(...))
+  if (prev.type === 'selector') {
+    const accessor = prev.namedChildren.find((c: SyntaxNode) =>
+      c.type === 'unconditional_assignable_selector' || c.type === 'conditional_assignable_selector'
+    );
+    if (accessor) {
+      const methodId = accessor.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+      if (methodId) {
+        // Include receiver for first call in chain (receiver is a direct identifier)
+        const accessorPrev = dartReceiverOf(prev);
+        if (accessorPrev?.type === 'identifier') {
+          return accessorPrev.text + '.' + methodId.text;
+        }
+        // A constructor called with type arguments names its type all the
+        // same: `BlocProvider<CounterCubit>.value(…)` → `BlocProvider.value`.
+        const typeName = dartTypeArgumentsReceiver(accessorPrev);
+        if (typeName) return typeName + '.' + methodId.text;
+        // Chained static-factory / fluent call: the receiver is itself a call
+        // (`Foo.create().bar()`), so accessorPrev is that call's argument_part
+        // selector. Encode `<innerCallee>().<method>` so resolution can infer
+        // bar's class from what `Foo.create` RETURNS (#645/#608 mechanism) —
+        // but only when the chain starts with a capitalized type (a companion
+        // factory / static method / constructor); an instance chain
+        // (`obj.foo().bar()`) keeps the bare name (its receiver's type can't
+        // be recovered here).
+        if (accessorPrev?.type === 'selector' &&
+            accessorPrev.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part')) {
+          const innerCallee = dartCalleeOfArgPart(accessorPrev);
+          if (innerCallee && /^[A-Z]/.test(innerCallee)) {
+            return `${innerCallee}().${methodId.text}`;
+          }
+        }
+        return methodId.text;
+      }
+    }
+  }
+
+  // super.method() / this.method(): prev is bare unconditional_assignable_selector
+  if (prev.type === 'unconditional_assignable_selector' || prev.type === 'conditional_assignable_selector') {
+    const methodId = prev.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+    if (methodId) return methodId.text;
+  }
+
+  return undefined;
+}
+
+/** The URI a directive's `uri` node holds, quotes stripped: `x.g.dart` for `'x.g.dart'`. */
+function dartUriText(uri: SyntaxNode | undefined, source: string): string {
+  const literal = uri?.namedChildren.find((c: SyntaxNode) => c.type === 'string_literal');
+  return literal ? getNodeText(literal, source).replace(/['"]/g, '') : '';
+}
+
 export const dartExtractor: LanguageExtractor = {
   functionTypes: ['function_signature'],
   classTypes: ['class_definition'],
@@ -124,13 +448,22 @@ export const dartExtractor: LanguageExtractor = {
   // constructor `Foo._()` parses as a bare `constructor_signature`, so include
   // it too — resolveName names it by the ctor name and getReturnType gives it
   // the class as its return type, so `Foo._().bar()` chains resolve (#750).
-  methodTypes: ['method_signature', 'constructor_signature'],
+  // `const` constructors and redirecting factories have signature kinds of
+  // their own: flutter_bloc's `const BlocProvider.value(…)` is one, and
+  // without its node a `BlocProvider.value(…)` call went to another class's
+  // `value`.
+  methodTypes: ['method_signature', 'constructor_signature', ...DART_BODILESS_CTORS],
   interfaceTypes: [],
   structTypes: [],
   enumTypes: ['enum_declaration'],
   enumMemberTypes: ['enum_constant'],
   typeAliasTypes: ['type_alias'],
-  importTypes: ['import_or_export'],
+  // `part 'x.g.dart';` is a library naming one of its own files — a generated
+  // part, often. Its URI resolves as an import's does, so the library links
+  // the part's file the way it links a file it imports, and a change to the
+  // part reaches whatever depends on the library. `part of` adds nothing to
+  // that edge, and stays out.
+  importTypes: ['import_or_export', 'part_directive'],
   callTypes: [],  // Dart calls use identifier+selector, handled via extractBareCall
   variableTypes: [],
   // `extension_type_declaration` is Dart 3's extension type. It sits beside the
@@ -147,19 +480,80 @@ export const dartExtractor: LanguageExtractor = {
   // parent scope (`file:` top-level / `class:` static member) comes from the
   // node stack, both of which the value-reference target gate accepts.
   visitNode: (node, ctx) => {
+    const push = (ref: UnresolvedReference) => ctx.addUnresolvedReference(ref);
     if (node.type === 'static_final_declaration') {
       const nameNode = node.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
       if (nameNode) {
         const valueNode = nameNode.nextNamedSibling;
         const initValue = valueNode ? getNodeText(valueNode, ctx.source).slice(0, 100) : undefined;
-        ctx.createNode('constant', getNodeText(nameNode, ctx.source), node, {
+        const constant = ctx.createNode('constant', getNodeText(nameNode, ctx.source), node, {
           signature: initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined,
         });
+        // The initializer is code the constant runs: riverpod's `final
+        // repoProvider = Provider((ref) => Repository(ref.watch(dioProvider)));`
+        // calls `Provider`, `Repository` and `ref.watch`, and the types it
+        // names (`Family<Report?, String>()`, #2327) are the constant's too.
+        if (constant) {
+          ctx.pushScope(constant.id);
+          ctx.walkInitializer(node);
+          ctx.popScope();
+        }
+      }
+      return true;
+    }
+    // A field's declared type is its class's: Dart fields mint no nodes of
+    // their own (`final Report report;`, #2327). Each initializer is walked
+    // as its entry is reached, below.
+    if (node.type === 'declaration') {
+      const owner = ctx.nodeStack[ctx.nodeStack.length - 1];
+      const inBody = node.parent !== null && DART_MEMBER_BODIES.has(node.parent.type);
+      const isField = inBody && node.namedChildren.some((c: SyntaxNode) =>
+        c.type === 'initialized_identifier_list' || c.type === 'static_final_declaration_list'
+      );
+      if (owner && isField) {
+        for (const child of node.namedChildren) {
+          if (child.type !== 'initialized_identifier_list' && child.type !== 'static_final_declaration_list') {
+            pushDartTypeRefs(child, owner, push);
+          }
+        }
       }
+      return false;
+    }
+    // A field's initializer, or a top-level variable's, is code its class or
+    // the file runs — neither declaration mints a node to own it. A `static
+    // final` / `const` one is its constant's (above).
+    if (node.type === 'initialized_identifier' && isDartFieldOrTopLevelEntry(node)) {
+      ctx.walkInitializer(node);
       return true;
     }
+    // A top-level variable's declared type is the file's — the grammar lays
+    // it out directly under `program`.
+    if (DART_TOP_LEVEL_TYPES.has(node.type) && node.parent?.type === 'program') {
+      const owner = ctx.nodeStack[ctx.nodeStack.length - 1];
+      if (owner) pushDartTypeRefs(node, owner, push);
+    }
     return false;
   },
+  // A member with no body — a constructor like `Foo._();` or `const Foo.c();`,
+  // an abstract `void m();` — is a `declaration` wrapping its signature, and
+  // the member's `///` dartdoc and `@annotation`s come before the wrapper. A
+  // signature that opens the declaration takes both from there.
+  getDeclarationWrapper: (node) => {
+    const parent = node.parent;
+    if (parent?.type !== 'declaration') return undefined;
+    return parent.firstNamedChild?.equals(node) ? parent : undefined;
+  },
+  // A member's annotations stand between it and the dartdoc written above them
+  // (`/// Builds the widget.` `@override` `Widget build(…)`), so the docstring
+  // walk steps over them instead of stopping there. A class-like declaration
+  // (class, mixin, extension, extension type, enum, typedef) needs none of
+  // this: its annotations open its own node, and the dartdoc above them is
+  // that node's previous sibling.
+  docstringStepOverTypes: ['annotation'],
+  // An annotation belongs to the next declaration, whatever comments come
+  // between them: `@override` `// ignore: must_call_super` `void f()`, or a
+  // dartdoc written below the annotations. The decorator scan steps over them.
+  decoratorStepOverTypes: ['comment', 'documentation_comment'],
   resolveBody: (node, bodyField) => {
     // Dart: function_body is a next sibling of function_signature/method_signature
     if (node.type === 'function_signature' || node.type === 'method_signature') {
@@ -189,7 +583,10 @@ export const dartExtractor: LanguageExtractor = {
     // tree-sitter misparsed as a ctor (`@override (T) m()`) is NOT skipped here.
     // (isMisparsedFunction skips node creation but still visits the body.)
     const ctor = dartCtorInfo(node);
-    return ctor != null && ctor.ctorName === ctor.className;
+    // A `const` constructor or redirecting factory is nothing else, so one
+    // that names no enclosing type is error recovery's, and skipped.
+    if (!ctor) return DART_BODILESS_CTORS.has(node.type);
+    return ctor.ctorName === ctor.className;
   },
   getSignature: (node, source) => {
     // For function_signature: extract params + return type
@@ -202,7 +599,9 @@ export const dartExtractor: LanguageExtractor = {
       if (inner) sig = inner;
     }
     const params = sig.namedChildren.find((c: SyntaxNode) => c.type === 'formal_parameter_list');
-    const retType = sig.namedChildren.find((c: SyntaxNode) =>
+    // A constructor has no return type: the type a redirecting factory names
+    // is its target (`= _Impl`).
+    const retType = DART_BODILESS_CTORS.has(sig.type) ? undefined : sig.namedChildren.find((c: SyntaxNode) =>
       c.type === 'type_identifier' || c.type === 'void_type'
     );
     if (!params && !retType) return undefined;
@@ -247,6 +646,13 @@ export const dartExtractor: LanguageExtractor = {
     return false;
   },
   resolveName: (node) => {
+    // `class A = B with C;` — a mixin application — names its class inside
+    // the `mixin_application_class`, not in a `name` field.
+    if (node.type === 'class_definition') {
+      const application = node.namedChildren.find((c: SyntaxNode) => c.type === 'mixin_application_class');
+      const id = application?.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+      if (id) return id.text;
+    }
     // Name a factory / named constructor by its constructor name — the 2nd
     // identifier (`create` in `factory Foo.create()`, `_` in `Foo._()`) — not
     // the class, so a call `Foo.create()` resolves to `Foo::create` (#750). The
@@ -267,6 +673,11 @@ export const dartExtractor: LanguageExtractor = {
     const importText = source.substring(node.startIndex, node.endIndex).trim();
     let moduleName = '';
 
+    // A part: part 'x.g.dart';
+    if (node.type === 'part_directive') {
+      moduleName = dartUriText(node.namedChildren.find((c: SyntaxNode) => c.type === 'uri'), source);
+    }
+
     // Dart imports: import 'dart:async'; import 'package:foo/bar.dart' as bar;
     const libraryImport = node.namedChildren.find((c: SyntaxNode) => c.type === 'library_import');
     if (libraryImport) {
@@ -274,13 +685,7 @@ export const dartExtractor: LanguageExtractor = {
       if (importSpec) {
         const configurableUri = importSpec.namedChildren.find((c: SyntaxNode) => c.type === 'configurable_uri');
         if (configurableUri) {
-          const uri = configurableUri.namedChildren.find((c: SyntaxNode) => c.type === 'uri');
-          if (uri) {
-            const stringLiteral = uri.namedChildren.find((c: SyntaxNode) => c.type === 'string_literal');
-            if (stringLiteral) {
-              moduleName = getNodeText(stringLiteral, source).replace(/['"]/g, '');
-            }
-          }
+          moduleName = dartUriText(configurableUri.namedChildren.find((c: SyntaxNode) => c.type === 'uri'), source);
         }
       }
     }
@@ -291,13 +696,7 @@ export const dartExtractor: LanguageExtractor = {
       if (libraryExport) {
         const configurableUri = libraryExport.namedChildren.find((c: SyntaxNode) => c.type === 'configurable_uri');
         if (configurableUri) {
-          const uri = configurableUri.namedChildren.find((c: SyntaxNode) => c.type === 'uri');
-          if (uri) {
-            const stringLiteral = uri.namedChildren.find((c: SyntaxNode) => c.type === 'string_literal');
-            if (stringLiteral) {
-              moduleName = getNodeText(stringLiteral, source).replace(/['"]/g, '');
-            }
-          }
+          moduleName = dartUriText(configurableUri.namedChildren.find((c: SyntaxNode) => c.type === 'uri'), source);
         }
       }
     }
@@ -314,54 +713,16 @@ export const dartExtractor: LanguageExtractor = {
       const hasArgPart = node.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part');
       if (!hasArgPart) return undefined;
 
-      const prev = node.previousNamedSibling;
-      if (!prev) return undefined;
-
-      // Simple function/constructor call: prev is identifier (e.g., runApp(...), MyWidget(...))
-      if (prev.type === 'identifier') {
-        return prev.text;
-      }
-
-      // Method call: prev is selector with accessor (e.g., obj.method(...), Navigator.push(...))
-      if (prev.type === 'selector') {
-        const accessor = prev.namedChildren.find((c: SyntaxNode) =>
-          c.type === 'unconditional_assignable_selector' || c.type === 'conditional_assignable_selector'
-        );
-        if (accessor) {
-          const methodId = accessor.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
-          if (methodId) {
-            // Include receiver for first call in chain (receiver is a direct identifier)
-            const accessorPrev = prev.previousNamedSibling;
-            if (accessorPrev?.type === 'identifier') {
-              return accessorPrev.text + '.' + methodId.text;
-            }
-            // Chained static-factory / fluent call: the receiver is itself a call
-            // (`Foo.create().bar()`), so accessorPrev is that call's argument_part
-            // selector. Encode `<innerCallee>().<method>` so resolution can infer
-            // bar's class from what `Foo.create` RETURNS (#645/#608 mechanism) —
-            // but only when the chain starts with a capitalized type (a companion
-            // factory / static method / constructor); an instance chain
-            // (`obj.foo().bar()`) keeps the bare name (its receiver's type can't
-            // be recovered here).
-            if (accessorPrev?.type === 'selector' &&
-                accessorPrev.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part')) {
-              const innerCallee = dartCalleeOfArgPart(accessorPrev);
-              if (innerCallee && /^[A-Z]/.test(innerCallee)) {
-                return `${innerCallee}().${methodId.text}`;
-              }
-            }
-            return methodId.text;
-          }
-        }
-      }
-
-      // super.method() / this.method(): prev is bare unconditional_assignable_selector
-      if (prev.type === 'unconditional_assignable_selector' || prev.type === 'conditional_assignable_selector') {
-        const methodId = prev.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
-        if (methodId) return methodId.text;
-      }
+      // Past comments: `box.grow /* by */ (3)` calls `box.grow`.
+      const prev = dartPrevNamed(node);
+      return prev ? dartCallee(prev) : undefined;
+    }
 
-      return undefined;
+    // A generic call the grammar read as two comparisons (`ref.read<Repo>(p)`),
+    // named at its `<`, where a parsed call's argument part starts.
+    if (node.type === 'relational_operator') {
+      const call = dartMisparsedGenericCall(node);
+      return call ? dartCallee(call.callee) : undefined;
     }
 
     // new MyWidget() — explicit constructor call
@@ -380,6 +741,18 @@ export const dartExtractor: LanguageExtractor = {
       return undefined;
     }
 
+    // `=> BlocProvider<CounterCubit>.value(…)` — a constructor called with type
+    // arguments, as most expressions parse it. The type is the last
+    // `type_identifier`: an import prefix (`p.X<T>.named`) is one too.
+    if (node.type === 'constructor_invocation') {
+      const typeId = node.namedChildren.filter((c: SyntaxNode) => c.type === 'type_identifier').pop();
+      const nameId = node.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+      if (typeId && nameId) return typeId.text + '.' + nameId.text;
+      if (typeId) return typeId.text;
+      return undefined;
+    }
+
     return undefined;
   },
+  extractMemberRead: dartMemberRead,
 };
diff --git a/src/extraction/languages/go.ts b/src/extraction/languages/go.ts
index 5e41fbfaa6..dd294b6853 100644
--- a/src/extraction/languages/go.ts
+++ b/src/extraction/languages/go.ts
@@ -38,6 +38,71 @@ function extractGoReturnType(node: SyntaxNode, source: string): string | undefin
   return last;
 }
 
+/**
+ * Go's predeclared types. None is ever a node in the graph, and as the lone
+ * term of an interface (`interface{ int64 }`) a basic type is a type-set
+ * constraint, not an embedded interface.
+ */
+const GO_PREDECLARED_TYPES: ReadonlySet<string> = new Set([
+  'any', 'bool', 'byte', 'comparable', 'complex64', 'complex128', 'error', 'float32', 'float64',
+  'int', 'int8', 'int16', 'int32', 'int64', 'rune', 'string', 'uint', 'uint8', 'uint16', 'uint32',
+  'uint64', 'uintptr',
+]);
+
+/**
+ * The name node of the type a Go embedding names, in a struct or an interface:
+ * `Base`, `*Base` (the `*` is a sibling token), `pkg.Base` and `Base[T]` all
+ * embed `Base`. A qualified type yields its name, not its package: the package
+ * stays in the source text, and resolution reads it back from the reference's
+ * position (#2322). Undefined for any other type (a literal, `~T`, a union's
+ * term) and for a predeclared one.
+ */
+export function goEmbeddedTypeName(type: SyntaxNode | null | undefined, source: string): SyntaxNode | undefined {
+  if (type?.type === 'generic_type') type = getChildByField(type, 'type');
+  if (type?.type === 'qualified_type') return getChildByField(type, 'name') ?? undefined;
+  if (type?.type !== 'type_identifier') return undefined;
+  return GO_PREDECLARED_TYPES.has(getNodeText(type, source)) ? undefined : type;
+}
+
+/**
+ * The name nodes of the types a Go `type_alias` node names on its right-hand
+ * side, in source order: an alias's (`Event` in `type Event = mvccpb.Event`,
+ * `List` and `Event` in `type Page = List[Event]`) and a defined type's
+ * (`WatchResponse` in `type WatchChan <-chan WatchResponse`, `Context` in
+ * `type HandlerFunc func(*Context)`), each where it is written, so resolution
+ * reads a package qualifier back. Not types it names: the declaration's own
+ * type parameters (`T` in `type Items[T any] = List[T]`), Go's predeclared
+ * types, and its own name written bare, which in a recursive type (`type
+ * stateFn func(*Lexer) stateFn`) is the declaration itself. A generic alias
+ * has no rule in tree-sitter-go 0.23: it parses as a `type_spec` whose `=` is
+ * an error, and reads as any other declaration here.
+ */
+export function goAliasTypeNames(node: SyntaxNode, source: string): SyntaxNode[] {
+  const type = getChildByField(node, 'type');
+  if (!type) return [];
+  const nameNode = getChildByField(node, 'name');
+  const own = nameNode ? getNodeText(nameNode, source) : undefined;
+  const params = new Set<string>();
+  for (const decl of getChildByField(node, 'type_parameters')?.namedChildren ?? []) {
+    for (const c of decl.namedChildren) {
+      if (c.type === 'identifier') params.add(getNodeText(c, source));
+    }
+  }
+  const names: SyntaxNode[] = [];
+  // `qualified`: the name of a `pkg.Name`, which is that package's whatever
+  // this one declares.
+  const walk = (n: SyntaxNode, qualified: boolean): void => {
+    if (n.type === 'type_identifier') {
+      const text = getNodeText(n, source);
+      if (!GO_PREDECLARED_TYPES.has(text) && (qualified || (!params.has(text) && text !== own))) names.push(n);
+      return;
+    }
+    for (const c of n.namedChildren) walk(c, n.type === 'qualified_type');
+  };
+  walk(type, false);
+  return names;
+}
+
 export const goExtractor: LanguageExtractor = {
   functionTypes: ['function_declaration'],
   classTypes: [], // Go doesn't have classes
@@ -45,7 +110,7 @@ export const goExtractor: LanguageExtractor = {
   interfaceTypes: [],  // Handled via type_spec → resolveTypeAliasKind
   structTypes: [],     // Handled via type_spec → resolveTypeAliasKind
   enumTypes: [],
-  typeAliasTypes: ['type_spec'], // Go type declarations
+  typeAliasTypes: ['type_spec', 'type_alias'], // `type A B` and `type A = B`
   importTypes: ['import_declaration'],
   callTypes: ['call_expression'],
   variableTypes: ['var_declaration', 'short_var_declaration', 'const_declaration'],
@@ -66,7 +131,8 @@ export const goExtractor: LanguageExtractor = {
     return sig;
   },
   resolveTypeAliasKind: (node, _source) => {
-    // Go type_spec: `type Foo struct { ... }` or `type Bar interface { ... }`
+    // Go type_spec: `type Foo struct { ... }` or `type Bar interface { ... }`,
+    // and an alias of a literal (`type Foo = struct { ... }`) alike.
     // The inner type is in the 'type' field of the type_spec node
     const typeChild = getChildByField(node, 'type');
     if (!typeChild) return undefined;
@@ -102,4 +168,21 @@ export const goExtractor: LanguageExtractor = {
     const match = text.match(/\(\s*(?:[A-Za-z_]\w*\s+)?\*?\s*([A-Za-z_]\w*)/);
     return match?.[1];
   },
+  // A type declared on its own, `type Foo struct{…}`, is a `type_declaration`
+  // holding one spec, and its doc comment comes before the declaration, outside
+  // the spec. A member of a `type ( … )` group has its comment beside it in the
+  // parentheses, and the comment above the group is the group's. A group of one
+  // is that type's declaration, as go doc reads it, unless its member has a
+  // comment of its own.
+  getDeclarationWrapper: (node) => {
+    const parent = node.parent;
+    if (parent?.type !== 'type_declaration' || !parent.firstNamedChild?.equals(node)) return undefined;
+    const specs = parent.namedChildren.filter(
+      (c: SyntaxNode) => c.type === 'type_spec' || c.type === 'type_alias'
+    );
+    return specs.length === 1 ? parent : undefined;
+  },
+  // A comment after code on its line (`const sides = 4 // sides of a square.`)
+  // is that line's, never the doc of the declaration below it.
+  docstringSkipsTrailingComments: true,
 };
diff --git a/src/extraction/languages/kotlin.ts b/src/extraction/languages/kotlin.ts
index e0b40927af..c41b2cd38b 100644
--- a/src/extraction/languages/kotlin.ts
+++ b/src/extraction/languages/kotlin.ts
@@ -161,7 +161,75 @@ function isFunInterfaceNode(node: SyntaxNode): boolean {
   return hasFun && hasInterfaceType;
 }
 
+/**
+ * The qualifier of a function type's receiver — `DatabaseConfig.` in
+ * `configure: (DatabaseConfig.Builder.() -> Unit)?`. The grammar reads a
+ * single-segment receiver (`Builder.() -> Unit`) but not a qualified one, and
+ * its error recovery then drops the enclosing class: Exposed's
+ * `DatabaseTestsBase` came out as a file of loose functions. `X.(` is not an
+ * expression, so the shape only occurs in a type.
+ */
+const QUALIFIED_RECEIVER = /\b(?:[A-Za-z_]\w*(?:<[^<>()\n]*>)?\.)+(?=[A-Za-z_]\w*(?:<[^<>()\n]*>)?\.\()/g;
+
+/** Blank a function type's receiver qualifier to spaces (offsets survive), leaving its simple type name. */
+export function blankKotlinQualifiedReceivers(source: string): string {
+  if (!source.includes('.(')) return source;
+  return source.replace(QUALIFIED_RECEIVER, (m) => ' '.repeat(m.length));
+}
+
+/**
+ * A primary constructor written on the line after its class name —
+ * `expect open class ByteString` / `internal constructor(data: ByteArray) :
+ * Comparable<ByteString> {` (okio, and Kotlin Multiplatform code generally) —
+ * with a supertype list after it: the grammar reads it as two statements and
+ * drops the class, its members coming out as loose functions. Blanking the
+ * constructor's modifiers and keyword (`(data: ByteArray) : …` parses) keeps
+ * the class, its supertypes and every offset; only the visibility is lost.
+ */
+const SPLIT_PRIMARY_CONSTRUCTOR =
+  /(\bclass\s+[A-Za-z_]\w*(?:\s*<[^<>{}]*(?:<[^<>{}]*>[^<>{}]*)*>)?[ \t]*\r?\n(?:[ \t]*\/\/[^\n]*\n)*[ \t]*)((?:(?:public|private|protected|internal|actual|expect)\s+|@[\w.]+(?:\([^)]*\))?\s+)*constructor)(?=\s*\()/g;
+
+export function joinKotlinSplitConstructors(source: string): string {
+  if (!source.includes('constructor')) return source;
+  return source.replace(SPLIT_PRIMARY_CONSTRUCTOR, (_m, head: string, ctor: string) => head + ' '.repeat(ctor.length));
+}
+
+/**
+ * Kotlin syntax newer than the grammar (tree-sitter-kotlin 0.3.8), rewritten
+ * to an older equivalent of the same length so every offset survives — each
+ * one otherwise made error recovery drop the class around it (Exposed: 158 of
+ * 1,004 files):
+ *
+ * - a `when` guard (Kotlin 2.1), `is H2Dialect if dialect.mode == X ->`,
+ *   becomes a second condition, `is H2Dialect,   dialect.mode == X ->`, so
+ *   the guard's references are kept;
+ * - an open-ended range (1.9), `1..<n`, becomes `1.. n`;
+ * - a multi-dollar string (2.1), `$$"?(@.a == $x)"`, loses its prefix;
+ * - a nullable receiver in a function type, `Op<Boolean>?.() -> Op<Boolean>`,
+ *   becomes `Op<Boolean>.( ) -> …`.
+ */
+const WHEN_GUARD = /^([ \t]*!?(?:is|in)[ \t]+(?:(?!->)[^\n])*?[\w>?)\]'"])([ \t]+)if(?=[ \t(])/gm;
+const MULTI_DOLLAR_STRING = /(?<![\w$"])\$\$+(?=")/g;
+const NULLABLE_RECEIVER_FN = /([\w>])\?\.\(\)(?=\s*->)/g;
+
+export function rewriteNewerKotlinSyntax(source: string): string {
+  let out = source;
+  if (out.includes(' if')) {
+    // (the condition stops short of `->`: `is X -> if (…)` is a branch whose body is an if)
+    out = out.replace(WHEN_GUARD, (_m, cond: string, gap: string) => `${cond},${' '.repeat(gap.length + 1)}`);
+  }
+  if (out.includes('..<')) out = out.replace(/\.\.</g, '.. ');
+  if (out.includes('$$')) out = out.replace(MULTI_DOLLAR_STRING, (m) => ' '.repeat(m.length));
+  if (out.includes('?.()')) out = out.replace(NULLABLE_RECEIVER_FN, '$1.( )');
+  return out;
+}
+
+function preParseKotlin(source: string): string {
+  return rewriteNewerKotlinSyntax(joinKotlinSplitConstructors(blankKotlinQualifiedReceivers(source)));
+}
+
 export const kotlinExtractor: LanguageExtractor = {
+  preParse: preParseKotlin,
   functionTypes: ['function_declaration'],
   classTypes: ['class_declaration'],
   methodTypes: ['function_declaration'], // Methods are functions inside classes
diff --git a/src/extraction/languages/typescript.ts b/src/extraction/languages/typescript.ts
index c59b4ca7a3..15ef823981 100644
--- a/src/extraction/languages/typescript.ts
+++ b/src/extraction/languages/typescript.ts
@@ -1,5 +1,6 @@
 import { getNodeText, getChildByField } from '../tree-sitter-helpers';
 import type { LanguageExtractor } from '../tree-sitter-types';
+import { hasFlowPragma } from '../grammars';
 import type { Node as SyntaxNode } from 'web-tree-sitter';
 
 /**
@@ -38,7 +39,63 @@ export function classifyTsClassMember(node: SyntaxNode): 'method' | 'property' {
   return 'property';
 }
 
+/**
+ * Flow's own syntax, blanked to spaces (offsets survive) so a Flow file reads
+ * as TSX: exact object types `{| a: T |}`, a maybe type's `?` (`x: ?string`,
+ * `Array<?T>`), an inexact object's `...`, `import typeof`, `opaque type`. Only files with the `@flow`
+ * pragma — the ones `detectLanguage` sends here from `.js`.
+ */
+export function blankFlowSyntax(source: string, filePath?: string): string {
+  if (!filePath || !/\.(?:jsx?|mjs|cjs)$/.test(filePath) || !hasFlowPragma(source)) return source;
+  return source
+    .replace(/\{\|/g, '{ ')
+    .replace(/\|\}/g, ' }')
+    .replace(/([:<,]\s*)\?(?=[\w$({[])/g, '$1 ')
+    .replace(/\bimport\s+typeof\b/g, (m) => 'import' + ' '.repeat(m.length - 'import'.length))
+    .replace(/\bopaque(?=\s+type\b)/g, '      ')
+    // An inexact object type's bare `...` (`{a: T, ...}`) — never a value spread.
+    .replace(/\.\.\.(?=\s*[},])/g, '   ');
+}
+
+/**
+ * Whether `node` is declared in a `declare module 'x' { … }` or `declare
+ * global { … }` body, which exports it without an `export` keyword.
+ *
+ * This is TypeScript's own rule: the binder makes an ambient module body an
+ * export context unless the body holds an export declaration (`export {…}`,
+ * `export * from`, `export =`, `export default x`), and a namespace nested in
+ * one is ambient too. What such a body declares belongs to that module or to
+ * the global scope, not to this file (`interface Window`, chart.js's
+ * `PluginOptionsByType`): other files reach it through them, and so does the
+ * library whose type it extends. `declare namespace X` is not one: in a module
+ * file, X belongs to that file. Mirrored in the kernel (tsjs/mod.rs
+ * `is_ambient_export`).
+ */
+export function isAmbientExport(node: SyntaxNode): boolean {
+  for (let current = node.parent; current; current = current.parent) {
+    if (current.type === 'statement_block' && hasExportDeclaration(current)) return false;
+    if (current.type !== 'ambient_declaration') continue;
+    // `declare global` is the keyword and a bare block, with no field names.
+    for (let i = 0; i < current.childCount; i++) {
+      if (current.child(i)?.type === 'global') return true;
+    }
+    const declared = current.namedChild(0);
+    if (declared?.type === 'module' && getChildByField(declared, 'name')?.type === 'string') return true;
+  }
+  return false;
+}
+
+/** A statement in `block` that exports by name or by assignment, not by declaring. */
+function hasExportDeclaration(block: SyntaxNode): boolean {
+  for (let i = 0; i < block.namedChildCount; i++) {
+    const statement = block.namedChild(i);
+    if (statement?.type === 'export_statement' && !getChildByField(statement, 'declaration')) return true;
+  }
+  return false;
+}
+
 export const typescriptExtractor: LanguageExtractor = {
+  preParse: blankFlowSyntax,
   functionTypes: ['function_declaration', 'generator_function_declaration', 'arrow_function', 'function_expression', 'generator_function'],
   classTypes: ['class_declaration', 'abstract_class_declaration'],
   // `method_signature` is the interface/type-literal form of a method; without it
@@ -123,7 +180,7 @@ export const typescriptExtractor: LanguageExtractor = {
       if (current.type === 'export_statement') return true;
       current = current.parent;
     }
-    return false;
+    return isAmbientExport(node);
   },
   isAsync: (node) => {
     for (let i = 0; i < node.childCount; i++) {
diff --git a/src/extraction/languages/vbnet.ts b/src/extraction/languages/vbnet.ts
index b2ec4aab50..35f6349538 100644
--- a/src/extraction/languages/vbnet.ts
+++ b/src/extraction/languages/vbnet.ts
@@ -87,9 +87,12 @@ export const vbnetExtractor: LanguageExtractor = {
   // this, calls inside every Sub/Function would be skipped.
   resolveBody: (node: SyntaxNode) => node,
   getReturnType: extractVbnetReturnType,
+  // `Protected Friend` and `Private Protected` are two modifiers each, so they
+  // read as protected and private, like C#'s `protected internal` and
+  // `private protected`.
   getVisibility: (node) => {
     if (hasModifier(node, /^private$/i)) return 'private';
-    if (hasModifier(node, /^protected(\s+friend)?$/i)) return 'protected';
+    if (hasModifier(node, /^protected$/i)) return 'protected';
     if (hasModifier(node, /^friend$/i)) return 'internal';
     return 'public'; // VB members default to Public in practice
   },
@@ -116,8 +119,13 @@ export const vbnetExtractor: LanguageExtractor = {
     // findable declaration (WinForms/WPF code is built around them).
     if (node.type === 'event_declaration' || node.type === 'custom_event_declaration') {
       const nameNode = node.childForFieldName('name');
-      if (nameNode) {
-        ctx.createNode('field', getNodeText(nameNode, ctx.source), node);
+      const event = nameNode ? ctx.createNode('field', getNodeText(nameNode, ctx.source), node) : null;
+      // A Custom Event's AddHandler / RemoveHandler / RaiseEvent blocks run
+      // code, which is the event's.
+      if (event && node.type === 'custom_event_declaration') {
+        ctx.pushScope(event.id);
+        ctx.visitFunctionBody(node, event.id);
+        ctx.popScope();
       }
       return true;
     }
diff --git a/src/extraction/parse-budget.ts b/src/extraction/parse-budget.ts
new file mode 100644
index 0000000000..276e388b7a
--- /dev/null
+++ b/src/extraction/parse-budget.ts
@@ -0,0 +1,23 @@
+/**
+ * A parse that answers a request — the viewer's syntax highlighting, the
+ * branch guards a Steps or Flow card reads — runs on the server's one thread,
+ * so a parse that does not finish takes every other request down with it.
+ * Indexing parses in workers it can kill; these cannot be killed, so they are
+ * cancelled instead: tree-sitter asks its progress callback as it goes, and a
+ * `true` stops the parse. A free-format COBOL window handed to the
+ * fixed-format grammar kept cobolcraft's Flow strip — and the whole viewer
+ * after it — parsing for good.
+ */
+
+import type { Parser, Tree } from 'web-tree-sitter';
+
+/** Longest a request-time parse may run before it is given up — far past any file that parses at all. */
+export const REQUEST_PARSE_BUDGET_MS = 3000;
+
+/** `parser.parse(source)`, or null when it runs past the budget. */
+export function parseWithinBudget(parser: Parser, source: string, budgetMs = REQUEST_PARSE_BUDGET_MS): Tree | null {
+  const deadline = Date.now() + budgetMs;
+  // The runtime hands the callback's return value to the parser: `true` cancels.
+  const cancel = (() => Date.now() > deadline) as unknown as () => void;
+  return parser.parse(source, null, { progressCallback: cancel }) ?? null;
+}
diff --git a/src/extraction/parse-pool.ts b/src/extraction/parse-pool.ts
index 9b2b100e4e..b406a0916d 100644
--- a/src/extraction/parse-pool.ts
+++ b/src/extraction/parse-pool.ts
@@ -75,6 +75,16 @@ const MAX_SCALED_PARSE_TIMEOUT_MS = 20_000;
  * only a worker that stays silent the whole window is treated as hung.
  */
 const HARD_KILL_MULTIPLIER = 3;
+/**
+ * How long `destroy()` waits for a worker that is still starting up — loading
+ * its modules, then its grammars — before terminating it anyway. Terminating a
+ * worker while it is still loading its modules can take the whole process down
+ * with an access violation (0xC0000005, seen on Windows): a pool torn down
+ * right after a short index often has a late-spawned worker in exactly that
+ * state. A start finishes in well under a second normally and a few seconds
+ * under heavy load; the cap only bounds a start that is wedged.
+ */
+const GRAMMAR_LOAD_SETTLE_MS = 15_000;
 /**
  * Max workers cold-starting at once. A worker's cold start is heavy (module load
  * + grammar WASM compile); starting the whole pool simultaneously thrashes CPU.
@@ -169,6 +179,8 @@ export interface ParseWorkerPoolOptions {
   parseTimeoutMs?: number;
   /** Worker factory (tests inject a fake). Defaults to a real `worker_threads` Worker. */
   createWorker?: () => ParsePoolWorker;
+  /** How long destroy() waits on a worker still loading grammars (tests shorten it). Default 15s. */
+  loadSettleMs?: number;
   /** Optional verbose logger (the orchestrator's `[worker] …` logger). */
   log?: (msg: string) => void;
   /**
@@ -190,6 +202,10 @@ export class ParseWorkerPool {
   // Spawned but not yet 'grammars-loaded'. Growth counts these so a single first
   // parse doesn't spawn the whole pool before the eager worker reports ready.
   private pending = new Set<ParsePoolWorker>();
+  // Each worker's grammar load, settled when it reports 'grammars-loaded' or
+  // goes away — what destroy() waits on before terminating it (see
+  // GRAMMAR_LOAD_SETTLE_MS).
+  private loads = new Map<ParsePoolWorker, { settled: Promise<void>; settle: () => void }>();
   private parseCounts = new Map<ParsePoolWorker, number>();
   private nextId = 1;
   private totalCrashes = 0;
@@ -200,6 +216,7 @@ export class ParseWorkerPool {
   private readonly recycleInterval: number;
   private readonly parseTimeoutMs: number;
   private readonly createWorker: () => ParsePoolWorker;
+  private readonly loadSettleMs: number;
   private readonly log: (msg: string) => void;
   private readonly grammarBuffers?: Record<string, Uint8Array>;
 
@@ -209,6 +226,7 @@ export class ParseWorkerPool {
     this.maxSize = Math.max(1, Math.min(opts.size, MAX_PARSE_POOL_SIZE));
     this.recycleInterval = opts.recycleInterval ?? DEFAULT_RECYCLE_INTERVAL;
     this.parseTimeoutMs = opts.parseTimeoutMs ?? DEFAULT_PARSE_TIMEOUT_MS;
+    this.loadSettleMs = opts.loadSettleMs ?? GRAMMAR_LOAD_SETTLE_MS;
     this.log = opts.log ?? (() => {});
     if (opts.createWorker) {
       this.createWorker = opts.createWorker;
@@ -278,9 +296,12 @@ export class ParseWorkerPool {
     this.workers.add(w);
     this.pending.add(w);
     this.parseCounts.set(w, 0);
+    let settle!: () => void;
+    const settled = new Promise<void>((resolve) => { settle = resolve; });
+    this.loads.set(w, { settled, settle });
     w.on('message', (m) => this.onMessage(w, (m ?? {}) as ParseWorkerMessage));
-    w.on('error', (e) => this.onWorkerGone(w, `Worker error: ${e?.message ?? 'unknown'}`));
-    w.on('exit', (code) => { if (code !== 0) this.onWorkerGone(w, `Worker exited with code ${code}`); });
+    w.on('error', (e) => { this.loadSettled(w); this.onWorkerGone(w, `Worker error: ${e?.message ?? 'unknown'}`); });
+    w.on('exit', (code) => { this.loadSettled(w); if (code !== 0) this.onWorkerGone(w, `Worker exited with code ${code}`); });
     // Load grammars; the worker replies 'grammars-loaded' and only then is idle.
     // Pre-read WASM bytes (when the orchestrator provided them) make this a
     // memory load instead of a per-spawn disk read.
@@ -289,6 +310,7 @@ export class ParseWorkerPool {
 
   private onMessage(w: ParsePoolWorker, m: ParseWorkerMessage): void {
     if (m.type === 'grammars-loaded') {
+      this.loadSettled(w);
       if (!this.workers.has(w)) return; // recycled/destroyed before ready
       this.pending.delete(w);
       this.idle.push(w);
@@ -351,6 +373,32 @@ export class ParseWorkerPool {
     if (this.healthy && !this.destroyed) this.spawnOne();
   }
 
+  /** The worker's grammar load is over: it reported ready, errored or exited. */
+  private loadSettled(w: ParsePoolWorker): void {
+    const load = this.loads.get(w);
+    if (!load) return;
+    this.loads.delete(w);
+    load.settle();
+  }
+
+  /**
+   * Terminate a worker, but not while it is still loading grammars: wait for
+   * the load to finish (or the worker to go away), up to `loadSettleMs`
+   * (GRAMMAR_LOAD_SETTLE_MS — see that constant for the crash this avoids).
+   */
+  private async terminateSettled(w: ParsePoolWorker): Promise<void> {
+    const load = this.loads.get(w);
+    if (load) {
+      let cap: NodeJS.Timeout | undefined;
+      await Promise.race([
+        load.settled,
+        new Promise<void>((resolve) => { cap = setTimeout(resolve, this.loadSettleMs); cap.unref?.(); }),
+      ]);
+      clearTimeout(cap);
+    }
+    try { await w.terminate(); } catch { /* already gone */ }
+  }
+
   private removeWorker(w: ParsePoolWorker): void {
     this.workers.delete(w);
     this.pending.delete(w);
@@ -471,6 +519,6 @@ export class ParseWorkerPool {
     }
     this.inflight.clear();
     this.queue = [];
-    await Promise.all(ws.map((w) => Promise.resolve(w.terminate()).catch(() => { /* already gone */ })));
+    await Promise.all(ws.map((w) => this.terminateSettled(w)));
   }
 }
diff --git a/src/extraction/parse-worker.ts b/src/extraction/parse-worker.ts
index b5be212b39..e1ec6bc281 100644
--- a/src/extraction/parse-worker.ts
+++ b/src/extraction/parse-worker.ts
@@ -17,6 +17,7 @@ import { parentPort } from 'worker_threads';
 import { extractFromSource } from './tree-sitter';
 import { detectLanguage, loadGrammarsForLanguages, resetParser } from './grammars';
 import { tryKernelExtractRaw } from './kernel';
+import { commonJsRequireRefs } from './commonjs-requires';
 import { getAllFrameworkResolvers, getApplicableFrameworks } from '../resolution/frameworks';
 import type { Language, ExtractionResult } from '../types';
 
@@ -103,7 +104,8 @@ parentPort!.on('message', async (msg: { type: string; id?: number; filePath?: st
           result = {
             nodes: [],
             edges: [],
-            unresolvedReferences: [],
+            // Read beside the kernel's tables (extractFromSource's own post-step).
+            unresolvedReferences: commonJsRequireRefs(filePath!, content!, language),
             errors: raw.errors,
             durationMs: 0,
             kernelBuffers: raw.buffers,
diff --git a/src/extraction/sfc-script.ts b/src/extraction/sfc-script.ts
new file mode 100644
index 0000000000..b5b608fc02
--- /dev/null
+++ b/src/extraction/sfc-script.ts
@@ -0,0 +1,120 @@
+/**
+ * How a single-file component's script joins the component — shared by the
+ * Vue, Svelte and Astro extractors, which hand each `<script>` block (or
+ * Astro's frontmatter) to the TypeScript extractor and fold its result back.
+ *
+ * The fold used to keep the block's own file node and make the component
+ * contain it AND every node in the block, so the hierarchy ran file-inside-
+ * component and every member had two parents: the Symbol view listed a
+ * component's script twice, with the component and its file among its own
+ * members. And everything the block did at its top level stayed on that file
+ * node — but `<script setup>`, a Svelte instance script and Astro's
+ * frontmatter run once per component instance, so their top-level calls ARE
+ * the component's doing: a Nuxt page's `useAsyncData(…)`, a Svelte page's
+ * `onMount(…)`. With them on the file, a walk from the component found
+ * nothing, and the viewer's Steps tab drew a screen alone.
+ *
+ * Now: the SFC has one file node, the whole file, holding the component; what
+ * the block holds at its top level the component holds, and a nested symbol
+ * keeps its own parent; a per-instance block's top-level calls and references
+ * — a top-level constant's initializer's included — are the component's,
+ * while its imports, and everything a module-level block does, stay with the
+ * file.
+ */
+
+import type { Edge, ExtractionError, ExtractionResult, Language, Node, UnresolvedReference } from '../types';
+import * as path from 'path';
+
+/** The SFC's own file node — the whole file, as the tree-sitter extractor makes one. */
+export function sfcFileNode(filePath: string, source: string, language: Language): Node {
+  return {
+    id: `file:${filePath}`,
+    kind: 'file',
+    name: path.basename(filePath),
+    qualifiedName: filePath,
+    filePath,
+    language,
+    startLine: 1,
+    endLine: source.split('\n').length,
+    startColumn: 0,
+    endColumn: 0,
+    isExported: false,
+    updatedAt: Date.now(),
+  };
+}
+
+export interface ScriptFold {
+  filePath: string;
+  componentNodeId: string;
+  /** Lines before the block in the SFC file: the block's line 1 is `lineOffset + 1`. */
+  lineOffset: number;
+  language: Language;
+  /** The block runs once per component instance — Vue `<script setup>`, a Svelte instance script, Astro frontmatter. */
+  perInstance: boolean;
+}
+
+export interface ScriptSink {
+  nodes: Node[];
+  edges: Edge[];
+  unresolvedReferences: UnresolvedReference[];
+  errors: ExtractionError[];
+}
+
+/** What a per-instance block does at its top level, as opposed to what it imports. */
+const INSTANCE_REF_KINDS: ReadonlySet<string> = new Set(['calls', 'references', 'instantiates', 'function_ref']);
+
+export function foldScriptResult(result: ExtractionResult, fold: ScriptFold, sink: ScriptSink): void {
+  const blockFile = `file:${fold.filePath}`;
+  // What already has a parent inside the block — a method's class, a nested
+  // function's function. The block's file holding something is not a parent:
+  // the component is, now.
+  const parented = new Set<string>();
+  for (const edge of result.edges) {
+    if (edge.kind === 'contains' && edge.source !== blockFile) parented.add(edge.target);
+  }
+
+  // A per-instance block's top-level `const data = useFetch(…)` is component
+  // state: its initializer runs on every instance, as the component's doing.
+  const instanceValues = new Set<string>();
+  if (fold.perInstance) {
+    for (const node of result.nodes) {
+      if ((node.kind === 'constant' || node.kind === 'variable') && !parented.has(node.id)) instanceValues.add(node.id);
+    }
+  }
+  const runsAsComponent = (id: string) => id === blockFile || instanceValues.has(id);
+
+  for (const node of result.nodes) {
+    if (node.kind === 'file') continue;
+    node.startLine += fold.lineOffset;
+    node.endLine += fold.lineOffset;
+    node.language = fold.language;
+    sink.nodes.push(node);
+    if (!parented.has(node.id)) sink.edges.push({ source: fold.componentNodeId, target: node.id, kind: 'contains' });
+  }
+
+  for (const edge of result.edges) {
+    if (edge.kind === 'contains' && edge.source === blockFile) continue;
+    if (edge.line) edge.line += fold.lineOffset;
+    // What a top-level value DOES is the component's; what it HOLDS stays its
+    // own — `const api = { load() {…} }` keeps `api::load` (#2300).
+    if (fold.perInstance && runsAsComponent(edge.source) && edge.kind !== 'imports' && edge.kind !== 'contains') {
+      edge.source = fold.componentNodeId;
+    }
+    sink.edges.push(edge);
+  }
+
+  for (const ref of result.unresolvedReferences) {
+    ref.line += fold.lineOffset;
+    ref.filePath = fold.filePath;
+    ref.language = fold.language;
+    if (fold.perInstance && runsAsComponent(ref.fromNodeId) && INSTANCE_REF_KINDS.has(ref.referenceKind)) {
+      ref.fromNodeId = fold.componentNodeId;
+    }
+    sink.unresolvedReferences.push(ref);
+  }
+
+  for (const error of result.errors) {
+    if (error.line) error.line += fold.lineOffset;
+    sink.errors.push(error);
+  }
+}
diff --git a/src/extraction/store-worker.ts b/src/extraction/store-worker.ts
index 6493e0040e..65b1f20972 100644
--- a/src/extraction/store-worker.ts
+++ b/src/extraction/store-worker.ts
@@ -32,6 +32,7 @@ import { QueryBuilder } from '../db/queries';
 import { createDatabase, SqliteDatabase } from '../db/sqlite-adapter';
 import { finalizeStoreBundle, type KernelStoreBundle, type StoreBundle } from './store-writer';
 import { decodeExtractBuffers } from './kernel/decode';
+import { collectBeforeExit } from '../worker-teardown';
 
 if (!parentPort) {
   throw new Error('store-worker must be run as a worker thread');
@@ -70,6 +71,7 @@ function decodeKernelBundle(bundle: KernelStoreBundle): StoreBundle {
     bundle.filePath,
     bundle.language
   );
+  if (bundle.extraRefs?.length) decoded.unresolvedReferences.push(...bundle.extraRefs);
   return finalizeStoreBundle(decoded, bundle.filePath, bundle.language, bundle.file);
 }
 
@@ -134,6 +136,8 @@ port.on('message', (msg: InMessage) => {
         } catch {
           /* already closed */
         }
+        // No GC marking in flight when the thread ends (worker-teardown.ts).
+        collectBeforeExit();
         process.exit(0);
         break;
       }
diff --git a/src/extraction/store-writer.ts b/src/extraction/store-writer.ts
index a766bd813b..4accc3d3c4 100644
--- a/src/extraction/store-writer.ts
+++ b/src/extraction/store-writer.ts
@@ -9,6 +9,7 @@
 
 import { Worker } from 'worker_threads';
 import { ExtractionResult, Language, Node, Edge, UnresolvedReference, FileRecord } from '../types';
+import { terminateOnceStarted, workerStarted } from '../worker-teardown';
 
 /** One file's complete store payload (pre-filtered — see storeFileBundle). */
 export interface StoreBundle {
@@ -30,6 +31,8 @@ export interface KernelStoreBundle {
   language: Language;
   buffers: NonNullable<ExtractionResult['kernelBuffers']>;
   file: FileRecord;
+  /** References read beside the kernel's tables (a CommonJS `require`). */
+  extraRefs?: ExtractionResult['unresolvedReferences'];
 }
 
 /**
@@ -64,6 +67,8 @@ export function finalizeStoreBundle(
 
 export class StoreWriter {
   private worker: Worker;
+  /** Settles on the worker's first message or its end — see worker-teardown.ts. */
+  private started: Promise<void>;
   private readyPromise: Promise<void>;
   private firstError: Error | null = null;
   private drainWaiters = new Map<number, { resolve: () => void; reject: (e: Error) => void }>();
@@ -75,6 +80,7 @@ export class StoreWriter {
 
   constructor(workerScriptPath: string, dbPath: string, fastInit: boolean) {
     this.worker = new Worker(workerScriptPath);
+    this.started = workerStarted(this.worker);
     let readyResolve!: () => void;
     let readyReject!: (e: Error) => void;
     this.readyPromise = new Promise<void>((resolve, reject) => {
@@ -173,14 +179,18 @@ export class StoreWriter {
     return p;
   }
 
-  /** Close the worker's DB connection and join the thread. */
-  async close(): Promise<void> {
+  /**
+   * Close the worker's DB connection and join the thread; the worker collects
+   * garbage and exits by itself (worker-teardown.ts). One that hasn't by
+   * `timeoutMs` is terminated — but never while it is still starting up.
+   */
+  async close(timeoutMs = 5000): Promise<void> {
     if (this.exited) return;
     this.worker.postMessage({ type: 'close' });
     await new Promise<void>((resolve) => {
       const t = setTimeout(() => {
-        void this.worker.terminate().then(() => resolve());
-      }, 5000);
+        void terminateOnceStarted(this.worker, this.started).then(() => resolve());
+      }, timeoutMs);
       this.worker.once('exit', () => {
         clearTimeout(t);
         resolve();
diff --git a/src/extraction/svelte-extractor.ts b/src/extraction/svelte-extractor.ts
index ab0b939216..34c98e173a 100644
--- a/src/extraction/svelte-extractor.ts
+++ b/src/extraction/svelte-extractor.ts
@@ -2,6 +2,7 @@ import { Node, Edge, ExtractionResult, ExtractionError, UnresolvedReference, Lan
 import { generateNodeId } from './tree-sitter-helpers';
 import { TreeSitterExtractor } from './tree-sitter';
 import { isLanguageSupported } from './grammars';
+import { foldScriptResult, sfcFileNode } from './sfc-script';
 
 /** Svelte 5 rune names — compiler builtins, not real functions */
 const SVELTE_RUNES = new Set([
@@ -41,8 +42,10 @@ export class SvelteExtractor {
     const startTime = Date.now();
 
     try {
-      // Create component node for the .svelte file itself
+      // The file, holding the component the .svelte file is
+      this.nodes.push(sfcFileNode(this.filePath, this.source, 'svelte'));
       const componentNode = this.createComponentNode();
+      this.edges.push({ source: `file:${this.filePath}`, target: componentNode.id, kind: 'contains' });
 
       // Extract and process script blocks
       const scriptBlocks = this.extractScriptBlocks();
@@ -132,8 +135,8 @@ export class SvelteExtractor {
       // Detect TypeScript from lang attribute
       const isTypeScript = /lang\s*=\s*["'](ts|typescript)["']/.test(attrs);
 
-      // Detect module script
-      const isModule = /context\s*=\s*["']module["']/.test(attrs);
+      // Detect module script: Svelte 4's `context="module"`, Svelte 5's `module`
+      const isModule = /context\s*=\s*["']module["']|(?:^|\s)module(?=[\s=]|$)/.test(attrs);
 
       // Calculate the 0-indexed line where the content begins. The content
       // starts right after the opening tag's `>` — its leading `\n` is part
@@ -179,45 +182,11 @@ export class SvelteExtractor {
     const extractor = new TreeSitterExtractor(this.filePath, block.content, scriptLanguage);
     const result = extractor.extract();
 
-    // Offset line numbers from script block back to .svelte file positions
-    for (const node of result.nodes) {
-      node.startLine += block.startLine;
-      node.endLine += block.startLine;
-      node.language = 'svelte'; // Mark as svelte, not TS/JS
-
-      this.nodes.push(node);
-
-      // Add containment edge from component to this node
-      this.edges.push({
-        source: componentNodeId,
-        target: node.id,
-        kind: 'contains',
-      });
-    }
-
-    // Offset edges (they reference line numbers)
-    for (const edge of result.edges) {
-      if (edge.line) {
-        edge.line += block.startLine;
-      }
-      this.edges.push(edge);
-    }
-
-    // Offset unresolved references
-    for (const ref of result.unresolvedReferences) {
-      ref.line += block.startLine;
-      ref.filePath = this.filePath;
-      ref.language = 'svelte';
-      this.unresolvedReferences.push(ref);
-    }
-
-    // Carry over errors
-    for (const error of result.errors) {
-      if (error.line) {
-        error.line += block.startLine;
-      }
-      this.errors.push(error);
-    }
+    foldScriptResult(
+      result,
+      { filePath: this.filePath, componentNodeId, lineOffset: block.startLine, language: 'svelte', perInstance: !block.isModule },
+      { nodes: this.nodes, edges: this.edges, unresolvedReferences: this.unresolvedReferences, errors: this.errors }
+    );
   }
 
   /**
diff --git a/src/extraction/syntax-tokens.ts b/src/extraction/syntax-tokens.ts
index 56a19f0859..67c0d1b710 100644
--- a/src/extraction/syntax-tokens.ts
+++ b/src/extraction/syntax-tokens.ts
@@ -42,6 +42,7 @@ import type { Node as SyntaxNode } from 'web-tree-sitter';
 import { Language } from '../types';
 import { EXTRACTORS } from './languages';
 import { getParser, loadGrammarsForLanguages } from './grammars';
+import { parseWithinBudget } from './parse-budget';
 import type { LanguageExtractor } from './tree-sitter-types';
 
 /* ------------------------------------------------------------- the classes -- */
@@ -450,7 +451,7 @@ async function tokenizeRegion(
     await loadGrammarsForLanguages([language]);
     const parser = getParser(language);
     if (!parser) return null;
-    const tree = parser.parse(source);
+    const tree = parseWithinBudget(parser, source);
     if (!tree?.rootNode) return null;
     try {
       return classifyTree(tree.rootNode, source, language, offset);
diff --git a/src/extraction/tree-sitter-helpers.ts b/src/extraction/tree-sitter-helpers.ts
index da880cca54..1177f2881c 100644
--- a/src/extraction/tree-sitter-helpers.ts
+++ b/src/extraction/tree-sitter-helpers.ts
@@ -60,6 +60,27 @@ export function getChildByField(node: SyntaxNode, fieldName: string): SyntaxNode
   return node.childForFieldName(fieldName);
 }
 
+/**
+ * Built-in/primitive type names that shouldn't create references. Shared by the
+ * core type-annotation walker and the per-language ones (Dart's), so every type
+ * position skips the same names.
+ */
+export const BUILTIN_TYPE_NAMES: ReadonlySet<string> = new Set([
+  'string', 'number', 'boolean', 'void', 'null', 'undefined', 'never', 'any', 'unknown',
+  'object', 'symbol', 'bigint', 'true', 'false',
+  // Rust
+  'str', 'bool', 'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
+  'u8', 'u16', 'u32', 'u64', 'u128', 'usize', 'f32', 'f64', 'char',
+  // Java/C#
+  'int', 'long', 'short', 'byte', 'float', 'double', 'char',
+  // Go
+  'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
+  'float32', 'float64', 'complex64', 'complex128', 'rune', 'error',
+  // Scala (capitalized primitives + ubiquitous stdlib aliases)
+  'Int', 'Long', 'Short', 'Byte', 'Float', 'Double', 'Boolean', 'Char', 'Unit',
+  'String', 'Any', 'AnyRef', 'AnyVal', 'Nothing', 'Null',
+]);
+
 /**
  * Node types that *wrap* a declaration so a leading comment is a sibling of the
  * wrapper, not of the emitted (inner) declaration node. CodeGraph emits the
@@ -108,8 +129,23 @@ function cleanCommentMarkers(comment: string): string {
 
 /**
  * Get the docstring/comment preceding a node
+ *
+ * `stepOver` lists node types that may stand between the comments and the
+ * declaration without ending the run: Dart's annotations, in `/// Builds it.`
+ * `@override` `Widget build(…)`. They are not part of the docstring, and the
+ * comments on either side of one join as if it weren't there. Default: none.
+ *
+ * `skipTrailing` leaves out the comments the run opens with that belong to
+ * the line above: one written after code on its line (`const n = 4 // four.`),
+ * and any that begins on the line such a comment ends. Go reads them as that
+ * line's comment, never the next declaration's doc. Default: off.
  */
-export function getPrecedingDocstring(node: SyntaxNode, source: string): string | undefined {
+export function getPrecedingDocstring(
+  node: SyntaxNode,
+  source: string,
+  stepOver: readonly string[] = [],
+  skipTrailing = false
+): string | undefined {
   // Climb out of any wrapper(s) so a comment preceding the WHOLE construct
   // (export-, decorator-, or const-arrow-wrapped) is reachable as a sibling.
   // The emitted node's own `previousNamedSibling` is empty (export/const) or a
@@ -121,7 +157,7 @@ export function getPrecedingDocstring(node: SyntaxNode, source: string): string
   }
 
   let sibling = anchor.previousNamedSibling;
-  const comments: string[] = [];
+  const comments: SyntaxNode[] = [];
 
   while (sibling) {
     if (
@@ -130,15 +166,39 @@ export function getPrecedingDocstring(node: SyntaxNode, source: string): string
       sibling.type === 'block_comment' ||
       sibling.type === 'documentation_comment'
     ) {
-      comments.unshift(getNodeText(sibling, source));
+      comments.unshift(sibling);
+      sibling = sibling.previousNamedSibling;
+    } else if (stepOver.includes(sibling.type)) {
       sibling = sibling.previousNamedSibling;
     } else {
       break;
     }
   }
 
-  if (comments.length === 0) return undefined;
+  let first = 0;
+  if (skipTrailing) {
+    let endRow = -1;
+    for (const comment of comments) {
+      const trails =
+        first === 0 ? followsCodeOnItsLine(comment, source) : comment.startPosition.row === endRow;
+      if (!trails) break;
+      endRow = comment.endPosition.row;
+      first++;
+    }
+  }
+  if (first === comments.length) return undefined;
 
   // Strip each comment's syntax markers (language-aware), then join.
-  return comments.map(cleanCommentMarkers).join('\n').trim();
+  return comments
+    .slice(first)
+    .map((c) => cleanCommentMarkers(getNodeText(c, source)))
+    .join('\n')
+    .trim();
+}
+
+/** Whether code comes before `node` on the line it starts on. */
+function followsCodeOnItsLine(node: SyntaxNode, source: string): boolean {
+  let i = node.startIndex;
+  while (i > 0 && (source[i - 1] === ' ' || source[i - 1] === '\t')) i--;
+  return i > 0 && source[i - 1] !== '\n' && source[i - 1] !== '\r';
 }
diff --git a/src/extraction/tree-sitter-types.ts b/src/extraction/tree-sitter-types.ts
index 6477b02739..e665b7d3dc 100644
--- a/src/extraction/tree-sitter-types.ts
+++ b/src/extraction/tree-sitter-types.ts
@@ -54,6 +54,13 @@ export interface ExtractorContext {
   visitNode(node: SyntaxNode): void;
   /** Visit a function body to extract calls */
   visitFunctionBody(body: SyntaxNode, functionId: string): void;
+  /**
+   * Walk a declaration's initializer as code the scope on top of the stack
+   * runs, the way a function body is walked. When the hook then reports the
+   * node handled, the function-as-value scan the dispatcher runs over it skips
+   * what was walked here: the walk captured those candidates already.
+   */
+  walkInitializer(node: SyntaxNode): void;
   /** Add an unresolved reference */
   addUnresolvedReference(ref: UnresolvedReference): void;
   /** Push a node ID onto the scope stack (for containment/qualified name building) */
@@ -159,6 +166,37 @@ export interface LanguageExtractor {
    * their own variants. Returns cleaned prose, or undefined when there is none.
    */
   getBodyDocstring?: (node: SyntaxNode, source: string) => string | undefined;
+  /**
+   * The node that wraps `node` and stands in its place among the declarations
+   * around it, when the grammar adds one. The doc comment and annotations
+   * written before the declaration precede that wrapper, so both are looked up
+   * from it. Dart wraps a member with no body (`Foo._();`, an abstract
+   * `void m();`) in a `declaration` node, and Go a type declared on its own
+   * (`type Foo struct{…}`) in a `type_declaration`. Returns undefined when
+   * there is none.
+   */
+  getDeclarationWrapper?: (node: SyntaxNode) => SyntaxNode | undefined;
+  /**
+   * Node types that may stand between a declaration and the comments written
+   * above it without ending the comment run its docstring is read from. Dart
+   * writes annotations there (`/// Builds it.` `@override` `Widget build(…)`):
+   * each one is stepped over, and comments on either side of it still join.
+   */
+  docstringStepOverTypes?: string[];
+  /**
+   * Leave out of a docstring the comments that belong to the line above it:
+   * one written after code on its line, and any that begins on the line such
+   * a comment ends. In Go, `var origin = Point{} // the origin.` comments that
+   * line and never documents the declaration below it.
+   */
+  docstringSkipsTrailingComments?: boolean;
+  /**
+   * Node types that may stand between a declaration and the decorators written
+   * before it without ending the scan for them. Dart writes comments there
+   * (`@override` `// ignore: must_call_super` `void f()`), and an annotation
+   * always belongs to the declaration that follows it.
+   */
+  decoratorStepOverTypes?: string[];
   /** Extract visibility from node */
   getVisibility?: (node: SyntaxNode) => 'public' | 'private' | 'protected' | 'internal' | undefined;
   /** Check if node is exported */
@@ -311,6 +349,16 @@ export interface LanguageExtractor {
    */
   extractBareCall?: (node: SyntaxNode, source: string) => string | undefined;
 
+  /**
+   * Detect a member read that may run code — Dart's `x.area`, which calls the
+   * getter `area` when `area` is one. Returns the ref name (`x.area`) and the
+   * node to position it on, or undefined. Emitted as a `references` ref from
+   * the function the read is in; the resolver links it only to a getter, with
+   * a `calls` edge (a plain field read links nothing). `parent` is the node's
+   * parent, handed down by the body walker.
+   */
+  extractMemberRead?: (node: SyntaxNode, parent?: SyntaxNode) => { name: string; node: SyntaxNode } | undefined;
+
   /**
    * Node types representing a file-level package/namespace declaration
    * (e.g. Kotlin `package_header`, Java `package_declaration`). When set,
diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts
index 19c16471a2..c503052fe7 100644
--- a/src/extraction/tree-sitter.ts
+++ b/src/extraction/tree-sitter.ts
@@ -16,13 +16,16 @@ import {
   UnresolvedReference,
 } from '../types';
 import { getParser, detectLanguage, isLanguageSupported, isFileLevelOnlyLanguage } from './grammars';
-import { NodeIdAllocator, getNodeText, getChildByField, getPrecedingDocstring } from './tree-sitter-helpers';
+import { NodeIdAllocator, getNodeText, getChildByField, getPrecedingDocstring, BUILTIN_TYPE_NAMES } from './tree-sitter-helpers';
 import { FN_REF_SPECS, captureFnRefCandidates, type FnRefSpec, type FnRefCandidate } from './function-ref';
-import { isGeneratedFile } from './generated-detection';
+import { isGeneratedFile, isMinifiedContent } from './generated-detection';
 import type { LanguageExtractor, ExtractorContext } from './tree-sitter-types';
 import { EXTRACTORS } from './languages';
-import { stripCppTemplateArgs, isCppConstructorDeclaration } from './languages/c-cpp';
+import { stripCppTemplateArgs, isCppConstructorDeclaration, cDeclaratorIdentifier, isClassLikeDefinition } from './languages/c-cpp';
+import { NestedIntervals, scanCppBraceScopes, type CppBraceScopes } from './languages/cpp-brace-scopes';
 import { rustImplTypeName } from './languages/rust';
+import { goAliasTypeNames, goEmbeddedTypeName } from './languages/go';
+import { dartMisparsedGenericCall, dartReceiverOf, isDartTypeName, pushDartTypeRefs } from './languages/dart';
 import { LiquidExtractor } from './liquid-extractor';
 import { RazorExtractor } from './razor-extractor';
 import { SvelteExtractor } from './svelte-extractor';
@@ -32,6 +35,7 @@ import { VueExtractor } from './vue-extractor';
 import { MyBatisExtractor } from './mybatis-extractor';
 import { CfmlExtractor } from './cfml-extractor';
 import { tryKernelExtract, takeDeferredPreParse } from './kernel';
+import { commonJsRequireRefs } from './commonjs-requires';
 import {
   getAllFrameworkResolvers,
   getApplicableFrameworks,
@@ -239,33 +243,26 @@ function scalaBaseTypeName(node: SyntaxNode | null, source: string): string | nu
 }
 
 /**
- * Resolve the declared identifier inside a C declarator. A `declaration`'s
- * `declarator` field nests the name through `init_declarator` (with value),
- * `pointer_declarator`/`array_declarator`/`parenthesized_declarator`
- * wrappers (each via their own `declarator` field) down to an `identifier`.
- * A `function_declarator` means the declaration is a function prototype (or a
- * function-pointer var) — return null so it isn't extracted as a variable.
+ * The class a C# declared type names, as `new T()` would name it: `Foo`,
+ * `List<Foo>` → `List`, `Ns.Foo` / `global::Foo` → `Foo`, `Foo?` → `Foo`.
+ * Predefined, array, tuple and pointer types name no class → null. Mirrored
+ * in the kernel (csharp.rs class_type_name).
  */
-function cDeclaratorIdentifier(node: SyntaxNode | null): SyntaxNode | null {
-  let cur: SyntaxNode | null = node;
-  let guard = 0;
-  while (cur && guard++ < 12) {
-    switch (cur.type) {
-      case 'identifier':
-        return cur;
-      case 'function_declarator':
-        return null;
-      case 'init_declarator':
-      case 'pointer_declarator':
-      case 'array_declarator':
-      case 'parenthesized_declarator':
-        cur = getChildByField(cur, 'declarator');
-        break;
-      default:
-        return null;
-    }
+function csharpClassTypeName(node: SyntaxNode | null, source: string): string | null {
+  if (!node) return null;
+  switch (node.type) {
+    case 'identifier':
+      return getNodeText(node, source) || null;
+    case 'generic_name':
+      return csharpClassTypeName(node.namedChildren.find((c: SyntaxNode) => c.type === 'identifier') ?? null, source);
+    case 'qualified_name':
+    case 'alias_qualified_name':
+      return csharpClassTypeName(getChildByField(node, 'name'), source);
+    case 'nullable_type':
+      return csharpClassTypeName(getChildByField(node, 'type'), source);
+    default:
+      return null;
   }
-  return null;
 }
 
 /** First `simple_identifier` in `node`'s subtree (breadth-ish, first-found).
@@ -337,7 +334,7 @@ const PHP_TYPE_NODES: ReadonlySet<string> = new Set([
  */
 const MEMBER_ACCESS_TYPES: ReadonlySet<string> = new Set([
   'field_access',                       // java (`Foo.BAR`)
-  'member_access_expression',           // c#  (`Foo.Bar`)
+  'member_access_expression',           // c# / vb.net (`Foo.Bar`)
   'navigation_expression',              // kotlin / swift (`Foo.bar`)
   'field_expression',                   // scala (`Foo.bar`)
   'class_constant_access_expression',   // php (`Foo::CONST`, `Foo::class`)
@@ -356,11 +353,34 @@ const MEMBER_ACCESS_TYPES: ReadonlySet<string> = new Set([
  * static read is pure duplication) — while adding real graph noise (+1813 edges /
  * +2448 `references` on excalidraw, the retrieval-perf benchmark, all pointing at
  * already-covered types). Don't re-add `member_expression`/`attribute` here.
+ * VB.NET (#2305) sends every member read with its receiver instead, and its
+ * resolver decides whether the receiver is a type (see extractVbMemberRead).
+ * Rust imports too, but a variant is usually written through a path that names
+ * its module, not its enum (`mode::Mode::A` under `use crate::mode;`), so no
+ * `use` names the enum at all (#2328).
  */
 const STATIC_MEMBER_LANGS: ReadonlySet<string> = new Set([
-  'java', 'csharp', 'kotlin', 'swift', 'scala', 'dart', 'php', 'cpp',
+  'java', 'csharp', 'kotlin', 'swift', 'scala', 'dart', 'php', 'cpp', 'vbnet', 'rust',
+]);
+
+/**
+ * Parents of a Rust `scoped_identifier` that is not a member written as a
+ * value or a pattern: the prefix of a longer path, or a `use` tree.
+ */
+const RUST_NON_MEMBER_PATH_PARENTS: ReadonlySet<string> = new Set([
+  'scoped_identifier', 'scoped_type_identifier',
+  'use_declaration', 'use_list', 'scoped_use_list', 'use_as_clause', 'use_wildcard',
 ]);
 
+/**
+ * VB.NET receivers no project type can be named: the namespace roots
+ * (`System.IO.Path`, `My.Settings`, `Global.X`) and the built-in type keywords
+ * (`String.Empty`, `Integer.MaxValue`). A read through one, or a path that
+ * starts with one, is never sent.
+ */
+const VB_NON_TYPE_RECEIVERS =
+  /^(?:Global|System|Microsoft|My|Boolean|Byte|Char|Date|Decimal|Double|Integer|Long|Object|SByte|Short|Single|String|UInteger|ULong|UShort)$/i;
+
 /**
  * Tree-sitter node kinds that represent constructor invocations
  * (`new Foo()` and friends). Used by extractInstantiation to emit
@@ -409,8 +429,29 @@ const TS_JS_CHAIN_LANGUAGES = new Set(['typescript', 'tsx', 'javascript', 'jsx']
 
 /** Receiver node types (TS/JS grammars) that continue a member chain downward. */
 const TS_JS_CHAIN_RECEIVER_TYPES = new Set(['member_expression', 'subscript_expression']);
+
+/**
+ * A named object literal owns its function members (#2300): `const api = {
+ * load() {…}, save: () => {…} }`, the same object inside an IIFE or another
+ * function, or one hung on a path — `window.App = {…}`, `App.utils = {…}`.
+ * Each member is a `function` node qualified under its owner (`api::load`,
+ * `window.App::init`), and the calls written in it are its own. These are the
+ * values a member can hold, and the keys that name one — a computed `[expr]`
+ * key names nothing static, so its member's code stays with the owner.
+ * Mirrored in the kernel (tsjs/extractors.rs).
+ */
+const OBJECT_MEMBER_FUNCTION_TYPES: ReadonlySet<string> = new Set(['arrow_function', 'function_expression', 'generator_function']);
+const STATIC_OBJECT_KEY_TYPES: ReadonlySet<string> = new Set(['property_identifier', 'string', 'number']);
+/**
+ * Path roots that are the global object: `window.App = {…}` defines the global
+ * `App`. (`self` is the global only in a worker; in page code it is far more
+ * often `var self = this`, so `self.x = {…}` stays an ordinary path.)
+ */
+const HOST_GLOBAL_ROOTS: ReadonlySet<string> = new Set(['window', 'globalThis']);
 /** The field of a `this.<field>.<method>()` receiver: public or ES private (#1496, #1987). */
 const THIS_FIELD_PROPERTY_TYPES = new Set(['property_identifier', 'private_property_identifier']);
+/** A Swift receiver that is a path of types, `API.PackageController.GetRoute` — two segments or more, each capitalized. */
+const SWIFT_TYPE_PATH_RECEIVER = /^(?!Self\.)[A-Z]\w*(?:\.[A-Z]\w*)+$/;
 
 /**
  * Identifier-rooted member chains have no inferred property type (#1566),
@@ -493,7 +534,13 @@ export class TreeSitterExtractor {
    * same symbol, and the column holds free text (#1905).
    */
   private docstringFor(node: SyntaxNode): string | undefined {
-    const preceding = getPrecedingDocstring(node, this.source);
+    const anchor = this.extractor?.getDeclarationWrapper?.(node) ?? node;
+    const preceding = getPrecedingDocstring(
+      anchor,
+      this.source,
+      this.extractor?.docstringStepOverTypes,
+      this.extractor?.docstringSkipsTrailingComments
+    );
     const body = this.extractor?.getBodyDocstring?.(node, this.source);
     if (preceding && body) return `${preceding}\n\n${body}`;
     return body || preceding;
@@ -525,6 +572,20 @@ export class TreeSitterExtractor {
   // files, and a node per block would flood search with same-named symbols
   // (the #1093 crowd-out failure mode). Always empty outside C/C++.
   private namespacePrefix: string[] = [];
+  // A C++ file whose tree has errors is walked in the scopes its braces
+  // open (see visitInCppBraceScope): the scan of them, null for every other
+  // file, and the class-like nodes extracted so far by the braces of their
+  // bodies.
+  private cppBraceScopes: CppBraceScopes | null = null;
+  private cppClassScopes = new NestedIntervals<string>();
+  private cppClassScopeIds = new Set<string>();
+  // C/C++: whether a class, struct, union or enum defined in the type of a
+  // declaration outside any body is walked (see visitNode). Not in a C++ file
+  // whose tree has errors and whose braces don't balance: error recovery can
+  // close a namespace or a class at the wrong `}`, or run a class past its
+  // own, and with no brace scopes to correct it the walked class would land
+  // in the wrong scope.
+  private walkDeclaredTypes = false;
   // C++ local function-pointer bindings, per enclosing symbol:
   // `auto kernel = &flash_fwd_kernel<…>;` recorded as callerId → kernel →
   // {flash_fwd_kernel}, so a later `kernel<<<grid, block>>>(params)` (or plain
@@ -541,6 +602,12 @@ export class TreeSitterExtractor {
   private fnRefCandidates: Array<FnRefCandidate & { fromNodeId: string }> = [];
   // Memoized "is this a Vue store file" verdict (per-extractor = per-file).
   private vueStoreFile: boolean | null = null;
+  // An object literal hung on a path (`window.App = {…}`, `ns.mod = {…}`) is
+  // named by the path's last link but qualified by the whole path, which its
+  // members are then qualified under (see buildQualifiedName, #2300).
+  private objectPathOwners = new Map<string, string>();
+  // Memoized ownsObjectLiterals verdict (per-extractor = per-file).
+  private ownsObjects: boolean | null = null;
   // Source already went through the extractor's preParse at the kernel route
   // point (this instance is the wasm fallback for a kernel-deferred file) —
   // don't blank it a second time.
@@ -615,6 +682,12 @@ export class TreeSitterExtractor {
       if (!this.tree) {
         throw new Error('Parser returned null tree');
       }
+      if (this.language === 'cpp' && this.tree.rootNode.hasError) {
+        this.cppBraceScopes = scanCppBraceScopes(this.source);
+      }
+      this.walkDeclaredTypes =
+        this.language === 'c' ||
+        (this.language === 'cpp' && (!this.tree.rootNode.hasError || this.cppBraceScopes !== null));
 
       // Create file node representing the source file
       const fileNode: Node = {
@@ -655,6 +728,10 @@ export class TreeSitterExtractor {
       if (packageNodeId) this.nodeStack.pop();
       this.nodeStack.pop();
 
+      // A CommonJS `require('./x')` is a file import, like ESM's `import`. The
+      // kernel reads the same (kernel/index.ts and the parse worker's transport).
+      this.unresolvedReferences.push(...commonJsRequireRefs(this.filePath, this.source, this.language));
+
       // hasError is routine for several grammars; warn only when no symbols survived.
       const symbolCount = this.nodes.filter((n) => n.kind !== 'file').length;
       if (this.tree?.rootNode.hasError && symbolCount === 0) {
@@ -726,8 +803,10 @@ export class TreeSitterExtractor {
    * nested function definitions: their bodies are walked — and their
    * candidates attributed — by extractFunction's own body walk.
    */
-  private scanFnRefSubtree(node: SyntaxNode, depth: number): void {
+  private scanFnRefSubtree(node: SyntaxNode, depth: number, walked?: ReadonlySet<number>): void {
     if (!this.fnRefSpec || depth > 12) return;
+    // Subtrees the body walker has already been through.
+    if (walked?.has(node.id)) return;
     const nodeType = node.type;
     if (depth > 0 && (
       this.extractor?.functionTypes.includes(nodeType) ||
@@ -742,7 +821,7 @@ export class TreeSitterExtractor {
     this.maybeCaptureFnRefs(node, nodeType);
     for (let i = 0; i < node.namedChildCount; i++) {
       const child = node.namedChild(i);
-      if (child) this.scanFnRefSubtree(child, depth + 1);
+      if (child) this.scanFnRefSubtree(child, depth + 1, walked);
     }
   }
 
@@ -865,7 +944,7 @@ export class TreeSitterExtractor {
    * distinctive names become reference targets; function/method/const/var symbols become reader
    * scopes whose bodies flushValueRefs scans.
    */
-  private captureValueRefScope(kind: NodeKind, name: string, id: string, node: SyntaxNode): void {
+  private captureValueRefScope(kind: NodeKind, name: string, id: string, node: SyntaxNode, valueTarget = true): void {
     // Pascal targets `constant` only: its extractor emits function PARAMETERS
     // (`Dest: TBufferWriter`) and class fields (`declField`) as `variable` at the
     // enclosing scope, which would otherwise become noisy targets (a param name
@@ -874,7 +953,7 @@ export class TreeSitterExtractor {
     // `var` globals are the rare cost; the parameter/field noise dominates.)
     const targetKindOk =
       this.language === 'pascal' ? kind === 'constant' : kind === 'constant' || kind === 'variable';
-    if (targetKindOk && name.length >= 3 && /[A-Z_]/.test(name)) {
+    if (valueTarget && targetKindOk && name.length >= 3 && /[A-Z_]/.test(name)) {
       const parentId = this.nodeStack[this.nodeStack.length - 1];
       // file-scope OR class/module/struct/enum-scope constants are targets.
       // Class/module scope matters for languages (Ruby) that keep nearly all
@@ -1067,6 +1146,65 @@ export class TreeSitterExtractor {
    * Visit a node and extract information
    */
   private visitNode(node: SyntaxNode): void {
+    if (this.cppBraceScopes) this.visitInCppBraceScope(node, this.cppBraceScopes);
+    else this.dispatchNode(node);
+  }
+
+  /**
+   * Walk a node of a C++ file whose tree has errors in the namespaces and
+   * classes its source braces put it in. That is where the tree put it unless
+   * error recovery closed a scope at the wrong `}` or ran one past its own —
+   * the rest of a class then parses as declarations of the namespace around
+   * it (rocksdb's `struct Opts`), and the rest of each namespace one level out
+   * (protobuf's `FieldDescriptor` at the top level). See cpp-brace-scopes.ts.
+   *
+   * The namespaces apply everywhere. The enclosing classes are set only at
+   * declaration level, where the stack above the file node holds nothing but
+   * class scopes; inside a function (a local class's members) the walk's own
+   * stack stands.
+   */
+  private visitInCppBraceScope(node: SyntaxNode, scopes: CppBraceScopes): void {
+    const at = node.startIndex;
+    const namespaces = this.namespacePrefix;
+    this.namespacePrefix = scopes.namespacesAt(at);
+    const stack = this.nodeStack;
+    let base = stack.length;
+    while (base > 1 && this.cppClassScopeIds.has(stack[base - 1]!)) base--;
+    let walked: string[] | null = null;
+    if (base === 1) {
+      const classes = this.cppClassScopes.at(at);
+      if (classes.length !== stack.length - base || classes.some((id, i) => stack[base + i] !== id)) {
+        walked = stack.splice(base);
+        stack.push(...classes);
+      }
+    }
+    this.dispatchNode(node);
+    if (walked) stack.splice(base, stack.length - base, ...walked);
+    this.namespacePrefix = namespaces;
+  }
+
+  /**
+   * The textual extent of a C++ class-like body while the file is walked in
+   * brace scopes: where the node ends (the `}` that closes its body) to pass
+   * to createNode, or null to keep the tree's.
+   */
+  private cppBodyEnd(body: SyntaxNode | null | undefined): Partial<Node> | null {
+    const close = body ? this.cppBraceScopes?.closeOf(body.startIndex) : undefined;
+    if (close === undefined) return null;
+    const end = this.cppBraceScopes!.positionOf(close + 1);
+    return { endLine: end.line, endColumn: end.column };
+  }
+
+  /** Open a class-like node's body as a scope for visitInCppBraceScope. */
+  private openCppClassScope(node: Node, body: SyntaxNode | null | undefined): void {
+    if (!body) return;
+    const close = this.cppBraceScopes?.closeOf(body.startIndex);
+    if (close !== undefined && this.cppClassScopes.add(body.startIndex, close, node.id)) {
+      this.cppClassScopeIds.add(node.id);
+    }
+  }
+
+  private dispatchNode(node: SyntaxNode): void {
     if (!this.extractor) return;
 
     const nodeType = node.type;
@@ -1080,8 +1218,9 @@ export class TreeSitterExtractor {
         // The hook consumed this subtree, so the walkers below never descend
         // into it — scan it for function-as-value candidates (#756). Scala's
         // hook handles val/var definitions (`val table = Seq(targetCb)`), for
-        // example. The scan is capture-only and halts at nested functions.
-        this.scanFnRefSubtree(node, 0);
+        // example. The scan is capture-only and halts at nested functions;
+        // an initializer the hook walked has captured its own.
+        this.scanFnRefSubtree(node, 0, ctx.walked ?? undefined);
         return;
       }
     }
@@ -1138,11 +1277,41 @@ export class TreeSitterExtractor {
       }
     }
 
+    // C# block namespaces scope only their own body: serilog's Guard.cs opens
+    // `namespace JetBrains.Annotations { … }` and then declares `static class
+    // Guard` at the top level, and a file's second namespace is its own. A
+    // namespace written inside another is `Outer.Inner` — the dotted name a
+    // type's qualifiedName leads with — so it takes the outer's place on the
+    // scope while its body is walked. (A file-scoped `namespace X;` covers
+    // the whole file: extractFilePackage.) Mirrored in the kernel (csharp.rs).
+    if (this.language === 'csharp' && nodeType === 'namespace_declaration') {
+      const nsName = this.extractor.extractPackage?.(node, this.source);
+      if (nsName) {
+        const topId = this.nodeStack[this.nodeStack.length - 1];
+        const top = this.nodes.find((n) => n.id === topId);
+        const outer = top?.kind === 'namespace' ? top : null;
+        if (outer) this.nodeStack.pop();
+        const ns = this.createNode('namespace', outer ? `${outer.name}.${nsName}` : nsName, node);
+        if (ns) this.nodeStack.push(ns.id);
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const child = node.namedChild(i);
+          if (child) this.visitNode(child);
+        }
+        if (ns) this.nodeStack.pop();
+        if (outer) this.nodeStack.push(outer.id);
+        return;
+      }
+    }
+
     // Function-as-value capture (#756) — independent of the dispatch ladder
     // below (the captured container types have no other handler there), so it
     // can never shadow or be shadowed by an extraction branch.
     this.maybeCaptureFnRefs(node, nodeType);
 
+    // `window.App = {…}` / `App.utils = {…}`: the object's functions are the
+    // path's members (#2300). Its whole subtree is handled there.
+    if (nodeType === 'assignment_expression' && this.extractAssignedObjectOwner(node, true)) return;
+
     // Check for function declarations
     // For Python/Ruby, function_definition inside a class should be treated as method
     if (this.extractor.functionTypes.includes(nodeType)) {
@@ -1239,27 +1408,41 @@ export class TreeSitterExtractor {
       skipChildren = true; // extractEnum visits body children
     }
     // Check for type alias declarations (e.g. `type X = ...` in TypeScript)
-    // For Go, type_spec wraps struct/interface definitions — resolveTypeAliasKind
-    // detects these and extractTypeAlias creates the correct node kind.
+    // For Go, type_spec (and type_alias, `type A = B`) wraps struct/interface
+    // definitions — resolveTypeAliasKind detects these and extractTypeAlias
+    // creates the correct node kind.
     else if (this.extractor.typeAliasTypes.includes(nodeType)) {
       skipChildren = this.extractTypeAlias(node);
     }
     // Check for class properties (e.g. C# property_declaration)
     else if (this.extractor.propertyTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {
-      this.extractProperty(node);
-      // Property initializers aren't walked — scan for function-as-value
-      // candidates (#756): Scala `val table = Seq(targetCb)` in an object,
-      // Kotlin `val cb = ::handler` class properties.
-      this.scanFnRefSubtree(node, 0);
+      const propNode = this.extractProperty(node);
+      // The code a property runs is the property's: its calls,
+      // instantiations and reads attribute to it, as a method's do.
+      const bodies = propNode ? this.propertyBodies(node) : [];
+      if (propNode && bodies.length > 0) {
+        this.nodeStack.push(propNode.id);
+        const declaredType = getChildByField(node, 'type');
+        for (const body of bodies) {
+          this.extractTargetTypedNew(body, declaredType);
+          this.visitFunctionBody(body, propNode.id);
+        }
+        this.nodeStack.pop();
+      }
+      // Whatever the body walk didn't cover (a C# property's attributes, any
+      // other language's whole declaration) is scanned for function-as-value
+      // candidates (#756); the bodies captured their own.
+      this.scanFnRefSubtree(node, 0, new Set(bodies.map((b) => b.id)));
       skipChildren = true;
     }
     // Check for class fields (e.g. Java field_declaration, C# field_declaration)
     else if (this.extractor.fieldTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {
-      this.extractField(node);
-      // Field initializers aren't walked — scan for function-as-value
-      // candidates (#756): Java `List<IntConsumer> table = List.of(Main::cb)`,
-      // C# `List<Action<int>> table = new() { TargetCb }`.
-      this.scanFnRefSubtree(node, 0);
+      const walked = this.extractField(node);
+      // Scan the declaration for function-as-value candidates (#756): Java
+      // `List<IntConsumer> table = List.of(Main::cb)`. A C# declarator
+      // extractField walked captured its own (`List<Action<int>> table =
+      // new() { TargetCb }` is the field's), so the scan skips it.
+      this.scanFnRefSubtree(node, 0, walked);
       skipChildren = true;
     }
     // Check for variable declarations (const, let, var, etc.)
@@ -1272,6 +1455,17 @@ export class TreeSitterExtractor {
       this.extractor.variableTypes.includes(nodeType) &&
       (!this.isInsideClassLikeNode() || this.isClassScopeConstantAssignment(node))
     ) {
+      // C/C++: a class, struct, union or enum defined in the declaration's
+      // type (`struct Foo { … } foo;`, `static struct { … } SPT;`) is a
+      // definition like one written on its own, and the variables keep their
+      // nodes beside it. So is a class the tree reads as a declaration's type
+      // in a file walked in brace scopes (`class X {…}` glued to the tokens
+      // after it by error recovery). In a class or function body the children
+      // walk reaches it; here, this branch skips that walk. Mirrored in the
+      // kernel (ccpp/mod.rs visit_node).
+      const declaredType = this.walkDeclaredTypes ? getChildByField(node, 'type') : null;
+      const definedType = declaredType && isClassLikeDefinition(declaredType) ? declaredType : null;
+      if (definedType) this.visitNode(definedType);
       this.extractVariable(node);
       // extractVariable doesn't walk every initializer shape (object literals
       // are deliberately skipped; Python/Ruby don't walk at all), so scan the
@@ -1279,8 +1473,9 @@ export class TreeSitterExtractor {
       // { home: renderHome }`, `handlers = {"recv": target_cb}`. The scan halts
       // at nested function definitions (their bodies are walked — and
       // attributed — separately) and flush-time dedup absorbs any overlap with
-      // initializers extractVariable DOES walk.
-      this.scanFnRefSubtree(node, 0);
+      // initializers extractVariable DOES walk. A type walked above captured
+      // its own.
+      this.scanFnRefSubtree(node, 0, definedType ? new Set([definedType.id]) : undefined);
       skipChildren = true; // extractVariable handles children
     }
     // Swift properties inside a type. A stored instance property becomes a `field`
@@ -1421,6 +1616,9 @@ export class TreeSitterExtractor {
     else if (this.extractor.callTypes.includes(nodeType)) {
       this.extractCall(node);
     }
+    else if (this.language === 'kotlin' && nodeType === 'infix_expression') {
+      this.extractKotlinInfixCall(node);
+    }
     // `new Foo(...)` / `Foo::new(...)` / object_creation_expression —
     // produce an `instantiates` reference. Children still walked so
     // nested calls inside the constructor args (`new Foo(bar())`) get
@@ -1476,7 +1674,10 @@ export class TreeSitterExtractor {
     kind: NodeKind,
     name: string,
     node: SyntaxNode,
-    extra?: Partial<Node>
+    extra?: Partial<Node>,
+    // False for a value no other scope names by this name — a local, or an
+    // object hung on a dotted path (see captureValueRefScope).
+    valueTarget = true
   ): Node | null {
     // Skip nodes with empty/missing names — they are not meaningful symbols
     // and would cause FK violations when edges reference them (see issue #42)
@@ -1538,7 +1739,7 @@ export class TreeSitterExtractor {
       }
     }
 
-    if (this.valueRefsEnabled) this.captureValueRefScope(kind, name, id, node);
+    if (this.valueRefsEnabled) this.captureValueRefScope(kind, name, id, node, valueTarget);
 
     return newNode;
   }
@@ -1617,6 +1818,13 @@ export class TreeSitterExtractor {
     // C/C++ enclosing namespaces prefix first (empty for every other language).
     const parts: string[] = [...this.namespacePrefix];
     for (const nodeId of this.nodeStack) {
+      // An object literal hung on a path qualifies what it holds by that path
+      // (`window.App::init`), which already carries its own scope.
+      const pathOwner = this.objectPathOwners.get(nodeId);
+      if (pathOwner !== undefined) {
+        parts.splice(0, parts.length, pathOwner);
+        continue;
+      }
       const node = this.nodes.find((n) => n.id === nodeId);
       if (node && node.kind !== 'file') {
         parts.push(node.name);
@@ -1628,14 +1836,21 @@ export class TreeSitterExtractor {
 
   /**
    * Build an ExtractorContext for passing to language-specific visitNode hooks.
+   * `walked` collects the initializers the hook walks, for the dispatcher's
+   * function-as-value scan to skip.
    */
-  private makeExtractorContext(): ExtractorContext {
+  private makeExtractorContext(): ExtractorContext & { walked: Set<number> | null } {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
-    return {
+    const ctx: ExtractorContext & { walked: Set<number> | null } = {
+      walked: null,
       createNode: (kind, name, node, extra) => self.createNode(kind, name, node, extra),
       visitNode: (node) => self.visitNode(node),
       visitFunctionBody: (body, functionId) => self.visitFunctionBody(body, functionId),
+      walkInitializer: (node) => {
+        (ctx.walked ??= new Set()).add(node.id);
+        self.visitFunctionBody(node, '');
+      },
       addUnresolvedReference: (ref) => self.unresolvedReferences.push(ref),
       pushScope: (nodeId) => self.nodeStack.push(nodeId),
       popScope: () => self.nodeStack.pop(),
@@ -1644,6 +1859,7 @@ export class TreeSitterExtractor {
       get nodeStack() { return self.nodeStack; },
       get nodes() { return self.nodes; },
     };
+    return ctx;
   }
 
   /**
@@ -1663,7 +1879,9 @@ export class TreeSitterExtractor {
       parentNode.kind === 'interface' ||
       parentNode.kind === 'trait' ||
       parentNode.kind === 'enum' ||
-      parentNode.kind === 'module'
+      parentNode.kind === 'module' ||
+      // A Java / Kotlin enum constant with a body of its own (see extractEnum).
+      parentNode.kind === 'enum_member'
     );
   }
 
@@ -1793,7 +2011,8 @@ export class TreeSitterExtractor {
   /**
    * Detect a React component declared via an HOC wrapper whose result is itself a
    * component: `forwardRef(...)`, `memo(...)`, `React.forwardRef/memo(...)`, and
-   * styled-components / emotion `styled.tag\`…\`` / `styled(Base)\`…\``. These
+   * styled-components / emotion `styled.tag\`…\`` / `styled(Base)\`…\``, typed
+   * (`styled.tag<Props>\`…\``) or not. These
    * initializers are a call / tagged-template (not a bare arrow), so the const is
    * otherwise classified `constant` — and a constant is skipped by both the
    * JSX-render edge synthesizer and component resolution, so `<Button/>` usages
@@ -1805,6 +2024,7 @@ export class TreeSitterExtractor {
    * `undefined` when this initializer is not a recognized component wrapper.
    */
   private reactComponentHoc(valueNode: SyntaxNode): { inner: SyntaxNode | null } | undefined {
+    if (this.isTypedStyledTemplate(valueNode)) return { inner: null };
     if (valueNode.type !== 'call_expression') return undefined;
     const callee = getChildByField(valueNode, 'function');
     if (!callee) return undefined;
@@ -1832,6 +2052,42 @@ export class TreeSitterExtractor {
     return { inner };
   }
 
+  /**
+   * A styled tag with type arguments: `styled.div<Props>\`…\``,
+   * `styled(Base)<Props>\`…\``. tree-sitter's tagged-template call takes no type
+   * arguments, so when the type argument also reads as an expression the
+   * initializer parses as comparisons around it: `(styled.div < Props) > \`…\``.
+   * (A type argument that can't be an expression, like `<{ open: boolean }>`,
+   * error-recovers into a call on the tag instead, which the callee test in
+   * reactComponentHoc takes.) The tag is the leftmost operand, against a `<`;
+   * the template is the rightmost, against a `>` (`>>` when the type argument
+   * ends in its own `<…>`). Operators in between belong to the type argument:
+   * `<A & B>` parses as `(styled.div < A) & (B > \`…\`)`. Mirrored in the
+   * kernel (tsjs/extractors.rs is_typed_styled_template).
+   */
+  private isTypedStyledTemplate(valueNode: SyntaxNode): boolean {
+    if (valueNode.type !== 'binary_expression') return false;
+    let tagParent = valueNode;
+    let tag = getChildByField(valueNode, 'left');
+    while (tag?.type === 'binary_expression') {
+      tagParent = tag;
+      tag = getChildByField(tag, 'left');
+    }
+    let templateParent = valueNode;
+    let template = getChildByField(valueNode, 'right');
+    while (template?.type === 'binary_expression') {
+      templateParent = template;
+      template = getChildByField(template, 'right');
+    }
+    return (
+      !!tag &&
+      template?.type === 'template_string' &&
+      getChildByField(tagParent, 'operator')?.type === '<' &&
+      /^>+$/.test(getChildByField(templateParent, 'operator')?.type ?? '') &&
+      /^styled\b/.test(getNodeText(tag, this.source))
+    );
+  }
+
   /**
    * Emit a `component` node for an HOC-wrapped React component declaration (see
    * reactComponentHoc). Named by the declarator (`Button`) and located at it so
@@ -1879,8 +2135,10 @@ export class TreeSitterExtractor {
       docstring,
       visibility,
       isExported,
+      ...this.cppBodyEnd(resolvedBody),
     });
     if (!classNode) return;
+    this.openCppClassScope(classNode, resolvedBody);
 
     // Extract extends/implements
     this.extractInheritance(node, classNode.id);
@@ -2075,7 +2333,12 @@ export class TreeSitterExtractor {
     // (#1093) because the two defaults differ — a bodiless CLASS is kept
     // unless a language opts into skipping, a bodiless STRUCT is skipped
     // unless a language opts into keeping.
-    const body = getChildByField(node, this.extractor.bodyField);
+    //
+    // resolveBody first, as for classes and enums: a VB.NET Structure tags
+    // every member as its own `body` field, so the field alone yields only
+    // the first member.
+    const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+      ?? getChildByField(node, this.extractor.bodyField);
     if (!body && node.type !== 'record_declaration' && !this.extractor.allowBodilessStruct)
       return;
 
@@ -2088,8 +2351,10 @@ export class TreeSitterExtractor {
       docstring,
       visibility,
       isExported,
+      ...this.cppBodyEnd(body),
     });
     if (!aggregateNode) return;
+    this.openCppClassScope(aggregateNode, body);
 
     // Extract inheritance (e.g. Swift: struct HTTPMethod: RawRepresentable)
     this.extractInheritance(node, aggregateNode.id);
@@ -2147,7 +2412,18 @@ export class TreeSitterExtractor {
       if (!child) continue;
 
       if (memberTypes?.includes(child.type)) {
-        this.extractEnumMembers(child);
+        const member = this.extractEnumMembers(child);
+        // Java's `PLUS { int apply(…) { … } }`, Kotlin's `NewBuffer { override
+        // fun pipe() … }`: the constant's own body declares members of its own.
+        const entryBody = member ? child.namedChildren.find((c) => c.type === 'class_body') : undefined;
+        if (member && entryBody) {
+          this.nodeStack.push(member.id);
+          for (let j = 0; j < entryBody.namedChildCount; j++) {
+            const inner = entryBody.namedChild(j);
+            if (inner) this.visitNode(inner);
+          }
+          this.nodeStack.pop();
+        }
       } else {
         this.visitNode(child);
       }
@@ -2159,28 +2435,30 @@ export class TreeSitterExtractor {
    * Extract enum member names from an enum member node.
    * Handles multi-case declarations (Swift: `case put, delete`) and single-case patterns.
    */
-  private extractEnumMembers(node: SyntaxNode): void {
+  private extractEnumMembers(node: SyntaxNode): Node | null {
     // Try field-based name first (e.g. Rust enum_variant has a 'name' field)
     const nameNode = getChildByField(node, 'name');
     if (nameNode) {
-      this.createNode('enum_member', getNodeText(nameNode, this.source), node);
-      return;
+      return this.createNode('enum_member', getNodeText(nameNode, this.source), node);
     }
 
     // Check for identifier-like children (Swift: simple_identifier, TS: property_identifier)
+    let first: Node | null = null;
     let found = false;
     for (let i = 0; i < node.namedChildCount; i++) {
       const child = node.namedChild(i);
       if (child && (child.type === 'simple_identifier' || child.type === 'identifier' || child.type === 'property_identifier')) {
-        this.createNode('enum_member', getNodeText(child, this.source), child);
+        const created = this.createNode('enum_member', getNodeText(child, this.source), child);
+        first ??= created;
         found = true;
       }
     }
 
     // If the node itself IS the identifier (e.g. TS property_identifier directly in enum body)
     if (!found && node.namedChildCount === 0) {
-      this.createNode('enum_member', getNodeText(node, this.source), node);
+      return this.createNode('enum_member', getNodeText(node, this.source), node);
     }
+    return first;
   }
 
   /**
@@ -2253,12 +2531,59 @@ export class TreeSitterExtractor {
     return propNode;
   }
 
+  /**
+   * The parts of a property declaration that run code, for the body walker.
+   * VB.NET writes its `Get` / `Set` blocks, `= initializer` and `As New T`
+   * as children of the declaration itself, so the declaration is walked
+   * whole, the way its methods are (resolveBody). C# runs code in each
+   * accessor's body (`get { … }`, `set => …`) and in the property's `value`:
+   * an expression body's `=> …` or an `= initializer`. Its attributes are
+   * not walked. Mirrored in the kernel (csharp.rs property_bodies).
+   */
+  private propertyBodies(node: SyntaxNode): SyntaxNode[] {
+    if (this.language === 'vbnet') return [node];
+    if (this.language !== 'csharp') return [];
+    const bodies: SyntaxNode[] = [];
+    for (const accessor of getChildByField(node, 'accessors')?.namedChildren ?? []) {
+      const body = accessor.type === 'accessor_declaration' ? getChildByField(accessor, 'body') : null;
+      if (body) bodies.push(body);
+    }
+    const value = getChildByField(node, 'value');
+    if (value) bodies.push(value);
+    return bodies;
+  }
+
+  /**
+   * A C# target-typed `new()` names no type, which is why INSTANTIATION_KINDS
+   * leaves `implicit_object_creation_expression` out. As a field's or
+   * property's initializer, though, it constructs the declared type:
+   * `private readonly List<Foo> _items = new();` instantiates List, as
+   * `new List<Foo>()` does. Emitted from the node-stack top (the member).
+   * Mirrored in the kernel (csharp.rs extract_target_typed_new).
+   */
+  private extractTargetTypedNew(value: SyntaxNode | null, declaredType: SyntaxNode | null): void {
+    if (this.language !== 'csharp' || value?.type !== 'implicit_object_creation_expression') return;
+    const className = declaredType ? csharpClassTypeName(declaredType, this.source) : null;
+    const fromNodeId = this.nodeStack[this.nodeStack.length - 1];
+    if (!className || !fromNodeId) return;
+    this.unresolvedReferences.push({
+      fromNodeId,
+      referenceName: className,
+      referenceKind: 'instantiates',
+      line: value.startPosition.row + 1,
+      column: value.startPosition.column,
+    });
+  }
+
   /**
    * Extract a class field declaration (e.g. Java field_declaration, C# field_declaration).
    * Extracts each declarator as a 'field' kind node inside the owning class.
+   * Returns the C# declarators it walked, for the function-as-value scan to
+   * skip.
    */
-  private extractField(node: SyntaxNode): void {
-    if (!this.extractor) return;
+  private extractField(node: SyntaxNode): Set<number> {
+    const walked = new Set<number>();
+    if (!this.extractor) return walked;
 
     const docstring = this.docstringFor(node);
     const visibility = this.extractor.getVisibility?.(node);
@@ -2313,7 +2638,7 @@ export class TreeSitterExtractor {
             isStatic,
           });
         }
-        return;
+        return walked;
       }
     }
 
@@ -2357,12 +2682,26 @@ export class TreeSitterExtractor {
           // candidates, so a lambda / method reference / anonymous class in
           // `private final Runnable r = () -> target();` contributed NO call
           // edge at all and `target` looked callerless. Keyed on the `value`
-          // FIELD, which only Java's `variable_declarator` carries — C#,
-          // VB.NET and PHP spell their initializer differently and are
-          // deliberately untouched here.
-          const valueNode = getChildByField(decl, 'value');
+          // FIELD, which only Java's `variable_declarator` carries. VB.NET
+          // writes `= expr` (the declarator's `initializer`) or `As New T(…)`
+          // (inside its as_clause), and C# writes `= expr` as the
+          // declarator's last, unnamed child, so both walk the whole
+          // declarator. PHP spells its initializer differently and is
+          // untouched.
+          const wholeDeclarator = this.language === 'vbnet' || this.language === 'csharp';
+          const valueNode = wholeDeclarator ? decl : getChildByField(decl, 'value');
           if (valueNode) {
             this.nodeStack.push(fieldNode.id);
+            if (this.language === 'csharp') {
+              this.extractTargetTypedNew(
+                decl.namedChild(decl.namedChildCount - 1),
+                varDecl ? getChildByField(varDecl, 'type') : null,
+              );
+              // Its function-as-value candidates are the field's, captured
+              // here once. (VB.NET captures none; Java's scan still takes
+              // its initializers for the class as well.)
+              walked.add(decl.id);
+            }
             this.visitFunctionBody(valueNode, fieldNode.id);
             this.nodeStack.pop();
           }
@@ -2381,6 +2720,165 @@ export class TreeSitterExtractor {
         });
       }
     }
+    return walked;
+  }
+
+  /**
+   * Whether a named object literal in this file owns its function members
+   * (#2300). TS/JS only; a generated or minified bundle — named so
+   * (`*.min.js`) or not (a vendored `bundle.js`, by its content) — keeps the
+   * old shape, so its single-letter objects don't become hundreds of nodes.
+   * Mirrored in the kernel (tsjs/extractors.rs owns_object_literals).
+   */
+  private ownsObjectLiterals(): boolean {
+    this.ownsObjects ??= TS_JS_CHAIN_LANGUAGES.has(this.language) && !isGeneratedFile(this.filePath) &&
+      !isMinifiedContent(this.filePath, this.source);
+    return this.ownsObjects;
+  }
+
+  /**
+   * The function an owned literal's member becomes, named by its static key:
+   * `load() {…}`, `load: () => {…}`, `load: function () {…}`, `load: function* () {…}`.
+   * Null for every other member — a computed key, a value, a shorthand, a spread.
+   */
+  private ownedMemberFunction(member: SyntaxNode): { fn: SyntaxNode; name: string } | null {
+    if (member.type === 'method_definition') {
+      const key = getChildByField(member, 'name');
+      return key && STATIC_OBJECT_KEY_TYPES.has(key.type) ? { fn: member, name: this.objectKeyName(key) } : null;
+    }
+    if (member.type !== 'pair') return null;
+    const key = getChildByField(member, 'key');
+    const value = getChildByField(member, 'value');
+    if (!key || !value || !STATIC_OBJECT_KEY_TYPES.has(key.type) || !OBJECT_MEMBER_FUNCTION_TYPES.has(value.type)) return null;
+    return { fn: value, name: this.objectKeyName(key) };
+  }
+
+  /** `value` when it is an object literal that owns at least one function member, else null. */
+  private ownedObjectValue(value: SyntaxNode | null): SyntaxNode | null {
+    if (!value || (value.type !== 'object' && value.type !== 'object_expression') || !this.ownsObjectLiterals()) return null;
+    for (let i = 0; i < value.namedChildCount; i++) {
+      const member = value.namedChild(i);
+      if (member && this.ownedMemberFunction(member)) return value;
+    }
+    return null;
+  }
+
+  /**
+   * Extract an owned literal's members: each function member becomes a node
+   * of its own, qualified under the owner (at file scope for one on the global
+   * object, `global`). Every other member — a value, a computed key, a spread —
+   * runs where the literal is written, so it is walked there: under the owner
+   * for a module-scope declaration (`valuesUnderOwner`, its initializer's calls
+   * are the constant's, #693), under the enclosing function for a local or an
+   * assignment, as they were before members had nodes. The literal's shorthand
+   * members (`{ load }`) go to the function-as-value capture the same way.
+   */
+  private extractOwnedObjectMembers(obj: SyntaxNode, ownerId: string, valuesUnderOwner: boolean, global: boolean): void {
+    const enclosing = this.nodeStack;
+    const ownerStack = [...(global ? enclosing.slice(0, 1) : enclosing), ownerId];
+    const valueStack = valuesUnderOwner ? ownerStack : enclosing;
+    this.nodeStack = valueStack;
+    this.maybeCaptureFnRefs(obj, obj.type);
+    for (let i = 0; i < obj.namedChildCount; i++) {
+      const member = obj.namedChild(i);
+      if (!member) continue;
+      const owned = this.ownedMemberFunction(member);
+      this.nodeStack = owned ? ownerStack : valueStack;
+      if (owned) this.extractFunction(owned.fn, owned.name);
+      else this.visitFunctionBody(member, '');
+    }
+    this.nodeStack = enclosing;
+  }
+
+  /**
+   * `const api = { load() {…} }` written in a function body or an IIFE: the
+   * owner gets the node a module-scope declaration would, and its members are
+   * extracted under it (#2300). Returns false when the declarator holds no
+   * owned literal, leaving it to the walker.
+   */
+  private extractLocalObjectOwner(declarator: SyntaxNode): boolean {
+    const nameNode = getChildByField(declarator, 'name');
+    if (nameNode?.type !== 'identifier') return false;
+    const obj = this.ownedObjectValue(getChildByField(declarator, 'value'));
+    if (!obj) return false;
+    const declaration = declarator.parent;
+    const isConst = declaration ? (this.extractor?.isConst?.(declaration) ?? false) : false;
+    const initValue = getNodeText(obj, this.source).slice(0, 100);
+    // A local: never the target of another scope's value read.
+    const owner = this.createNode(isConst ? 'constant' : 'variable', getNodeText(nameNode, this.source), declarator, {
+      docstring: this.docstringFor(declarator),
+      signature: `= ${initValue}${initValue.length >= 100 ? '...' : ''}`,
+      isExported: false,
+    }, false);
+    if (!owner) return false;
+    this.extractVariableTypeAnnotation(declarator, owner.id);
+    this.extractOwnedObjectMembers(obj, owner.id, false, false);
+    return true;
+  }
+
+  /**
+   * `window.App = {…}` / `App.utils = {…}` / `dw_page = {…}`: an object
+   * literal assigned to a name owns its function members like a declared one
+   * (#2300). Assigned to a plain identifier — an implicit global, or a binding
+   * declared elsewhere — it is qualified like a declaration. Hung on a path,
+   * the owner is named by the path's last link and qualified by the path as
+   * written — `window.App`, `App.utils` — so its members read
+   * `window.App::init`: a property is reached through its object, not through
+   * the function that happened to assign it (Lua's `M.helpers::a` reads the
+   * same way). A path on the global object is global wherever it is written,
+   * so it is also contained by the file. CommonJS export objects and
+   * prototypes are not namespaces and are left alone. Returns false (nothing
+   * extracted) for any other assignment.
+   */
+  private extractAssignedObjectOwner(node: SyntaxNode, moduleLevel: boolean): boolean {
+    const obj = this.ownedObjectValue(getChildByField(node, 'right'));
+    if (!obj) return false;
+    const path = this.objectOwnerPath(getChildByField(node, 'left'));
+    // A plain name assigned at module level is a global (`dw_page = {…}`); in
+    // a function it is a local being reassigned (`e = {…}` in a bundle's IIFE).
+    if (!path || (path.length === 1 && !moduleLevel)) return false;
+    const qualifiedName = path.length > 1 ? path.join('.') : undefined;
+    const global = path.length > 1 && HOST_GLOBAL_ROOTS.has(path[0]!);
+    const saved = this.nodeStack;
+    if (global) this.nodeStack = saved.slice(0, 1);
+    const initValue = getNodeText(obj, this.source).slice(0, 100);
+    const statement = node.parent?.type === 'expression_statement' ? node.parent : node;
+    // `App.utils` is read as `App.utils`, never as a bare `utils`: only a name
+    // the code reads by that name is a value-read target.
+    const owner = this.createNode('variable', path[path.length - 1]!, node, {
+      docstring: this.docstringFor(statement),
+      signature: `= ${initValue}${initValue.length >= 100 ? '...' : ''}`,
+      isExported: false,
+      ...(qualifiedName !== undefined ? { qualifiedName } : {}),
+    }, path.length === 1 || global);
+    this.nodeStack = saved;
+    if (!owner) return false;
+    if (qualifiedName !== undefined) this.objectPathOwners.set(owner.id, qualifiedName);
+    this.extractOwnedObjectMembers(obj, owner.id, false, global);
+    return true;
+  }
+
+  /**
+   * The links of an assignment target written as plain names — `dw_page` →
+   * `['dw_page']`, `window.App` → `['window', 'App']`, `App.utils.dom` →
+   * `['App', 'utils', 'dom']` — or null for anything else: `this.x`, a
+   * computed `a[k]`, a call, CommonJS's `module.exports` / `exports.x`, or a
+   * prototype.
+   */
+  private objectOwnerPath(left: SyntaxNode | null): string[] | null {
+    const path: string[] = [];
+    let cur = left;
+    while (cur?.type === 'member_expression') {
+      const property = getChildByField(cur, 'property');
+      if (property?.type !== 'property_identifier') return null;
+      path.unshift(getNodeText(property, this.source));
+      cur = getChildByField(cur, 'object');
+    }
+    if (cur?.type !== 'identifier') return null;
+    const root = getNodeText(cur, this.source);
+    if (root === 'module' || root === 'exports' || path.includes('prototype')) return null;
+    path.unshift(root);
+    return path;
   }
 
   /**
@@ -2427,8 +2925,16 @@ export class TreeSitterExtractor {
    */
   private isExportedLater(name: string): boolean {
     if (!/^[A-Za-z_$][\w$]*$/.test(name)) return false;
+    // Unescaped, a `$` in the name (`items$`, `$store`) is a line-end anchor,
+    // not the character. Escaped as the kernel's `regex::escape` does, so
+    // both paths decide the same.
+    const n = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Inside `{ … }` the name is bounded by a character that can't continue
+    // an identifier, not by `\b`, which takes a `$` for a separator: it can't
+    // bound `items$` and finds `items` inside it. Spelled in ASCII, as the
+    // kernel spells it, since the kernel's `\w` is Unicode.
     const re = new RegExp(
-      `^[ \\t]*export\\s+(?:default\\s+${name}\\s*;?[ \\t]*$|\\{[^}]*\\b${name}\\b[^}]*\\})`,
+      `^[ \\t]*export\\s+(?:default\\s+${n}\\s*;?[ \\t]*$|\\{(?:[^}]*[^0-9A-Za-z_$}])?${n}(?:[^0-9A-Za-z_$}][^}]*)?\\})`,
       'm'
     );
     return re.test(this.source);
@@ -2823,6 +3329,14 @@ export class TreeSitterExtractor {
               if (nameNode.type === 'object_pattern' && valueNode?.type === 'identifier') {
                 this.extractRtkHookBindings(nameNode, isExported);
               }
+              // A pattern declares no symbol of its own, but its initializer
+              // (and any default value in the pattern) still runs. Walk the
+              // declarator the way a function body walks it, with the
+              // enclosing scope on the stack: the file for module code, which
+              // a `<script setup>` block hands to its component. Without this
+              // `const { data } = useFetch()` recorded no call at all (#2340).
+              // Mirrored in the kernel (tsjs/extractors.rs extract_variable).
+              this.visitFunctionBody(child, '');
               continue;
             }
             const name = getNodeText(nameNode, this.source);
@@ -2867,6 +3381,17 @@ export class TreeSitterExtractor {
               this.extractVariableTypeAnnotation(child, varNode.id);
             }
 
+            // A named object literal owns its function members, exported or
+            // not (#2300): `const api = { load() {…} }` gives `api::load`, and
+            // the calls written in a member are the member's. The rest of the
+            // literal is walked under the owner. (The same literal inside a
+            // function or an IIFE goes through visitFunctionBody.)
+            const ownedObject = varNode ? this.ownedObjectValue(valueNode) : null;
+            if (varNode && ownedObject) {
+              this.extractOwnedObjectMembers(ownedObject, varNode.id, true, false);
+              continue;
+            }
+
             // Exported const object-of-functions — extract each function-valued
             // property as a function named by its key + walk its body so its
             // calls are captured. Two shapes, both keyed on AST shape (not on any
@@ -3367,6 +3892,18 @@ export class TreeSitterExtractor {
           // entry's string-literal name as a searchable member (issue #634).
           this.extractTsTupleContractNames(value, typeAliasNode);
         }
+      } else if (this.language === 'go') {
+        // Go's `type Event = mvccpb.Event` names its type in the `type` field,
+        // and so does a defined type, `type WatchChan <-chan WatchResponse`.
+        for (const type of goAliasTypeNames(node, this.source)) {
+          this.unresolvedReferences.push({
+            fromNodeId: typeAliasNode.id,
+            referenceName: getNodeText(type, this.source),
+            referenceKind: 'references',
+            line: type.startPosition.row + 1,
+            column: type.startPosition.column,
+          });
+        }
       }
     }
     return false;
@@ -3377,7 +3914,7 @@ export class TreeSitterExtractor {
    * contained by the interface (e.g. `Marshal`, `Unmarshal` of a `Core`
    * interface). tree-sitter-go names these `method_elem` (newer) or
    * `method_spec` (older). Embedded interfaces (`Reader` inside `ReadWriter`)
-   * are `type_identifier`s, not methods, and are left to inheritance extraction.
+   * are `type_elem`s, not methods, and are left to inheritance extraction.
    */
   private extractGoInterfaceMethods(interfaceType: SyntaxNode, ifaceId: string): void {
     this.nodeStack.push(ifaceId);
@@ -4062,6 +4599,31 @@ export class TreeSitterExtractor {
     return this.erlangAtomMacros.get(macroName) ?? null;
   }
 
+  /**
+   * A Kotlin infix call — `Users.id eq id1`, `a to b`, `x shouldBe y` — is a
+   * call of the infix function in the middle: `receiver.fn` when the left
+   * operand is a plain name (as `receiver.fn(arg)` would be), else the bare
+   * name. Nothing records it otherwise, so a project's infix DSL had no
+   * callers. Mirrored in the kernel's extract_infix_call (kotlin.rs).
+   */
+  private extractKotlinInfixCall(node: SyntaxNode): void {
+    if (this.nodeStack.length === 0 || node.namedChildCount !== 3) return;
+    const lhs = node.namedChild(0);
+    const fn = node.namedChild(1);
+    if (!lhs || !fn || fn.type !== 'simple_identifier' || LITERAL_RECEIVER_TYPES.has(lhs.type)) return;
+    const callerId = this.nodeStack[this.nodeStack.length - 1];
+    if (!callerId) return;
+    const name = getNodeText(fn, this.source);
+    const receiver = lhs.type === 'simple_identifier' ? getNodeText(lhs, this.source) : '';
+    this.unresolvedReferences.push({
+      fromNodeId: callerId,
+      referenceName: receiver && receiver !== 'this' && receiver !== 'super' ? `${receiver}.${name}` : name,
+      referenceKind: 'calls',
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column,
+    });
+  }
+
   private extractCall(node: SyntaxNode): void {
     if (this.nodeStack.length === 0) return;
 
@@ -4098,6 +4660,15 @@ export class TreeSitterExtractor {
         }
       } else if (fn.type === 'identifier') {
         calleeName = getNodeText(fn, this.source);
+      } else if (fn.type === 'with_member_access_expression') {
+        // `.Run()` in a `With x` block is `x.Run()`; through a longer path
+        // (`Me._h`, `{T}` for `With DirectCast(o, T)`) the resolver types each link.
+        const member = fn.namedChild(0);
+        const target = this.vbWithTarget(fn);
+        const receiver = target ? this.vbReceiverPath(target) : null;
+        if (member?.type !== 'identifier' || !receiver || VB_NON_TYPE_RECEIVERS.test(receiver.split('.')[0]!)) return;
+        const memberName = getNodeText(member, this.source);
+        calleeName = /^(?:me|mybase|myclass)$/i.test(receiver) ? memberName : `${receiver}.${memberName}`;
       } else {
         return; // parenthesized/chained receivers: no static name to link
       }
@@ -4902,6 +5473,21 @@ export class TreeSitterExtractor {
                 else reencode = !!innerCallee;
               }
               calleeName = reencode ? `${innerCallee}().${methodName}` : methodName;
+            } else if (
+              this.language === 'swift' &&
+              receiver &&
+              receiver.type === 'navigation_expression' &&
+              SWIFT_TYPE_PATH_RECEIVER.test(getNodeText(receiver, this.source).replace(/\s+/g, ''))
+            ) {
+              // Swift call through a type path — `API.PackageController.GetRoute.query(on:)`,
+              // on one line or split before the `.query`. Keep the path: the
+              // bare method name this used to emit exact-matched whichever
+              // type's `query` came first (every route in a Vapor app has one).
+              // The resolver finds the member on the type the path names, or
+              // leaves the call unresolved. An instance chain (`self.store.load()`,
+              // `viewModel.state.reset()`) is not a type path and stays bare.
+              // Mirrored in the kernel's extract_call (swift.rs).
+              calleeName = `${getNodeText(receiver, this.source).replace(/\s+/g, '')}.${methodName}`;
             } else if (
               this.language === 'cfscript' &&
               receiver &&
@@ -5313,7 +5899,7 @@ export class TreeSitterExtractor {
    * where types are Capitalized by convention, and skipped when the access is a
    * call's callee (the call extractor already links the method).
    */
-  private extractStaticMemberRef(node: SyntaxNode): void {
+  private extractStaticMemberRef(node: SyntaxNode, knownParent?: SyntaxNode): void {
     if (!STATIC_MEMBER_LANGS.has(this.language)) return;
     if (this.nodeStack.length === 0) return;
     const ownerId = this.nodeStack[this.nodeStack.length - 1];
@@ -5325,13 +5911,51 @@ export class TreeSitterExtractor {
     if (this.language === 'dart') {
       if (node.type !== 'selector') return;
       if (node.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part')) return;
-      const prev = node.previousNamedSibling;
+      const prev = dartReceiverOf(node);
       if (prev?.type === 'identifier' && /^[A-Z][A-Za-z0-9_]*$/.test(prev.text)) {
+        // `Map` in `x.read<Map<K, V>>(y)` parsed as comparisons is a type
+        // argument, which the body walker references as a type.
+        const before = knownParent?.type === 'relational_expression' ? prev.previousNamedSibling : null;
+        if (before?.type === 'relational_operator' && dartMisparsedGenericCall(before)) return;
         this.pushStaticMemberRef(prev.text, ownerId, prev);
       }
       return;
     }
 
+    // Rust writes an enum variant as a path: read (`Mode::A`, `mode::Mode::B`,
+    // `xs.map(Mode::C)`), matched (`Mode::C(x) =>`, `Mode::D { .. } =>`), or
+    // `Self::A` in an impl (#2328). The receiver — the segment before the
+    // member — is referenced where it is written, so a `mode::` / `other::`
+    // prefix scopes it as it scopes a type annotation, and the resolver keeps it
+    // only on an enum that declares the member (an associated const read the
+    // same way, `Limits::MAX`, links nothing). A lowercase receiver is a module
+    // and a lowercase member a function (`util::take`, `Foo::new`); a call's
+    // callee (`Mode::C(1)`) and a struct literal's name are already linked to
+    // their member; the prefix of a longer path and a `use` tree name no member.
+    // Mirrored by the native kernel's `extract_static_member_ref` — change both.
+    if (this.language === 'rust') {
+      if (node.type !== 'scoped_identifier' && node.type !== 'scoped_type_identifier') return;
+      // Looked up only at a body's root (a `const X: M = M::A;` value).
+      const parent = knownParent ?? node.parent;
+      if (!parent) return;
+      if (node.type === 'scoped_type_identifier' ? parent.type !== 'struct_pattern'
+        : RUST_NON_MEMBER_PATH_PARENTS.has(parent.type)) return;
+      if (parent.type === 'call_expression' && getChildByField(parent, 'function')?.startIndex === node.startIndex) return;
+      const member = getChildByField(node, 'name');
+      let recv = getChildByField(node, 'path');
+      if (recv?.type === 'scoped_identifier') recv = getChildByField(recv, 'name');
+      if (!member || recv?.type !== 'identifier' || !/^[A-Z]/.test(getNodeText(member, this.source))) return;
+      let text = getNodeText(recv, this.source);
+      if (text === 'Self') text = this.extractor!.getReceiverType?.(node, this.source) ?? '';
+      if (/^[A-Z][A-Za-z0-9_]*$/.test(text)) this.pushStaticMemberRef(text, ownerId, recv);
+      return;
+    }
+
+    if (this.language === 'vbnet') {
+      this.extractVbMemberRead(node, knownParent, ownerId);
+      return;
+    }
+
     if (!MEMBER_ACCESS_TYPES.has(node.type)) return;
 
     // Skip `Type.method()` — the access is the callee of a call, already linked.
@@ -5373,6 +5997,131 @@ export class TreeSitterExtractor {
     });
   }
 
+  /**
+   * VB.NET: a value read or write through a receiver — `AppSession.SessionId`,
+   * `AppSession.CurrentUser = "demo"`, `x.Normal = 3`, `Me._h.Title`, `.Value`
+   * in a `With` block, `.Switch` in `New BoolParam With {.Switch = "--x"}` —
+   * is a use of the member, and through a type name of the type (#2305). One
+   * `references` ref carries the member with its receiver as a path:
+   * `x.Normal`, `Me._h.Title`, or `{T}.Switch` for a value whose type the code
+   * writes (a cast's, a `New`'s). The resolver decides what the receiver is —
+   * a project type, or a value of the type it is declared as — which only it
+   * can tell in case-insensitive VB.NET (see vbnet-receivers'
+   * matchVbMemberRead). A call through the access is the call extractor's.
+   */
+  private extractVbMemberRead(node: SyntaxNode, knownParent: SyntaxNode | undefined, ownerId: string): void {
+    let receiver: string | null;
+    let member: SyntaxNode | null;
+    if (node.type === 'member_access_expression') {
+      member = getChildByField(node, 'member');
+      const object = getChildByField(node, 'object');
+      receiver = object && !this.isVbSplitNew(object) ? this.vbReceiverPath(object) : null;
+    } else if (node.type === 'with_member_access_expression') {
+      member = node.namedChild(0);
+      const target = this.vbWithTarget(node);
+      receiver = target ? this.vbReceiverPath(target) : null;
+    } else if (node.type === 'member_initializer') {
+      member = getChildByField(node, 'name');
+      const creation = (knownParent ?? node.parent)?.parent;
+      receiver = creation?.type === 'object_creation_expression' ? this.vbReceiverPath(creation) : null;
+    } else return;
+    if (!receiver || member?.type !== 'identifier' || VB_NON_TYPE_RECEIVERS.test(receiver.split('.')[0]!)) return;
+    // `x.Method()`: the access is the callee of a call, which the call extractor links.
+    const parent = node.type === 'member_initializer' ? null : knownParent ?? node.parent;
+    if (parent && this.extractor!.callTypes.includes(parent.type)) {
+      const callee = getChildByField(parent, 'function') ?? getChildByField(parent, 'method') ?? parent.namedChild(0);
+      if (callee && callee.startIndex === node.startIndex) return;
+    }
+    this.unresolvedReferences.push({
+      fromNodeId: ownerId,
+      referenceName: `${receiver}.${getNodeText(member, this.source)}`,
+      referenceKind: 'references',
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column,
+    });
+  }
+
+  /**
+   * A VB.NET receiver as the resolver reads it: a name, `Me` / `MyClass` /
+   * `MyBase`, a member of one (`Me._h`, `user.Settings`), a `With` block's
+   * `.Inner`, or `{T}` for a value whose type the code writes there
+   * (`DirectCast(o, T)`, `New T(…)`). Null for anything else — an index, a
+   * call's result, a built-in type — which no declaration here types.
+   */
+  private vbReceiverPath(node: SyntaxNode, depth = 0): string | null {
+    if (depth > 6) return null;
+    switch (node.type) {
+      case 'identifier':
+        return getNodeText(node, this.source);
+      case 'me_expression':
+        return 'Me';
+      case 'myclass_expression':
+        return 'MyClass';
+      case 'mybase_expression':
+        return 'MyBase';
+      case 'parenthesized_expression': {
+        const inner = node.namedChild(0);
+        return inner ? this.vbReceiverPath(inner, depth + 1) : null;
+      }
+      case 'member_access_expression':
+      case 'with_member_access_expression': {
+        const through = node.type === 'member_access_expression';
+        const member = through ? getChildByField(node, 'member') : node.namedChild(0);
+        if (member?.type !== 'identifier') return null;
+        const object = through ? getChildByField(node, 'object') : this.vbWithTarget(node);
+        if (through && object && this.isVbSplitNew(object)) return null;
+        const head = object ? this.vbReceiverPath(object, depth + 1) : null;
+        return head ? `${head}.${getNodeText(member, this.source)}` : null;
+      }
+      case 'cast_expression':
+      case 'object_creation_expression': {
+        let type = getChildByField(node, 'type');
+        // `New T()` parses as an array type whose rank is the constructor's empty parentheses.
+        if (node.type === 'object_creation_expression' && type?.type === 'array_type') {
+          const rank = type.namedChildren.find((c: SyntaxNode) => c.type === 'array_rank_specifier');
+          type = rank && /^\(\s*\)$/.test(getNodeText(rank, this.source)) ? getChildByField(type, 'element_type') : null;
+        }
+        if (!type || type.type === 'predefined_type' || type.type === 'array_type') return null;
+        const written = getNodeText(type, this.source).replace(/\s+/g, ' ');
+        // .NET's own types (`System.Drawing.Point`) are never the project's.
+        return /^(?:System|Microsoft|My)\./i.test(written) ? null : `{${written}}`;
+      }
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Whether `node`, a member access's object, is `New System` of `New
+   * System.Drawing.Size(…)` or `New Ns` of `New Ns.Holder`: the grammar reads
+   * a qualified type after `New` as members read through a `New` of its first
+   * name. A value's `New` has its parentheses (`New Holder().Normal`).
+   */
+  private isVbSplitNew(node: SyntaxNode): boolean {
+    return node.type === 'object_creation_expression' && !getChildByField(node, 'arguments') &&
+      !getChildByField(node, 'initializer') && getChildByField(node, 'type')?.type !== 'array_type';
+  }
+
+  /**
+   * What a VB.NET `.Member` is read through: the expression of the `With`
+   * block it is in (a nested block's own `With .Inner` is read through the
+   * block around it), or the object an initializer sets up (`New T With {.X =
+   * 1}`). Null in an anonymous type's `New With {.X = 1}`, which declares X.
+   */
+  private vbWithTarget(node: SyntaxNode): SyntaxNode | null {
+    let child = node;
+    for (let p = node.parent; p; child = p, p = p.parent) {
+      if (p.type === 'with_statement') {
+        const expression = getChildByField(p, 'expression');
+        if (expression && expression.startIndex === child.startIndex && expression.endIndex === child.endIndex) continue;
+        return expression;
+      }
+      if (p.type === 'object_initializer') return p.parent?.type === 'object_creation_expression' ? p.parent : null;
+      if (p.type === 'anonymous_object_creation_expression') return null;
+    }
+    return null;
+  }
+
   /**
    * Find a `class_body` child of an `object_creation_expression` — the
    * marker for an anonymous class (`new T() { ... }`). Returns the body
@@ -5580,9 +6329,16 @@ export class TreeSitterExtractor {
     //    wrapper objects from `parent`/`namedChild` navigation, so
     //    `sibling === declNode` is unreliable — `startIndex` does
     //    the matching instead.
-    const parent = declNode.parent;
+    //
+    //    A grammar that wraps the declaration (Dart's `declaration`
+    //    around a member with no body) puts the annotations before the
+    //    wrapper, so the scan starts there. One that lets comments sit
+    //    between the annotations and the declaration (Dart) steps over them.
+    const anchor = this.extractor?.getDeclarationWrapper?.(declNode) ?? declNode;
+    const stepOver = this.extractor?.decoratorStepOverTypes;
+    const parent = anchor.parent;
     if (parent) {
-      const declStart = declNode.startIndex;
+      const declStart = anchor.startIndex;
       let declIdx = -1;
       for (let i = 0; i < parent.namedChildCount; i++) {
         const sibling = parent.namedChild(i);
@@ -5595,6 +6351,7 @@ export class TreeSitterExtractor {
         for (let j = declIdx - 1; j >= 0; j--) {
           const sibling = parent.namedChild(j);
           if (!sibling) continue;
+          if (stepOver?.includes(sibling.type)) continue;
           if (sibling.type !== 'decorator' && sibling.type !== 'annotation' && sibling.type !== 'marker_annotation') {
             break; // non-decorator separator → stop consuming
           }
@@ -5854,7 +6611,9 @@ export class TreeSitterExtractor {
   private visitFunctionBody(body: SyntaxNode, _functionId: string): void {
     if (!this.extractor) return;
 
-    const visitForCallsAndStructure = (node: SyntaxNode): void => {
+    // `parent` is handed down by the walk (absent at the body's root): reading
+    // `node.parent` walks down from the tree's root on every call.
+    const visitForCallsAndStructure = (node: SyntaxNode, parent?: SyntaxNode): void => {
       const nodeType = node.type;
 
       // A function-like macro defined inside a body is still a macro (#1838).
@@ -5867,6 +6626,13 @@ export class TreeSitterExtractor {
       // not in visitNode, so the capture hook must fire in both walkers.
       this.maybeCaptureFnRefs(node, nodeType);
 
+      // A named object literal in a body — an IIFE's `const App = {…}`, a
+      // handler map in a function — owns its function members as one at
+      // module scope does, and so does `window.App = {…}` written in here
+      // (#2300). Each handles its whole subtree.
+      if (nodeType === 'variable_declarator' && this.extractLocalObjectOwner(node)) return;
+      if (nodeType === 'assignment_expression' && this.extractAssignedObjectOwner(node, false)) return;
+
       // Rocket route-registration macros (`routes![…]` / `catchers![…]`): the
       // handler paths live in a raw token tree the call walker can't see.
       if (nodeType === 'macro_invocation') this.extractRustRouteMacro(node);
@@ -5887,6 +6653,8 @@ export class TreeSitterExtractor {
           this.extractAnonymousClass(node, anonBody);
           return;
         }
+      } else if (this.language === 'kotlin' && nodeType === 'infix_expression') {
+        this.extractKotlinInfixCall(node);
       } else if (this.extractor!.extractBareCall) {
         const calleeName = this.extractor!.extractBareCall(node, this.source);
         if (calleeName && this.nodeStack.length > 0) {
@@ -5967,7 +6735,45 @@ export class TreeSitterExtractor {
       }
 
       // Static-member / value-read: `Enum.value`, `Type.CONST`, `Foo::BAR`.
-      this.extractStaticMemberRef(node);
+      this.extractStaticMemberRef(node, parent);
+
+      // A member read that may run code — Dart's `x.area` calls the getter
+      // `area` (#2338). The resolver links it to a getter, as a call, or to
+      // nothing: a plain field read stays a reference that names no symbol.
+      const read = this.extractor!.extractMemberRead?.(node, parent);
+      if (read) {
+        const readerId = this.nodeStack[this.nodeStack.length - 1];
+        if (readerId) {
+          this.unresolvedReferences.push({
+            fromNodeId: readerId,
+            referenceName: read.name,
+            referenceKind: 'references',
+            line: read.node.startPosition.row + 1,
+            column: read.node.startPosition.column,
+          });
+        }
+      }
+
+      // A type a Dart body names — a local's declared type, a generic argument
+      // (`Future<Report?>.value(null)`, `context.read<Report>()`, and
+      // `ref.read<Report>(p)` when the grammar read that call as comparisons),
+      // a cast, a type test — is the function's dependency, as a TS local's
+      // annotation is just below (#2327).
+      if (this.language === 'dart') {
+        const typeNode = nodeType === 'type_identifier' ? node
+          : nodeType === 'relational_operator' ? dartMisparsedGenericCall(node)?.typeName
+          : undefined;
+        const ownerId = this.nodeStack[this.nodeStack.length - 1];
+        if (typeNode && ownerId && isDartTypeName(typeNode)) {
+          this.unresolvedReferences.push({
+            fromNodeId: ownerId,
+            referenceName: getNodeText(typeNode, this.source),
+            referenceKind: 'references',
+            line: typeNode.startPosition.row + 1,
+            column: typeNode.startPosition.column,
+          });
+        }
+      }
 
       // Local variable type annotations inside a body — `const items: Foo[] = []`,
       // `const x: SomeType = svc.load()`. We deliberately do NOT create nodes for
@@ -6071,7 +6877,7 @@ export class TreeSitterExtractor {
       for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (child) {
-          visitForCallsAndStructure(child);
+          visitForCallsAndStructure(child, node);
         }
       }
     };
@@ -6119,11 +6925,39 @@ export class TreeSitterExtractor {
       return;
     }
 
+    // Dart: the type an extension is `on` is one it depends on — `extension
+    // ReportX on Report`, `on List<Report>` (#2327). Not a supertype: a
+    // `references` edge, as a C# extension method's `this Report r` gets.
+    if (this.language === 'dart' && node.type === 'extension_declaration') {
+      for (const onType of node.childrenForFieldName('class')) {
+        if (onType) pushDartTypeRefs(onType, classId, (ref) => this.unresolvedReferences.push(ref));
+      }
+    }
+
     // Look for extends/implements clauses
     for (let i = 0; i < node.namedChildCount; i++) {
       const child = node.namedChild(i);
       if (!child) continue;
 
+      // Dart: `class A = B with M implements I;` keeps its supertypes in a
+      // `mixin_application` — the same shapes as a class body's clauses.
+      if (this.language === 'dart' && child.type === 'mixin_application_class') {
+        const application = child.namedChildren.find((c: SyntaxNode) => c.type === 'mixin_application');
+        for (const t of application?.namedChildren ?? []) {
+          const targets = t.type === 'type_identifier' ? [t] : t.type === 'mixins' ? t.namedChildren.filter((m: SyntaxNode) => m.type === 'type_identifier') : t.type === 'interfaces' ? t.namedChildren : [];
+          for (const target of targets) {
+            this.unresolvedReferences.push({
+              fromNodeId: classId,
+              referenceName: getNodeText(target, this.source),
+              referenceKind: t.type === 'type_identifier' ? 'extends' : 'implements',
+              line: target.startPosition.row + 1,
+              column: target.startPosition.column,
+            });
+          }
+        }
+        continue;
+      }
+
       if (
         child.type === 'extends_clause' ||
         child.type === 'superclass' ||
@@ -6269,15 +7103,18 @@ export class TreeSitterExtractor {
         }
       }
 
-      // Go interface embedding: `type Querier interface { LabelQuerier; ... }`
-      // constraint_elem wraps the embedded interface type identifier
-      if (child.type === 'constraint_elem') {
-        const typeId = child.namedChildren.find((c: SyntaxNode) => c.type === 'type_identifier');
+      // Go interface embedding: `type IRouter interface { IRoutes; Group(…) }`.
+      // tree-sitter-go parses every element of an interface that is not a
+      // method as a `type_elem`; one holding a single named type embeds that
+      // interface. A union (`float32 | float64`), an underlying type (`~int`)
+      // or a lone basic type (`int64`) is a type-set constraint instead.
+      if (this.language === 'go' && child.type === 'type_elem') {
+        const terms = child.namedChildren.filter((c: SyntaxNode) => c.type !== 'comment');
+        const typeId = terms.length === 1 ? goEmbeddedTypeName(terms[0], this.source) : undefined;
         if (typeId) {
-          const name = getNodeText(typeId, this.source);
           this.unresolvedReferences.push({
             fromNodeId: classId,
-            referenceName: name,
+            referenceName: getNodeText(typeId, this.source),
             referenceKind: 'extends',
             line: typeId.startPosition.row + 1,
             column: typeId.startPosition.column,
@@ -6286,21 +7123,23 @@ export class TreeSitterExtractor {
       }
 
       // Go struct embedding: field_declaration without field_identifier
-      // e.g. `type DB struct { *Head; Queryable }` — no field name means embedded type
-      if (child.type === 'field_declaration') {
+      // e.g. `type DB struct { *Head; Queryable; sync.Mutex }` — no field name
+      // means an embedded type, read the way an interface's is.
+      // Go only: C, C++ and Objective-C members are field_declarations too, but
+      // nest their name inside the declarator (`Cache* cache_;`, `jv elems[];`,
+      // `Status Get(int);`), so this test read every such member's type as a
+      // supertype. Their supertypes come from base_class_clause / superclass.
+      if (this.language === 'go' && child.type === 'field_declaration') {
         const hasFieldIdentifier = child.namedChildren.some((c: SyntaxNode) => c.type === 'field_identifier');
-        if (!hasFieldIdentifier) {
-          const typeId = child.namedChildren.find((c: SyntaxNode) => c.type === 'type_identifier');
-          if (typeId) {
-            const name = getNodeText(typeId, this.source);
-            this.unresolvedReferences.push({
-              fromNodeId: classId,
-              referenceName: name,
-              referenceKind: 'extends',
-              line: typeId.startPosition.row + 1,
-              column: typeId.startPosition.column,
-            });
-          }
+        const typeId = hasFieldIdentifier ? undefined : goEmbeddedTypeName(getChildByField(child, 'type'), this.source);
+        if (typeId) {
+          this.unresolvedReferences.push({
+            fromNodeId: classId,
+            referenceName: getNodeText(typeId, this.source),
+            referenceKind: 'extends',
+            line: typeId.startPosition.row + 1,
+            column: typeId.startPosition.column,
+          });
         }
       }
 
@@ -6541,21 +7380,7 @@ export class TreeSitterExtractor {
   /**
    * Built-in/primitive type names that shouldn't create references
    */
-  private readonly BUILTIN_TYPES = new Set([
-    'string', 'number', 'boolean', 'void', 'null', 'undefined', 'never', 'any', 'unknown',
-    'object', 'symbol', 'bigint', 'true', 'false',
-    // Rust
-    'str', 'bool', 'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
-    'u8', 'u16', 'u32', 'u64', 'u128', 'usize', 'f32', 'f64', 'char',
-    // Java/C#
-    'int', 'long', 'short', 'byte', 'float', 'double', 'char',
-    // Go
-    'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
-    'float32', 'float64', 'complex64', 'complex128', 'rune', 'error',
-    // Scala (capitalized primitives + ubiquitous stdlib aliases)
-    'Int', 'Long', 'Short', 'Byte', 'Float', 'Double', 'Boolean', 'Char', 'Unit',
-    'String', 'Any', 'AnyRef', 'AnyVal', 'Nothing', 'Null',
-  ]);
+  private readonly BUILTIN_TYPES = BUILTIN_TYPE_NAMES;
 
   /**
    * Extract type references from type annotations on a function/method/field node.
@@ -6604,6 +7429,18 @@ export class TreeSitterExtractor {
             c.type === 'factory_constructor_signature'
         ) ?? node;
       }
+      // A redirecting factory names the class it constructs after `=`, then
+      // perhaps that class's constructor (`= _$QuestionImpl.fromJson`, which
+      // parses as two type_identifiers). Neither the constructor nor an import
+      // prefix is a type, and Dart writes types UpperCamel.
+      if (sig.type === 'redirecting_factory_constructor_signature') {
+        for (const child of sig.namedChildren) {
+          if (child.type !== 'type_identifier' || /^[_$]*[A-Z]/.test(child.text)) {
+            this.extractTypeRefsFromSubtree(child, nodeId);
+          }
+        }
+        return;
+      }
       this.extractTypeRefsFromSubtree(sig, nodeId);
       return;
     }
diff --git a/src/extraction/vue-extractor.ts b/src/extraction/vue-extractor.ts
index 862f17c793..37b8305c84 100644
--- a/src/extraction/vue-extractor.ts
+++ b/src/extraction/vue-extractor.ts
@@ -2,6 +2,9 @@ import { Node, Edge, ExtractionResult, ExtractionError, UnresolvedReference, Lan
 import { generateNodeId } from './tree-sitter-helpers';
 import { TreeSitterExtractor } from './tree-sitter';
 import { isLanguageSupported } from './grammars';
+import { foldScriptResult, sfcFileNode } from './sfc-script';
+import { vueOptionsMembers } from './vue-options-api';
+import { vueTemplateCalls } from './vue-template-calls';
 
 /**
  * Vue built-in components — skipped so a `<Transition>` / `<KeepAlive>` in the
@@ -55,8 +58,10 @@ export class VueExtractor {
     const startTime = Date.now();
 
     try {
-      // Create component node for the .vue file itself
+      // The file, holding the component the .vue file is
+      this.nodes.push(sfcFileNode(this.filePath, this.source, 'vue'));
       const componentNode = this.createComponentNode();
+      this.edges.push({ source: `file:${this.filePath}`, target: componentNode.id, kind: 'contains' });
 
       // Extract and process script blocks
       const scriptBlocks = this.extractScriptBlocks();
@@ -70,6 +75,11 @@ export class VueExtractor {
       // markup (incl. through a barrel import) is invisible to callers /
       // impact (#629 follow-up).
       this.extractTemplateComponents(componentNode.id);
+
+      // Calls the template makes — `{{ useBar(link) }}`, `:to="localePath(x)"`,
+      // `@click="save(item)"` — are the component's, like the calls its
+      // `<script setup>` makes (#2340).
+      this.extractTemplateCalls(componentNode.id);
     } catch (error) {
       this.errors.push({
         message: `Vue extraction error: ${error instanceof Error ? error.message : String(error)}`,
@@ -114,6 +124,67 @@ export class VueExtractor {
     return node;
   }
 
+  /**
+   * Method nodes for an Options API component's members (see
+   * ./vue-options-api), and the references and edges written inside each —
+   * which the TS extractor attributed to the file — re-attributed to it.
+   * Lines are block-relative here; the caller offsets them with the rest.
+   */
+  private addOptionsMembers(
+    block: { content: string; startLine: number },
+    result: ExtractionResult,
+    componentNodeId: string
+  ): void {
+    const members = vueOptionsMembers(block.content);
+    if (members.length === 0) return;
+    const component = this.nodes.find((n) => n.id === componentNodeId);
+    const owner = component?.name ?? 'component';
+    const lineAt = (offset: number) => block.content.slice(0, offset).split('\n').length;
+    const colAt = (offset: number) => offset - block.content.lastIndexOf('\n', offset - 1) - 1;
+    const now = Date.now();
+    const created: Node[] = [];
+    for (const m of members) {
+      const startLine = lineAt(m.start);
+      const endLine = lineAt(m.end);
+      created.push({
+        id: generateNodeId(this.filePath, 'method', `${owner}.${m.name}`, startLine + block.startLine),
+        kind: 'method',
+        name: m.name,
+        qualifiedName: `${owner}::${m.name}`,
+        filePath: this.filePath,
+        language: 'vue',
+        startLine,
+        endLine,
+        startColumn: colAt(m.start),
+        endColumn: colAt(m.end),
+        updatedAt: now,
+      });
+    }
+    // Innermost member for a line: `computed: { x: { get() {…} } }` is one member.
+    const memberAt = (line: number): Node | undefined => {
+      let best: Node | undefined;
+      for (const n of created) {
+        if (n.startLine <= line && n.endLine >= line && (!best || n.startLine >= best.startLine)) best = n;
+      }
+      return best;
+    };
+    // What the TS extractor attributed to the file (or to nothing narrower).
+    const fileNode = result.nodes.find((n) => n.kind === 'file');
+    const narrower = new Set(result.nodes.filter((n) => n.kind !== 'file').map((n) => n.id));
+    const isFileLevel = (id: string) => (fileNode ? id === fileNode.id : !narrower.has(id));
+    for (const ref of result.unresolvedReferences) {
+      if (!isFileLevel(ref.fromNodeId)) continue;
+      const member = memberAt(ref.line);
+      if (member) ref.fromNodeId = member.id;
+    }
+    for (const edge of result.edges) {
+      if (edge.kind === 'contains' || !edge.line || !isFileLevel(edge.source)) continue;
+      const member = memberAt(edge.line);
+      if (member) edge.source = member.id;
+    }
+    result.nodes.push(...created);
+  }
+
   /**
    * Extract <script> and <script setup> blocks from the Vue source
    */
@@ -187,45 +258,16 @@ export class VueExtractor {
     const extractor = new TreeSitterExtractor(this.filePath, block.content, scriptLanguage);
     const result = extractor.extract();
 
-    // Offset line numbers from script block back to .vue file positions
-    for (const node of result.nodes) {
-      node.startLine += block.startLine;
-      node.endLine += block.startLine;
-      node.language = 'vue'; // Mark as vue, not TS/JS
-
-      this.nodes.push(node);
-
-      // Add containment edge from component to this node
-      this.edges.push({
-        source: componentNodeId,
-        target: node.id,
-        kind: 'contains',
-      });
-    }
-
-    // Offset edges (they reference line numbers)
-    for (const edge of result.edges) {
-      if (edge.line) {
-        edge.line += block.startLine;
-      }
-      this.edges.push(edge);
-    }
-
-    // Offset unresolved references
-    for (const ref of result.unresolvedReferences) {
-      ref.line += block.startLine;
-      ref.filePath = this.filePath;
-      ref.language = 'vue';
-      this.unresolvedReferences.push(ref);
-    }
+    // An Options API component's functions — `methods`, `computed`, `watch`,
+    // lifecycle hooks — are object-literal members the TS extractor leaves as
+    // part of the file. Name each one, and hand it the calls written inside it.
+    if (!block.isSetup) this.addOptionsMembers(block, result, componentNodeId);
 
-    // Carry over errors
-    for (const error of result.errors) {
-      if (error.line) {
-        error.line += block.startLine;
-      }
-      this.errors.push(error);
-    }
+    foldScriptResult(
+      result,
+      { filePath: this.filePath, componentNodeId, lineOffset: block.startLine, language: 'vue', perInstance: block.isSetup },
+      { nodes: this.nodes, edges: this.edges, unresolvedReferences: this.unresolvedReferences, errors: this.errors }
+    );
   }
 
   /**
@@ -290,4 +332,50 @@ export class VueExtractor {
       }
     }
   }
+
+  /**
+   * Calls written in the `<template>` (see ./vue-template-calls), each made by
+   * the component at the line it is written on — the same `calls` reference a
+   * call in `<script setup>` makes, so a composable or helper used only in
+   * markup has its callers.
+   *
+   * A template calls an Options API component's own methods by their bare
+   * name (`{{ price(item) }}`, `@click="save(form)"`), where script code
+   * writes `this.save()`. Resolution only binds a bare call to a component
+   * method when it reads `this.` at the call site, so these are linked here,
+   * where the method is known to be this component's.
+   */
+  private extractTemplateCalls(componentNodeId: string): void {
+    const calls = vueTemplateCalls(this.source);
+    if (calls.length === 0) return;
+    const component = this.nodes.find((n) => n.id === componentNodeId);
+    const ownMethods = new Map<string, string>();
+    for (const n of this.nodes) {
+      if (n.kind === 'method' && n.qualifiedName === `${component?.name}::${n.name}`) ownMethods.set(n.name, n.id);
+    }
+    const lineStarts = [0];
+    for (let i = 0; i < this.source.length; i++) {
+      if (this.source.charCodeAt(i) === 10) lineStarts.push(i + 1);
+    }
+    let line = 0;
+    for (const call of calls) {
+      // Calls come in source order, so the line only moves forward.
+      while (line + 1 < lineStarts.length && lineStarts[line + 1]! <= call.offset) line++;
+      const column = call.offset - lineStarts[line]!;
+      const ownMethod = call.name.includes('.') ? undefined : ownMethods.get(call.name);
+      if (ownMethod) {
+        this.edges.push({ source: componentNodeId, target: ownMethod, kind: 'calls', line: line + 1, column });
+        continue;
+      }
+      this.unresolvedReferences.push({
+        fromNodeId: componentNodeId,
+        referenceName: call.name,
+        referenceKind: 'calls',
+        line: line + 1, // 1-indexed
+        column,
+        filePath: this.filePath,
+        language: 'vue',
+      });
+    }
+  }
 }
diff --git a/src/extraction/vue-options-api.ts b/src/extraction/vue-options-api.ts
new file mode 100644
index 0000000000..8d7ec63267
--- /dev/null
+++ b/src/extraction/vue-options-api.ts
@@ -0,0 +1,204 @@
+/**
+ * The members of a Vue Options API component — `export default { methods:
+ * { login() {…} }, computed: {…}, watch: {…}, mounted() {…} }`.
+ *
+ * A `<script>` block goes through the TypeScript/JavaScript extractor, which
+ * extracts no symbol for a method written in an object literal. Every Vue 2
+ * app, and every Vue 3 app not on `<script setup>`, keeps its code there:
+ * vue-element-admin's login screen had no `handleLogin`, so its calls, its
+ * `this.$router.push`, and the `@click="handleLogin"` that runs it all
+ * belonged to the file.
+ *
+ * This reads the options object the default export is — directly, or through
+ * `defineComponent({…})` / `Vue.extend({…})` / `Vue.component('x', {…})` —
+ * and names each function in it: `methods`, `computed` and `watch` entries,
+ * and the component's own functions (`data`, `setup`, the lifecycle hooks,
+ * Nuxt 2's `asyncData` / `fetch`, `render`).
+ */
+
+/** One function-valued member of the options object, as offsets into the script. */
+export interface OptionsMember {
+  name: string;
+  /** Where the member's key starts. */
+  start: number;
+  /** One past where its value ends. */
+  end: number;
+}
+
+/** The options a component declares as functions of its own. */
+const COMPONENT_FUNCTIONS = new Set([
+  'data', 'setup', 'render',
+  'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUpdate', 'updated',
+  'activated', 'deactivated', 'beforeDestroy', 'destroyed', 'beforeUnmount', 'unmounted',
+  'errorCaptured', 'renderTracked', 'renderTriggered', 'serverPrefetch',
+  // Nuxt 2
+  'asyncData', 'fetch', 'head', 'validate', 'middleware',
+]);
+
+/** The groups whose every entry is a function (or, for computed/watch, an object of them). */
+const MEMBER_GROUPS = new Set(['methods', 'computed', 'watch']);
+
+/** The index after a string, template or regex-free literal starting at `at`; -1 if unterminated. */
+function skipQuoted(s: string, at: number): number {
+  const quote = s[at]!;
+  for (let i = at + 1; i < s.length; i++) {
+    const ch = s[i]!;
+    if (ch === '\\') {
+      i++;
+      continue;
+    }
+    if (quote === '`' && ch === '$' && s[i + 1] === '{') {
+      const close = matchClose(s, i + 1);
+      if (close < 0) return -1;
+      i = close;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+  }
+  return -1;
+}
+
+/** The index of the bracket closing the one at `open`; -1 if unbalanced. */
+function matchClose(s: string, open: number): number {
+  let depth = 0;
+  for (let i = open; i < s.length; i++) {
+    const ch = s[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipQuoted(s, i);
+      if (end < 0) return -1;
+      i = end - 1;
+      continue;
+    }
+    if (ch === '/' && s[i + 1] === '/') {
+      const nl = s.indexOf('\n', i);
+      i = nl < 0 ? s.length : nl;
+      continue;
+    }
+    if (ch === '/' && s[i + 1] === '*') {
+      const close = s.indexOf('*/', i + 2);
+      i = close < 0 ? s.length : close + 1;
+      continue;
+    }
+    if (ch === '{' || ch === '[' || ch === '(') depth++;
+    else if (ch === '}' || ch === ']' || ch === ')') {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+interface RawMember {
+  name: string;
+  start: number;
+  /** Where the value starts (after `:`), or the `(` of a method shorthand. */
+  valueAt: number;
+  end: number;
+  shorthand: boolean;
+}
+
+/** The members of the object literal whose `{` is at `open`. */
+function objectMembers(s: string, open: number): RawMember[] {
+  const close = matchClose(s, open);
+  if (close < 0) return [];
+  const out: RawMember[] = [];
+  let i = open + 1;
+  while (i < close) {
+    // Skip separators, whitespace and comments between members.
+    const ws = /^(?:\s|,|\/\/[^\n]*|\/\*[\s\S]*?\*\/)+/.exec(s.slice(i, close));
+    if (ws) {
+      i += ws[0].length;
+      continue;
+    }
+    const start = i;
+    // `async name(…)`, `*name(…)`, `get name()`, `'quoted-key'`, `name`, `...spread`
+    const head = /^(?:(?:async|get|set)\s+(?=[\w$'"[]))?\*?\s*(?:([A-Za-z_$][\w$]*)|(['"])((?:(?!\2).)*)\2|(\[)|(\.\.\.))/.exec(s.slice(i, close));
+    if (!head) {
+      i++;
+      continue;
+    }
+    const name = head[1] ?? head[3] ?? null;
+    let j = i + head[0].length;
+    if (head[5] !== undefined) {
+      // A computed key — `[KEY]() {}` — has no static name; step over it.
+      const keyClose = matchClose(s, j - 1);
+      if (keyClose < 0) return out;
+      j = keyClose + 1;
+    }
+    // Where this member ends: the next depth-0 comma, or the object's end.
+    let k = j;
+    while (k < close) {
+      const ch = s[k]!;
+      if (ch === '"' || ch === "'" || ch === '`') {
+        const end = skipQuoted(s, k);
+        if (end < 0) return out;
+        k = end;
+        continue;
+      }
+      if (ch === '/' && (s[k + 1] === '/' || s[k + 1] === '*')) {
+        const end = s[k + 1] === '/' ? s.indexOf('\n', k) : s.indexOf('*/', k + 2) + 1;
+        k = end <= 0 ? close : end + 1;
+        continue;
+      }
+      if (ch === '{' || ch === '[' || ch === '(') {
+        const end = matchClose(s, k);
+        if (end < 0) return out;
+        k = end + 1;
+        continue;
+      }
+      if (ch === ',') break;
+      k++;
+    }
+    const rest = s.slice(j, k);
+    const colon = /^\s*:/.exec(rest);
+    if (name !== null && head[6] === undefined) {
+      out.push({
+        name,
+        start,
+        valueAt: colon ? j + colon[0].length : j,
+        end: k,
+        shorthand: !colon && /^\s*\(/.test(rest),
+      });
+    }
+    i = k + 1;
+  }
+  return out;
+}
+
+/** Whether a member's value is a function: a shorthand method, `function (…) {…}`, or an arrow. */
+function isFunctionValue(s: string, m: RawMember): boolean {
+  if (m.shorthand) return true;
+  const value = s.slice(m.valueAt, m.end).trimStart();
+  return /^(?:async\s+)?function\b/.test(value) || /^(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(value);
+}
+
+/** The `{` of the options object the default export is, or -1. */
+function optionsObjectStart(script: string): number {
+  const m = /\bexport\s+default\s+(?:(?:defineComponent|defineNuxtComponent|Vue\s*\.\s*extend)\s*\(\s*|Vue\s*\.\s*component\s*\(\s*(['"])[^'"]*\1\s*,\s*)?\{/.exec(script);
+  return m ? m.index + m[0].length - 1 : -1;
+}
+
+/** Every function a Vue Options API component declares, in source order. */
+export function vueOptionsMembers(script: string): OptionsMember[] {
+  const open = optionsObjectStart(script);
+  if (open < 0) return [];
+  const out: OptionsMember[] = [];
+  for (const member of objectMembers(script, open)) {
+    if (COMPONENT_FUNCTIONS.has(member.name) && isFunctionValue(script, member)) {
+      out.push({ name: member.name, start: member.start, end: member.end });
+      continue;
+    }
+    if (!MEMBER_GROUPS.has(member.name) || member.shorthand) continue;
+    const valueOpen = script.indexOf('{', member.valueAt);
+    if (valueOpen < 0 || valueOpen >= member.end || script.slice(member.valueAt, valueOpen).trim() !== '') continue;
+    for (const entry of objectMembers(script, valueOpen)) {
+      // `computed: { x: { get() {}, set() {} } }` and `watch: { y: { handler() {} } }`
+      // are functions too; a watcher written as a method NAME (`z: 'onZ'`) is not.
+      const value = script.slice(entry.valueAt, entry.end).trimStart();
+      if (isFunctionValue(script, entry) || (member.name !== 'methods' && value.startsWith('{'))) {
+        out.push({ name: entry.name, start: entry.start, end: entry.end });
+      }
+    }
+  }
+  return out;
+}
diff --git a/src/extraction/vue-template-calls.ts b/src/extraction/vue-template-calls.ts
new file mode 100644
index 0000000000..fa225633ac
--- /dev/null
+++ b/src/extraction/vue-template-calls.ts
@@ -0,0 +1,561 @@
+/**
+ * Calls written in a Vue single-file component's `<template>` (#2340).
+ *
+ * A template runs code as surely as the `<script>` does: `{{ formatDate(at) }}`,
+ * `:to="localePath(link)"`, `v-if="canEdit(user)"` and `@click="save(item)"`
+ * call a function every time the component renders or the event fires. The
+ * Vue extractor hands only `<script>` blocks to the TypeScript extractor, so
+ * none of these were calls: `callers` on a Nuxt composable used in markup
+ * came back empty.
+ *
+ * This finds them without a template compiler. A tag scanner reads the root
+ * `<template>` (quote-aware, so a `>` inside an attribute value never ends a
+ * tag) and collects the expressions Vue compiles: `{{ }}` interpolations in
+ * text, and the values of directives (`:x` / `v-bind`, `@x` / `v-on`, `v-if`,
+ * `v-show`, `v-model`, `v-for`'s source, custom `v-*`). A small JS lexer then
+ * names each call's callee the way a script-side call is named (`useBar`,
+ * `store.fetchUsers`), skipping strings and comments and reading into
+ * template-literal substitutions.
+ *
+ * What is never a call to project code is dropped: names the template binds
+ * itself (`v-for` aliases and slot props for their element's subtree, arrow
+ * and function parameters for the rest of their expression), `$`-prefixed
+ * instance helpers (`$t`, `$emit`, `$router.push`), the globals Vue lets a
+ * template reach (`Math`, `JSON`, `Date`...), keywords, `new X()`, and an
+ * object literal's method shorthand. A `v-pre` subtree is not compiled by Vue
+ * and is skipped, as is a template in another language (`lang="pug"`).
+ * Approach after the template-binding scan in #2073 by @L0garithmic.
+ */
+
+export interface VueTemplateCall {
+  /** The callee as a script-side call names it: `useBar`, `store.fetchUsers`. */
+  name: string;
+  /** Offset of the callee's first character in the SFC source. */
+  offset: number;
+}
+
+/** Elements that never have children: no closing tag, no scope of their own. */
+const VOID_ELEMENTS = new Set([
+  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta',
+  'param', 'source', 'track', 'wbr',
+]);
+
+/**
+ * The globals a Vue template can reach — Vue's own allow-list
+ * (`isGloballyAllowed` in @vue/shared). Every other name in a template is the
+ * component's: a script binding, a prop, an auto-import.
+ */
+const TEMPLATE_GLOBALS = new Set([
+  'Infinity', 'undefined', 'NaN', 'isFinite', 'isNaN', 'parseFloat', 'parseInt',
+  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'Math',
+  'Number', 'Date', 'Array', 'Object', 'Boolean', 'String', 'RegExp', 'Map', 'Set',
+  'JSON', 'Intl', 'BigInt', 'console', 'Error', 'Symbol',
+]);
+
+/** Words that can stand before `(` without being a call. */
+const KEYWORDS = new Set([
+  'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'default', 'break',
+  'continue', 'return', 'throw', 'try', 'catch', 'finally', 'function', 'class',
+  'new', 'delete', 'typeof', 'void', 'instanceof', 'in', 'of', 'var', 'let',
+  'const', 'this', 'super', 'import', 'export', 'await', 'async', 'yield', 'with',
+  'debugger', 'true', 'false', 'null', 'undefined',
+]);
+
+/** Keywords that end an operand, as an identifier does (`this`, `true`). */
+const VALUE_KEYWORDS = new Set(['this', 'super', 'true', 'false', 'null', 'undefined']);
+
+const IDENT_START = /[A-Za-z_$]/;
+const IDENT_CHAR = /[\w$]/;
+const IDENTIFIERS = /[A-Za-z_$][\w$]*/g;
+const WS = /\s/;
+
+/** Vue's own `v-for` split: aliases, then `in` / `of`, then the source expression. */
+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.
+  const blank = (m: string) => m.replace(/[^\n]/g, ' ');
+  const masked = source
+    .replace(/<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1\s*>/g, blank)
+    .replace(/<!--[\s\S]*?-->/g, blank);
+  const root = rootTemplate(masked);
+  if (!root) return [];
+  const calls: VueTemplateCall[] = [];
+  scanMarkup(masked, root.start, root.end, calls);
+  return calls.sort((a, b) => a.offset - b.offset);
+}
+
+/** The content range of the SFC's root `<template>`; null for none or a non-HTML one. */
+function rootTemplate(s: string): { start: number; end: number } | null {
+  const tagRe = /<(\/?)template(?=[\s/>])((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+  let m: RegExpExecArray | null;
+  let start = -1;
+  let depth = 0;
+  while ((m = tagRe.exec(s)) !== null) {
+    const closing = m[1] === '/';
+    const attrs = m[2] ?? '';
+    if (start === -1) {
+      if (closing || attrs.trimEnd().endsWith('/')) continue;
+      const lang = /\blang\s*=\s*["']?([\w-]+)/.exec(attrs)?.[1];
+      if (lang && lang.toLowerCase() !== 'html') return null;
+      start = m.index + m[0].length;
+      depth = 1;
+    } else if (closing) {
+      if (--depth === 0) return { start, end: m.index };
+    } else if (!attrs.trimEnd().endsWith('/')) {
+      depth++;
+    }
+  }
+  return start === -1 ? null : { start, end: s.length };
+}
+
+interface Attr {
+  name: string;
+  value: string | null;
+  /** Offset of the value's first character (inside any quotes). */
+  valueStart: number;
+}
+
+interface Frame {
+  tag: string;
+  locals: Set<string> | null;
+  pre: boolean;
+}
+
+/** The markup of `s[start, end)`: element nesting, directive values, interpolations. */
+function scanMarkup(s: string, start: number, end: number, out: VueTemplateCall[]): void {
+  const stack: Frame[] = [];
+  const inScope = (name: string, own?: Set<string>) =>
+    own?.has(name) === true || stack.some((f) => f.locals?.has(name) === true);
+  const inPre = () => stack.some((f) => f.pre);
+  const closeTag = /<\/([A-Za-z][^\s/>]*)\s*>/y;
+
+  // The next `{{` at or after `i`, searched for again only once `i` passes it
+  // (a fresh search per tag would rescan the rest of a mustache-free template).
+  let nextMustache = -1;
+  let i = start;
+  while (i < end) {
+    if (nextMustache < i) {
+      const mu = s.indexOf('{{', i);
+      nextMustache = mu === -1 || mu >= end ? end : mu;
+    }
+    const lt = s.indexOf('<', i);
+    const nextTag = lt === -1 || lt >= end ? end : lt;
+    if (nextMustache < nextTag) {
+      // A `{{ }}` interpolation runs to the first `}}`, as Vue's parser reads it.
+      const close = s.indexOf('}}', nextMustache + 2);
+      const exprEnd = close === -1 || close > end ? end : close;
+      if (!inPre()) scanExpression(s, nextMustache + 2, exprEnd, (n) => inScope(n), out);
+      i = exprEnd + 2;
+      continue;
+    }
+    if (nextTag >= end) break;
+
+    closeTag.lastIndex = nextTag;
+    const cm = closeTag.exec(s);
+    if (cm) {
+      const name = cm[1]!;
+      for (let k = stack.length - 1; k >= 0; k--) {
+        if (stack[k]!.tag === name || stack[k]!.tag.toLowerCase() === name.toLowerCase()) {
+          stack.length = k;
+          break;
+        }
+      }
+      i = nextTag + cm[0].length;
+      continue;
+    }
+    if (!/[A-Za-z]/.test(s[nextTag + 1] ?? '')) {
+      i = nextTag + 1; // a `<` in text, not a tag
+      continue;
+    }
+
+    const tag = parseOpenTag(s, nextTag, end);
+    i = tag.close;
+    // Names this element binds for itself and its subtree: `v-for` aliases,
+    // slot props (`#item="{ item }"`, `v-slot="props"`, Vue 2 `slot-scope`).
+    let own: Set<string> | null = null;
+    let pre = false;
+    let forSource: { start: number; end: number } | null = null;
+    for (const a of tag.attrs) {
+      if (a.name === 'v-pre') pre = true;
+      if (a.value === null) continue;
+      const kind = directiveKind(a.name);
+      if (kind === 'for') {
+        const fm = FOR_ALIAS.exec(a.value);
+        if (fm) {
+          own ??= new Set();
+          for (const id of fm[1]!.match(IDENTIFIERS) ?? []) own.add(id);
+          forSource = { start: a.valueStart + a.value.length - fm[2]!.length, end: a.valueStart + a.value.length };
+        }
+      } else if (kind === 'slot') {
+        own ??= new Set();
+        for (const id of a.value.match(IDENTIFIERS) ?? []) own.add(id);
+      }
+    }
+    if (!pre && !inPre()) {
+      const ownLocals = own ?? undefined;
+      const local = (n: string) => inScope(n, ownLocals);
+      for (const a of tag.attrs) {
+        if (a.value === null) continue;
+        const kind = directiveKind(a.name);
+        if (kind === 'expr' || kind === 'on') {
+          scanExpression(s, a.valueStart, a.valueStart + a.value.length, local, out);
+        } else if (kind === 'for' && forSource) {
+          scanExpression(s, forSource.start, forSource.end, local, out);
+        }
+      }
+    }
+    if (!tag.selfClosing && !VOID_ELEMENTS.has(tag.name.toLowerCase())) {
+      stack.push({ tag: tag.name, locals: own, pre });
+    }
+  }
+}
+
+/** What an attribute is to Vue: a `v-for`, a slot-props pattern, a handler, an expression, or plain HTML. */
+function directiveKind(name: string): 'for' | 'slot' | 'on' | 'expr' | null {
+  if (name === 'v-for') return 'for';
+  if (name.startsWith('#') || name === 'v-slot' || name.startsWith('v-slot:') || name === 'slot-scope' || name === 'scope') {
+    return 'slot';
+  }
+  if (name.startsWith('@') || name === 'v-on' || name.startsWith('v-on:')) return 'on';
+  // `:x` / `.x` (v-bind and its `.prop` shorthand), `v-bind`, `v-if`, `v-model`, custom `v-*`.
+  if (name.startsWith(':') || name.startsWith('.') || name.startsWith('v-')) return 'expr';
+  return null;
+}
+
+/** An opening tag at `at`: its name, its attributes, where it ends. Quote-aware. */
+function parseOpenTag(
+  s: string,
+  at: number,
+  end: number
+): { name: string; attrs: Attr[]; close: number; selfClosing: boolean } {
+  let p = at + 1;
+  const nameStart = p;
+  while (p < end && !/[\s/>]/.test(s[p]!)) p++;
+  const name = s.slice(nameStart, p);
+  const attrs: Attr[] = [];
+  while (p < end) {
+    while (p < end && WS.test(s[p]!)) p++;
+    if (p >= end) break;
+    const c = s[p]!;
+    if (c === '>') return { name, attrs, close: p + 1, selfClosing: false };
+    if (c === '/' && s[p + 1] === '>') return { name, attrs, close: p + 2, selfClosing: true };
+    const attrStart = p;
+    while (p < end && !/[\s"'>/=]/.test(s[p]!)) p++;
+    if (p === attrStart) {
+      p++; // a stray `/`, quote or `=`
+      continue;
+    }
+    const attrName = s.slice(attrStart, p);
+    let q = p;
+    while (q < end && WS.test(s[q]!)) q++;
+    if (s[q] !== '=') {
+      attrs.push({ name: attrName, value: null, valueStart: -1 });
+      continue;
+    }
+    q++;
+    while (q < end && WS.test(s[q]!)) q++;
+    const quote = s[q];
+    if (quote === '"' || quote === "'") {
+      const closeQuote = s.indexOf(quote, q + 1);
+      const valueEnd = closeQuote === -1 || closeQuote > end ? end : closeQuote;
+      attrs.push({ name: attrName, value: s.slice(q + 1, valueEnd), valueStart: q + 1 });
+      p = valueEnd + 1;
+    } else {
+      const valueStart = q;
+      while (q < end && !/[\s>]/.test(s[q]!)) q++;
+      attrs.push({ name: attrName, value: s.slice(valueStart, q), valueStart });
+      p = q;
+    }
+  }
+  return { name, attrs, close: end, selfClosing: false };
+}
+
+/** Prior token class, as the lexer needs it: what may follow, and what a `/` means. */
+type Prev = 'start' | 'operand' | 'dot' | 'new' | 'decl';
+
+interface Paren {
+  open: number;
+  /** Index in `found` of the call this paren opens, or -1. */
+  call: number;
+  /** The parameter list of a `function`. */
+  params: boolean;
+}
+
+/**
+ * The calls in one template expression `s[start, end)`. `outerLocal` is the
+ * template scope (aliases and slot props in force); arrow and function
+ * parameters bound inside the expression join it as they are met.
+ */
+function scanExpression(
+  s: string,
+  start: number,
+  end: number,
+  outerLocal: (name: string) => boolean,
+  out: VueTemplateCall[]
+): void {
+  const params = new Set<string>();
+  const isLocal = (name: string) => params.has(name) || outerLocal(name);
+  const found: Array<VueTemplateCall & { dropped?: boolean }> = [];
+  const parens: Paren[] = [];
+  let lastGroup: { open: number; close: number } | null = null;
+  let lastIdent = '';
+  let functionPending = false;
+  let prev: Prev = 'start';
+
+  const skipWs = (k: number) => {
+    while (k < end && WS.test(s[k]!)) k++;
+    return k;
+  };
+  const wordEnd = (k: number) => {
+    while (k < end && IDENT_CHAR.test(s[k]!)) k++;
+    return k;
+  };
+  const addParams = (from: number, to: number) => {
+    for (const id of s.slice(from, to).match(IDENTIFIERS) ?? []) params.add(id);
+  };
+
+  let i = start;
+  while (i < end) {
+    const c = s[i]!;
+    if (WS.test(c)) {
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i = skipString(s, i, end);
+      prev = 'operand';
+      continue;
+    }
+    if (c === '`') {
+      i = skipTemplateLiteral(s, i, end, (a, b) => scanExpression(s, a, b, isLocal, out));
+      prev = 'operand';
+      continue;
+    }
+    if (c === '/') {
+      if (s[i + 1] === '/') {
+        const nl = s.indexOf('\n', i);
+        i = nl === -1 || nl > end ? end : nl;
+        continue;
+      }
+      if (s[i + 1] === '*') {
+        const close = s.indexOf('*/', i + 2);
+        i = close === -1 || close > end ? end : close + 2;
+        continue;
+      }
+      if (prev !== 'operand') {
+        i = skipRegex(s, i, end);
+        prev = 'operand';
+        continue;
+      }
+      i++;
+      prev = 'start';
+      continue;
+    }
+    if (/[0-9]/.test(c) || (c === '.' && /[0-9]/.test(s[i + 1] ?? ''))) {
+      i++;
+      while (i < end && /[\w.]/.test(s[i]!)) i++;
+      prev = 'operand';
+      continue;
+    }
+    if (IDENT_START.test(c)) {
+      const wEnd = wordEnd(i);
+      const word = s.slice(i, wEnd);
+      if (prev === 'dot') {
+        // A member tail of something that is not a plain path: `a().b`, `x[0].y`.
+        i = wEnd;
+        prev = 'operand';
+        lastIdent = '';
+        continue;
+      }
+      if (KEYWORDS.has(word)) {
+        i = wEnd;
+        lastIdent = '';
+        if (word === 'new') prev = 'new';
+        else if (word === 'function' || word === 'class') {
+          prev = 'decl';
+          if (word === 'function') functionPending = true;
+        } else prev = VALUE_KEYWORDS.has(word) ? 'operand' : 'start';
+        continue;
+      }
+      if (prev === 'decl') {
+        // A function or class name, not a call.
+        i = wEnd;
+        prev = 'operand';
+        continue;
+      }
+      // The member path rooted here: `a`, `a.b.c`, `a?.b`, TS `a!.b`.
+      const segments = [word];
+      let p = wEnd;
+      for (;;) {
+        let q = skipWs(p);
+        if (s[q] === '!' && s[q + 1] === '.') q++;
+        let r: number;
+        if (s[q] === '.' && s[q + 1] !== '.') r = skipWs(q + 1);
+        else if (s[q] === '?' && s[q + 1] === '.' && !/[0-9]/.test(s[q + 2] ?? '')) r = skipWs(q + 2);
+        else break;
+        if (!IDENT_START.test(s[r] ?? '')) break;
+        const segEnd = wordEnd(r);
+        segments.push(s.slice(r, segEnd));
+        p = segEnd;
+      }
+      // Called? `path(`, or optionally `path?.(`.
+      let q = skipWs(p);
+      if (s[q] === '?' && s[q + 1] === '.' && s[skipWs(q + 2)] === '(') q = skipWs(q + 2);
+      const root = segments[0]!;
+      if (s[q] === '(') {
+        let call = -1;
+        if (prev !== 'new' && !root.startsWith('$') && !TEMPLATE_GLOBALS.has(root) && !isLocal(root)) {
+          found.push({ name: segments.join('.'), offset: i });
+          call = found.length - 1;
+        }
+        parens.push({ open: q, call, params: false });
+        i = q + 1;
+        prev = 'start';
+        lastIdent = '';
+        continue;
+      }
+      i = p;
+      prev = 'operand';
+      lastIdent = segments.length === 1 ? word : '';
+      continue;
+    }
+    // Punctuation.
+    if (c === '(') {
+      parens.push({ open: i, call: -1, params: functionPending });
+      functionPending = false;
+      i++;
+      prev = 'start';
+      continue;
+    }
+    if (c === ')') {
+      const paren = parens.pop();
+      if (paren) {
+        lastGroup = { open: paren.open, close: i };
+        if (paren.params) addParams(paren.open + 1, i);
+        // `{ fmt(v) { … } }` — an object literal's method, not a call.
+        if (paren.call >= 0 && s[skipWs(i + 1)] === '{') found[paren.call]!.dropped = true;
+      }
+      i++;
+      prev = 'operand';
+      lastIdent = '';
+      continue;
+    }
+    if (c === '=' && s[i + 1] === '>') {
+      // Arrow parameters: `(a, { b }) =>` or `a =>`.
+      if (lastIdent) params.add(lastIdent);
+      else if (lastGroup && lastGroup.close === previousNonWs(s, i, start)) addParams(lastGroup.open + 1, lastGroup.close);
+      i += 2;
+      prev = 'start';
+      lastIdent = '';
+      continue;
+    }
+    if (c === '.') {
+      if (s[i + 1] === '.' && s[i + 2] === '.') {
+        i += 3;
+        prev = 'start';
+      } else {
+        i++;
+        prev = 'dot';
+      }
+      lastIdent = '';
+      continue;
+    }
+    if (c === '?' && s[i + 1] === '.' && !/[0-9]/.test(s[i + 2] ?? '')) {
+      i += 2;
+      prev = 'dot';
+      lastIdent = '';
+      continue;
+    }
+    i++;
+    prev = c === ']' || c === '}' ? 'operand' : 'start';
+    lastIdent = '';
+  }
+
+  for (const f of found) if (!f.dropped) out.push({ name: f.name, offset: f.offset });
+}
+
+/** Index of the last non-whitespace character before `i` (not before `floor`). */
+function previousNonWs(s: string, i: number, floor: number): number {
+  let k = i - 1;
+  while (k >= floor && WS.test(s[k]!)) k--;
+  return k;
+}
+
+/** Past a `'…'` / `"…"` string starting at `i`. */
+function skipString(s: string, i: number, end: number): number {
+  const quote = s[i];
+  let k = i + 1;
+  while (k < end) {
+    const c = s[k]!;
+    if (c === '\\') k += 2;
+    else if (c === quote) return k + 1;
+    else k++;
+  }
+  return end;
+}
+
+/** Past a template literal starting at `i`, reporting each `${…}` substitution's range. */
+function skipTemplateLiteral(
+  s: string,
+  i: number,
+  end: number,
+  onSubstitution?: (start: number, end: number) => void
+): number {
+  let k = i + 1;
+  while (k < end) {
+    const c = s[k]!;
+    if (c === '\\') k += 2;
+    else if (c === '`') return k + 1;
+    else if (c === '$' && s[k + 1] === '{') {
+      const close = matchingBrace(s, k + 2, end);
+      onSubstitution?.(k + 2, close);
+      k = close + 1;
+    } else k++;
+  }
+  return end;
+}
+
+/** The `}` closing a brace opened just before `i` (strings and template literals skipped). */
+function matchingBrace(s: string, i: number, end: number): number {
+  let depth = 0;
+  let k = i;
+  while (k < end) {
+    const c = s[k]!;
+    if (c === '"' || c === "'") k = skipString(s, k, end);
+    else if (c === '`') k = skipTemplateLiteral(s, k, end);
+    else if (c === '{') {
+      depth++;
+      k++;
+    } else if (c === '}') {
+      if (depth === 0) return k;
+      depth--;
+      k++;
+    } else k++;
+  }
+  return end;
+}
+
+/** Past a regex literal starting at `i` (a `/` where an operand is expected). */
+function skipRegex(s: string, i: number, end: number): number {
+  let k = i + 1;
+  let inClass = false;
+  while (k < end) {
+    const c = s[k]!;
+    if (c === '\\') {
+      k += 2;
+      continue;
+    }
+    if (c === '\n') return i + 1; // not a regex after all
+    if (c === '[') inClass = true;
+    else if (c === ']') inClass = false;
+    else if (c === '/' && !inClass) {
+      k++;
+      while (k < end && /[a-z]/i.test(s[k]!)) k++;
+      return k;
+    }
+    k++;
+  }
+  return i + 1;
+}
diff --git a/src/extraction/wasm/tree-sitter-cobol.wasm b/src/extraction/wasm/tree-sitter-cobol.wasm
index 12496a95a2..c96722eb93 100755
Binary files a/src/extraction/wasm/tree-sitter-cobol.wasm and b/src/extraction/wasm/tree-sitter-cobol.wasm differ
diff --git a/src/extraction/wasm/tree-sitter-kotlin.wasm b/src/extraction/wasm/tree-sitter-kotlin.wasm
index 8188ae26ba..75ce09a916 100755
Binary files a/src/extraction/wasm/tree-sitter-kotlin.wasm and b/src/extraction/wasm/tree-sitter-kotlin.wasm differ
diff --git a/src/extraction/wasm/tree-sitter-vbnet.wasm b/src/extraction/wasm/tree-sitter-vbnet.wasm
index 365a6c6035..c09cc4746a 100755
Binary files a/src/extraction/wasm/tree-sitter-vbnet.wasm and b/src/extraction/wasm/tree-sitter-vbnet.wasm differ
diff --git a/src/graph/branch-guards.ts b/src/graph/branch-guards.ts
index 76097b6347..bc45ef45e7 100644
--- a/src/graph/branch-guards.ts
+++ b/src/graph/branch-guards.ts
@@ -33,6 +33,7 @@ import * as fs from 'fs';
 import type { Node as SyntaxNode, Tree } from 'web-tree-sitter';
 import type { Language } from '../types';
 import { getParser, loadGrammarsForLanguages } from '../extraction/grammars';
+import { parseWithinBudget } from '../extraction/parse-budget';
 
 // =============================================================================
 // Public shape
@@ -213,7 +214,7 @@ async function parse(source: string, language: Language): Promise<Tree | null> {
     await loadGrammarsForLanguages([language]);
     const parser = getParser(language);
     if (!parser) return null;
-    return parser.parse(source) ?? null;
+    return parseWithinBudget(parser, source);
   } catch {
     return null;
   }
@@ -293,7 +294,7 @@ export function guardsForFileSync(
     } catch {
       return out;
     }
-    const tree = parser.parse(source);
+    const tree = parseWithinBudget(parser, source);
     if (!tree) return out;
     cached = { key, tree, source };
     remember(absPath, cached);
diff --git a/src/graph/cobol-copybooks.ts b/src/graph/cobol-copybooks.ts
new file mode 100644
index 0000000000..a182db82ad
--- /dev/null
+++ b/src/graph/cobol-copybooks.ts
@@ -0,0 +1,122 @@
+/**
+ * COBOL copybooks a query names — one derivation of "the agent asked about
+ * copybook X" (#2342).
+ *
+ * The COBOL extractor records every `COPY X` and `EXEC SQL INCLUDE X` as an
+ * `import` node named X sitting on the include statement, and the resolver
+ * links X to the indexed copybook file (`X.cpy`, …) with an `imports` edge
+ * from the including scope. That `import` node is not the low-information
+ * line an `import { Foo } from './foo'` is in JavaScript: a copybook member
+ * name is how COBOL code is talked about, and the include statement is half of
+ * the answer to a question about it. So a query token that names a copybook
+ * asks for two things:
+ *
+ *  - the copybook's own source, when it is indexed (the record layout, the SQL
+ *    host variables, the shared paragraphs), and
+ *  - every statement that includes it — where that layout is pulled in, which
+ *    is what changing it would touch.
+ *
+ * A member whose source is not in the project (a DB2 DCLGEN member, a
+ * compiler-supplied copybook such as SQLCA or DFHAID) has include sites and no
+ * file, and saying so is part of the answer too: it tells the reader there is
+ * no copybook source here to go looking for.
+ *
+ * Shared by the context builder (entry points for `codegraph_explore` and
+ * `codegraph context`) and by explore's renderer (pinning the copybook, listing
+ * its include sites), so the two read one answer and cannot drift apart.
+ */
+
+import type { Edge, EdgeKind, Node } from '../types';
+
+/** The queries this derivation needs — satisfied by `QueryBuilder`. */
+export interface CopybookLookup {
+  hasFilesOfLanguage(language: string): boolean;
+  getCobolIncludesByMember(member: string, limit: number): Node[];
+  getCobolFilesByStem(member: string): Node[];
+  getIncomingEdges(targetId: string, kinds?: EdgeKind[]): Edge[];
+}
+
+/** One copybook member the query names, with what the index knows about it. */
+export interface NamedCopybook {
+  /** The member as the query spelled it. */
+  member: string;
+  /**
+   * The indexed copybook file(s) the member resolves to — a `.cpy` file, or
+   * any COBOL file an include actually resolved to. Empty when the member's
+   * source is not indexed.
+   */
+  files: Node[];
+  /** Every `COPY` / `EXEC SQL INCLUDE` statement naming the member, in file/line order. */
+  includes: Node[];
+}
+
+/**
+ * Most include statements gathered per member. A shared copybook in a large
+ * estate is included by hundreds of programs; past this the list is a count.
+ */
+export const MAX_COPYBOOK_INCLUDES = 200;
+
+/** Most query tokens looked up — a pasted paragraph must not become 200 probes. */
+const MAX_MEMBER_TOKENS = 16;
+
+/**
+ * A COBOL word: letters, digits, hyphens and the national characters `$ # @`
+ * (`CVACT01Y`, `CUST-REC`, `DFH$AID`). Wider than the identifier shapes the
+ * generic symbol extraction knows — a copybook name with a digit in it
+ * (`CVACT01Y`) was never extracted as a symbol at all.
+ */
+const COBOL_WORD = /[A-Za-z0-9$#@][A-Za-z0-9$#@-]*/g;
+
+/**
+ * The query's tokens that could name a copybook member. In a longer query a
+ * plain lowercase word is skipped: `customer` in a prose question is English,
+ * while a member name is written the way the code writes it (`CUSTOMER`,
+ * `cvact01y`) — the same rule explore's own symbol seeding applies to bare
+ * words. A query that is one word is a name lookup whatever its case
+ * (`lgpolicy`, after the file `lgpolicy.cpy`).
+ */
+export function copybookMemberTokens(query: string): string[] {
+  const words = (query.match(COBOL_WORD) ?? []).map((raw) => raw.replace(/-+$/, ''));
+  const lone = words.length === 1;
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const token of words) {
+    if (token.length < 3 || !/[A-Za-z]/.test(token) || (!lone && /^[a-z]+$/.test(token))) continue;
+    const key = token.toUpperCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(token);
+    if (out.length >= MAX_MEMBER_TOKENS) break;
+  }
+  return out;
+}
+
+/**
+ * Is this node a COBOL copybook include — the statement `COPY X` /
+ * `EXEC SQL INCLUDE X` — rather than an import in any other language?
+ */
+export function isCopybookInclude(node: Pick<Node, 'kind' | 'language'>): boolean {
+  return node.kind === 'import' && node.language === 'cobol';
+}
+
+/**
+ * The copybooks `query` names. A token qualifies when the index holds a COBOL
+ * include of that member or a copybook file with that name. A project without
+ * COBOL answers after one index seek, so every other language's queries are
+ * untouched.
+ */
+export function findNamedCopybooks(lookup: CopybookLookup, query: string): NamedCopybook[] {
+  const tokens = copybookMemberTokens(query);
+  if (tokens.length === 0 || !lookup.hasFilesOfLanguage('cobol')) return [];
+  const named: NamedCopybook[] = [];
+  for (const member of tokens) {
+    const includes = lookup.getCobolIncludesByMember(member, MAX_COPYBOOK_INCLUDES);
+    // A same-named PROGRAM (`COACTUPC.cbl` for the query `COACTUPC`) is not a
+    // copybook: only a `.cpy` file, or a file some include resolved to, is.
+    const files = lookup.getCobolFilesByStem(member).filter((file) =>
+      /\.cpy$/i.test(file.filePath) || lookup.getIncomingEdges(file.id, ['imports']).length > 0);
+    if (includes.length === 0 && files.length === 0) continue;
+    named.push({ member, files, includes });
+  }
+  return named;
+}
diff --git a/src/graph/dead-code.ts b/src/graph/dead-code.ts
index 5dce8f6db1..d712a00009 100644
--- a/src/graph/dead-code.ts
+++ b/src/graph/dead-code.ts
@@ -17,7 +17,12 @@
  * candidate is dropped from the list the moment there is any reason to believe
  * something outside the graph reaches it:
  *
- * - it is **exported** (something outside this repository may import it);
+ * - it is **exported** (something outside this repository may import it). That
+ *   includes whatever a TypeScript `declare module 'x'` or `declare global`
+ *   block declares, which TypeScript exports without the keyword: `interface
+ *   Window` or chart.js's `PluginOptionsByType` merges into a type declared
+ *   outside the index, and the runtime or the library reads it through that
+ *   type, so nothing in the repository names it;
  * - it lives in a **test** or a **generated** file (not code anyone deletes by
  *   hand);
  * - it is **abstract** or declared on an interface (a declaration is dispatched
@@ -25,11 +30,18 @@
  * - it is **decorated** (`@app.route`, `@Component`, `@EventHandler`) — a
  *   decorator is a registration, and the framework that reads it is not in the
  *   graph. Seen as the symbol's own outgoing `decorates` edge, which is where
- *   the engine records it; `node.decorators` is only populated by a couple of
- *   languages and is checked as well rather than instead;
+ *   the engine records it, or, for a decorator imported from outside the index
+ *   (`@HostListener`, `@Cron`), as the resolver's unresolved `decorates` row —
+ *   the same record the ancestor rule below reads for a supertype it could not
+ *   follow. `node.decorators` is only populated by a couple of languages and is
+ *   checked as well rather than instead;
  * - it **overrides** a member an ancestor declares (calls land on the ancestor;
  *   see {@link overrideCandidates} for why an ancestor we cannot read counts
  *   the same way);
+ * - it is a **hook its framework calls by name**: `ngOnInit` on a component
+ *   that never writes `implements OnInit`. Which names are hooks is not kept in
+ *   a table here — the index already says it, in what the classes that DO
+ *   write the interface out declare (see {@link byNameHookCandidates});
  * - it has a name the language calls by itself (`constructor`, `__enter__`,
  *   `main`);
  * - it sits in a **vendored** directory (`vendor/`, `third_party/`,
@@ -90,7 +102,7 @@
 import fs from 'fs';
 import path from 'path';
 import type CodeGraph from '../index';
-import type { Node, NodeKind } from '../types';
+import type { EdgeKind, Node, NodeKind } from '../types';
 import { isTestFile } from '../search/query-utils';
 
 // =============================================================================
@@ -184,6 +196,18 @@ const OVERRIDABLE_KINDS: ReadonlySet<NodeKind> = new Set<NodeKind>([
   'field',
 ]);
 
+/**
+ * Languages whose `implements` clause is erased before the program runs, so a
+ * framework that calls an interface's member can only be finding it by name —
+ * the premise of {@link byNameHookCandidates}. Java, C#, Kotlin and the rest
+ * check the interface itself: Spring never calls `afterPropertiesSet` on a
+ * bean that merely has a method of that name.
+ */
+const BY_NAME_DISPATCH_LANGUAGES: ReadonlySet<string> = new Set(['typescript', 'tsx']);
+
+/** Member kinds a framework calls as a hook. */
+const HOOK_KINDS: readonly NodeKind[] = ['method', 'function'];
+
 /**
  * Names a language or a runtime calls without anything in the source naming
  * them.
@@ -193,7 +217,8 @@ const OVERRIDABLE_KINDS: ReadonlySet<NodeKind> = new Set<NodeKind>([
  * stale, and it would hide real dead code behind a name coincidence. The
  * entries below are the ones where the *language itself* does the calling, so
  * no source file could name them even in principle. Framework hooks are caught
- * by the decorator and override rules instead, which are structural.
+ * by the decorator, override and by-name hook rules instead, which are
+ * structural.
  */
 const IMPLICIT_ENTRY_NAMES: ReadonlySet<string> = new Set([
   'constructor',
@@ -333,7 +358,11 @@ export interface DeadCodeExclusions {
   tests: number;
   /** In a tool-generated file. */
   generated: number;
-  /** Exported, or declared in a header — reachable from outside this index. */
+  /**
+   * Exported, or declared in a header — reachable from outside this index. A
+   * TypeScript `declare module` / `declare global` declaration is exported
+   * implicitly: it merges into a library's or the global scope's type.
+   */
   exported: number;
   /**
    * In a language this index records no export marker for, so nothing here can
@@ -346,6 +375,12 @@ export interface DeadCodeExclusions {
   decorated: number;
   /** Overrides a member an ancestor declares, or an ancestor we cannot read. */
   overriding: number;
+  /**
+   * A hook its framework calls by name, on a class that skips the interface:
+   * the class carries a decorator, and the name is one an interface outside
+   * the index carries, going by the classes that write it out.
+   */
+  hooks: number;
   /** Named something the language calls by itself. */
   implicit: number;
   /** In a vendored directory — carried code, reached by something outside the index. */
@@ -437,6 +472,7 @@ export function buildDeadCodeReport(cg: CodeGraph, query: DeadCodeQuery = {}): D
     declarations: 0,
     decorated: 0,
     overriding: 0,
+    hooks: 0,
     implicit: 0,
     vendored: 0,
     testScope: 0,
@@ -508,14 +544,7 @@ export function buildDeadCodeReport(cg: CodeGraph, query: DeadCodeQuery = {}): D
   // A `decorates` edge runs FROM the decorated symbol to the decorator, so
   // this is an outgoing-edge question, not something the candidate query could
   // have answered.
-  const decorated = new Set(
-    cg
-      .getOutgoingEdgesFrom(
-        surviving.map((row) => row.node.id),
-        ['decorates']
-      )
-      .map((edge) => edge.source)
-  );
+  const decorated = carriesDecorator(cg, surviving.map((row) => row.node));
   const containers = containersOf(cg, surviving.map((row) => row.node));
   const overriding = overrideCandidates(cg, surviving.map((row) => row.node), containers);
   // One batched count for every file still in play. A file nothing reaches is
@@ -532,10 +561,19 @@ export function buildDeadCodeReport(cg: CodeGraph, query: DeadCodeQuery = {}): D
   const names = surviving.map((row) => row.node.name);
   const unresolved = cg.getUnresolvedNamesAmong(names);
   const ambiguousNames = cg.getAmbiguousReferencedNames(names);
+  // Asked only about the members no earlier rule in the loop below drops.
+  const hooks = byNameHookCandidates(
+    cg,
+    surviving
+      .map((row) => row.node)
+      .filter((node) => !decorated.has(node.id) && !overriding.has(node.id)),
+    containers,
+    candidates.map((row) => row.node)
+  );
 
   const kept: Array<{ node: Node; generated: boolean }> = [];
   for (const row of surviving) {
-    if (decorated.has(row.node.id) || (row.node.decorators?.length ?? 0) > 0) {
+    if (decorated.has(row.node.id)) {
       excluded.decorated += 1;
       continue;
     }
@@ -548,6 +586,10 @@ export function buildDeadCodeReport(cg: CodeGraph, query: DeadCodeQuery = {}): D
       excluded.overriding += 1;
       continue;
     }
+    if (hooks.has(row.node.id)) {
+      excluded.hooks += 1;
+      continue;
+    }
     if (unresolved.has(row.node.name)) {
       excluded.unresolvedName += 1;
       continue;
@@ -814,44 +856,8 @@ function overrideCandidates(
   const containerIds = [...new Set([...containers.values()].map((node) => node.id))];
   if (containerIds.length === 0) return dropped;
 
-  // Level-by-level upward walk over EVERY container at once: one query per
-  // level rather than one per container. `reach` maps an ancestor back to the
-  // containers it is an ancestor of.
-  const reach = new Map<string, Set<string>>();
-  const seen = new Map(containerIds.map((id) => [id, new Set([id])]));
-  let frontier = containerIds.map((id) => ({ id, roots: new Set<string>([id]) }));
-
-  for (let depth = 0; depth < MAX_OVERRIDE_ANCESTOR_DEPTH && frontier.length > 0; depth++) {
-    const rootsOf = new Map(frontier.map((item) => [item.id, item.roots]));
-    const edges = cg.getOutgoingEdgesFrom(
-      frontier.map((item) => item.id),
-      ['extends', 'implements']
-    );
-    const next = new Map<string, Set<string>>();
-    for (const edge of edges) {
-      if (edge.target === edge.source) continue;
-      const roots = rootsOf.get(edge.source);
-      if (!roots) continue;
-      const merged = next.get(edge.target) ?? new Set<string>();
-      const visited = seen.get(edge.target) ?? new Set<string>();
-      const known = reach.get(edge.target) ?? new Set<string>();
-      // An ancestor may already be a candidate root. Only skip pairs we have
-      // propagated, so later descendants still reach all of its ancestors.
-      for (const root of roots) {
-        if (visited.has(root)) continue;
-        visited.add(root);
-        merged.add(root);
-        known.add(root);
-      }
-      seen.set(edge.target, visited);
-      if (merged.size > 0) next.set(edge.target, merged);
-      if (known.size > 0) reach.set(edge.target, known);
-    }
-    frontier = [];
-    for (const [id, roots] of next) {
-      frontier.push({ id, roots });
-    }
-  }
+  // `reach` maps an ancestor back to the containers it is an ancestor of.
+  const reach = ancestorsOf(cg, containerIds, ['extends', 'implements']);
 
   const opaqueContainers = new Set<string>();
   const externalBased = cg.getUnresolvedSupertypeSourcesAmong([...containerIds, ...reach.keys()]);
@@ -901,3 +907,208 @@ function overrideCandidates(
   }
   return dropped;
 }
+
+/**
+ * Every ancestor of `ids` along `kinds` edges, mapped back to the ids it is an
+ * ancestor of. A level-by-level upward walk over EVERY id at once — one query
+ * per level rather than one per id — up to {@link MAX_OVERRIDE_ANCESTOR_DEPTH}.
+ */
+function ancestorsOf(
+  cg: CodeGraph,
+  ids: readonly string[],
+  kinds: EdgeKind[]
+): Map<string, Set<string>> {
+  const reach = new Map<string, Set<string>>();
+  const seen = new Map(ids.map((id) => [id, new Set([id])]));
+  let frontier = ids.map((id) => ({ id, roots: new Set<string>([id]) }));
+
+  for (let depth = 0; depth < MAX_OVERRIDE_ANCESTOR_DEPTH && frontier.length > 0; depth++) {
+    const rootsOf = new Map(frontier.map((item) => [item.id, item.roots]));
+    const edges = cg.getOutgoingEdgesFrom(
+      frontier.map((item) => item.id),
+      kinds
+    );
+    const next = new Map<string, Set<string>>();
+    for (const edge of edges) {
+      if (edge.target === edge.source) continue;
+      const roots = rootsOf.get(edge.source);
+      if (!roots) continue;
+      const merged = next.get(edge.target) ?? new Set<string>();
+      const visited = seen.get(edge.target) ?? new Set<string>();
+      const known = reach.get(edge.target) ?? new Set<string>();
+      // An ancestor may already be a root. Only skip pairs we have propagated,
+      // so later descendants still reach all of its ancestors.
+      for (const root of roots) {
+        if (visited.has(root)) continue;
+        visited.add(root);
+        merged.add(root);
+        known.add(root);
+      }
+      seen.set(edge.target, visited);
+      if (merged.size > 0) next.set(edge.target, merged);
+      if (known.size > 0) reach.set(edge.target, known);
+    }
+    frontier = [];
+    for (const [id, roots] of next) {
+      frontier.push({ id, roots });
+    }
+  }
+  return reach;
+}
+
+/**
+ * Which of `nodes` carry a decorator: their own outgoing `decorates` edge, an
+ * unresolved `decorates` row (the only trace a decorator imported from outside
+ * the index, like `@HostListener` or `@Cron`, leaves), or the `decorators`
+ * list a couple of languages record on the node itself.
+ */
+function carriesDecorator(cg: CodeGraph, nodes: readonly Node[]): Set<string> {
+  const ids = nodes.map((node) => node.id);
+  const found = new Set(cg.getOutgoingEdgesFrom(ids, ['decorates']).map((edge) => edge.source));
+  for (const id of cg.getUnresolvedReferenceNamesFrom(ids, ['decorates']).keys()) found.add(id);
+  for (const node of nodes) if ((node.decorators?.length ?? 0) > 0) found.add(node.id);
+  return found;
+}
+
+/**
+ * Which members are hooks their framework calls by name — the ids to drop.
+ *
+ * Angular calls `ngOnInit` on every component it creates, and NestJS calls
+ * `onModuleInit` on every provider, whether or not the class writes
+ * `implements OnInit`: TypeScript erases the clause, so the framework can only
+ * be finding the method by its name. A class that writes the clause is already
+ * off the list, because its ancestor is outside the index
+ * ({@link overrideCandidates}). One that skips it is tied to the framework by
+ * nothing but the name.
+ *
+ * Which names are hooks is not a table kept here; a table would go stale and
+ * hide real dead code behind a name coincidence. The index says it already:
+ * what `OnInit` carries is what the classes that DO write `implements OnInit`
+ * have. A method is dropped when all of this holds:
+ *
+ * - **its class carries a decorator**, so a framework creates it
+ *   (`@Component`, `@Injectable`). Nothing creates an undecorated class, so
+ *   nothing calls its hooks. And the class's decorator says nothing about its
+ *   other methods: an unused helper on a component stays on the list;
+ * - **an interface outside the index carries the name**. Every TypeScript class
+ *   that writes the interface into an `implements` clause has a method of that
+ *   name, declared or inherited from an ancestor that declares it, which is
+ *   what TypeScript itself checks; a class that inherits from outside the index
+ *   may have it from there, so it is no evidence either way. At least two of
+ *   them, and more than half, declare it themselves: one class's methods are
+ *   that class, not a contract, and a name that only a few declare while the
+ *   rest are unreadable is not evidence of one either;
+ * - **more than half of those classes carry a decorator** as well: the
+ *   interface is one that framework-created classes fill, not a library type
+ *   whose method happens to share the name.
+ *
+ * TypeScript only — see {@link BY_NAME_DISPATCH_LANGUAGES}.
+ */
+function byNameHookCandidates(
+  cg: CodeGraph,
+  nodes: readonly Node[],
+  containers: ReadonlyMap<string, Node>,
+  unreferenced: readonly Node[]
+): Set<string> {
+  const dropped = new Set<string>();
+  const isHookShaped = (node: Node): boolean =>
+    HOOK_KINDS.includes(node.kind) && BY_NAME_DISPATCH_LANGUAGES.has(node.language);
+  const methods = nodes.filter(
+    (node) => isHookShaped(node) && containers.get(node.id)?.kind === 'class'
+  );
+  if (methods.length === 0) return dropped;
+
+  const classes = new Map<string, Node>();
+  for (const node of methods) {
+    const container = containers.get(node.id);
+    if (container) classes.set(container.id, container);
+  }
+  const registered = carriesDecorator(cg, [...classes.values()]);
+  const eligible = methods.filter((node) => registered.has(containers.get(node.id)?.id ?? ''));
+  if (eligible.length === 0) return dropped;
+
+  // Every class declaring a method of each name. A hook is called by its
+  // framework and never by the code in the index, so each class's own
+  // declaration of it is unreferenced too: it is in `unreferenced` already, and
+  // the index need not be searched by name. (A name with a declaration that
+  // something does call is the ambiguous-name rule's, which drops every
+  // candidate of that name.)
+  const names = new Set(eligible.map((node) => node.name));
+  const declarations = unreferenced.filter((node) => names.has(node.name) && isHookShaped(node));
+  const declaredIn = containersOf(
+    cg,
+    declarations.filter((node) => !containers.has(node.id))
+  );
+  const declaring = new Map<string, Set<string>>();
+  for (const node of declarations) {
+    const container = containers.get(node.id) ?? declaredIn.get(node.id);
+    if (container?.kind !== 'class') continue;
+    const ids = declaring.get(node.name);
+    if (ids) ids.add(container.id);
+    else declaring.set(node.name, new Set([container.id]));
+  }
+
+  // The interfaces outside the index each of those classes writes out.
+  const declarers = new Set([...declaring.values()].flatMap((ids) => [...ids]));
+  const interfacesOf = cg.getUnresolvedReferenceNamesFrom(declarers, ['implements']);
+  const interfaces = new Set([...interfacesOf.values()].flat());
+  if (interfaces.size === 0) return dropped;
+
+  // Every TypeScript class writing each of those interfaces out, kept where
+  // more than half of them are framework-created.
+  const writers = cg.getUnresolvedReferenceSourcesNamed(interfaces, ['implements']);
+  const writerIds = [...new Set([...writers.values()].flatMap((ids) => [...ids]))];
+  const typescript = [...cg.getNodesByIds(writerIds).values()].filter((node) =>
+    BY_NAME_DISPATCH_LANGUAGES.has(node.language)
+  );
+  const typescriptIds = new Set(typescript.map((node) => node.id));
+  const registeredWriters = carriesDecorator(cg, typescript);
+  const implementers = new Map<string, string[]>();
+  for (const [name, ids] of writers) {
+    const own = [...ids].filter((id) => typescriptIds.has(id));
+    const registeredCount = own.filter((id) => registeredWriters.has(id)).length;
+    if (registeredCount > own.length / 2) implementers.set(name, own);
+  }
+  if (implementers.size === 0) return dropped;
+
+  // What each implementer inherits from, and which inherit from outside the
+  // index somewhere up the chain.
+  const implementerIds = [...new Set([...implementers.values()].flat())];
+  const ancestors = ancestorsOf(cg, implementerIds, ['extends']);
+  const inherits = new Map<string, string[]>();
+  for (const [ancestor, roots] of ancestors) {
+    for (const root of roots) {
+      const bucket = inherits.get(root);
+      if (bucket) bucket.push(ancestor);
+      else inherits.set(root, [ancestor]);
+    }
+  }
+  const outside = cg.getUnresolvedReferenceNamesFrom([...implementerIds, ...ancestors.keys()], ['extends']);
+  const opaque = new Set(implementerIds.filter((id) => outside.has(id)));
+  for (const [ancestor, roots] of ancestors) {
+    if (outside.has(ancestor)) for (const root of roots) opaque.add(root);
+  }
+
+  const hookNames = new Set<string>();
+  for (const name of names) {
+    const declared = declaring.get(name);
+    if (!declared) continue;
+    const has = (id: string): boolean =>
+      declared.has(id) ||
+      opaque.has(id) ||
+      (inherits.get(id) ?? []).some((ancestor) => declared.has(ancestor));
+    const contracts = new Set([...declared].flatMap((id) => interfacesOf.get(id) ?? []));
+    for (const contract of contracts) {
+      const own = implementers.get(contract);
+      if (!own) continue;
+      const declaredCount = own.filter((id) => declared.has(id)).length;
+      if (declaredCount >= 2 && declaredCount > own.length / 2 && own.every(has)) {
+        hookNames.add(name);
+        break;
+      }
+    }
+  }
+
+  for (const node of eligible) if (hookNames.has(node.name)) dropped.add(node.id);
+  return dropped;
+}
diff --git a/src/graph/named-symbol-flow.ts b/src/graph/named-symbol-flow.ts
index a83edf2d82..956c43ee59 100644
--- a/src/graph/named-symbol-flow.ts
+++ b/src/graph/named-symbol-flow.ts
@@ -287,7 +287,14 @@ export function resolveNamedTokens(
 ): NamedSymbolFlow {
   const directed = opts.mode === 'directed';
   const out = EMPTY_FLOW();
-  const tokens = flowTokens(query);
+  // A directed question names its two ends exactly — a symbol's own name, as
+  // the viewer's links write it: an Objective-C selector (`initWithFrame:`), a
+  // Ruby predicate (`valid?`), a two-letter method (`ok`, Go's `Do`). The
+  // free-text filter below is for explore's bag of words, and it dropped every
+  // one of those, leaving the other end reported as naming nothing.
+  const tokens = directed && opts.from && opts.to
+    ? [...new Set([normalizeToken(opts.from), normalizeToken(opts.to)])]
+    : flowTokens(query);
   out.tokens = tokens;
   if (tokens.length < 2) return out;
 
@@ -382,6 +389,19 @@ function callSitesOf(steps: readonly FlowStep[]): Map<string, number> {
 const NAMED_VISIT_CAP = 1500;
 const DIRECTED_VISIT_CAP = 12_000;
 
+/** How the `named` walk reached a node, and what the route there carries. */
+interface WalkStep {
+  prev: string | null;
+  edge: Edge | null;
+  node: Node;
+  /** Hops from the seed. */
+  depth: number;
+  /** Unnamed hops the route ends on, held against `maxBridge`. */
+  streak: number;
+  /** Named symbols on the route, the seed and this node included. */
+  named: number;
+}
+
 /**
  * Breadth-first over `calls` edges — synthesized ones included, which is what
  * carries a flow across a callback, a re-render or a JSX child.
@@ -390,6 +410,19 @@ const DIRECTED_VISIT_CAP = 12_000;
  * at most `maxBridge` unnamed symbols may sit between two of them. That cap is
  * what bounds the frontier, so {@link NAMED_VISIT_CAP} is generous.
  *
+ * Two routes of the same length to one node are settled by the agent's naming,
+ * not by the order the index lists callees in: the route through more named
+ * symbols wins. An interface method calls every implementation, so
+ * prometheus's `Queryable.Querier` reaches `NewMergeQuerier` through
+ * `fanout.Querier` and the TSDB's `DB.Querier` alike; keeping whichever was
+ * listed first took the Flow through `DB.Querier` when the query named
+ * `fanout.Querier`. A rival route comes from another node at the same depth,
+ * and every node at one depth is expanded before any node at the next, so the
+ * choice is final before anything is reached through it. Ending on fewer
+ * unnamed hops ranks first, so a choice never spends bridge budget that a later
+ * hop needs (with the default budget of one, only a route node's streak can
+ * differ).
+ *
  * Returns the parent map, so a caller can reconstruct any reached node's path.
  */
 function walkCalls(
@@ -398,25 +431,41 @@ function walkCalls(
   named: ReadonlySet<string>,
   maxHops: number,
   maxBridge: number
-): { parent: Map<string, { prev: string | null; edge: Edge | null; node: Node }>; reached: string[] } {
-  const parent = new Map<string, { prev: string | null; edge: Edge | null; node: Node }>();
-  parent.set(seed.id, { prev: null, edge: null, node: seed });
-  const queue: Array<{ id: string; depth: number; streak: number }> = [
-    { id: seed.id, depth: 0, streak: 0 },
-  ];
+): { parent: Map<string, WalkStep>; reached: string[] } {
+  const parent = new Map<string, WalkStep>();
+  parent.set(seed.id, {
+    prev: null,
+    edge: null,
+    node: seed,
+    depth: 0,
+    streak: 0,
+    named: named.has(seed.id) ? 1 : 0,
+  });
+  const queue: string[] = [seed.id];
   const reached: string[] = [];
   for (let head = 0; head < queue.length && parent.size < NAMED_VISIT_CAP; head++) {
-    const { id, depth, streak } = queue[head]!;
+    const id = queue[head]!;
+    const at = parent.get(id)!;
     if (id !== seed.id && named.has(id)) reached.push(id);
-    if (depth >= maxHops - 1) continue;
+    if (at.depth >= maxHops - 1) continue;
     for (const c of cg.getCallees(id)) {
-      if (!FLOW_EDGE_KINDS.has(c.edge.kind) || parent.has(c.node.id)) continue;
+      if (!FLOW_EDGE_KINDS.has(c.edge.kind)) continue;
+      const isNamed = named.has(c.node.id);
       // A route node is a connector, not a symbol the reader would have named:
       // crossing one costs no bridge budget.
-      const newStreak = named.has(c.node.id) ? 0 : c.node.kind === 'route' ? streak : streak + 1;
-      if (newStreak > maxBridge) continue;
-      parent.set(c.node.id, { prev: id, edge: c.edge, node: c.node });
-      queue.push({ id: c.node.id, depth: depth + 1, streak: newStreak });
+      const streak = isNamed ? 0 : c.node.kind === 'route' ? at.streak : at.streak + 1;
+      if (streak > maxBridge) continue;
+      const depth = at.depth + 1;
+      const namedOnRoute = at.named + (isNamed ? 1 : 0);
+      const prior = parent.get(c.node.id);
+      if (prior) {
+        // Reached already: only a better route of the same length replaces it.
+        if (prior.depth !== depth) continue;
+        if (streak > prior.streak || (streak === prior.streak && namedOnRoute <= prior.named)) continue;
+      } else {
+        queue.push(c.node.id);
+      }
+      parent.set(c.node.id, { prev: id, edge: c.edge, node: c.node, depth, streak, named: namedOnRoute });
     }
   }
   return { parent, reached };
@@ -589,13 +638,20 @@ export function resolveNamedSymbolFlow(
     } else {
       for (const seed of [...flow.named.values()].slice(0, MAX_SEEDS)) {
         const { parent, reached } = walkCalls(cg, seed, namedIds, maxHops, maxBridge);
-        // Explore's rule: the DEEPEST named sink this seed can reach.
-        let deepest: FlowStep[] | null = null;
+        // Explore's rule: the DEEPEST named sink this seed can reach. Of two as
+        // deep, the one whose route passes more named symbols, as in the walk.
+        let deepest: WalkStep | null = null;
         for (const id of reached) {
-          const steps = chainTo(parent, id);
-          if (!deepest || steps.length > deepest.length) deepest = steps;
+          const at = parent.get(id)!;
+          if (
+            !deepest ||
+            at.depth > deepest.depth ||
+            (at.depth === deepest.depth && at.named > deepest.named)
+          ) {
+            deepest = at;
+          }
         }
-        if (deepest) found.push(deepest);
+        if (deepest) found.push(chainTo(parent, deepest.node.id));
       }
     }
 
diff --git a/src/index.ts b/src/index.ts
index 5dd5865157..7e51047b25 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -25,10 +25,12 @@ import {
   BuildContextOptions,
   FindRelevantContextOptions,
   UnresolvedReference,
+  IndexHealth,
 } from './types';
 import { DatabaseConnection, getDatabasePath, removeDatabaseFiles } from './db';
 import { WalCheckpointValve, resolveWalValveMb } from './db/wal-valve';
 import { QueryBuilder } from './db/queries';
+import { importPathKeys, moduleReferenceKeys } from './db/reference-tail';
 import {
   isInitialized,
   createDirectory,
@@ -43,13 +45,16 @@ import {
   extractFromSource,
   initGrammars,
 } from './extraction';
+import { detectLanguage, hasGrammarLoadFailure, isFileLevelOnlyLanguage } from './extraction/grammars';
 import {
   ReferenceResolver,
+  changedRoutes,
   createResolver,
   ResolutionResult,
 } from './resolution';
 import { hasSynthesisPattern } from './resolution/callback-synthesizer';
 import { GraphTraverser, GraphQueryManager } from './graph';
+import { findNamedCopybooks, type NamedCopybook } from './graph/cobol-copybooks';
 import { ContextBuilder, createContextBuilder } from './context';
 import { Mutex, FileLock } from './utils';
 import { FileWatcher, WatchOptions, PendingFile, LockUnavailableError } from './sync';
@@ -511,6 +516,7 @@ export class CodeGraph {
    */
   async indexAll(options: IndexOptions = {}): Promise<IndexResult> {
     return this.indexMutex.withLock(async () => {
+      const startedAt = Date.now();
       try {
         this.fileLock.acquire();
       } catch {
@@ -772,6 +778,10 @@ export class CodeGraph {
           }
         } catch { /* metadata is advisory — never fail an index over it */ }
 
+        // The time covers the whole run, like the totals above. The
+        // orchestrator's covers extraction alone, and the summary printed it
+        // as the run's, leaving out resolution and linking (#2334).
+        result.durationMs = Date.now() - startedAt;
         return result;
       } finally {
         // Restore the auto-checkpoint interval AFTER the fold-up above so the
@@ -824,6 +834,7 @@ export class CodeGraph {
    */
   async sync(options: IndexOptions = {}): Promise<SyncResult> {
     return this.indexMutex.withLock(async () => {
+      const startedAt = Date.now();
       try {
         this.fileLock.acquire();
       } catch (err) {
@@ -912,8 +923,15 @@ export class CodeGraph {
         let refreshSynthesis = this.queries.getMetadata('synthesis_pending') === '1' ||
           this.queries.getUnresolvedReferencesCount() > 0;
         if (refreshSynthesis) this.queries.setMetadata('synthesis_pending', '1');
+        // The route nodes as they were before this sync replaced or removed a
+        // file — read at the first change, so a sync that changes nothing
+        // reads nothing, and only where a router binds navigation calls to
+        // routes. Compared with the routes after runPostExtract below.
+        const watchRoutes = this.resolver.hasNavigationRouters();
+        let routesBefore = null as Node[] | null;
         const result = await this.orchestrator.sync(options.onProgress, options.paths, backpressure,
           (filePath, content) => {
+            if (watchRoutes && routesBefore === null) routesBefore = this.queries.getNodesByKind('route');
             if (!refreshSynthesis && (this.queries.hasSynthesizedEdgesTouchingFile(filePath) ||
               this.queries.wasSynthesisInput(filePath) ||
               (content !== undefined && hasSynthesisPattern(filePath, content)))) {
@@ -930,18 +948,39 @@ export class CodeGraph {
         // Cross-file finalization (e.g. NestJS RouterModule prefixes). Run on
         // every sync that touched files so edits to `app.module.ts` propagate
         // to controllers in unchanged files. The pass is idempotent and cheap
-        // (regex over *.module.ts only).
-        if (result.filesAdded > 0 || result.filesModified > 0) {
+        // (regex over *.module.ts only). A removal counts too: deleting the
+        // file that hands a React Router table to the router leaves the
+        // table's routes behind unless this pass runs to take them away.
+        // (A pure-removal sync still resolves refs below — the deletion path
+        // resurrects the removed file's incoming edges as pending refs, #1240
+        // removal case — and runPostExtract starts by dropping the resolver's
+        // name caches, which a long-lived daemon warmed against the
+        // pre-removal graph.)
+        if (result.filesAdded > 0 || result.filesModified > 0 || result.filesRemoved > 0) {
           this.resolver.runPostExtract();
-        } else if (result.filesRemoved > 0) {
-          // A pure-removal sync still resolves refs below — the deletion path
-          // resurrects the removed file's incoming edges as pending refs
-          // (#1240 removal case) and the orphan sweep consumes them. In a
-          // long-lived process (daemon) the resolver's name caches were
-          // warmed against the pre-removal graph; drop them so resolution
-          // sees the post-removal state. (runPostExtract above clears caches
-          // itself, so the changed-files branch is already covered.)
-          this.resolver.clearCaches();
+        }
+
+        // A route that appeared, went away or was renamed changes what a
+        // navigation call in an UNCHANGED file resolves to: `history.push(
+        // '/login')` binds again once `/login` is back. While the route was
+        // missing the call was parked as failed, or bound to a catch-all, and
+        // nothing below revisits it: the retry keys on the names this sync's
+        // files define, which a call named for the router's method (`push`)
+        // never matches. Put those calls back in the pending set for the sweep
+        // below, and let the synthesizers redraw the links markup makes to
+        // routes. The route table is final here: renames and table routes are
+        // runPostExtract's.
+        if (routesBefore) {
+          const tNav = Date.now();
+          const routes = changedRoutes(routesBefore, this.queries.getNodesByKind('route'));
+          const reopened = this.resolver.reopenNavigationsFor(routes, result.changedFilePaths ?? []);
+          if (routes.length > 0 && !refreshSynthesis) {
+            refreshSynthesis = true;
+            this.queries.setMetadata('synthesis_pending', '1');
+          }
+          if (process.env.CODEGRAPH_SYNTH_TIMINGS) {
+            console.error(`[phase-timing] sync-navigation-retry: ${Date.now() - tNav}ms (${routes.length} routes changed, ${reopened} refs re-opened)`);
+          }
         }
 
         // Resolve references if files were updated
@@ -974,12 +1013,40 @@ export class CodeGraph {
             // now resolve, and nothing else ever revisits them (their rows
             // were parked as status='failed' by an earlier completed pass).
             // Look them up by the symbol names the changed files now carry
-            // and re-resolve just that set. On a sync where no failed ref
-            // matches, this is one indexed lookup.
+            // and re-resolve just that set. The names include each file's
+            // own, which a reference written as a path
+            // (`snippets/price.liquid`) waits under, and the keys a route's
+            // lazily loaded module waits under (`module:Team` for
+            // `lazy-import:./pages/Team`), as does a reference through an
+            // import binding the module declares under another name
+            // (`module:tag` for `import tagsController from
+            // './tag/tag.controller'`): each resolves through the module, so
+            // an edit can satisfy it as well as an added file. On a sync
+            // where no failed ref matches, this is one indexed lookup.
             const tRetry = Date.now();
-            const retryable = this.queries.getRetryableFailedReferences(
-              this.queries.getNodeNamesByFiles(result.changedFilePaths)
+            const retryable = this.queries.getRetryableFailedReferences([...new Set([
+              ...this.queries.getNodeNamesByFiles(result.changedFilePaths),
+              ...result.changedFilePaths.flatMap(moduleReferenceKeys),
+            ])]);
+            // A failed import waits for a file, a folder or a namespace, not a
+            // symbol: `package:app/b.dart` for a file named `b.dart`, `./ui`
+            // for `ui/index.ts`, `using Foo.Bar` for that namespace's node.
+            // Look those up by what the ADDED files can be imported as (a
+            // modified file was already there for any import of it), and by
+            // the namespaces and modules the changed files declare.
+            const retryRows = new Set(retryable.map((ref) => ref.rowId));
+            const importRetry = this.queries.getRetryableFailedImports(
+              (result.addedFilePaths ?? []).flatMap(importPathKeys),
+              this.queries.getNodeNamesByFiles(result.changedFilePaths, ['namespace', 'module'])
             );
+            for (const ref of importRetry) {
+              if (!retryRows.has(ref.rowId)) retryable.push(ref);
+            }
+            // In row order, as a full index resolves them: when two refs make
+            // the same edge, such as a route's lazily loaded class that its
+            // layout also renders, the one written first names it, as it
+            // does in a fresh index.
+            retryable.sort((a, b) => (a.rowId ?? 0) - (b.rowId ?? 0));
             if (retryable.length > 0) {
               options.onProgress?.({
                 phase: 'resolving',
@@ -1143,6 +1210,8 @@ export class CodeGraph {
         this.orchestrator.finishGitIndexState(gitState, fullReconcile, result.failedFilePaths);
 
         if (fullReconcile && result.filesChecked > 0) this.pendingFullReconcile = false;
+        // The whole sync, as for indexAll: resolution and linking included (#2334).
+        result.durationMs = Date.now() - startedAt;
         return result;
       } finally {
         // Mirror indexAll's teardown: stop the valve, then restore the
@@ -1389,7 +1458,9 @@ export class CodeGraph {
    * Extract nodes and edges from source code (without storing)
    */
   extractFromSource(filePath: string, source: string): ExtractionResult {
-    return extractFromSource(filePath, source);
+    // The project root is what tells a Shopify theme's JSON templates (Liquid)
+    // apart from other JSON.
+    return extractFromSource(filePath, source, detectLanguage(filePath, source, undefined, this.projectRoot));
   }
 
   // ===========================================================================
@@ -1623,6 +1694,24 @@ export class CodeGraph {
     return this.queries.getUnresolvedSupertypeSourcesAmong(nodeIds);
   }
 
+  /**
+   * The names each of the given symbols refers to, by reference kind, where
+   * the resolver could not follow the reference — a decorator or an interface
+   * from outside the index, which leaves no edge. Ids with none are absent.
+   */
+  getUnresolvedReferenceNamesFrom(nodeIds: Iterable<string>, kinds: readonly Edge['kind'][]): Map<string, string[]> {
+    return this.queries.getUnresolvedReferenceNamesFrom(nodeIds, kinds);
+  }
+
+  /**
+   * Every symbol that refers to each of the given names, by reference kind,
+   * where the resolver could not follow it: for `implements`, every class that
+   * names a given interface from outside the index.
+   */
+  getUnresolvedReferenceSourcesNamed(names: Iterable<string>, kinds: readonly Edge['kind'][]): Map<string, Set<string>> {
+    return this.queries.getUnresolvedReferenceSourcesNamed(names, kinds);
+  }
+
   /**
    * The symbols with the most distinct dependents, most first — the index's
    * hubs. Distinct dependents, not edges: a helper called forty times from one
@@ -1809,6 +1898,15 @@ export class CodeGraph {
     return this.queries.getExploreMissDiagnostics(query);
   }
 
+  /**
+   * The COBOL copybooks a query names (`CVACT01Y`, `MYCOPYBOOK`): each
+   * member's indexed copybook file(s) and every `COPY` / `EXEC SQL INCLUDE`
+   * statement that includes it. Empty for a query that names none.
+   */
+  findNamedCopybooks(query: string): NamedCopybook[] {
+    return findNamedCopybooks(this.queries, query);
+  }
+
   /**
    * Graph-derived prompt matching for the front-load hook's MEDIUM tier:
    * which indexed symbols do these prose words name? "state machine des
@@ -2045,6 +2143,14 @@ export class CodeGraph {
     return this.queries.getFileByPath(filePath);
   }
 
+  /**
+   * Whether the index holds any file under `dir`, a project-relative POSIX
+   * directory (e.g. `packages/api`).
+   */
+  hasFilesUnder(dir: string): boolean {
+    return this.queries.hasFilesUnder(dir);
+  }
+
   /**
    * Get all tracked files
    */
@@ -2083,6 +2189,34 @@ export class CodeGraph {
     return this.queries.countGeneratedFiles();
   }
 
+  /**
+   * Indexed files whose symbols are missing although their content is current
+   * — rows a content-hash comparison calls up to date (#2336). Reported by
+   * `status`; `sync` repairs the `needsReindex` group.
+   */
+  getIndexHealth(): IndexHealth {
+    const needsReindex: string[] = [];
+    const parseErrors: string[] = [];
+    for (const file of this.queries.getFilesWithoutNodesOrWithErrors()) {
+      const errors = file.errors ?? [];
+      if (hasGrammarLoadFailure(errors)) {
+        // Stored without being parsed — its grammar could not load (#2335).
+        needsReindex.push(file.path);
+      } else if (file.nodeCount === 0) {
+        // Every parse stores at least the file node, so zero nodes means a
+        // wiped row (#1541) or a recorded failure — except file-level-only
+        // languages and files over the size limit, which are empty on purpose.
+        if (isFileLevelOnlyLanguage(file.language)) continue;
+        if (errors.length === 0) needsReindex.push(file.path);
+        else if (errors.some((e) => e.severity === 'error' || e.code === 'parse_error')) parseErrors.push(file.path);
+      } else if (errors.some((e) => e.code === 'parse_error')) {
+        // Parsed, but the tree had errors and no symbols survived.
+        parseErrors.push(file.path);
+      }
+    }
+    return { needsReindex, parseErrors };
+  }
+
   // ===========================================================================
   // Graph Query Methods
   // ===========================================================================
diff --git a/src/mcp/daemon-paths.ts b/src/mcp/daemon-paths.ts
index 34751814f3..8f78d5063e 100644
--- a/src/mcp/daemon-paths.ts
+++ b/src/mcp/daemon-paths.ts
@@ -32,14 +32,20 @@ import * as crypto from 'crypto';
 import * as net from 'net';
 import * as os from 'os';
 import * as path from 'path';
-import { getCodeGraphDir } from '../directory';
+import { canonicalProjectRoot, getCodeGraphDir } from '../directory';
 
 /** Soft upper bound for in-project socket paths. */
 const POSIX_SOCKET_PATH_LIMIT = 100;
 
-/** Short stable identifier for a project root — used in tmpdir/pipe names. */
+/**
+ * Short stable identifier for a project root — used in tmpdir/pipe names.
+ *
+ * Hashed over {@link canonicalProjectRoot}, never a raw `path.resolve`: the key
+ * is a rendezvous, so every spelling of one directory must land on one name or
+ * a proxy probes a pipe the running daemon never bound (see that function).
+ */
 function projectHash(projectRoot: string): string {
-  return crypto.createHash('sha256').update(path.resolve(projectRoot)).digest('hex').slice(0, 16);
+  return crypto.createHash('sha256').update(canonicalProjectRoot(projectRoot)).digest('hex').slice(0, 16);
 }
 
 /**
diff --git a/src/mcp/daemon-registry.ts b/src/mcp/daemon-registry.ts
index b4a01c307f..a9e5860116 100644
--- a/src/mcp/daemon-registry.ts
+++ b/src/mcp/daemon-registry.ts
@@ -22,6 +22,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import * as crypto from 'crypto';
+import { canonicalProjectRoot } from '../directory';
 import {
   getDaemonPidPath,
   getDaemonSocketCandidates,
@@ -30,7 +31,15 @@ import {
   probeDaemonIdentity,
   type DaemonLockInfo,
 } from './daemon-paths';
-import { readWriterLock, releaseWriterLock, tryAcquireWriterLock } from './writer-lock';
+import {
+  readWriterLock,
+  releaseWriterLock,
+  swapWriterLock,
+  tryAcquireWriterLock,
+  type WriterLockInfo,
+} from './writer-lock';
+import { isOlderRelease } from './version';
+import { WORKER_START_SETTLE_MS } from '../worker-teardown';
 
 export interface DaemonRecord {
   /** Realpath'd project root the daemon serves. */
@@ -50,8 +59,14 @@ export function getRegistryDir(): string {
   return path.join(os.homedir(), '.codegraph', 'daemons');
 }
 
+/**
+ * One record per project, so it is keyed the same way the daemon socket is:
+ * over {@link canonicalProjectRoot}, not a raw `path.resolve` — otherwise the
+ * same project spelled with another drive-letter case files two records, and
+ * `list` over-lists while `stop --all` misses one.
+ */
 function recordPath(root: string): string {
-  const hash = crypto.createHash('sha256').update(path.resolve(root)).digest('hex').slice(0, 16);
+  const hash = crypto.createHash('sha256').update(canonicalProjectRoot(root)).digest('hex').slice(0, 16);
   return path.join(getRegistryDir(), `${hash}.json`);
 }
 
@@ -147,7 +162,6 @@ function cleanupDaemonArtifacts(
   root: string,
   expectedLockContents: string | null,
 ): boolean {
-  const pidPath = getDaemonPidPath(root);
   // A daemon owns writer.pid before binding or relocating its socket. Claiming
   // the writer slot therefore freezes every legitimate daemon artifact writer
   // while we compare the inspected lock snapshot and clean it up.
@@ -156,33 +170,39 @@ function cleanupDaemonArtifacts(
   if (claim.kind === 'taken') return false;
 
   try {
-    if (expectedLockContents === null) {
-      if (fs.existsSync(pidPath)) return false;
-    } else {
-      try {
-        if (fs.readFileSync(pidPath, 'utf8') !== expectedLockContents) return false;
-      } catch {
-        return false;
-      }
-    }
-    // POSIX sockets are real files; Windows named pipes vanish with the process.
-    // Sweep every candidate before releasing daemon.pid, so no successor can
-    // acquire the lock and bind a socket that this cleanup then removes.
-    if (process.platform !== 'win32') {
-      for (const candidate of getDaemonSocketCandidates(root)) {
-        try { fs.unlinkSync(candidate); } catch { /* gone */ }
-      }
-    }
-    deregisterDaemon(root);
-    try { fs.unlinkSync(pidPath); } catch (err) {
-      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') return false;
-    }
-    return true;
+    return removeDaemonArtifacts(root, expectedLockContents);
   } finally {
     releaseWriterLock(root);
   }
 }
 
+/** The removal behind {@link cleanupDaemonArtifacts}, for a caller already holding the writer slot. */
+function removeDaemonArtifacts(root: string, expectedLockContents: string | null): boolean {
+  const pidPath = getDaemonPidPath(root);
+  if (expectedLockContents === null) {
+    if (fs.existsSync(pidPath)) return false;
+  } else {
+    try {
+      if (fs.readFileSync(pidPath, 'utf8') !== expectedLockContents) return false;
+    } catch {
+      return false;
+    }
+  }
+  // POSIX sockets are real files; Windows named pipes vanish with the process.
+  // Sweep every candidate before releasing daemon.pid, so no successor can
+  // acquire the lock and bind a socket that this cleanup then removes.
+  if (process.platform !== 'win32') {
+    for (const candidate of getDaemonSocketCandidates(root)) {
+      try { fs.unlinkSync(candidate); } catch { /* gone */ }
+    }
+  }
+  deregisterDaemon(root);
+  try { fs.unlinkSync(pidPath); } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') return false;
+  }
+  return true;
+}
+
 /** Remove daemon artifacts only when no matching daemon answers the socket hello. */
 export async function clearStaleDaemonArtifacts(root: string): Promise<boolean> {
   const pidPath = getDaemonPidPath(root);
@@ -206,6 +226,18 @@ export async function clearStaleDaemonArtifacts(root: string): Promise<boolean>
 
 const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
 
+/** How long `stopDaemonAt` gives a daemon to exit on SIGTERM before looking closer. */
+const DAEMON_TERM_WAIT_MS = 3_000;
+
+/**
+ * How much longer `stopDaemonAt` waits for a daemon that is partway through its
+ * own shutdown: it has stopped answering its socket (or let go of its lock) but
+ * not yet exited. That shutdown waits up to {@link WORKER_START_SETTLE_MS} for a
+ * query worker still starting up before it exits, so this covers that plus the
+ * rest of the shutdown (#2311).
+ */
+const DAEMON_SHUTDOWN_GRACE_MS = WORKER_START_SETTLE_MS + 2_000;
+
 async function waitForDeath(pid: number, timeoutMs: number): Promise<boolean> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -220,6 +252,8 @@ export interface StopResult {
   pid: number | null;
   /** 'term' graceful, 'kill' force, 'still-running' refused, 'not-running' stale, 'no-daemon' absent, 'unverified' preserved. */
   outcome: 'term' | 'kill' | 'still-running' | 'not-running' | 'no-daemon' | 'unverified';
+  /** The daemon's version as its lock recorded it, when the stop got that far. */
+  version?: string;
 }
 
 /**
@@ -228,8 +262,14 @@ export interface StopResult {
  * keys its socket/lockfile). Resolves the pid from the authoritative lockfile,
  * falling back to the registry. Rebuild callers preserve unverified live locks
  * instead of interpreting a failed probe as permission to discard the database.
+ * A daemon still finishing its own shutdown is waited for, up to
+ * `shutdownGraceMs` more (default {@link DAEMON_SHUTDOWN_GRACE_MS}; tests
+ * shorten it), before it is reported `still-running`.
  */
-export async function stopDaemonAt(root: string, options: { preserveUnverified?: boolean } = {}): Promise<StopResult> {
+export async function stopDaemonAt(
+  root: string,
+  options: { preserveUnverified?: boolean; shutdownGraceMs?: number } = {},
+): Promise<StopResult> {
   let pid: number | null = null;
   let identity: DaemonLockInfo | null = null;
   let lockContents: string | null = null;
@@ -242,7 +282,7 @@ export async function stopDaemonAt(root: string, options: { preserveUnverified?:
   }
   if (pid == null) {
     const rec = listDaemons({ prune: false }).find(
-      (r) => path.resolve(r.root) === path.resolve(root)
+      (r) => canonicalProjectRoot(r.root) === canonicalProjectRoot(root)
     );
     pid = rec?.pid ?? null;
     if (rec) identity = rec;
@@ -266,31 +306,144 @@ export async function stopDaemonAt(root: string, options: { preserveUnverified?:
     const removed = cleanupDaemonArtifacts(root, lockContents);
     return { root, pid, outcome: removed ? 'not-running' : 'unverified' };
   }
+  return stopVerifiedDaemon(root, identity, lockContents, options.shutdownGraceMs);
+}
 
+/**
+ * The signalling half of a stop, for a daemon whose socket hello just proved
+ * `identity` against the lock read as `lockContents`: SIGTERM, wait, SIGKILL
+ * only one that still answers, then sweep its artifacts.
+ */
+async function stopVerifiedDaemon(
+  root: string,
+  identity: DaemonLockInfo,
+  lockContents: string | null,
+  shutdownGraceMs = DAEMON_SHUTDOWN_GRACE_MS,
+): Promise<StopResult> {
+  const { pid, version } = identity;
   // Identity probing awaits I/O: never act on a superseded ownership record.
   const sameLock = (): boolean => {
     try { return fs.readFileSync(getDaemonPidPath(root), 'utf8') === lockContents; }
     catch { return lockContents === null; }
   };
-  if (!sameLock()) return { root, pid, outcome: 'unverified' };
+  if (!sameLock()) return { root, pid, outcome: 'unverified', version };
 
   // POSIX: SIGTERM runs the daemon's graceful shutdown. Windows: TerminateProcess
   // (no graceful path), so we always sweep artifacts ourselves below.
   try { process.kill(pid, 'SIGTERM'); } catch { /* raced to exit */ }
   let outcome: StopResult['outcome'] = 'term';
-  if (!(await waitForDeath(pid, 3000))) {
+  if (!(await waitForDeath(pid, DAEMON_TERM_WAIT_MS))) {
     // Re-prove identity before escalating; the old PID may have been reused.
-    if (!sameLock() || !await probeDaemonIdentity(identity) || !sameLock()) {
-      return { root, pid, outcome: 'still-running' };
-    }
-    try { process.kill(pid, 'SIGKILL'); } catch { /* raced to exit */ }
-    if (!(await waitForDeath(pid, 2000))) {
-      return { root, pid, outcome: 'still-running' };
+    if (sameLock() && await probeDaemonIdentity(identity) && sameLock()) {
+      try { process.kill(pid, 'SIGKILL'); } catch { /* raced to exit */ }
+      if (!(await waitForDeath(pid, 2000))) {
+        return { root, pid, outcome: 'still-running', version };
+      }
+      outcome = 'kill';
+    } else {
+      // No longer answering its socket, or no longer holding the lock it held
+      // when it was signalled: a daemon partway through its own shutdown, which
+      // closes the socket first and can then wait on a query worker still
+      // starting up before it releases the lock and exits (#2311). On Windows,
+      // where SIGTERM is TerminateProcess, this is a termination still settling.
+      // Its identity can't be re-proven without the socket, so signal nothing
+      // more; just wait, bounded, for the PID to go. One that outlives the
+      // wait is reported, as before.
+      if (!(await waitForDeath(pid, shutdownGraceMs))) {
+        return { root, pid, outcome: 'still-running', version };
+      }
     }
-    outcome = 'kill';
   }
+  // Compares the lock with the one we signalled, so a successor's is kept.
   cleanupDaemonArtifacts(root, lockContents);
-  return { root, pid, outcome };
+  return { root, pid, outcome, version };
+}
+
+/**
+ * Stop the daemon serving `root` when it runs an older CodeGraph release than
+ * `version`, so the caller can start one from its own install (#2335). A
+ * daemon keeps running the code it started with: one that outlived an upgrade
+ * goes on loading grammars from files the upgrade removed, while it holds the
+ * project's writer lock and file watcher. Only a daemon whose lock records an
+ * older release ({@link isOlderRelease}) and whose socket hello confirms that
+ * lock is signalled, exactly as {@link stopDaemonAt} would; one of the same, a
+ * newer or an unknown version is never touched, so two installs cannot take
+ * turns stopping each other's daemon.
+ *
+ * The project's writer slot never falls free on the way: before the signal,
+ * this process takes it over from the old daemon (mode `handover`), and the
+ * caller hands it on to the daemon it starts, which takes it over in turn
+ * ({@link swapWriterLock}). The old daemon's sessions serve themselves
+ * in-process the moment it goes, and one that found the slot free would claim
+ * it as their writer — with the code of an install the upgrade removed — and
+ * keep the new daemon from starting. When the old daemon is not stopped, the
+ * slot goes back to it.
+ *
+ * Resolves null when the lock names no older daemon (there is none, or another
+ * launcher already replaced it) or the slot could not be taken (another
+ * launcher holds it to replace the same daemon). Otherwise says what became of
+ * the daemon: `term` or `kill` when it was stopped, and this process now holds
+ * the slot for its successor (release it with {@link releaseWriterLock} once
+ * that one has taken over or failed); `not-running` when it had already exited
+ * (its successor clears the stale lock); `unverified` or `still-running` when
+ * it is still there.
+ */
+export async function stopOlderDaemon(
+  root: string,
+  version: string,
+  options: { shutdownGraceMs?: number } = {},
+): Promise<StopResult | null> {
+  let lockContents: string;
+  try {
+    lockContents = fs.readFileSync(getDaemonPidPath(root), 'utf8');
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    return { root, pid: null, outcome: 'unverified' };
+  }
+  const identity = decodeLockInfo(lockContents);
+  if (!identity) return { root, pid: null, outcome: 'unverified' };
+  if (!isOlderRelease(identity.version, version)) return null;
+  const { pid } = identity;
+  if (!isProcessAlive(pid)) return { root, pid, outcome: 'not-running', version: identity.version };
+  // The hello must name this pid and version (#1553): a reused pid is no daemon.
+  if (!canProbeDaemonIdentity(identity) || !await probeDaemonIdentity(identity)) {
+    return { root, pid, outcome: 'unverified', version: identity.version };
+  }
+  const slot = takeWriterSlotFrom(root, pid);
+  if (!slot) return null;
+  const result = await stopVerifiedDaemon(root, identity, lockContents, options.shutdownGraceMs);
+  if (result.outcome === 'term' || result.outcome === 'kill') {
+    // The stop's own sweep needs the slot this process now holds: clear what
+    // the old daemon left (all of it on Windows, where the stop is
+    // TerminateProcess), so its successor starts on a clean lock.
+    removeDaemonArtifacts(root, lockContents);
+  } else {
+    slot.giveBack();
+  }
+  return result;
+}
+
+/**
+ * Take the project's writer slot from the daemon `pid` this process is about
+ * to stop (see {@link stopOlderDaemon}), whether the record is that daemon's,
+ * stale, or absent. Returns how to give it back to that daemon, or null when
+ * the slot could not be taken: another live process holds it (another
+ * launcher replacing the same daemon), or the swap lost a race.
+ */
+function takeWriterSlotFrom(root: string, pid: number): { giveBack(): void } | null {
+  const previous = readWriterLock(root);
+  if (previous && previous.pid !== pid && previous.pid !== process.pid && isProcessAlive(previous.pid)) return null;
+  const claim: WriterLockInfo = { pid: process.pid, mode: 'handover', startedAt: Date.now(), ready: false };
+  const held = previous
+    ? swapWriterLock(root, previous.pid, claim)
+    : tryAcquireWriterLock(root, 'handover').kind === 'acquired';
+  if (!held) return null;
+  return {
+    giveBack: () => {
+      if (previous?.pid === pid) swapWriterLock(root, process.pid, previous);
+      else releaseWriterLock(root);
+    },
+  };
 }
 
 /** Stop every registered, live daemon. */
diff --git a/src/mcp/daemon.ts b/src/mcp/daemon.ts
index 5f44ff6e85..db38f97f5e 100644
--- a/src/mcp/daemon.ts
+++ b/src/mcp/daemon.ts
@@ -54,12 +54,14 @@ import {
   getDaemonSocketCandidates,
   getDaemonSocketPath,
 } from './daemon-paths';
-import { CodeGraphPackageVersion } from './version';
+import { CodeGraphPackageJsonPath, CodeGraphPackageVersion } from './version';
 import {
   releaseWriterLock,
+  swapWriterLock,
   tryAcquireWriterLock,
   assertNoRebuild,
   writerLockHeldMessage,
+  type WriterLockInfo,
 } from './writer-lock';
 import { registerDaemon, deregisterDaemon } from './daemon-registry';
 
@@ -118,6 +120,38 @@ export function finalizeDaemonExit(
 /** How often the daemon sweeps connected clients for a dead peer process (#692). */
 const DEFAULT_CLIENT_SWEEP_MS = 30_000;
 
+/** How often the daemon checks that the install it runs from is still in place (#2335). */
+const DEFAULT_INSTALL_CHECK_MS = 30_000;
+
+/**
+ * Why the install this daemon was started from no longer matches it, or null
+ * while it still does. An upgrade replaces or deletes the package directory
+ * under a running daemon (npm reinstalling the package, the launcher pruning
+ * an old bundle), and everything the daemon loads lazily from there afterwards
+ * fails — grammars among them, so every file its watcher re-indexed came out
+ * empty (#2335). Such a daemon should make way for one started from the
+ * current install. Any other read failure, or a package.json caught mid-write,
+ * answers null: the next check looks again. Exported for testing.
+ */
+export function installChangedReason(packageJsonPath: string, runningVersion: string): string | null {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(packageJsonPath, 'utf8');
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    return code === 'ENOENT' || code === 'ENOTDIR' ? `Install removed (${packageJsonPath} is gone)` : null;
+  }
+  let version: unknown;
+  try {
+    version = (JSON.parse(raw) as { version?: unknown } | null)?.version;
+  } catch {
+    return null;
+  }
+  return typeof version === 'string' && version !== runningVersion
+    ? `Install replaced by v${version} (this daemon is v${runningVersion})`
+    : null;
+}
+
 /** How long the daemon waits for the optional client-hello before proceeding without it. */
 const CLIENT_HELLO_TIMEOUT_MS = 3_000;
 
@@ -183,19 +217,23 @@ export class Daemon {
   private lastActivityAt = Date.now();
   private maxIdleTimer: NodeJS.Timeout | null = null;
   private clientSweepTimer: NodeJS.Timeout | null = null;
+  private installCheckTimer: NodeJS.Timeout | null = null;
   private engine: MCPEngine;
   private stopping = false;
   private socketPath: string;
   private pidPath: string;
+  /** The launcher holding the writer slot for this daemon, when it replaced an older one (#2335). */
+  private handoverFrom: number | null;
 
   constructor(
     private projectRoot: string,
-    opts: { idleTimeoutMs?: number; maxIdleMs?: number } = {},
+    opts: { idleTimeoutMs?: number; maxIdleMs?: number; handoverFrom?: number | null } = {},
   ) {
     this.socketPath = getDaemonSocketPath(projectRoot);
     this.pidPath = getDaemonPidPath(projectRoot);
     this.idleTimeoutMs = opts.idleTimeoutMs ?? resolveIdleTimeoutMs();
     this.maxIdleMs = opts.maxIdleMs ?? resolveMaxIdleMs();
+    this.handoverFrom = opts.handoverFrom ?? null;
     // Daemon mode serves many concurrent clients on one event loop, so off-load
     // read-tool dispatch to a worker pool — otherwise concurrent explores
     // serialize and starve the MCP transport (clients time out). Direct mode
@@ -214,7 +252,17 @@ export class Daemon {
     // #1740: claim the project writer lock before opening/watching so a
     // concurrent direct-mode serve --mcp cannot start a second watcher.
     assertNoRebuild(this.projectRoot);
-    const writer = tryAcquireWriterLock(this.projectRoot, 'daemon');
+    let writer = tryAcquireWriterLock(this.projectRoot, 'daemon');
+    // The launcher that stopped an older daemon has held the slot for us since
+    // (#2335); take it over without letting it fall free.
+    if (writer.kind === 'taken' && this.handoverFrom !== null &&
+        writer.existing?.pid === this.handoverFrom && writer.existing.mode === 'handover') {
+      const info: WriterLockInfo = { pid: process.pid, mode: 'daemon', startedAt: Date.now(), ready: false };
+      if (swapWriterLock(this.projectRoot, this.handoverFrom, info)) {
+        writer = { kind: 'acquired', pidPath: writer.pidPath, info };
+        process.stderr.write(`[CodeGraph daemon] Took over the writer lock from launcher pid ${this.handoverFrom}, which stopped an older daemon.\n`);
+      }
+    }
     if (writer.kind === 'taken') {
       const msg = writerLockHeldMessage(writer.existing, writer.pidPath);
       process.stderr.write(`[CodeGraph daemon] ${msg}\n`);
@@ -357,6 +405,10 @@ export class Daemon {
       clearInterval(this.clientSweepTimer);
       this.clientSweepTimer = null;
     }
+    if (this.installCheckTimer) {
+      clearInterval(this.installCheckTimer);
+      this.installCheckTimer = null;
+    }
     process.stderr.write(`[CodeGraph daemon] Shutting down (${reason}; clients=${this.clients.size}).\n`);
     for (const session of [...this.clients]) {
       try { session.stop(); } catch { /* best-effort */ }
@@ -476,6 +528,31 @@ export class Daemon {
       this.clientSweepTimer = setInterval(() => this.reapDeadClients(isProcessAlive), sweepMs);
       this.clientSweepTimer.unref?.();
     }
+    // An install whose version could not be read at startup has nothing to
+    // compare against; leave that daemon alone.
+    const installMs = resolveInstallCheckMs();
+    if (installMs > 0 && CodeGraphPackageVersion !== '0.0.0-unknown') {
+      this.installCheckTimer = setInterval(() => { this.checkInstall(); }, installMs);
+      this.installCheckTimer.unref?.();
+    }
+  }
+
+  /**
+   * Exit once the install this daemon runs from has been upgraded or removed
+   * (#2335; see {@link installChangedReason}). Its clients' proxies fall back
+   * and reconnect, and the next launch starts a daemon from the current
+   * install. Returns whether the daemon is exiting. The check is injected for
+   * tests; the timer passes the real one.
+   */
+  checkInstall(
+    changed: () => string | null = () => installChangedReason(CodeGraphPackageJsonPath, CodeGraphPackageVersion),
+  ): boolean {
+    if (this.stopping) return false;
+    const reason = changed();
+    if (!reason) return false;
+    process.stderr.write(`[CodeGraph daemon] ${reason}; exiting so the next session starts a daemon from the current install.\n`);
+    void this.stop('install changed');
+    return true;
   }
 
   /**
@@ -850,6 +927,14 @@ function resolveClientSweepMs(): number {
   return Math.floor(parsed); // 0 disables the sweep
 }
 
+function resolveInstallCheckMs(): number {
+  const raw = process.env.CODEGRAPH_DAEMON_INSTALL_CHECK_MS;
+  if (raw === undefined || raw === '') return DEFAULT_INSTALL_CHECK_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_INSTALL_CHECK_MS;
+  return Math.floor(parsed); // 0 disables the check
+}
+
 /**
  * Parse one client-hello line. Returns the peer pids if `line` is a well-formed
  * client-hello (carries the `codegraph_client` marker), or null otherwise — in
diff --git a/src/mcp/engine.ts b/src/mcp/engine.ts
index 2898f203b1..cc0b43ba1d 100644
--- a/src/mcp/engine.ts
+++ b/src/mcp/engine.ts
@@ -18,6 +18,7 @@ import { ToolHandler } from './tools';
 import { WslSharedIndexError } from '../db/wsl-shared-index';
 import { assertNoRebuild, releaseWriterLock, tryAcquireWriterLock, writerLockHeldMessage } from './writer-lock';
 import { QueryPool, resolvePoolSize } from './query-pool';
+import { endFreshnessMeasurements } from './index-freshness';
 import { acquireProject, ProjectLease } from './project-lifecycle';
 
 // Lazy-load the heavy CodeGraph chain (sqlite + query/graph/context layers) OFF
@@ -167,6 +168,11 @@ export class MCPEngine {
     this.toolHandler.setDefaultProjectHint(projectPath);
   }
 
+  /** Whether this engine only reads: no watcher, no sync, no writer slot. */
+  isReadOnly(): boolean {
+    return this.opts.readOnly;
+  }
+
   /** Project root that the engine resolved on first init (null if none). */
   getProjectPath(): string | null {
     return this.projectPath;
@@ -266,13 +272,16 @@ export class MCPEngine {
 
     // Detach + terminate the worker pool first so no tool call routes to a
     // worker mid-teardown; outstanding pool calls resolve with graceful guidance.
+    // Stopping waits for the workers to end — the pool's, and any
+    // `codegraph_status` change count still measuring: the daemon exits right
+    // after, and exiting while a worker is still starting up can crash the
+    // process.
     this.toolHandler.setQueryPool(null);
-    if (this.queryPool) {
-      void this.queryPool.destroy();
-      this.queryPool = null;
-    }
+    const poolDown = this.queryPool ? this.queryPool.destroy() : Promise.resolve();
+    this.queryPool = null;
+    const measurementsDown = endFreshnessMeasurements();
     const drained = this.toolHandler.closeAll();
-    this.stopPromise = drained.then(async () => {
+    this.stopPromise = Promise.all([drained, poolDown, measurementsDown]).then(async () => {
       if (this.initPromise) await this.initPromise;
       if (this.defaultLease) {
         await this.defaultLease.release();
diff --git a/src/mcp/index-freshness-worker.ts b/src/mcp/index-freshness-worker.ts
index 06d9787372..b678f1d20a 100644
--- a/src/mcp/index-freshness-worker.ts
+++ b/src/mcp/index-freshness-worker.ts
@@ -1,5 +1,6 @@
 /** Exact CLI-parity change count, isolated from the MCP transport event loop. */
 import { parentPort, workerData } from 'worker_threads';
+import { collectBeforeExit } from '../worker-teardown';
 
 if (parentPort) {
   const port = parentPort;
@@ -7,6 +8,9 @@ if (parentPort) {
   let counts: { added: number; modified: number; removed: number } | null = null;
   try {
     const CodeGraph = (require('../index') as typeof import('../index')).default;
+    // Loaded: from here on the owner may terminate this worker. Ending it while
+    // it loads those modules can crash the process on Windows (worker-teardown.ts).
+    port.postMessage({ type: 'loaded' });
     cg = CodeGraph.openSync((workerData as { root: string }).root);
     const changes = cg.getChangedFiles();
     counts = {
@@ -19,5 +23,7 @@ if (parentPort) {
   } finally {
     try { cg?.close(); } catch { /* the worker is exiting */ }
   }
-  port.postMessage(counts);
+  // The owner terminates this worker on the answer: no GC marking in flight then.
+  collectBeforeExit();
+  port.postMessage({ type: 'counts', counts });
 }
diff --git a/src/mcp/index-freshness.ts b/src/mcp/index-freshness.ts
index ed6c66b02f..504216f425 100644
--- a/src/mcp/index-freshness.ts
+++ b/src/mcp/index-freshness.ts
@@ -1,6 +1,7 @@
 import { existsSync } from 'fs';
 import * as path from 'path';
 import { Worker } from 'worker_threads';
+import { terminateOnceStarted, workerStarted } from '../worker-teardown';
 
 export interface PendingChangeCounts {
   added: number;
@@ -12,20 +13,31 @@ export interface PendingChangeCounts {
 const MEASURE_TIMEOUT_MS = 8_000;
 let liveMeasurements = 0;
 const active = new Map<string, Promise<PendingChangeCounts | null>>();
+/** Every measurement worker not yet terminated, with its load — for {@link endFreshnessMeasurements}. */
+const live = new Map<Worker, Promise<void>>();
 
-export function measurePendingChanges(root: string): Promise<PendingChangeCounts | null> {
+export function measurePendingChanges(root: string, timeoutMs = MEASURE_TIMEOUT_MS): Promise<PendingChangeCounts | null> {
   const key = path.resolve(root);
   const existing = active.get(key);
   if (existing) return existing;
   // Status probes for many projects must not exhaust the shared daemon.
   if (liveMeasurements >= 2) return Promise.resolve(null);
 
-  const pending = runMeasurement(key).finally(() => active.delete(key));
+  const pending = runMeasurement(key, timeoutMs).finally(() => active.delete(key));
   active.set(key, pending);
   return pending;
 }
 
-function runMeasurement(root: string): Promise<PendingChangeCounts | null> {
+/**
+ * Terminate every measurement still running, each once it has loaded its
+ * modules (worker-teardown.ts) — for a server that is about to exit, since
+ * exiting tears the workers down the same way terminating them does.
+ */
+export async function endFreshnessMeasurements(): Promise<void> {
+  await Promise.all([...live].map(([worker, loaded]) => terminateOnceStarted(worker, loaded)));
+}
+
+function runMeasurement(root: string, timeoutMs: number): Promise<PendingChangeCounts | null> {
   // The compiled sibling is beside us in production; Vitest loads src/ but
   // builds dist/ before the tests, so use that copy for the worker there.
   const sibling = path.join(__dirname, 'index-freshness-worker.js');
@@ -41,6 +53,10 @@ function runMeasurement(root: string): Promise<PendingChangeCounts | null> {
     return Promise.resolve(null);
   }
 
+  // Its first message is 'loaded', posted once its modules are in. Terminating
+  // it before then can crash the whole process on Windows (worker-teardown.ts).
+  const loaded = workerStarted(worker);
+  live.set(worker, loaded);
   liveMeasurements++;
   return new Promise(resolve => {
     let settled = false;
@@ -48,13 +64,19 @@ function runMeasurement(root: string): Promise<PendingChangeCounts | null> {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      // A worker inside a synchronous Git call may take time to terminate.
-      // Return unknown on deadline, but keep its concurrency slot until exit.
-      void worker.terminate().catch(() => {}).finally(() => { liveMeasurements--; });
+      // A worker inside a synchronous Git call may take time to terminate, and
+      // one still loading its modules must not be terminated yet. Return
+      // unknown on deadline, but keep its concurrency slot until it is gone.
+      void terminateOnceStarted(worker, loaded).finally(() => {
+        live.delete(worker);
+        liveMeasurements--;
+      });
       resolve(counts);
     };
-    const timer = setTimeout(() => finish(null), MEASURE_TIMEOUT_MS);
-    worker.once('message', (value: PendingChangeCounts | null) => {
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    worker.on('message', (msg: { type?: string; counts?: PendingChangeCounts | null }) => {
+      if (msg?.type !== 'counts') return;
+      const value = msg.counts;
       const valid = value && typeof value === 'object' && ['added', 'modified', 'removed'].every(
         key => Number.isSafeInteger(value[key as keyof PendingChangeCounts]) && value[key as keyof PendingChangeCounts] >= 0,
       );
diff --git a/src/mcp/index.ts b/src/mcp/index.ts
index 824132d629..e41bd43e05 100644
--- a/src/mcp/index.ts
+++ b/src/mcp/index.ts
@@ -44,11 +44,13 @@ import { MCPSession } from './session';
 import {
   Daemon,
   clearStaleDaemonLock,
+  installChangedReason,
   isProcessAlive,
   tryAcquireDaemonLock,
 } from './daemon';
-import { clearStaleDaemonArtifacts } from './daemon-registry';
+import { clearStaleDaemonArtifacts, stopOlderDaemon } from './daemon-registry';
 import { connectWithHello, runLocalHandshakeProxy } from './proxy';
+import { CodeGraphPackageJsonPath, CodeGraphPackageVersion } from './version';
 import {
   readWriterLock,
   assertNoRebuild,
@@ -83,6 +85,13 @@ const DIRECT_QUERY_POOL_MAX = 2;
  */
 const DAEMON_INTERNAL_ENV = 'CODEGRAPH_DAEMON_INTERNAL';
 
+/**
+ * Env var naming the launcher that holds the project's writer slot for the
+ * daemon it spawns, after stopping an older one (#2335). That daemon takes the
+ * slot over instead of finding it held.
+ */
+const DAEMON_HANDOVER_ENV = 'CODEGRAPH_DAEMON_HANDOVER';
+
 /**
  * Retries for the detached daemon arbitrating the O_EXCL lock against a racing
  * sibling. Tiny — the lock resolves on the first round in practice; the retries
@@ -91,6 +100,13 @@ const DAEMON_INTERNAL_ENV = 'CODEGRAPH_DAEMON_INTERNAL';
 const TAKEOVER_MAX_RETRIES = 5;
 const TAKEOVER_RETRY_DELAY_MS = 100;
 
+/**
+ * How long a daemon the writer slot is held for (#2335) waits out a racing
+ * candidate that took the daemon lock first. That candidate cannot get the
+ * slot, so it leaves; this bounds a wait that never ends.
+ */
+const HANDOVER_CANDIDATE_WAIT_MS = 5_000;
+
 /**
  * A fallback that serves reads without a watcher or a writer lock (#1963).
  * Say so on stderr: otherwise a session that quietly stopped syncing looks
@@ -135,6 +151,14 @@ function makeFallbackEngine(root: string): MCPEngine {
   if (existing && isProcessAlive(existing.pid)) {
     return readOnlyFallback(`live daemon PID ${existing.pid} holds the project lock`);
   }
+  // This session's own install was upgraded or removed underneath it (#2335):
+  // its code no longer loads whole, so as the project's writer it would only
+  // keep a daemon from the current install from starting. Its daemon exits
+  // for the same reason, which is how it got here.
+  if (CodeGraphPackageVersion !== '0.0.0-unknown' &&
+      installChangedReason(CodeGraphPackageJsonPath, CodeGraphPackageVersion) !== null) {
+    return readOnlyFallback('this session\'s CodeGraph install was upgraded or removed; restart the session to use the current one');
+  }
   return new MCPEngine({ writerLockRoot: root, queryPool: true, queryPoolDefaultMax: DIRECT_QUERY_POOL_MAX });
 }
 
@@ -243,9 +267,10 @@ function resolveDaemonRoot(explicitPath: string | null): string | null {
  * `process.execArgv` (carries `--liftoff-only`, so the daemon never re-execs)
  * and `process.argv[1]` (this script). The spawned process self-arbitrates the
  * O_EXCL lock, so racing launchers may each spawn one — losers exit and every
- * launcher proxies through the single winner.
+ * launcher proxies through the single winner. `handover` tells the daemon this
+ * launcher holds the writer slot for it (see {@link DAEMON_HANDOVER_ENV}).
  */
-function spawnDetachedDaemon(root: string): void {
+function spawnDetachedDaemon(root: string, handover = false): void {
   const scriptPath = process.argv[1];
   if (!scriptPath) {
     // No resolvable CLI entry point to re-invoke — let the caller fall back to
@@ -267,6 +292,8 @@ function spawnDetachedDaemon(root: string): void {
     // where a long-dead session's host pid would trigger spurious shutdowns.
     const env: NodeJS.ProcessEnv = { ...process.env, [DAEMON_INTERNAL_ENV]: '1' };
     delete env[HOST_PPID_ENV];
+    if (handover) env[DAEMON_HANDOVER_ENV] = String(process.pid);
+    else delete env[DAEMON_HANDOVER_ENV];
     const child = spawn(
       process.execPath,
       [...process.execArgv, scriptPath, 'serve', '--mcp', '--path', root],
@@ -277,6 +304,12 @@ function spawnDetachedDaemon(root: string): void {
         env,
       },
     );
+    // An upgrade can delete the install this launcher runs from — its daemon
+    // then exits (#2335) and a respawn finds no executable. spawn reports that
+    // as an asynchronous 'error' event, which would crash this process if
+    // nobody listened. No daemon binds either way; the caller's poll gives up
+    // and the session is served in-process.
+    child.on('error', () => { /* no daemon — see above */ });
     child.unref();
   } finally {
     // The child holds its own dup of the log fd now; the launcher doesn't need it.
@@ -286,6 +319,76 @@ function spawnDetachedDaemon(root: string): void {
   }
 }
 
+/**
+ * How long a launcher replacing an older daemon waits for one that is partway
+ * through its shutdown, past the stop's own 3s wait. Tool calls are held
+ * meanwhile, so it is short: a daemon that takes longer leaves the session
+ * served in-process until the proxy's next retry (#2277) finds it gone.
+ */
+const OLDER_DAEMON_SHUTDOWN_GRACE_MS = 5_000;
+
+/**
+ * Stop the daemon serving `root` from an older install so the caller can start
+ * one from this install (#2335). A daemon keeps the code it started with: one
+ * that outlived an upgrade went on loading grammars from the removed install
+ * and wrote every file it re-indexed as empty, and as the project's writer it
+ * kept every newer session from syncing. {@link stopOlderDaemon} finds it by
+ * the project lock, verifies it, and never stops one of the same, a newer or an
+ * unknown version. `answered` says an older daemon answered this launcher's
+ * own probe. Resolves `stopped` (this launcher now holds the project's writer
+ * slot for the daemon it starts next), `none` (no older daemon holds the
+ * project), or `kept` (one does, unverified or still shutting down).
+ */
+async function replaceOlderDaemon(root: string, answered: boolean): Promise<'stopped' | 'none' | 'kept'> {
+  const result = await stopOlderDaemon(root, CodeGraphPackageVersion, {
+    shutdownGraceMs: OLDER_DAEMON_SHUTDOWN_GRACE_MS,
+  });
+  // No older daemon in the lock (none, or already replaced), or it had exited.
+  if (!result || result.outcome === 'not-running') return 'none';
+  const daemon = result.version
+    ? `the CodeGraph ${result.version} daemon (pid ${result.pid})`
+    : 'an older CodeGraph daemon';
+  if (result.outcome === 'term' || result.outcome === 'kill') {
+    process.stderr.write(
+      `[CodeGraph MCP] Stopped ${daemon} serving this project; starting one from this install (${CodeGraphPackageVersion}).\n`
+    );
+    return 'stopped';
+  }
+  if (result.outcome === 'still-running') {
+    process.stderr.write(`[CodeGraph MCP] Asked ${daemon} serving this project to stop, but it has not exited yet.\n`);
+  } else if (answered) {
+    process.stderr.write(
+      `[CodeGraph MCP] Found ${daemon} serving this project but could not verify it, so left it running; serving this session in-process.\n`
+    );
+  }
+  return 'kept';
+}
+
+/**
+ * Wait out the daemon candidate `pid` holding the daemon lock while launcher
+ * `handoverFrom` holds the writer slot for this daemon (#2335): the candidate
+ * cannot get the slot, so it releases the lock and exits. Resolves true once
+ * `pid` no longer holds the lock; false at once when no slot is held for this
+ * daemon, and false when that stops being so or the wait runs out.
+ */
+async function outwaitCandidate(root: string, handoverFrom: number | null, pid: number): Promise<boolean> {
+  const heldForUs = (): boolean => {
+    const writer = readWriterLock(root);
+    return handoverFrom !== null && writer?.pid === handoverFrom && writer.mode === 'handover';
+  };
+  if (!heldForUs()) return false;
+  process.stderr.write(`[CodeGraph daemon] Waiting for daemon candidate pid ${pid} to give up the lock; the writer lock is held for this daemon.\n`);
+  const deadline = Date.now() + HANDOVER_CANDIDATE_WAIT_MS;
+  while (Date.now() < deadline) {
+    if (!heldForUs()) return false;
+    let holder: number | undefined;
+    try { holder = decodeLockInfo(fs.readFileSync(getDaemonPidPath(root), 'utf8'))?.pid; } catch { holder = undefined; }
+    if (holder !== pid || !isProcessAlive(pid)) return true;
+    await sleep(25);
+  }
+  return false;
+}
+
 /**
  * MCP Server for CodeGraph
  *
@@ -495,11 +598,15 @@ export class MCPServer {
     // kills/restarts can be placed in time (#1431 — the log was undatable).
     timestampStderrLines();
     const root = resolveDaemonRoot(this.projectPath) ?? this.projectPath ?? process.cwd();
+    // Read once and dropped, so nothing this daemon spawns inherits it.
+    const handoverPid = Number(process.env[DAEMON_HANDOVER_ENV]);
+    const handoverFrom = Number.isInteger(handoverPid) && handoverPid > 0 ? handoverPid : null;
+    delete process.env[DAEMON_HANDOVER_ENV];
     for (let attempt = 0; attempt < TAKEOVER_MAX_RETRIES; attempt++) {
       const lock = tryAcquireDaemonLock(root);
 
       if (lock.kind === 'acquired') {
-        const daemon = new Daemon(root);
+        const daemon = new Daemon(root, { handoverFrom });
         await daemon.start();
         this.daemon = daemon;
         this.mode = 'daemon';
@@ -529,6 +636,9 @@ export class MCPServer {
           stillStarting ||
           await probeDaemonIdentity(existing)
         ) {
+          // A daemon the writer slot is held for outwaits a candidate still
+          // starting in its way, which cannot get the slot and leaves (#2335).
+          if (stillStarting && await outwaitCandidate(root, handoverFrom, existing.pid)) continue;
           process.stderr.write(
             `[CodeGraph daemon] Another daemon (pid ${existing.pid}) already holds the lock; exiting.\n`
           );
@@ -560,7 +670,8 @@ export class MCPServer {
   /**
    * Proxy mode (the common case). Serve the MCP handshake LOCALLY for instant
    * tool registration, forwarding tool calls to the shared daemon — which is
-   * connected in the background (probed, then spawned + polled if absent) so the
+   * connected in the background (probed, then spawned + polled if absent; one of
+   * an older release is stopped first, #2335) so the
    * handshake never waits ~600ms on it. Runs until the host disconnects; the
    * proxy falls back to an in-process engine if the daemon never binds, so this
    * never wedges a session.
@@ -577,9 +688,8 @@ export class MCPServer {
       for (const candidate of candidates) {
         const s = await connectWithHello(candidate);
         // A wrong-version daemon IS up — definitive; propagate so the caller
-        // serves in-process instead of spawning + polling for 6s. Don't keep
-        // probing fallbacks past it.
-        if (s === 'version-mismatch') return s;
+        // replaces it (an older release) or serves in-process instead of
+        // spawning + polling for 6s. Don't keep probing fallbacks past it.
         if (s) return s;
       }
       return null;
@@ -588,16 +698,31 @@ export class MCPServer {
       // Fast path: a daemon may already be listening (on either candidate).
       const probe = await connectAnyCandidate();
       if (probe === 'version-mismatch') return null; // definitive — serve in-process, don't poll for 6s
-      if (probe) return probe;
-      // None reachable — spawn one (detached) and poll for its bind.
-      spawnDetachedDaemon(root);
-      for (let attempt = 0; attempt < DAEMON_CONNECT_MAX_RETRIES; attempt++) {
-        await sleep(DAEMON_CONNECT_RETRY_DELAY_MS);
-        const s = await connectAnyCandidate();
-        if (s === 'version-mismatch') return null;
-        if (s) return s;
+      if (probe && probe !== 'older-version') return probe;
+      // A daemon of an older release answered — or none did, while the project
+      // lock may still name one on a socket we don't probe (on Windows, daemons
+      // before #2278 named their pipe after the root as typed). Either way it
+      // makes way for one from this install (#2335).
+      const answered = probe === 'older-version';
+      const older = await replaceOlderDaemon(root, answered);
+      if (older === 'kept' && answered) return null;
+      // None reachable — spawn one (detached) and poll for its bind. After a
+      // replacement this launcher holds the writer slot for it meanwhile.
+      try {
+        spawnDetachedDaemon(root, older === 'stopped');
+        for (let attempt = 0; attempt < DAEMON_CONNECT_MAX_RETRIES; attempt++) {
+          await sleep(DAEMON_CONNECT_RETRY_DELAY_MS);
+          const s = await connectAnyCandidate();
+          // Another version answering now, older or not, waits for the next
+          // retry: one replacement per attempt, so this can never loop.
+          if (s === 'older-version' || s === 'version-mismatch') return null;
+          if (s) return s;
+        }
+        return null; // never bound — the proxy serves this session in-process
+      } finally {
+        // The new daemon has taken the slot over, or never came; a no-op unless still ours.
+        if (older === 'stopped') releaseWriterLock(root);
       }
-      return null; // never bound — the proxy serves this session in-process
     };
     await runLocalHandshakeProxy({ getDaemonSocket, makeEngine: () => makeFallbackEngine(root), root });
   }
diff --git a/src/mcp/project-lifecycle.ts b/src/mcp/project-lifecycle.ts
index ba405f57d1..1a634815eb 100644
--- a/src/mcp/project-lifecycle.ts
+++ b/src/mcp/project-lifecycle.ts
@@ -2,13 +2,15 @@
 import { realpathSync } from 'fs';
 import type { Socket } from 'net';
 import type CodeGraph from '../index';
-import { isInitialized } from '../directory';
+import { canonicalProjectRoot, isInitialized } from '../directory';
 import { LockUnavailableError, watchDisabledReason } from '../sync';
 import { getDaemonSocketCandidates } from './daemon-paths';
 import { connectWithHello } from './proxy';
 import { markWriterReady, readWriterLock, releaseWriterLock, tryAcquireWriterLock } from './writer-lock';
 
 interface Project {
+  /** Identity key: one entry however the root is spelled (#2278). */
+  key: string;
   cg: CodeGraph;
   refs: number;
   owner: boolean;
@@ -35,13 +37,14 @@ export function acquireProject(
   options: Parameters<CodeGraph['watch']>[0],
 ): ProjectLease {
   root = realpathSync(root);
-  let project = projects.get(root);
+  const key = canonicalProjectRoot(root);
+  let project = projects.get(key);
   if (!project) {
     const cg = open();
-    project = { cg, refs: 0, owner: false, caughtUp: false, retirement: null, gate: null, socket: null, options,
+    project = { key, cg, refs: 0, owner: false, caughtUp: false, retirement: null, gate: null, socket: null, options,
       timer: setInterval(() => { void ready(root, project!); }, 1000) };
     project.timer.unref();
-    projects.set(root, project);
+    projects.set(key, project);
   }
   const entry = project;
   entry.refs++;
@@ -80,7 +83,7 @@ function retire(root: string, project: Project): Promise<void> {
       setTimeout(finish, 25);
       return;
     }
-    projects.delete(root);
+    projects.delete(project.key);
     project.cg.close();
     if (project.owner) releaseWriterLock(root);
     resolve();
@@ -115,7 +118,8 @@ async function activate(root: string, project: Project): Promise<void> {
     if (writer.existing?.mode === 'daemon') {
       for (const candidate of getDaemonSocketCandidates(root)) {
         const socket = await connectWithHello(candidate);
-        if (!socket || socket === 'version-mismatch') continue;
+        // A daemon of another version, older or not, is left to the project's own launchers.
+        if (!socket || typeof socket === 'string') continue;
         if (project.refs === 0) { socket.destroy(); return; }
         project.socket = socket;
         socket.once('close', () => {
diff --git a/src/mcp/proxy.ts b/src/mcp/proxy.ts
index bdcb997d2a..c0d9f6cafb 100644
--- a/src/mcp/proxy.ts
+++ b/src/mcp/proxy.ts
@@ -26,18 +26,38 @@ import { EARLY_PPID } from './early-ppid';
 import { supervisionLostReason } from './ppid-watchdog';
 import { armStartupHandshakeTimeout } from './startup-handshake';
 import { treatStdinFailureAsShutdown } from './stdin-teardown';
-import { CodeGraphPackageVersion } from './version';
+import { CodeGraphPackageVersion, isOlderRelease } from './version';
 import { SERVER_INFO, PROTOCOL_VERSION, initializeInstructions } from './session';
 import { SERVER_INSTRUCTIONS } from './server-instructions';
 import { getStaticTools } from './tools';
+import { ErrorCodes } from './transport';
 import { ExploreSessionState } from './explore-session-state';
 import { getTelemetry, ClientInfo } from '../telemetry';
 import { installMainThreadWatchdog, WatchdogHandle } from './liveness-watchdog';
 import type { MCPEngine } from './engine';
+import { WORKER_START_SETTLE_MS } from '../worker-teardown';
 
 /** Default poll cadence for the PPID watchdog (same as the direct server). */
 const DEFAULT_PPID_POLL_MS = 5000;
 
+/**
+ * How long a proxy serving in-process waits before trying the shared daemon
+ * again, doubling after each miss up to the cap (#2277). Tunable through
+ * `CODEGRAPH_DAEMON_RETRY_MS` (`0` turns retrying off) and
+ * `CODEGRAPH_DAEMON_RETRY_MAX_MS`.
+ */
+const DEFAULT_DAEMON_RETRY_MS = 5_000;
+const DEFAULT_DAEMON_RETRY_MAX_MS = 300_000;
+
+/**
+ * Longest the proxy waits, once it is shutting down, for its in-process engines
+ * to stop before exiting anyway. An engine's stop waits up to
+ * {@link WORKER_START_SETTLE_MS} for a query worker still starting up (exiting
+ * mid-start can crash the process on Windows); this bounds a stop that never
+ * settles (#2311).
+ */
+const SHUTDOWN_BACKSTOP_MS = WORKER_START_SETTLE_MS + 5_000;
+
 /**
  * Env var that opts INTO the "attached to shared daemon" log line. Off by
  * default: the line is benign INFO, but MCP hosts render any server stderr at
@@ -128,14 +148,17 @@ export async function runProxy(
 
 /**
  * Connect to a daemon at `socketPath` and verify its hello (exact version match).
- * Returns the live socket (hello already consumed) or null if unreachable / stale
- * / version-mismatched. Unlike {@link runProxy} it does NOT pipe — the caller
- * owns the socket. Used by the local-handshake proxy's background connect.
+ * Returns the live socket (hello already consumed), null if unreachable / stale,
+ * or — for a daemon of another version — `'older-version'` when it runs an older
+ * release ({@link isOlderRelease}; the launcher replaces it, #2335) and
+ * `'version-mismatch'` for any other version, which is left alone. Unlike
+ * {@link runProxy} it does NOT pipe — the caller owns the socket. Used by the
+ * local-handshake proxy's background connect.
  */
 export async function connectWithHello(
   socketPath: string,
   expectedVersion: string = CodeGraphPackageVersion,
-): Promise<net.Socket | 'version-mismatch' | null> {
+): Promise<net.Socket | 'older-version' | 'version-mismatch' | null> {
   if (process.platform !== 'win32' && !fs.existsSync(socketPath)) return null;
   const socket = net.createConnection(socketPath);
   socket.setEncoding('utf8');
@@ -156,12 +179,14 @@ export async function connectWithHello(
   }
   if (hello.codegraph !== expectedVersion) {
     // A daemon IS up but it's the wrong version — definitive, not a "not yet".
-    // Don't poll; the caller serves in-process so we never run stale-vs-new.
+    socket.destroy();
+    // An older release is the launcher's to replace (#2335); it says what it did.
+    if (isOlderRelease(hello.codegraph, expectedVersion)) return 'older-version';
+    // Any other: don't poll; the caller serves in-process so we never run stale-vs-new.
     process.stderr.write(
       `[CodeGraph MCP] Found a daemon on ${socketPath} but version (${hello.codegraph}) ` +
       `differs from ours (${expectedVersion}); serving this session in-process.\n`
     );
-    socket.destroy();
     return 'version-mismatch';
   }
   logAttachedDaemon(socketPath, hello);
@@ -192,11 +217,13 @@ type JsonRpc = Record<string, unknown>;
 /** Dependencies the local-handshake proxy needs, injected by MCPServer (which
  *  owns the daemon-spawn machinery and the engine factory). */
 export interface LocalHandshakeDeps {
-  /** Probe → spawn → retry → hello-verify; resolves a connected daemon socket,
-   *  or null when the daemon path is genuinely unavailable (→ in-process fallback). */
+  /** Probe (replacing a daemon of an older release, #2335) → spawn → retry →
+   *  hello-verify; resolves a connected daemon socket, or null when the daemon
+   *  path is genuinely unavailable (→ in-process fallback). */
   getDaemonSocket(): Promise<net.Socket | null>;
-  /** Lazily create an in-process engine — used ONLY if the daemon never comes up,
-   *  preserving the "a broken daemon never wedges a session" guarantee. */
+  /** Lazily create an in-process engine — used only while the daemon is
+   *  unreachable, preserving the "a broken daemon never wedges a session"
+   *  guarantee. Called again whenever the previous engine was retired (#2277). */
   makeEngine(): MCPEngine;
   /** Project root for the fallback engine's lazy init. */
   root: string;
@@ -214,6 +241,12 @@ export interface LocalHandshakeDeps {
  * the local one). If the daemon never comes up (version mismatch / spawn fail),
  * a lazily-created in-process engine serves the calls — so the handshake speedup
  * never costs the old fall-back-to-direct robustness.
+ *
+ * Serving in-process is not for the rest of the session (#2277): that engine
+ * may own the project's writer lock, and no daemon can start while it does, so
+ * every other session on the project would be stuck without auto-sync. The
+ * proxy retries the daemon with backoff, handing the writer lock back first,
+ * and proxies again once one answers.
  */
 export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<void> {
   // The proxy is long-lived and can serve fallback tool calls in-process. Match
@@ -223,6 +256,7 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
   let daemonStatus: 'connecting' | 'ready' | 'failed' = 'connecting';
   let daemonSocket: net.Socket | null = null;
   let clientInitId: unknown = undefined;   // suppress the daemon's reply to the forwarded initialize
+  let clientInitLine: string | undefined;  // replayed to a daemon that comes up mid-session (#2277)
   // Telemetry attribution for the in-process fallback only — calls routed to
   // the daemon are counted by the daemon's own session (which receives the
   // forwarded initialize, clientInfo included), never double-counted here.
@@ -230,7 +264,16 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
   const pending: string[] = [];            // client lines buffered until the daemon resolves
   let engine: MCPEngine | null = null;
   let engineReady: Promise<void> | null = null;
+  // Calls being served in-process; the engine is only ever stopped after they finish.
+  const localCalls = new Set<Promise<void>>();
+  // Engines retired but not yet stopped; shutdown() waits for them too.
+  const retiring = new Set<MCPEngine>();
   let shuttingDown = false;
+  const retryBaseMs = parseDelayMs(process.env.CODEGRAPH_DAEMON_RETRY_MS, DEFAULT_DAEMON_RETRY_MS);
+  const retryMaxMs = Math.max(retryBaseMs, parseDelayMs(process.env.CODEGRAPH_DAEMON_RETRY_MAX_MS, DEFAULT_DAEMON_RETRY_MAX_MS));
+  let retryDelayMs = retryBaseMs;
+  let retryTimer: NodeJS.Timeout | null = null;
+  let attachedAt = 0;
   // Requests forwarded to the daemon and not yet answered, keyed by JSON-RPC id.
   // If the daemon dies mid-session (#662 — e.g. an MCP host SIGTERM's it when a
   // new session starts), these would otherwise hang forever; we re-serve them
@@ -255,24 +298,63 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
   const shutdown = (): void => {
     if (shuttingDown) return; shuttingDown = true;
     try { livenessWatchdog?.stop(); } catch { /* ignore */ }
+    if (retryTimer) clearTimeout(retryTimer);
     try { daemonSocket?.destroy(); } catch { /* ignore */ }
-    try { engine?.stop(); } catch { /* ignore */ }
-    process.exit(0);
+    // Exit once every engine has stopped, a retiring one included: exiting while
+    // a query worker is still starting up can crash the process on Windows (see
+    // QueryPool.destroy), and stopping releases the writer lock. The backstop
+    // bounds a stop that never settles; it stays ref'd so the process lives
+    // until one of the two exits it.
+    setTimeout(() => {
+      process.stderr.write(`[CodeGraph MCP] In-process engine did not stop within ${SHUTDOWN_BACKSTOP_MS}ms; exiting anyway.\n`);
+      process.exit(0);
+    }, SHUTDOWN_BACKSTOP_MS);
+    const stopping = [engine, ...retiring].map((e) => Promise.resolve().then(() => e?.stop()));
+    void Promise.allSettled(stopping).then(() => process.exit(0));
   };
-  const ensureEngine = (): Promise<void> => {
-    if (!engine) engine = deps.makeEngine();
-    if (!engineReady) engineReady = engine.ensureInitialized(deps.root).catch(() => { /* degraded */ });
-    return engineReady;
+  // Resolves the engine a call was started on, so a call in flight while the
+  // engine is being retired still finishes on it.
+  const ensureEngine = async (): Promise<MCPEngine> => {
+    // shutdown() stops only the engines it can see; never start one after it.
+    if (!engine && shuttingDown) throw new Error('codegraph is shutting down');
+    if (!engine) {
+      engine = deps.makeEngine();
+      engineReady = engine.ensureInitialized(deps.root).catch(() => { /* degraded */ });
+    }
+    const current = engine;
+    await engineReady;
+    return current;
+  };
+  // Stop the in-process engine once the calls it is serving have answered.
+  // Stopping it releases the writer lock if it held one.
+  const retireEngine = async (): Promise<void> => {
+    const retired = engine;
+    engine = null;
+    engineReady = null;
+    if (retired) retiring.add(retired);
+    try {
+      await Promise.allSettled([...localCalls]);
+      try { await retired?.stop(); } catch { /* best-effort */ }
+    } finally {
+      if (retired) retiring.delete(retired);
+    }
   };
   // Daemon-unavailable fallback: serve a client message in-process.
-  const handleLocally = async (line: string): Promise<void> => {
+  const handleLocally = (line: string): Promise<void> => {
+    const call = serveLocally(line);
+    localCalls.add(call);
+    const done = (): void => { localCalls.delete(call); };
+    call.then(done, done);
+    return call;
+  };
+  const serveLocally = async (line: string): Promise<void> => {
     let msg: JsonRpc; try { msg = JSON.parse(line) as JsonRpc; } catch { return; }
     const id = msg.id;
     if (msg.method === 'tools/call' && id !== undefined) {
       try {
-        await ensureEngine();
+        const local = await ensureEngine();
         const params = (msg.params || {}) as { name: string; arguments?: Record<string, unknown> };
-        const result = await engine!.getToolHandler().execute(params.name, params.arguments || {}, exploreSession);
+        const result = await local.getToolHandler().execute(params.name, params.arguments || {}, exploreSession);
         writeClient({ jsonrpc: '2.0', id, result });
         getTelemetry().recordUsage('mcp_tool', params.name, !result.isError, telemetryClient);
       } catch (err) {
@@ -304,6 +386,9 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
   let stdinBuf = '';
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', (chunk: string) => {
+    // Nothing is served once shutdown starts: a call now could start an engine
+    // shutdown() never sees, and the process exits as soon as the others stop.
+    if (shuttingDown) return;
     stdinBuf += chunk;
     let idx: number;
     while ((idx = stdinBuf.indexOf('\n')) !== -1) {
@@ -313,6 +398,7 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
       let msg: JsonRpc; try { msg = JSON.parse(line) as JsonRpc; } catch { routeToDaemon(line); continue; }
       if (msg.method === 'initialize') {
         clientInitId = msg.id;
+        clientInitLine = line;
         const initParams = (msg.params ?? {}) as { clientInfo?: { name?: unknown; version?: unknown } };
         if (initParams.clientInfo) {
           telemetryClient = {
@@ -332,6 +418,12 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
         writeClient({ jsonrpc: '2.0', id: msg.id, result: { resourceTemplates: [] } });
       } else if (msg.method === 'prompts/list') {
         writeClient({ jsonrpc: '2.0', id: msg.id, result: { prompts: [] } });
+      } else if (msg.method === 'server/discover' && msg.id !== undefined) {
+        // Newer clients (Antigravity 2.5) probe this before `initialize` and wait
+        // for the answer. We don't implement it; Method-not-found is what sends
+        // them on to `initialize`. Answer locally — forwarded, it waited on the
+        // daemon connection and was lost if the client closed stdin first. (#2084)
+        writeClient({ jsonrpc: '2.0', id: msg.id, error: { code: ErrorCodes.MethodNotFound, message: 'Method not found: server/discover' } });
       } else {
         routeToDaemon(line);
       }
@@ -357,15 +449,58 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
   });
 
   // ---- daemon connection (background) ----
-  let socket: net.Socket | null = null;
-  try { socket = await deps.getDaemonSocket(); } catch { socket = null; }
+  const connectDaemon = async (): Promise<net.Socket | null> => {
+    let socket: net.Socket | null = null;
+    try { socket = await deps.getDaemonSocket(); } catch { socket = null; }
+    // `socket.destroyed`: the connect-window error guard above can absorb an
+    // 'error' that already destroyed the socket before we got here (#974) — treat
+    // a dead socket as "no daemon" so we cleanly fall back to the in-process engine.
+    if (socket && (socket.destroyed || shuttingDown)) {
+      try { socket.destroy(); } catch { /* ignore */ }
+      socket = null;
+    }
+    return socket;
+  };
+  // Every buffered call binds to the engine now, so a later retirement waits for all of them.
+  const serveBufferedLocally = (): void => {
+    for (const line of pending.splice(0)) void handleLocally(line);
+  };
+  const scheduleDaemonRetry = (): void => {
+    if (shuttingDown || retryTimer || retryBaseMs <= 0) return;
+    const delay = retryDelayMs;
+    retryDelayMs = Math.min(retryDelayMs * 2, retryMaxMs);
+    retryTimer = setTimeout(() => { retryTimer = null; void retryDaemon(); }, delay);
+    retryTimer.unref?.();
+  };
+  const retryDaemon = async (): Promise<void> => {
+    if (shuttingDown || daemonStatus !== 'failed') return;
+    // While a writing engine owns writer.pid no daemon can start (#2277). Hand
+    // the lock back first, once the calls it is serving have answered, and
+    // buffer new calls until a daemon answers or we resume in-process. One
+    // writer at a time: the engine is fully stopped before a daemon is spawned.
+    const handover = engine !== null && !engine.isReadOnly();
+    if (handover) {
+      daemonStatus = 'connecting';
+      await retireEngine();
+    }
+    const socket = await connectDaemon();
+    if (shuttingDown) return;
+    if (socket) {
+      process.stderr.write('[CodeGraph MCP] Shared daemon reachable; proxying this session to it instead of serving in-process.\n');
+      attachDaemon(socket, true);
+      // A read-only engine holds no lock: let its calls finish, then close it.
+      if (!handover) void retireEngine();
+      return;
+    }
+    daemonStatus = 'failed';
+    serveBufferedLocally();
+    scheduleDaemonRetry();
+  };
 
-  // `!socket.destroyed`: the connect-window error guard above can absorb an
-  // 'error' that already destroyed the socket before we got here (#974) — treat
-  // a dead socket as "no daemon" so we cleanly fall back to the in-process engine.
-  if (socket && !socket.destroyed && !shuttingDown) {
+  const attachDaemon = (socket: net.Socket, replayInitialize: boolean): void => {
     daemonSocket = socket;
     daemonStatus = 'ready';
+    attachedAt = Date.now();
     let sockBuf = '';
     socket.setEncoding('utf8');
     socket.on('data', (chunk: string) => {
@@ -390,33 +525,48 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
     // The daemon going away does NOT end the session (#662). An MCP host can
     // SIGTERM the shared daemon when another session starts; if we exited here,
     // this host would silently lose CodeGraph and any in-flight request would
-    // hang. Instead, fall back to the in-process engine for the rest of the
-    // session and re-serve whatever the dead daemon never answered.
+    // hang. Instead, fall back to the in-process engine until a daemon answers
+    // again, and re-serve whatever the dead daemon never answered.
     const onDaemonLost = (): void => {
-      if (shuttingDown || daemonStatus !== 'ready') return; // host teardown, or already handled
+      if (shuttingDown || daemonSocket !== socket) return; // host teardown, or already handled
       daemonStatus = 'failed';
-      try { daemonSocket?.destroy(); } catch { /* ignore */ }
       daemonSocket = null;
+      try { socket.destroy(); } catch { /* ignore */ }
       process.stderr.write(
         `[CodeGraph MCP] Shared daemon connection lost; serving this session in-process (degraded), re-serving ${inflight.size} in-flight request(s).\n`
       );
       const orphaned = [...inflight.values()];
       inflight.clear();
       for (const line of orphaned) void handleLocally(line);
+      // A link that stayed up past the longest wait starts the backoff over; one
+      // that keeps dropping right after it attaches keeps backing off.
+      if (Date.now() - attachedAt >= retryMaxMs) retryDelayMs = retryBaseMs;
+      scheduleDaemonRetry();
     };
     socket.on('close', onDaemonLost);
     socket.on('error', onDaemonLost);
+    // A daemon that came up mid-session has never seen this client: prime its
+    // session with the client's own initialize, whose reply is suppressed
+    // above like the first one.
+    if (replayInitialize && clientInitLine !== undefined) {
+      try { socket.write(clientInitLine + '\n'); } catch { /* close path */ }
+    }
     for (const line of pending) {
       trackInflight(line);
       if (process.env.CODEGRAPH_MCP_DEBUG) process.stderr.write(`[mcp-debug] proxy-flush ${line.slice(0, 80)}\n`);
       try { socket.write(line + '\n'); } catch { /* ignore */ }
     }
     pending.length = 0;
+  };
+
+  const socket = await connectDaemon();
+  if (socket) {
+    attachDaemon(socket, false);
   } else if (!shuttingDown) {
     daemonStatus = 'failed';
     process.stderr.write('[CodeGraph MCP] Shared daemon unavailable; serving this session in-process (degraded).\n');
-    const buffered = pending.splice(0);
-    for (const line of buffered) await handleLocally(line);
+    serveBufferedLocally();
+    scheduleDaemonRetry();
   }
 
   await new Promise<void>(() => { /* stdin keeps the loop alive; exit via shutdown() */ });
@@ -581,10 +731,15 @@ function startPpidWatchdog(socket: net.Socket): void {
 }
 
 function parsePollMs(raw: string | undefined): number {
-  if (raw === undefined || raw === '') return DEFAULT_PPID_POLL_MS;
+  return parseDelayMs(raw, DEFAULT_PPID_POLL_MS);
+}
+
+/** A non-negative millisecond env value; unset or malformed gives `fallback`. */
+function parseDelayMs(raw: string | undefined, fallback: number): number {
+  if (raw === undefined || raw === '') return fallback;
   const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) return DEFAULT_PPID_POLL_MS;
-  if (parsed < 0) return DEFAULT_PPID_POLL_MS;
+  if (!Number.isFinite(parsed)) return fallback;
+  if (parsed < 0) return fallback;
   return Math.floor(parsed);
 }
 
diff --git a/src/mcp/query-pool.ts b/src/mcp/query-pool.ts
index b3a0f5322e..6b1f473991 100644
--- a/src/mcp/query-pool.ts
+++ b/src/mcp/query-pool.ts
@@ -69,6 +69,17 @@ const CRASH_BUDGET = 12;
  */
 const MAX_CONCURRENT_SPAWN = 2;
 
+/**
+ * How long `destroy()` waits for a worker that is still starting up before
+ * terminating it anyway. Terminating a worker while it is still loading its
+ * modules can take the whole process down with an access violation
+ * (0xC0000005, seen on Windows), and the daemon shuts its pool down whenever
+ * it stops — a session that ends within a few seconds of starting has a
+ * worker in exactly that state. A start takes about a second normally and a
+ * few under heavy load; the cap only bounds a start that is wedged.
+ */
+const WORKER_START_SETTLE_MS = 15_000;
+
 /** Shape of a message a worker posts back (ready handshake or a tool result). */
 interface WorkerMessage {
   type?: string;
@@ -99,6 +110,8 @@ export interface QueryPoolOptions {
   maxRetries?: number;
   /** Worker factory (tests inject a fake). Defaults to a real `worker_threads` Worker. */
   createWorker?: () => PoolWorker;
+  /** How long destroy() waits on a worker still starting up (tests shorten it). Default 15s. */
+  startSettleMs?: number;
 }
 
 /**
@@ -150,6 +163,10 @@ export class QueryPool {
   // a large DB open) saturate the box and starve the main loop. Grow only when
   // the queue outstrips idle + pending.
   private pendingWorkers = new Set<PoolWorker>();
+  // Each worker's start, settled when it posts 'ready' (either way) or goes
+  // away — what destroy() waits on before terminating it (see
+  // WORKER_START_SETTLE_MS).
+  private starts = new Map<PoolWorker, { settled: Promise<void>; settle: () => void }>();
   private nextId = 1;
   private totalCrashes = 0;
   private destroyed = false;
@@ -158,6 +175,7 @@ export class QueryPool {
   private readonly softTimeoutMs: number;
   private readonly maxRetries: number;
   private readonly createWorker: () => PoolWorker;
+  private readonly startSettleMs: number;
 
   constructor(opts: QueryPoolOptions) {
     this.root = opts.root;
@@ -165,6 +183,7 @@ export class QueryPool {
     this.softTimeoutMs = opts.softTimeoutMs ?? resolveBusyTimeoutMs();
     this.maxRetries = opts.maxRetries ?? 1;
     this.createWorker = opts.createWorker ?? (() => new Worker(WORKER_FILE, { workerData: { root: this.root } }));
+    this.startSettleMs = opts.startSettleMs ?? WORKER_START_SETTLE_MS;
     this.spawnOne(); // one eager warm worker, ready for the first call
   }
 
@@ -211,12 +230,18 @@ export class QueryPool {
     }
     this.workers.add(w);
     this.pendingWorkers.add(w);
+    let settle!: () => void;
+    const settled = new Promise<void>((resolve) => { settle = resolve; });
+    this.starts.set(w, { settled, settle });
     w.on('message', (m) => this.onMessage(w, (m ?? {}) as WorkerMessage));
-    w.on('error', () => this.onWorkerGone(w));
-    w.on('exit', (code) => { if (code !== 0) this.onWorkerGone(w); });
+    w.on('error', () => { this.startSettled(w); this.onWorkerGone(w); });
+    w.on('exit', (code) => { this.startSettled(w); if (code !== 0) this.onWorkerGone(w); });
   }
 
   private onMessage(w: PoolWorker, m: WorkerMessage): void {
+    // Before the retired-worker check: destroy() waits on this for a worker
+    // it has already let go of.
+    if (m?.type === 'ready') this.startSettled(w);
     if (!m || !this.workers.has(w)) return; // ignore late messages from retired workers
     if (m.type === 'ready') {
       if (!this.pendingWorkers.delete(w)) return; // already handled this handshake
@@ -311,7 +336,36 @@ export class QueryPool {
     });
   }
 
-  /** Terminate all workers and answer any outstanding calls gracefully. */
+  private startSettled(w: PoolWorker): void {
+    const start = this.starts.get(w);
+    if (!start) return;
+    this.starts.delete(w);
+    start.settle();
+  }
+
+  /**
+   * Terminate a worker, but not while it is still starting up: wait for it to
+   * post 'ready' (or go away), up to `startSettleMs` (WORKER_START_SETTLE_MS —
+   * see that constant for the crash this avoids).
+   */
+  private async terminateStarted(w: PoolWorker): Promise<void> {
+    const start = this.starts.get(w);
+    if (start) {
+      let cap: NodeJS.Timeout | undefined;
+      await Promise.race([
+        start.settled,
+        new Promise<void>((resolve) => { cap = setTimeout(resolve, this.startSettleMs); cap.unref?.(); }),
+      ]);
+      clearTimeout(cap);
+    }
+    try { await w.terminate(); } catch { /* already gone */ }
+  }
+
+  /**
+   * Terminate all workers and answer any outstanding calls gracefully. A worker
+   * still starting up is terminated once it has started (see
+   * WORKER_START_SETTLE_MS); outstanding calls are answered first.
+   */
   async destroy(): Promise<void> {
     if (this.destroyed) return;
     this.destroyed = true;
@@ -324,6 +378,6 @@ export class QueryPool {
     }
     this.inflight.clear();
     this.queue = [];
-    await Promise.all(ws.map((w) => Promise.resolve(w.terminate()).catch(() => { /* already gone */ })));
+    await Promise.all(ws.map((w) => this.terminateStarted(w)));
   }
 }
diff --git a/src/mcp/tools.ts b/src/mcp/tools.ts
index 7553ca5a65..fa8f35425b 100644
--- a/src/mcp/tools.ts
+++ b/src/mcp/tools.ts
@@ -26,8 +26,10 @@ export function __setLoadCodeGraphForTests(cls: typeof import('../index').defaul
 }
 import {
   detectWorktreeIndexMismatch,
+  nestedRepositoryBelow,
   worktreeMismatchWarning,
   worktreeMismatchNotice,
+  type NestedRepository,
   type WorktreeIndexMismatch,
 } from '../sync/worktree';
 import type { PendingFile } from '../sync';
@@ -51,6 +53,7 @@ import { clamp, validatePathWithinRoot, validateProjectPath, isConfigLeafNode, C
 import { guardLabel, guardsForFileSync, siteKey, supportsBranchGuards, warmBranchGuardGrammars } from '../graph/branch-guards';
 import { findDynamicBoundaries, type BoundarySite } from '../graph/dynamic-boundary-report';
 import { countImplementers } from '../graph/type-hierarchy';
+import { isCopybookInclude, MAX_COPYBOOK_INCLUDES, type NamedCopybook } from '../graph/cobol-copybooks';
 import {
   findAllSymbols,
   resolveNamedSymbolFlow,
@@ -1538,7 +1541,6 @@ export interface ToolResult {
   _cgExploreEmission?: ExploreEmission;
   /** Internal structured provenance, preserved by query workers and stripped by execute. */
   _cgAnswerFiles?: AnswerFile[];
-  structuredContent?: Record<string, unknown>;
 }
 
 /**
@@ -1867,6 +1869,23 @@ function canonicalPath(p: string): string {
  */
 export const MAX_CACHED_PROJECTS = 8;
 
+/**
+ * How long an explicit-`projectPath` project may go unused before the handler
+ * releases it (#2087). Releasing frees its SQLite handle, its watcher and the
+ * writer lock the engine may hold on that project — which otherwise stays held
+ * for the whole life of this daemon, locking the project's own daemon and
+ * `codegraph index` out. The next call reopens it and catches up.
+ * `CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS` overrides it; `0` never releases.
+ */
+const DEFAULT_PROJECT_IDLE_TIMEOUT_MS = 600_000;
+function resolveProjectIdleTimeoutMs(): number {
+  const raw = process.env.CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS;
+  if (raw === undefined || raw === '') return DEFAULT_PROJECT_IDLE_TIMEOUT_MS;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) return DEFAULT_PROJECT_IDLE_TIMEOUT_MS;
+  return Math.floor(n);
+}
+
 /**
  * Engine-side lifecycle for a project the ToolHandler opened for an explicit
  * `projectPath` (#1835). `activate` gives it the same treatment the default
@@ -1892,6 +1911,10 @@ export class ToolHandler {
   // CANONICAL (realpath) index root. Map insertion order doubles as LRU order:
   // a hit re-inserts, and `MAX_CACHED_PROJECTS` bounds the size (#1835).
   private projectCache: Map<string, CodeGraph> = new Map();
+  // When each cached root was last handed to a call, and the one timer that
+  // releases the oldest once it has been idle long enough (#2087).
+  private projectUsedAt: Map<string, number> = new Map();
+  private idleReleaseTimer: NodeJS.Timeout | null = null;
   // Engine hook that watches + catches up an explicit project (null for the
   // CLI and worker-thread handlers, which never own a watcher).
   private projectLifecycle: ProjectLifecycle | null = null;
@@ -1921,6 +1944,10 @@ export class ToolHandler {
   // once and every later tool call reuses the result — never shelling out to
   // git on the hot path. `undefined` = not computed yet; `null` = no mismatch.
   private worktreeMismatchCache: Map<string, WorktreeIndexMismatch | null> = new Map();
+  // Per-(projectPath, index root) cache of the different git repository the
+  // path sits in below that root, if any (#2110) — the git half of
+  // `uncoveredNestedRepo`, memoized like the mismatch above.
+  private nestedRepoCache: Map<string, NestedRepository | null> = new Map();
   // Gate that the MCP engine pokes after `cg.open()` so the first tool call
   // blocks on the post-open filesystem reconcile (catch-up sync). Without
   // this, a tool call that races past `catchUpSync()` serves rows for files
@@ -2240,6 +2267,30 @@ export class ToolHandler {
       );
     }
 
+    const cg = this.openProjectRoot(resolvedRoot, canonicalRoot);
+    // The walk above crosses git boundaries. A nested repository the ancestor
+    // index leaves out (typically gitignored) would otherwise be answered from
+    // the ancestor's code, looking like an answer about the requested project
+    // (#2110) — so it gets the same guidance as a project with no index at all.
+    const nested = this.uncoveredNestedRepo(projectPath, canonicalRoot, cg);
+    if (nested) {
+      throw new NotIndexedError(
+        `The project at ${projectPath} isn't indexed with codegraph: it is its own git repository ` +
+        `(${nested.root}), and the nearest index, at ${canonicalRoot}, holds none of its files ` +
+        '(that repository is excluded from it, e.g. by a .gitignore), so codegraph cannot query it. ' +
+        "Use your built-in tools (Read/Grep/Glob) for that codebase instead, and don't call codegraph " +
+        "for it again this session. Indexing is the user's decision — they can run 'codegraph init' " +
+        `in ${nested.root} to enable it.`
+      );
+    }
+    return cg;
+  }
+
+  /**
+   * The open CodeGraph for an index root the up-walk resolved: the default
+   * instance, a cached one, or a newly opened (and cached) one.
+   */
+  private openProjectRoot(resolvedRoot: string, canonicalRoot: string): CodeGraph {
     // If the path resolves to the default project, reuse the already-open
     // default instance rather than opening a SECOND connection to the same DB.
     // A duplicate connection serializes reads against the watcher's auto-sync
@@ -2260,6 +2311,7 @@ export class ToolHandler {
       // Refresh LRU position.
       this.projectCache.delete(canonicalRoot);
       this.projectCache.set(canonicalRoot, cached);
+      this.projectUsedAt.set(canonicalRoot, Date.now());
       return this.freshen(cached);
     }
 
@@ -2269,6 +2321,7 @@ export class ToolHandler {
       if (isSameIndexRoot(root, resolvedRoot)) {
         this.projectCache.delete(root);
         this.projectCache.set(root, open);
+        this.projectUsedAt.set(root, Date.now());
         return this.freshen(open);
       }
     }
@@ -2276,10 +2329,39 @@ export class ToolHandler {
     const open = () => loadCodeGraph().openSync(canonicalRoot);
     const cg = this.projectLifecycle?.open(canonicalRoot, open) ?? open();
     this.projectCache.set(canonicalRoot, cg);
+    this.projectUsedAt.set(canonicalRoot, Date.now());
     this.trimProjects();
     return cg;
   }
 
+  /**
+   * The nested git repository `projectPath` lives in when the index the
+   * up-walk reached (`indexRoot`'s, open as `cg`) holds none of its files; null
+   * when that index covers it — an ordinary subdirectory, a submodule or
+   * embedded clone the ancestor indexes, a linked worktree (#155) — or when git
+   * can't tell (#2110).
+   *
+   * The git half is memoized per (projectPath, index root), keyed on both for
+   * the reason `worktreeMismatchCache` is (#926). The index half is one
+   * primary-key probe per call, so a sync that brings the repository into the
+   * index is honored without a restart.
+   */
+  private uncoveredNestedRepo(projectPath: string, indexRoot: string, cg: CodeGraph): NestedRepository | null {
+    const cacheKey = `${projectPath}\u0000${indexRoot}`;
+    let nested = this.nestedRepoCache.get(cacheKey);
+    if (nested === undefined) {
+      nested = nestedRepositoryBelow(projectPath, indexRoot);
+      this.nestedRepoCache.set(cacheKey, nested);
+    }
+    if (!nested) return null;
+    try {
+      return cg.hasFilesUnder(nested.relPath) ? null : nested;
+    } catch {
+      // An index we can't read is no evidence the repository is excluded.
+      return null;
+    }
+  }
+
   private async awaitProjectGate(projectPath: string): Promise<void> {
     const cg = this.getCodeGraph(projectPath);
     if (!this.projectLifecycle || cg === this.cg) return;
@@ -2295,13 +2377,21 @@ export class ToolHandler {
     await this.awaitCatchUpGate(gate);
   }
 
-  /** Never evict a graph while a tool call or its timed-out reconcile uses it. */
+  /**
+   * Never evict a graph while a tool call or its timed-out reconcile uses it.
+   * Evicts over the LRU bound, on close, and once idle past the timeout
+   * (#2087). The cache is in last-use order, so idle entries lead it.
+   */
   private trimProjects(): void {
     if (this.activeCalls > 0) return;
+    const idleMs = resolveProjectIdleTimeoutMs();
+    const now = Date.now();
     for (const [root, cg] of this.projectCache) {
-      if (!this.closing && this.projectCache.size <= MAX_CACHED_PROJECTS) break;
+      const idle = idleMs > 0 && now - (this.projectUsedAt.get(root) ?? now) >= idleMs;
+      if (!this.closing && this.projectCache.size <= MAX_CACHED_PROJECTS && !idle) break;
       if (this.projectGates.has(cg)) continue;
       this.projectCache.delete(root);
+      this.projectUsedAt.delete(root);
       if (this.projectLifecycle) {
         this.pendingCloses++;
         void Promise.resolve(this.projectLifecycle.release(cg)).finally(() => {
@@ -2313,6 +2403,26 @@ export class ToolHandler {
     if (this.closing && this.projectCache.size === 0 && this.pendingCloses === 0) {
       for (const resolve of this.closeWaiters.splice(0)) resolve();
     }
+    this.scheduleIdleRelease(idleMs);
+  }
+
+  /**
+   * Arm one unref'd timer for the oldest project a trim could release. A
+   * project whose catch-up is still running is trimmed when that settles; the
+   * 1s floor keeps a project a trim must skip from re-arming in a tight loop.
+   */
+  private scheduleIdleRelease(idleMs: number): void {
+    if (this.idleReleaseTimer || this.closing || idleMs <= 0) return;
+    for (const [root, cg] of this.projectCache) {
+      if (this.projectGates.has(cg)) continue;
+      const due = (this.projectUsedAt.get(root) ?? Date.now()) + idleMs - Date.now();
+      this.idleReleaseTimer = setTimeout(() => {
+        this.idleReleaseTimer = null;
+        this.trimProjects();
+      }, Math.min(Math.max(due, 1000), 0x7fffffff)); // setTimeout's 32-bit cap
+      this.idleReleaseTimer.unref();
+      return;
+    }
   }
 
   /**
@@ -2347,6 +2457,9 @@ export class ToolHandler {
   closeAll(): Promise<void> {
     this.closing = true;
     this.worktreeMismatchCache.clear();
+    if (this.idleReleaseTimer) clearTimeout(this.idleReleaseTimer);
+    this.idleReleaseTimer = null;
+    this.nestedRepoCache.clear();
     this.trimProjects();
     if (this.projectCache.size === 0 && this.activeCalls === 0 && this.pendingCloses === 0) return Promise.resolve();
     return new Promise((resolve) => this.closeWaiters.push(resolve));
@@ -2757,7 +2870,10 @@ export class ToolHandler {
             if (validation.unchecked.length > 20) lines.push(`- … ${validation.unchecked.length - 20} more (narrow the query)`);
           }
           lines.push('Retry after a successful codegraph sync, or narrow the query.');
-          return { ...this.textResult(lines.join('\n')), structuredContent: { freshness: validation } };
+          // Text only: Claude Code shows the model a result's structuredContent
+          // in place of its text (#2088). The text names every stale file and
+          // the first unchecked ones; the rest only need a narrower query.
+          return this.textResult(lines.join('\n'));
         }
       }
       // Record + STRIP before anything else touches the result: the emission is
@@ -3289,6 +3405,14 @@ export class ToolHandler {
         registeredAt,
       };
     }
+    if (m?.synthesizedBy === 'interface-impl' && typeof m.promotedInto === 'string') {
+      // Go: the implementing struct gets this method from a type it embeds.
+      return {
+        label: `interface dispatch — runs the method \`${m.promotedInto}\` gets by embedding (dynamic dispatch)`,
+        compact: `dynamic: interface → method promoted into ${m.promotedInto}${at}`,
+        registeredAt,
+      };
+    }
     if (m?.synthesizedBy === 'interface-impl') {
       return {
         label: `interface/abstract dispatch — runs the implementation override (dynamic dispatch)`,
@@ -3819,6 +3943,46 @@ export class ToolHandler {
     ].join('\n');
   }
 
+  /**
+   * The COBOL copybooks an explore query named (#2342): where each one's source
+   * lives, and every `COPY` / `EXEC SQL INCLUDE` statement that pulls it in —
+   * locations only, one per line. The source section can afford a few include
+   * windows; this list is what answers "what includes X / what does changing X
+   * touch" without a grep for `COPY X`. A member whose source is not indexed
+   * says so, so nobody goes hunting for a copybook file that is not here.
+   */
+  private buildCopybookSection(copybooks: NamedCopybook[]): string {
+    const MAX_LISTED_SITES = 25;
+    const blocks: string[] = [];
+    for (const copybook of copybooks) {
+      // Spelled as the code spells it — an include's member, else the file's
+      // stem — not as the query happened to type it.
+      const name = copybook.includes[0]?.name
+        ?? copybook.files[0]?.name.replace(/\.[^.]*$/, '')
+        ?? copybook.member;
+      const source = copybook.files.length > 0
+        ? `source ${copybook.files.map((f) => `\`${f.filePath}\``).join(', ')}`
+        : 'no indexed source (typically a DB2 DCLGEN member, a compiler-supplied copybook such as SQLCA, or one kept outside this project)';
+      const count = copybook.includes.length;
+      if (count === 0) {
+        blocks.push(`**COBOL copybook \`${name}\`** — ${source}; nothing indexed includes it (no \`COPY\` or \`EXEC SQL INCLUDE\` of it).`, '');
+        continue;
+      }
+      const sites = `${count}${count >= MAX_COPYBOOK_INCLUDES ? '+' : ''} site${count === 1 ? '' : 's'}`;
+      blocks.push(`**COBOL copybook \`${name}\`** — ${source}; included at ${sites}:`, '');
+      for (const include of copybook.includes.slice(0, MAX_LISTED_SITES)) {
+        const statement = /^\s*EXEC\b/i.test(include.signature ?? '') ? 'EXEC SQL INCLUDE' : 'COPY';
+        blocks.push(`- \`${include.filePath}:${include.startLine}\` — ${statement}`);
+      }
+      if (count > MAX_LISTED_SITES) {
+        const files = new Set(copybook.includes.slice(MAX_LISTED_SITES).map((n) => n.filePath)).size;
+        blocks.push(`- … +${count - MAX_LISTED_SITES} more site${count - MAX_LISTED_SITES === 1 ? '' : 's'} in ${files} file${files === 1 ? '' : 's'}`);
+      }
+      blocks.push('');
+    }
+    return blocks.join('\n');
+  }
+
   /**
    * Test-coverage note for a blast-radius entry whose DIRECT callers include no
    * test file. A helper called only by production code can still be exercised
@@ -4005,6 +4169,22 @@ export class ToolHandler {
         }
       } catch { /* path pinning must never fail an explore call */ }
     }
+    // A COBOL copybook the query names (`CVACT01Y`) names its FILE as surely as
+    // `app/cpy/CVACT01Y.cpy` would (#2342), so it is pinned the same way: the
+    // copybook's own source is admitted, ranked first and funded first. Looked
+    // up on the path-stripped query — a query that already pinned the file by
+    // path gets exactly the answer it got before. The include sites are listed
+    // in their own section below.
+    let namedCopybooks: NamedCopybook[] = [];
+    try {
+      namedCopybooks = cg.findNamedCopybooks(matchQuery);
+    } catch { /* copybook pinning must never fail an explore call */ }
+    for (const copybook of namedCopybooks) {
+      for (const file of copybook.files) {
+        if (pinnedFiles.length >= maxFiles) break;
+        if (!pinnedFiles.includes(file.filePath)) pinnedFiles = [...pinnedFiles, file.filePath];
+      }
+    }
     // A same-named file the span did not pin is named in the summary line, so
     // an agent that did mean it sees where it went instead of a silent drop.
     const setAsideNote = setAsideMatches.map((s) => {
@@ -4539,9 +4719,20 @@ export class ToolHandler {
       }
     }
 
+    // Import/export nodes add noise without information — except a COBOL
+    // include the query named (#2342). `COPY CVACT01Y` is where the copybook is
+    // pulled in, half of what a question about the copybook asks, so it is
+    // grouped, rendered (a window around the statement) and listed like any
+    // symbol. The context builder makes one an entry point only when the query
+    // names its member, so no other import ever passes this test.
+    const namedIncludeIds = new Set(subgraph.roots.filter((id) => {
+      const root = subgraph.nodes.get(id);
+      return root !== undefined && isCopybookInclude(root);
+    }));
+    const isListedSymbol = (n: Node): boolean =>
+      n.kind !== 'export' && (n.kind !== 'import' || namedIncludeIds.has(n.id));
     for (const node of subgraph.nodes.values()) {
-      // Skip import/export nodes — they add noise without information
-      if (node.kind === 'import' || node.kind === 'export') continue;
+      if (!isListedSymbol(node)) continue;
       // SECURITY (#383): never render the on-disk source of a config-leaf
       // (Spring application.{yml,properties} key) — its line is `key = <secret>`,
       // so whole-file/cluster rendering here would push secrets into context
@@ -4958,6 +5149,12 @@ export class ToolHandler {
     ];
     const summaryLineIdx = 2;
 
+    // A named COBOL copybook's include sites, ALL of them (#2342) — the source
+    // below has room for a few include windows, and "what includes X" is the
+    // question a copybook name asks.
+    const copybookSection = this.buildCopybookSection(namedCopybooks);
+    if (copybookSection) lines.push(copybookSection);
+
     // Blast radius (always-on, compact): for the entry symbols, who depends on
     // them + which tests cover them — locations only, no source — so the agent
     // knows what to update/verify before editing without a separate call.
@@ -5325,7 +5522,7 @@ export class ToolHandler {
       const hit = overheadCache.get(filePath);
       if (hit !== undefined) return hit;
       const names = [...new Set(
-        nodes.filter((n) => n.kind !== 'import' && n.kind !== 'export')
+        nodes.filter(isListedSymbol)
           .map((n) => `${n.name}(${n.kind})`),
       )].slice(0, budget.maxSymbolsInFileHeader);
       // header + blank, then ```lang / body / ``` / blank around the source.
@@ -5863,7 +6060,7 @@ export class ToolHandler {
       // The file node is not one of them: no section delivers "the file" as a
       // symbol, and it spans trailing lines no render prints.
       const wantedFrom = (nodes: readonly Node[]): ExploreWantedSpan[] => nodes
-        .filter((n) => n.kind !== 'import' && n.kind !== 'export' && n.kind !== 'file' && n.startLine > 0)
+        .filter((n) => isListedSymbol(n) && n.kind !== 'file' && n.startLine > 0)
         .map((n) => ({
           name: n.name,
           kind: n.kind,
@@ -5900,7 +6097,7 @@ export class ToolHandler {
           && !anchorSpans.has(filePath)
           && (onSpineGodFile || (!hasSpineNode && isPolymorphicSibling(group.nodes) && !spared))) {
         const syms = group.nodes
-          .filter(n => n.kind !== 'import' && n.kind !== 'export' && n.startLine > 0)
+          .filter(n => isListedSymbol(n) && n.startLine > 0)
           .sort((a, b) => a.startLine - b.startLine);
         // Pass 1: choose which symbols get a FULL body, by priority, greedily within
         // a per-file body cap — so one huge family file can't body every named method
@@ -6043,7 +6240,7 @@ export class ToolHandler {
           }
         }
         if (skel.length > 0) {
-          const names = [...new Set(group.nodes.filter(n => n.kind !== 'import' && n.kind !== 'export').map(n => n.name))]
+          const names = [...new Set(group.nodes.filter(isListedSymbol).map(n => n.name))]
             .slice(0, budget.maxSymbolsInFileHeader).join(', ');
           // Steer the agent to codegraph_explore for an elided body — NEVER to
           // Read. The old "Read for more" / "Read for a full body" tags invited
@@ -6202,7 +6399,7 @@ export class ToolHandler {
         const wholeSection = ddWhole.parts.map((p) => p.text).join(GAP_MARKER);
         const uniqSymbols = [...new Set(
           group.nodes
-            .filter(n => n.kind !== 'import' && n.kind !== 'export')
+            .filter(isListedSymbol)
             .map(n => `${n.name}(${n.kind})`)
         )];
         const headerNames = uniqSymbols.slice(0, budget.maxSymbolsInFileHeader);
@@ -7381,7 +7578,7 @@ export class ToolHandler {
       const g = fileGroups.get(fp);
       if (!g) return sum;
       return sum + new Set(
-        g.nodes.filter((n) => n.kind !== 'import' && n.kind !== 'export').map((n) => n.id),
+        g.nodes.filter(isListedSymbol).map((n) => n.id),
       ).size;
     }, 0);
     let summaryLine = survivors.length > 0
@@ -8006,9 +8203,8 @@ export class ToolHandler {
       }
     }
 
-    return { ...this.textResult(lines.join('\n')), structuredContent: {
-      freshness: { lastIndexedAt, changes, complete: changes !== null },
-    } };
+    // Text only, for the same reason as the stale-answer path (#2088).
+    return this.textResult(lines.join('\n'));
   }
 
   /**
diff --git a/src/mcp/version.ts b/src/mcp/version.ts
index cef1b7834a..e2ee11ea4d 100644
--- a/src/mcp/version.ts
+++ b/src/mcp/version.ts
@@ -4,7 +4,8 @@
  * The version string is the rendezvous datum between cooperating daemon and
  * proxy processes: the daemon advertises its version in the hello line, and
  * the proxy refuses to share IPC across a mismatch (falls back to direct
- * mode). Keeping the resolution in one place avoids drift between the CLI
+ * mode), or replaces a daemon of an older release ({@link isOlderRelease}).
+ * Keeping the resolution in one place avoids drift between the CLI
  * `--version` output (which reads `package.json` directly) and the daemon
  * handshake.
  *
@@ -19,10 +20,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+/** The `package.json` of the install this process runs from. */
+export const CodeGraphPackageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+
 function readPackageVersion(): string {
   try {
-    const pkgPath = path.join(__dirname, '..', '..', 'package.json');
-    const raw = fs.readFileSync(pkgPath, 'utf8');
+    const raw = fs.readFileSync(CodeGraphPackageJsonPath, 'utf8');
     const parsed = JSON.parse(raw);
     if (typeof parsed?.version === 'string' && parsed.version.length > 0) {
       return parsed.version;
@@ -34,3 +37,25 @@ function readPackageVersion(): string {
 }
 
 export const CodeGraphPackageVersion = readPackageVersion();
+
+/**
+ * Whether `version` is a CodeGraph release older than `than` — the test a
+ * launcher applies before it replaces a running daemon (#2335). Only plain
+ * `MAJOR.MINOR.PATCH` releases compare: a prerelease, a build suffix or the
+ * "0.0.0-unknown" sentinel is never older. A daemon is replaced only by a
+ * strictly newer release, so two installed versions can never take turns
+ * stopping each other's daemon.
+ */
+export function isOlderRelease(version: string, than: string): boolean {
+  const a = parseRelease(version);
+  const b = parseRelease(than);
+  if (!a || !b) return false;
+  if (a[0] !== b[0]) return a[0] < b[0];
+  if (a[1] !== b[1]) return a[1] < b[1];
+  return a[2] < b[2];
+}
+
+function parseRelease(version: string): [number, number, number] | null {
+  const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
diff --git a/src/mcp/writer-lock.ts b/src/mcp/writer-lock.ts
index 9acbdb9a46..7785cde674 100644
--- a/src/mcp/writer-lock.ts
+++ b/src/mcp/writer-lock.ts
@@ -165,6 +165,44 @@ export function markWriterReady(projectRoot: string): void {
   }
 }
 
+/** Waits between retries of a writer-record swap refused by Windows (another process has the file open). */
+const SWAP_RETRY_DELAYS_MS = [25, 50, 100, 200];
+
+/**
+ * Replace the writer record of `fromPid` with `next`, and only that record, so
+ * the slot passes between two processes without ever falling free (#2335). A
+ * stopped daemon's sessions serve themselves in-process the moment it goes, and
+ * one that found the slot free or stale would claim it as their own writer.
+ * Compare and rename are separate steps, so callers check the result: whether
+ * the record was replaced. Never throws.
+ */
+export function swapWriterLock(projectRoot: string, fromPid: number, next: WriterLockInfo): boolean {
+  const pidPath = getWriterPidPath(projectRoot);
+  const tmp = `${pidPath}.${process.pid}.swap.tmp`;
+  try {
+    if (readWriterLock(projectRoot)?.pid !== fromPid) return false;
+    fs.writeFileSync(tmp, encode(next), { mode: 0o600 });
+    for (let attempt = 0; ; attempt++) {
+      try {
+        fs.renameSync(tmp, pidPath);
+        return true;
+      } catch (err) {
+        const code = (err as NodeJS.ErrnoException).code;
+        const delay = SWAP_RETRY_DELAYS_MS[attempt];
+        if (process.platform !== 'win32' || !['EPERM', 'EACCES', 'EBUSY'].includes(code ?? '') || delay === undefined) {
+          return false;
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
+        if (readWriterLock(projectRoot)?.pid !== fromPid) return false;
+      }
+    }
+  } catch {
+    return false;
+  } finally {
+    try { fs.unlinkSync(tmp); } catch { /* renamed, or never written */ }
+  }
+}
+
 /** Release if we still own the lock (pid match). */
 export function releaseWriterLock(projectRoot: string, lockName: 'writer.pid' | 'rebuild.pid' = 'writer.pid'): void {
   const pidPath = getWriterPidPath(projectRoot, lockName);
diff --git a/src/resolution/alias-binding.ts b/src/resolution/alias-binding.ts
index 4b2ec2380e..3251abff05 100644
--- a/src/resolution/alias-binding.ts
+++ b/src/resolution/alias-binding.ts
@@ -131,5 +131,20 @@ export function extractLocalExportAliases(content: string): Array<{ exportedName
       }
     }
   }
+  // CommonJS: `exports.setCharset = function setCharset(…)`, `module.exports.x = impl`.
+  const memberRe = /^[ \t]*(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)\s*\(|([A-Za-z_$][\w$]*)\s*;?[ \t]*$)/gm;
+  let member: RegExpExecArray | null;
+  while ((member = memberRe.exec(content)) !== null) {
+    out.push({ exportedName: member[1]!, localName: member[2] ?? member[3]! });
+  }
+  // `module.exports = { parse, format: formatDate }`.
+  const objectRe = /^[ \t]*module\.exports\s*=\s*\{([^{}]*)\}/gm;
+  let object: RegExpExecArray | null;
+  while ((object = objectRe.exec(content)) !== null) {
+    for (const raw of object[1]!.split(',')) {
+      const entry = /^\s*([A-Za-z_$][\w$]*)\s*(?::\s*([A-Za-z_$][\w$]*)\s*)?$/.exec(raw);
+      if (entry) out.push({ exportedName: entry[1]!, localName: entry[2] ?? entry[1]! });
+    }
+  }
   return out;
 }
diff --git a/src/resolution/angular-template-synthesizer.ts b/src/resolution/angular-template-synthesizer.ts
new file mode 100644
index 0000000000..b5b7ce206d
--- /dev/null
+++ b/src/resolution/angular-template-synthesizer.ts
@@ -0,0 +1,832 @@
+/**
+ * Angular templates: what a component renders and where it links.
+ *
+ * An Angular component's markup is a template — a `templateUrl` file beside
+ * it, or an inline `template:` string — that the index never parses, so four
+ * things a reader relies on were missing from the graph:
+ *
+ * - **The component tree.** `<app-article-list [config]="listConfig">` in the
+ *   home page's template renders `ArticleListComponent`, and the
+ *   `<app-favorite-button>` inside that renders the button whose click
+ *   navigates. Without the edge, a navigation in a child component reached no
+ *   screen. A `calls` edge from the parent class to the child class
+ *   (`synthesizedBy: 'angular-template'`) stands for the render, the way
+ *   `jsx-render` does for a React child.
+ * - **`routerLink`.** `routerLink="/login"`, `routerLink="/profile/{{ name }}"`,
+ *   `[routerLink]="['/article', article.slug]"`, and a bound property that
+ *   holds a route constant (`[routerLink]="routerLinkAbout"` with
+ *   `routerLinkAbout = publicRoutes.about.routerLink`) each become a
+ *   `navigates` edge from the component to the route it names.
+ *
+ * - **Event bindings.** `(click)="toggleFavorite()"` is the only caller a
+ *   handler method has. A `calls` edge from the component to its own method
+ *   (`synthesizedBy: 'angular-event'`) carries the binding as its
+ *   `trigger`, the label Steps puts on the hop — read from the template, so
+ *   it cannot be read back from the source at the edge's line.
+ * - **Bindings.** `[name]="icon()"`, `{{ label() }}`, `*ngIf="isOpen()"` and
+ *   `@if (loading()) {` call the component's own members at every render —
+ *   with signals (`icon = computed(…)`), the usual way a template reads
+ *   state, and often a member's only caller. Each is a `calls` edge
+ *   (`synthesizedBy: 'angular-binding'`, the binding as `via`) WITHOUT a
+ *   trigger: the call runs when the template renders, not when a user acts,
+ *   the way a JSX attribute's `name={icon()}` carries none. Reading a member
+ *   without calling it counts only when the member is method-kind: a getter
+ *   (`[disabled]="!canSave"`) runs, so it is called; a method handed to a
+ *   child (`[displayWith]="displayFn"`, `trackBy: trackById`) is a function
+ *   reference (`references`, `fnRef`), as `this.handler` passed as an
+ *   argument is in TypeScript; a field a call filled (`days =
+ *   Array.from(…)`) is a plain `references`. A property read
+ *   (`[value]="title"`) links nothing — TypeScript records no property reads
+ *   either, and the dead-code list does not ask about properties.
+ *
+ * A child is matched by its element selector (`selector: 'app-article-list'`),
+ * in the same app first; a selector two components share there is left
+ * unmatched. A relative link and a destination no route serves draw nothing.
+ */
+
+import type { Edge, Node } from '../types';
+import type { ResolutionContext } from './types';
+import type { MaybeYield } from './cooperative-yield';
+import { isTestPath } from '../search/query-utils';
+import { stripCommentsForRegex } from './strip-comments';
+import { matchBracket, readFields, skipString } from './frameworks/object-literal';
+import { dependsOn } from './frameworks/package-deps';
+import { appRootFor, HOLE, toHref, type HrefLiteral } from './frameworks/expo-router';
+import { destinationsForHref } from './frameworks/nextjs';
+import { angularDestination, angularRouteTable, angularRoutesFor, namesSomewhere, staticString, templatePathFor } from './frameworks/angular-router';
+
+interface AngularComponent {
+  node: Node;
+  file: string;
+  selectors: string[];
+  template: { file: string; text: string; firstLine: number; inline: boolean } | null;
+}
+
+/** Links a single component may carry before it is a navigation menu rather than a decision. */
+const MAX_LINKS_PER_COMPONENT = 24;
+/** Children a single template may render before the rest are left out. */
+const MAX_CHILDREN_PER_COMPONENT = 40;
+
+/** An element selector: `app-article-list`, not `[appDirective]` or `button[app-x]`. */
+const ELEMENT_SELECTOR = /^[a-zA-Z][\w-]*$/;
+
+const lineOfOffset = (text: string, at: number): number => {
+  let line = 1;
+  for (let i = 0; i < at && i < text.length; i++) if (text.charCodeAt(i) === 10) line++;
+  return line;
+};
+
+/** Every `@Component` class a file declares, with its selectors and template. */
+function componentsIn(file: string, content: string, nodes: readonly Node[], ctx: ResolutionContext): AngularComponent[] {
+  const out: AngularComponent[] = [];
+  const safe = stripCommentsForRegex(content, 'typescript');
+  const decorator = /@Component\s*\(/g;
+  let m: RegExpExecArray | null;
+  while ((m = decorator.exec(safe)) !== null) {
+    const paren = m.index + m[0].length - 1;
+    const close = matchBracket(safe, paren);
+    if (close < 0) continue;
+    decorator.lastIndex = close;
+    const open = safe.indexOf('{', paren);
+    if (open < 0 || open > close) continue;
+    const objEnd = matchBracket(safe, open);
+    if (objEnd < 0) continue;
+    const cls = /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/.exec(safe.slice(close + 1, close + 400));
+    if (!cls) continue;
+    const node = nodes.find((n) => n.kind === 'class' && n.name === cls[1]);
+    if (!node) continue;
+    const fields = readFields(safe, open, objEnd);
+    const selectorText = fields.get('selector')?.text;
+    const selector = selectorText ? staticString(selectorText) : null;
+    const selectors = (selector ?? '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter((s) => ELEMENT_SELECTOR.test(s));
+
+    let template: AngularComponent['template'] = null;
+    const url = fields.get('templateUrl')?.text;
+    const templateUrl = url ? staticString(url) : null;
+    if (templateUrl) {
+      const templateFile = templatePathFor(file, templateUrl);
+      const text = ctx.readFile(templateFile);
+      if (text) template = { file: templateFile, text, firstLine: 1, inline: false };
+    } else {
+      const inline = fields.get('template');
+      if (inline) {
+        // The template string's body, from the original source (stripping
+        // comments must not touch a template's text), at its own offset.
+        const quoteAt = content.indexOf(inline.text.trim()[0] ?? '`', inline.at + 'template'.length);
+        const end = quoteAt < 0 ? -1 : skipString(content, quoteAt);
+        if (end > quoteAt) {
+          template = { file, text: content.slice(quoteAt + 1, end), firstLine: lineOfOffset(content, quoteAt + 1), inline: true };
+        }
+      }
+    }
+    out.push({ node, file, selectors, template });
+  }
+  return out;
+}
+
+/** Per context, renewed with the route list (whose identity changes when the resolver's caches do). */
+const componentIndexes = new WeakMap<ResolutionContext, { source: readonly Node[]; components: AngularComponent[] }>();
+
+/** Every component in the project, read once per resolution state. */
+export function angularComponents(ctx: ResolutionContext): AngularComponent[] {
+  const source = ctx.getNodesByKind('route');
+  const hit = componentIndexes.get(ctx);
+  if (hit && hit.source === source) return hit.components;
+  const components: AngularComponent[] = [];
+  for (const file of ctx.getAllFiles()) {
+    if (!/\.[cm]?ts$/.test(file) || file.endsWith('.d.ts') || isTestPath(file)) continue;
+    if (!(ctx.fileContains?.(file, '@Component') ?? ctx.readFile(file)?.includes('@Component'))) continue;
+    const content = ctx.readFile(file);
+    if (!content) continue;
+    components.push(...componentsIn(file, content, ctx.getNodesInFile(file), ctx));
+  }
+  componentIndexes.set(ctx, { source, components });
+  return components;
+}
+
+// =============================================================================
+// Reading a template
+// =============================================================================
+
+/** `routerLink="…"` (plain) and `[routerLink]="…"` (bound), either quote. `routerLinkActive` is neither. */
+const ROUTER_LINK = /(\[routerLink\]|\brouterLink)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** `(click)="save()"` / `(ngSubmit)="submitForm()"` — an event binding, not `[(ngModel)]`'s two-way half. */
+const EVENT_BINDING = /(?<!\[)\(([A-Za-z][\w.-]*)\)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** A call a template statement makes on its component: `save()`, `this.toggle(item)` — not `form.reset()`. */
+const OWN_CALL = /(?<![\w$.])(?:this\s*\.\s*)?([A-Za-z_$][\w$]*)\s*\(/g;
+
+/** The element a binding at `at` is written on: the last opening tag before it. */
+function elementAt(text: string, at: number): string | null {
+  const open = text.lastIndexOf('<', at);
+  if (open < 0) return null;
+  const tag = /^<([a-zA-Z][\w-]*)/.exec(text.slice(open, open + 64));
+  return tag ? tag[1]! : null;
+}
+
+/** A `routerLink:` field of an object literal written in a class. */
+const ROUTER_LINK_FIELD = /(?<![\w$.])routerLink\s*:\s*/g;
+
+/** An object field's value text from `at`, up to its `,` or closing brace at depth 0. */
+function fieldValue(text: string, at: number): string | null {
+  let i = at;
+  while (i < text.length) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(text, i);
+      if (end < 0) return null;
+      i = end + 1;
+      continue;
+    }
+    if (ch === '[' || ch === '{' || ch === '(') {
+      const end = matchBracket(text, i);
+      if (end < 0) return null;
+      i = end + 1;
+      continue;
+    }
+    if (ch === ',' || ch === '}' || ch === ']' || ch === ')' || ch === ';') break;
+    i++;
+  }
+  return text.slice(at, i).trim() || null;
+}
+
+/** An opening tag's name. */
+const TAG = /<([a-zA-Z][\w-]*)(?=[\s/>])/g;
+
+/** The destination a plain `routerLink` names: `/profile/{{ user.username }}` is `/profile/${…}`. */
+function plainHref(value: string): HrefLiteral | null {
+  const withHoles = value.trim().replace(/\{\{[\s\S]*?\}\}/g, HOLE);
+  return withHoles.startsWith('/') ? namesSomewhere(toHref(withHoles)) : null;
+}
+
+// =============================================================================
+// What a template reads at render
+// =============================================================================
+
+/** `[name]="…"`, `[attr.aria-label]="…"`, `[class.done]="…"`, `[(ngModel)]="…"`: a binding whose value is an expression. */
+const PROPERTY_BINDING = /\[(\([A-Za-z][\w.-]*\)|[A-Za-z@][\w.@-]*)\]\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** `*ngIf="…"`, `*ngFor="let item of items; trackBy: trackById"`: a structural directive, in its microsyntax. */
+const STRUCTURAL_DIRECTIVE = /(?<![\w$*-])\*([A-Za-z][\w.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** `{{ … }}`, in text or inside an attribute's value. */
+const INTERPOLATION = /\{\{([\s\S]*?)\}\}/g;
+/** A control-flow block that takes an expression: `@if (…) {`, `@else if (…)`, `@for (…)`, `@switch (…)`, `@case (…)`, `@defer (…)`. */
+const CONTROL_FLOW = /(?<![\w$@])@(if|else\s+if|for|switch|case|defer)\s*\(/g;
+/** `@let total = price() * quantity();` — a template's own constant. */
+const LET_DECLARATION = /(?<![\w$@])@let\s+([A-Za-z_$][\w$]*)\s*=/g;
+/** A template reference variable — `#nameInput`, `ref-nameInput` — which the whole template sees. */
+const REFERENCE_VARIABLE = /(?<=\s)(?:#|ref-)([A-Za-z_$][\w$]*)(?=[\s=/>])/g;
+/** `let-row`, `let-i="index"` on an `<ng-template>`: a local of what it renders. */
+const TEMPLATE_INPUT = /(?<=\s)let-([A-Za-z_$][\w$]*)(?=[\s=/>])/g;
+const HTML_COMMENT = /<!--[\s\S]*?-->/g;
+/** A name an expression writes: `this.` may lead it; a member of something else (`form.reset`) is not one. */
+const EXPRESSION_NAME = /(?<![\w$.])(?:this\s*\.\s*)?([A-Za-z_$][\w$]*)/g;
+const NAME_AT = /[A-Za-z_$][\w$]*/y;
+
+/** A name a template expression calls (`icon()`) or only reads (`canSave`, `displayFn`). */
+export interface TemplateMemberUse {
+  name: string;
+  /** Offset of the name in the template. */
+  at: number;
+  call: boolean;
+  /** The binding the expression belongs to, as written: `[name]`, `{{ }}`, `*ngIf`, `@if`, `@let`. */
+  via: string;
+}
+
+/**
+ * One expression, and the scope it is read in. `scope` is the directive or
+ * block that evaluates it — the locals that scope declares are visible to it
+ * only where Angular says so (`@for`'s `track` sees the loop variable; the
+ * `@if` condition does not see its own `as` alias).
+ */
+interface TemplateExpression {
+  via: string;
+  at: number;
+  text: string;
+  scope: number;
+  seesOwnLocals: boolean;
+}
+
+/** A name the template declares — a local, never the component's member. Visible from `from` on. */
+interface TemplateLocal {
+  name: string;
+  from: number;
+  /** The directive or block that declared it; -1 for a reference variable or a `let-` input. */
+  scope: number;
+}
+
+/**
+ * Each string literal blanked to spaces, so a quoted `'save()'` names nothing
+ * and offsets survive. A template literal keeps its `${…}` holes: they are
+ * expressions (`isToday(\`${key}-${formatDay(day)}\`)`).
+ */
+function blankStrings(text: string): string {
+  let out = '';
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'") {
+      const end = skipString(text, i);
+      const close = end < 0 ? text.length : end + 1;
+      out += ' '.repeat(close - i);
+      i = close;
+    } else if (ch === '`') {
+      out += ' ';
+      i++;
+      while (i < text.length) {
+        if (text[i] === '`') {
+          out += ' ';
+          i++;
+          break;
+        }
+        const close = text[i] === '$' && text[i + 1] === '{' ? matchBracket(text, i + 1) : -1;
+        if (close >= 0) {
+          out += `  ${blankStrings(text.slice(i + 2, close))} `;
+          i = close + 1;
+          continue;
+        }
+        const step = text[i] === '\\' ? Math.min(2, text.length - i) : 1;
+        out += ' '.repeat(step);
+        i += step;
+      }
+    } else {
+      out += ch;
+      i++;
+    }
+  }
+  return out;
+}
+
+const isBlank = (ch: string | undefined): boolean => ch !== undefined && /\s/.test(ch);
+
+/** The names an expression calls or reads, minus a pipe's name and an object literal's keys. */
+function expressionUses(expression: string): Array<{ name: string; at: number; call: boolean }> {
+  const text = blankStrings(expression);
+  const out: Array<{ name: string; at: number; call: boolean }> = [];
+  EXPRESSION_NAME.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = EXPRESSION_NAME.exec(text)) !== null) {
+    const name = m[1]!;
+    const end = m.index + m[0].length;
+    let before = m.index - 1;
+    while (isBlank(text[before])) before--;
+    let after = end;
+    while (isBlank(text[after])) after++;
+    const prev = text[before];
+    const next = text[after];
+    // `form .reset()`: a member of something else, however it is spaced.
+    if (prev === '.') continue;
+    // A pipe's name: `total | currency: code()` — but `a || b` is no pipe.
+    if (prev === '|' && text[before - 1] !== '|') continue;
+    // An object literal's key: `[ngClass]="{ active: isActive() }"`.
+    if ((prev === '{' || prev === ',') && next === ':') continue;
+    out.push({ name, at: end - name.length, call: next === '(' });
+  }
+  return out;
+}
+
+/**
+ * Where the expression starting at `from` ends: a `;` or `,` outside any
+ * bracket, or the words `as` / `let` that open the next microsyntax binding.
+ */
+function expressionEnd(text: string, from: number): number {
+  let depth = 0;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(text, i);
+      if (end < 0) return text.length;
+      i = end;
+      continue;
+    }
+    if (ch === '(' || ch === '[' || ch === '{') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}') depth--;
+    else if (depth === 0 && (ch === ';' || ch === ',')) return i;
+    else if (depth === 0 && isBlank(text[i - 1]) && /^(?:as|let)(?![\w$])/.test(text.slice(i, i + 4))) return i;
+  }
+  return text.length;
+}
+
+/** `text` split at each `;` outside brackets and strings, with each part's offset. */
+function topLevelParts(text: string): Array<{ at: number; text: string }> {
+  const parts: Array<{ at: number; text: string }> = [];
+  let start = 0;
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(text, i);
+      if (end < 0) break;
+      i = end;
+      continue;
+    }
+    if (ch === '(' || ch === '[' || ch === '{') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}') depth--;
+    else if (ch === ';' && depth === 0) {
+      parts.push({ at: start, text: text.slice(start, i) });
+      start = i + 1;
+    }
+  }
+  parts.push({ at: start, text: text.slice(start) });
+  return parts;
+}
+
+/**
+ * A structural directive's microsyntax, read into the expressions it
+ * evaluates and the locals it declares: `let item of items; let i = index;
+ * trackBy: trackById` evaluates `items` and `trackById` and declares `item`
+ * and `i`. A key (`of`, `trackBy:`, `else`) and the context name a binding
+ * takes (`index`, `index as i`) belong to the directive, never the component.
+ */
+export function readMicrosyntax(text: string): { expressions: Array<{ at: number; text: string }>; locals: string[] } {
+  const expressions: Array<{ at: number; text: string }> = [];
+  const locals: string[] = [];
+  let i = 0;
+  const skip = (separators: boolean) => {
+    while (i < text.length && (isBlank(text[i]) || (separators && (text[i] === ';' || text[i] === ',')))) i++;
+  };
+  const word = (): string | null => {
+    NAME_AT.lastIndex = i;
+    const m = NAME_AT.exec(text);
+    if (!m) return null;
+    i += m[0].length;
+    return m[0];
+  };
+  let first = true;
+  while (i < text.length) {
+    skip(true);
+    if (i >= text.length) break;
+    const start = i;
+    const key = word();
+    if (key === 'let' && isBlank(text[i])) {
+      // `let item`, `let i = index`: a local, and the context name it takes.
+      skip(false);
+      const local = word();
+      if (local) locals.push(local);
+      skip(false);
+      if (text[i] === '=') {
+        i++;
+        skip(false);
+        word();
+      }
+      first = false;
+      continue;
+    }
+    if (first || key === null) {
+      // The directive's own expression (`*ngIf="cond"`) has no key.
+      i = start;
+    } else {
+      skip(false);
+      if (text[i] === ':') i++;
+      skip(false);
+    }
+    const end = expressionEnd(text, i);
+    if (end > i) expressions.push({ at: i, text: text.slice(i, end) });
+    i = end;
+    skip(false);
+    if (/^as(?![\w$])/.test(text.slice(i, i + 3))) {
+      i += 2;
+      skip(false);
+      const alias = word();
+      if (alias) locals.push(alias);
+    }
+    // Nothing read (a stray character): step past it.
+    if (i === start) i++;
+    first = false;
+  }
+  return { expressions, locals };
+}
+
+/** The `;` that ends a `@let` declaration's expression, or -1. */
+function statementEnd(text: string, from: number): number {
+  let depth = 0;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(text, i);
+      if (end < 0) return -1;
+      i = end;
+      continue;
+    }
+    if (ch === '(' || ch === '[' || ch === '{') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}') {
+      if (--depth < 0) return -1;
+    } else if (ch === ';' && depth === 0) return i;
+  }
+  return -1;
+}
+
+/**
+ * Every name a template's bindings call or read at render — property
+ * bindings, interpolations, structural directives, control flow and `@let` —
+ * in template order, minus what the template names itself: a pipe, an object
+ * key, a microsyntax key, and any local it declares (`let item`, `as user`,
+ * `#input`, `@let total`). Event bindings are not here: they run when the
+ * user acts, and are read on their own. A commented-out binding reads nothing.
+ */
+export function templateMemberUses(template: string): TemplateMemberUse[] {
+  const text = template.replace(HTML_COMMENT, (c) => c.replace(/[^\n]/g, ' '));
+  const expressions: TemplateExpression[] = [];
+  const locals: TemplateLocal[] = [];
+  let scope = 0;
+  const valueAt = (m: RegExpExecArray, value: string) => m.index + m[0].length - 1 - value.length;
+  const tagStart = (at: number) => Math.max(0, text.lastIndexOf('<', at));
+
+  PROPERTY_BINDING.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = PROPERTY_BINDING.exec(text)) !== null) {
+    const value = m[2] ?? m[3] ?? '';
+    expressions.push({ via: `[${m[1]!}]`, at: valueAt(m, value), text: value, scope: ++scope, seesOwnLocals: false });
+  }
+  STRUCTURAL_DIRECTIVE.lastIndex = 0;
+  while ((m = STRUCTURAL_DIRECTIVE.exec(text)) !== null) {
+    const value = m[2] ?? m[3] ?? '';
+    const at = valueAt(m, value);
+    const own = ++scope;
+    const read = readMicrosyntax(value);
+    for (const e of read.expressions) expressions.push({ via: `*${m[1]!}`, at: at + e.at, text: e.text, scope: own, seesOwnLocals: false });
+    // The host element and everything inside it see the directive's locals.
+    for (const name of read.locals) locals.push({ name, from: tagStart(m.index), scope: own });
+  }
+  INTERPOLATION.lastIndex = 0;
+  while ((m = INTERPOLATION.exec(text)) !== null) {
+    expressions.push({ via: '{{ }}', at: m.index + 2, text: m[1]!, scope: ++scope, seesOwnLocals: false });
+  }
+  CONTROL_FLOW.lastIndex = 0;
+  while ((m = CONTROL_FLOW.exec(text)) !== null) {
+    const open = m.index + m[0].length - 1;
+    const close = matchBracket(text, open);
+    if (close < 0) continue;
+    const kind = m[1]!.replace(/\s+/g, ' ');
+    const via = `@${kind}`;
+    const own = ++scope;
+    const parts = topLevelParts(text.slice(open + 1, close)).map((p) => ({ at: open + 1 + p.at, text: p.text }));
+    if (kind === 'switch' || kind === 'case') {
+      for (const p of parts) expressions.push({ via, at: p.at, text: p.text, scope: own, seesOwnLocals: false });
+    } else if (kind === 'defer') {
+      // `when cond` is an expression; `on viewport`, `on timer(5s)` are triggers.
+      for (const p of parts) {
+        const when = /^\s*(?:(?:prefetch|hydrate)\s+)?when(?![\w$])/.exec(p.text);
+        if (when) expressions.push({ via, at: p.at + when[0].length, text: p.text.slice(when[0].length), scope: own, seesOwnLocals: false });
+      }
+    } else if (kind === 'for') {
+      // `item of items(); track item.id; let i = $index, odd = $odd`
+      const [head, ...rest] = parts;
+      const loop = head ? /^(\s*)([A-Za-z_$][\w$]*)\s+of(?![\w$])/.exec(head.text) : null;
+      if (head && loop) {
+        locals.push({ name: loop[2]!, from: m.index, scope: own });
+        expressions.push({ via, at: head.at + loop[0].length, text: head.text.slice(loop[0].length), scope: own, seesOwnLocals: false });
+      }
+      for (const p of rest) {
+        const track = /^\s*track(?![\w$])/.exec(p.text);
+        if (track) {
+          expressions.push({ via, at: p.at + track[0].length, text: p.text.slice(track[0].length), scope: own, seesOwnLocals: true });
+          continue;
+        }
+        if (/^\s*let(?![\w$])/.test(p.text)) {
+          for (const alias of p.text.matchAll(/([A-Za-z_$][\w$]*)\s*=\s*\$?[\w$]+/g)) locals.push({ name: alias[1]!, from: m.index, scope: own });
+        }
+      }
+    } else {
+      // `@if (user(); as user)`: the condition, then the alias its body sees.
+      const [head, ...rest] = parts;
+      if (head) expressions.push({ via, at: head.at, text: head.text, scope: own, seesOwnLocals: false });
+      for (const p of rest) {
+        const alias = /^\s*as\s+([A-Za-z_$][\w$]*)/.exec(p.text);
+        if (alias) locals.push({ name: alias[1]!, from: m.index, scope: own });
+      }
+    }
+  }
+  LET_DECLARATION.lastIndex = 0;
+  while ((m = LET_DECLARATION.exec(text)) !== null) {
+    const at = m.index + m[0].length;
+    const end = statementEnd(text, at);
+    if (end < 0) continue;
+    const own = ++scope;
+    expressions.push({ via: '@let', at, text: text.slice(at, end), scope: own, seesOwnLocals: false });
+    locals.push({ name: m[1]!, from: m.index, scope: own });
+  }
+  REFERENCE_VARIABLE.lastIndex = 0;
+  while ((m = REFERENCE_VARIABLE.exec(text)) !== null) locals.push({ name: m[1]!, from: 0, scope: -1 });
+  TEMPLATE_INPUT.lastIndex = 0;
+  while ((m = TEMPLATE_INPUT.exec(text)) !== null) locals.push({ name: m[1]!, from: tagStart(m.index), scope: -1 });
+
+  const uses: TemplateMemberUse[] = [];
+  for (const e of expressions) {
+    for (const u of expressionUses(e.text)) {
+      const at = e.at + u.at;
+      const shadowed = locals.some((l) => l.name === u.name && l.from <= at && (l.scope !== e.scope || e.seesOwnLocals));
+      if (!shadowed) uses.push({ name: u.name, at, call: u.call, via: e.via });
+    }
+  }
+  return uses.sort((a, b) => a.at - b.at);
+}
+
+/**
+ * What a method-kind member's own declaration says it is: an accessor (`get
+ * canSave() {`), a function (`displayFn(p) {`, `onPick = (p) => …`), or a
+ * field holding what a call returned (`days = Array.from({ length: 31 }, (_,
+ * i) => i + 1)`, `total = computed(() => …)`) — a method only because a
+ * callback is written in its initializer, and as likely plain data.
+ */
+type MemberShape = 'get' | 'set' | 'function' | 'value';
+
+function memberShape(lines: readonly string[], member: Node): MemberShape {
+  const head = lines
+    .slice(member.startLine - 1, member.startLine + 4)
+    .join('\n')
+    .slice(member.startColumn);
+  let from = 0;
+  for (;;) {
+    const at = head.indexOf(member.name, from);
+    if (at < 0) return 'function';
+    from = at + member.name.length;
+    // The name itself — not a longer name, and not a decorator's `'value'` argument.
+    if (/[\w$'"`]/.test(head[at - 1] ?? '') || /[\w$'"`]/.test(head[from] ?? '')) continue;
+    const accessor = /(?<![\w$])(get|set)\s+$/.exec(head.slice(0, at));
+    if (accessor) return accessor[1] as 'get' | 'set';
+    // `name = …`, `name: Type = …` (a function type's `=>` is not the `=`).
+    const field = /^[?!]?\s*(?::[^=;]*(?:=>[^=;]*)*)?=(?![=>])\s*/.exec(head.slice(from));
+    if (!field) return 'function';
+    const value = head.slice(from + field[0].length).replace(/^async\s+/, '');
+    if (/^(?:function(?![\w$])|[A-Za-z_$][\w$]*\s*=>)/.test(value)) return 'function';
+    const close = value.startsWith('(') ? matchBracket(value, 0) : -1;
+    return close > 0 && /^\s*(?::[^=]*)?=>/.test(value.slice(close + 1)) ? 'function' : 'value';
+  }
+}
+
+/**
+ * The member one use links, and how. A call links what it calls: a method,
+ * or a signal held in a field (`count = signal(0)` is a property). A name
+ * read without a call links only a method-kind member — a getter runs when
+ * it is read, so it is called; a function handed over uncalled
+ * (`[displayWith]="displayFn"`) is a function reference; a field a call
+ * filled (`@for (day of days)`) is a plain reference. Same-named methods
+ * resolve as the event bindings' do: the last declared (an overload's body).
+ */
+function bindingTarget(
+  candidates: readonly Node[] | undefined,
+  call: boolean,
+  shape: (n: Node) => MemberShape
+): { node: Node; kind: 'calls' | 'references'; fnRef: boolean } | null {
+  if (!candidates) return null;
+  const methods = candidates.filter((n) => n.kind === 'method');
+  if (call) {
+    const target =
+      [...methods].reverse().find((n) => shape(n) === 'function' || shape(n) === 'value') ??
+      methods[0] ??
+      candidates.find((n) => n.kind === 'property');
+    return target ? { node: target, kind: 'calls', fnRef: false } : null;
+  }
+  const getter = methods.find((n) => shape(n) === 'get');
+  if (getter) return { node: getter, kind: 'calls', fnRef: false };
+  const read = [...methods].reverse().find((n) => shape(n) !== 'set');
+  return read ? { node: read, kind: 'references', fnRef: shape(read) === 'function' } : null;
+}
+
+// =============================================================================
+// The pass
+// =============================================================================
+
+export async function angularTemplateEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]> {
+  if (!dependsOn(ctx, '@angular/core')) return [];
+  const components = angularComponents(ctx);
+  if (components.length === 0) return [];
+
+  // Element selector → the components that answer to it, per app.
+  const bySelector = new Map<string, AngularComponent[]>();
+  for (const c of components) {
+    for (const sel of c.selectors) {
+      const list = bySelector.get(sel);
+      if (list) list.push(c);
+      else bySelector.set(sel, [c]);
+    }
+  }
+  const childFor = (tag: string, parent: AngularComponent): AngularComponent | null => {
+    const all = bySelector.get(tag);
+    if (!all || all.length === 0) return null;
+    if (all.length === 1) return all[0]!;
+    const root = appRootFor(parent.file);
+    const near = all.filter((c) => c.file.startsWith(root));
+    return near.length === 1 ? near[0]! : null;
+  };
+
+  const table = angularRouteTable(ctx);
+  const edges: Edge[] = [];
+  const seen = new Set<string>();
+  let scanned = 0;
+  for (const component of components) {
+    if ((++scanned & 31) === 0) await onYield();
+    const template = component.template;
+    if (!template) continue;
+    const text = template.text;
+    // Where an edge is written: the tag's own line for an inline template;
+    // for a template file, the class — the file the edge's source is in.
+    const siteLine = (at: number) => (template.inline ? template.firstLine + lineOfOffset(text, at) - 1 : component.node.startLine);
+    const registeredAt = (at: number) => `${template.file}:${template.firstLine + lineOfOffset(text, at) - 1}`;
+
+    let children = 0;
+    TAG.lastIndex = 0;
+    let t: RegExpExecArray | null;
+    while ((t = TAG.exec(text)) !== null && children < MAX_CHILDREN_PER_COMPONENT) {
+      const child = childFor(t[1]!, component);
+      if (!child || child.node.id === component.node.id) continue;
+      const key = `${component.node.id}>${child.node.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      children++;
+      edges.push({
+        source: component.node.id,
+        target: child.node.id,
+        kind: 'calls',
+        line: siteLine(t.index),
+        provenance: 'heuristic',
+        metadata: { synthesizedBy: 'angular-template', via: t[1]!, registeredAt: registeredAt(t.index) },
+      });
+    }
+
+    // Event bindings: `(click)="toggleFavorite()"` runs the component's own
+    // method when the user acts. The binding is the trigger Steps draws —
+    // known only from the template, so it rides on the edge.
+    const own = ctx
+      .getNodesInFile(component.file)
+      .filter((n) => (n.kind === 'method' || n.kind === 'property') && n.qualifiedName.startsWith(`${component.node.qualifiedName}::`));
+    const members = new Map(own.filter((n) => n.kind === 'method').map((n) => [n.name, n]));
+    /** Members this template already links — only the first edge between two nodes survives the merge. */
+    const linked = new Set<string>();
+    let handlers = 0;
+    EVENT_BINDING.lastIndex = 0;
+    let ev: RegExpExecArray | null;
+    while ((ev = EVENT_BINDING.exec(text)) !== null && handlers < MAX_CHILDREN_PER_COMPONENT) {
+      const statement = ev[2] ?? ev[3] ?? '';
+      const event = `(${ev[1]!})`;
+      const element = elementAt(text, ev.index);
+      OWN_CALL.lastIndex = 0;
+      let c: RegExpExecArray | null;
+      while ((c = OWN_CALL.exec(statement)) !== null) {
+        const method = members.get(c[1]!);
+        if (!method) continue;
+        const key = `${component.node.id}>${method.id}>${event}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        linked.add(method.id);
+        handlers++;
+        edges.push({
+          source: component.node.id,
+          target: method.id,
+          kind: 'calls',
+          line: siteLine(ev.index),
+          provenance: 'heuristic',
+          metadata: {
+            synthesizedBy: 'angular-event',
+            via: event,
+            registeredAt: registeredAt(ev.index),
+            trigger: { kind: 'prop', name: event, of: element },
+          },
+        });
+      }
+    }
+
+    // Bindings: `[name]="icon()"`, `{{ label() }}`, `@if (loading())` read the
+    // component every time it renders, so the hop carries no trigger. At most
+    // one edge per member, so the class's own size bounds them.
+    let declaration: string[] | null = null;
+    const shapes = new Map<string, MemberShape>();
+    const shape = (n: Node): MemberShape => {
+      const known = shapes.get(n.id);
+      if (known) return known;
+      declaration ??= (ctx.readFile(component.file) ?? '').split('\n');
+      const read = memberShape(declaration, n);
+      shapes.set(n.id, read);
+      return read;
+    };
+    const named = new Map<string, Node[]>();
+    for (const n of own) {
+      const list = named.get(n.name);
+      if (list) list.push(n);
+      else named.set(n.name, [n]);
+    }
+    for (const use of templateMemberUses(text)) {
+      const found = bindingTarget(named.get(use.name), use.call, shape);
+      if (!found || linked.has(found.node.id)) continue;
+      linked.add(found.node.id);
+      edges.push({
+        source: component.node.id,
+        target: found.node.id,
+        kind: found.kind,
+        line: siteLine(use.at),
+        provenance: 'heuristic',
+        metadata: {
+          synthesizedBy: 'angular-binding',
+          via: use.via,
+          registeredAt: registeredAt(use.at),
+          ...(found.fnRef ? { fnRef: true } : {}),
+        },
+      });
+    }
+
+    const routes = angularRoutesFor(table, component.file);
+    if (!routes || routes.exact.size === 0) continue;
+    let links = 0;
+    // A tab bar or menu built in the class — `this.tabs = [{ label, routerLink:
+    // internalRoutes.home.subRoutes.summary.routerLink }]`, handed to a
+    // `<gf-page-tabs [tabs]>` whose template binds `[routerLink]="tab.routerLink"`
+    // in a loop. The destination is the field this class wrote.
+    const source = ctx.readFile(component.file);
+    if (source) {
+      const lines = source.split('\n');
+      const body = lines.slice(component.node.startLine - 1, component.node.endLine).join('\n');
+      ROUTER_LINK_FIELD.lastIndex = 0;
+      let f: RegExpExecArray | null;
+      while ((f = ROUTER_LINK_FIELD.exec(body)) !== null && links < MAX_LINKS_PER_COMPONENT) {
+        const value = fieldValue(body, f.index + f[0].length);
+        const href = value ? angularDestination(value, component.file, component.node, ctx) : null;
+        if (!href || !href.path.startsWith('/')) continue;
+        const line = component.node.startLine + lineOfOffset(body, f.index) - 1;
+        for (const dest of destinationsForHref(href, routes)) {
+          const key = `${component.node.id}>${dest.node.id}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          links++;
+          edges.push({
+            source: component.node.id,
+            target: dest.node.id,
+            kind: 'navigates',
+            line,
+            provenance: 'heuristic',
+            metadata: { synthesizedBy: 'angular-router-link', href: dest.href.display, navMethod: 'routerLink', registeredAt: `${component.file}:${line}` },
+          });
+        }
+      }
+    }
+    ROUTER_LINK.lastIndex = 0;
+    let r: RegExpExecArray | null;
+    while ((r = ROUTER_LINK.exec(text)) !== null && links < MAX_LINKS_PER_COMPONENT) {
+      const value = r[2] ?? r[3] ?? '';
+      const href = r[1] === '[routerLink]' ? angularDestination(value, component.file, component.node, ctx) : plainHref(value);
+      if (!href || !href.path.startsWith('/')) continue;
+      for (const dest of destinationsForHref(href, routes)) {
+        const key = `${component.node.id}>${dest.node.id}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        links++;
+        edges.push({
+          source: component.node.id,
+          target: dest.node.id,
+          kind: 'navigates',
+          line: siteLine(r.index),
+          provenance: 'heuristic',
+          metadata: {
+            synthesizedBy: 'angular-router-link',
+            href: dest.href.display,
+            navMethod: 'routerLink',
+            registeredAt: registeredAt(r.index),
+            template: true,
+          },
+        });
+      }
+    }
+  }
+  return edges;
+}
diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts
index ae619d01f1..72704a0769 100644
--- a/src/resolution/callback-synthesizer.ts
+++ b/src/resolution/callback-synthesizer.ts
@@ -33,12 +33,13 @@ import { nextLinkEdges } from './next-router-synthesizer';
 import { reactRouterLinkEdges } from './react-router-synthesizer';
 import { tanstackLinkEdges } from './tanstack-router-synthesizer';
 import { vueRouterLinkEdges } from './vue-router-synthesizer';
+import { angularTemplateEdges } from './angular-template-synthesizer';
 import { svelteKitLinkEdges, svelteKitPageComponentEdges } from './sveltekit-synthesizer';
 import { createYielder, type MaybeYield } from './cooperative-yield';
 import { crossTierEdges, hasCrossTierPattern, hasTestRequestPattern, testRequestEdges } from './tier-synthesizer';
 import { enclosingFn, makeLineAt } from './synth-utils';
 import { resolveImportPath } from './import-resolver';
-import { crossesCodeBoundary } from './name-matcher';
+import { crossesCodeBoundary, jsCodeBindsName } from './name-matcher';
 
 const REGISTRAR_NAME = /^(on[A-Z]\w*|subscribe|addListener|addEventListener|register|watch|listen|addCallback)$/;
 const DISPATCHER_NAME = /(emit|trigger|notify|dispatch|fire|publish|flush)/i;
@@ -801,59 +802,342 @@ const IFACE_OVERRIDE_LANGS = new Set([
   'java', 'kotlin', 'csharp', 'typescript', 'javascript', 'swift', 'scala', 'go', 'rust',
   'arkts',
 ]);
+/**
+ * Whether a supertype edge out of a Go type is one of its embeddings (#2397):
+ * declared, never synthesized (go-implements writes those), into a struct, an
+ * interface or a defined type, and out of an interface only into an interface.
+ * `kindOf` answers those three kinds for a Go node id, null for anything else.
+ */
+function isGoEmbedding(e: Edge, kindOf: (id: string) => NodeKind | null): boolean {
+  if (e.provenance === 'heuristic') return false;
+  const to = kindOf(e.target);
+  return to !== null && (kindOf(e.source) !== 'interface' || to === 'interface');
+}
+/**
+ * The top-level items of the Go bracketed list opening at `text[open]` — the
+ * parameters of `(ctx context.Context, a, b int)` are `ctx context.Context`, `a`
+ * and `b int` — and the offset where the list closes. Nested brackets, string
+ * literals and comments are skipped whole. Null when the list never closes.
+ */
+function goListItems(text: string, open: number): { items: string[]; end: number } | null {
+  const items: string[] = [];
+  let depth = 0;
+  let item = '';
+  for (let i = open; i < text.length; i++) {
+    const c = text[i]!;
+    if (c === '/' && (text[i + 1] === '/' || text[i + 1] === '*')) {
+      const end = text[i + 1] === '/' ? text.indexOf('\n', i) : text.indexOf('*/', i + 2) + 1;
+      if (end <= 0) return null;
+      i = end;
+      item += ' ';
+      continue;
+    }
+    if (c === '"' || c === '`' || c === "'") {
+      let j = i + 1;
+      while (j < text.length && text[j] !== c) j += c !== '`' && text[j] === '\\' ? 2 : 1;
+      if (j >= text.length) return null;
+      item += text.slice(i, j + 1);
+      i = j;
+      continue;
+    }
+    if (c === '(' || c === '[' || c === '{') {
+      if (depth++ === 0) continue;
+    } else if (c === ')' || c === ']' || c === '}') {
+      if (--depth === 0) {
+        if (item.trim()) items.push(item.trim());
+        return { items, end: i };
+      }
+    } else if (c === ',' && depth === 1) {
+      if (item.trim()) items.push(item.trim());
+      item = '';
+      continue;
+    }
+    item += c;
+  }
+  return null;
+}
+
+/**
+ * A Go signature as extraction stores it for a function or method — the
+ * parameter list's text, then the result's — split into its parameters and
+ * results: `(ctx context.Context, a, b int) (int, error)` has the parameters
+ * `ctx context.Context`, `a` and `b int`. Null when the text has another shape.
+ */
+function goSignatureParts(signature: string | undefined): { params: string[]; results: string[] } | null {
+  const sig = signature?.trim();
+  if (!sig || sig[0] !== '(') return null;
+  const params = goListItems(sig, 0);
+  if (!params) return null;
+  const rest = sig.slice(params.end + 1).trim();
+  if (rest[0] !== '(') return { params: params.items, results: rest ? [rest] : [] };
+  const results = goListItems(rest, 0);
+  if (!results || rest.slice(results.end + 1).trim()) return null;
+  return { params: params.items, results: results.items };
+}
+
+/**
+ * How many parameters and results a Go signature has, as `params/results`:
+ * `(ctx context.Context, keys ...string) (int, error)` is `2/2`, and a grouped
+ * `a, b int` is two parameters. Null when the signature doesn't read.
+ */
+export function goSignatureArity(signature: string | undefined): string | null {
+  const parts = goSignatureParts(signature);
+  return parts ? `${parts.params.length}/${parts.results.length}` : null;
+}
+
+/**
+ * The arity a gRPC server implements an RPC with, read off the signature the
+ * generated client has for it. A unary call (`Range(ctx, in *RangeRequest,
+ * opts ...grpc.CallOption) (*RangeResponse, error)`) is served without the
+ * call options (`Range(ctx, *RangeRequest) (*RangeResponse, error)`); a
+ * streaming one (`Watch(ctx, opts ...grpc.CallOption) (Watch_WatchClient,
+ * error)`) gets its stream in their place and returns an error
+ * (`Watch(Watch_WatchServer) error`). Null when it isn't a client's.
+ */
+function goGrpcServerArity(signature: string | undefined): string | null {
+  const parts = goSignatureParts(signature);
+  const opts = parts?.params[parts.params.length - 1];
+  if (!parts || !opts || !/^(?:[A-Za-z_]\w*\s+)?\.\.\.\s*(?:grpc\.)?CallOption$/.test(opts)) return null;
+  const unary = parts.results.length === 2 && parts.results[0]!.startsWith('*');
+  return `${parts.params.length - 1}/${unary ? 2 : 1}`;
+}
+
 /**
  * Go implicit interface satisfaction (#584). Go has no `implements` keyword — a
- * struct satisfies an interface structurally when its method set covers the
- * interface's. Synthesize the missing `implements` edge (struct → interface) by
- * matching method-NAME sets, so impl-navigation works and the interface-dispatch
+ * type satisfies an interface structurally when its method set covers the
+ * interface's. Synthesize the missing `implements` edge (type → interface) by
+ * matching method sets, so impl-navigation works and the interface-dispatch
  * bridge ({@link interfaceOverrideEdges}, now 'go'-enabled) can link an interface
- * method call to the concrete overrides.
+ * method call to the concrete overrides, and to the methods embedding promotes.
+ *
+ * The implementers are structs and defined types. A defined type declares
+ * methods as a struct does — gin's `type formSource map[string][]string` has
+ * `TrySet`, prometheus's `type staticDiscoverer []*targetgroup.Group` has `Run`,
+ * an adapter `type HandlerFunc func(…)` has `ServeHTTP` — and is extracted as a
+ * `type_alias` that owns them through `contains` edges. Go gives it none of
+ * the methods declared on the type it is written over, so it is matched by
+ * the methods it declares. A true alias (`type A = B`) is B, not a type of its
+ * own: its `type_alias` owns only methods written with it as the receiver
+ * (`func (c *KumaSDConfig) Name()`), which are B's, and stands in for B with
+ * those. One without any is no implementer.
  *
- * Name-only matching (signatures ignored) — over-approximation accepted, in line
- * with the other dispatch synthesizers; capped per interface. Empty interfaces
- * (`any`) are skipped so they don't match every struct.
+ * Both method sets include what embedding brings in, read off the declared
+ * `extends`/`implements` edge each embedded type is. An interface has the
+ * methods of the interfaces it embeds: etcd's `AuthReadTx` is `RLock` and
+ * `RUnlock` plus all of `UnsafeAuthReader`, so an `RWMutex` is not one. A struct
+ * has the methods promoted from the structs, interfaces and defined types it
+ * embeds, at any depth: counting embedded interfaces alone would drop every
+ * struct that satisfies one through promoted methods. Synthesized edges are
+ * never followed (this pass writes them), and an embedding that resolved to
+ * nothing (`io.Closer`) adds nothing.
+ *
+ * Each wanted method also needs a declaration with its parameter and result
+ * counts, read off the stored signatures: Go wants the signatures identical,
+ * and the counts are what the text settles for certain — a cache's `Get(ctx,
+ * key, opts ...OpOption)` is no `Get(id types.ID) Peer`. A signature that
+ * doesn't read rules nothing out. A gRPC client interface also takes the
+ * structs serving its service (see `wantedArities`), the bridge a client's
+ * call crosses to reach its handler.
+ *
+ * Types are not compared, and a promoted name counts even where Go finds it
+ * ambiguous or hidden by a field — over-approximation accepted, in line with
+ * the other dispatch synthesizers; capped per interface. Empty interfaces
+ * (`any`) are skipped so they don't match every type, and a struct that
+ * embeds the interface keeps the edge its embedding already is.
  */
 async function goImplementsEdges(queries: QueryBuilder, onYield: MaybeYield): Promise<Edge[]> {
   let scanned255 = 0;
   const edges: Edge[] = [];
   const seen = new Set<string>();
 
-  const methodNameSet = (id: string): Set<string> =>
-    new Set(
-      queries
-        .getOutgoingEdges(id, ['contains'])
-        .map((e) => queries.getNodeById(e.target))
-        .filter((n): n is Node => !!n && n.kind === 'method')
-        .map((n) => n.name),
-    );
+  // Materializes GO types only (the pass is language-gated by the caller),
+  // never the whole struct kind — that array is O(nodes) on struct-heavy repos
+  // like the Linux kernel (#1212). Structs and defined types arrive
+  // interleaved in one canonical order, so the cap below takes implementers
+  // as the files declare them, whatever their kind.
+  const goImplementers: Node[] = [];
+  for (const n of queries.iterateNodesByKindIn(['struct', 'type_alias'], ['go'])) {
+    if ((++scanned255 & 63) === 0) await onYield();
+    goImplementers.push(n);
+  }
+  const goInterfaces: Node[] = [];
+  for (const i of queries.iterateNodesByKindIn('interface', ['go'])) {
+    if ((++scanned255 & 63) === 0) await onYield();
+    goInterfaces.push(i);
+  }
 
-  // Materializes GO structs only (the pass is language-gated by the caller),
-  // never the whole struct kind — that array is O(nodes) on struct-heavy
-  // repos like the Linux kernel (#1212).
-  const goStructs: Node[] = [];
-  for (const s of queries.iterateNodesByKindIn('struct', ['go'])) {
+  // The kinds of type whose methods embedding passes on: a struct can embed a
+  // defined type (`type HandlersChain []HandlerFunc`) as well.
+  const typeKind = new Map<string, NodeKind>();
+  for (const n of goImplementers) typeKind.set(n.id, n.kind);
+  for (const i of goInterfaces) typeKind.set(i.id, 'interface');
+  const kindOf = (id: string): NodeKind | null => typeKind.get(id) ?? null;
+
+  // Memoized: an embedded base is read once, however many types embed it. Each
+  // method's stored signature rides along for the arity check below.
+  const ownMemo = new Map<string, Set<string>>();
+  const ownSignatures = new Map<string, Map<string, (string | undefined)[]>>();
+  const ownMethods = (id: string): Set<string> => {
+    let names = ownMemo.get(id);
+    if (!names) {
+      names = new Set();
+      const signatures = new Map<string, (string | undefined)[]>();
+      for (const e of queries.getOutgoingEdges(id, ['contains'])) {
+        const n = queries.getNodeById(e.target);
+        if (!n || n.kind !== 'method') continue;
+        names.add(n.name);
+        const list = signatures.get(n.name);
+        if (list) list.push(n.signature);
+        else signatures.set(n.name, [n.signature]);
+      }
+      ownMemo.set(id, names);
+      ownSignatures.set(id, signatures);
+    }
+    return names;
+  };
+
+  // The types one embeds: an interface embeds interfaces, a struct any of the
+  // three. Every type's are read up front in a few batched queries rather than
+  // one query per type.
+  const isEmbedding = (e: Edge): boolean => isGoEmbedding(e, kindOf);
+  const NO_EMBEDS: string[] = [];
+  const embedMemo = new Map<string, string[]>();
+  const typeIds = [...typeKind.keys()];
+  for (let i = 0; i < typeIds.length; i += 2000) {
+    for (const e of queries.getOutgoingEdgesFrom(typeIds.slice(i, i + 2000), ['extends', 'implements'])) {
+      if (!isEmbedding(e)) continue;
+      const targets = embedMemo.get(e.source);
+      if (targets) targets.push(e.target);
+      else embedMemo.set(e.source, [e.target]);
+    }
+    await onYield();
+  }
+  const embeds = (id: string): string[] => embedMemo.get(id) ?? NO_EMBEDS;
+
+  // The type and every type it embeds, down to the last level. Go allows a
+  // struct to embed a pointer to itself, or to one embedding it back.
+  const embedClosure = (id: string): string[] => {
+    if (embeds(id).length === 0) return [id];
+    const reached = new Set<string>([id]);
+    const pending = [id];
+    while (pending.length > 0) {
+      const at = pending.pop()!;
+      for (const t of embeds(at)) {
+        if (reached.has(t)) continue;
+        reached.add(t);
+        pending.push(t);
+      }
+    }
+    return [...reached];
+  };
+
+  // Own methods plus every embedded type's.
+  const methodSet = (id: string): Set<string> => {
+    const types = embedClosure(id);
+    if (types.length === 1) return ownMethods(id);
+    const names = new Set<string>();
+    for (const t of types) for (const m of ownMethods(t)) names.add(m);
+    return names;
+  };
+
+  const covers = (have: Set<string>, want: Set<string>): boolean => {
+    if (have.size < want.size) return false;
+    for (const m of want) {
+      if (!have.has(m)) return false;
+    }
+    return true;
+  };
+
+  // Each method name in a type's method set → the arities (`params/results`)
+  // its declarations there have, or null when one of their signatures doesn't
+  // read (then the name rules nothing out). Built only for the pairs whose
+  // names already match.
+  const arityMemo = new Map<string, Map<string, Set<string> | null>>();
+  const methodArities = (id: string): Map<string, Set<string> | null> => {
+    let arities = arityMemo.get(id);
+    if (arities) return arities;
+    arities = new Map();
+    for (const t of embedClosure(id)) {
+      ownMethods(t);
+      for (const [name, signatures] of ownSignatures.get(t) ?? []) {
+        let known = arities.get(name);
+        if (known === null) continue;
+        if (!known) arities.set(name, (known = new Set()));
+        for (const signature of signatures) {
+          const arity = goSignatureArity(signature);
+          if (arity === null) {
+            arities.set(name, null);
+            break;
+          }
+          known.add(arity);
+        }
+      }
+    }
+    arityMemo.set(id, arities);
+    return arities;
+  };
+  // The arities an implementer may declare each of an interface's methods
+  // with: the interface's own. A gRPC client interface (every method takes
+  // `opts ...grpc.CallOption` last) also takes its service's server side, so
+  // the structs serving it (etcd's `kvServer` for `KVClient`) stay linked and
+  // a client's call keeps reaching the handler that serves it.
+  const wantedArities = (iface: Node): Map<string, Set<string> | null> => {
+    const own = methodArities(iface.id);
+    const wanted = new Map<string, Set<string> | null>();
+    for (const t of embedClosure(iface.id)) {
+      for (const [name, signatures] of ownSignatures.get(t) ?? []) {
+        let arities = wanted.get(name);
+        if (!arities) wanted.set(name, (arities = new Set(own.get(name))));
+        for (const signature of signatures) {
+          const served = goGrpcServerArity(signature);
+          if (served === null) return own;
+          arities.add(served);
+        }
+      }
+    }
+    return wanted;
+  };
+
+  // Go accepts an implementation only when each method's signature is the
+  // interface's. The stored text settles how many parameters and results
+  // there are: a type with no declaration of a wanted name at a wanted arity
+  // can't satisfy it.
+  const aritiesFit = (typeId: string, wanted: Map<string, Set<string> | null>): boolean => {
+    const have = methodArities(typeId);
+    for (const [name, arities] of wanted) {
+      const got = have.get(name);
+      if (!arities || !got) continue;
+      let fits = false;
+      for (const arity of arities) {
+        if (got.has(arity)) {
+          fits = true;
+          break;
+        }
+      }
+      if (!fits) return false;
+    }
+    return true;
+  };
+
+  // A type without a method satisfies no interface this pass looks at.
+  const candidates: Node[] = [];
+  const candidateMethods = new Map<string, Set<string>>();
+  for (const s of goImplementers) {
     if ((++scanned255 & 63) === 0) await onYield();
-    goStructs.push(s);
+    const have = methodSet(s.id);
+    if (have.size === 0) continue;
+    candidates.push(s);
+    candidateMethods.set(s.id, have);
   }
-  const structMethods = new Map<string, Set<string>>();
-  for (const s of goStructs) structMethods.set(s.id, methodNameSet(s.id));
 
-  for (const iface of queries.iterateNodesByKindIn('interface', ['go'])) {
+  for (const iface of goInterfaces) {
     if ((++scanned255 & 63) === 0) await onYield();
-    const want = methodNameSet(iface.id);
+    const want = methodSet(iface.id);
     if (want.size === 0) continue; // empty interface (`any`) — would match everything
     let added = 0;
-    for (const s of goStructs) {
-      if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
-      const have = structMethods.get(s.id);
-      if (!have || have.size < want.size) continue;
-      let all = true;
-      for (const m of want) {
-        if (!have.has(m)) { all = false; break; }
-      }
-      if (!all) continue;
+    const link = (s: Node): void => {
       const key = `${s.id}>${iface.id}`;
-      if (seen.has(key)) continue;
+      if (seen.has(key)) return;
       seen.add(key);
       edges.push({
         source: s.id,
@@ -864,6 +1148,26 @@ async function goImplementsEdges(queries: QueryBuilder, onYield: MaybeYield): Pr
         metadata: { synthesizedBy: 'go-implements', via: iface.name, registeredAt: `${s.filePath}:${s.startLine}` },
       });
       added++;
+    };
+    // A struct that needs promoted methods waits for the types declaring all
+    // of them, every defined type among them: under the cap, those are what
+    // the interface-dispatch bridge links a call through the interface to.
+    const throughEmbedding: Node[] = [];
+    let wanted: Map<string, Set<string> | null> | undefined;
+    for (const s of candidates) {
+      if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
+      const have = candidateMethods.get(s.id)!;
+      if (!covers(have, want)) continue;
+      if (embeds(s.id).includes(iface.id)) continue; // declared by embedding it
+      if (!wanted) wanted = wantedArities(iface);
+      if (!aritiesFit(s.id, wanted)) continue;
+      const own = ownMethods(s.id);
+      if (own !== have && !covers(own, want)) throughEmbedding.push(s);
+      else link(s);
+    }
+    for (const s of throughEmbedding) {
+      if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
+      link(s);
     }
   }
   return edges;
@@ -1011,6 +1315,118 @@ async function kotlinExpectActualEdges(queries: QueryBuilder, onYield: MaybeYiel
   return edges;
 }
 
+/** The methods a Go struct runs for a name it does not declare, and the line of the embedding they come through. */
+interface GoPromotion {
+  methods: Node[];
+  line: number;
+}
+
+/**
+ * Which embedded type's method a Go struct runs for a name it does not
+ * declare, picked the way Go's selector picks it: breadth-first through the
+ * struct's embeddings, the shallowest depth holding the name wins, and the
+ * name selects nothing when it occurs more than once at that depth, one type
+ * reached along two paths included. A type met at a shallower depth is not
+ * walked again. An embedded interface brings its whole method set at its own
+ * depth, and a method it provides is a dynamic call once more, so that is no
+ * promotion either. Struct fields are not in the graph: a field that hides a
+ * promoted method is not seen.
+ */
+function goPromotions(
+  queries: QueryBuilder,
+  methodsOf: (id: string) => Node[]
+): (structId: string, name: string) => GoPromotion | null {
+  const kinds = new Map<string, NodeKind | null>();
+  const kindOf = (id: string): NodeKind | null => {
+    let kind = kinds.get(id);
+    if (kind === undefined) {
+      const n = queries.getNodeById(id);
+      kind = n?.language === 'go' && (n.kind === 'struct' || n.kind === 'interface' || n.kind === 'type_alias')
+        ? n.kind
+        : null;
+      kinds.set(id, kind);
+    }
+    return kind;
+  };
+  const embedMemo = new Map<string, Edge[]>();
+  const embeds = (id: string): Edge[] => {
+    let out = embedMemo.get(id);
+    if (!out) {
+      const targets = new Set<string>();
+      out = queries.getOutgoingEdges(id, ['extends', 'implements']).filter((e) => {
+        if (!isGoEmbedding(e, kindOf) || targets.has(e.target)) return false;
+        targets.add(e.target);
+        return true;
+      });
+      embedMemo.set(id, out);
+    }
+    return out;
+  };
+  const ifaceMemo = new Map<string, Set<string>>();
+  const ifaceMethods = (id: string): Set<string> => {
+    let names = ifaceMemo.get(id);
+    if (!names) {
+      names = new Set<string>();
+      const reached = new Set<string>([id]);
+      const pending = [id];
+      while (pending.length > 0) {
+        const at = pending.pop()!;
+        for (const m of methodsOf(at)) names.add(m.name);
+        for (const e of embeds(at)) {
+          if (reached.has(e.target)) continue;
+          reached.add(e.target);
+          pending.push(e.target);
+        }
+      }
+      ifaceMemo.set(id, names);
+    }
+    return names;
+  };
+  const provides = (id: string, name: string): boolean =>
+    kindOf(id) === 'interface' ? ifaceMethods(id).has(name) : methodsOf(id).some((m) => m.name === name);
+
+  const memo = new Map<string, GoPromotion | null>();
+  return (structId, name) => {
+    const key = `${structId}>${name}`;
+    const hit = memo.get(key);
+    if (hit !== undefined) return hit;
+    let found: GoPromotion | null = null;
+    // Each type at the current depth, with how many paths reach it and the
+    // line of the struct's own embedding the first of them starts with.
+    let level = new Map<string, { paths: number; line: number }>([[structId, { paths: 1, line: 0 }]]);
+    const met = new Set<string>([structId]);
+    for (let depth = 0; level.size > 0; depth++) {
+      const next = new Map<string, { paths: number; line: number }>();
+      for (const [id, at] of level) {
+        if (kindOf(id) === 'interface') continue; // its embeddings are its method set
+        for (const e of embeds(id)) {
+          if (met.has(e.target)) continue;
+          const to = next.get(e.target);
+          if (to) to.paths += at.paths;
+          else next.set(e.target, { paths: at.paths, line: depth === 0 ? (e.line ?? 0) : at.line });
+        }
+      }
+      let paths = 0;
+      let provider: string | undefined;
+      for (const [id, at] of next) {
+        met.add(id);
+        if (!provides(id, name)) continue;
+        paths += at.paths;
+        provider = id;
+      }
+      if (provider !== undefined) {
+        if (paths === 1 && kindOf(provider) !== 'interface') {
+          found = { methods: methodsOf(provider).filter((m) => m.name === name), line: next.get(provider)!.line };
+        }
+        break;
+      }
+      level = next;
+    }
+    memo.set(key, found);
+    return found;
+  };
+}
+
 async function interfaceOverrideEdges(queries: QueryBuilder, onYield: MaybeYield): Promise<Edge[]> {
   let scanned255 = 0;
   const edges: Edge[] = [];
@@ -1048,12 +1464,26 @@ async function interfaceOverrideEdges(queries: QueryBuilder, onYield: MaybeYield
     protocolMemo.set(base.id, methods);
     return methods;
   };
+  // A Go struct also satisfies an interface with the methods its embedded
+  // types promote into it (goImplementsEdges counts them), and a call through
+  // the interface then runs the embedded type's method. Those links are made
+  // after the loop, from what the struct's cap has left, so every override
+  // keeps its edge, and a provider that implements the interface itself keeps
+  // its own.
+  const goPromotion = goPromotions(queries, methodsOf);
+  const promoted: { cls: Node; methods: Node[]; left: number }[] = [];
   // Concrete-side kinds vary by language: `class` covers Java / Kotlin /
   // C# / TS / Swift-classes / Scala-classes; `struct` covers Swift value
-  // types that conform to protocols. Iterate both.
+  // types that conform to protocols. Iterate both. A Go defined type
+  // (`type HandlerFunc func(…)`) holds its methods as a struct does, as a
+  // `type_alias`; that kind is walked for Go alone.
   const concreteKinds = ['class', 'struct', 'union'] as const;
-  for (const kind of concreteKinds) {
-  for (const cls of queries.iterateNodesByKind(kind)) {
+  const concrete = [
+    ...concreteKinds.map((kind) => () => queries.iterateNodesByKind(kind)),
+    () => queries.iterateNodesByKindIn('type_alias', ['go']),
+  ];
+  for (const nodesOfKind of concrete) {
+  for (const cls of nodesOfKind()) {
     if ((++scanned255 & 63) === 0) await onYield();
     // A class can only emit here if it HAS a supertype edge — check that
     // (one edge query) before materializing its methods: most classes in a
@@ -1061,10 +1491,21 @@ async function interfaceOverrideEdges(queries: QueryBuilder, onYield: MaybeYield
     const sups = queries.getOutgoingEdges(cls.id, ['implements', 'extends']);
     if (sups.length === 0) continue;
     const implMethods = methodsOf(cls.id).filter((n) => IFACE_OVERRIDE_LANGS.has(n.language));
-    if (implMethods.length === 0) continue;
+    // A Go struct that satisfies an interface (a synthesized edge) may do so
+    // with promoted methods alone. Its declared `implements` edges are the
+    // interfaces it embeds, which provide whatever it lacks themselves.
+    const goStruct = cls.language === 'go' && cls.kind === 'struct';
+    if (implMethods.length === 0 && !(goStruct && sups.some((s) => s.provenance === 'heuristic'))) continue;
     for (const sup of sups) {
       const base = queries.getNodeById(sup.target);
       if (!base || !IFACE_OVERRIDE_LANGS.has(base.language) || base.id === cls.id) continue;
+      // Go has no inheritance: a Go type's supertype edge to a struct or a
+      // defined type is an embedding (`type Engine struct { RouterGroup }`),
+      // and a call on the embedded type runs its own method, never the
+      // embedder's of the same name. Only a call through an interface
+      // dispatches.
+      if (cls.language === 'go' && base.kind !== 'interface') continue;
+      const promotes = goStruct && sup.provenance === 'heuristic' && base.kind === 'interface';
       // Group impl methods by name to handle OVERLOADS: an interface `list()` and
       // `list(params)` are distinct nodes and a call may resolve to either, so
       // link every base overload → every same-name impl overload (keying by name
@@ -1075,9 +1516,15 @@ async function interfaceOverrideEdges(queries: QueryBuilder, onYield: MaybeYield
         if (arr) arr.push(m); else implByName.set(m.name, [m]);
       }
       let added = 0;
+      const unmatched: Node[] = [];
       for (const bm of baseMethodsOf(base)) {
         if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
-        for (const m of implByName.get(bm.name) ?? []) {
+        const impls = implByName.get(bm.name);
+        if (!impls) {
+          if (promotes) unmatched.push(bm);
+          continue;
+        }
+        for (const m of impls) {
           if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
           if (bm.id === m.id) continue;
           const key = `${bm.id}>${m.id}`;
@@ -1094,9 +1541,43 @@ async function interfaceOverrideEdges(queries: QueryBuilder, onYield: MaybeYield
           added++;
         }
       }
+      if (unmatched.length > 0 && added < MAX_CALLBACKS_PER_CHANNEL) {
+        promoted.push({ cls, methods: unmatched, left: MAX_CALLBACKS_PER_CHANNEL - added });
+      }
     }
   }
   }
+  // The wiring site of a promoted method is the struct's embedding it comes
+  // through: `type blockSeriesSet struct{ blockBaseSeriesSet }`.
+  for (const { cls, methods, left } of promoted) {
+    if ((++scanned255 & 63) === 0) await onYield();
+    let budget = left;
+    for (const bm of methods) {
+      if (budget <= 0) break;
+      const promotion = goPromotion(cls.id, bm.name);
+      if (!promotion) continue;
+      for (const m of promotion.methods) {
+        if (budget <= 0) break;
+        const key = `${bm.id}>${m.id}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        edges.push({
+          source: bm.id,
+          target: m.id,
+          kind: 'calls',
+          line: bm.startLine,
+          provenance: 'heuristic',
+          metadata: {
+            synthesizedBy: 'interface-impl',
+            via: m.name,
+            promotedInto: cls.name,
+            registeredAt: `${cls.filePath}:${promotion.line || cls.startLine}`,
+          },
+        });
+        budget--;
+      }
+    }
+  }
   return edges;
 }
 
@@ -1221,6 +1702,15 @@ const JSX_CHILD_KINDS = new Set<NodeKind>(['component', 'function', 'class']);
  */
 const JSX_CHILD_LANGUAGES = [...JS_FAMILY, 'vue', 'svelte'];
 
+function languageForJsxFile(file: string): Language {
+  if (file.endsWith('.tsx')) return 'tsx';
+  if (/\.[cm]?ts$/.test(file)) return 'typescript';
+  if (file.endsWith('.jsx')) return 'jsx';
+  if (file.endsWith('.vue')) return 'vue';
+  if (file.endsWith('.svelte')) return 'svelte';
+  return 'javascript';
+}
+
 /** `localName` → the project file it is imported from, for one file's imports. */
 function importedFrom(ctx: ResolutionContext, file: string, language: Language): Map<string, string> {
   const out = new Map<string, string>();
@@ -1258,7 +1748,21 @@ function jsxChild(
   importsOf: () => Map<string, string>
 ): Node | undefined {
   const candidates = ctx.getNodesByName(name).filter((n) => JSX_CHILD_KINDS.has(n.kind));
-  if (candidates.length <= 1) return candidates[0];
+  if (candidates.length === 0) {
+    // A name nothing declares is the file's DEFAULT import of a module's one
+    // component under another name: segmented-control renders
+    // `<RNCSegmentedControlNativeComponent>`, the default export of a module
+    // that is `requireNativeComponent('RNCSegmentedControl')`; element-plus's
+    // tests render `<Autocomplete>` from `autocomplete.vue`. A named import
+    // names an export of its own, which a barrel's one component is not.
+    const isDefault = ctx
+      .getImportMappings(file, languageForJsxFile(file))
+      .some((m) => m.localName === name && m.isDefault);
+    const from = isDefault ? importsOf().get(name) : undefined;
+    const components = from ? ctx.getNodesInFile(from).filter((n) => n.kind === 'component') : [];
+    return components.length === 1 ? components[0] : undefined;
+  }
+  if (candidates.length === 1) return candidates[0];
   const local = candidates.find((n) => n.filePath === file);
   if (local) return local;
   const from = importsOf().get(name);
@@ -1269,14 +1773,62 @@ function jsxChild(
   return candidates.find((n) => JSX_CHILD_LANGUAGES.includes(n.language)) ?? candidates[0];
 }
 
+/**
+ * Whether the `<Name` at `at` opens a JSX tag. A type argument list follows
+ * its type's name directly — `useState<User>()`, `Array<Item>`, the
+ * `<Document>` of `<PaginatedList<Document>` — and a tag never does, short of
+ * a `return` written up against it. A generic arrow function's type
+ * parameters read like a tag but constrain theirs: `<Entry extends
+ * BaseEntity>({ data }) =>`.
+ */
+function opensTag(src: string, at: number, name: string): boolean {
+  const end = at + 1 + name.length;
+  if (/^\s+extends\s/.test(src.slice(end, end + 40))) return false;
+  return !/[\w$]/.test(src[at - 1] ?? '') || /\breturn$/.test(src.slice(Math.max(0, at - 7), at));
+}
+
+/**
+ * Whether `src` writes `name` other than in a tag (`<Name`, `</Name`): a
+ * parent binds a name only where it writes it bare (`const Content =`,
+ * `(Widget) =>`), so the check for that runs only on these.
+ */
+function writtenBare(src: string, name: string): boolean {
+  for (let at = src.indexOf(name); at !== -1; at = src.indexOf(name, at + name.length)) {
+    if (/[\w$]/.test(src[at - 1] ?? '') || /[\w$]/.test(src[at + name.length] ?? '')) continue;
+    if (src[at - 1] === '<' || (src[at - 1] === '/' && src[at - 2] === '<')) continue;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * What a tag renders when its parent binds the name itself: a component the
+ * parent declares in its own lines (`const Row = ({ row }) => <tr />` in a
+ * table's body), else nothing. Any other local is no node, and a same-named
+ * component elsewhere is only a guess at what it holds.
+ */
+function declaredInside(ctx: ResolutionContext, name: string, parent: Node, child: Node): Node | undefined {
+  const inside = (n: Node) => n.id !== parent.id && n.filePath === parent.filePath &&
+    n.startLine >= parent.startLine && n.startLine <= parent.endLine;
+  if (inside(child)) return child;
+  return ctx.getNodesByName(name).find((n) => JSX_CHILD_KINDS.has(n.kind) && inside(n));
+}
+
 /**
  * Phase 5: React JSX child rendering. A component that returns `<Child .../>`
  * mounts Child — React calls it — but JSX instantiation isn't a static call edge,
  * so a render tree (App.render → StaticCanvas → renderStaticScene) breaks at the
  * JSX hop. Link parent → each capitalized JSX child it renders. File-oriented
- * (read each JSX file once). Precision gate: the child name must resolve to a
- * component/function/class node — TS generics like `Array<Foo>` resolve to a type
- * (or nothing) and are dropped.
+ * (read each JSX file once). Precision gates: the parent must write the name as
+ * a tag, not only in a type argument or parameter list (`useState<User>()`,
+ * `<Entry extends BaseEntity>(…) =>`; outline's `<PaginatedList<Document>`
+ * read its `Document` model class as a child), and the name must resolve to a
+ * component/function/class node. A name the parent binds itself by its first
+ * tag — a parameter, or a `const` like outline's `const Content = variant ===
+ * "dropdown" ? DropdownMenu.SubContent : ContextMenu.SubContent` — is that
+ * local, and renders only a component declared inside the parent
+ * (`declaredInside`). A destructured name still links by name, as a
+ * destructured function call does.
  */
 async function reactJsxChildEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]> {
   let scannedFiles = 0;
@@ -1299,17 +1851,47 @@ async function reactJsxChildEdges(ctx: ResolutionContext, onYield: MaybeYield):
     let imports: Map<string, string> | null = null;
     const importsOf = () =>
       (imports ??= importedFrom(ctx, file, parents[0]!.language));
+    // A function renders the tags its own lines hold, so functions that span
+    // the same lines share them: every function of a minified bundle spans
+    // its one line, and reading that line again per function took 9 to 25 s
+    // over go-ethereum's graphiql.min.js (2,234 functions on 980 KB). The
+    // file is split once, not once per function.
+    let lines: string[] | null = null;
+    // Each name a span holds, and the line of its first tag: 0 while only type
+    // argument or parameter lists name it (`opensTag`). `bare` holds the
+    // names it also writes outside a tag (`writtenBare`).
+    const tagsBySpan = new Map<string, { tags: Map<string, number>; bare: Set<string> }>();
     for (const parent of parents) {
-      const src = sliceLines(content, parent.startLine, parent.endLine);
-      if (!src || (!src.includes('</') && !src.includes('/>'))) continue;
-      const names = new Set<string>();
-      JSX_TAG_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      while ((m = JSX_TAG_RE.exec(src))) names.add(m[1]!);
+      if (!parent.startLine || !parent.endLine) continue;
+      const span = `${parent.startLine}:${parent.endLine}`;
+      let names = tagsBySpan.get(span);
+      if (!names) {
+        names = { tags: new Map<string, number>(), bare: new Set<string>() };
+        lines ??= content.split('\n');
+        const src = lines.slice(parent.startLine - 1, parent.endLine).join('\n');
+        if (src.includes('</') || src.includes('/>')) {
+          let line = parent.startLine;
+          let counted = 0;
+          JSX_TAG_RE.lastIndex = 0;
+          let m: RegExpExecArray | null;
+          while ((m = JSX_TAG_RE.exec(src))) {
+            for (let nl = src.indexOf('\n', counted); nl !== -1 && nl < m.index; nl = src.indexOf('\n', nl + 1)) line++;
+            counted = m.index;
+            if (!names.tags.get(m[1]!)) names.tags.set(m[1]!, opensTag(src, m.index, m[1]!) ? line : 0);
+          }
+          for (const [name, first] of names.tags) if (first && writtenBare(src, name)) names.bare.add(name);
+        }
+        tagsBySpan.set(span, names);
+      }
       let added = 0;
-      for (const name of names) {
+      for (const [name, line] of names.tags) {
         if (added >= MAX_JSX_CHILDREN) break;
-        const child = jsxChild(ctx, name, file, importsOf);
+        if (!line) continue;
+        let child = jsxChild(ctx, name, file, importsOf);
+        // A name the parent binds itself by its first tag is that local.
+        if (child && names.bare.has(name) && jsCodeBindsName(name, parent, file, line, ctx)) {
+          child = declaredInside(ctx, name, parent, child);
+        }
         if (!child || child.id === parent.id || crossesCodeBoundary(parent.language, child.language)) continue;
         const key = `${parent.id}>${child.id}`;
         if (seen.has(key)) continue;
@@ -1419,9 +2001,14 @@ async function vueTemplateEdges(ctx: ResolutionContext, onYield: MaybeYield): Pr
       const event = m[1]!;
       const expr = m[2]!.trim();
       if (expr.includes('=>') || expr.startsWith('$')) continue; // inline arrow / $emit
-      const name = expr.match(/^([A-Za-z_]\w*)/)?.[1];
+      // `@click="save"` names a method Vue calls with the event. A handler that
+      // is an expression — `save(item)`, `emit('close')`, `open = true` — is
+      // the template's own code: the Vue extractor records its calls, on their
+      // line (#2340), so resolving its leading name here too doubled those
+      // edges and bound `emit(…)` / `open = …` to any function of that name.
+      const name = expr.match(/^([A-Za-z_$][\w$]*)\s*(?:\(|$)/)?.[1];
       if (!name) continue;
-      const direct = resolve(name, HANDLER_KINDS);
+      const direct = name === expr ? resolve(name, HANDLER_KINDS) : undefined;
       if (direct) { addEdge(direct, { synthesizedBy: 'vue-handler', event }); continue; }
       // Composable-destructure handler → resolve to the composable's returned fn.
       const d = destructured.get(name);
@@ -1489,8 +2076,79 @@ const RN_JVM_EMIT_RE = /\.emit\s*\(\s*"([^"]+)"\s*,/g;
 // is followed by `… ) {`) never matches. Multi-line tolerant. (java/kotlin/swift)
 const RN_NATIVE_SENDEVENT_RE = /\bsendEvent\s*\([^;{}]*?"([^"]+)"/g;
 
+// The same calls with the event named by a CONSTANT — NetInfo listens with
+// `addListener(PrivateTypes.DEVICE_CONNECTIVITY_EVENT, …)`, many libraries emit
+// with `.emit(EVENT_NAME, …)` or `sendEventWithName:kLocationEvent`.
+const RN_OBJC_SEND_CONST_RE = /\bsendEventWithName\s*:\s*([A-Za-z_]\w*)\b/g;
+const RN_SWIFT_SEND_CONST_RE = /\bsendEvent\s*\(\s*withName\s*:\s*([A-Za-z_][\w.]*)/g;
+const RN_JVM_EMIT_CONST_RE = /\.emit\s*\(\s*([A-Za-z_][\w.]*)\s*,/g;
+const RN_NATIVE_SENDEVENT_CONST_RE = /\bsendEvent\s*\(\s*[A-Za-z_][\w.]*\s*,\s*([A-Za-z_][\w.]*)\s*,/g;
+const RN_JS_LISTEN_CONST_RE = /\.(?:on|once|addListener)\(\s*((?:[A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*)\s*,\s*([A-Za-z_$][\w$.]*|(?:async\s*)?(?:\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>|function\s*\())/g;
+
+const CONSTANT_KINDS = new Set<NodeKind>(['constant', 'variable', 'field', 'property', 'enum_member']);
+
+/**
+ * The string an event-name constant holds, read off its declaration line:
+ * `export const DEVICE_CONNECTIVITY_EVENT = 'netInfo.networkStatusDidChange'`,
+ * `static final String EVENT = "x"`, `const val EVENT = "x"`,
+ * `NSString *const kEvent = @"x"`, `#define kEvent @"x"`, `static let event = "x"`,
+ * an enum case `Changed = 'changed'`.
+ *
+ * Scoped as the language scopes the name, never by the name alone — a
+ * parameter `eventName` is not some test's `eventName = "pong"`:
+ * - a bare `NAME` is a declaration in the same file, or (JS) the one an
+ *   import of that name points at;
+ * - `Owner.NAME` is a declaration inside `Owner`, or (JS) `NAME` in the file
+ *   a namespace import `Owner` points at.
+ * Null unless those declarations agree on one literal.
+ */
+function constantEventName(expr: string, file: string, ctx: ResolutionContext, memo: Map<string, string | null>): string | null {
+  const key = `${file}\0${expr}`;
+  if (memo.has(key)) return memo.get(key)!;
+  const parts = expr.replace(/\.rawValue$/, '').split('.');
+  const name = parts[parts.length - 1]!;
+  const owner = parts.length > 1 ? parts[parts.length - 2]! : null;
+  let value: string | null = null;
+  if (/^[A-Za-z_$][\w$]*$/.test(name) && name !== 'this' && (parts.length <= 2 || parts[0] !== 'this')) {
+    const read = (n: Node): string | null => {
+      const line = (ctx.getFileLines?.(n.filePath) ?? ctx.readFile(n.filePath)?.split(/\r?\n/))?.[n.startLine - 1] ?? '';
+      const at = line.indexOf(name);
+      if (at < 0) return null;
+      const rest = line.slice(at + name.length);
+      const m = /^\s*(?::[^=;]*)?[=:]\s*@?(["'`])([^"'`]+)\1/.exec(rest) ?? /^\s+@?(")([^"]+)"/.exec(rest);
+      return m ? m[2]! : null;
+    };
+    const declaredIn = (f: string) => ctx.getNodesInFile(f).filter((n) => n.name === name && CONSTANT_KINDS.has(n.kind));
+    const js = /\.(?:[cm]?[jt]sx?)$/.test(file);
+    const language: Language = /\.tsx$/.test(file) ? 'tsx' : /\.[cm]?ts$/.test(file) ? 'typescript' : file.endsWith('.jsx') ? 'jsx' : 'javascript';
+    const importedFile = (local: string): string | null => {
+      if (!js) return null;
+      const binding = ctx.getImportMappings(file, language).find((m) => m.localName === local);
+      return binding ? resolveImportPath(binding.source, file, language, ctx) : null;
+    };
+    let decls: Node[] = [];
+    if (owner === null) {
+      decls = declaredIn(file);
+      if (decls.length === 0) {
+        const from = importedFile(name);
+        if (from) decls = declaredIn(from);
+      }
+    } else {
+      const from = importedFile(owner);
+      decls = from
+        ? declaredIn(from)
+        : ctx.getNodesByName(name).filter((n) => CONSTANT_KINDS.has(n.kind) && new RegExp(`(?:^|[.:])${owner}(?:[.:]|$)`).test(n.qualifiedName.slice(0, n.qualifiedName.lastIndexOf(name))));
+    }
+    const values = new Set(decls.map(read).filter((v): v is string => v !== null));
+    value = values.size === 1 ? [...values][0]! : null;
+  }
+  memo.set(key, value);
+  return value;
+}
+
 async function rnEventEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]> {
   let scannedFiles = 0;
+  const constants = new Map<string, string | null>();
   // Native dispatchers (source = the native method whose body sends the
   // event) and JS handlers (target = the function/method registered as
   // the listener) keyed by event name.
@@ -1520,6 +2178,11 @@ async function rnEventEdges(ctx: ResolutionContext, onYield: MaybeYield): Promis
       while ((m = RN_OBJC_SEND_RE.exec(content))) {
         if (m[1]) addDispatcher(m[1], lineOf(m.index));
       }
+      RN_OBJC_SEND_CONST_RE.lastIndex = 0;
+      while ((m = RN_OBJC_SEND_CONST_RE.exec(content))) {
+        const event = constantEventName(m[1]!, file, ctx, constants);
+        if (event) addDispatcher(event, lineOf(m.index));
+      }
     }
 
     // Swift side: same RCTEventEmitter method, parens/named-args syntax.
@@ -1533,6 +2196,11 @@ async function rnEventEdges(ctx: ResolutionContext, onYield: MaybeYield): Promis
       while ((m = RN_NATIVE_SENDEVENT_RE.exec(content))) {
         if (m[1]) addDispatcher(m[1], lineOf(m.index));
       }
+      RN_SWIFT_SEND_CONST_RE.lastIndex = 0;
+      while ((m = RN_SWIFT_SEND_CONST_RE.exec(content))) {
+        const event = constantEventName(m[1]!, file, ctx, constants);
+        if (event) addDispatcher(event, lineOf(m.index));
+      }
     }
 
     // JVM side: `.emit("X", …)` in Java/Kotlin, plus the common
@@ -1549,6 +2217,13 @@ async function rnEventEdges(ctx: ResolutionContext, onYield: MaybeYield): Promis
       while ((m = RN_NATIVE_SENDEVENT_RE.exec(content))) {
         if (m[1]) addDispatcher(m[1], lineOf(m.index));
       }
+      for (const re of [RN_JVM_EMIT_CONST_RE, RN_NATIVE_SENDEVENT_CONST_RE]) {
+        re.lastIndex = 0;
+        while ((m = re.exec(content))) {
+          const event = constantEventName(m[1]!, file, ctx, constants);
+          if (event) addDispatcher(event, lineOf(m.index));
+        }
+      }
     }
 
     // JS subscribers (.addListener("X", handler)). Restrict to JS-family
@@ -1634,6 +2309,23 @@ async function rnEventEdges(ctx: ResolutionContext, onYield: MaybeYield): Promis
         if (!map.has(enclosing.id)) map.set(enclosing.id, `${file}:${lineOf(m.index)}`);
         jsHandlersByEvent.set(event, map);
       }
+      // A constant event name: the listener lands where a literal one would —
+      // the named handler when it is a node, else the enclosing function.
+      RN_JS_LISTEN_CONST_RE.lastIndex = 0;
+      while ((m = RN_JS_LISTEN_CONST_RE.exec(content))) {
+        const event = constantEventName(m[1]!, file, ctx, constants);
+        if (!event) continue;
+        const arg = m[2]!;
+        const bare = /^[A-Za-z_$][\w$.]*$/.test(arg) ? arg.slice(arg.lastIndexOf('.') + 1) : null;
+        const line = lineOf(m.index);
+        // The handler this file names — never a same-named function elsewhere.
+        const named = bare ? nodesInFile.find((n) => (n.kind === 'function' || n.kind === 'method') && n.name === bare) : undefined;
+        const target = named ?? enclosingFn(nodesInFile, line);
+        if (!target) continue;
+        const map = jsHandlersByEvent.get(event) ?? new Map<string, string>();
+        if (!map.has(target.id)) map.set(target.id, `${file}:${line}`);
+        jsHandlersByEvent.set(event, map);
+      }
     }
   }
 
@@ -3757,6 +4449,8 @@ export const SYNTH_PASSES: SynthPassDef[] = [
   { name: 'reactRouterLinkEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => reactRouterLinkEdges(c, y) },
   { name: 'tanstackLinkEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => tanstackLinkEdges(c, y) },
   { name: 'vueRouterLinkEdges', gate: (has) => has('vue', ...JS_FAMILY), run: (_q, c, y) => vueRouterLinkEdges(c, y) },
+  // An Angular template: the child components it renders and its `routerLink`s.
+  { name: 'angularTemplateEdges', gate: (has) => has('typescript'), run: (_q, c, y) => angularTemplateEdges(c, y) },
   { name: 'svelteKitPageEdges', gate: (has) => has('svelte'), run: (_q, c, y) => svelteKitPageComponentEdges(c, y) },
   { name: 'svelteKitLinkEdges', gate: (has) => has('svelte'), run: (_q, c, y) => svelteKitLinkEdges(c, y) },
   { name: 'nixOptionEdges', gate: (has) => has('nix'), run: (q, _c, y) => nixOptionPathEdges(q, y) },
diff --git a/src/resolution/cpp-constructor.ts b/src/resolution/cpp-constructor.ts
index 92d2f4d7a2..30c756de04 100644
--- a/src/resolution/cpp-constructor.ts
+++ b/src/resolution/cpp-constructor.ts
@@ -7,6 +7,8 @@
  *  - the type is looked up in the LEXICAL namespaces of the call site — for
  *    `second::use()` writing `Widget w;`, `second::Widget` before a global
  *    `Widget`; a `::T` spelling is global only;
+ *  - a type named through a `typedef` / `using` alias is the type the alias
+ *    names, looked up from the alias's own scope (cpp-type-aliases.ts);
  *  - among that type's constructors, the single overload whose parameter
  *    count admits the argument count wins (defaults and `...` widen a range);
  *    two admitting overloads (`T(int)` / `T(double)` for `T w(x)`) resolve to
@@ -17,6 +19,7 @@
  */
 import type { Node } from '../types';
 import type { ResolvedRef, ResolutionContext, UnresolvedRef } from './types';
+import { resolveCppAliasedType } from './cpp-type-aliases';
 
 const CONSTRUCTOR_REF = /^(.*)::([^:]+)\/(\d+)$/;
 
@@ -80,14 +83,26 @@ function constructorShape(signature: string | undefined): { min: number; max: nu
 export function matchCppConstructor(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
   const match = ref.referenceName.match(CONSTRUCTOR_REF);
   if (!match) return null;
-  const [, rawType, name, count] = match;
-  const type = rawType!.replace(/^::/, '');
-  if (type.split('::').pop() !== name) return null;
+  const [, rawType, ctorName, count] = match;
+  let type = rawType!.replace(/^::/, '');
+  if (type.split('::').pop() !== ctorName) return null;
   const argc = Number(count);
 
   // Innermost lexical namespace first, then outward, then global.
   const caller = context.getNodeById?.(ref.fromNodeId);
-  const scopes = rawType!.startsWith('::') ? [] : (caller?.qualifiedName.split('::') ?? []);
+  let scopes = rawType!.startsWith('::') ? [] : (caller?.qualifiedName.split('::') ?? []);
+  // A type named through an alias (`Table::Iterator iter(&table_);` under
+  // `typedef SkipList<…> Table;`) constructs the type the alias names, looked
+  // up from where the alias wrote it — never an outer class the alias hides.
+  if (!rawType!.startsWith('::')) {
+    const aliased = resolveCppAliasedType(type, ref, context);
+    if (aliased === null) return null;
+    if (aliased) {
+      type = [...aliased.target, ...aliased.rest].join('::');
+      scopes = aliased.scope ? aliased.scope.split('::') : [];
+    }
+  }
+  const name = type.split('::').pop()!;
   const candidates: string[] = [];
   for (let i = scopes.length; i > 0; i--) candidates.push(`${scopes.slice(0, i).join('::')}::${type}`);
   candidates.push(type);
@@ -98,7 +113,7 @@ export function matchCppConstructor(ref: UnresolvedRef, context: ResolutionConte
       .filter((n) => n.language === 'cpp' && (n.kind === 'class' || n.kind === 'struct' || n.kind === 'union'));
     if (owners.length === 0) continue;
     const constructors = context
-      .getNodesByName(name!)
+      .getNodesByName(name)
       .filter((n) => n.language === 'cpp' && n.kind === 'method' && n.qualifiedName === `${qualified}::${name}`);
     // Brace-init prefers an initializer_list overload over arity — that
     // choice needs the argument types, so decline.
diff --git a/src/resolution/cpp-includers.ts b/src/resolution/cpp-includers.ts
new file mode 100644
index 0000000000..d3fd4b5ef1
--- /dev/null
+++ b/src/resolution/cpp-includers.ts
@@ -0,0 +1,124 @@
+/**
+ * Which files include a C or C++ file: the files whose `#include` names it,
+ * then the files that include those, out to the translation units.
+ *
+ * Read from the `import` node extraction mints for every `#include`, each
+ * resolved by the import resolver exactly as the graph's include edge is, so
+ * "includes" here is the include edge a reader sees. The name matcher asks it
+ * whether a C or C++ file named like a test is part of a reference's
+ * translation unit: protobuf's conformance framework lives in
+ * `conformance/conformance_test.h` and `test_runner.h`, which the suites and
+ * runners that use it include.
+ *
+ * The walk starts from the included file, not from the reference's: a handful
+ * of such files are asked about, by references from many files, and a file
+ * nothing includes — a project's own tests, mostly — costs one map lookup.
+ */
+import type { Language, Node } from '../types';
+import type { ResolutionContext } from './types';
+
+/** One `#include` directive, as its import node records it. */
+interface Include {
+  id: string;
+  /** The path as written: `conformance/conformance_test.h`. */
+  spec: string;
+  file: string;
+  language: Language;
+  line: number;
+  column: number;
+}
+
+interface Memo {
+  /** Every C / C++ `#include`, by the file name it spells (`a/b.h` → `b.h`). */
+  byName: Map<string, Include[]> | null;
+  /** Import node id → the indexed file its `#include` names (null: none). */
+  targets: Map<string, string | null>;
+  /** File → the files that include it, directly or through other includes. */
+  includers: Map<string, ReadonlySet<string>>;
+}
+
+const MEMO = new WeakMap<ResolutionContext, Memo>();
+
+export function clearCppIncluderMemos(context: ResolutionContext): void {
+  MEMO.delete(context);
+}
+
+function memoFor(context: ResolutionContext): Memo {
+  let memo = MEMO.get(context);
+  if (!memo) MEMO.set(context, (memo = { byName: null, targets: new Map(), includers: new Map() }));
+  return memo;
+}
+
+const isCFamily = (language: string): boolean => language === 'c' || language === 'cpp';
+const fileName = (filePath: string): string => filePath.slice(Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\')) + 1);
+
+const toInclude = (n: Pick<Node, 'id' | 'name' | 'filePath' | 'language' | 'startLine' | 'startColumn'>): Include =>
+  ({ id: n.id, spec: n.name, file: n.filePath, language: n.language, line: n.startLine, column: n.startColumn });
+
+/** The indexed file an `#include` names, the way its include edge resolves it. */
+function includedFile(include: Include, context: ResolutionContext, memo: Memo): string | null {
+  const hit = memo.targets.get(include.id);
+  if (hit !== undefined) return hit;
+  const resolved = context.resolveImport?.({
+    fromNodeId: include.id,
+    referenceName: include.spec,
+    referenceKind: 'imports',
+    line: include.line,
+    column: include.column,
+    filePath: include.file,
+    language: include.language,
+  });
+  const target = resolved ? context.getNodeById?.(resolved.targetNodeId) : null;
+  const file = target?.kind === 'file' ? target.filePath : null;
+  memo.targets.set(include.id, file);
+  return file;
+}
+
+function includesByName(context: ResolutionContext, memo: Memo): Map<string, Include[]> {
+  if (memo.byName) return memo.byName;
+  const byName = new Map<string, Include[]>();
+  const nodes = context.getCppIncludeNodes?.() ?? context.iterateNodesByKind?.('import') ?? context.getNodesByKind('import');
+  for (const n of nodes) {
+    if (!isCFamily(n.language)) continue;
+    const name = fileName(n.name);
+    const list = byName.get(name);
+    if (list) list.push(toInclude(n));
+    else byName.set(name, [toInclude(n)]);
+  }
+  memo.byName = byName;
+  return byName;
+}
+
+/** The indexed file the `#include` an import node records names, or null. */
+export function cppIncludedFile(include: Node, context: ResolutionContext): string | null {
+  return include.kind === 'import' && isCFamily(include.language) ? includedFile(toInclude(include), context, memoFor(context)) : null;
+}
+
+/**
+ * Every file that includes `filePath`, directly or through the files that
+ * include it: the translation units (and headers) it is part of.
+ */
+export function cppIncluders(filePath: string, context: ResolutionContext): ReadonlySet<string> {
+  const memo = memoFor(context);
+  const hit = memo.includers.get(filePath);
+  if (hit) return hit;
+  const byName = includesByName(context, memo);
+  const found = new Set<string>();
+  const queue = [filePath];
+  for (let i = 0; i < queue.length; i++) {
+    const target = queue[i]!;
+    const name = fileName(target);
+    const dot = name.lastIndexOf('.');
+    // `#include "foo"` can name `foo.h`: the include resolver tries extensions.
+    for (const spelled of dot > 0 ? [name, name.slice(0, dot)] : [name]) {
+      for (const include of byName.get(spelled) ?? []) {
+        if (include.file === filePath || found.has(include.file)) continue;
+        if (includedFile(include, context, memo) !== target) continue;
+        found.add(include.file);
+        queue.push(include.file);
+      }
+    }
+  }
+  memo.includers.set(filePath, found);
+  return found;
+}
diff --git a/src/resolution/cpp-macro-visibility.ts b/src/resolution/cpp-macro-visibility.ts
index e5c76e2f11..b0b3ed18a8 100644
--- a/src/resolution/cpp-macro-visibility.ts
+++ b/src/resolution/cpp-macro-visibility.ts
@@ -15,6 +15,12 @@
  * flags remain possible, so only definite macro visibility suppresses a call.
  * Object-like definitions participate in conditions but never enter the cached
  * call-site timelines (vendor headers can contain tens of thousands of them).
+ *
+ * A guard the walk cannot decide (`#define X_H 1`, or any header reached under
+ * an unknown `#if`) re-enters its header on every inclusion path, which is
+ * exponential in the include graph's depth (#2127). A re-entry that provably
+ * repeats an earlier visit which changed nothing is skipped, and a hard budget
+ * bounds whatever is left: past it, nothing is known and nothing is suppressed.
  */
 import * as path from 'path';
 import { maskCppRawStrings } from '../extraction/languages/c-cpp';
@@ -29,17 +35,22 @@ type FileEvent =
   | { kind: 'branch'; op: string; expression: string; guard: boolean; line: number }
   | { kind: 'once'; line: number };
 type Event = { line: number; defined: Truth };
+/** Macro name → events in root-file line order; from `cutoff` on, nothing is known. */
+type Timeline = { events: Map<string, Event[]>; cutoff: number };
 type Cache = {
   summaries: Map<string, FileEvent[]>;
   includes: Map<string, string | null>;
   /** Indexed files by basename, for `#include "dir/name.h"` that no include root explains. */
   byBasename: Map<string, string[]> | null;
   /** Per root file: macro name → define/undef events in root-file line order. */
-  roots: Map<string, Map<string, Event[]>>;
+  roots: Map<string, Timeline>;
 };
 
 const memo = new WeakMap<ResolutionContext, Cache>();
 const ROOT_TIMELINE_CAP = 32;
+/** Directive events one translation-unit walk may evaluate (#2127). */
+const WALK_EVENT_BUDGET = 1_000_000;
+const NO_CUTS: string[] = [];
 
 const and = (a: Truth, b: Truth): Truth =>
   a === false || b === false ? false : a === true && b === true ? true : undefined;
@@ -79,7 +90,8 @@ export function isVisibleCppMacro(ref: UnresolvedRef, context: ResolutionContext
     if (cache.roots.size >= ROOT_TIMELINE_CAP) cache.roots.delete(cache.roots.keys().next().value!);
     cache.roots.set(rootKey, timeline);
   }
-  const before = (timeline.get(ref.referenceName) ?? []).filter((e) => e.line <= ref.line);
+  if (ref.line >= timeline.cutoff) return false;
+  const before = (timeline.events.get(ref.referenceName) ?? []).filter((e) => e.line <= ref.line);
   return before.length > 0 && before[before.length - 1]!.defined === true;
 }
 
@@ -250,12 +262,24 @@ function walkTranslationUnit(
   language: UnresolvedRef['language'],
   context: ResolutionContext,
   cache: Cache
-): Map<string, Event[]> {
+): Timeline {
   const timeline = new Map<string, Event[]>();
   const definitions = new Map<string, { defined: Truth; value: Truth; macro: Truth }>();
   const scanning = new Set<string>();
   const macroNames = new Set<string>();
   const once = new Map<string, Truth>();
+  // Every change a later directive could observe (definitions, `#pragma once`,
+  // the macro-name set) bumps `version`. A visit that left it unchanged, entered
+  // again with the same inherited truth while it is still unchanged, starts from
+  // the same state, so it would take the same branches and change nothing again;
+  // the events it would push repeat each name's current state, which is already
+  // its last event. Include cycles cut by the recursion stack (`cuts`) must still
+  // be cut for the repeat to hold.
+  let version = 0;
+  const cuts: string[] = [];
+  const visits = new Map<string, { inherited: Truth; start: number; end: number; cuts: string[] }>();
+  let budget = WALK_EVENT_BUDGET;
+  let cutoff = Infinity;
   const condition = (expression: string): Truth => {
     const text = expression.trim();
     if (/^(?:0x[\da-f]+|\d+)[uUlL]*$/i.test(text)) return Number(text.replace(/[uUlL]+$/, '')) !== 0;
@@ -267,12 +291,28 @@ function walkTranslationUnit(
     return /^\w+$/.test(text) ? definitions.get(text)?.value : undefined;
   };
   const scan = (file: string, inherited: Truth, includeLine?: number): void => {
-    if (inherited === false || scanning.has(file) || once.get(file) === true) return;
+    if (inherited === false || once.get(file) === true || cutoff !== Infinity) return;
+    if (scanning.has(file)) {
+      cuts.push(file);
+      return;
+    }
+    const seen = visits.get(file);
+    if (
+      seen && seen.inherited === inherited && seen.start === seen.end && seen.end === version &&
+      seen.cuts.every((c) => scanning.has(c))
+    ) {
+      cuts.push(...seen.cuts);
+      return;
+    }
+    const start = version;
+    const firstCut = cuts.length;
     scanning.add(file);
     let active: Truth = inherited;
     const frames: Array<{ parent: Truth; taken: Truth }> = [];
     for (const ev of summarize(file, context, cache)) {
       const line = includeLine ?? ev.line;
+      if (cutoff === Infinity && --budget < 0) cutoff = line;
+      if (cutoff !== Infinity) break;
       if (ev.kind === 'branch') {
         if (ev.op === 'if' || ev.op === 'ifdef' || ev.op === 'ifndef') {
           const known = definitions.get(ev.expression.trim())?.defined;
@@ -294,7 +334,9 @@ function walkTranslationUnit(
       }
       if (active === false) continue;
       if (ev.kind === 'once') {
-        once.set(file, or(once.get(file) ?? false, active));
+        const next = or(once.get(file) ?? false, active);
+        if (next !== (once.get(file) ?? false)) version++;
+        once.set(file, next);
         continue;
       }
       if (ev.kind === 'include') {
@@ -309,12 +351,17 @@ function walkTranslationUnit(
       // A name no directive has touched is unknown, not undefined: the build
       // can set it on the command line. So an `#undef` under an undecidable
       // `#if` leaves it unknown (#2069); only a certain one clears it.
-      definitions.set(ev.name, {
+      const next = {
         defined: defining ? or(prior?.defined, active) : and(prior?.defined, not(active)),
         value: defining && active === true ? condition(ev.value) : undefined,
         macro: now,
-      });
-      if (ev.functionLike) macroNames.add(ev.name);
+      };
+      if (next.defined !== prior?.defined || next.value !== prior?.value || next.macro !== prior?.macro) version++;
+      definitions.set(ev.name, next);
+      if (ev.functionLike && !macroNames.has(ev.name)) {
+        macroNames.add(ev.name);
+        version++;
+      }
       if (macroNames.has(ev.name)) {
         const events = timeline.get(ev.name) ?? [];
         events.push({ line, defined: now });
@@ -322,8 +369,11 @@ function walkTranslationUnit(
       }
     }
     scanning.delete(file);
+    const own = cuts.length > firstCut ? [...new Set(cuts.splice(firstCut))] : NO_CUTS;
+    cuts.push(...own);
+    visits.set(file, { inherited, start, end: version, cuts: own });
   };
 
   scan(rootFile, true);
-  return timeline;
+  return { events: timeline, cutoff };
 }
diff --git a/src/resolution/cpp-supertypes.ts b/src/resolution/cpp-supertypes.ts
new file mode 100644
index 0000000000..7ac3c74e44
--- /dev/null
+++ b/src/resolution/cpp-supertypes.ts
@@ -0,0 +1,276 @@
+/**
+ * A C or C++ base class — `class DynamicMessage final : public Message` — is
+ * the class C++ name lookup finds for it.
+ *
+ * The base used to be matched by its name alone, so one named like a class of
+ * another namespace, or of another language, bound to whichever namesake
+ * ranked first: protobuf's `google::protobuf::DynamicMessage` derived from
+ * `json_internal::ResolverPool::Message`, and before #2397 from the PHP
+ * extension's C struct `Message`; leveldb's iterators from
+ * `SkipList::Iterator`. A wrong supertype reaches everything that walks the
+ * hierarchy: the supertype walk that finds an inherited method, the
+ * cpp-override edges, the type hierarchy `codegraph_explore` prints.
+ *
+ * The name is looked up as C++ looks it up:
+ *  - from the scope the class is declared in (its own members are not in
+ *    scope in its base clause), outwards to the global scope; a class scope
+ *    includes its bases, a qualified name is resolved a segment at a time and
+ *    an alias is followed to the class it names (cpp-type-aliases.ts);
+ *    `::Base` is the global one;
+ *  - then through what the file writes before the class: a namespace alias
+ *    (`namespace _pbi = ::google::protobuf::internal;`), a using-declaration
+ *    (`using leveldb::FilterPolicy;`), a using-directive (`using namespace
+ *    ROCKSDB_NAMESPACE;`); and through a namespace a macro opens
+ *    (`fmt::detail::buffer` under fmt's FMT_BEGIN_NAMESPACE);
+ *  - a class a source file (`.cc`, `.cpp`, `.c`) defines belongs to that
+ *    translation unit, so only that file sees it (leveldb's skiplist test
+ *    declares its own `leveldb::Comparator`);
+ *  - a template parameter (`template <class Base> class X : public Base`) or
+ *    a member of one (`public T::Base`) is whatever a template argument makes
+ *    it: no edge.
+ * When none of that finds the class, a class of that name that is the only
+ * one the file can see is taken: the index loses a class's namespace in a
+ * few shapes (`class PROTOBUF_EXPORT FieldDescriptor`, the classes after a
+ * partial specialization), and the lookup from the wrong scope finds nothing.
+ * Several such classes would be a guess, so there is no edge.
+ *
+ * Only C and C++ declarations are candidates, and no other strategy (a
+ * framework's, the import resolver, name matching) sees these references.
+ */
+import type { Node } from '../types';
+import type { ResolvedRef, ResolutionContext, UnresolvedRef } from './types';
+import {
+  cppClassNamed,
+  cppParentScope,
+  cppScopesWithin,
+  cppTemplateParameters,
+  cppTypeSegments,
+  stripCppTemplateArguments,
+  type CppNamedClass,
+} from './cpp-type-aliases';
+import { cppMacroNamespaceFrames, cppNamespaceAliases } from './name-matcher';
+import { stripCommentsForRegex } from './strip-comments';
+
+const CLASS_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'union']);
+
+/** A C or C++ source file, whose definitions belong to its own translation unit. */
+const SOURCE_FILE = /\.(?:c|cc|cpp|cxx|c\+\+|cu|metal)$/i;
+
+/** Does `ref` name a C or C++ class's base? */
+export function isCppSupertypeRef(ref: UnresolvedRef): boolean {
+  return (ref.language === 'cpp' || ref.language === 'c') &&
+    (ref.referenceKind === 'extends' || ref.referenceKind === 'implements');
+}
+
+function isCFamily(n: Node): boolean {
+  return n.language === 'cpp' || n.language === 'c';
+}
+
+/** The declarations code in `file` can see: a header's, and the file's own. */
+function visibleFrom(file: string): (n: Node) => boolean {
+  return (n) => n.filePath === file || !SOURCE_FILE.test(n.filePath);
+}
+
+export function matchCppSupertype(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const derived = context.getNodeById?.(ref.fromNodeId);
+  if (!derived || !isCFamily(derived) || !CLASS_KINDS.has(derived.kind)) return null;
+  const written = writtenBase(ref, context);
+  const segments = cppTypeSegments(written);
+  if (!segments) return null;
+  const global = written.startsWith('::');
+  if (!global && cppTemplateParameters(derived, context).has(segments[0]!)) return null;
+
+  const visible = visibleFrom(derived.filePath);
+  const scopes = cppScopesWithin(cppParentScope(derived.qualifiedName));
+  const resolved = (target: Node | null | undefined): ResolvedRef | null =>
+    target ? { original: ref, targetNodeId: target.id, confidence: 0.9, resolvedBy: 'qualified-name' } : null;
+
+  // The scopes around the class, or only the global one for `::Base`.
+  const lexical = classNode(cppClassNamed(written, global ? [''] : scopes, ref, context, visible), derived, context);
+  if (lexical !== undefined) return resolved(lexical);
+
+  // What the file writes before the class, the nearest first: each stands for
+  // the name's first segment, and the rest stays as written.
+  const path = segments.join('::');
+  const first = /^\s*(?:::\s*)?[A-Za-z_]\w*/.exec(written)?.[0] ?? '';
+  const after = written.slice(first.length);
+  const usings = usingsIn(derived.filePath, context).filter((u) => u.line < ref.line).reverse();
+  const lookUp = (spelled: string): Node | undefined => {
+    const absolute = spelled.startsWith('::');
+    return classNode(cppClassNamed(spelled, absolute ? [''] : scopes, ref, context, visible), derived, context) ?? undefined;
+  };
+  // `::_pbi::MessageGlobalsBase` under `namespace _pbi = ::google::protobuf::internal;`.
+  if (segments.length > 1) {
+    const local = usings.find((u) => u.kind === 'alias' && u.name === segments[0]);
+    const target = local?.path ?? cppNamespaceAliases(context).get(segments[0]!);
+    const hit = target ? lookUp(target + after) : undefined;
+    if (hit) return resolved(hit);
+  }
+  if (!global) {
+    // `using leveldb::FilterPolicy;` … `public FilterPolicy`.
+    for (const u of usings) {
+      if (u.kind !== 'declaration' || u.name !== segments[0]) continue;
+      const hit = lookUp(u.path + after);
+      if (hit) return resolved(hit);
+    }
+    // `using namespace ROCKSDB_NAMESPACE;` … `public EventListener`.
+    for (const u of usings) {
+      if (u.kind !== 'directive') continue;
+      const hit = lookUp(`${u.path}::${written}`);
+      if (hit) return resolved(hit);
+    }
+  }
+  // `fmt::detail::buffer`, where a macro opens `namespace fmt` around `detail::buffer`.
+  if (segments.length > 1) {
+    const hit = pick(namedClasses(segments, derived, context, visible)
+      .filter((n) => macroQualifiedName(n, context) === path), derived);
+    if (hit) return resolved(hit);
+  }
+  // The only class of that name the file can see, by its qualified tail.
+  const tail = namedClasses(segments, derived, context, visible)
+    .filter((n) => n.qualifiedName === path || n.qualifiedName.endsWith(`::${path}`));
+  const own = tail.filter((n) => n.filePath === derived.filePath);
+  const sole = own.length > 0 ? own : tail;
+  return sole.length === 1 ? { original: ref, targetNodeId: sole[0]!.id, confidence: 0.7, resolvedBy: 'exact-match' } : null;
+}
+
+/**
+ * The base as the base clause writes it, template arguments included
+ * (`bool_constant<is_utf8_enabled>`): the reference carries the name without
+ * them, and an alias template is only ever named with them. The reference's
+ * own name when the source there reads otherwise.
+ */
+function writtenBase(ref: UnresolvedRef, context: ResolutionContext): string {
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/);
+  const text = lines?.slice(ref.line - 1, ref.line + 11).join('\n').slice(Math.max(0, ref.column)) ?? '';
+  let depth = 0;
+  let end = text.length;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]!;
+    // A template's `<` follows its name; `sizeof(T) <= 8` and `1 << n` compare and shift.
+    const opens = c === '(' || (c === '<' && /\w/.test(text[i - 1] ?? '') && text[i + 1] !== '=' && text[i + 1] !== '<');
+    const closes = c === ')' || (c === '>' && text[i - 1] !== '-' && text[i + 1] !== '=');
+    if (opens) depth++;
+    else if (closes) {
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+      depth--;
+    } else if (depth === 0 && (c === ',' || c === '{' || c === ';')) {
+      end = i;
+      break;
+    }
+  }
+  const written = text.slice(0, end).trim();
+  const squash = (s: string): string => s.replace(/\s+/g, '');
+  return squash(stripCppTemplateArguments(written)) === squash(ref.referenceName) ? written : ref.referenceName.trim();
+}
+
+/**
+ * The node of the class a lookup found, as the deriving class's file sees it
+ * (null: the name names no particular class; undefined: keep looking).
+ */
+function classNode(named: CppNamedClass, derived: Node, context: ResolutionContext): Node | null | undefined {
+  if (named === null || named === undefined) return named;
+  if ('alias' in named) return named.alias;
+  const classes = context
+    .getNodesByQualifiedName(named.cls)
+    .filter((n) => isCFamily(n) && CLASS_KINDS.has(n.kind) && n.id !== derived.id);
+  // A lookup that ended on the class itself (its namespace lost) found nothing.
+  if (classes.length === 0) return undefined;
+  const visible = classes.filter(visibleFrom(derived.filePath));
+  return pick(visible.length > 0 ? visible : classes, derived);
+}
+
+/**
+ * One of several declarations of a class (separate translation units,
+ * vendored copies): the deriving class's own file's, then its header's, then
+ * the nearest by path.
+ */
+function pick(classes: Node[], derived: Node): Node | undefined {
+  if (classes.length <= 1) return classes[0];
+  const own = classes.find((n) => n.filePath === derived.filePath);
+  if (own) return own;
+  const stem = (p: string): string => p.replace(/\.[^./\\]+$/, '');
+  const header = classes.find((n) => stem(n.filePath) === stem(derived.filePath));
+  if (header) return header;
+  const shared = (p: string): number => {
+    const a = p.split('/');
+    const b = derived.filePath.split('/');
+    let i = 0;
+    while (i < a.length - 1 && i < b.length - 1 && a[i] === b[i]) i++;
+    return i;
+  };
+  return classes.reduce((best, n) => (shared(n.filePath) > shared(best.filePath) ? n : best));
+}
+
+/** C and C++ classes named like the last segment of `segments` that `derived`'s file can see. */
+function namedClasses(segments: readonly string[], derived: Node, context: ResolutionContext, visible: (n: Node) => boolean): Node[] {
+  return context
+    .getNodesByName(segments[segments.length - 1]!)
+    .filter((n) => isCFamily(n) && CLASS_KINDS.has(n.kind) && n.id !== derived.id && visible(n));
+}
+
+/** A declaration's qualified name with the namespaces macros open around it: `fmt::detail::buffer` for `detail::buffer`. */
+function macroQualifiedName(n: Node, context: ResolutionContext): string {
+  const prefix = cppMacroNamespaceFrames(n.filePath, context)
+    .filter((f) => f.start <= n.startLine && f.end >= n.startLine)
+    .sort((a, b) => a.start - b.start)
+    .flatMap((f) => f.path);
+  return prefix.length > 0 ? `${prefix.join('::')}::${n.qualifiedName}` : n.qualifiedName;
+}
+
+/** A `using` declaration or directive, or a namespace alias, a C or C++ file writes. */
+interface CppUsing {
+  line: number;
+  kind: 'declaration' | 'directive' | 'alias';
+  /** The name it brings in: the declared name, or the alias. */
+  name: string;
+  /** What it names, as written: `leveldb::FilterPolicy`, `ROCKSDB_NAMESPACE`, `::google::protobuf::internal`. */
+  path: string;
+}
+
+const USINGS = new WeakMap<ResolutionContext, Map<string, CppUsing[]>>();
+
+/** Drop the per-file `using` memo (see ReferenceResolver.clearCaches). */
+export function clearCppSupertypeMemos(context: ResolutionContext): void {
+  USINGS.delete(context);
+}
+
+const PATH = String.raw`(?:::\s*)?[A-Za-z_]\w*(?:\s*::\s*[A-Za-z_]\w*)*`;
+const USING = new RegExp(
+  String.raw`\busing\s+namespace\s+(${PATH})\s*;` +
+  String.raw`|\busing\s+(${PATH}\s*::\s*[A-Za-z_]\w*)\s*;` +
+  String.raw`|\bnamespace\s+([A-Za-z_]\w*)\s*=\s*(${PATH})\s*;`,
+  'g',
+);
+
+/** The `using` declarations and directives and namespace aliases of a file, in order. */
+function usingsIn(file: string, context: ResolutionContext): CppUsing[] {
+  let memo = USINGS.get(context);
+  if (!memo) USINGS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const found: CppUsing[] = [];
+  const source = context.readFile(file);
+  if (source && (source.includes('using') || source.includes('namespace'))) {
+    const text = stripCommentsForRegex(source, 'cpp');
+    let line = 1;
+    let at = 0;
+    for (const m of text.matchAll(USING)) {
+      for (; at < m.index; at++) if (text.charCodeAt(at) === 10) line++;
+      const squash = (s: string): string => s.replace(/\s+/g, '');
+      if (m[1]) {
+        found.push({ line, kind: 'directive', name: '', path: squash(m[1]) });
+      } else if (m[2]) {
+        const path = squash(m[2]);
+        found.push({ line, kind: 'declaration', name: path.slice(path.lastIndexOf('::') + 2), path });
+      } else if (m[3] && m[4]) {
+        found.push({ line, kind: 'alias', name: m[3], path: squash(m[4]) });
+      }
+    }
+  }
+  memo.set(file, found);
+  return found;
+}
diff --git a/src/resolution/cpp-type-aliases.ts b/src/resolution/cpp-type-aliases.ts
new file mode 100644
index 0000000000..2a4cbf33eb
--- /dev/null
+++ b/src/resolution/cpp-type-aliases.ts
@@ -0,0 +1,640 @@
+/**
+ * C++ type aliases in a declared type: `typedef X Y;` and `using Y = X;`.
+ *
+ * Both extractors index an alias as a `type_alias` node and record nothing
+ * about the type it names, so a receiver declared through one used to be
+ * looked up by the alias's own name. google/leveldb's `MemTable::Add` calls
+ * `table_.Insert(buf)` on a member `Table table_;`, with
+ * `typedef SkipList<const char*, KeyComparator> Table;` declared beside it in
+ * the class. No class `Table` has an `Insert` (the one class `Table` is the
+ * unrelated `leveldb::Table`), so the call fell through to a guess by the
+ * receiver's name and reached `HandleTable::Insert`.
+ *
+ * A name is looked up the way C++ looks it up: from the innermost scope of
+ * the code that uses it outwards. That is an alias declared earlier in the
+ * calling function, then the caller's class and that class's bases, then the
+ * classes and namespaces around it, and the global scope. The first scope
+ * that declares the name decides; a class there is the type itself. An alias
+ * there is read from its own declaration and followed from the alias's own
+ * scope, for a few hops at most. A qualified name is resolved a segment at a
+ * time, so `Table::Iterator` is `SkipList::Iterator` and `MemTable::Table`
+ * is `SkipList`. Template arguments are dropped. An alias of what only a
+ * template argument decides (`using Type = GenericType;` in the template
+ * that declares `GenericType`, `typename Traits::Field`) or of a
+ * `decltype(…)` names no particular class, and is reported as such.
+ */
+import type { Node } from '../types';
+import type { ResolutionContext, UnresolvedRef } from './types';
+
+/** Kinds that declare a type name in a scope, besides an alias. */
+const DECLARING_KINDS: ReadonlySet<string> = new Set([
+  'class', 'struct', 'union', 'enum', 'interface', 'namespace', 'module',
+]);
+const CLASS_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'union']);
+
+/** How many aliases one name is followed through (`A` → `B` → `C`). */
+const MAX_HOPS = 4;
+/** How many base classes deep a member is looked for. */
+const MAX_BASE_DEPTH = 4;
+/** How far past a class's first line its base clause may run. */
+const HEAD_LINES = 12;
+
+/**
+ * What a type named through an alias resolved to: the aliased type as written
+ * in `scope` (`['SkipList']`), then the rest of the name that followed the
+ * alias (`['Iterator']` for `Table::Iterator`).
+ */
+export interface CppAliasedType {
+  target: string[];
+  rest: string[];
+  /** The qualified scope `target` is written in (`''` for the global scope). */
+  scope: string;
+  /** An alias on the way named a pointer (`using Field = const FieldDescriptor*;`). */
+  pointer: boolean;
+  /**
+   * The type is a class template of the project (or a class nested in one),
+   * whose specializations can declare members the primary template doesn't.
+   */
+  classTemplate: boolean;
+}
+
+/** A written type's `::` segments, each with whether template arguments followed it. */
+interface TypeName {
+  names: string[];
+  templated: boolean[];
+}
+
+/** `SkipList<const char*, Cmp<int>>::Iterator` → `SkipList::Iterator`. */
+export function stripCppTemplateArguments(text: string): string {
+  let out = '';
+  let depth = 0;
+  for (const c of text) {
+    if (c === '<') depth++;
+    else if (c === '>') depth = Math.max(0, depth - 1);
+    else if (depth === 0) out += c;
+  }
+  return out;
+}
+
+/** The `::` segments of a written type, or null when it is not a plain (possibly qualified) type name. */
+function cppTypeName(raw: string): TypeName | null {
+  const parts: string[] = [];
+  const templated: boolean[] = [];
+  let depth = 0;
+  let part = '';
+  let args = false;
+  const text = raw.replace(/\b(?:const|volatile|mutable|typename|template|class|struct|union|enum)\b/g, ' ').replace(/[&*]+/g, ' ');
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]!;
+    if (c === '<') {
+      depth++;
+      args = true;
+    } else if (c === '>') depth = Math.max(0, depth - 1);
+    else if (depth > 0) continue;
+    else if (c === ':' && text[i + 1] === ':') {
+      parts.push(part.trim());
+      templated.push(args);
+      part = '';
+      args = false;
+      i++;
+    } else part += c;
+  }
+  parts.push(part.trim());
+  templated.push(args);
+  if (parts[0] === '') {
+    // A leading `::` names the global scope.
+    parts.shift();
+    templated.shift();
+  }
+  if (parts.length === 0 || !parts.every((p) => /^[A-Za-z_]\w*$/.test(p))) return null;
+  return { names: parts, templated };
+}
+
+/** Is a written type a pointer (`Table*`, `const Foo* const`), not counting its template arguments? */
+export function isCppPointerType(raw: string): boolean {
+  return stripCppTemplateArguments(raw).includes('*');
+}
+
+/**
+ * The `::` segments of a written type: `const ns::Foo<T>&` → `['ns', 'Foo']`.
+ * Null when what is written is not a plain (possibly qualified) type name —
+ * `unsigned int`, `decltype(…)`, a function type.
+ */
+export function cppTypeSegments(raw: string): string[] | null {
+  return cppTypeName(raw)?.names ?? null;
+}
+
+/** C and C++ declare the names a C++ file can see (a header may be either). */
+function isCFamily(n: Node): boolean {
+  return n.language === 'cpp' || n.language === 'c';
+}
+
+/** Scopes visible from inside the scope `qualified`, innermost first, ending with the global scope. */
+function scopesWithin(qualified: string): string[] {
+  const parts = qualified ? qualified.split('::') : [];
+  const scopes: string[] = [];
+  for (let i = parts.length; i >= 0; i--) scopes.push(parts.slice(0, i).join('::'));
+  return scopes;
+}
+
+/** The scope a declaration sits in: `leveldb::MemTable` for `leveldb::MemTable::Table`. */
+function parentScope(qualified: string): string {
+  const cut = qualified.lastIndexOf('::');
+  return cut < 0 ? '' : qualified.slice(0, cut);
+}
+
+/** The scope the code that makes `ref` is written in: its class for a method, itself for a class. */
+function callerScope(caller: Node | null | undefined): string {
+  if (!caller || caller.kind === 'file') return '';
+  return DECLARING_KINDS.has(caller.kind) ? caller.qualifiedName : parentScope(caller.qualifiedName);
+}
+
+function linesOf(filePath: string, context: ResolutionContext): string[] | null {
+  return context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? null;
+}
+
+const escapeRegExp = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/** The text of `node`'s declaration, cut to its columns when they fit the lines. */
+function declarationText(node: Node, context: ResolutionContext): string | null {
+  const lines = linesOf(node.filePath, context);
+  if (!lines) return null;
+  const span = lines.slice(node.startLine - 1, node.endLine ?? node.startLine);
+  if (span.length === 0) return null;
+  const whole = span.join('\n');
+  if (span.length === 1) {
+    span[0] = span[0]!.slice(node.startColumn, node.endColumn);
+  } else {
+    span[0] = span[0]!.slice(node.startColumn);
+    span[span.length - 1] = span[span.length - 1]!.slice(0, node.endColumn);
+  }
+  const cut = span.join('\n');
+  return /\b(?:typedef|using)\b/.test(cut) ? cut : whole;
+}
+
+/** Split `text` on commas outside `<>`, `()`, `[]` and `{}`. */
+function splitTopLevel(text: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]!;
+    if ('<([{'.includes(c)) depth++;
+    else if ('>)]}'.includes(c)) depth = Math.max(0, depth - 1);
+    else if (c === ',' && depth === 0) {
+      parts.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+
+/**
+ * What an alias of `name` declares in `text`, as written: `SkipList<const
+ * char*, KeyComparator>` for `typedef SkipList<const char*, KeyComparator>
+ * Table;` and for `using Table = SkipList<const char*, KeyComparator>;`.
+ * Null when `text` declares no alias of that name.
+ */
+function aliasedTypeIn(text: string, name: string): string | null {
+  const escaped = escapeRegExp(name);
+  const using = new RegExp(String.raw`\busing\s+${escaped}\s*(?:\[\[[^\]]*\]\]\s*)?=\s*([^;]+)`).exec(text);
+  if (using) return using[1]!.trim();
+  const typedef = /\btypedef\b([^;]+)/.exec(text);
+  if (!typedef) return null;
+  // `typedef Foo* FooPtr, FooObj;` indexes its first declarator; the type is
+  // what precedes that declarator's name.
+  const declared = new RegExp(String.raw`^([\s\S]*?)\b${escaped}\s*$`).exec(splitTopLevel(typedef[1]!)[0]!);
+  return declared?.[1]?.trim() || null;
+}
+
+/** Is `alias` an alias template (`template <typename T> using Vec = std::vector<T>;`)? */
+function isAliasTemplate(alias: Node, context: ResolutionContext): boolean {
+  const lines = linesOf(alias.filePath, context);
+  if (!lines) return false;
+  const before = [
+    ...lines.slice(Math.max(0, alias.startLine - 4), alias.startLine - 1),
+    (lines[alias.startLine - 1] ?? '').slice(0, alias.startColumn),
+  ].join(' ');
+  return /\btemplate\s*<[^;{}]*>\s*$/.test(before);
+}
+
+const LOCAL_ALIAS_LINES = new WeakMap<ResolutionContext, Map<string, number[]>>();
+
+/** The lines of a function's body that declare an alias (`typedef …;`, `using X = …;`), last first. */
+function localAliasLines(caller: Node, lines: readonly string[], context: ResolutionContext): number[] {
+  let memo = LOCAL_ALIAS_LINES.get(context);
+  if (!memo) LOCAL_ALIAS_LINES.set(context, (memo = new Map()));
+  let found = memo.get(caller.id);
+  if (!found) {
+    found = [];
+    const last = Math.min(caller.endLine ?? caller.startLine, lines.length);
+    for (let i = last - 1; i >= caller.startLine - 1 && i >= 0; i--) {
+      if (/\b(?:typedef\b|using\s+\w+\s*=)/.test(lines[i]!)) found.push(i);
+    }
+    memo.set(caller.id, found);
+  }
+  return found;
+}
+
+/**
+ * The type an alias declared earlier in the calling function names, as
+ * written. Those aliases are not indexed, so the function's own lines are
+ * read, from the call back to the function's first line.
+ */
+function localAliasedType(name: string, caller: Node | null | undefined, ref: UnresolvedRef, context: ResolutionContext): string | null | undefined {
+  if (!caller || (caller.kind !== 'function' && caller.kind !== 'method') || caller.filePath !== ref.filePath) return undefined;
+  const lines = linesOf(ref.filePath, context);
+  if (!lines) return undefined;
+  const declares = new RegExp(String.raw`\b(?:using\s+${escapeRegExp(name)}\s*=|typedef\b[^;]*\b${escapeRegExp(name)}\s*[;,])`);
+  for (const i of localAliasLines(caller, lines, context)) {
+    if (i > ref.line - 1) continue;
+    const line = lines[i]!;
+    if (line.includes(name) && declares.test(line)) return aliasedTypeIn(line, name);
+  }
+  return undefined;
+}
+
+/** What a scope declares under a name. */
+type Declared =
+  | { alias: Node }
+  /** A class, struct or union, by its qualified name. */
+  | { cls: string }
+  /** An enum, namespace or other non-class type. */
+  | 'other'
+  /**
+   * Aliases naming different types, none of them the calling file's: rocksdb's
+   * `using DBWithTTLImplBase = …;` in each arm of an `#if USE_COROUTINES`.
+   */
+  | { ambiguous: Node[] }
+  | undefined;
+
+/** Which declarations a lookup can see; every one of them unless a caller narrows it. */
+type Visible = (n: Node) => boolean;
+
+/** C and C++ declarations named `name` that can stand for a type or scope. */
+function typeDeclarations(name: string, context: ResolutionContext, visible?: Visible): Node[] {
+  return context.getNodesByName(name).filter((n) =>
+    isCFamily(n) && (n.kind === 'type_alias' || DECLARING_KINDS.has(n.kind)) && (!visible || visible(n)));
+}
+
+function declaredIn(
+  scope: string,
+  name: string,
+  named: readonly Node[],
+  templated: boolean,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): Declared {
+  const qualified = scope ? `${scope}::${name}` : name;
+  let here = named.filter((n) => n.qualifiedName === qualified);
+  // An alias template is only ever named with template arguments.
+  if (!templated) here = here.filter((n) => n.kind !== 'type_alias' || !isAliasTemplate(n, context));
+  if (here.length === 0) return undefined;
+  // `typedef struct Node Node;` declares the struct as well.
+  if (here.some((n) => CLASS_KINDS.has(n.kind))) return { cls: qualified };
+  if (here.some((n) => n.kind !== 'type_alias')) return 'other';
+  const alias = pickAlias(here, ref, context);
+  return alias ? { alias } : { ambiguous: here };
+}
+
+/**
+ * One of several aliases a scope declares under one name (a translation unit
+ * sees one of them): the one in the calling file, then in its header, then
+ * any of them when they all name the same type.
+ */
+function pickAlias(aliases: Node[], ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  if (aliases.length === 1) return aliases[0]!;
+  const sameFile = aliases.filter((a) => a.filePath === ref.filePath);
+  if (sameFile.length === 1) return sameFile[0]!;
+  const stem = (p: string): string => p.replace(/\.[^./\\]+$/, '');
+  const header = aliases.filter((a) => stem(a.filePath) === stem(ref.filePath));
+  if (header.length === 1) return header[0]!;
+  const named = new Set(aliases.map((a) => {
+    const text = declarationText(a, context);
+    const type = text ? aliasedTypeIn(text, a.name) : null;
+    return type ? (cppTypeSegments(type)?.join('::') ?? type) : null;
+  }));
+  return named.size === 1 && !named.has(null) ? aliases[0]! : null;
+}
+
+const BASES = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const TEMPLATE_PARAMETERS = new WeakMap<ResolutionContext, Map<string, ReadonlySet<string>>>();
+
+/** Drop the memos of class bases, template parameters and local aliases (see ReferenceResolver.clearCaches). */
+export function clearCppTypeAliasMemos(context: ResolutionContext): void {
+  BASES.delete(context);
+  TEMPLATE_PARAMETERS.delete(context);
+  LOCAL_ALIAS_LINES.delete(context);
+}
+
+/** Add the parameter names of the `template <…>` header that ends right where a declaration starts. */
+function collectTemplateHeader(lines: readonly string[], startLine: number, startColumn: number, names: Set<string>): void {
+  const before = [...lines.slice(Math.max(0, startLine - 4), startLine - 1), (lines[startLine - 1] ?? '').slice(0, startColumn)].join('\n');
+  const at = before.lastIndexOf('template');
+  const header = at < 0 ? null : /^template\s*<([\s\S]*)>\s*$/.exec(before.slice(at));
+  if (!header) return;
+  for (const item of splitTopLevel(header[1]!)) {
+    // `typename T = int`, `template <typename> class Policy`, `typename... Ts`, `int N`.
+    const declared = stripCppTemplateArguments(item).split('=')[0]!;
+    const name = /([A-Za-z_]\w*)\s*$/.exec(declared)?.[1];
+    if (name && name !== 'typename' && name !== 'class') names.add(name);
+  }
+}
+
+/**
+ * The template parameters in scope where `node` is declared: its own
+ * `template <…>` header and those of the class templates around it.
+ */
+function templateParametersAround(node: Node, context: ResolutionContext): ReadonlySet<string> {
+  let memo = TEMPLATE_PARAMETERS.get(context);
+  if (!memo) TEMPLATE_PARAMETERS.set(context, (memo = new Map()));
+  const hit = memo.get(node.id);
+  if (hit) return hit;
+  const names = new Set<string>();
+  const lines = linesOf(node.filePath, context);
+  if (lines) {
+    collectTemplateHeader(lines, node.startLine, node.startColumn, names);
+    for (let scope = parentScope(node.qualifiedName); scope; scope = parentScope(scope)) {
+      for (const cls of context.getNodesByQualifiedName(scope)) {
+        if (!isCFamily(cls) || !CLASS_KINDS.has(cls.kind) || cls.filePath !== node.filePath) continue;
+        if (node.startLine < cls.startLine || node.startLine > (cls.endLine ?? cls.startLine)) continue;
+        collectTemplateHeader(lines, cls.startLine, cls.startColumn, names);
+      }
+    }
+  }
+  memo.set(node.id, names);
+  return names;
+}
+
+/**
+ * The qualified names of the classes `cls` derives from, read from the base
+ * clause of its own declaration (`struct ParseProto2Descriptor :
+ * Proto2Descriptor {`) and looked up from the scope the class is declared in.
+ */
+function baseClassesOf(cls: string, context: ResolutionContext): string[] {
+  let memo = BASES.get(context);
+  if (!memo) BASES.set(context, (memo = new Map()));
+  const hit = memo.get(cls);
+  if (hit) return hit;
+  memo.set(cls, []);
+  const bases: string[] = [];
+  for (const decl of context.getNodesByQualifiedName(cls)) {
+    if (!isCFamily(decl) || !CLASS_KINDS.has(decl.kind)) continue;
+    const lines = linesOf(decl.filePath, context);
+    if (!lines) continue;
+    const head = lines.slice(decl.startLine - 1, decl.startLine - 1 + HEAD_LINES);
+    if (head.length === 0) continue;
+    head[0] = head[0]!.slice(decl.startColumn);
+    const text = head.join('\n');
+    const brace = text.indexOf('{');
+    // A forward declaration (`class Foo;`) has no base clause of its own.
+    if (brace < 0 || text.slice(0, brace).includes(';')) continue;
+    const colon = text.slice(0, brace).search(/(?<!:):(?!:)/);
+    if (colon < 0) continue;
+    for (const part of splitTopLevel(text.slice(colon + 1, brace))) {
+      const name = cppTypeName(part.replace(/\b(?:public|protected|private|virtual)\b/g, ' '));
+      if (!name) continue;
+      const base = classNamed(name.names, scopesWithin(parentScope(cls)), context);
+      if (base && base !== cls && !bases.includes(base)) bases.push(base);
+    }
+  }
+  memo.set(cls, bases);
+  return bases;
+}
+
+/** The qualified name of the class `names` spells, looked up from `scopes`. */
+function classNamed(names: readonly string[], scopes: readonly string[], context: ResolutionContext): string | undefined {
+  const spelled = names.join('::');
+  for (const scope of scopes) {
+    const qualified = scope ? `${scope}::${spelled}` : spelled;
+    if (context.getNodesByQualifiedName(qualified).some((n) => isCFamily(n) && CLASS_KINDS.has(n.kind))) return qualified;
+  }
+  return undefined;
+}
+
+/** `name` declared in class `cls` or one of its bases. */
+function memberOf(
+  cls: string,
+  name: string,
+  named: readonly Node[],
+  templated: boolean,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  depth = 0,
+  seen: Set<string> = new Set(),
+): Declared {
+  const own = declaredIn(cls, name, named, templated, ref, context);
+  if (own !== undefined || depth >= MAX_BASE_DEPTH) return own;
+  seen.add(cls);
+  for (const base of baseClassesOf(cls, context)) {
+    if (seen.has(base)) continue;
+    const inherited = memberOf(base, name, named, templated, ref, context, depth + 1, seen);
+    if (inherited !== undefined) return inherited;
+  }
+  return undefined;
+}
+
+/** `name` looked up unqualified from `scopes`, innermost first; a class scope includes its bases. */
+function lookupUnqualified(
+  name: string,
+  templated: boolean,
+  scopes: readonly string[],
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  visible?: Visible,
+): Declared {
+  const named = typeDeclarations(name, context, visible);
+  if (named.length === 0) return undefined;
+  for (const scope of scopes) {
+    const found = scope ? memberOf(scope, name, named, templated, ref, context) : declaredIn('', name, named, templated, ref, context);
+    if (found !== undefined) return found;
+  }
+  return undefined;
+}
+
+/**
+ * The type a C++ declared type names once the aliases in it are followed,
+ * looked up from the code that makes `ref`.
+ *  - `undefined`: the type is not an alias; the caller keeps its own reading.
+ *  - `null`: an alias that names no particular class: a template
+ *    parameter's type (`using Type = GenericType;`, `typename
+ *    Traits::Field`), a `decltype(…)` or a function type, or a chain of
+ *    aliases too long to follow.
+ */
+export function resolveCppAliasedType(rawType: string, ref: UnresolvedRef, context: ResolutionContext): CppAliasedType | null | undefined {
+  const name = cppTypeName(rawType);
+  if (!name) return undefined;
+  const caller = context.getNodeById?.(ref.fromNodeId);
+  const scope = callerScope(caller);
+  const local = localAliasedType(name.names[0]!, caller, ref, context);
+  const resolved = local !== undefined
+    ? expand(local, name.names.slice(1), name.templated.slice(1), scope, ref, context, 1,
+      caller ? templateParametersAround(caller, context) : undefined)
+    : follow(name, scope, ref, context, 0);
+  // `Table* table` is a pointer whatever `Table` names.
+  return resolved && isCppPointerType(rawType) ? { ...resolved, pointer: true } : resolved;
+}
+
+/**
+ * The name receiver inference gives a type resolved through aliases: the
+ * aliased type's last segment (`SkipList`), as for any declared type, with
+ * the nested part of a name reached through the alias kept on it
+ * (`SkipList::Iterator`), since that owner is what names the nested type.
+ */
+export function cppAliasedTypeName(resolved: CppAliasedType): string {
+  return [resolved.target[resolved.target.length - 1]!, ...resolved.rest].join('::');
+}
+
+/** What a C++ type name names when it is looked up for a class (see cppClassNamed). */
+export type CppNamedClass =
+  /** A class, by its qualified name. */
+  | { cls: string }
+  /**
+   * An alias that leads to none of the project's classes: one of a type
+   * outside the project (`template <bool B> using bool_constant =
+   * std::integral_constant<bool, B>;`), of what a template argument decides,
+   * or one each `#if` arm declares differently (the first declaration).
+   */
+  | { alias: Node }
+  /** No particular class: an enum, a member of a type outside the project. */
+  | null
+  /** Nothing in the scopes looked in declares it. */
+  | undefined;
+
+/**
+ * The class a C++ type written as `written` names, looked up from `scopes`
+ * (innermost first) as a declared type is — a class scope with its bases, a
+ * qualified name a segment at a time — and followed through an alias it
+ * reaches: rocksdb's `InternalIterator` under `using InternalIterator =
+ * InternalIteratorBase<Slice>;` names `InternalIteratorBase`. `visible`
+ * narrows the declarations the lookup can see.
+ */
+export function cppClassNamed(
+  written: string,
+  scopes: readonly string[],
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  visible?: Visible,
+): CppNamedClass {
+  const name = cppTypeName(written);
+  if (!name) return null;
+  const { found, next } = lookupSegments(name, scopes, ref, context, visible);
+  if (found === undefined) return undefined;
+  if (typeof found !== 'object') return null;
+  if ('cls' in found) return found;
+  if ('ambiguous' in found) {
+    // An alias each `#if` arm declares differently: the first declaration.
+    const [first] = [...found.ambiguous].sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine);
+    return next === name.names.length ? { alias: first! } : null;
+  }
+  const alias = found.alias;
+  const text = declarationText(alias, context);
+  // The aliased type is written in the alias's own scope.
+  const aliased = expand(text ? aliasedTypeIn(text, alias.name) : null, name.names.slice(next), name.templated.slice(next),
+    parentScope(alias.qualifiedName), ref, context, 1, templateParametersAround(alias, context));
+  const cls = aliased && !aliased.pointer && classNamed([...aliased.target, ...aliased.rest], scopesWithin(aliased.scope), context);
+  if (cls) return { cls };
+  // A member of a type outside the project (`Alias::Inner`) is not the alias.
+  return next === name.names.length ? { alias } : null;
+}
+
+/** The scopes visible from inside the scope `qualified`, innermost first, ending with the global scope. */
+export function cppScopesWithin(qualified: string): string[] {
+  return scopesWithin(qualified);
+}
+
+/** The scope a C++ declaration is declared in: `leveldb::MemTable` for `leveldb::MemTable::Table`. */
+export function cppParentScope(qualified: string): string {
+  return parentScope(qualified);
+}
+
+/** The template parameters in scope where `node` is declared: its own `template <…>` header and its class templates'. */
+export function cppTemplateParameters(node: Node, context: ResolutionContext): ReadonlySet<string> {
+  return templateParametersAround(node, context);
+}
+
+/**
+ * What a written name declares, looked up from `scopes` (innermost first), and
+ * how many of its segments that took: a class's member is looked up in the
+ * class, and an alias ends the walk (`next` is where the rest of the name
+ * starts).
+ */
+function lookupSegments(
+  name: TypeName,
+  scopes: readonly string[],
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  visible?: Visible,
+): { found: Declared; next: number } {
+  let found = lookupUnqualified(name.names[0]!, name.templated[0]!, scopes, ref, context, visible);
+  let next = 1;
+  if (found === undefined && name.names.length > 1) {
+    // Namespaces are not indexed: `detail::buffer_t` from inside `fmt` is
+    // found by its spelling in an enclosing scope, longest prefix first.
+    for (let i = name.names.length; i >= 2 && found === undefined; i--) {
+      const spelled = name.names.slice(0, i);
+      const named = typeDeclarations(spelled[spelled.length - 1]!, context, visible);
+      for (const s of scopes) {
+        found = declaredIn(s ? `${s}::${spelled.slice(0, -1).join('::')}` : spelled.slice(0, -1).join('::'),
+          spelled[spelled.length - 1]!, named, name.templated[i - 1]!, ref, context);
+        if (found !== undefined) break;
+      }
+      next = i;
+    }
+  }
+  // `MemTable::Table`, `Table::Iterator`: one segment at a time.
+  while (found && typeof found === 'object' && 'cls' in found && next < name.names.length) {
+    found = memberOf(found.cls, name.names[next]!, typeDeclarations(name.names[next]!, context, visible), name.templated[next]!, ref, context);
+    next++;
+  }
+  return { found, next };
+}
+
+function follow(
+  name: TypeName,
+  scope: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  hops: number,
+): CppAliasedType | null | undefined {
+  const { found, next } = lookupSegments(name, scopesWithin(scope), ref, context);
+  if (!found || typeof found !== 'object' || !('alias' in found)) return undefined;
+  const alias = found.alias;
+  if (hops >= MAX_HOPS) return null;
+  const text = declarationText(alias, context);
+  // The aliased type is written in the alias's own scope.
+  return expand(text ? aliasedTypeIn(text, alias.name) : null, name.names.slice(next), name.templated.slice(next),
+    parentScope(alias.qualifiedName), ref, context, hops + 1, templateParametersAround(alias, context));
+}
+
+/**
+ * Continue from the type an alias names, as written (`rest` followed the
+ * alias in the name; `parameters` are the template parameters where it is
+ * written).
+ */
+function expand(
+  written: string | null,
+  rest: readonly string[],
+  restTemplated: readonly boolean[],
+  scope: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  hops: number,
+  parameters?: ReadonlySet<string>,
+): CppAliasedType | null {
+  // `typename Traits::Field`, `PolicyTemplate<const T>` inside the template
+  // that declares `PolicyTemplate`: whatever a template argument makes it.
+  if (!written || /\btypename\b/.test(written)) return null;
+  const target = cppTypeName(written);
+  if (!target || parameters?.has(target.names[0]!)) return null;
+  const pointer = isCppPointerType(written);
+  const names = [...target.names, ...rest];
+  const further = follow({ names, templated: [...target.templated, ...restTemplated] }, scope, ref, context, hops);
+  if (further === null) return null;
+  if (further) return { ...further, pointer: further.pointer || pointer };
+  const cls = classNamed(names, scopesWithin(scope), context);
+  const classTemplate = !!cls && context.getNodesByQualifiedName(cls)
+    .some((n) => isCFamily(n) && CLASS_KINDS.has(n.kind) && templateParametersAround(n, context).size > 0);
+  return { target: target.names, rest: [...rest], scope, pointer, classTemplate };
+}
diff --git a/src/resolution/dart-libraries.ts b/src/resolution/dart-libraries.ts
new file mode 100644
index 0000000000..2301899864
--- /dev/null
+++ b/src/resolution/dart-libraries.ts
@@ -0,0 +1,796 @@
+/**
+ * Which files' top-level declarations a Dart file can name without a prefix.
+ *
+ * A Dart library is a file and its `part`s. Its top-level scope holds its own
+ * declarations, private `_` names included, and every name exported by a
+ * library it imports without a prefix: that library's own public declarations
+ * and, through its `export`s, other libraries'. Every import and export is
+ * narrowed by its `show` / `hide` combinators. A conditional import (`import
+ * 'stub.dart' if (dart.library.io) 'io.dart'`) brings in every alternative.
+ * `dart:` libraries and packages outside the repository (flutter, test,
+ * mockito, …) export nothing of the project.
+ *
+ * `package:<name>/<path>` is `<root>/lib/<path>` of the package whose
+ * pubspec.yaml says `name: <name>`: the nearest pubspec.yaml above an indexed
+ * .dart file, never above the project root. When packages share a name
+ * (example apps), the importing file's own package wins, then the one
+ * enclosing it, then the one its package depends on by `path:`, else all of
+ * them count. An `import`, `export` or `part` edge links the one file its URI
+ * names (`dartDirectiveFile`).
+ *
+ * Directives are read from the head of each file at resolution time, not from
+ * what extraction recorded of them. Where the library cannot be
+ * established — a `part of` naming no library this can find, a file it cannot
+ * read, a file in no package — every file counts as visible, so the rule only
+ * narrows where the library is known.
+ */
+import * as path from 'path';
+import type { ResolutionContext } from './types';
+
+/** The names an import's or export's `show` / `hide` combinators let through; `show` null lets every name through. */
+export interface NameFilter {
+  readonly show: ReadonlySet<string> | null;
+  readonly hide: ReadonlySet<string> | null;
+  /** Identifies equal filters, so a namespace keeps each once. */
+  readonly key: string;
+}
+
+const EVERY_NAME: NameFilter = { show: null, hide: null, key: '*|' };
+
+function makeFilter(show: ReadonlySet<string> | null, hide: ReadonlySet<string> | null): NameFilter {
+  const hidden = hide && hide.size > 0 ? hide : null;
+  if (show === null && hidden === null) return EVERY_NAME;
+  return { show, hide: hidden, key: `${show ? [...show].sort().join(',') : '*'}|${hidden ? [...hidden].sort().join(',') : ''}` };
+}
+
+/** `a`, then `b`: a name gets through when both let it. */
+function composeFilters(a: NameFilter, b: NameFilter): NameFilter {
+  if (a === EVERY_NAME) return b;
+  if (b === EVERY_NAME) return a;
+  const show = a.show && b.show ? new Set([...a.show].filter((n) => b.show!.has(n))) : (a.show ?? b.show);
+  const hide = a.hide && b.hide ? new Set([...a.hide, ...b.hide]) : (a.hide ?? b.hide);
+  return makeFilter(show, hide);
+}
+
+function lets(filter: NameFilter, name: string): boolean {
+  return (filter.show === null || filter.show.has(name)) && (filter.hide === null || !filter.hide.has(name));
+}
+
+/** An `import` or `export` directive. */
+export interface DartNamespaceDirective {
+  /** The URI, then each conditional alternative (`if (dart.library.io) 'io.dart'`). */
+  uris: string[];
+  /** The prefix of `import '…' as p`, or null. */
+  prefix: string | null;
+  filter: NameFilter;
+}
+
+/** The directives at the head of a Dart file. */
+export interface DartDirectives {
+  /** `library a.b;` gives `a.b`, `library;` gives '', no directive null. */
+  libraryName: string | null;
+  partOf: { uri: string } | { name: string } | null;
+  parts: string[];
+  imports: DartNamespaceDirective[];
+  exports: DartNamespaceDirective[];
+}
+
+const DIRECTIVE_KEYWORDS: ReadonlySet<string> = new Set(['library', 'import', 'export', 'part']);
+const IDENTIFIER = /[A-Za-z_$][\w$]*/y;
+
+/** The index past the whitespace and comments at `i` (Dart block comments nest). */
+function skipTrivia(src: string, i: number): number {
+  const n = src.length;
+  while (i < n) {
+    const c = src.charCodeAt(i);
+    if (c === 32 || (c >= 9 && c <= 13) || c === 0xfeff) {
+      i++;
+    } else if (c === 47 && src.charCodeAt(i + 1) === 47) {
+      const newline = src.indexOf('\n', i + 2);
+      i = newline < 0 ? n : newline + 1;
+    } else if (c === 47 && src.charCodeAt(i + 1) === 42) {
+      let depth = 1;
+      i += 2;
+      while (i < n && depth > 0) {
+        if (src.charCodeAt(i) === 47 && src.charCodeAt(i + 1) === 42) {
+          depth++;
+          i += 2;
+        } else if (src.charCodeAt(i) === 42 && src.charCodeAt(i + 1) === 47) {
+          depth--;
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+    } else {
+      break;
+    }
+  }
+  return i;
+}
+
+/** The string literal at `i` — `'…'`, `"…"`, triple-quoted or raw — as its value and the index past it, or null. */
+function readString(src: string, i: number): { value: string; end: number } | null {
+  let raw = false;
+  if (src[i] === 'r' && (src[i + 1] === "'" || src[i + 1] === '"')) {
+    raw = true;
+    i++;
+  }
+  const quote = src[i];
+  if (quote !== "'" && quote !== '"') return null;
+  const close = src.startsWith(quote.repeat(3), i) ? quote.repeat(3) : quote;
+  let j = i + close.length;
+  let value = '';
+  while (j < src.length) {
+    if (src.startsWith(close, j)) return { value, end: j + close.length };
+    const c = src[j]!;
+    if (c === '\n' && close.length === 1) return null;
+    if (c === '\\' && !raw) {
+      value += src[j + 1] ?? '';
+      j += 2;
+    } else if (c === '$' && !raw && src[j + 1] === '{') {
+      let depth = 1;
+      j += 2;
+      while (j < src.length && depth > 0) {
+        const inner = readString(src, j);
+        if (inner) {
+          j = inner.end;
+          continue;
+        }
+        if (src[j] === '{') depth++;
+        else if (src[j] === '}') depth--;
+        j++;
+      }
+    } else {
+      value += c;
+      j++;
+    }
+  }
+  return null;
+}
+
+/** The index past the balanced `open` … `close` group at `i`, strings and comments skipped; -1 if it never closes. */
+function skipGroup(src: string, i: number, open: string, close: string): number {
+  let depth = 0;
+  while (i < src.length) {
+    i = skipTrivia(src, i);
+    const literal = readString(src, i);
+    if (literal) {
+      i = literal.end;
+      continue;
+    }
+    const c = src[i];
+    if (c === open) depth++;
+    else if (c === close && --depth === 0) return i + 1;
+    i++;
+  }
+  return -1;
+}
+
+/** The index past the metadata annotation at `i` (`@TestOn('vm')`, `@Tags(['slow'])`, `@JS()`). */
+function skipAnnotation(src: string, i: number): number {
+  i++;
+  for (;;) {
+    i = skipTrivia(src, i);
+    IDENTIFIER.lastIndex = i;
+    const name = IDENTIFIER.exec(src);
+    if (!name) return i;
+    i += name[0].length;
+    const next = skipTrivia(src, i);
+    if (src[next] !== '.') break;
+    i = next + 1;
+  }
+  i = skipTrivia(src, i);
+  if (src[i] === '<') {
+    const end = skipGroup(src, i, '<', '>');
+    if (end < 0) return src.length;
+    i = skipTrivia(src, end);
+  }
+  if (src[i] === '(') {
+    const end = skipGroup(src, i, '(', ')');
+    return end < 0 ? src.length : end;
+  }
+  return i;
+}
+
+type DirectiveToken =
+  | { kind: 'string'; value: string }
+  | { kind: 'word'; value: string }
+  | { kind: 'condition' }
+  | { kind: 'punctuation'; value: string };
+
+/**
+ * The tokens of a directive, from just past its keyword to its `;`, and the
+ * index past that `;` — or null when a body (`{`, `=>`) comes first, as in a
+ * function named `part`, or the file ends.
+ */
+function readDirectiveTokens(src: string, i: number): { tokens: DirectiveToken[]; end: number } | null {
+  const tokens: DirectiveToken[] = [];
+  for (;;) {
+    i = skipTrivia(src, i);
+    if (i >= src.length || tokens.length > 2000) return null;
+    const c = src[i]!;
+    if (c === ';') return { tokens, end: i + 1 };
+    if (c === '{' || c === '}' || (c === '=' && src[i + 1] === '>')) return null;
+    const literal = readString(src, i);
+    if (literal) {
+      tokens.push({ kind: 'string', value: literal.value });
+      i = literal.end;
+      continue;
+    }
+    if (c === '(') {
+      // A configuration condition: `(dart.library.io)`, `(dart.library.js_interop == 'true')`.
+      i = skipGroup(src, i, '(', ')');
+      if (i < 0) return null;
+      tokens.push({ kind: 'condition' });
+      continue;
+    }
+    IDENTIFIER.lastIndex = i;
+    const word = IDENTIFIER.exec(src);
+    if (word) {
+      tokens.push({ kind: 'word', value: word[0] });
+      i += word[0].length;
+      continue;
+    }
+    tokens.push({ kind: 'punctuation', value: c });
+    i++;
+  }
+}
+
+/** A dotted library name (`app.named`), as the words and dots it is written with. */
+function dottedName(tokens: readonly DirectiveToken[]): string | null {
+  let name = '';
+  for (const t of tokens) {
+    if (t.kind === 'word' || (t.kind === 'punctuation' && t.value === '.')) name += t.value;
+    else return null;
+  }
+  return name;
+}
+
+/** Record the directive `keyword` with `tokens` in `out`; false when the tokens are no such directive. */
+function addDirective(out: DartDirectives, keyword: string, tokens: DirectiveToken[]): boolean {
+  const first = tokens[0];
+  if (keyword === 'library') {
+    const name = dottedName(tokens);
+    if (name === null) return false;
+    out.libraryName = name;
+    return true;
+  }
+  if (keyword === 'part') {
+    if (first?.kind === 'word' && first.value === 'of') {
+      const target = tokens[1];
+      const name = target?.kind === 'string' ? null : dottedName(tokens.slice(1));
+      if (target?.kind === 'string') out.partOf = { uri: target.value };
+      else if (name) out.partOf = { name };
+      else return false;
+      return true;
+    }
+    if (first?.kind !== 'string') return false;
+    out.parts.push(first.value);
+    return true;
+  }
+  if (first?.kind !== 'string') return false;
+  const uris = [first.value];
+  let prefix: string | null = null;
+  let filter = EVERY_NAME;
+  let k = 1;
+  // Adjacent literals are one string: `'package:a/' 'b.dart'`.
+  for (let t = tokens[k]; t?.kind === 'string'; t = tokens[++k]) uris[0] += t.value;
+  while (k < tokens.length) {
+    const t = tokens[k]!;
+    const next = tokens[k + 1];
+    const uri = tokens[k + 2];
+    if (t.kind === 'word' && t.value === 'if' && next?.kind === 'condition' && uri?.kind === 'string') {
+      uris.push(uri.value);
+      k += 3;
+    } else if (t.kind === 'word' && t.value === 'as' && next?.kind === 'word') {
+      prefix = next.value;
+      k += 2;
+    } else if (t.kind === 'word' && (t.value === 'show' || t.value === 'hide')) {
+      const names = new Set<string>();
+      k++;
+      while (tokens[k]?.kind === 'word') {
+        names.add((tokens[k] as { value: string }).value);
+        const comma = tokens[k + 1];
+        if (comma?.kind !== 'punctuation' || comma.value !== ',') {
+          k++;
+          break;
+        }
+        k += 2;
+      }
+      filter = composeFilters(filter, t.value === 'show' ? makeFilter(names, null) : makeFilter(null, names));
+    } else {
+      // `deferred`, and anything this does not model.
+      k++;
+    }
+  }
+  (keyword === 'import' ? out.imports : out.exports).push({ uris, prefix, filter });
+  return true;
+}
+
+/**
+ * The `library`, `part`, `part of`, `import` and `export` directives at the
+ * head of a Dart source file — past its script tag, comments and metadata,
+ * up to its first declaration.
+ */
+export function readDartDirectives(source: string): DartDirectives {
+  const out: DartDirectives = { libraryName: null, partOf: null, parts: [], imports: [], exports: [] };
+  let i = source.charCodeAt(0) === 0xfeff ? 1 : 0;
+  if (source.startsWith('#!', i)) {
+    const newline = source.indexOf('\n', i);
+    i = newline < 0 ? source.length : newline + 1;
+  }
+  for (;;) {
+    i = skipTrivia(source, i);
+    if (i >= source.length) break;
+    if (source[i] === '@') {
+      i = skipAnnotation(source, i);
+      continue;
+    }
+    IDENTIFIER.lastIndex = i;
+    const keyword = IDENTIFIER.exec(source)?.[0];
+    if (keyword === undefined || !DIRECTIVE_KEYWORDS.has(keyword)) break;
+    const directive = readDirectiveTokens(source, i + keyword.length);
+    if (!directive || !addDirective(out, keyword, directive.tokens)) break;
+    i = directive.end;
+  }
+  return out;
+}
+
+/** A pub package of the project: its pubspec.yaml's `name`, and the directory holding it ('' for the project root). */
+interface PubPackage {
+  name: string;
+  root: string;
+}
+
+/** What a file's imports and its library's own files make visible. */
+interface FileScope {
+  /** The library's files: the library, its parts, and the file itself. */
+  own: ReadonlySet<string>;
+  /** The files whose imports apply here: the file, and for a part each file up to its library. */
+  importers: readonly string[];
+  /** By import prefix ('' for none), the libraries those imports name, each with the import's filter (read on first use). */
+  imported: Map<string, Array<{ filter: NameFilter; library: string }>> | null;
+  /** By prefix and declaring file, the filters through which the imports bring in its names (read on first use). */
+  visible: Map<string, readonly NameFilter[]>;
+}
+
+interface Memo {
+  directives: Map<string, DartDirectives | null>;
+  packageOfDir: Map<string, PubPackage | null>;
+  packages: Map<string, PubPackage[]> | null;
+  /** By package root and dependency name, the directories its `path:` dependencies of that name point at. */
+  pathDependencies: Map<string, readonly string[]>;
+  libraryNames: Map<string, string[]> | null;
+  libraryOf: Map<string, string | null>;
+  /** A part's parent: the file its `part of` names. */
+  parentOf: Map<string, string>;
+  members: Map<string, ReadonlySet<string>>;
+  exports: Map<string, ReadonlyMap<string, readonly NameFilter[]>>;
+  scopes: Map<string, FileScope | null>;
+  prefixes: Map<string, ReadonlySet<string>>;
+}
+
+const memos = new WeakMap<ResolutionContext, Memo>();
+
+function memoFor(context: ResolutionContext): Memo {
+  let memo = memos.get(context);
+  if (!memo) {
+    memo = {
+      directives: new Map(),
+      packageOfDir: new Map(),
+      packages: null,
+      pathDependencies: new Map(),
+      libraryNames: null,
+      libraryOf: new Map(),
+      parentOf: new Map(),
+      members: new Map(),
+      exports: new Map(),
+      scopes: new Map(),
+      prefixes: new Map(),
+    };
+    memos.set(context, memo);
+  }
+  return memo;
+}
+
+/** Drop the memos (see ReferenceResolver.clearCaches). */
+export function clearDartLibraryMemos(context: ResolutionContext): void {
+  memos.delete(context);
+}
+
+function parentDir(file: string): string {
+  const cut = file.lastIndexOf('/');
+  return cut < 0 ? '' : file.slice(0, cut);
+}
+
+function directivesOf(file: string, context: ResolutionContext, memo: Memo): DartDirectives | null {
+  const hit = memo.directives.get(file);
+  if (hit !== undefined) return hit;
+  const source = context.readFile(file);
+  const directives = source === null ? null : readDartDirectives(source);
+  memo.directives.set(file, directives);
+  return directives;
+}
+
+const PUBSPEC_NAME = /^name[ \t]*:[ \t]*['"]?([A-Za-z_]\w*)/m;
+
+/** The package of the nearest pubspec.yaml at or above project-relative `dir`, never above the project root. */
+function packageOfDir(dir: string, context: ResolutionContext, memo: Memo): PubPackage | null {
+  const walked: string[] = [];
+  let found: PubPackage | null | undefined;
+  for (let d = dir; ; d = parentDir(d)) {
+    found = memo.packageOfDir.get(d);
+    if (found !== undefined) break;
+    walked.push(d);
+    const pubspec = d ? `${d}/pubspec.yaml` : 'pubspec.yaml';
+    const name = context.fileExists(pubspec) ? PUBSPEC_NAME.exec(context.readFile(pubspec) ?? '')?.[1] : undefined;
+    if (name) {
+      found = { name, root: d };
+      break;
+    }
+    if (d === '') {
+      found = null;
+      break;
+    }
+  }
+  for (const d of walked) memo.packageOfDir.set(d, found);
+  return found;
+}
+
+/** The project's packages named `name`: the packages that hold an indexed .dart file. */
+function packagesNamed(name: string, context: ResolutionContext, memo: Memo): readonly PubPackage[] {
+  if (!memo.packages) {
+    const byName = new Map<string, PubPackage[]>();
+    const seen = new Set<PubPackage>();
+    for (const file of context.getAllFiles()) {
+      if (!file.endsWith('.dart')) continue;
+      const pkg = packageOfDir(parentDir(file), context, memo);
+      if (!pkg || seen.has(pkg)) continue;
+      seen.add(pkg);
+      const list = byName.get(pkg.name);
+      if (list) list.push(pkg);
+      else byName.set(pkg.name, [pkg]);
+    }
+    memo.packages = byName;
+  }
+  return memo.packages.get(name) ?? [];
+}
+
+/**
+ * The `path:` a pubspec gives its dependency `name`, written as a block
+ * (`name:`, then `path: x` below it) or a flow mapping (`name: {path: x}`).
+ * A git dependency's `path:` (inside its `git:` mapping) is a path in that
+ * repository, so only `path:` directly under the name counts.
+ */
+function yamlPathDependencies(text: string, name: string): string[] {
+  const out: string[] = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const key = /^([ \t]+)(['"]?)([A-Za-z_]\w*)\2[ \t]*:(?:[ \t]+(.*))?$/.exec(lines[i]!);
+    if (!key || key[3] !== name) continue;
+    const value = (key[4] ?? '').replace(/(?:^|[ \t])#.*$/, '').trim();
+    if (value !== '') {
+      const flow = /^\{[^{}]*\}$/.test(value)
+        ? /[{,][ \t]*path[ \t]*:[ \t]*(?:"([^"]*)"|'([^']*)'|([^,}\s]+))/.exec(value)
+        : null;
+      if (flow) out.push(flow[1] ?? flow[2] ?? flow[3]!);
+      continue;
+    }
+    let childIndent = -1;
+    for (let j = i + 1; j < lines.length; j++) {
+      const line = lines[j]!;
+      if (/^[ \t]*(?:#.*)?$/.test(line)) continue;
+      const indent = /^[ \t]*/.exec(line)![0].length;
+      if (indent <= key[1]!.length) break;
+      if (childIndent < 0) childIndent = indent;
+      const dep = indent === childIndent ? /^[ \t]*path[ \t]*:[ \t]*(?:"([^"]*)"|'([^']*)'|([^\s#]+))/.exec(line) : null;
+      if (dep) out.push(dep[1] ?? dep[2] ?? dep[3]!);
+    }
+  }
+  return out;
+}
+
+/** The project directories `pkg`'s pubspec_overrides.yaml and pubspec.yaml give as the `path:` of its dependency `name`. */
+function pathDependencies(pkg: PubPackage, name: string, context: ResolutionContext, memo: Memo): readonly string[] {
+  const key = `${pkg.root}\0${name}`;
+  const hit = memo.pathDependencies.get(key);
+  if (hit) return hit;
+  const dirs: string[] = [];
+  for (const file of ['pubspec_overrides.yaml', 'pubspec.yaml']) {
+    const pubspec = pkg.root ? `${pkg.root}/${file}` : file;
+    const text = context.fileExists(pubspec) ? context.readFile(pubspec) : null;
+    for (const written of text ? yamlPathDependencies(text, name) : []) {
+      const dep = written.replace(/\\/g, '/');
+      if (dep.startsWith('/') || /^[A-Za-z]:/.test(dep)) continue;
+      const dir = path.posix.normalize(path.posix.join(pkg.root || '.', dep)).replace(/\/+$/, '');
+      if (dir === '..' || dir.startsWith('../')) continue;
+      const root = dir === '.' ? '' : dir;
+      if (!dirs.includes(root)) dirs.push(root);
+    }
+  }
+  memo.pathDependencies.set(key, dirs);
+  return dirs;
+}
+
+/** The project files a URI written in `from` names: none for `dart:` and other schemes, or a package outside the project. */
+function resolveDartUri(from: string, uri: string, context: ResolutionContext, memo: Memo): string[] {
+  if (uri.startsWith('package:')) {
+    const slash = uri.indexOf('/');
+    if (slash < 0) return [];
+    const name = uri.slice('package:'.length, slash);
+    const rest = uri.slice(slash + 1);
+    let chosen = packagesNamed(name, context, memo);
+    if (chosen.length > 1) {
+      const own = packageOfDir(parentDir(from), context, memo);
+      const enclosing = chosen.filter((p) => p.root === '' || from.startsWith(`${p.root}/`));
+      if (own && own.name === name) chosen = [own];
+      else if (enclosing.length > 0) chosen = [enclosing.reduce((a, b) => (b.root.length > a.root.length ? b : a))];
+      else if (own) {
+        // Example apps that each keep a same-named package (bloc's two
+        // authentication_repository) name theirs as a path dependency.
+        const dirs = pathDependencies(own, name, context, memo);
+        const declared = chosen.filter((p) => dirs.includes(p.root));
+        if (declared.length === 1) chosen = declared;
+      }
+    }
+    return chosen.map((p) => path.posix.normalize(p.root ? `${p.root}/lib/${rest}` : `lib/${rest}`));
+  }
+  if (/^[A-Za-z][\w+.-]*:/.test(uri)) return [];
+  const joined = path.posix.normalize(path.posix.join(parentDir(from) || '.', uri));
+  return joined === '..' || joined.startsWith('../') || joined.startsWith('/') ? [] : [joined];
+}
+
+/**
+ * The project file a Dart `import`, `export` or `part` in `from` names by
+ * `uri`, or null: a `dart:` library, a package from outside the project, a
+ * path out of it, or a package name the project repeats with nothing to say
+ * which.
+ */
+export function dartDirectiveFile(from: string, uri: string, context: ResolutionContext): string | null {
+  const files = resolveDartUri(from, uri, context, memoFor(context));
+  return files.length === 1 ? files[0]! : null;
+}
+
+/** The files declaring `library <name>;`. */
+function libraryFilesNamed(name: string, context: ResolutionContext, memo: Memo): readonly string[] {
+  if (!memo.libraryNames) {
+    const byName = new Map<string, string[]>();
+    for (const file of context.getAllFiles()) {
+      if (!file.endsWith('.dart') || context.fileContains?.(file, 'library') === false) continue;
+      const declared = directivesOf(file, context, memo)?.libraryName;
+      if (!declared) continue;
+      const list = byName.get(declared);
+      if (list) list.push(file);
+      else byName.set(declared, [file]);
+    }
+    memo.libraryNames = byName;
+  }
+  return memo.libraryNames.get(name) ?? [];
+}
+
+/** The file a part's `part of` names, or null when it names none this can find. */
+function partParent(file: string, partOf: NonNullable<DartDirectives['partOf']>, context: ResolutionContext, memo: Memo): string | null {
+  const candidates = 'uri' in partOf
+    ? resolveDartUri(file, partOf.uri, context, memo).filter((f) => directivesOf(f, context, memo) !== null)
+    : libraryFilesNamed(partOf.name, context, memo);
+  if (candidates.length <= 1) return candidates[0] ?? null;
+  const listing = candidates.filter((c) =>
+    (directivesOf(c, context, memo)?.parts ?? []).some((uri) => resolveDartUri(c, uri, context, memo).includes(file)));
+  return listing.length === 1 ? listing[0]! : null;
+}
+
+/** The library file `file` belongs to: itself, or for a part the library its `part of` chain ends at; null when unknown. */
+function libraryOf(file: string, context: ResolutionContext, memo: Memo): string | null {
+  const hit = memo.libraryOf.get(file);
+  if (hit !== undefined) return hit;
+  // A part cycle ends at null.
+  memo.libraryOf.set(file, null);
+  const directives = directivesOf(file, context, memo);
+  let library: string | null = null;
+  if (directives && !directives.partOf) {
+    library = file;
+  } else if (directives?.partOf) {
+    const parent = partParent(file, directives.partOf, context, memo);
+    if (parent !== null) {
+      memo.parentOf.set(file, parent);
+      library = libraryOf(parent, context, memo);
+    }
+  }
+  memo.libraryOf.set(file, library);
+  return library;
+}
+
+/** A library's files: the library and its parts, theirs included. */
+function membersOf(library: string, context: ResolutionContext, memo: Memo): ReadonlySet<string> {
+  const hit = memo.members.get(library);
+  if (hit) return hit;
+  const files = new Set<string>([library]);
+  const queue = [library];
+  while (queue.length > 0 && files.size < 1000) {
+    const file = queue.shift()!;
+    for (const uri of directivesOf(file, context, memo)?.parts ?? []) {
+      for (const part of resolveDartUri(file, uri, context, memo)) {
+        if (files.has(part)) continue;
+        files.add(part);
+        queue.push(part);
+      }
+    }
+  }
+  memo.members.set(library, files);
+  return files;
+}
+
+function addFilter(namespace: Map<string, NameFilter[]>, file: string, filter: NameFilter): void {
+  const filters = namespace.get(file);
+  if (!filters) namespace.set(file, [filter]);
+  else if (filters[0] === EVERY_NAME) return;
+  else if (filter === EVERY_NAME) filters.splice(0, filters.length, EVERY_NAME);
+  else if (!filters.some((f) => f.key === filter.key)) filters.push(filter);
+}
+
+/**
+ * The files whose public names `library` exports, each with the filters on
+ * the way: its own files, and what its `export`s reach. `low` is the
+ * shallowest library still on `stack` that the walk came back to; a result
+ * that leans on one is incomplete until that library finishes, so it is kept
+ * only when the walk came back to nothing shallower than this library.
+ */
+function exportsOf(
+  library: string,
+  context: ResolutionContext,
+  memo: Memo,
+  stack: Map<string, number>,
+): { namespace: ReadonlyMap<string, readonly NameFilter[]>; low: number } {
+  const hit = memo.exports.get(library);
+  if (hit) return { namespace: hit, low: Infinity };
+  const depth = stack.size;
+  stack.set(library, depth);
+  const namespace = new Map<string, NameFilter[]>();
+  let low = Infinity;
+  const members = membersOf(library, context, memo);
+  for (const file of members) addFilter(namespace, file, EVERY_NAME);
+  for (const file of members) {
+    for (const directive of directivesOf(file, context, memo)?.exports ?? []) {
+      for (const uri of directive.uris) {
+        for (const target of resolveDartUri(file, uri, context, memo)) {
+          const exported = libraryOf(target, context, memo);
+          if (exported === null) continue;
+          const onStack = stack.get(exported);
+          if (onStack !== undefined) {
+            low = Math.min(low, onStack);
+            continue;
+          }
+          const inner = exportsOf(exported, context, memo, stack);
+          low = Math.min(low, inner.low);
+          for (const [f, filters] of inner.namespace) {
+            for (const filter of filters) addFilter(namespace, f, composeFilters(directive.filter, filter));
+          }
+        }
+      }
+    }
+  }
+  stack.delete(library);
+  if (low >= depth) memo.exports.set(library, namespace);
+  return { namespace, low };
+}
+
+/**
+ * What `file` can see, or null when that is unknown: its library cannot be
+ * found, or no pubspec.yaml above it says which package its `package:`
+ * imports start from (a mason brick's template, a project indexed below its
+ * package root).
+ */
+function scopeOf(file: string, context: ResolutionContext, memo: Memo): FileScope | null {
+  const hit = memo.scopes.get(file);
+  if (hit !== undefined) return hit;
+  const library = packageOfDir(parentDir(file), context, memo) === null ? null : libraryOf(file, context, memo);
+  let scope: FileScope | null = null;
+  if (library !== null) {
+    const own = new Set(membersOf(library, context, memo));
+    own.add(file);
+    const importers: string[] = [];
+    for (let f: string | undefined = file; f !== undefined && importers.length < 32; f = memo.parentOf.get(f)) {
+      importers.push(f);
+      if (f === library) break;
+    }
+    scope = { own, importers, imported: null, visible: new Map() };
+  }
+  memo.scopes.set(file, scope);
+  return scope;
+}
+
+/**
+ * The filters through which the imports written with `prefix` ('' for none)
+ * bring `declFile`'s names in — empty when they bring in none of them — or
+ * null when no import has that prefix.
+ */
+function importedFilters(scope: FileScope, prefix: string, declFile: string, context: ResolutionContext, memo: Memo): readonly NameFilter[] | null {
+  if (!scope.imported) {
+    scope.imported = new Map();
+    for (const importer of scope.importers) {
+      for (const directive of directivesOf(importer, context, memo)?.imports ?? []) {
+        const key = directive.prefix ?? '';
+        const libraries = scope.imported.get(key) ?? [];
+        scope.imported.set(key, libraries);
+        for (const uri of directive.uris) {
+          for (const target of resolveDartUri(importer, uri, context, memo)) {
+            const library = libraryOf(target, context, memo);
+            if (library !== null) libraries.push({ filter: directive.filter, library });
+          }
+        }
+      }
+    }
+  }
+  const libraries = scope.imported.get(prefix);
+  if (!libraries) return prefix === '' ? [] : null;
+  const key = `${prefix}\0${declFile}`;
+  const hit = scope.visible.get(key);
+  if (hit) return hit;
+  const through = new Map<string, NameFilter[]>();
+  for (const { filter, library } of libraries) {
+    for (const exported of exportsOf(library, context, memo, new Map()).namespace.get(declFile) ?? []) {
+      addFilter(through, declFile, composeFilters(filter, exported));
+    }
+  }
+  const filters = through.get(declFile) ?? [];
+  scope.visible.set(key, filters);
+  return filters;
+}
+
+/**
+ * Whether the library of `fromFile` can name `name`, declared at the top level
+ * of `declFile`, without a prefix: `declFile` is one of the library's own
+ * files, or a library it imports unprefixed exports the name. True when the
+ * library of `fromFile` cannot be established.
+ */
+export function dartLibrarySees(fromFile: string, declFile: string, name: string, context: ResolutionContext): boolean {
+  if (fromFile === declFile) return true;
+  const memo = memoFor(context);
+  const scope = scopeOf(fromFile, context, memo);
+  if (!scope || scope.own.has(declFile)) return true;
+  if (name.startsWith('_')) return false;
+  return (importedFilters(scope, '', declFile, context, memo) ?? []).some((f) => lets(f, name));
+}
+
+/**
+ * Whether `prefix.name` in `fromFile` can mean `name` declared at the top
+ * level of `declFile`: a library imported `as prefix` exports it. True when
+ * no import of the file's library has that prefix, or the library is unknown.
+ */
+export function dartPrefixSees(fromFile: string, prefix: string, declFile: string, name: string, context: ResolutionContext): boolean {
+  const memo = memoFor(context);
+  const scope = scopeOf(fromFile, context, memo);
+  if (!scope) return true;
+  const filters = importedFilters(scope, prefix, declFile, context, memo);
+  return filters === null || (!name.startsWith('_') && filters.some((f) => lets(f, name)));
+}
+
+/**
+ * The import prefixes written in `fromFile` can stand for — the `p` of
+ * `import '…' as p` and `deferred as p` — read from the imports of its
+ * library, which a part (`part of …`) takes from the file it is part of.
+ */
+export function dartImportPrefixes(fromFile: string, context: ResolutionContext): ReadonlySet<string> {
+  const memo = memoFor(context);
+  const hit = memo.prefixes.get(fromFile);
+  if (hit) return hit;
+  const prefixes = new Set<string>();
+  // Records each part's parent, a library in no package included.
+  libraryOf(fromFile, context, memo);
+  let file: string | undefined = fromFile;
+  for (let hops = 0; file !== undefined && hops < 32; file = memo.parentOf.get(file), hops++) {
+    for (const directive of directivesOf(file, context, memo)?.imports ?? []) {
+      if (directive.prefix !== null) prefixes.add(directive.prefix);
+    }
+  }
+  memo.prefixes.set(fromFile, prefixes);
+  return prefixes;
+}
+
+/** Whether `declFile` is a file of the library `fromFile` belongs to (false when that library is unknown). */
+export function inSameDartLibrary(fromFile: string, declFile: string, context: ResolutionContext): boolean {
+  if (fromFile === declFile) return true;
+  const scope = scopeOf(fromFile, context, memoFor(context));
+  return scope !== null && scope.own.has(declFile);
+}
diff --git a/src/resolution/dart-local-scope.ts b/src/resolution/dart-local-scope.ts
new file mode 100644
index 0000000000..f8d6d93d20
--- /dev/null
+++ b/src/resolution/dart-local-scope.ts
@@ -0,0 +1,676 @@
+/**
+ * A name a Dart function, closure or block around a call declares — a
+ * parameter, a local variable, a loop or `catch` variable, a pattern
+ * variable — is what a bare call of that name means there.
+ *
+ * riverpod's `overrideWith(CreatedT Function(Ref ref, ArgT arg) create)` calls
+ * its parameter, `create(ref, arg)`, and so do its tests' provider factories
+ * (`(create, {name, dependencies}) => …`). The index holds no node for any of
+ * those, so the name matcher handed 48 such calls to the one top-level
+ * `create` it knew: a docs example's `final create = Mutation<…>()` that none
+ * of the callers import. A parameter hides a member as well: a bloc event
+ * handler's `emit(…)` calls its `Emitter` parameter, never `Bloc.emit`. The
+ * same holds for a function passed by name. Read from the source of the
+ * call's file:
+ *
+ * - a parameter list that a body follows (`{ … }` or `=> …`), the body being
+ *   its scope: a function's, a method's, a closure's, a `catch` clause's, a
+ *   constructor's (its initializer list too);
+ * - the variables a `for` head declares, for the loop;
+ * - a local a block declares (`final x = …`, `Foo? x;`, `var (a, b) = …`, a
+ *   pattern's `final x`), from there to the block's end.
+ *
+ * Fields and top-level variables are not locals. The nearest binding around
+ * the call decides: a local function declared there is a node, and the call
+ * keeps the one it resolved to.
+ */
+import type { ResolutionContext, ResolvedRef, UnresolvedRef } from './types';
+
+/** Where a name is bound: offsets into the file's source, inclusive. */
+interface Scope {
+  start: number;
+  end: number;
+  /** A local function's name, which a call can reach. */
+  fn?: boolean;
+}
+
+interface DartFileScopes {
+  lineStarts: number[];
+  /** Name → the scopes it is bound in. */
+  names: Map<string, Scope[]>;
+}
+
+const memos = new WeakMap<ResolutionContext, Map<string, DartFileScopes | null>>();
+
+/** Drop the memos (see ReferenceResolver.clearCaches). */
+export function clearDartLocalScopeMemos(context: ResolutionContext): void {
+  memos.delete(context);
+}
+
+/**
+ * The resolved reference, or null when it is a receiver-less Dart call (or a
+ * function passed by name) whose name a parameter or local around it binds.
+ */
+export function gateDartLocal(resolved: ResolvedRef | null, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  if (!resolved || ref.language !== 'dart') return resolved;
+  if (ref.referenceKind !== 'calls' && ref.referenceKind !== 'function_ref') return resolved;
+  const name = ref.referenceName;
+  if (!/^[A-Za-z_$][\w$]*$/.test(name)) return resolved;
+  const file = fileScopes(ref.filePath, context);
+  const bound = file?.names.get(name);
+  if (!file || !bound) return resolved;
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split('\n');
+  const line = lines?.[ref.line - 1];
+  if (line === undefined) return resolved;
+  const column = nameColumn(line, name, ref.column);
+  // `this.create()`, `x.create()`, `..create()` — the dot maybe ending the
+  // line before: a member, whatever the locals are.
+  const before = line.slice(0, column);
+  if (column < 0 || /\.\s*$/.test(before) ||
+      (before.trim() === '' && /\.\s*$/.test((lines![ref.line - 2] ?? '').replace(/\/\/.*$/, '')))) return resolved;
+  const at = (file.lineStarts[ref.line - 1] ?? 0) + column;
+  // Scopes nest, so the binding that starts last is the nearest one.
+  let nearest: Scope | null = null;
+  for (const scope of bound) {
+    if (at >= scope.start && at <= scope.end && (!nearest || scope.start > nearest.start)) nearest = scope;
+  }
+  return !nearest || nearest.fn ? resolved : null;
+}
+
+/**
+ * Whether a parameter, local or local function `name` is bound at offset `at`
+ * of the file's source — where it hides a library name, an import prefix
+ * among them: `http.get(…)` with a parameter `http` calls the parameter's.
+ */
+export function isDartLocallyBound(filePath: string, name: string, at: number, context: ResolutionContext): boolean {
+  const bound = fileScopes(filePath, context)?.names.get(name);
+  return bound !== undefined && bound.some((scope) => at >= scope.start && at <= scope.end);
+}
+
+/**
+ * Where on its line a reference's name starts. A Dart ref's column sits just
+ * past the name (a function value's at it); a column counted in bytes misses
+ * on a line with non-ASCII text before it, so the nearest whole-word
+ * occurrence is taken then.
+ */
+function nameColumn(line: string, name: string, column: number): number {
+  const isWord = (at: number): boolean =>
+    line.startsWith(name, at) && !/[\w$]/.test(line[at - 1] ?? '') && !/[\w$]/.test(line[at + name.length] ?? '');
+  if (column >= 0 && isWord(column)) return column;
+  if (column >= name.length && isWord(column - name.length)) return column - name.length;
+  let best = -1;
+  for (let at = line.indexOf(name); at >= 0; at = line.indexOf(name, at + 1)) {
+    if (isWord(at) && (best < 0 || Math.abs(at - column) < Math.abs(best - column))) best = at;
+  }
+  return best;
+}
+
+function fileScopes(filePath: string, context: ResolutionContext): DartFileScopes | null {
+  let memo = memos.get(context);
+  if (!memo) {
+    memo = new Map();
+    memos.set(context, memo);
+  }
+  const hit = memo.get(filePath);
+  if (hit !== undefined) return hit;
+  const source = context.readFile(filePath);
+  const scopes = source === null ? null : readScopes(source);
+  memo.set(filePath, scopes);
+  return scopes;
+}
+
+/** Every parameter, loop variable and local a Dart file binds, with its scope. */
+function readScopes(source: string): DartFileScopes {
+  const lineStarts = [0];
+  for (let i = source.indexOf('\n'); i >= 0; i = source.indexOf('\n', i + 1)) lineStarts.push(i + 1);
+  const code = blankTypeArguments(blankDartLiterals(source));
+  const brackets = matchBrackets(code);
+  const names = new Map<string, Scope[]>();
+  const bind = (name: string, start: number, end: number, fn = false): void => {
+    if (name === '_' || DART_RESERVED.has(name)) return;
+    const scope: Scope = fn ? { start, end, fn } : { start, end };
+    const list = names.get(name);
+    if (list) list.push(scope);
+    else names.set(name, [scope]);
+  };
+  const parameterLists = bindParameters(code, brackets, bind);
+  bindLocals(code, brackets, parameterLists, bind);
+  return { lineStarts, names };
+}
+
+type Bind = (name: string, start: number, end: number, fn?: boolean) => void;
+
+/**
+ * Each parameter list a body follows, the body being where its names are
+ * bound — and a `for` head's variables, for the loop. A group a control-flow
+ * keyword heads (`if (create) {`) holds an expression, and a call's arguments
+ * (`: super(x) {`, `: _f = make(x) {` in an initializer list) bind nothing.
+ * A function declared in a block binds its own name there, to the block's end.
+ * Returns the offsets of the groups read as parameter lists.
+ */
+function bindParameters(code: string, b: Brackets, bind: Bind): Set<number> {
+  const lists = new Set<number>();
+  for (let k = 0; k < b.at.length; k++) {
+    const open = b.partner[k]!;
+    if (code[b.at[k]!] !== ')' || open < 0) continue;
+    const from = b.at[open]!;
+    const head = tokenBefore(code, from);
+    let i = skipSpace(code, b.at[k]! + 1);
+    const modifier = /^(?:async\s*\*?|sync\s*\*)/.exec(code.slice(i, i + 8));
+    if (modifier) i = skipSpace(code, i + modifier[0].length);
+    const list = code.slice(from + 1, b.at[k]!);
+    const block = code[i] === '{' && b.at[k + 1] === i && b.partner[k + 1]! >= 0 ? b.at[b.partner[k + 1]!]! : -1;
+    if (head.word === 'for') {
+      const end = block >= 0 ? block : endOfStatement(code, b, i, false);
+      for (const name of forHeadNames(list)) bind(name, from, end);
+      lists.add(from);
+      continue;
+    }
+    if (head.word !== null && CONTROL_HEADS.has(head.word)) continue;
+    let scope: Scope | null = null;
+    if (block >= 0) scope = { start: i, end: block };
+    else if (code.startsWith('=>', i)) scope = { start: i, end: endOfStatement(code, b, i + 2, true) };
+    else if (code[i] === ':' && isConstructorHead(code, head)) scope = { start: i, end: endOfConstructor(code, b, i + 1) };
+    if (!scope || isCallArguments(code, head)) continue;
+    lists.add(from);
+    for (const name of parameterNames(list)) bind(name, scope.start, scope.end);
+    // `int make() => 2;` in a block: a local function, a node of its own.
+    const around = head.word !== null && !DART_KEYWORDS.has(head.word) ? enclosingBlock(code, b, head.at) : -1;
+    if (around >= 0) bind(head.word!, head.at, blockEnd(code, b, around), true);
+  }
+  return lists;
+}
+
+/**
+ * Whether a group is a call's arguments rather than a declaration's
+ * parameters: a call in a constructor's initializer list (`: _value =
+ * compute(x) {`, `: super.named(x) {`, `: assert(x) {`).
+ */
+function isCallArguments(code: string, head: { word: string | null; at: number }): boolean {
+  if (head.word === null) return false;
+  if (head.word === 'super' || head.word === 'this' || head.word === 'assert') return true;
+  const before = tokenBefore(code, head.at);
+  if (before.word === null && /^[=:,]$/.test(code[before.at] ?? '')) return true;
+  // `super.named(x)` / `this.named(x)`, never a named constructor `Foo.named(x)`.
+  if (before.word === null && code[before.at] === '.') {
+    const owner = tokenBefore(code, before.at);
+    return owner.word === 'super' || owner.word === 'this';
+  }
+  return false;
+}
+
+/**
+ * Whether a group followed by `:` is a constructor's parameter list —
+ * `Foo(this.x) :`, `const Foo.named(int x) :` at the start of a member — and
+ * not a call in a conditional (`c ? f(x) : y`) or a `case Foo(x):`.
+ */
+function isConstructorHead(code: string, head: { word: string | null; at: number }): boolean {
+  if (head.word === null || DART_KEYWORDS.has(head.word)) return false;
+  let type = head.word;
+  let before = tokenBefore(code, head.at);
+  if (before.word === null && code[before.at] === '.') {
+    const owner = tokenBefore(code, before.at);
+    if (owner.word === null) return false;
+    type = owner.word;
+    before = tokenBefore(code, owner.at);
+  }
+  if (!/^_*[A-Z$]/.test(type)) return false;
+  if (before.word !== null) return before.word === 'const' || before.word === 'external';
+  return before.at < 0 || /^[;{}]$/.test(code[before.at] ?? '');
+}
+
+/**
+ * The end of a constructor's initializer list and body, from just past its
+ * `:` — the body being the first `{` that does not start a value (`: _m = {}`).
+ */
+function endOfConstructor(code: string, b: Brackets, from: number): number {
+  let k = firstBracketFrom(b, from);
+  let pos = from;
+  for (;;) {
+    const next = k < b.at.length ? b.at[k]! : code.length;
+    const semicolon = code.indexOf(';', pos);
+    if (semicolon >= 0 && semicolon < next) return semicolon;
+    if (k >= b.at.length) return code.length;
+    const ch = code[next];
+    if (ch === ')' || ch === ']' || ch === '}') return next;
+    const close = b.partner[k]!;
+    if (close < 0) return code.length;
+    if (ch === '{') {
+      const prior = tokenBefore(code, next);
+      if (prior.word !== null || /[)\]'"]/.test(code[prior.at] ?? '')) return b.at[close]!;
+    }
+    pos = b.at[close]! + 1;
+    k = close + 1;
+  }
+}
+
+/**
+ * The names a parameter list declares: `(Ref ref, {required this.create,
+ * int count = 0})`, `([String? label])`, old-style `void cb(int x)` (`cb`),
+ * untyped closure parameters `(create, {name})`, and a switch arm's pattern
+ * `Foo(:final value) =>`.
+ */
+function parameterNames(list: string): string[] {
+  const names: string[] = [];
+  for (const raw of splitParameters(list)) {
+    let item = raw.replace(/@[\w$.]+(?:\s*\([^()]*\))?/g, ' ');
+    const eq = item.indexOf('=');
+    if (eq >= 0) item = item.slice(0, eq);
+    item = item.trimEnd();
+    // `void cb(int x)`: the name is before its own parameter list.
+    if (item.endsWith(')')) {
+      let depth = 0;
+      let at = item.length - 1;
+      for (; at >= 0; at--) {
+        if (item[at] === ')') depth++;
+        else if (item[at] === '(' && --depth === 0) break;
+      }
+      item = item.slice(0, Math.max(0, at)).trimEnd();
+    }
+    const name = /([A-Za-z_$][\w$]*)$/.exec(item)?.[1];
+    if (name) names.push(name);
+  }
+  return names;
+}
+
+/** A parameter list's items, the optional group's (`{…}` / `[…]`, always last) included. */
+function splitParameters(list: string): string[] {
+  const items: string[] = [];
+  let depth = 0;
+  let item = '';
+  for (let i = 0; i < list.length; i++) {
+    const ch = list[i]!;
+    if (depth === 0 && (ch === '{' || ch === '[') && item.trim() === '') {
+      const close = list.lastIndexOf(ch === '{' ? '}' : ']');
+      items.push(...splitParameters(list.slice(i + 1, close > i ? close : list.length)));
+      return items;
+    }
+    if (ch === '(' || ch === '[' || ch === '{') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}') depth--;
+    if (ch === ',' && depth === 0) {
+      if (item.trim() !== '') items.push(item);
+      item = '';
+    } else {
+      item += ch;
+    }
+  }
+  if (item.trim() !== '') items.push(item);
+  return items;
+}
+
+/** The variables a `for` head declares: `final x in xs`, `var (a, b) in pairs`, `var i = 0, j = n; …`. */
+function forHeadNames(head: string): string[] {
+  const loop = /^([^;]*?)\bin\b/.exec(head);
+  if (loop) {
+    const decl = loop[1]!.trim();
+    const pattern = /^(?:final|var)\s*(?:[\w$.]+\s*)?([([{][\s\S]*)$/.exec(decl);
+    if (pattern) return patternBinders(pattern[1]!);
+    const declared = /^(?:(?:final|var|const)\s+(?:[\w$.]+\s*\??\s+)?|[\w$.]+\s*\??\s+)([A-Za-z_$][\w$]*)$/.exec(decl);
+    return declared ? [declared[1]!] : [];
+  }
+  const init = head.split(';')[0] ?? '';
+  if (!/^\s*(?:(?:final|var|const|late)\b|[\w$.]+\s*\??\s+[A-Za-z_$][\w$]*\s*=)/.test(init)) return [];
+  return [...init.matchAll(/(?:^|,|\s)([A-Za-z_$][\w$]*)\s*=(?![=>])/g)].map((m) => m[1]!);
+}
+
+/** The names a destructuring pattern binds: `(a, b)`, `[x, ...rest]`, `Point(:x, y: final py)`, `{'k': v}`. */
+function patternBinders(pattern: string): string[] {
+  const names: string[] = [];
+  for (const m of pattern.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)(?![\w$])(?!\s*[:(])(?!\s+[A-Za-z_$(])/g)) {
+    if (m[1] !== '_' && !DART_RESERVED.has(m[1]!)) names.push(m[1]!);
+  }
+  return names;
+}
+
+/**
+ * The locals a block declares, each bound from its declaration to the
+ * block's end: `final x = …`, `var x;`, `Foo<T>? x = …`, `void Function() x
+ * = …`, `final (a, b) = …`, and a pattern's `final x` / `var x` (`case
+ * Foo(:final x)`, `if (v case final x?)`). A declaration directly in a class
+ * body is a field, and one at the top of the file a library variable.
+ */
+function bindLocals(code: string, b: Brackets, parameterLists: Set<number>, bind: Bind): void {
+  // `direct`: a statement's own declaration, whose block is the bracket right
+  // around it; a pattern's variable is in the block around its `case` or `if`.
+  const bindInBlock = (name: string, at: number, direct: boolean): void => {
+    let k = innermostBracket(code, b, at);
+    while (!direct && k >= 0 && code[b.at[k]!] !== '{') {
+      // A parameter list's `final x` is the parameter, bound where the list is read.
+      if (parameterLists.has(b.at[k]!)) return;
+      k = b.parent[k]!;
+    }
+    if (k >= 0 && code[b.at[k]!] === '{' && !isTypeBody(code, b.at[k]!)) bind(name, at, blockEnd(code, b, k));
+  };
+  for (const m of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)(?=\s*(?:=(?![=>])|;))/g)) {
+    if (isDeclarationType(code, b, tokenBefore(code, m.index))) bindInBlock(m[1]!, m.index, true);
+  }
+  // A pattern variable: `case Foo(:final value)`, `if (x case final y?)` —
+  // not the type of `final Foo? x = …`.
+  for (const m of code.matchAll(/(?<![\w$.])(?:final|var)\s+(?:[\w$.]+\s*\??\s+)?([A-Za-z_$][\w$]*)(?=\s*(?:[)\]},:]|\?(?!\s*[\w$])|=>|\bwhen\b|&&|\|\|))/g)) {
+    bindInBlock(m[1]!, m.index, false);
+  }
+  // A destructuring declaration: `final (a, b) = …`, `var Point(:x, :y) = …`.
+  for (const m of code.matchAll(/(?<![\w$.])(?:final|var)\s*(?:[A-Z][\w$]*\s*)?([([{])/g)) {
+    const open = m.index + m[0].length - 1;
+    const k = bracketIndexAt(b, open);
+    if (k < 0 || b.partner[k]! < 0) continue;
+    const close = b.at[b.partner[k]!]!;
+    if (!/^\s*=(?![=>])/.test(code.slice(close + 1, close + 4))) continue;
+    for (const name of patternBinders(code.slice(open + 1, close))) bindInBlock(name, m.index, true);
+  }
+}
+
+/**
+ * Whether the token before a name followed by `=` / `;` makes it a
+ * declaration: `final` / `var` / `const`, a type (`Foo`, `Foo?`, `List<int>`
+ * — type arguments are blanked — or a function type ending `Function(…)`).
+ */
+function isDeclarationType(code: string, b: Brackets, before: { word: string | null; at: number }): boolean {
+  if (before.word !== null) return DECLARATION_KEYWORDS.has(before.word) || !DART_KEYWORDS.has(before.word);
+  const ch = code[before.at];
+  if (ch === '?') return /[\w$)]/.test(code[before.at - 1] ?? '');
+  if (ch === ')') {
+    const k = bracketIndexAt(b, before.at);
+    const open = k >= 0 ? b.partner[k]! : -1;
+    return open >= 0 && tokenBefore(code, b.at[open]!).word === 'Function';
+  }
+  return false;
+}
+
+/** Whether the `{` at `brace` opens a class, mixin, enum or extension body. */
+function isTypeBody(code: string, brace: number): boolean {
+  const from = Math.max(code.lastIndexOf(';', brace - 1), code.lastIndexOf('{', brace - 1), code.lastIndexOf('}', brace - 1));
+  return TYPE_BODY_HEAD.test(code.slice(from + 1, brace));
+}
+
+const TYPE_BODY_HEAD = /^\s*(?:@[\w$.]+(?:\s*\((?:[^()]|\([^()]*\))*\))?\s*)*(?:(?:abstract|base|final|sealed|interface|mixin|augment)\s+)*(?:class|mixin|enum|extension)\b/;
+
+/** The index of the `{` right around offset `at` when it holds statements (no class or extension body), or -1. */
+function enclosingBlock(code: string, b: Brackets, at: number): number {
+  const k = innermostBracket(code, b, at);
+  return k >= 0 && code[b.at[k]!] === '{' && !isTypeBody(code, b.at[k]!) ? k : -1;
+}
+
+/** Where the bracket at index `k` closes: the end of the file when it never does. */
+function blockEnd(code: string, b: Brackets, k: number): number {
+  return b.partner[k]! >= 0 ? b.at[b.partner[k]!]! : code.length;
+}
+
+/**
+ * Where the expression or statement starting at `from` ends: the first `;`
+ * (and, for an expression, `,`) outside the brackets it opens, or the close
+ * of the bracket around it — the end of a `=> …` body in an argument list,
+ * a switch arm or a declaration.
+ */
+function endOfStatement(code: string, b: Brackets, from: number, expression: boolean): number {
+  let k = firstBracketFrom(b, from);
+  let pos = from;
+  for (;;) {
+    const next = k < b.at.length ? b.at[k]! : code.length;
+    for (let i = pos; i < next; i++) {
+      if (code[i] === ';' || (expression && code[i] === ',')) return i;
+    }
+    if (k >= b.at.length) return code.length;
+    const ch = code[next];
+    if (ch === ')' || ch === ']' || ch === '}') return next;
+    const close = b.partner[k]!;
+    if (close < 0) return code.length;
+    pos = b.at[close]! + 1;
+    k = close + 1;
+  }
+}
+
+/** The word right before offset `at` (skipping blanks), or else the offset of the character there (-1 at the start). */
+function tokenBefore(code: string, at: number): { word: string | null; at: number } {
+  let i = at - 1;
+  while (i >= 0 && /\s/.test(code[i]!)) i--;
+  let start = i;
+  while (start >= 0 && /[\w$]/.test(code[start]!)) start--;
+  if (start === i) return { word: null, at: i };
+  return { word: code.slice(start + 1, i + 1), at: start + 1 };
+}
+
+function skipSpace(code: string, at: number): number {
+  while (at < code.length && /\s/.test(code[at]!)) at++;
+  return at;
+}
+
+/** Keywords that head a parenthesised expression, not a parameter list. */
+const CONTROL_HEADS: ReadonlySet<string> = new Set(['if', 'while', 'switch']);
+
+/** Keywords a declaration's name can follow. */
+const DECLARATION_KEYWORDS: ReadonlySet<string> = new Set(['final', 'var', 'const']);
+
+/** Dart's reserved words: never a name a declaration binds. */
+const DART_RESERVED: ReadonlySet<string> = new Set([
+  'assert', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default', 'do', 'else', 'enum', 'extends',
+  'false', 'final', 'finally', 'for', 'if', 'in', 'is', 'new', 'null', 'rethrow', 'return', 'super', 'switch',
+  'this', 'throw', 'true', 'try', 'var', 'void', 'while', 'with',
+]);
+
+/**
+ * The reserved words and the built-in and contextual ones that never name a
+ * declaration's type or a function there. Several are fine parameter names —
+ * json_generator's `R Function(DartType item) set` — so only DART_RESERVED
+ * keeps a name from binding.
+ */
+const DART_KEYWORDS: ReadonlySet<string> = new Set([
+  ...DART_RESERVED,
+  'abstract', 'as', 'async', 'await', 'base', 'covariant', 'deferred', 'export', 'extension', 'external', 'factory',
+  'get', 'hide', 'implements', 'import', 'interface', 'late', 'library', 'mixin', 'of', 'on', 'operator', 'part',
+  'required', 'sealed', 'set', 'show', 'static', 'sync', 'typedef', 'when', 'yield',
+]);
+
+// ---------------------------------------------------------------- brackets
+
+interface Brackets {
+  /** The offset of every bracket character, in order. */
+  at: number[];
+  /** For each bracket, the index of its partner, or -1. */
+  partner: number[];
+  /** For each bracket, the index of the open bracket around it, or -1. */
+  parent: number[];
+}
+
+/** Pairs `()`, `[]` and `{}`; a stray close is left unpaired, and so are the opens a close skips past. */
+function matchBrackets(code: string): Brackets {
+  const at: number[] = [];
+  const partner: number[] = [];
+  const parent: number[] = [];
+  const stack: number[] = [];
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if (ch === '(' || ch === '[' || ch === '{') {
+      at.push(i);
+      partner.push(-1);
+      parent.push(stack.length > 0 ? stack[stack.length - 1]! : -1);
+      stack.push(at.length - 1);
+    } else if (ch === ')' || ch === ']' || ch === '}') {
+      const want = ch === ')' ? '(' : ch === ']' ? '[' : '{';
+      let s = stack.length - 1;
+      while (s >= 0 && code[at[stack[s]!]!] !== want) s--;
+      at.push(i);
+      partner.push(-1);
+      if (s < 0) {
+        parent.push(stack.length > 0 ? stack[stack.length - 1]! : -1);
+        continue;
+      }
+      const open = stack[s]!;
+      stack.length = s;
+      partner[open] = at.length - 1;
+      partner[at.length - 1] = open;
+      parent.push(parent[open]!);
+    }
+  }
+  return { at, partner, parent };
+}
+
+/** The index of the first bracket at or after offset `from`. */
+function firstBracketFrom(b: Brackets, from: number): number {
+  let lo = 0;
+  let hi = b.at.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (b.at[mid]! < from) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+
+/** The index of the bracket at offset `at`, or -1. */
+function bracketIndexAt(b: Brackets, at: number): number {
+  const k = firstBracketFrom(b, at);
+  return b.at[k] === at ? k : -1;
+}
+
+/** The index of the innermost open bracket around offset `at`, or -1. */
+function innermostBracket(code: string, b: Brackets, at: number): number {
+  const k = firstBracketFrom(b, at) - 1;
+  if (k < 0) return -1;
+  const ch = code[b.at[k]!];
+  return ch === '(' || ch === '[' || ch === '{' ? k : b.parent[k]!;
+}
+
+// ---------------------------------------------------------------- lexing
+
+/**
+ * The source with comments and the text of string literals blanked to
+ * spaces (offsets and newlines kept). Code inside a `${…}` interpolation
+ * stays, minus the braces that delimit it; block comments nest, and raw
+ * strings (`r'…'`) have no escapes or interpolation.
+ */
+function blankDartLiterals(source: string): string {
+  const out = source.split('');
+  const n = source.length;
+  const blank = (from: number, to: number): void => {
+    for (let k = from; k < to && k < n; k++) if (source[k] !== '\n' && source[k] !== '\r') out[k] = ' ';
+  };
+  // The strings an interpolation was opened from, innermost last, with the brace depth inside it.
+  const suspended: Array<{ quote: string; braces: number }> = [];
+  let quote: string | null = null;
+  let raw = false;
+  let i = 0;
+  while (i < n) {
+    if (quote !== null) {
+      if (source.startsWith(quote, i)) {
+        i += quote.length;
+        quote = null;
+        continue;
+      }
+      const ch = source[i]!;
+      if (!raw && ch === '\\') {
+        blank(i, i + 2);
+        i += 2;
+        continue;
+      }
+      if (!raw && ch === '$' && source[i + 1] === '{') {
+        blank(i, i + 2);
+        suspended.push({ quote, braces: 0 });
+        quote = null;
+        i += 2;
+        continue;
+      }
+      // A single-quoted string ends at the line's end however it was left.
+      if (quote.length === 1 && ch === '\n') {
+        quote = null;
+        i++;
+        continue;
+      }
+      blank(i, i + 1);
+      i++;
+      continue;
+    }
+    const ch = source[i]!;
+    if (ch === '/' && source[i + 1] === '/') {
+      const end = source.indexOf('\n', i);
+      blank(i, end < 0 ? n : end);
+      i = end < 0 ? n : end;
+      continue;
+    }
+    if (ch === '/' && source[i + 1] === '*') {
+      let depth = 1;
+      let j = i + 2;
+      while (j < n && depth > 0) {
+        if (source[j] === '/' && source[j + 1] === '*') {
+          depth++;
+          j += 2;
+        } else if (source[j] === '*' && source[j + 1] === '/') {
+          depth--;
+          j += 2;
+        } else {
+          j++;
+        }
+      }
+      blank(i, j);
+      i = j;
+      continue;
+    }
+    if (suspended.length > 0 && (ch === '{' || ch === '}')) {
+      const top = suspended[suspended.length - 1]!;
+      if (ch === '{') top.braces++;
+      else if (top.braces > 0) top.braces--;
+      else {
+        blank(i, i + 1);
+        suspended.pop();
+        quote = top.quote;
+        raw = false;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      raw = source[i - 1] === 'r' && !/[\w$]/.test(source[i - 2] ?? '');
+      quote = source[i + 1] === ch && source[i + 2] === ch ? ch.repeat(3) : ch;
+      i += quote.length;
+      continue;
+    }
+    i++;
+  }
+  return out.join('');
+}
+
+/**
+ * The code with type-argument lists blanked — `Map<String, int>`, `<T>(x) =>`,
+ * `<int>[]` — so their commas never end an argument and their angle brackets
+ * never read as comparisons. A `<` opens one when it follows a name with no
+ * space (`List<int>`), or when what it closes is followed by `(`, `[`, `{` or
+ * `.` (a generic function or a typed literal), and everything inside is type
+ * syntax.
+ */
+function blankTypeArguments(code: string): string {
+  if (!code.includes('<')) return code;
+  const out = code.split('');
+  let i = code.indexOf('<');
+  while (i >= 0) {
+    const end = typeArgumentsEnd(code, i);
+    if (end > i) {
+      const glued = /[\w$]/.test(code[i - 1] ?? '');
+      const next = code[skipSpace(code, end + 1)] ?? '';
+      if (glued || next === '(' || next === '[' || next === '{' || next === '.') {
+        for (let k = i; k <= end; k++) if (out[k] !== '\n' && out[k] !== '\r') out[k] = ' ';
+        i = code.indexOf('<', end + 1);
+        continue;
+      }
+    }
+    i = code.indexOf('<', i + 1);
+  }
+  return out.join('');
+}
+
+/** The offset of the `>` closing a type-argument list opened at `open`, or -1 if what follows is not one. */
+function typeArgumentsEnd(code: string, open: number): number {
+  let angles = 0;
+  let parens = 0;
+  for (let i = open; i < code.length && i < open + 400; i++) {
+    const ch = code[i]!;
+    if (ch === '<') angles++;
+    else if (ch === '>') {
+      if (code[i - 1] === '=') return -1;
+      if (--angles === 0) return parens === 0 ? i : -1;
+    } else if (ch === '(' || ch === '{') parens++;
+    else if (ch === ')' || ch === '}') {
+      if (--parens < 0) return -1;
+    } else if (!/[\w$\s.,?]/.test(ch)) return -1;
+  }
+  return -1;
+}
diff --git a/src/resolution/frameworks/angular-router.ts b/src/resolution/frameworks/angular-router.ts
new file mode 100644
index 0000000000..5d37951a99
--- /dev/null
+++ b/src/resolution/frameworks/angular-router.ts
@@ -0,0 +1,1116 @@
+/**
+ * Angular Router — routes declared in `Routes` arrays, navigation written as
+ * command arrays.
+ *
+ *   export const routes: Routes = [
+ *     { path: 'login', component: AuthComponent },
+ *     { path: 'article/:slug', loadComponent: () => import('./article.component') },
+ *     { path: 'editor', children: [{ path: ':slug', loadComponent: … }] },
+ *     { path: 'profile', loadChildren: () => import('./profile/profile.routes') },
+ *   ];
+ *
+ * `extract()` reads every such array — typed `Routes` / `Route[]`, passed to
+ * `RouterModule.forRoot/forChild(…)` or `provideRouter(…)`, or a routes
+ * file's `export default [...]` — into one `route` node per screen, named by
+ * its path the way every other framework's routes are. Angular paths are
+ * relative: a child's path joins its parent's, and a `loadChildren` file's
+ * routes sit under the path that lazy-loads them, which only a cross-file
+ * pass can know — so `extract()` names a routes file's routes as if it were
+ * mounted at `/`, and `postExtract()` puts each under its mount (following an
+ * NgModule `loadChildren` through to the routing module it imports).
+ *
+ * A route with `children` is a layout, not a screen: its component renders
+ * an outlet the children fill, and the `''` child is the screen at its
+ * address. It is a screen only when no child claims that address. A
+ * `redirectTo` entry and a `**` catch-all are not screens either.
+ *
+ * A path written as a constant (`path: internalRoutes.account.path`) is read
+ * from the object the constant names, `$localize` defaults included, in the
+ * same cross-file pass.
+ *
+ * A route binds to its component with a `references` edge — `route-roots.ts`
+ * takes a class as the handler a resolver named. A lazy `loadComponent`
+ * names a file, and its component is the `@Component` class that file
+ * exports.
+ *
+ * **Navigation is a command array.** `router.navigate(['/article', slug])`
+ * is `/article/${…}`; `navigateByUrl('/login')`, a guard's
+ * `router.createUrlTree(['/login'])` and `parseUrl('/login')` name a path the
+ * way every other router's calls do. A relative navigation (`relativeTo`) is
+ * left unresolved rather than guessed. `routerLink` is markup, read by
+ * `angular-template-synthesizer.ts`.
+ */
+
+import * as path from 'path';
+import type { Node } from '../../types';
+import type { FrameworkExtractionResult, FrameworkResolver, ResolutionContext, ResolvedRef, UnresolvedRef } from '../types';
+import { resolveImportPath } from '../import-resolver';
+import { stripCommentsForRegex } from '../strip-comments';
+import { matchBracket, readFields, skipString, topLevelObjects } from './object-literal';
+import { dependsOn } from './package-deps';
+import {
+  addRouteTo,
+  appRootFor,
+  firstArgumentText,
+  HOLE,
+  toHref,
+  nthArgumentText,
+  parseHrefExpression,
+  readStringAt,
+  routesForFile,
+  type HrefLiteral,
+  type RootedRouteTable,
+  type RouteTable,
+} from './expo-router';
+import { destinationsForHref } from './nextjs';
+
+// =============================================================================
+// Reading a routes array
+// =============================================================================
+
+/** The component a route names: a class in scope, or a lazily imported file's (`name` null = its default export). */
+export type AngularComponentRef = { name: string; spec: null } | { name: string | null; spec: string };
+
+export interface AngularRoute {
+  /** `/editor/:slug` within this file; a constant path segment is kept as `{expr}` until the cross-file pass reads it. */
+  path: string;
+  line: number;
+  component: AngularComponentRef | null;
+  /** The layouts the screen renders inside, outermost first: each ancestor route's component, around its `<router-outlet>`. */
+  layouts: AngularComponentRef[];
+}
+
+export interface AngularRedirect {
+  /** `/` within this file. */
+  from: string;
+  /** Where it sends the user, within this file — or, when `absolute`, in the app: `/home`. */
+  to: string;
+  absolute: boolean;
+}
+
+export interface AngularMount {
+  /** Where the lazily loaded routes sit within this file: `/profile`. */
+  prefix: string;
+  /** The `loadChildren` import: `./profile/profile.routes`. */
+  spec: string;
+  line: number;
+}
+
+/** A file that could hold a routes array — the cheap gate before scanning. */
+const ROUTER_IMPORT = /['"]@angular\/router['"]/;
+
+/**
+ * Where a routes array opens: typed `Routes` / `Route[]`, handed to
+ * `RouterModule.forRoot/forChild` or `provideRouter`, or a routes file's
+ * default export. `children: [` is reached by walking an entry, never here.
+ */
+const ARRAY_OPENERS =
+  /(?::\s*(?:Routes|Route\s*\[\s*\])\s*=\s*|\bRouterModule\s*\.\s*for(?:Root|Child)\s*\(\s*|\bprovideRouter\s*\(\s*|\bexport\s+default\s+(?:<\s*Routes\s*>\s*)?|\b(?:const|let)\s+[A-Za-z_$][\w$]*\s*=\s*)\[/g;
+
+/** The fields that make an object a route rather than any object in an array. */
+const ROUTE_KEYS = ['component', 'loadComponent', 'children', 'loadChildren', 'redirectTo'] as const;
+
+/** A path value the pass can name later: `internalRoutes.account.path`. */
+const CONSTANT_PATH = /^[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)+$/;
+
+/** A `$localize` tagged template's default text: `` $localize`:kebab-case@@routes.about:about` `` is `about`. */
+export function localizeDefault(text: string): string | null {
+  const m = /^\$localize\s*`((?:[^`\\$]|\\.)*)`$/.exec(text.trim());
+  if (!m) return null;
+  const body = m[1]!;
+  // `:meaning|description@@id:text` — the metadata block is the leading `:…:`.
+  const meta = /^:[^:]*:/.exec(body);
+  return meta ? body.slice(meta[0].length) : body;
+}
+
+/**
+ * A string written statically: a literal, a `$localize` default, or `+`
+ * between those — `'/' + $localize`:…:about``, as Ghostfolio builds its
+ * links. Null when any part is computed.
+ */
+export function staticString(text: string): string | null {
+  const parts: string[] = [];
+  let rest = text.trim();
+  while (rest.length > 0) {
+    let part: string | null = null;
+    let used = 0;
+    const q = rest[0];
+    if (q === '"' || q === "'") {
+      part = readStringAt(rest, 0);
+      used = part === null ? 0 : skipString(rest, 0) + 1;
+    } else if (rest.startsWith('$localize')) {
+      const tick = rest.indexOf('`');
+      const end = tick < 0 ? -1 : skipString(rest, tick);
+      if (end > 0) {
+        part = localizeDefault(rest.slice(0, end + 1));
+        used = end + 1;
+      }
+    } else if (q === '`') {
+      const end = skipString(rest, 0);
+      const body = end > 0 ? rest.slice(1, end) : '';
+      if (end > 0 && !body.includes('${')) {
+        part = body;
+        used = end + 1;
+      }
+    }
+    if (part === null || used === 0) return null;
+    parts.push(part);
+    rest = rest.slice(used).trim();
+    if (rest.length === 0) break;
+    if (rest[0] !== '+') return null;
+    rest = rest.slice(1).trim();
+  }
+  return parts.length > 0 ? parts.join('') : null;
+}
+
+/** A route's own path segment(s): a string, a `$localize` default, or a constant kept as `{expr}`; null when it cannot be named. */
+function pathSegments(text: string): string[] | null {
+  const trimmed = text.trim();
+  const value = staticString(trimmed);
+  if (value !== null) {
+    if (value.includes('**')) return null;
+    return value.split('/').filter((s) => s.length > 0);
+  }
+  if (CONSTANT_PATH.test(trimmed)) return [`{${trimmed.replace(/\s+/g, '')}}`];
+  // `` `issue/:${ProjectConst.IssueId}` ``: a template whose holes are constants.
+  if (trimmed.startsWith('`') && skipString(trimmed, 0) === trimmed.length - 1) {
+    let ok = true;
+    const body = trimmed.slice(1, -1).replace(/\$\{([^}]*)\}/g, (_all, hole: string) => {
+      if (!CONSTANT_PATH.test(hole.trim())) ok = false;
+      return `{${hole.replace(/\s+/g, '')}}`;
+    });
+    if (ok && !body.includes('**')) return body.split('/').filter((seg) => seg.length > 0);
+    return null;
+  }
+  // `internalRoutes.account.subRoutes.access.path + '/:id'`: each part a
+  // string or a constant, the constant a whole segment of its own.
+  if (trimmed.includes('+')) {
+    const joined: string[] = [];
+    for (const part of splitPlus(trimmed)) {
+      const literal = staticString(part);
+      if (literal !== null) joined.push(literal);
+      else if (CONSTANT_PATH.test(part.trim())) joined.push(`{${part.trim().replace(/\s+/g, '')}}`);
+      else return null;
+    }
+    const value = joined.join('');
+    return value.includes('**') ? null : value.split('/').filter((seg) => seg.length > 0);
+  }
+  return null;
+}
+
+/** An expression's `+` operands at depth 0, strings and brackets stepped over. */
+function splitPlus(text: string): string[] {
+  const parts: string[] = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(text, i);
+      if (end < 0) return [text];
+      i = end;
+    } else if (ch === '(' || ch === '[' || ch === '{') {
+      const end = matchBracket(text, i);
+      if (end < 0) return [text];
+      i = end;
+    } else if (ch === '+') {
+      parts.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+
+/** The component a `component:` / `loadComponent:` value names. */
+function componentRef(field: 'component' | 'loadComponent', text: string): AngularComponentRef | null {
+  if (field === 'component') {
+    const ident = /^\s*([A-Z][\w$]*)\s*$/.exec(text);
+    return ident ? { name: ident[1]!, spec: null } : null;
+  }
+  const lazy = lazyImport(text);
+  return lazy ? { name: lazy.member, spec: lazy.spec } : null;
+}
+
+/** `() => import('./x')` → `./x`; `.then(m => m.X)` / `.then((c) => c.X)` names the member. */
+function lazyImport(text: string): { spec: string; member: string | null } | null {
+  const imp = /\bimport\s*\(\s*(['"`])([^'"`]+)\1\s*\)/.exec(text);
+  if (!imp) return null;
+  const after = text.slice(imp.index + imp[0].length);
+  const then = /^\s*\.then\s*\(\s*\(?\s*([A-Za-z_$][\w$]*)\s*\)?\s*=>\s*\(?\s*\1\s*\.\s*([A-Za-z_$][\w$]*)/.exec(after);
+  // `async () => (await import('./x')).HomeModule`
+  const awaited = /^\s*\)\s*\.\s*([A-Za-z_$][\w$]*)/.exec(after);
+  return { spec: imp[2]!, member: then ? then[2]! : awaited ? awaited[1]! : null };
+}
+
+function joinPath(segs: readonly string[]): string {
+  return '/' + segs.join('/');
+}
+
+/**
+ * Every screen and lazy mount a file's routes arrays declare. Entries are
+ * walked as objects (`object-literal.ts`), never read out of a window of
+ * text: `path` may be written after `component`.
+ */
+export function parseAngularRoutes(content: string): { routes: AngularRoute[]; mounts: AngularMount[]; redirects: AngularRedirect[] } {
+  const routes: AngularRoute[] = [];
+  const mounts: AngularMount[] = [];
+  const redirects: AngularRedirect[] = [];
+  if (!ROUTER_IMPORT.test(content)) return { routes, mounts, redirects };
+  const safe = stripCommentsForRegex(content, 'typescript');
+  const lineOf = (at: number) => safe.slice(0, at).split('\n').length;
+  const seenPaths = new Set<string>();
+  const walked = new Set<number>();
+
+  const walk = (open: number, close: number, prefix: readonly string[], depth: number, layouts: readonly AngularComponentRef[]): void => {
+    if (walked.has(open) || depth > 12) return;
+    walked.add(open);
+    for (const obj of topLevelObjects(safe, open + 1, close)) {
+      const fields = readFields(safe, obj.start, obj.end);
+      if (!ROUTE_KEYS.some((k) => fields.has(k))) continue;
+      // A custom `matcher` decides the address at run time — no path to name.
+      if (fields.has('matcher')) continue;
+      const pathField = fields.get('path');
+      // `{ path: '**', redirectTo: 'home' }`: where an address nothing else matches lands.
+      if (pathField && fields.has('redirectTo') && staticString(pathField.text) === '**') {
+        const target = staticString(fields.get('redirectTo')!.text);
+        if (target !== null && !target.includes('**')) {
+          const absolute = target.startsWith('/');
+          redirects.push({ from: joinPath([...prefix, '**']), to: joinPath([...(absolute ? [] : prefix), ...target.split('/').filter((t) => t.length > 0)]), absolute });
+        }
+        continue;
+      }
+      const own = pathField ? pathSegments(pathField.text) : [];
+      if (own === null) continue; // a computed path, or a `**` catch-all
+      const segs = [...prefix, ...own];
+      const line = lineOf(pathField ? pathField.at : obj.start);
+
+      const redirectTo = fields.get('redirectTo');
+      if (redirectTo) {
+        // `{ path: '', redirectTo: 'home' }`: arriving at `/` is arriving at
+        // `/home`. A relative target is a sibling, under the same parent.
+        const target = staticString(redirectTo.text);
+        if (target !== null && !target.includes('**')) {
+          const absolute = target.startsWith('/');
+          const to = joinPath([...(absolute ? [] : prefix), ...target.split('/').filter((t) => t.length > 0)]);
+          redirects.push({ from: joinPath(segs), to, absolute });
+        }
+        continue;
+      }
+
+      const loadChildren = fields.get('loadChildren');
+      if (loadChildren) {
+        const lazy = lazyImport(loadChildren.text);
+        if (lazy) mounts.push({ prefix: joinPath(segs), spec: lazy.spec, line });
+        continue;
+      }
+      const componentField = fields.get('component') ? 'component' : fields.get('loadComponent') ? 'loadComponent' : null;
+      const component = componentField ? componentRef(componentField, fields.get(componentField)!.text) : null;
+
+      const children = fields.get('children');
+      let childClaimsAddress = false;
+      if (children) {
+        const childOpen = safe.indexOf('[', children.at);
+        const childClose = childOpen < 0 ? -1 : matchBracket(safe, childOpen);
+        if (childOpen >= 0 && childClose > childOpen) {
+          for (const child of topLevelObjects(safe, childOpen + 1, childClose)) {
+            const childPath = readFields(safe, child.start, child.end).get('path');
+            if (!childPath || pathSegments(childPath.text)?.length === 0) childClaimsAddress = true;
+          }
+          walk(childOpen, childClose, segs, depth + 1, component ? [...layouts, component] : layouts);
+        }
+      }
+      // A layout is a screen only where no child claims its address; a
+      // redirect and a componentless grouping are no screen at all.
+      if (!componentField || (children && childClaimsAddress)) continue;
+      const route = joinPath(segs);
+      if (seenPaths.has(route)) continue;
+      seenPaths.add(route);
+      routes.push({ path: route, line, component, layouts: [...layouts] });
+    }
+  };
+
+  ARRAY_OPENERS.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = ARRAY_OPENERS.exec(safe)) !== null) {
+    const open = m.index + m[0].length - 1;
+    const close = matchBracket(safe, open);
+    if (close < 0) continue;
+    // `const x = [` is a routes array only when it says so: `] as Routes` / `] satisfies Routes`.
+    if (/^\b(?:const|let)\b/.test(m[0]) && !/^\]\s*(?:as|satisfies)\s+Routes\b/.test(safe.slice(close, close + 32))) continue;
+    walk(open, close, [], 0, []);
+  }
+  return { routes, mounts, redirects };
+}
+
+/** The id a config-declared route carries — reconstructed exactly, so the resolver recognises its own. */
+function routeId(filePath: string, line: number, inFilePath: string): string {
+  return `route:${filePath}:${line}:${inFilePath}:angular`;
+}
+
+/** True for a route node this resolver emitted. */
+export function isAngularRoute(node: Node): boolean {
+  return node.kind === 'route' && node.id.endsWith(':angular') && node.id === routeId(node.filePath, node.startLine, inFilePath(node));
+}
+
+/** The path a route has within its own file, before any mount — kept in the qualified name so the cross-file pass is idempotent. */
+function inFilePath(node: Node): string {
+  const marker = '::route:';
+  const at = node.qualifiedName.indexOf(marker);
+  return at < 0 ? node.name : node.qualifiedName.slice(at + marker.length);
+}
+
+// =============================================================================
+// The component a file lazily exports
+// =============================================================================
+
+/** `@Component({…}) export default class X` / `export class X` — the classes a file declares as components. */
+const COMPONENT_CLASS = /@Component\s*\(/g;
+
+/** The `@Component` classes a file declares, in order, with whether each is the default export. */
+export function componentClassesIn(content: string): Array<{ name: string; isDefault: boolean; decoratorAt: number }> {
+  const out: Array<{ name: string; isDefault: boolean; decoratorAt: number }> = [];
+  const safe = stripCommentsForRegex(content, 'typescript');
+  COMPONENT_CLASS.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = COMPONENT_CLASS.exec(safe)) !== null) {
+    const open = m.index + m[0].length - 1;
+    const close = matchBracket(safe, open);
+    if (close < 0) continue;
+    const after = /^\s*(export\s+)?(default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/.exec(safe.slice(close + 1, close + 400));
+    if (after) out.push({ name: after[3]!, isDefault: !!after[2], decoratorAt: m.index });
+    COMPONENT_CLASS.lastIndex = close;
+  }
+  return out;
+}
+
+/** The component class a lazily loaded file provides: the member named, else its default export, else its only component. */
+function lazyComponent(spec: string, member: string | null, fromFile: string, context: ResolutionContext): Node | null {
+  const file = resolveImportPath(spec, fromFile, 'typescript', context);
+  if (!file) return null;
+  let name = member;
+  if (!name) {
+    const content = context.readFile(file);
+    if (!content) return null;
+    const classes = componentClassesIn(content);
+    name = (classes.find((c) => c.isDefault) ?? (classes.length === 1 ? classes[0] : undefined))?.name ?? null;
+    if (!name) {
+      const plain = /\bexport\s+default\s+class\s+([A-Za-z_$][\w$]*)/.exec(content);
+      name = plain ? plain[1]! : null;
+    }
+  }
+  if (!name) return null;
+  return context.getNodesInFile(file).find((n) => n.kind === 'class' && n.name === name) ?? null;
+}
+
+/** A path's segments with each `{expr}` read from the constant it names, as seen from `file` — where the route (or the mount) is written. */
+function resolvedSegments(pathText: string, file: string, context: ResolutionContext): string[] {
+  return pathText
+    .split('/')
+    .filter((seg) => seg.length > 0)
+    .flatMap((seg) => {
+      if (seg.startsWith('{') && seg.endsWith('}') && seg.indexOf('{', 1) < 0) {
+        const value = constantValue(seg.slice(1, -1), file, context);
+        return value === null ? [seg] : value.split('/').filter((v) => v.length > 0);
+      }
+      // `:{ProjectConst.IssueId}` — a constant inside a segment.
+      return [seg.replace(/\{([^{}]+)\}/g, (all, expr: string) => constantValue(expr, file, context) ?? all)];
+    });
+}
+
+/** The class a route's component names, by its import (or this file) — or a lazy import's. */
+function routeComponent(encoded: string, fromFile: string, context: ResolutionContext): Node | null {
+  const lazy = LAZY_COMPONENT_REF.exec(encoded);
+  if (lazy) return lazyComponent(lazy[1]!, lazy[2] === 'default' ? null : lazy[2]!, fromFile, context);
+  const file = declaringFile(encoded, fromFile, context);
+  return file ? (context.getNodesInFile(file).find((n) => n.kind === 'class' && n.name === encoded) ?? null) : null;
+}
+
+// =============================================================================
+// The cross-file pass: mounts and constant paths
+// =============================================================================
+
+/**
+ * The file a routes import names, and — for an NgModule — the routing modules
+ * it imports. A barrel is looked through first: an Nx library is imported by
+ * its alias (`@angular-spotify/web/home/feature`), which names the library's
+ * `src/index.ts`, whose `export * from './lib/home.module'` names the module.
+ */
+function routeFilesLoadedBy(spec: string, fromFile: string, context: ResolutionContext, routeFiles: ReadonlySet<string>, mountFiles: ReadonlySet<string>): string[] {
+  const target = resolveImportPath(spec, fromFile, 'typescript', context);
+  const seen = new Set<string>();
+  const out: string[] = [];
+  // A barrel can re-export another barrel; a few hops settle it.
+  let barrels = target ? [target] : [];
+  for (let hop = 0; hop < 4 && barrels.length > 0; hop++) {
+    const next: string[] = [];
+    for (const file of barrels) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      if (routeFiles.has(file) || mountFiles.has(file)) {
+        out.push(file);
+        continue;
+      }
+      const content = context.readFile(file);
+      if (!content) continue;
+      // `loadChildren: () => import('./layout/layout.module').then(m => m.LayoutModule)`:
+      // the module holds no routes; the routing module it imports does.
+      if (/@NgModule\s*\(/.test(content)) {
+        const imports = /\bimport\s+[^'"]*?from\s+(['"])([^'"]+)\1/g;
+        let m: RegExpExecArray | null;
+        while ((m = imports.exec(content)) !== null) {
+          const imported = resolveImportPath(m[2]!, file, 'typescript', context);
+          if (imported && (routeFiles.has(imported) || mountFiles.has(imported)) && !out.includes(imported)) out.push(imported);
+        }
+        continue;
+      }
+      const reexports = /\bexport\s+(?:\*|\{[^}]*\})\s*(?:as\s+[\w$]+\s*)?from\s+(['"])([^'"]+)\1/g;
+      let m: RegExpExecArray | null;
+      while ((m = reexports.exec(content)) !== null) {
+        const reexported = resolveImportPath(m[2]!, file, 'typescript', context);
+        if (reexported && !seen.has(reexported)) next.push(reexported);
+      }
+    }
+    barrels = next;
+  }
+  return out;
+}
+
+/** Per context, renewed with the route list (whose identity changes when the resolver's caches do). */
+const constantTexts = new WeakMap<ResolutionContext, { source: readonly Node[]; memo: Map<string, string | null> }>();
+
+/**
+ * The source text a constant member chain names — `internalRoutes.account.path`
+ * is the `path:` field of `account` in `export const internalRoutes = {…}` —
+ * read from the file the chain's root is imported from (or declared in).
+ */
+export function constantText(expr: string, fromFile: string, context: ResolutionContext): string | null {
+  const source = context.getNodesByKind('route');
+  let entry = constantTexts.get(context);
+  if (!entry || entry.source !== source) constantTexts.set(context, (entry = { source, memo: new Map() }));
+  const memo = entry.memo;
+  const key = `${fromFile}\0${expr}`;
+  if (memo.has(key)) return memo.get(key)!;
+  // `const { create } = internalRoutes.accounts.subRoutes;` / `const accounts = internalRoutes.accounts;`
+  // make `create.path` a chain rooted at the import.
+  const aliased = localAlias(expr, fromFile, context);
+  if (aliased !== null && aliased !== expr) {
+    const value = constantText(aliased, fromFile, context);
+    memo.set(key, value);
+    return value;
+  }
+  const [root, ...chain] = expr.split('.').map((part) => part.trim());
+  let value: string | null = null;
+  const file = root ? declaringFile(root, fromFile, context) : null;
+  const content = file && root ? declarationSource(root, file, context, 0) : null;
+  if (content && root && chain.length > 0) {
+    const safe = stripCommentsForRegex(content, 'typescript');
+    const readChain = (open: number, links: readonly string[]): string | null => {
+      let start = open;
+      let end = matchBracket(safe, start);
+      for (let i = 0; i < links.length && end > start; i++) {
+        const field = readFields(safe, start, end).get(links[i]!);
+        if (!field) return null;
+        if (i === links.length - 1) return field.text.trim();
+        start = safe.indexOf('{', field.at);
+        end = start < 0 ? -1 : matchBracket(safe, start);
+      }
+      return null;
+    };
+    const decl = new RegExp(String.raw`\b(?:const|let)\s+${root}\s*(?::[^=]+)?=\s*\{`).exec(safe);
+    const enumDecl = decl ? null : new RegExp(String.raw`\benum\s+${root}\s*\{`).exec(safe);
+    const classDecl = decl || enumDecl ? null : new RegExp(String.raw`\bclass\s+${root}\b[^{]*\{`).exec(safe);
+    if (decl) value = readChain(decl.index + decl[0].length - 1, chain);
+    else if (enumDecl && chain.length === 1) {
+      // `enum Paths { Board = 'board' }`
+      const open = enumDecl.index + enumDecl[0].length - 1;
+      const body = safe.slice(open, Math.max(open, matchBracket(safe, open)));
+      value = new RegExp(String.raw`\b${chain[0]}\s*=\s*(['"\`][^'"\`]*['"\`])`).exec(body)?.[1] ?? null;
+    } else if (classDecl) {
+      // `class ProjectConst { static readonly IssueId = 'issueId' }`, and
+      // `class RouterUtil { static Configuration = { Visualizer: 'visualizer' } }`.
+      const open = classDecl.index + classDecl[0].length - 1;
+      const close = matchBracket(safe, open);
+      const body = close > open ? safe.slice(open, close) : '';
+      const field = new RegExp(String.raw`\bstatic\s+(?:readonly\s+)?${chain[0]}\s*(?::[^=;]+)?=\s*`).exec(body);
+      if (field) {
+        const at = open + field.index + field[0].length;
+        if (safe[at] === '{') value = chain.length > 1 ? readChain(at, chain.slice(1)) : null;
+        else if (chain.length === 1) value = /^(['"\`])[^'"\`]*\1/.exec(safe.slice(at))?.[0] ?? null;
+      }
+    }
+  }
+  memo.set(key, value);
+  return value;
+}
+
+/**
+ * The source that declares `root`: `file` itself, or — when `file` is a
+ * barrel (an Nx library's `src/index.ts`) — the module it re-exports it from.
+ */
+function declarationSource(root: string, file: string, context: ResolutionContext, hops: number): string | null {
+  const content = context.readFile(file);
+  if (!content) return null;
+  if (new RegExp(String.raw`\b(?:const|let|class|enum)\s+${root}\b`).test(content)) return content;
+  if (hops >= 3) return null;
+  const reexports = /\bexport\s+(\*|\{[^}]*\})\s*from\s+(['"])([^'"]+)\2/g;
+  let m: RegExpExecArray | null;
+  while ((m = reexports.exec(content)) !== null) {
+    if (m[1] !== '*' && !new RegExp(String.raw`\b${root}\b`).test(m[1]!)) continue;
+    const target = resolveImportPath(m[3]!, file, 'typescript', context);
+    const found = target ? declarationSource(root, target, context, hops + 1) : null;
+    if (found) return found;
+  }
+  return null;
+}
+
+/** `create.path` as the chain its root was destructured from in `fromFile`, or null when the root is no local alias. */
+function localAlias(expr: string, fromFile: string, context: ResolutionContext): string | null {
+  const content = context.readFile(fromFile);
+  if (!content) return null;
+  const [root, ...rest] = expr.split('.');
+  if (!root) return null;
+  const destructure = /\b(?:const|let)\s*\{([^}]*)\}\s*=\s*([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)\s*;?/g;
+  let m: RegExpExecArray | null;
+  while ((m = destructure.exec(content)) !== null) {
+    for (const binding of m[1]!.split(',')) {
+      const [prop, local] = binding.split(':').map((part) => part.trim());
+      if ((local ?? prop) === root && prop) return [`${m[2]!.replace(/\s+/g, '')}.${prop}`, ...rest].join('.');
+    }
+  }
+  const simple = new RegExp(String.raw`\b(?:const|let)\s+${root}\s*=\s*([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)+)\s*;`).exec(content);
+  return simple ? [simple[1]!.replace(/\s+/g, ''), ...rest].join('.') : null;
+}
+
+/** A constant path's value: `internalRoutes.account.path` → `account`. */
+function constantValue(expr: string, fromFile: string, context: ResolutionContext): string | null {
+  const text = constantText(expr, fromFile, context);
+  return text === null ? null : staticString(text);
+}
+
+/** The file declaring `name` for code in `fromFile`: its import, else the file itself. */
+function declaringFile(name: string, fromFile: string, context: ResolutionContext): string | null {
+  const content = context.readFile(fromFile);
+  if (!content) return null;
+  const imports = /\bimport\s*\{([^}]*)\}\s*from\s*(['"])([^'"]+)\2/g;
+  let m: RegExpExecArray | null;
+  while ((m = imports.exec(content)) !== null) {
+    const names = m[1]!.split(',').map((s) => s.trim().split(/\s+as\s+/).pop()!.trim());
+    if (names.includes(name)) return resolveImportPath(m[3]!, fromFile, 'typescript', context);
+  }
+  return fromFile;
+}
+
+// =============================================================================
+// Route table
+// =============================================================================
+
+interface AngularMounts {
+  /** Every file that lazy-loads routes, whether or not it declares a screen of its own. */
+  mountFiles: ReadonlySet<string>;
+  /** The path segments a file's routes sit under: its parent's prefix plus the mount's. */
+  prefixOf(file: string): string[];
+}
+
+const mountMemo = new WeakMap<ResolutionContext, { source: readonly Node[]; mounts: AngularMounts }>();
+
+/**
+ * Where every routes file is mounted — the `loadChildren` chain from the app
+ * down, settled from the top. Shared by the cross-file pass, which names the
+ * routes, and the route table, which reads the redirects in files that only
+ * mount others (jira-clone's `app.routes.ts` holds nothing but two mounts and
+ * `'' → 'project'`).
+ */
+function angularMounts(context: ResolutionContext, routes: readonly Node[]): AngularMounts {
+  const source = context.getNodesByKind('route');
+  const cached = mountMemo.get(context);
+  if (cached && cached.source === source) return cached.mounts;
+  const routeFiles = new Set(routes.map((r) => r.filePath));
+  const mountsByFile = new Map<string, AngularMount[]>();
+  for (const file of context.getAllFiles()) {
+    if (!/\.[cm]?ts$/.test(file) || !(context.fileContains?.(file, 'loadChildren') ?? context.readFile(file)?.includes('loadChildren'))) continue;
+    const content = context.readFile(file);
+    if (!content) continue;
+    const { mounts } = parseAngularRoutes(content);
+    if (mounts.length > 0) mountsByFile.set(file, mounts);
+  }
+  const mountFiles = new Set(mountsByFile.keys());
+  const loadedBy = new Map<string, { parent: string; prefix: string }>();
+  for (const [file, mounts] of mountsByFile) {
+    for (const mount of mounts) {
+      for (const target of routeFilesLoadedBy(mount.spec, file, context, routeFiles, mountFiles)) {
+        // A file mounted from two places keeps its first mount.
+        if (target !== file && !loadedBy.has(target)) loadedBy.set(target, { parent: file, prefix: mount.prefix });
+      }
+    }
+  }
+  const memo = new Map<string, string[]>();
+  const prefixOf = (file: string, seen: Set<string> = new Set()): string[] => {
+    const hit = memo.get(file);
+    if (hit !== undefined) return hit;
+    const mount = loadedBy.get(file);
+    let prefix: string[] = [];
+    if (mount && !seen.has(file)) {
+      seen.add(file);
+      prefix = [...prefixOf(mount.parent, seen), ...resolvedSegments(mount.prefix, mount.parent, context)];
+    }
+    memo.set(file, prefix);
+    return prefix;
+  };
+  const mounts: AngularMounts = { mountFiles, prefixOf: (file) => prefixOf(file) };
+  mountMemo.set(context, { source, mounts });
+  return mounts;
+}
+
+const workspaceRoots = new WeakMap<ResolutionContext, Map<string, string | null>>();
+
+/**
+ * The app a routes file belongs to. An Angular workspace — the directory an
+ * `angular.json` or an Nx `nx.json` sits in — is one app however its routes
+ * are split: angular-spotify declares its screens across a dozen `libs/*`
+ * packages, each with a `src/` of its own, and keyed by those every
+ * template's `routerLink` looked for its routes in the wrong table. Outside a
+ * workspace, the conventional app root.
+ */
+function angularAppRoot(filePath: string, context: ResolutionContext): string {
+  let memo = workspaceRoots.get(context);
+  if (!memo) workspaceRoots.set(context, (memo = new Map()));
+  const slash = filePath.lastIndexOf('/');
+  const dir = slash < 0 ? '' : filePath.slice(0, slash);
+  let found = memo.get(dir);
+  if (found === undefined) {
+    found = null;
+    for (let d: string | null = dir; d !== null; d = d === '' ? null : d.includes('/') ? d.slice(0, d.lastIndexOf('/')) : '') {
+      const at = d === '' ? '' : `${d}/`;
+      if (context.fileExists(`${at}angular.json`) || context.fileExists(`${at}nx.json`)) {
+        found = at;
+        break;
+      }
+    }
+    memo.set(dir, found);
+  }
+  return found ?? appRootFor(filePath);
+}
+
+export type AngularRouteTable = RootedRouteTable;
+
+/** True for a route the table holds: this resolver's, at an absolute path. */
+function inAngularTable(node: Node): boolean {
+  return isAngularRoute(node) && node.name.startsWith('/');
+}
+
+const tables = new WeakMap<ResolutionContext, AngularRouteTable>();
+
+export function angularRouteTable(context: ResolutionContext): AngularRouteTable {
+  const all = context.getNodesByKind('route');
+  const cached = tables.get(context);
+  if (cached && cached.source === all) return cached;
+  const byRoot = new Map<string, RouteTable>();
+  const byFile = new Map<string, Node>();
+  for (const node of all) {
+    if (!inAngularTable(node)) continue;
+    const root = angularAppRoot(node.filePath, context);
+    let t = byRoot.get(root);
+    if (!t) byRoot.set(root, (t = { source: all, exact: new Map(), dynamic: [] }));
+    addRouteTo(t, node.name, node);
+    if (!byFile.has(node.filePath)) byFile.set(node.filePath, node);
+  }
+  // Redirects: arriving at `/` is arriving at wherever `redirectTo` sends
+  // the user. A file's mount prefix is what its routes' names add to their
+  // in-file paths. A chain (`/` → `/pages` → `/pages/dashboard`) settles in
+  // a few passes.
+  const aliases: Array<{ table: RouteTable; from: string; to: string }> = [];
+  const mounts = byFile.size > 0 ? angularMounts(context, all.filter(isAngularRoute)) : null;
+  const redirectFiles = new Map<string, string[]>();
+  for (const [file, sample] of byFile) {
+    const own = resolvedSegments(inFilePath(sample), file, context);
+    const full = sample.name.split('/').filter((seg) => seg.length > 0);
+    redirectFiles.set(file, full.slice(0, Math.max(0, full.length - own.length)));
+  }
+  // A file that only mounts others can still redirect: its prefix is where it is mounted.
+  for (const file of mounts?.mountFiles ?? []) {
+    if (!redirectFiles.has(file)) redirectFiles.set(file, mounts!.prefixOf(file));
+  }
+  for (const [file, prefix] of redirectFiles) {
+    const content = context.readFile(file);
+    if (!content || !content.includes('redirectTo')) continue;
+    const table = byRoot.get(angularAppRoot(file, context)) ?? (byRoot.size === 1 ? [...byRoot.values()][0]! : undefined);
+    if (!table) continue;
+    for (const r of parseAngularRoutes(content).redirects) {
+      const from = joinPath([...prefix, ...resolvedSegments(r.from, file, context)]);
+      const to = joinPath([...(r.absolute ? [] : prefix), ...resolvedSegments(r.to, file, context)]);
+      aliases.push({ table, from, to });
+    }
+  }
+  for (let pass = 0; pass < 4; pass++) {
+    let added = false;
+    for (const a of aliases) {
+      const target = a.table.exact.get(a.to);
+      if (target && !a.table.exact.has(a.from)) {
+        a.table.exact.set(a.from, target);
+        added = true;
+      }
+    }
+    if (!added) break;
+  }
+  // `/` that no route or redirect serves falls through to the app's root
+  // `**` redirect. Only `/`: letting the wildcard answer any path would draw
+  // every destination this reading could not name as a trip home.
+  for (const a of aliases) {
+    if (a.from !== '/**') continue;
+    const target = a.table.exact.get(a.to);
+    if (target && !a.table.exact.has('/')) a.table.exact.set('/', target);
+  }
+  const table: AngularRouteTable = { source: all, byRoot };
+  tables.set(context, table);
+  return table;
+}
+
+const appCounts = new WeakMap<ResolutionContext, { source: readonly Node[]; count: number }>();
+
+/**
+ * How many apps the table splits into — `byRoot.size` of
+ * {@link angularRouteTable}, counted from the routes alone: building the table
+ * reads every file that mounts or redirects.
+ */
+function angularAppCount(context: ResolutionContext): number {
+  const all = context.getNodesByKind('route');
+  const cached = appCounts.get(context);
+  if (cached && cached.source === all) return cached.count;
+  const roots = new Set<string>();
+  for (const node of all) if (inAngularTable(node)) roots.add(angularAppRoot(node.filePath, context));
+  appCounts.set(context, { source: all, count: roots.size });
+  return roots.size;
+}
+
+/**
+ * The routes a file navigates among: its app's, or — for a shared library
+ * outside any app (an Nx `libs/ui`) — the one app's, when there is only one.
+ */
+export function angularRoutesFor(table: AngularRouteTable, filePath: string): RouteTable | null {
+  const own = routesForFile(table, filePath);
+  if (own && own.exact.size > 0) return own;
+  return table.byRoot.size === 1 ? [...table.byRoot.values()][0]! : null;
+}
+
+// =============================================================================
+// Navigation
+// =============================================================================
+
+/** `this.router.navigate`, `router.navigateByUrl`, `this._router.createUrlTree`, `router.parseUrl`. */
+const NAV_CALL = /^(?:this\.)?_?[rR]outer\.(navigate|navigateByUrl|createUrlTree|parseUrl)$/;
+
+/** The destination a command array names: `['/article', slug]` is `/article/${…}`; null when it is relative or not a literal array. */
+export function commandsHref(text: string, fromRoot = false): HrefLiteral | null {
+  const arr = text.trim();
+  if (arr[0] !== '[') return null;
+  const close = matchBracket(arr, 0);
+  if (close < 0) return null;
+  const parts: string[] = [];
+  let i = 1;
+  let element = '';
+  const flush = (): boolean => {
+    const e = element.trim();
+    element = '';
+    if (e.length === 0) return true;
+    const literal = staticString(e);
+    if (literal !== null) {
+      parts.push(...literal.split('/').filter((seg) => seg.length > 0));
+      return true;
+    }
+    // A matrix-params object says nothing about the path.
+    if (e.startsWith('{')) return true;
+    parts.push(HOLE);
+    return true;
+  };
+  while (i < close) {
+    const ch = arr[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(arr, i);
+      if (end < 0) return null;
+      element += arr.slice(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    if (ch === '[' || ch === '{' || ch === '(') {
+      const end = matchBracket(arr, i);
+      if (end < 0) return null;
+      element += arr.slice(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    if (ch === ',') flush();
+    else element += ch;
+    i++;
+  }
+  flush();
+  // Only an absolute destination: `['/login']`. In a template, `['../', id]`
+  // and a bare `['edit']` are relative to wherever the component is; a
+  // `router.navigate(['project', 'issue', id])` with no `relativeTo` starts
+  // from the root.
+  const firstElement = arr.slice(1, close).split(',')[0] ?? '';
+  const first = staticString(firstElement);
+  if (first === null || (!first.startsWith('/') && !(fromRoot && !first.startsWith('.')))) return null;
+  const pathText = '/' + parts.filter((p) => p.length > 0).join('/');
+  return namesSomewhere({ path: pathText, display: pathText.split(HOLE).join('${…}') });
+}
+
+/**
+ * The href, when it names at least one segment of its own. A path made only
+ * of holes (`[\`/${a}\`, b, c]`) would match any route of its length — a
+ * hole scores against a literal segment — so it names nothing.
+ */
+export function namesSomewhere(href: HrefLiteral | null): HrefLiteral | null {
+  if (!href) return null;
+  const segs = href.path.split('/').filter((seg) => seg.length > 0);
+  return segs.length === 0 || segs.some((seg) => !seg.includes(HOLE)) ? href : null;
+}
+
+/** A class property's initializer, read from its body: `routerLinkAbout = publicRoutes.about.routerLink;`. */
+export function propertyInitializer(owner: Node, name: string, content: string): string | null {
+  const body = content.split('\n').slice(owner.startLine - 1, owner.endLine).join('\n');
+  const decl = new RegExp(String.raw`(?:^|[\s;{])(?:(?:public|private|protected|readonly|static|override)\s+)*${name}\s*(?::[^=;\n]+)?=\s*`).exec(body);
+  if (!decl) return null;
+  let i = decl.index + decl[0].length;
+  const start = i;
+  while (i < body.length) {
+    const ch = body[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(body, i);
+      if (end < 0) return null;
+      i = end + 1;
+      continue;
+    }
+    if (ch === '[' || ch === '{' || ch === '(') {
+      const end = matchBracket(body, i);
+      if (end < 0) return null;
+      i = end + 1;
+      continue;
+    }
+    if (ch === ';' || ch === '\n') break;
+    i++;
+  }
+  return body.slice(start, i).trim() || null;
+}
+
+/** The array an arrow function returns: `(id) => ['/x', id]` or `(id) => { return ['/x', id]; }`. */
+function arrowReturn(fn: string): string | null {
+  const arrow = fn.indexOf('=>');
+  if (arrow < 0) return null;
+  let i = arrow + 2;
+  while (i < fn.length && /\s/.test(fn[i]!)) i++;
+  if (fn[i] === '(') i++;
+  if (fn[i] === '[') {
+    const end = matchBracket(fn, i);
+    return end > i ? fn.slice(i, end + 1) : null;
+  }
+  if (fn[i] === '{') {
+    const ret = /\breturn\s*\[/.exec(fn.slice(i));
+    if (!ret) return null;
+    const open = i + ret.index + ret[0].length - 1;
+    const end = matchBracket(fn, open);
+    return end > open ? fn.slice(open, end + 1) : null;
+  }
+  return null;
+}
+
+/**
+ * Where an Angular destination expression leads — the argument of
+ * `router.navigate(…)`, or a `[routerLink]` binding:
+ *
+ * - a command array, `['/article', slug]`;
+ * - a static string, `'/login'` or `'/' + $localize…`, and `'/editor/' + slug`;
+ * - a route constant, `internalRoutes.zen.routerLink`;
+ * - a property of the class it is written in, `this.routerLinkAbout`,
+ *   holding one of those;
+ * - any of those `.concat(id)`, one more segment.
+ *
+ * `owner` is the class the expression is written in, for `this.` properties.
+ */
+export function angularDestination(expr: string, file: string, owner: Node | null, context: ResolutionContext, depth = 0, fromRoot = false): HrefLiteral | null {
+  return namesSomewhere(destinationOf(expr, file, owner, context, depth, fromRoot));
+}
+
+function destinationOf(expr: string, file: string, owner: Node | null, context: ResolutionContext, depth: number, fromRoot: boolean): HrefLiteral | null {
+  const text = expr.trim();
+  if (text.length === 0 || depth > 4) return null;
+  if (text[0] === '[') return commandsHref(text, fromRoot);
+  const literal = staticString(text);
+  if (literal !== null) return toHref(literal);
+  // `'/editor/' + article.slug`: the literal head, a hole for the rest.
+  if (/^['"]/.test(text) && text.includes('+')) {
+    const head = staticString(text.slice(0, text.indexOf('+')));
+    if (head !== null && head.startsWith('/')) return toHref(head.replace(/\/?$/, '/') + HOLE);
+  }
+  // `this.routerLinkAdminControlUsers.concat(userId)`: one segment more.
+  const concat = /^(.*?)\.concat\s*\((.*)\)$/s.exec(text);
+  if (concat) {
+    const base = angularDestination(concat[1]!, file, owner, context, depth + 1, fromRoot);
+    const added = concat[2]!.split(',').filter((a) => a.trim().length > 0).length;
+    return base && added > 0 ? toHref(base.path.replace(/\/$/, '') + ('/' + HOLE).repeat(added)) : base;
+  }
+  // `update.routerLink(dataSource, symbol)`: a route constant that builds its
+  // commands — its returned array, the arguments holes.
+  const call = /^((?:this\s*\.\s*)?[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)+)\s*\((.*)\)$/s.exec(text);
+  if (call) {
+    const fn = constantText(call[1]!.replace(/\s+/g, '').replace(/^this\./, ''), file, context);
+    const returned = fn ? arrowReturn(fn) : null;
+    return returned ? commandsHref(returned, fromRoot) : null;
+  }
+  const chain = /^(?:this\s*\.\s*)?([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)$/.exec(text);
+  if (!chain) return parseHrefExpression(text);
+  const parts = chain[1]!.replace(/\s+/g, '').split('.');
+  const content = context.readFile(file);
+  if (content && owner && (text.startsWith('this') || parts.length === 1)) {
+    const init = propertyInitializer(owner, parts[0]!, content);
+    if (init !== null) {
+      if (parts.length === 1) return angularDestination(init, file, owner, context, depth + 1, fromRoot);
+      return angularDestination(`${init}.${parts.slice(1).join('.')}`, file, owner, context, depth + 1, fromRoot);
+    }
+  }
+  const constant = constantText(parts.join('.'), file, context);
+  return constant ? angularDestination(constant, file, owner, context, depth + 1, fromRoot) : null;
+}
+
+// =============================================================================
+// The resolver
+// =============================================================================
+
+/** A route's lazily loaded component: `import:./x.component#default` / `#XComponent`. */
+const LAZY_COMPONENT_REF = /^import:([^#]+)#([\w$]+)$/;
+/** A layout a screen renders inside: `layout:ProfileComponent`, `layout:import:./x#default`. */
+const LAYOUT_REF = /^layout:(.+)$/;
+
+export const angularRouterResolver: FrameworkResolver = {
+  name: 'angular-router',
+  languages: ['typescript', 'javascript'],
+
+  detect(context: ResolutionContext): boolean {
+    return dependsOn(context, '@angular/router', '@angular/core');
+  },
+
+  claimsReference(name: string): boolean {
+    return NAV_CALL.test(name) || LAZY_COMPONENT_REF.test(name) || LAYOUT_REF.test(name);
+  },
+
+  navigation: {
+    tails: ['navigate', 'navigateByUrl', 'createUrlTree', 'parseUrl'],
+    // A call matches against its own app's table — or, in a workspace of one
+    // app, against that app's from anywhere, a shared library included
+    // (`angularRoutesFor`).
+    scope: (route, context) => {
+      if (!inAngularTable(route)) return null;
+      return angularAppCount(context) === 1 ? [''] : [angularAppRoot(route.filePath, context)];
+    },
+  },
+
+  extract(filePath: string, content: string): FrameworkExtractionResult {
+    if (!/\.[cm]?ts$/.test(filePath) || filePath.endsWith('.d.ts')) return { nodes: [], references: [] };
+    const { routes } = parseAngularRoutes(content);
+    if (routes.length === 0) return { nodes: [], references: [] };
+    const now = Date.now();
+    const nodes: Node[] = [];
+    const references: UnresolvedRef[] = [];
+    for (const route of routes) {
+      const node: Node = {
+        id: routeId(filePath, route.line, route.path),
+        kind: 'route',
+        name: route.path,
+        qualifiedName: `${filePath}::route:${route.path}`,
+        filePath,
+        startLine: route.line,
+        endLine: route.line,
+        startColumn: 0,
+        endColumn: 0,
+        language: 'typescript',
+        updatedAt: now,
+      };
+      nodes.push(node);
+      const ref = (component: AngularComponentRef, layout: boolean): UnresolvedRef => ({
+        fromNodeId: node.id,
+        referenceName: `${layout ? 'layout:' : ''}${component.spec === null ? component.name : `import:${component.spec}#${component.name ?? 'default'}`}`,
+        referenceKind: 'references',
+        line: route.line,
+        column: 0,
+        filePath,
+        language: 'typescript',
+      });
+      if (route.component) references.push(ref(route.component, false));
+      // The layouts around it: their links and buttons are on this screen too.
+      for (const layout of route.layouts) references.push(ref(layout, true));
+    }
+    return { nodes, references };
+  },
+
+  /**
+   * Put each routes file's routes under the path that lazy-loads it, and read
+   * constant path segments. Recomputed from each route's in-file path (its
+   * qualified name), so a second run changes nothing.
+   */
+  postExtract(context: ResolutionContext): Node[] {
+    const routes = context.getNodesByKind('route').filter(isAngularRoute);
+    if (routes.length === 0) return [];
+    const { prefixOf } = angularMounts(context, routes);
+    const resolved = (pathText: string, file: string): string[] => resolvedSegments(pathText, file, context);
+    const changed: Node[] = [];
+    for (const route of routes) {
+      const name = joinPath([...prefixOf(route.filePath), ...resolved(inFilePath(route), route.filePath)]);
+      if (name !== route.name) changed.push({ ...route, name });
+    }
+    return changed;
+  },
+
+  resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    const layout = LAYOUT_REF.exec(ref.referenceName);
+    if (layout) {
+      if (!ref.fromNodeId.endsWith(':angular')) return null;
+      const component = routeComponent(layout[1]!, ref.filePath, context);
+      return component
+        ? { original: ref, targetNodeId: component.id, confidence: 0.95, resolvedBy: 'framework', metadata: { layout: true } }
+        : null;
+    }
+    const lazy = LAZY_COMPONENT_REF.exec(ref.referenceName);
+    if (lazy) {
+      if (!ref.fromNodeId.endsWith(':angular')) return null;
+      const component = lazyComponent(lazy[1]!, lazy[2] === 'default' ? null : lazy[2]!, ref.filePath, context);
+      return component ? { original: ref, targetNodeId: component.id, confidence: 0.95, resolvedBy: 'framework' } : null;
+    }
+
+    const nav = NAV_CALL.exec(ref.referenceName);
+    if (!nav || ref.referenceKind !== 'calls') return null;
+    const verb = nav[1]!;
+    const routes = angularRoutesFor(angularRouteTable(context), ref.filePath);
+    if (!routes || routes.exact.size === 0) return null;
+    const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/) ?? null;
+    if (!lines) return null;
+    const arg = firstArgumentText(lines, ref.line, ref.column, verb);
+    if (arg === null) return null;
+    // `navigate(['..', id], { relativeTo: this.route })` goes somewhere relative to here.
+    const extras = nthArgumentText(lines, ref.line, ref.column, verb, 1);
+    if (extras && /\brelativeTo\b/.test(extras)) return null;
+    const owner = context
+      .getNodesInFile(ref.filePath)
+      .filter((n) => n.kind === 'class' && n.startLine <= ref.line && n.endLine >= ref.line)
+      .reduce<Node | null>((inner, n) => (!inner || n.startLine >= inner.startLine ? n : inner), null);
+    const href = angularDestination(arg, ref.filePath, owner, context, 0, true);
+    if (!href || !href.path.startsWith('/')) return null;
+    const targets = destinationsForHref(href, routes);
+    const target = targets[0];
+    if (!target) return null;
+    return {
+      original: ref,
+      targetNodeId: target.node.id,
+      ...(targets.length > 1
+        ? { alsoTargets: targets.slice(1).map((t) => ({ targetNodeId: t.node.id, metadata: { href: t.href.display, navMethod: verb } })) }
+        : {}),
+      confidence: 0.95,
+      resolvedBy: 'framework',
+      edgeKind: 'navigates',
+      metadata: { href: target.href.display, navMethod: verb },
+    };
+  },
+};
+
+/** For the template synthesizer: a template file's path, from the component file that names it. */
+export function templatePathFor(componentFile: string, templateUrl: string): string {
+  return path.posix.normalize(path.posix.join(path.posix.dirname(componentFile), templateUrl));
+}
diff --git a/src/resolution/frameworks/astro.ts b/src/resolution/frameworks/astro.ts
index 63e1af1322..635d19e971 100644
--- a/src/resolution/frameworks/astro.ts
+++ b/src/resolution/frameworks/astro.ts
@@ -7,6 +7,7 @@
 
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
+import { pageComponentRef, resolvePageComponent } from './page-component';
 
 /**
  * Astro virtual module prefixes — framework-provided, not user code
@@ -47,6 +48,10 @@ export const astroResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // A page route names the component its file is.
+    const page = resolvePageComponent(ref, context);
+    if (page) return page;
+
     // Pattern 1: the `Astro` global (Astro.props, Astro.url, Astro.params, …)
     // — runtime-provided in every component's frontmatter. Resolving it as
     // framework-provided keeps it from name-matching a user symbol named Astro.
@@ -74,7 +79,10 @@ export const astroResolver: FrameworkResolver = {
     // Pattern 3: Component references (PascalCase) — resolve to component
     // nodes. Template tags arrive as `references`, frontmatter expression
     // usages as `calls`.
+    // Only from Astro markup: a `.ts` file's `Page` (Playwright's) or a
+    // declaration file's `image?: Image` is no `Page.astro` / `Image.astro`.
     if (
+      ref.filePath.endsWith('.astro') &&
       isPascalCase(ref.referenceName) &&
       (ref.referenceKind === 'references' || ref.referenceKind === 'calls')
     ) {
@@ -92,8 +100,9 @@ export const astroResolver: FrameworkResolver = {
     return null;
   },
 
-  extract(filePath: string, _content: string) {
+  extract(filePath: string, content: string) {
     const nodes: Node[] = [];
+    const references: UnresolvedRef[] = [];
     const now = Date.now();
 
     // Normalize to forward slashes
@@ -115,8 +124,9 @@ export const astroResolver: FrameworkResolver = {
         !/\.config\.[a-z]+$/.test(base)
       ) {
         const routePath = filePathToAstroRoute(afterPages);
-
-        nodes.push({
+        const isPage = normalized.endsWith('.astro');
+        const language = isPage ? 'astro' : 'typescript';
+        const route: Node = {
           id: `route:${filePath}:${routePath}:1`,
           kind: 'route',
           name: routePath,
@@ -126,16 +136,31 @@ export const astroResolver: FrameworkResolver = {
           endLine: 1,
           startColumn: 0,
           endColumn: 0,
-          language: normalized.endsWith('.astro') ? 'astro' : 'typescript',
+          language,
           updatedAt: now,
-        });
+        };
+        nodes.push(route);
+        if (isPage) {
+          references.push(pageComponentRef(route, '.astro', 'astro'));
+        } else {
+          // An endpoint is served by the verbs it exports: `export const GET:
+          // APIRoute = …`, `export async function POST(…)`.
+          for (const m of content.matchAll(ENDPOINT_EXPORT)) {
+            const verb = m[1] ?? m[2]!;
+            const line = content.slice(0, m.index).split('\n').length;
+            references.push({ fromNodeId: route.id, referenceName: verb, referenceKind: 'references', line, column: 0, filePath, language, candidates: [verb] });
+          }
+        }
       }
     }
 
-    return { nodes, references: [] };
+    return { nodes, references };
   },
 };
 
+/** An Astro endpoint's exported handler: `export const GET`, `export async function POST`. */
+const ENDPOINT_EXPORT = /^\s*export\s+(?:(?:async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|ALL)\b|const\s+(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|ALL)\b)/gm;
+
 /**
  * Check if string is PascalCase
  */
diff --git a/src/resolution/frameworks/csharp.ts b/src/resolution/frameworks/csharp.ts
index 765acbd658..0cda2b67ba 100644
--- a/src/resolution/frameworks/csharp.ts
+++ b/src/resolution/frameworks/csharp.ts
@@ -7,10 +7,14 @@
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
+import { pickByNameAndKind } from './name-heuristic';
 
 export const aspnetResolver: FrameworkResolver = {
   name: 'aspnet',
   languages: ['csharp'],
+  // A Razor page's `@model CheckoutModel` names the PageModel in the
+  // code-behind beside it (`Checkout.cshtml.cs`); these rules look there first.
+  resolveLanguages: ['csharp', 'razor'],
 
   detect(context: ResolutionContext): boolean {
     // Check for .csproj files with ASP.NET references
@@ -67,7 +71,7 @@ export const aspnetResolver: FrameworkResolver = {
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
     // Pattern 1: Controller references
     if (ref.referenceName.endsWith('Controller')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, CONTROLLER_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, CONTROLLER_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -80,7 +84,7 @@ export const aspnetResolver: FrameworkResolver = {
 
     // Pattern 2: Service references (dependency injection)
     if (ref.referenceName.endsWith('Service') || ref.referenceName.startsWith('I') && ref.referenceName.length > 1) {
-      const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, SERVICE_DIRS, context);
+      const result = resolveByNameAndKind(ref, SERVICE_KINDS, SERVICE_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -93,7 +97,7 @@ export const aspnetResolver: FrameworkResolver = {
 
     // Pattern 3: Repository references
     if (ref.referenceName.endsWith('Repository')) {
-      const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, REPO_DIRS, context);
+      const result = resolveByNameAndKind(ref, SERVICE_KINDS, REPO_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -106,7 +110,7 @@ export const aspnetResolver: FrameworkResolver = {
 
     // Pattern 4: Model/Entity references
     if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, MODEL_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, MODEL_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -119,7 +123,7 @@ export const aspnetResolver: FrameworkResolver = {
 
     // Pattern 5: ViewModel references
     if (ref.referenceName.endsWith('ViewModel') || ref.referenceName.endsWith('Dto')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, VIEWMODEL_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, VIEWMODEL_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -191,7 +195,9 @@ export const aspnetResolver: FrameworkResolver = {
     // Minimal APIs: app.MapGet("/path", handler)
     const minimalRegex = /\.Map(Get|Post|Put|Patch|Delete)\s*\(\s*"([^"]+)"\s*,\s*([^,)]+)/g;
     while ((match = minimalRegex.exec(safe)) !== null) {
-      const [, verb, routePath, handlerExpr] = match;
+      const [, verb, rawPath, handlerExpr] = match;
+      // `app.MapGet("api/todos", …)` serves `/api/todos`.
+      const routePath = joinCsPath('', rawPath!);
       const method = verb!.toUpperCase();
       const line = safe.slice(0, match.index).split('\n').length;
 
@@ -272,45 +278,118 @@ export const aspnetResolver: FrameworkResolver = {
       });
     }
 
+    // FastEndpoints: an endpoint class (`: Endpoint<TReq, TRes>`,
+    // `EndpointWithoutRequest`, `Ep.Req<…>.Res<…>`) declares its verb and path in
+    // `Configure()` — `Get("/Contributors")`, `Post(CreateContributorRequest.Route)`
+    // — and handles the request in its own `HandleAsync` / `ExecuteAsync`. A
+    // constant path (`X.Route`, usually in the request's own file) is read in
+    // postExtract; until then the route is named by the expression.
+    const endpointClass = /\bclass\s+([A-Za-z_]\w*)[^{;]*?:\s*(?:FastEndpoints\.)?(?:Endpoint(?:WithoutRequest|WithoutResponse)?\b|Ep\.)/g;
+    while ((match = endpointClass.exec(safe)) !== null) {
+      const body = safe.slice(match.index);
+      const configure = /\bvoid\s+Configure\s*\(\s*\)\s*\{/.exec(body);
+      if (!configure) continue;
+      const handler = /\b(HandleAsync|ExecuteAsync)\s*\(/.exec(body)?.[1];
+      const verbRegex = /\b(Get|Post|Put|Patch|Delete)\s*\(\s*([^;]*?)\s*\)\s*;/g;
+      verbRegex.lastIndex = configure.index;
+      const configureEnd = configure.index + 3000;
+      let verb: RegExpExecArray | null;
+      while ((verb = verbRegex.exec(body)) !== null && verb.index < configureEnd) {
+        const method = verb[1]!.toUpperCase();
+        const args = verb[2]!;
+        // `$"/{nameof(Project)}s"` is `/Projects`.
+        const literals = [...args.matchAll(/"([^"]+)"/g)].map((l) => joinCsPath('', l[1]!.replace(/\{\s*nameof\s*\(\s*(\w+)\s*\)\s*\}/g, '$1')));
+        const constant = /^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/.exec(args);
+        const targets = literals.length > 0 ? literals.map((p) => ({ name: p, key: p })) : constant ? [{ name: `${constant[1]}.${constant[2]}`, key: `const:${constant[1]}.${constant[2]}` }] : [];
+        const line = safe.slice(0, match.index + verb.index).split('\n').length;
+        for (const t of targets) {
+          const id = `route:${filePath}:${line}:${method}:${t.name}`;
+          nodes.push({
+            id, kind: 'route', name: `${method} ${t.name}`,
+            qualifiedName: `${filePath}::fastendpoint:${method}:${t.key}`,
+            filePath, startLine: line, endLine: line, startColumn: 0, endColumn: 0, language: 'csharp', updatedAt: now,
+          });
+          if (handler) references.push({ fromNodeId: id, referenceName: handler, referenceKind: 'references', line, column: 0, filePath, language: 'csharp' });
+        }
+        // A second verb call (`Get(...); Post(...)`) is a second route; stop at Configure's end.
+        if (/\n\s*\}\s*\n/.test(body.slice(configure.index, verb.index))) break;
+      }
+    }
+
     return { nodes, references };
   },
 
-  /**
-   * The endpoint-group prefix convention, read once from the app: the
-   * `MapGroup($"/api/{groupName}")` that registers every `IEndpointGroup`
-   * (or `EndpointGroupBase`) under a head — `/api/` — before the class name.
-   * A group route extracted as `POST /TodoItems` becomes `POST /api/TodoItems`;
-   * a class with its own `RoutePrefix` literal already has its path. Idempotent:
-   * `qualifiedName` keeps the group and the sub-path.
-   */
+  /** Route names only the whole repository can give: FastEndpoints constant paths, endpoint-group prefixes. */
   postExtract(context: ResolutionContext): Node[] {
-    let head: string | null = null;
-    let looked = 0;
-    for (const file of context.getAllFiles()) {
-      if (!file.endsWith('.cs')) continue;
-      const content = context.readFile(file);
-      if (!content || !content.includes('MapGroup')) continue;
-      if (++looked > 400) break;
-      const m = /\$"([^"{]*)\{\s*(?:groupName|type\.Name|name|prefix)\s*\}"/.exec(content) ?? /MapGroup\(\s*\$"([^"{]*)\{/.exec(content);
+    return [...fastEndpointConstantRoutes(context), ...endpointGroupRoutes(context)];
+  },
+};
+
+/**
+ * A FastEndpoints route named by a constant (`Post(CreateContributorRequest.Route)`)
+ * gets the constant's value: `public const string Route = "/Contributors";` in
+ * that class, wherever it is declared. Idempotent — the qualified name keeps the
+ * expression.
+ */
+function fastEndpointConstantRoutes(context: ResolutionContext): Node[] {
+  const updates: Node[] = [];
+  for (const route of context.getNodesByKind('route')) {
+    if (route.language !== 'csharp') continue;
+    const q = /::fastendpoint:([A-Z]+):const:([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/.exec(route.qualifiedName);
+    if (!q) continue;
+    const [, method, owner, field] = q;
+    let value: string | null = null;
+    for (const decl of context.getNodesByName(owner!)) {
+      if (decl.language !== 'csharp' || (decl.kind !== 'class' && decl.kind !== 'struct')) continue;
+      const text = context.readFile(decl.filePath) ?? '';
+      const m = new RegExp(`\\b(?:const\\s+string|static\\s+readonly\\s+string|static\\s+string)\\s+${field}\\s*=\\s*"([^"]+)"`).exec(text);
       if (m) {
-        head = m[1]!;
+        value = m[1]!;
         break;
       }
     }
-    if (!head || head === '/' || head === '') return [];
-    const updates: Node[] = [];
-    for (const route of context.getNodesByKind('route')) {
-      if (route.language !== 'csharp') continue;
-      const q = /::group:([A-Za-z_]\w*):([A-Z]+):(.*)$/.exec(route.qualifiedName);
-      if (!q) continue;
-      const content = context.readFile(route.filePath);
-      if (content && /\bRoutePrefix\s*(?:=>|=)\s*"/.test(content)) continue;
-      const name = `${q[2]} ${joinCsPath(head.replace(/\/+$/, '') + '/' + q[1], q[3]!)}`;
-      if (name !== route.name) updates.push({ ...route, name });
+    if (!value) continue;
+    const name = `${method} ${joinCsPath('', value)}`;
+    if (name !== route.name) updates.push({ ...route, name });
+  }
+  return updates;
+}
+
+/**
+ * The endpoint-group prefix convention, read once from the app: the
+ * `MapGroup($"/api/{groupName}")` that registers every `IEndpointGroup`
+ * (or `EndpointGroupBase`) under a head — `/api/` — before the class name.
+ * A group route extracted as `POST /TodoItems` becomes `POST /api/TodoItems`;
+ * a class with its own `RoutePrefix` literal already has its path. Idempotent:
+ * `qualifiedName` keeps the group and the sub-path.
+ */
+function endpointGroupRoutes(context: ResolutionContext): Node[] {
+  let head: string | null = null;
+  let looked = 0;
+  for (const file of context.getAllFiles()) {
+    if (!file.endsWith('.cs')) continue;
+    const content = context.readFile(file);
+    if (!content || !content.includes('MapGroup')) continue;
+    if (++looked > 400) break;
+    const m = /\$"([^"{]*)\{\s*(?:groupName|type\.Name|name|prefix)\s*\}"/.exec(content) ?? /MapGroup\(\s*\$"([^"{]*)\{/.exec(content);
+    if (m) {
+      head = m[1]!;
+      break;
     }
-    return updates;
-  },
-};
+  }
+  if (!head || head === '/' || head === '') return [];
+  const updates: Node[] = [];
+  for (const route of context.getNodesByKind('route')) {
+    if (route.language !== 'csharp') continue;
+    const q = /::group:([A-Za-z_]\w*):([A-Z]+):(.*)$/.exec(route.qualifiedName);
+    if (!q) continue;
+    const content = context.readFile(route.filePath);
+    if (content && /\bRoutePrefix\s*(?:=>|=)\s*"/.test(content)) continue;
+    const name = `${q[2]} ${joinCsPath(head.replace(/\/+$/, '') + '/' + q[1], q[3]!)}`;
+    if (name !== route.name) updates.push({ ...route, name });
+  }
+  return updates;
+}
 
 /** Join a class-level [Route] prefix and an action's path into one normalized `/path`. */
 function joinCsPath(prefix: string, sub: string): string {
@@ -335,28 +414,12 @@ const VIEWMODEL_DIRS = ['/ViewModels/', '/ViewModel/', '/DTOs/', '/Dto/'];
 const CLASS_KINDS = new Set(['class']);
 const SERVICE_KINDS = new Set(['class', 'interface']);
 
-/**
- * Resolve a symbol by name using indexed queries instead of scanning all files.
- */
+/** A framework name heuristic's pick (see name-heuristic.ts), preferring these folders. */
 function resolveByNameAndKind(
-  name: string,
+  ref: UnresolvedRef,
   kinds: Set<string>,
   preferredDirPatterns: string[],
   context: ResolutionContext,
 ): string | null {
-  const candidates = context.getNodesByName(name);
-  if (candidates.length === 0) return null;
-
-  const kindFiltered = candidates.filter((n) => kinds.has(n.kind));
-  if (kindFiltered.length === 0) return null;
-
-  // Prefer candidates in framework-conventional directories
-  const preferred = kindFiltered.filter((n) =>
-    preferredDirPatterns.some((d) => n.filePath.includes(d))
-  );
-
-  if (preferred.length > 0) return preferred[0]!.id;
-
-  // Fall back to any match
-  return kindFiltered[0]!.id;
+  return pickByNameAndKind(ref, kinds, (f) => preferredDirPatterns.some((d) => f.includes(d)), context);
 }
diff --git a/src/resolution/frameworks/expo-modules.ts b/src/resolution/frameworks/expo-modules.ts
index a9f60174ad..c70d1d5acd 100644
--- a/src/resolution/frameworks/expo-modules.ts
+++ b/src/resolution/frameworks/expo-modules.ts
@@ -42,7 +42,12 @@ import type { Node } from '../../types';
 import {
   FrameworkExtractionResult,
   FrameworkResolver,
+  ResolutionContext,
+  ResolvedRef,
+  UnresolvedRef,
 } from '../types';
+import { resolveImportPath } from '../import-resolver';
+import { stripCommentsForRegex } from '../strip-comments';
 
 /**
  * Match `Function("name")`, `AsyncFunction("name")`, or `Property("name")`
@@ -196,3 +201,103 @@ export const expoModulesResolver: FrameworkResolver = {
     return null;
   },
 };
+
+// =============================================================================
+// The JS side: `ExpoCamera.scanFromURLAsync(…)` → the module's function
+// =============================================================================
+
+/** `requireNativeModule('ExpoCamera')`, typed or not, optional or not. */
+const REQUIRE_NATIVE = /\brequire(?:Optional)?NativeModule\s*(?:<\s*([A-Za-z_$][\w$]*)[^>]*>)?\s*\(\s*['"]([A-Za-z_$][\w$]*)['"]\s*\)/;
+
+interface NativeBinding {
+  /** The `Name("…")` the module declares. */
+  module: string;
+  /** The declared JS type, from `requireNativeModule<CameraNativeModule>(…)`. */
+  type: string | null;
+  /** The file the binding (and its type) is written in. */
+  file: string;
+}
+
+const bindingMemo = new WeakMap<ResolutionContext, Map<string, NativeBinding | null>>();
+
+/**
+ * What `name` is bound to in `file`: `const X = requireNativeModule('N')`
+ * here, or the import of a module whose default export (or a named export)
+ * is one — expo-camera's `import CameraManager from './ExpoCameraManager'`,
+ * whose whole body is `export default requireNativeModule<CameraNativeModule>('ExpoCamera')`.
+ */
+function nativeBinding(name: string, file: string, context: ResolutionContext): NativeBinding | null {
+  let memo = bindingMemo.get(context);
+  if (!memo) bindingMemo.set(context, (memo = new Map()));
+  const key = `${file}\0${name}`;
+  if (memo.has(key)) return memo.get(key)!;
+  let found: NativeBinding | null = null;
+  const own = context.readFile(file);
+  if (own && own.includes('NativeModule')) {
+    const local = new RegExp(String.raw`\b(?:const|let|var)\s+${name}\s*(?::[^=]+)?=\s*` + REQUIRE_NATIVE.source).exec(stripCommentsForRegex(own, 'typescript'));
+    if (local) found = { type: local[1] ?? null, module: local[2]!, file };
+  }
+  if (!found) {
+    const language = /\.tsx$/.test(file) ? 'tsx' : /\.[cm]?ts$/.test(file) ? 'typescript' : /\.jsx$/.test(file) ? 'jsx' : 'javascript';
+    const binding = context.getImportMappings(file, language).find((m) => m.localName === name);
+    const target = binding && binding.source.startsWith('.') ? resolveImportPath(binding.source, file, language, context) : null;
+    const content = target ? context.readFile(target) : null;
+    if (target && content && content.includes('NativeModule')) {
+      const safe = stripCommentsForRegex(content, 'typescript');
+      const pattern = binding!.isDefault
+        ? new RegExp(String.raw`\bexport\s+default\s+` + REQUIRE_NATIVE.source)
+        : new RegExp(String.raw`\bexport\s+(?:const|let)\s+${binding!.exportedName}\s*(?::[^=]+)?=\s*` + REQUIRE_NATIVE.source);
+      const m = pattern.exec(safe);
+      if (m) found = { type: m[1] ?? null, module: m[2]!, file: target };
+    }
+  }
+  memo.set(key, found);
+  return found;
+}
+
+/**
+ * JS calls into an Expo module, bound by the module's NAME, not by the
+ * method name alone: expo-camera calls its module `CameraManager`, so
+ * `CameraManager.isAvailableAsync()` went to `CameraView`'s own static
+ * `isAvailableAsync` in the same file. The native functions the module
+ * declares are the targets — Swift first, Kotlin beside it — and when it
+ * declares none of that name, the method on the type the binding is given
+ * (`requireNativeModule<CameraNativeModule>`).
+ */
+export const expoModulesJsResolver: FrameworkResolver = {
+  name: 'expo-modules-js',
+  languages: ['typescript', 'tsx', 'javascript', 'jsx'],
+
+  detect(context) {
+    return expoModulesResolver.detect(context);
+  },
+
+  resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    if (ref.referenceKind !== 'calls') return null;
+    const m = /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(ref.referenceName);
+    if (!m) return null;
+    const binding = nativeBinding(m[1]!, ref.filePath, context);
+    if (!binding) return null;
+    const fn = m[2]!;
+    const declared = context
+      .getNodesByName(fn)
+      .filter((n) => n.id.startsWith('expo-module:') && n.qualifiedName.endsWith(`::${binding.module}.${fn}`))
+      .sort((a, b) => (a.language === 'swift' ? 0 : 1) - (b.language === 'swift' ? 0 : 1));
+    if (declared.length > 0) {
+      return {
+        original: ref,
+        targetNodeId: declared[0]!.id,
+        ...(declared.length > 1 ? { alsoTargets: declared.slice(1).map((n) => ({ targetNodeId: n.id })) } : {}),
+        confidence: 0.95,
+        resolvedBy: 'framework',
+      };
+    }
+    if (binding.type) {
+      const typed = context
+        .getNodesByName(fn)
+        .find((n) => (n.kind === 'method' || n.kind === 'property' || n.kind === 'field') && n.qualifiedName.endsWith(`${binding.type}::${fn}`));
+      if (typed) return { original: ref, targetNodeId: typed.id, confidence: 0.9, resolvedBy: 'framework' };
+    }
+    return null;
+  },
+};
diff --git a/src/resolution/frameworks/expo-router.ts b/src/resolution/frameworks/expo-router.ts
index 2f513e3fad..e6641a4608 100644
--- a/src/resolution/frameworks/expo-router.ts
+++ b/src/resolution/frameworks/expo-router.ts
@@ -70,6 +70,8 @@ export function routePathForFile(filePath: string): string | null {
   const segs = bare.split('/');
   if (segs.includes('__tests__') || segs.includes('__mocks__')) return null;
   const base = segs[segs.length - 1]!;
+  // `hello+api.ts` is an endpoint (`apiRoutePathForFile`), not a screen.
+  if (base.endsWith('+api')) return null;
   // `_layout` (and any other `_`-prefixed file) is not navigable. `+not-found`
   // is a real screen; the other `+` files (`+html`, `+native-intent`) are not.
   if (base.startsWith('_')) return null;
@@ -79,6 +81,26 @@ export function routePathForFile(filePath: string): string | null {
   return '/' + kept.join('/');
 }
 
+/**
+ * An API route's path — `app/blog/og-image/[post]+api.ts` is
+ * `/blog/og-image/:post`, written the way every server route is so a
+ * client's `fetch('/blog/og-image/…')` can find it. Null for any other file.
+ */
+export function apiRoutePathForFile(filePath: string): string | null {
+  const dir = APP_DIR.exec(filePath);
+  if (!dir) return null;
+  const rel = filePath.slice(dir.index + dir[0].length);
+  const ext = /\.(tsx|ts|jsx|js|mjs|cjs)$/.exec(rel);
+  if (!ext) return null;
+  const bare = rel.slice(0, ext.index);
+  if (!bare.endsWith('+api')) return null;
+  const segs = bare.slice(0, -'+api'.length).split('/').filter((seg) => seg.length > 0 && !(seg.startsWith('(') && seg.endsWith(')')));
+  if (segs[segs.length - 1] === 'index') segs.pop();
+  return '/' + segs.map((seg) => seg.replace(/^\[\.\.\.(.+)\]$/, ':$1*').replace(/^\[(.+)\]$/, ':$1')).join('/');
+}
+
+const API_METHODS = 'GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS';
+
 function languageForFile(filePath: string): Language {
   const ext = ROUTE_EXT.exec(filePath)?.[1];
   switch (ext) {
@@ -588,6 +610,15 @@ export interface RouteTable {
 
 const tables = new Map<string, RouteTable>();
 
+/**
+ * True for this framework's own route nodes: the ones whose name IS the path
+ * derived from their file. Express/SvelteKit routes in the same project name
+ * themselves differently and never match.
+ */
+function isScreenRoute(node: Node): boolean {
+  return routePathForFile(node.filePath) === node.name;
+}
+
 export function routeTable(context: ResolutionContext): RouteTable {
   const all = context.getNodesByKind('route');
   const key = context.getProjectRoot();
@@ -596,10 +627,7 @@ export function routeTable(context: ResolutionContext): RouteTable {
   const exact = new Map<string, Node>();
   const dynamic: RouteEntry[] = [];
   for (const node of all) {
-    // Only this framework's own route nodes: the ones whose name IS the path
-    // derived from their file. Express/SvelteKit routes in the same project
-    // name themselves differently and never match.
-    if (routePathForFile(node.filePath) !== node.name) continue;
+    if (!isScreenRoute(node)) continue;
     exact.set(node.name, node);
     if (node.name.includes('[')) dynamic.push({ node, segs: node.name.split('/').slice(1) });
   }
@@ -713,6 +741,7 @@ function scoreMatch(href: string[], route: string[]): number | null {
 export const expoRouterResolver: FrameworkResolver = {
   name: 'expo-router',
   languages: [...ROUTE_LANGUAGES],
+  appDependencies: ['expo-router'],
 
   detect(context: ResolutionContext): boolean {
     if (dependsOn(context, 'expo-router')) return true;
@@ -726,7 +755,49 @@ export const expoRouterResolver: FrameworkResolver = {
     return NAV_METHOD.test(name);
   },
 
+  navigation: {
+    // A project's own wrapper (`safePush`) is left out: its tail is its own
+    // name, which the failed-tail index cannot find by suffix.
+    tails: ['push', 'replace', 'navigate', 'dismissTo'],
+    // One table for the whole project, and any file's call matches against it.
+    scope: (route) => (isScreenRoute(route) ? [''] : null),
+  },
+
   extract(filePath: string, content: string) {
+    const apiPath = apiRoutePathForFile(filePath);
+    if (apiPath !== null) {
+      // `export async function GET(request) {…}` / `export const POST = …` — one endpoint per method.
+      const language = languageForFile(filePath);
+      const stripped = stripCommentsForRegex(content, 'typescript');
+      const nodes: Node[] = [];
+      const references: UnresolvedRef[] = [];
+      const seen = new Set<string>();
+      const decl = new RegExp(`\\bexport\\s+(?:async\\s+)?function\\s+(${API_METHODS})\\b|\\bexport\\s+(?:const|let)\\s+(${API_METHODS})\\s*=`, 'g');
+      let m: RegExpExecArray | null;
+      while ((m = decl.exec(stripped)) !== null) {
+        const method = (m[1] ?? m[2])!;
+        if (seen.has(method)) continue;
+        seen.add(method);
+        const line = stripped.slice(0, m.index).split('\n').length;
+        const node: Node = {
+          id: `route:${filePath}:${line}:${method}:${apiPath}`,
+          kind: 'route',
+          name: `${method} ${apiPath}`,
+          qualifiedName: `${filePath}::${method}:${apiPath}`,
+          filePath,
+          startLine: line,
+          endLine: line,
+          startColumn: 0,
+          endColumn: m[0].length,
+          language,
+          isExported: true,
+          updatedAt: Date.now(),
+        };
+        nodes.push(node);
+        references.push({ fromNodeId: node.id, referenceName: method, referenceKind: 'references', line, column: 0, filePath, language, candidates: [method] });
+      }
+      return { nodes, references };
+    }
     const routePath = routePathForFile(filePath);
     if (routePath === null) return { nodes: [], references: [] };
     const language = languageForFile(filePath);
diff --git a/src/resolution/frameworks/express.ts b/src/resolution/frameworks/express.ts
index 7aaa8af7f0..c2e1f579ad 100644
--- a/src/resolution/frameworks/express.ts
+++ b/src/resolution/frameworks/express.ts
@@ -49,6 +49,30 @@ const RESERVED_CALLS = new Set([
   'Date', 'Math', 'JSON', 'Promise', 'require', 'fail', 'redirect',
 ]);
 
+/**
+ * The calls an inline handler's body makes, each once, framework noise aside.
+ * A member call keeps its receiver (`userService.find`, `c.text`) so it
+ * resolves as one: bare, hono's `c.text('…')` matched its client's
+ * `ClientResponse.text` 423 times. A member of an expression (`a.b().c(`)
+ * names nothing this can follow.
+ */
+function handlerCallNames(body: string): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const callRe = /((?:[A-Za-z_$][\w$]*\s*\??\.\s*)*)([A-Za-z_$][\w$]*)\s*\(/g;
+  let cm: RegExpExecArray | null;
+  while ((cm = callRe.exec(body)) !== null) {
+    const method = cm[2]!;
+    const receiver = cm[1]!.replace(/\s|\?/g, '').replace(/\.$/, '');
+    if (!receiver && /\.\s*$/.test(body.slice(0, cm.index))) continue;
+    const name = receiver ? `${receiver}.${method}` : method;
+    if (seen.has(name) || RESERVED_CALLS.has(method)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
+
 /**
  * The replies an inline handler makes — `res.status(404).json({…})`,
  * `res.json(user)`, `reply.send(…)`, `ctx.body = …` aside — as references the
@@ -104,9 +128,16 @@ export const expressResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // A JS/TS module reaches another file's middleware, controller or service
+    // only through an `import` / `require` — the import resolver's — never by
+    // name: SvelteKit's remote functions' `validate(arg)` went to the config
+    // loader's `validate` in another package. The patterns below stay for the
+    // file's own declarations.
+    const sameFile = (id: string | null): string | null =>
+      id !== null && context.getNodeById?.(id)?.filePath === ref.filePath ? id : null;
     // Pattern 1: Middleware references
     if (isMiddlewareName(ref.referenceName)) {
-      const result = resolveMiddleware(ref.referenceName, context);
+      const result = sameFile(resolveMiddleware(ref.referenceName, context, ref.filePath));
       if (result) {
         return {
           original: ref,
@@ -121,7 +152,7 @@ export const expressResolver: FrameworkResolver = {
     const controllerMatch = ref.referenceName.match(/^(\w+)Controller\.(\w+)$/);
     if (controllerMatch) {
       const [, controller, method] = controllerMatch;
-      const result = resolveControllerMethod(controller!, method!, context);
+      const result = sameFile(resolveControllerMethod(controller!, method!, context));
       if (result) {
         return {
           original: ref,
@@ -136,7 +167,7 @@ export const expressResolver: FrameworkResolver = {
     const serviceMatch = ref.referenceName.match(/^(\w+)(Service|Helper|Utils?)\.(\w+)$/);
     if (serviceMatch) {
       const [, name, suffix, method] = serviceMatch;
-      const result = resolveServiceMethod(name! + suffix!, method!, context);
+      const result = sameFile(resolveServiceMethod(name! + suffix!, method!, context));
       if (result) {
         return {
           original: ref,
@@ -186,32 +217,16 @@ export const expressResolver: FrameworkResolver = {
       const openParen = safe.indexOf('(', match.index);
       const closeParen = openParen >= 0 ? matchDelim(safe, openParen, '(', ')') : -1;
       const args = closeParen > openParen ? safe.slice(openParen + 1, closeParen) : '';
-      const arrowAt = args.indexOf('=>');
-
-      if (arrowAt >= 0) {
-        // Inline arrow handler (`router.post('/x', async (req,res) => {…})`). The
-        // arrow is anonymous, so its body — the actual request→service flow — would
-        // be lost. Attribute the body's calls to the route node as `calls` edges so
-        // `trace(route, service)` connects. Body = balanced `{…}` after `=>`, or the
-        // single-expression tail for `=> expr` arrows.
-        const afterArrow = args.slice(arrowAt + 2);
-        const braceAt = afterArrow.indexOf('{');
-        let body = afterArrow;
-        let bodyStart = openParen + 1 + arrowAt + 2;
-        if (braceAt >= 0 && afterArrow.slice(0, braceAt).trim() === '') {
-          const end = matchDelim(afterArrow, braceAt, '{', '}');
-          if (end > braceAt) {
-            body = afterArrow.slice(braceAt + 1, end);
-            bodyStart += braceAt + 1;
-          }
-        }
-        const callRe = /\b([A-Za-z_$][\w$]*)\s*\(/g;
-        const seen = new Set<string>();
-        let cm: RegExpExecArray | null;
-        while ((cm = callRe.exec(body)) !== null) {
-          const name = cm[1]!;
-          if (seen.has(name) || RESERVED_CALLS.has(name)) continue;
-          seen.add(name);
+      const inline = inlineHandlerBody(args);
+
+      if (inline) {
+        // Inline handler (`router.post('/x', async (req,res) => {…})`,
+        // `app.get('/x', function (req, res) {…})`). It is anonymous, so its
+        // body — the actual request→service flow — would be lost. Attribute the
+        // body's calls to the route node as `calls` edges so
+        // `trace(route, service)` connects.
+        const bodyStart = openParen + 1 + inline.start;
+        for (const name of handlerCallNames(inline.body)) {
           references.push({
             fromNodeId: routeNode.id,
             referenceName: name,
@@ -222,7 +237,7 @@ export const expressResolver: FrameworkResolver = {
             language: lang,
           });
         }
-        references.push(...replyRefs(safe, bodyStart, bodyStart + body.length, routeNode.id, filePath, lang));
+        references.push(...replyRefs(safe, bodyStart, bodyStart + inline.body.length, routeNode.id, filePath, lang));
       } else {
         // Named handler: the LAST comma-separated arg (earlier ones are middleware).
         const parts = args.split(',').map((s) => s.trim()).filter(Boolean);
@@ -271,17 +286,13 @@ export const expressResolver: FrameworkResolver = {
           updatedAt: now,
         };
         nodes.push(routeNode);
-        if (args.includes('=>')) {
-          const callRe = /\b([A-Za-z_$][\w$]*)\s*\(/g;
-          const seen = new Set<string>();
-          let cm: RegExpExecArray | null;
-          while ((cm = callRe.exec(args)) !== null) {
-            const name = cm[1]!;
-            if (seen.has(name) || RESERVED_CALLS.has(name)) continue;
-            seen.add(name);
+        const inline = inlineHandlerBody(args);
+        if (inline) {
+          for (const name of handlerCallNames(inline.body)) {
             references.push({ fromNodeId: routeNode.id, referenceName: name, referenceKind: 'calls', line, column: 0, filePath, language: lang });
           }
-          references.push(...replyRefs(safe, openParen + 1, closeParen, routeNode.id, filePath, lang));
+          const bodyStart = openParen + 1 + inline.start;
+          references.push(...replyRefs(safe, bodyStart, bodyStart + inline.body.length, routeNode.id, filePath, lang));
         } else {
           const parts = splitTopLevel(args).map((s) => s.trim()).filter(Boolean);
           const last = parts[parts.length - 1];
@@ -411,6 +422,48 @@ function splitTopLevel(args: string): string[] {
   return out;
 }
 
+/**
+ * The body of a handler written inline as a registration's LAST argument — an
+ * arrow (`async (req, res) => {…}`, `req => …`) or a function expression
+ * (`function (req, res) {…}`, the form Express's own examples use), bare or
+ * inside a wrapper call (`asyncHandler(async (req, res) => {…})`). `start` is
+ * the body's offset into `args`. Null when the last argument names a handler
+ * instead: an inline middleware before a named handler is not the handler.
+ */
+function inlineHandlerBody(args: string): { body: string; start: number } | null {
+  // A trailing comma (Prettier's default) leaves an empty last part.
+  const parts = splitTopLevel(args);
+  let lastStart = args.length;
+  let last = '';
+  for (let i = parts.length - 1, end = args.length; i >= 0; i--) {
+    const start = end - parts[i]!.length;
+    if (parts[i]!.trim() !== '') {
+      last = parts[i]!;
+      lastStart = start;
+      break;
+    }
+    end = start - 1;
+  }
+  const arrowAt = last.indexOf('=>');
+  const fn = /(?:^|[^\w$.])function\b\s*\*?\s*[\w$]*\s*\(/.exec(last);
+  if (fn && (arrowAt < 0 || fn.index < arrowAt)) {
+    const open = fn.index + fn[0].length - 1;
+    const close = matchDelim(last, open, '(', ')');
+    const brace = close > open ? last.indexOf('{', close) : -1;
+    const end = brace >= 0 ? matchDelim(last, brace, '{', '}') : -1;
+    if (end < 0) return null;
+    return { body: last.slice(brace + 1, end), start: lastStart + brace + 1 };
+  }
+  if (arrowAt < 0) return null;
+  const afterArrow = last.slice(arrowAt + 2);
+  const braceAt = afterArrow.indexOf('{');
+  if (braceAt >= 0 && afterArrow.slice(0, braceAt).trim() === '') {
+    const end = matchDelim(afterArrow, braceAt, '{', '}');
+    if (end > braceAt) return { body: afterArrow.slice(braceAt + 1, end), start: lastStart + arrowAt + 2 + braceAt + 1 };
+  }
+  return { body: afterArrow, start: lastStart + arrowAt + 2 };
+}
+
 /** `/api` + `/users` → `/api/users`; `/api/` + `/` → `/api`. */
 function joinPaths(prefix: string, path: string): string {
   const a = prefix.replace(/\/+$/, '');
@@ -461,12 +514,20 @@ function isMiddlewareName(name: string): boolean {
 /**
  * Resolve middleware reference using name-based lookup
  */
+/** Node kinds a middleware can be declared as. */
+const MIDDLEWARE_KINDS: ReadonlySet<string> = new Set(['function', 'method', 'variable', 'constant', 'class']);
+
 function resolveMiddleware(
   name: string,
-  context: ResolutionContext
+  context: ResolutionContext,
+  fromFile?: string,
 ): string | null {
-  // Try exact name first
-  const candidates = context.getNodesByName(name);
+  // Try exact name first — the calling file's own first. A middleware is a
+  // declaration (a function, a value, a class), never the file's import of a
+  // package (`import cors from 'cors'`) nor a heading or a module node.
+  const candidates = context.getNodesByName(name)
+    .filter((n) => MIDDLEWARE_KINDS.has(n.kind))
+    .sort((a, b) => Number(b.filePath === fromFile) - Number(a.filePath === fromFile));
   const match = candidates.find((n) =>
     n.name.toLowerCase() === name.toLowerCase() ||
     n.name.toLowerCase() === name.replace(/Middleware$/i, '').toLowerCase()
@@ -476,7 +537,7 @@ function resolveMiddleware(
   // Try without Middleware suffix
   const baseName = name.replace(/Middleware$/i, '');
   if (baseName !== name) {
-    const baseCandidates = context.getNodesByName(baseName);
+    const baseCandidates = context.getNodesByName(baseName).filter((n) => MIDDLEWARE_KINDS.has(n.kind));
     const MIDDLEWARE_DIRS = ['/middleware/', '/middlewares/'];
     const preferred = baseCandidates.filter((n) =>
       MIDDLEWARE_DIRS.some((d) => n.filePath.includes(d))
diff --git a/src/resolution/frameworks/fabric.ts b/src/resolution/frameworks/fabric.ts
index 308feca686..e5c15e835c 100644
--- a/src/resolution/frameworks/fabric.ts
+++ b/src/resolution/frameworks/fabric.ts
@@ -50,7 +50,7 @@ import {
 } from '../types';
 
 const CODEGEN_DECL_RE =
-  /codegenNativeComponent\s*(?:<[^>]+>)?\s*\(\s*['"]([A-Za-z_][A-Za-z0-9_]*)['"]/g;
+  /\b(codegenNativeComponent|requireNativeComponent)\s*(?:<[^>]+>)?\s*\(\s*['"]([A-Za-z_][A-Za-z0-9_]*)['"]/g;
 
 /**
  * Legacy Paper view manager macros — older RN libs (still very common,
@@ -95,7 +95,9 @@ function deriveComponentNameFromManager(className: string): string {
  * spec signal.
  */
 function isFabricSpec(source: string): boolean {
-  return source.includes('codegenNativeComponent');
+  // A Paper-era module names its native view the same way:
+  // segmented-control's `module.exports = requireNativeComponent('RNCSegmentedControl')`.
+  return source.includes('codegenNativeComponent') || source.includes('requireNativeComponent');
 }
 
 /**
@@ -299,7 +301,8 @@ function extractFabricNodes(filePath: string, source: string): Node[] {
   CODEGEN_DECL_RE.lastIndex = 0;
   let m: RegExpExecArray | null;
   while ((m = CODEGEN_DECL_RE.exec(source)) !== null) {
-    const componentName = m[1]!;
+    const declaredWith = m[1]!;
+    const componentName = m[2]!;
     const before = source.slice(0, m.index);
     const startLine = before.split('\n').length;
     const startColumn = before.length - before.lastIndexOf('\n') - 1;
@@ -314,15 +317,14 @@ function extractFabricNodes(filePath: string, source: string): Node[] {
       name: componentName,
       qualifiedName: `${filePath}::${componentName}`,
       filePath,
-      // The spec file is .ts or .tsx; use the file's apparent language
-      // by extension. Trim to a known Language value.
-      language: filePath.endsWith('.tsx') ? 'tsx' : 'typescript',
+      // The spec file's language by extension (a Paper module is often Flow `.js`).
+      language: filePath.endsWith('.tsx') ? 'tsx' : /\.[cm]?ts$/.test(filePath) ? 'typescript' : filePath.endsWith('.jsx') ? 'jsx' : 'javascript',
       startLine,
       endLine: startLine,
       startColumn,
-      endColumn: startColumn + 'codegenNativeComponent'.length,
-      docstring: `Fabric/Codegen native component '${componentName}'`,
-      signature: `codegenNativeComponent<NativeProps>('${componentName}')`,
+      endColumn: startColumn + declaredWith.length,
+      docstring: declaredWith === 'codegenNativeComponent' ? `Fabric/Codegen native component '${componentName}'` : `Native component '${componentName}' (requireNativeComponent)`,
+      signature: declaredWith === 'codegenNativeComponent' ? `codegenNativeComponent<NativeProps>('${componentName}')` : `requireNativeComponent('${componentName}')`,
       isExported: true,
       updatedAt: now,
     });
@@ -363,7 +365,7 @@ function extractFabricNodes(filePath: string, source: string): Node[] {
 
 export const fabricViewResolver: FrameworkResolver = {
   name: 'fabric-view',
-  languages: ['typescript', 'tsx', 'objc', 'java', 'kotlin'],
+  languages: ['typescript', 'tsx', 'javascript', 'jsx', 'objc', 'java', 'kotlin'],
 
   detect(context) {
     // Root package.json is the common case. The indexer only tracks
@@ -392,7 +394,7 @@ export const fabricViewResolver: FrameworkResolver = {
     // Pick the right extractor by file language. The framework registry
     // already filters by `languages` so we only see relevant files.
     let nodes: Node[] = [];
-    if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
+    if (/\.(?:[cm]?[jt]s|[jt]sx)$/.test(filePath)) {
       nodes = extractFabricNodes(filePath, source);
     } else if (filePath.endsWith('.m') || filePath.endsWith('.mm')) {
       nodes = extractLegacyViewManagerNodes(filePath, source);
diff --git a/src/resolution/frameworks/go.ts b/src/resolution/frameworks/go.ts
index 168d4b22c3..58453a9ee3 100644
--- a/src/resolution/frameworks/go.ts
+++ b/src/resolution/frameworks/go.ts
@@ -7,6 +7,8 @@
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
+import { GO_TYPE_KINDS, isGoBareName } from '../name-matcher';
+import { pickByNameAndKind } from './name-heuristic';
 
 export const goResolver: FrameworkResolver = {
   name: 'go',
@@ -25,9 +27,24 @@ export const goResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // The patterns below guess a declaration from the shape of a name, but Go
+    // reads a name from one package only: one written bare from the
+    // reference's own, `pkg.Node` from that import's (the import resolver's
+    // job), `x[i].Error()` from whatever type `x[i]` has. So they guess only
+    // for a bare name, only in its own package, and never for an embedded
+    // type, which name matching and the import resolver work out. Past that,
+    // promql/parser's `Node` parameters and embeddings went to
+    // discovery/kubernetes's struct `Node` beside the package's own `Node`
+    // interface, `apiv1.Node` to the struct in the same file, etcd's `Client`
+    // embedding its own `Lease` interface to the server's `Lease` struct, and
+    // every `.String()` called through an expression to the struct
+    // `promql.String`, as an instantiation.
+    if (ref.referenceKind === 'extends' || ref.referenceKind === 'implements') return null;
+    if (!isGoBareName(ref, context)) return null;
+
     // Pattern 1: Handler references
     if (ref.referenceName.endsWith('Handler') || ref.referenceName.startsWith('Handle')) {
-      const result = resolveByNameAndKind(ref.referenceName, 'function', HANDLER_DIRS, context);
+      const result = resolveInOwnPackage(ref, FUNCTION_KINDS, context);
       if (result) {
         return {
           original: ref,
@@ -40,7 +57,7 @@ export const goResolver: FrameworkResolver = {
 
     // Pattern 2: Service/Repository references
     if (ref.referenceName.endsWith('Service') || ref.referenceName.endsWith('Repository') || ref.referenceName.endsWith('Store')) {
-      const result = resolveByNameAndKind(ref.referenceName, null, SERVICE_DIRS, context, SERVICE_KINDS);
+      const result = resolveInOwnPackage(ref, SERVICE_KINDS, context);
       if (result) {
         return {
           original: ref,
@@ -53,7 +70,7 @@ export const goResolver: FrameworkResolver = {
 
     // Pattern 3: Middleware references
     if (ref.referenceName.endsWith('Middleware') || ref.referenceName.startsWith('Auth') || ref.referenceName.startsWith('Log')) {
-      const result = resolveByNameAndKind(ref.referenceName, 'function', MIDDLEWARE_DIRS, context);
+      const result = resolveInOwnPackage(ref, FUNCTION_KINDS, context);
       if (result) {
         return {
           original: ref,
@@ -64,9 +81,12 @@ export const goResolver: FrameworkResolver = {
       }
     }
 
-    // Pattern 4: Model/Entity references (typically PascalCase structs)
+    // Pattern 4: Model/Entity references — a PascalCase type of any kind: the
+    // package's `Node` interface or `Entry` type, not only its structs. Left
+    // to name matching, the result type of `func (f *fanout) Appender(…)
+    // Appender` linked to the method the line declares.
     if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, 'struct', MODEL_DIRS, context);
+      const result = resolveInOwnPackage(ref, GO_TYPE_KINDS, context);
       if (result) {
         return {
           original: ref,
@@ -165,43 +185,17 @@ function extractGoTailIdent(expr: string): string | null {
   return m ? m[1]! : null;
 }
 
-// Directory patterns for framework resolution
-const HANDLER_DIRS = ['handler', 'handlers', 'api', 'routes', 'controller', 'controllers'];
-const SERVICE_DIRS = ['service', 'services', 'repository', 'store', 'pkg'];
-const MIDDLEWARE_DIRS = ['middleware', 'middlewares'];
-const MODEL_DIRS = ['model', 'models', 'entity', 'entities', 'domain', 'pkg'];
-const SERVICE_KINDS = new Set(['struct', 'interface']);
+const FUNCTION_KINDS: ReadonlySet<string> = new Set(['function']);
+const SERVICE_KINDS: ReadonlySet<string> = new Set(['struct', 'interface']);
 
 /**
- * Resolve a symbol by name using indexed queries instead of scanning all files.
- * Uses getNodesByName (O(log n) indexed lookup) instead of iterating every file.
+ * A framework name heuristic's pick (see name-heuristic.ts) among the
+ * declarations of the reference's own package — its directory — its own
+ * file's first. No folder convention applies: Go never reads a bare name from
+ * another package, a dot import aside.
  */
-function resolveByNameAndKind(
-  name: string,
-  kind: string | null,
-  preferredDirs: string[],
-  context: ResolutionContext,
-  kinds?: Set<string>
-): string | null {
-  const candidates = context.getNodesByName(name);
-  if (candidates.length === 0) return null;
-
-  // Filter by kind
-  const kindFiltered = candidates.filter((n) => {
-    if (kinds) return kinds.has(n.kind);
-    if (kind) return n.kind === kind;
-    return true;
-  });
-
-  if (kindFiltered.length === 0) return null;
-
-  // Prefer candidates in framework-conventional directories
-  const preferred = kindFiltered.filter((n) =>
-    preferredDirs.some((d) => n.filePath.includes(`/${d}/`))
-  );
-
-  if (preferred.length > 0) return preferred[0]!.id;
-
-  // Fall back to any match
-  return kindFiltered[0]!.id;
+function resolveInOwnPackage(ref: UnresolvedRef, kinds: ReadonlySet<string>, context: ResolutionContext): string | null {
+  const dir = ref.filePath.slice(0, ref.filePath.lastIndexOf('/') + 1);
+  const inPackage = (n: Node) => n.filePath.startsWith(dir) && !n.filePath.slice(dir.length).includes('/');
+  return pickByNameAndKind(ref, kinds, () => false, context, { accept: inPackage });
 }
diff --git a/src/resolution/frameworks/index.ts b/src/resolution/frameworks/index.ts
index 4c96e186e0..da8f7b0ecf 100644
--- a/src/resolution/frameworks/index.ts
+++ b/src/resolution/frameworks/index.ts
@@ -15,9 +15,10 @@ import { nextjsResolver } from './nextjs';
 import { reactRouterResolver } from './react-router';
 import { tanstackRouterResolver } from './tanstack-router';
 import { vueRouterResolver } from './vue-router';
+import { angularRouterResolver } from './angular-router';
 import { svelteKitRouterResolver } from './sveltekit-router';
 import { svelteResolver } from './svelte';
-import { vueResolver } from './vue';
+import { vueResolver, nuxtResolver } from './vue';
 import { astroResolver } from './astro';
 import { djangoResolver, flaskResolver, fastapiResolver } from './python';
 import { railsResolver } from './ruby';
@@ -30,7 +31,7 @@ import { aspnetResolver } from './csharp';
 import { swiftUIResolver, uikitResolver, vaporResolver } from './swift';
 import { swiftObjcBridgeResolver } from './swift-objc';
 import { reactNativeBridgeResolver } from './react-native';
-import { expoModulesResolver } from './expo-modules';
+import { expoModulesResolver, expoModulesJsResolver } from './expo-modules';
 import { expoRouterResolver } from './expo-router';
 import { fabricViewResolver } from './fabric';
 import { cicsResolver } from './cics';
@@ -57,8 +58,11 @@ const FRAMEWORK_RESOLVERS: FrameworkResolver[] = [
   // SvelteKit — `src/routes/**/+page.svelte` routes are `svelteResolver`'s; `goto('/x')` / `redirect(303, '/x')` → navigates edges
   svelteKitRouterResolver,
   vueResolver,
+  // Nuxt — `pages/**` screens, `server/api/**` endpoints and `middleware/`, in a Nuxt app only
+  nuxtResolver,
   // Vue Router — `createRouter({ routes })` → route nodes; `router.push({ name })` / `router.push('/x')` → navigates edges
   vueRouterResolver,
+  angularRouterResolver,
   astroResolver,
   // Python
   djangoResolver,
@@ -86,6 +90,8 @@ const FRAMEWORK_RESOLVERS: FrameworkResolver[] = [
   reactNativeBridgeResolver,
   // Expo Modules — Function/AsyncFunction/Property DSL on Swift/Kotlin
   expoModulesResolver,
+  // Expo Modules, JS side — `M.fn()` on a `requireNativeModule('N')` binding → module N's `fn`
+  expoModulesJsResolver,
   // Expo Router — `app/` screen files → route nodes; `router.push('/x')` → navigates edges
   expoRouterResolver,
   // React Native Fabric / Codegen view components — TS spec → component nodes
@@ -136,6 +142,27 @@ export function getApplicableFrameworks(
   );
 }
 
+/**
+ * Filter a list of detected frameworks down to ones whose `resolve()` reads a
+ * reference written in `language`: its `resolveLanguages`, else its
+ * `languages`. Frameworks that declare neither are treated as universal.
+ *
+ * A framework's conventions are its languages': Express's `logger` middleware
+ * rule took a Go method's `*zap.Logger` result type for the method itself.
+ * Bridges list the language their references are written in — the React
+ * Native bridge JS, the Swift ↔ Objective-C bridge both, Drupal the
+ * `routing.yml` it reads controllers from.
+ */
+export function getResolvingFrameworks(
+  detected: FrameworkResolver[],
+  language: Language
+): FrameworkResolver[] {
+  return detected.filter((fw) => {
+    const languages = fw.resolveLanguages ?? fw.languages;
+    return !languages || languages.includes(language);
+  });
+}
+
 /**
  * Register a custom framework resolver
  */
@@ -157,9 +184,10 @@ export { reactResolver } from './react';
 export { reactRouterResolver } from './react-router';
 export { tanstackRouterResolver } from './tanstack-router';
 export { vueRouterResolver } from './vue-router';
+export { angularRouterResolver } from './angular-router';
 export { svelteKitRouterResolver } from './sveltekit-router';
 export { svelteResolver } from './svelte';
-export { vueResolver } from './vue';
+export { vueResolver, nuxtResolver } from './vue';
 export { astroResolver } from './astro';
 export { djangoResolver, flaskResolver, fastapiResolver } from './python';
 export { railsResolver } from './ruby';
@@ -172,6 +200,6 @@ export { aspnetResolver } from './csharp';
 export { swiftUIResolver, uikitResolver, vaporResolver } from './swift';
 export { swiftObjcBridgeResolver } from './swift-objc';
 export { reactNativeBridgeResolver } from './react-native';
-export { expoModulesResolver } from './expo-modules';
+export { expoModulesResolver, expoModulesJsResolver } from './expo-modules';
 export { expoRouterResolver } from './expo-router';
 export { fabricViewResolver } from './fabric';
diff --git a/src/resolution/frameworks/java.ts b/src/resolution/frameworks/java.ts
index bd36b1e4ed..1759b4ea59 100644
--- a/src/resolution/frameworks/java.ts
+++ b/src/resolution/frameworks/java.ts
@@ -7,6 +7,7 @@
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
+import { pickByNameAndKind } from './name-heuristic';
 
 export const springResolver: FrameworkResolver = {
   name: 'spring',
@@ -137,7 +138,7 @@ export const springResolver: FrameworkResolver = {
 
     // Pattern 1: Service references (dependency injection)
     if (ref.referenceName.endsWith('Service')) {
-      const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, SERVICE_DIRS, context);
+      const result = resolveByNameAndKind(ref, SERVICE_KINDS, SERVICE_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -150,7 +151,7 @@ export const springResolver: FrameworkResolver = {
 
     // Pattern 2: Repository references
     if (ref.referenceName.endsWith('Repository')) {
-      const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, REPO_DIRS, context);
+      const result = resolveByNameAndKind(ref, SERVICE_KINDS, REPO_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -163,7 +164,7 @@ export const springResolver: FrameworkResolver = {
 
     // Pattern 3: Controller references
     if (ref.referenceName.endsWith('Controller')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, CONTROLLER_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, CONTROLLER_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -176,7 +177,7 @@ export const springResolver: FrameworkResolver = {
 
     // Pattern 4: Entity/Model references
     if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, ENTITY_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, ENTITY_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -189,7 +190,7 @@ export const springResolver: FrameworkResolver = {
 
     // Pattern 5: Component references
     if (ref.referenceName.endsWith('Component') || ref.referenceName.endsWith('Config')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, COMPONENT_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, COMPONENT_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -553,28 +554,13 @@ function joinPath(prefix: string, sub: string): string {
   return '/' + parts.join('/');
 }
 
-/**
- * Resolve a symbol by name using indexed queries instead of scanning all files.
- */
+/** A framework name heuristic's pick (see name-heuristic.ts), preferring these folders. */
 function resolveByNameAndKind(
-  name: string,
+  ref: UnresolvedRef,
   kinds: Set<string>,
   preferredDirPatterns: string[],
   context: ResolutionContext,
 ): string | null {
-  const candidates = context.getNodesByName(name);
-  if (candidates.length === 0) return null;
-
-  const kindFiltered = candidates.filter((n) => kinds.has(n.kind));
-  if (kindFiltered.length === 0) return null;
-
-  // Prefer candidates in framework-conventional directories
-  const preferred = kindFiltered.filter((n) =>
-    preferredDirPatterns.some((d) => n.filePath.includes(d))
-  );
-
-  if (preferred.length > 0) return preferred[0]!.id;
-
-  // Fall back to any match
-  return kindFiltered[0]!.id;
+  return pickByNameAndKind(ref, kinds, (f) => preferredDirPatterns.some((d) => f.includes(d)), context);
 }
+
diff --git a/src/resolution/frameworks/laravel.ts b/src/resolution/frameworks/laravel.ts
index 1a8ea18742..f5b6fda12b 100644
--- a/src/resolution/frameworks/laravel.ts
+++ b/src/resolution/frameworks/laravel.ts
@@ -49,7 +49,7 @@ export const laravelResolver: FrameworkResolver = {
   // pre-filter would drop them before resolve() runs (Pattern 4). Claim them —
   // same hook the django ORM / Rails routing work needed.
   claimsReference(name: string): boolean {
-    return /^[A-Za-z_][A-Za-z0-9_]*Controller@\w+$/.test(name);
+    return CONTROLLER_ACTION.test(name) || NAMESPACED_CLASS.test(name);
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
@@ -82,8 +82,16 @@ export const laravelResolver: FrameworkResolver = {
       return null;
     }
 
+    // Pattern 5: a resource route's controller, named by string or `::class`.
+    if (ref.referenceKind === 'imports' && ref.fromNodeId.includes(':RESOURCE:')) {
+      const result = resolveControllerClass(ref.referenceName, context);
+      if (result) {
+        return { original: ref, targetNodeId: result, confidence: 0.9, resolvedBy: 'framework' };
+      }
+    }
+
     // Pattern 4: Controller method references
-    const controllerMatch = ref.referenceName.match(/^([A-Z][a-zA-Z]+Controller)@(\w+)$/);
+    const controllerMatch = ref.referenceName.match(CONTROLLER_ACTION);
     if (controllerMatch) {
       const [, controller, method] = controllerMatch;
       const result = resolveControllerMethod(controller!, method!, context);
@@ -172,7 +180,8 @@ export const laravelResolver: FrameworkResolver = {
       nodes.push(routeNode);
 
       if (handlerExpr) {
-        const controllerName = extractLaravelHandler(handlerExpr);
+        // The controller is the first argument; an options array may follow.
+        const controllerName = extractLaravelHandler(splitArgs(handlerExpr)[0] ?? handlerExpr);
         if (controllerName) {
           references.push({
             fromNodeId: routeNode.id,
@@ -478,14 +487,22 @@ function extractLaravelHandler(expr: string): string | null {
   const tupleMatch = trimmed.match(/^\[\s*([A-Za-z_\\][\w\\]*)::class\s*,\s*['"]([^'"]+)['"]\s*\]/);
   if (tupleMatch) return `${short(tupleMatch[1]!)}@${tupleMatch[2]!}`;
 
-  // 'Controller@method' (possibly namespaced) → `Controller@method`
+  // 'Controller@method' → `Controller@method`, keeping the namespace below
+  // the controllers root: akaunting writes 'Common\Uploads@inline' for
+  // App\Http\Controllers\Common\Uploads, and a `Portal\Uploads` beside it is a
+  // different controller.
   const atMatch = trimmed.match(/^['"]([^'"@]+)@([^'"]+)['"]$/);
-  if (atMatch) return `${short(atMatch[1]!)}@${atMatch[2]!}`;
+  if (atMatch) return `${controllerPath(atMatch[1]!)}@${atMatch[2]!}`;
 
   // Class::class (Route::resource controller) → `Class`
   const classMatch = trimmed.match(/^([A-Za-z_\\][\w\\]*)::class/);
   if (classMatch) return short(classMatch[1]!);
 
+  // A controller named by string — no `use` brings it in, so its namespace
+  // path below the controllers root is what finds it.
+  const stringClass = trimmed.match(/^['"]([A-Za-z_\\][\w\\]*)['"]$/);
+  if (stringClass) return controllerPath(stringClass[1]!);
+
   return null;
 }
 
@@ -539,38 +556,71 @@ function resolveModelCall(
 }
 
 /**
- * Resolve a Controller@method reference
+ * A route's `Controller@action`: a class name, or a namespace path under the
+ * controllers root (`Common\\Uploads`), or a fully qualified one
+ * (`Modules\\OfflinePayments\\Http\\Controllers\\Settings`).
+ */
+const CONTROLLER_ACTION = /^([A-Za-z_][\w\\]*)@(\w+)$/;
+
+/** A string handler's class as a path under the controllers root, a leading `\\` and `App\\Http\\Controllers\\` off. */
+function controllerPath(written: string): string {
+  return written.replace(/^\\+/, '').replace(/^App\\Http\\Controllers\\/i, '');
+}
+
+/** A class written with its namespace path (`Common\\Companies`). */
+const NAMESPACED_CLASS = /^[A-Za-z_]\w*(?:\\\w+)+$/;
+
+/** The controller class a resource route names: by its path under the controllers root, else by name. */
+function resolveControllerClass(controller: string, context: ResolutionContext): string | null {
+  const rel = controller.replace(/\\/g, '/');
+  const className = rel.split('/').pop()!;
+  const classes = context
+    .getNodesByName(className)
+    .filter((n) => n.kind === 'class' && n.filePath.includes('Controllers'));
+  const suffix = `/${rel.toLowerCase()}.php`;
+  const exact = classes.find((n) => `/${n.filePath.toLowerCase()}`.endsWith(suffix));
+  if (exact) return exact.id;
+  return classes.length === 1 ? classes[0]!.id : null;
+}
+
+/**
+ * Resolve a Controller@method reference: the file the path names under
+ * `app/Http/Controllers/`, else a class of that name in a controllers
+ * directory — the one whose path ends with the written namespace path when
+ * several share the name.
  */
 function resolveControllerMethod(
   controller: string,
   method: string,
   context: ResolutionContext
 ): string | null {
-  // Try app/Http/Controllers/
-  const controllerPath = `app/Http/Controllers/${controller}.php`;
+  const rel = controller.replace(/\\/g, '/');
+  const methodIn = (filePath: string): string | null =>
+    context.getNodesInFile(filePath).find((n) => n.kind === 'method' && n.name === method)?.id ?? null;
+
+  const controllerPath = `app/Http/Controllers/${rel}.php`;
   if (context.fileExists(controllerPath)) {
-    const nodes = context.getNodesInFile(controllerPath);
-    const methodNode = nodes.find(
-      (n) => n.kind === 'method' && n.name === method
-    );
-    if (methodNode) {
-      return methodNode.id;
-    }
+    const found = methodIn(controllerPath);
+    if (found) return found;
   }
 
-  // Try name-based lookup for namespaced controllers
-  const controllerCandidates = context.getNodesByName(controller);
-  for (const ctrl of controllerCandidates) {
-    if (ctrl.kind === 'class' && ctrl.filePath.includes('Controllers')) {
-      const nodesInFile = context.getNodesInFile(ctrl.filePath);
-      const methodNode = nodesInFile.find(
-        (n) => n.kind === 'method' && n.name === method
-      );
-      if (methodNode) {
-        return methodNode.id;
-      }
+  const className = rel.split('/').pop()!;
+  const classes = context
+    .getNodesByName(className)
+    .filter((n) => n.kind === 'class' && n.filePath.includes('Controllers'));
+  if (rel.includes('/')) {
+    const suffix = `/${rel.toLowerCase()}.php`;
+    const exact = classes.filter((n) => `/${n.filePath.toLowerCase()}`.endsWith(suffix));
+    for (const ctrl of exact) {
+      const found = methodIn(ctrl.filePath);
+      if (found) return found;
     }
+    // A namespace path that names no file decides nothing by name alone.
+    if (classes.length > 1) return null;
+  }
+  for (const ctrl of classes) {
+    const found = methodIn(ctrl.filePath);
+    if (found) return found;
   }
-
   return null;
 }
diff --git a/src/resolution/frameworks/name-heuristic.ts b/src/resolution/frameworks/name-heuristic.ts
new file mode 100644
index 0000000000..078dd26e11
--- /dev/null
+++ b/src/resolution/frameworks/name-heuristic.ts
@@ -0,0 +1,73 @@
+/**
+ * The shared pick behind the framework resolvers' name heuristics — "a
+ * `…Service` is a class under `/services/`", "a PascalCase name is a model
+ * under `/models/`", "`router` is a FastAPI router under `/routers/`".
+ *
+ * Each resolver used to take the FIRST same-named node of the right kind,
+ * preferring a conventional folder, and that heuristic outranks name matching
+ * on a tie. So every MyBatis `XExample`'s `new Criteria()` in mall went to the
+ * first `Example`'s nested `Criteria`, and axum's examples' `Uri` to a struct a
+ * routing test declares inside itself. The pick now considers only what the
+ * reference can see, and starts from its own scope.
+ */
+import { Node } from '../../types';
+import { UnresolvedRef, ResolutionContext } from '../types';
+import { isLexicallyReachable, isVisibleAcrossFiles } from '../name-matcher';
+
+/** Node kinds a nested type can be declared in. */
+const TYPE_OWNER_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'interface', 'enum', 'trait', 'protocol', 'record']);
+
+export interface NamePickOptions {
+  /**
+   * Whether a file in the reference's directory comes before the conventional
+   * folders — its package (JVM, Go, C#, Python). Not for Rust, where a sibling
+   * file is another module, reached only through a `use`.
+   */
+  sameDirectory?: boolean;
+  /** A language's own scope rule over the candidates (Rust's `use` / module paths). */
+  accept?: (n: Node) => boolean;
+}
+
+/**
+ * The id of the node named `ref.referenceName`, of one of `kinds`, that the
+ * reference can see: never a declaration inside some function body, never a
+ * type nested in another file's type (a nested type is reached by its bare
+ * name only from inside its owner), never one the language keeps out of the
+ * reference's file (a `private` member, an unexported Go name, a C# namespace
+ * the file does not use, a test suite from production code). Its own file's
+ * first, then (by default) its directory's, then a conventional folder's.
+ */
+export function pickByNameAndKind(
+  ref: UnresolvedRef,
+  kinds: ReadonlySet<string>,
+  inPreferredDir: (filePath: string) => boolean,
+  context: ResolutionContext,
+  options: NamePickOptions = {},
+): string | null {
+  const inheritance = ref.referenceKind === 'extends' || ref.referenceKind === 'implements';
+  const candidates = context.getNodesByName(ref.referenceName).filter((n) =>
+    kinds.has(n.kind) &&
+    // A type never inherits from itself.
+    !(inheritance && n.id === ref.fromNodeId) &&
+    isLexicallyReachable(n, ref, context) &&
+    (n.filePath === ref.filePath || (!isNestedType(n, context) && isVisibleAcrossFiles(n, ref, context))) &&
+    (!options.accept || options.accept(n)));
+  if (candidates.length === 0) return null;
+
+  const sameFile = candidates.find((n) => n.filePath === ref.filePath);
+  if (sameFile) return sameFile.id;
+  if (options.sameDirectory !== false) {
+    const dir = ref.filePath.slice(0, ref.filePath.lastIndexOf('/') + 1);
+    const sameDir = candidates.find((n) => n.filePath.startsWith(dir) && !n.filePath.slice(dir.length).includes('/'));
+    if (sameDir) return sameDir.id;
+  }
+  return (candidates.find((n) => inPreferredDir(n.filePath)) ?? candidates[0]!).id;
+}
+
+/** Whether a node is declared inside a type of its own file. */
+function isNestedType(n: Node, context: ResolutionContext): boolean {
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return false;
+  const owner = n.qualifiedName.slice(0, cut);
+  return context.getNodesInFile(n.filePath).some((p) => p.qualifiedName === owner && TYPE_OWNER_KINDS.has(p.kind));
+}
diff --git a/src/resolution/frameworks/nestjs.ts b/src/resolution/frameworks/nestjs.ts
index 6ea13f5daa..d3effb119d 100644
--- a/src/resolution/frameworks/nestjs.ts
+++ b/src/resolution/frameworks/nestjs.ts
@@ -89,6 +89,19 @@ export const nestjsResolver: FrameworkResolver = {
         .getNodesByName(ref.referenceName)
         .filter((n) => n.kind === 'class');
       if (candidates.length === 0) return null;
+      // A TS module reaches another file's class only by importing it — the
+      // import resolver's — so a guess by name stays in the feature: the
+      // file itself, or the convention file beside it (`users.controller.ts`
+      // → `users.service.ts`). Every Nest sample app declares its own
+      // `CatsService`, and the file-name preference sent specs across apps.
+      const own = candidates.find((n) => n.filePath === ref.filePath);
+      if (own) return { original: ref, targetNodeId: own.id, confidence: 0.85, resolvedBy: 'framework' };
+      if (/\.(?:m?[jt]sx?|cjs|cts|mts)$/.test(ref.filePath)) {
+        const dir = ref.filePath.slice(0, ref.filePath.lastIndexOf('/') + 1);
+        const beside = candidates.find((n) => n.filePath.includes(convention) &&
+          n.filePath.startsWith(dir) && !n.filePath.slice(dir.length).includes('/'));
+        return beside ? { original: ref, targetNodeId: beside.id, confidence: 0.85, resolvedBy: 'framework' } : null;
+      }
       const preferred = candidates.find((n) => n.filePath.includes(convention));
       const target = preferred ?? candidates[0]!;
       return {
@@ -208,14 +221,22 @@ export const nestjsResolver: FrameworkResolver = {
   postExtract(context: ResolutionContext): Node[] {
     const moduleToPrefix = new Map<string, string>();
     const controllerToModule = new Map<string, string>();
+    const bootstraps: NestBootstrap[] = [];
 
     for (const filePath of context.getAllFiles()) {
-      if (!/\.module\.(m?[jt]s|cjs)$/.test(filePath)) continue;
+      if (!/\.(m?[jt]s|cjs)$/.test(filePath)) continue;
+      const isModule = /\.module\.(m?[jt]s|cjs)$/.test(filePath);
+      if (!isModule && !(context.fileContains?.(filePath, 'NestFactory') ?? true)) continue;
       const content = context.readFile(filePath);
       if (!content) continue;
       const safe = stripCommentsForRegex(content, detectLanguage(filePath));
-      collectRouterModuleRegistrations(safe, moduleToPrefix);
-      collectModuleControllers(safe, controllerToModule);
+      if (isModule) {
+        collectRouterModuleRegistrations(safe, moduleToPrefix);
+        collectModuleControllers(safe, controllerToModule);
+      }
+      // Every app counts, even one that adds nothing: its routes must not
+      // borrow another app's prefix.
+      if (/\bNestFactory\s*\.\s*create/.test(safe)) bootstraps.push({ root: appRootOf(filePath), config: readBootstrap(safe) });
     }
 
     const controllerToPrefix = new Map<string, string>();
@@ -228,35 +249,243 @@ export const nestjsResolver: FrameworkResolver = {
       }
     }
 
-    if (controllerToPrefix.size === 0) return [];
+    const adds = bootstraps.some((b) => b.config.prefix !== '' || b.config.uri);
+    if (controllerToPrefix.size === 0 && !adds) return [];
 
-    const updates: Node[] = [];
+    // Route → what the app adds to it. A RouterModule prefix binds through the
+    // controller class's line range; the bootstrap's prefix and versioning
+    // only to a route its source shows is in a `@Controller` — an Express
+    // route has the same qualified-name shape.
+    const plan = new Map<string, { route: Node; modulePrefix: string; config: NestAppConfig | null; version: string | null | undefined }>();
     for (const [controllerName, prefix] of controllerToPrefix) {
-      const classes = context
-        .getNodesByName(controllerName)
-        .filter((n) => n.kind === 'class');
-      for (const cls of classes) {
-        const routes = context
-          .getNodesInFile(cls.filePath)
-          .filter((n) => n.kind === 'route');
+      for (const cls of context.getNodesByName(controllerName).filter((n) => n.kind === 'class')) {
+        for (const route of context.getNodesInFile(cls.filePath)) {
+          if (route.kind !== 'route' || route.startLine < cls.startLine || route.startLine > cls.endLine) continue;
+          plan.set(route.id, { route, modulePrefix: prefix, config: null, version: undefined });
+        }
+      }
+    }
+    if (adds) {
+      for (const filePath of context.getAllFiles()) {
+        if (!/\.(m?[jt]s|cjs)$/.test(filePath)) continue;
+        if (!(context.fileContains?.(filePath, '@Controller') ?? true)) continue;
+        const config = bootstrapFor(bootstraps, filePath);
+        if (!config || (config.prefix === '' && !config.uri)) continue;
+        const routes = context.getNodesInFile(filePath).filter((n) => n.kind === 'route' && HTTP_ROUTE_QN.test(n.qualifiedName));
+        if (routes.length === 0) continue;
+        const content = context.readFile(filePath);
+        if (!content) continue;
+        const safe = stripCommentsForRegex(content, detectLanguage(filePath));
+        const scopes = buildClassScopes(safe);
+        const hits = findDecorators(safe, HTTP_METHODS);
         for (const route of routes) {
-          // Multiple controllers can live in one file (covered by the
-          // existing "attributes methods to the right controller" test);
-          // each route must be associated with the controller whose line
-          // range contains it.
-          if (route.startLine < cls.startLine || route.startLine > cls.endLine) {
-            continue;
-          }
-          const updated = applyModulePrefix(route, prefix);
-          if (updated && updated.name !== route.name) updates.push(updated);
+          const hit = hits.find((h) => lineAt(safe, h.index) === route.startLine);
+          const scope = hit ? scopeFor(scopes, hit.index) : null;
+          if (!hit || !scope || scope.kind !== 'controller') continue;
+          const planned = plan.get(route.id);
+          plan.set(route.id, { route, modulePrefix: planned?.modulePrefix ?? '', config, version: routeVersion(safe, hit, scope) });
         }
       }
     }
 
+    const updates: Node[] = [];
+    for (const { route, modulePrefix, config, version } of plan.values()) {
+      const updated = applyAppConfig(route, modulePrefix, config, version);
+      if (updated && updated.name !== route.name) updates.push(updated);
+    }
     return updates;
   },
 };
 
+// ---------------------------------------------------------------------------
+// The app's bootstrap: global prefix and URI versioning
+// ---------------------------------------------------------------------------
+
+/** A route's in-file shape in its qualified name: `file::GET:/users`. */
+const HTTP_ROUTE_QN = /::(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|ALL):/;
+
+/** The version marker for `VERSION_NEUTRAL`: served without a version segment. */
+const NEUTRAL = '\u0000neutral';
+
+interface NestAppConfig {
+  /** `setGlobalPrefix('api')` — '' when none, or not a literal. */
+  prefix: string;
+  /** Paths the prefix skips: `exclude: ['health', { path: 'metrics', method }]`, without a leading `/`. */
+  excludes: string[];
+  /** URI versioning is on (`enableVersioning({ type: VersioningType.URI })`, the default type). */
+  uri: boolean;
+  /** `defaultVersion: '1'` — the version a route without its own is served at; null for none. */
+  defaultVersion: string | null;
+  /** The segment's prefix: `v` unless `prefix:` says otherwise (`false` is none). */
+  versionPrefix: string;
+}
+
+interface NestBootstrap {
+  root: string;
+  config: NestAppConfig;
+}
+
+/** The app a file belongs to: the directory above its `src/` (`apps/api/`), else the repository. */
+function appRootOf(filePath: string): string {
+  const m = /^((?:[^/]+\/)*?)src\//.exec(filePath);
+  return m ? m[1]! : '';
+}
+
+/**
+ * The config of the app that holds `filePath`: the bootstrap with the longest
+ * root above it, else — for a file outside every app, like an Nx `libs/`
+ * controller — the app, when there is only one.
+ */
+function bootstrapFor(bootstraps: readonly NestBootstrap[], filePath: string): NestAppConfig | null {
+  let root: string | null = null;
+  for (const b of bootstraps) {
+    if (filePath.startsWith(b.root) && (root === null || b.root.length > root.length)) root = b.root;
+  }
+  if (root === null) {
+    if (new Set(bootstraps.map((b) => b.root)).size !== 1) return null;
+    root = bootstraps[0]!.root;
+  }
+  // A seed or migration script creates the same app without serving it: the
+  // bootstrap that configures the app is the one that serves it.
+  const here = bootstraps.filter((b) => b.root === root);
+  return (here.find((b) => b.config.prefix !== '' || b.config.uri) ?? here[0])?.config ?? null;
+}
+
+/** One version value: `'2'`, `['1', '2']` (the first), `VERSION_NEUTRAL`. */
+function versionValue(text: string): string | null {
+  const t = text.trim();
+  if (/^VERSION_NEUTRAL\b/.test(t)) return NEUTRAL;
+  const lit = /^\[?\s*(['"`])([^'"`]*)\1/.exec(t);
+  return lit ? lit[2]! : null;
+}
+
+/** `setGlobalPrefix` and `enableVersioning` from the file that calls `NestFactory.create`. */
+function readBootstrap(safe: string): NestAppConfig {
+  const config: NestAppConfig = { prefix: '', excludes: [], uri: false, defaultVersion: null, versionPrefix: 'v' };
+  const prefixCall = /\.setGlobalPrefix\s*\(/.exec(safe);
+  if (prefixCall) {
+    const open = prefixCall.index + prefixCall[0].length - 1;
+    const close = matchingClose(safe, open);
+    const args = close > open ? safe.slice(open + 1, close) : '';
+    const lit = /^\s*(['"`])([^'"`$]*)\1/.exec(args);
+    if (lit) {
+      config.prefix = lit[2]!.replace(/^\/+|\/+$/g, '');
+      const ex = /\bexclude\s*:\s*\[/.exec(args);
+      if (ex) {
+        const exOpen = ex.index + ex[0].length - 1;
+        const exClose = matchingClose(args, exOpen);
+        const list = exClose > exOpen ? args.slice(exOpen + 1, exClose) : '';
+        for (const item of splitTopLevel(list)) {
+          const text = item.trim();
+          const path = /^(['"])([^'"]*)\1$/.exec(text)?.[2] ?? /\bpath\s*:\s*(['"])([^'"]*)\1/.exec(text)?.[2];
+          if (path !== undefined) config.excludes.push(path.replace(/^\/+/, ''));
+        }
+      }
+    }
+  }
+  const versioning = /\.enableVersioning\s*\(/.exec(safe);
+  if (versioning) {
+    const open = versioning.index + versioning[0].length - 1;
+    const close = matchingClose(safe, open);
+    const args = close > open ? safe.slice(open + 1, close) : '';
+    const type = /\btype\s*:\s*VersioningType\s*\.\s*(\w+)/.exec(args)?.[1];
+    config.uri = type === undefined || type === 'URI';
+    const def = /\bdefaultVersion\s*:\s*/.exec(args);
+    if (def) config.defaultVersion = versionValue(args.slice(def.index + def[0].length));
+    const pre = /\bprefix\s*:\s*(false|(['"`])([^'"`]*)\2)/.exec(args);
+    if (pre) config.versionPrefix = pre[1] === 'false' ? '' : pre[3]!;
+  }
+  return config;
+}
+
+/** A route excluded from the global prefix: `health`, `health/(.*)`, `health{/*wildcard}`, `health/*`. */
+function isExcluded(path: string, excludes: readonly string[]): boolean {
+  const route = path.replace(/^\/+/, '');
+  for (const pattern of excludes) {
+    const wild = /(?:\{\/?\*\w*\}|\/?\(\.\*\)|\/?\*\w*)$/.exec(pattern);
+    const base = wild ? pattern.slice(0, wild.index).replace(/\/+$/, '') : pattern.replace(/\/+$/, '');
+    if (route === base || (wild && route.startsWith(`${base}/`))) return true;
+  }
+  return false;
+}
+
+/**
+ * The version a route is served at: `@Version(…)` among its own decorators,
+ * else its controller's (`@Version(…)` on the class, `@Controller({ version })`).
+ * Undefined when neither says.
+ */
+function routeVersion(safe: string, hit: DecoratorHit, scope: ClassScope): string | null | undefined {
+  // The method's decorators: back through the ones stacked above this one…
+  const from = decoratorChainStart(safe, hit.index, scope.start);
+  // …and on to the handler itself — past the decorators between (`@UseGuards(…)`, `@Version('2')`).
+  const handler = methodNameAfter(safe, hit.end);
+  const at = handler ? new RegExp(String.raw`(?<![@\w$])${handler.replace(/\$/g, '\\$')}\s*\(`).exec(safe.slice(hit.end)) : null;
+  const to = at ? hit.end + at.index : hit.end;
+  const own = /@Version\s*\(([^)]*)\)/.exec(safe.slice(from, to));
+  if (own) return versionValue(own[1]!);
+  // The class's decorators, on either side of `@Controller`.
+  const cls = /\bclass\b/g;
+  cls.lastIndex = scope.start;
+  const head = safe.slice(decoratorChainStart(safe, scope.start, 0), cls.exec(safe)?.index ?? scope.start + 400);
+  const onClass = /@Version\s*\(([^)]*)\)/.exec(head);
+  if (onClass) return versionValue(onClass[1]!);
+  const inController = /@Controller\s*\(\s*\{[^)]*\bversion\s*:\s*([^,}]+)/.exec(head);
+  if (inController) return versionValue(inController[1]!);
+  return undefined;
+}
+
+/**
+ * Where the stack of decorators ending at `at` begins: back over each
+ * `@Name(…)` / `@Name` above it. A decorator's arguments may hold an object
+ * (`@ApiResponse({ status: 200 })`), so this steps over balanced parentheses
+ * rather than stopping at the first brace.
+ */
+function decoratorChainStart(safe: string, at: number, floor: number): number {
+  let start = at;
+  for (;;) {
+    let i = start;
+    while (i > floor && /\s/.test(safe[i - 1]!)) i--;
+    if (safe[i - 1] === ')') {
+      let depth = 0;
+      let j = i - 1;
+      for (; j >= floor; j--) {
+        if (safe[j] === ')') depth++;
+        else if (safe[j] === '(' && --depth === 0) break;
+      }
+      if (j < floor) return start;
+      i = j;
+    }
+    let name = i;
+    while (name > floor && /[\w$.]/.test(safe[name - 1]!)) name--;
+    if (name === i || safe[name - 1] !== '@') return start;
+    start = name - 1;
+  }
+}
+
+/**
+ * A route's name with everything the app adds to it, in NestJS's order:
+ * `/{globalPrefix}/{v}{version}/{RouterModule prefix}/{controller}/{method}`.
+ * Recomputed from the in-file `method:path` in the qualified name, so the pass
+ * is idempotent.
+ */
+function applyAppConfig(route: Node, modulePrefix: string, config: NestAppConfig | null, version: string | null | undefined): Node | null {
+  const sep = route.qualifiedName.indexOf('::');
+  if (sep < 0) return null;
+  const tail = route.qualifiedName.slice(sep + 2);
+  const colon = tail.indexOf(':');
+  if (colon < 0) return null;
+  const method = tail.slice(0, colon);
+  const inner = joinHttpPath(modulePrefix, tail.slice(colon + 1));
+  let path = inner;
+  if (config) {
+    const v = version === undefined ? config.defaultVersion : version;
+    const versionSeg = config.uri && v !== null && v !== NEUTRAL ? `${config.versionPrefix}${v}` : '';
+    const prefix = config.prefix && !isExcluded(inner, config.excludes) ? config.prefix : '';
+    path = joinHttpPath(joinHttpPath(prefix, versionSeg), inner);
+  }
+  return { ...route, name: `${method} ${path}`, updatedAt: Date.now() };
+}
+
 // ---------------------------------------------------------------------------
 // Provider resolution conventions
 // ---------------------------------------------------------------------------
@@ -646,29 +875,36 @@ function classNameAfter(safe: string, start: number): string | null {
   return m ? m[1]! : null;
 }
 
-/**
- * Recompute a route node's `name` by prepending `prefix` to the *original*
- * in-file path. The original is recovered from `qualifiedName`, which the
- * per-file extract emits as `${filePath}::${method}:${path}` and which this
- * pass deliberately never mutates — that's what keeps the update idempotent.
- */
-function applyModulePrefix(route: Node, prefix: string): Node | null {
-  const sep = '::';
-  const idx = route.qualifiedName.indexOf(sep);
-  if (idx < 0) return null;
-  const tail = route.qualifiedName.slice(idx + sep.length);
-  const colon = tail.indexOf(':');
-  if (colon < 0) return null;
-  const method = tail.slice(0, colon);
-  const original = tail.slice(colon + 1);
-  const newName = `${method} ${joinHttpPath(prefix, original)}`;
-  return { ...route, name: newName, updatedAt: Date.now() };
-}
 
 // ---------------------------------------------------------------------------
 // Small string utilities (object/array literal splitters)
 // ---------------------------------------------------------------------------
 
+/** A list's comma-separated items at depth 0, strings and brackets stepped over. */
+function splitTopLevel(list: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let inStr: string | null = null;
+  let start = 0;
+  for (let i = 0; i < list.length; i++) {
+    const ch = list[i]!;
+    if (inStr) {
+      if (ch === '\\') { i++; continue; }
+      if (ch === inStr) inStr = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === '`') { inStr = ch; continue; }
+    if (ch === '[' || ch === '{' || ch === '(') depth++;
+    else if (ch === ']' || ch === '}' || ch === ')') depth--;
+    else if (ch === ',' && depth === 0) {
+      out.push(list.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(list.slice(start));
+  return out.filter((item) => item.trim().length > 0);
+}
+
 /** Return the index of the bracket that closes the one at `open`, or -1. */
 function matchingClose(s: string, open: number): number {
   const opener = s[open];
diff --git a/src/resolution/frameworks/nextjs.ts b/src/resolution/frameworks/nextjs.ts
index 7eb543dee9..a2aba3d5dd 100644
--- a/src/resolution/frameworks/nextjs.ts
+++ b/src/resolution/frameworks/nextjs.ts
@@ -125,6 +125,12 @@ interface NextTable extends RouteTable {
 
 const tables = new WeakMap<ResolutionContext, NextTable>();
 
+/** The page a route node is, or null for a node the table leaves out (a handler, another framework's route). */
+function tablePage(node: Node): NextRouteFile | null {
+  const file = nextRouteForFile(node.filePath);
+  return file && file.kind === 'page' && file.path === node.name ? file : null;
+}
+
 export function nextRouteTable(context: ResolutionContext): NextTable {
   const all = context.getNodesByKind('route');
   const cached = tables.get(context);
@@ -133,8 +139,8 @@ export function nextRouteTable(context: ResolutionContext): NextTable {
   const dynamic: RouteTable['dynamic'] = [];
   const roots = new Set<string>();
   for (const node of all) {
-    const file = nextRouteForFile(node.filePath);
-    if (!file || file.kind !== 'page' || file.path !== node.name) continue;
+    const file = tablePage(node);
+    if (!file) continue;
     exact.set(node.name, node);
     if (node.name.includes(':')) dynamic.push({ node, segs: node.name.split('/').slice(1) });
     roots.add(file.root);
@@ -222,6 +228,7 @@ export function nextNavVerb(name: string): string | null {
 export const nextjsResolver: FrameworkResolver = {
   name: 'nextjs',
   languages: [...ROUTE_LANGUAGES],
+  appDependencies: ['next'],
 
   detect(context: ResolutionContext): boolean {
     if (dependsOn(context, 'next')) return true;
@@ -234,6 +241,13 @@ export const nextjsResolver: FrameworkResolver = {
     return NAV_CALL.test(name);
   },
 
+  navigation: {
+    tails: ['push', 'replace', 'prefetch', 'redirect', 'permanentRedirect'],
+    // One table holds every Next app's pages, and a call under any of them
+    // matches against all of it.
+    scope: (route, context) => (tablePage(route) ? nextRouteTable(context).roots : null),
+  },
+
   extract(filePath: string, content: string) {
     const file = nextRouteForFile(filePath);
     if (!file) return { nodes: [], references: [] };
diff --git a/src/resolution/frameworks/package-deps.ts b/src/resolution/frameworks/package-deps.ts
index 1793848fee..907c679431 100644
--- a/src/resolution/frameworks/package-deps.ts
+++ b/src/resolution/frameworks/package-deps.ts
@@ -1,10 +1,12 @@
 /**
- * The dependencies a project declares — in its root `package.json` and in
- * the ones one or two directories down (`apps/web/package.json`,
- * `frontend/package.json`, `packages/api/package.json`). A framework detector
- * that reads only the root misses every monorepo: proshop keeps `react` in
- * `frontend/`, a Turborepo keeps `next` in `apps/web/`, and the resolver for
- * that framework then never runs, so its routes never exist.
+ * The dependencies a project declares — in its root `package.json`, in the
+ * ones one or two directories down (`apps/web/package.json`,
+ * `frontend/package.json`, `packages/api/package.json`), and in the ones
+ * deeper still above JS/TS code (`src/Web/ClientApp/package.json`). A
+ * framework detector that reads only the root misses every monorepo: proshop
+ * keeps `react` in `frontend/`, a Turborepo keeps `next` in `apps/web/`, an
+ * ASP.NET solution keeps its Angular app in `src/Web/ClientApp/`, and the
+ * resolver for that framework then never runs, so its routes never exist.
  */
 
 import type { ResolutionContext } from '../types';
@@ -12,6 +14,12 @@ import type { ResolutionContext } from '../types';
 /** Nested manifests read per project, at most — a monorepo with hundreds of packages is sampled, not scanned. */
 const MAX_MANIFESTS = 24;
 
+/** Directories probed for a manifest below the first two levels, at most. */
+const MAX_DEEP_PROBES = MAX_MANIFESTS * 8;
+
+/** A file a JavaScript framework's app is written in. Its app's manifest is in a directory above it. */
+const SCRIPT_FILE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro)$/;
+
 /**
  * Cached per context, keyed by how many files are indexed.
  *
@@ -26,7 +34,7 @@ const MAX_MANIFESTS = 24;
  */
 const cache = new WeakMap<ResolutionContext, { files: number; names: Set<string> }>();
 
-/** Every dependency name declared at the root or up to two directories down, de-duplicated. */
+/** Every dependency name declared in the manifests read (see the file comment), de-duplicated. */
 export function declaredDependencies(context: ResolutionContext): Set<string> {
   const files = context.getAllFiles();
   const cached = cache.get(context);
@@ -46,6 +54,16 @@ export function declaredDependencies(context: ResolutionContext): Set<string> {
     if (manifests.length > MAX_MANIFESTS) break;
     if (!dir.includes('node_modules') && context.fileExists(dir + 'package.json')) manifests.push(dir + 'package.json');
   }
+  // An app can sit deeper: an ASP.NET solution's single-page app in
+  // `src/Web/ClientApp/`, prometheus's React apps in `web/ui/mantine-ui/`
+  // under a workspace root at `web/ui/`. The slots left go to the directories
+  // above JS/TS code, shallowest first.
+  if (manifests.length <= MAX_MANIFESTS) {
+    for (const dir of deepScriptDirectories(files)) {
+      if (manifests.length > MAX_MANIFESTS) break;
+      if (context.fileExists(dir + 'package.json')) manifests.push(dir + 'package.json');
+    }
+  }
   for (const manifest of manifests) {
     const content = context.readFile(manifest);
     if (!content) continue;
@@ -62,6 +80,34 @@ export function declaredDependencies(context: ResolutionContext): Set<string> {
   return names;
 }
 
+/**
+ * The directories three or more levels down that hold indexed JS/TS code or a
+ * directory that does, never inside `node_modules`: shallowest first, at most
+ * {@link MAX_DEEP_PROBES} of them. Sorted within a level, so the sample does
+ * not depend on the order the files come in. Extraction lists them as git or a
+ * directory walk returns them, the resolver in path order, and each decides
+ * from its own list which frameworks run.
+ */
+function deepScriptDirectories(files: readonly string[]): string[] {
+  // levels[n]: the directories n levels down (`a/b/c/` is 3).
+  const levels: Set<string>[] = [];
+  for (const file of files) {
+    if (!SCRIPT_FILE.test(file) || file.includes('node_modules')) continue;
+    let depth = 0;
+    for (let slash = file.indexOf('/'); slash >= 0; slash = file.indexOf('/', slash + 1)) {
+      if (++depth >= 3) (levels[depth] ??= new Set()).add(file.slice(0, slash + 1));
+    }
+  }
+  const dirs: string[] = [];
+  for (let depth = 3; depth < levels.length; depth++) {
+    for (const dir of [...(levels[depth] ?? [])].sort()) {
+      if (dirs.length === MAX_DEEP_PROBES) return dirs;
+      dirs.push(dir);
+    }
+  }
+  return dirs;
+}
+
 /** True when any of `deps` is declared anywhere the project's manifests are read. */
 export function dependsOn(context: ResolutionContext, ...deps: string[]): boolean {
   const names = declaredDependencies(context);
diff --git a/src/resolution/frameworks/page-component.ts b/src/resolution/frameworks/page-component.ts
new file mode 100644
index 0000000000..38d311b113
--- /dev/null
+++ b/src/resolution/frameworks/page-component.ts
@@ -0,0 +1,44 @@
+/**
+ * A file-routed page — Nuxt's `pages/admin.vue`, Astro's `src/pages/about.astro`
+ * — is served by the component its file IS: the single-file-component
+ * extractor's one component per file, named after the file. Without the link a
+ * page route stood alone, so the viewer's Steps tab drew nothing for a page and
+ * the routes list never named what serves it.
+ *
+ * The route says so with a `calls` reference by that name, the way a Next.js
+ * page names its default export, and {@link resolvePageComponent} lands it on
+ * the SAME file's component — never on a same-named one elsewhere, since every
+ * `index.vue` is a component named `index`.
+ */
+
+import type { Language, Node } from '../../types';
+import type { ResolutionContext, ResolvedRef, UnresolvedRef } from '../types';
+
+/** The component name a single-file-component extractor gives a file: its basename, extension off. */
+export function pageComponentName(filePath: string, extension: string): string {
+  const base = filePath.split(/[/\\]/).pop() ?? filePath;
+  return base.endsWith(extension) ? base.slice(0, -extension.length) : base;
+}
+
+export function pageComponentRef(route: Node, extension: string, language: Language): UnresolvedRef {
+  const name = pageComponentName(route.filePath, extension);
+  return {
+    fromNodeId: route.id,
+    referenceName: name,
+    referenceKind: 'calls',
+    line: 1,
+    column: 0,
+    filePath: route.filePath,
+    language,
+    candidates: [name],
+  };
+}
+
+/** A page route's reference to its file's own component, or null when this is not one. */
+export function resolvePageComponent(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  if (ref.referenceKind !== 'calls' || !ref.fromNodeId.startsWith(`route:${ref.filePath}:`)) return null;
+  const component = context
+    .getNodesInFile(ref.filePath)
+    .find((n) => n.kind === 'component' && n.name === ref.referenceName);
+  return component ? { original: ref, targetNodeId: component.id, confidence: 0.95, resolvedBy: 'framework' } : null;
+}
diff --git a/src/resolution/frameworks/play.ts b/src/resolution/frameworks/play.ts
index bc27baf149..a10a88c928 100644
--- a/src/resolution/frameworks/play.ts
+++ b/src/resolution/frameworks/play.ts
@@ -34,7 +34,9 @@ export const playResolver: FrameworkResolver = {
     if (buildSbt && /playframework|"play"|sbt-plugin|PlayScala|PlayJava/i.test(buildSbt)) return true;
     if (context.fileExists('conf/routes')) return true;
     if (context.fileExists('conf/application.conf')) return true;
-    return false;
+    // A repository of Play projects (playframework/play-samples) keeps each
+    // one's `conf/routes` in its own directory.
+    return context.getAllFiles().some((f) => isPlayRoutesFile(f));
   },
 
   // The handler is `Controller.method` (a class-qualified action), which names no
diff --git a/src/resolution/frameworks/python.ts b/src/resolution/frameworks/python.ts
index 2f1a7c9844..777016f2ac 100644
--- a/src/resolution/frameworks/python.ts
+++ b/src/resolution/frameworks/python.ts
@@ -8,6 +8,7 @@ import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolutionContext, FrameworkExtractionResult } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
 import { resolveImportPath } from '../import-resolver';
+import { pickByNameAndKind } from './name-heuristic';
 
 export const djangoResolver: FrameworkResolver = {
   name: 'django',
@@ -25,15 +26,15 @@ export const djangoResolver: FrameworkResolver = {
 
   resolve(ref, context) {
     if (ref.referenceName.endsWith('Model') || /^[A-Z][a-z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, MODEL_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, MODEL_DIRS, context);
       if (result) return { original: ref, targetNodeId: result, confidence: 0.8, resolvedBy: 'framework' };
     }
     if (ref.referenceName.endsWith('View') || ref.referenceName.endsWith('ViewSet')) {
-      const result = resolveByNameAndKind(ref.referenceName, VIEW_KINDS, VIEW_DIRS, context);
+      const result = resolveByNameAndKind(ref, VIEW_KINDS, VIEW_DIRS, context);
       if (result) return { original: ref, targetNodeId: result, confidence: 0.8, resolvedBy: 'framework' };
     }
     if (ref.referenceName.endsWith('Form')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, FORM_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, FORM_DIRS, context);
       if (result) return { original: ref, targetNodeId: result, confidence: 0.8, resolvedBy: 'framework' };
     }
     // ORM dynamic dispatch: QuerySet._fetch_all (and siblings) call
@@ -202,7 +203,7 @@ export const flaskResolver: FrameworkResolver = {
 
   resolve(ref, context) {
     if (ref.referenceName.endsWith('_bp') || ref.referenceName.endsWith('_blueprint')) {
-      const result = resolveByNameAndKind(ref.referenceName, VARIABLE_KINDS, [], context);
+      const result = resolveByNameAndKind(ref, VARIABLE_KINDS, [], context);
       if (result) return { original: ref, targetNodeId: result, confidence: 0.8, resolvedBy: 'framework' };
     }
     return null;
@@ -223,9 +224,10 @@ export const flaskResolver: FrameworkResolver = {
       language: 'python',
     });
     const restful = extractFlaskRestful(filePath, safe);
+    const rules = extractFlaskUrlRules(filePath, safe);
     return {
-      nodes: [...decorator.nodes, ...restful.nodes],
-      references: [...decorator.references, ...restful.references],
+      nodes: [...decorator.nodes, ...restful.nodes, ...rules.nodes],
+      references: [...decorator.references, ...restful.references, ...rules.references],
     };
   },
 };
@@ -264,11 +266,11 @@ export const fastapiResolver: FrameworkResolver = {
 
   resolve(ref, context) {
     if (ref.referenceName.endsWith('_router') || ref.referenceName === 'router') {
-      const result = resolveByNameAndKind(ref.referenceName, VARIABLE_KINDS, ROUTER_DIRS, context);
+      const result = resolveByNameAndKind(ref, VARIABLE_KINDS, ROUTER_DIRS, context);
       if (result) return { original: ref, targetNodeId: result, confidence: 0.8, resolvedBy: 'framework' };
     }
     if (ref.referenceName.startsWith('get_') || ref.referenceName.startsWith('Depends')) {
-      const result = resolveByNameAndKind(ref.referenceName, FUNCTION_KINDS, DEP_DIRS, context);
+      const result = resolveByNameAndKind(ref, FUNCTION_KINDS, DEP_DIRS, context);
       if (result) return { original: ref, targetNodeId: result, confidence: 0.75, resolvedBy: 'framework' };
     }
     return null;
@@ -537,6 +539,96 @@ function extractFlaskRestful(filePath: string, safe: string): FrameworkExtractio
   return { nodes, references };
 }
 
+/**
+ * Flask's imperative registration: `bp.add_url_rule('/path', 'name',
+ * view_func=View.as_view('name'), methods=[…])`, and a project's own wrapper
+ * around it — any call handing a list of path strings and a `view_func=`
+ * over, like flaskbb's `register_view(auth, routes=["/login"],
+ * view_func=Login.as_view("login"))`. A class-based view (`X.as_view(…)`)
+ * serves whatever verbs it defines, so its route is ANY unless `methods=`
+ * says; a plain function defaults to GET, as Flask does.
+ */
+function extractFlaskUrlRules(filePath: string, safe: string): FrameworkExtractionResult {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const now = Date.now();
+  const seen = new Set<string>();
+  const opener = /(\.add_url_rule|\b[A-Za-z_]\w*)\s*\(/g;
+  let m: RegExpExecArray | null;
+  while ((m = opener.exec(safe)) !== null) {
+    const open = m.index + m[0].length;
+    const args = balancedArgs(safe, open);
+    if (args === null || !/\bview_func\s*=|\.add_url_rule/.test(m[1]! + args)) continue;
+    const isRule = m[1] === '.add_url_rule';
+    let paths: string[] = [];
+    if (isRule) {
+      const first = /^\s*(?:rule\s*=\s*)?(['"])([^'"]*)\1/.exec(args);
+      if (first) paths = [first[2]!];
+    } else {
+      const list = /(?:^|,)\s*(?:routes|rules|urls|paths)?\s*=?\s*\[((?:\s*(['"])[^'"]*\2\s*,?)+)\]/.exec(args);
+      if (list) paths = (list[1]!.match(/(['"])([^'"]*)\1/g) ?? []).map((q) => q.slice(1, -1));
+    }
+    paths = paths.filter((p) => p.startsWith('/'));
+    if (paths.length === 0) continue;
+    // `view_func=X` / `view_func=X.as_view(…)`, or add_url_rule's third positional argument.
+    const expr = /\bview_func\s*=\s*([A-Za-z_][\w.]*)/.exec(args)?.[1] ??
+      (isRule ? /^\s*(['"])[^'"]*\1\s*,\s*(?:(['"])[^'"]*\2|None)\s*,\s*([A-Za-z_][\w.]*)/.exec(args)?.[3] : undefined);
+    if (!expr) continue;
+    const classView = expr.endsWith('.as_view');
+    const target = classView ? expr.slice(0, -'.as_view'.length) : expr;
+    const listed = /\bmethods\s*=\s*[[(]([^\])]*)[\])]/.exec(args)?.[1];
+    const methods = listed
+      ? (listed.match(/['"](\w+)['"]/g) ?? []).map((q) => q.slice(1, -1).toUpperCase())
+      : [classView ? 'ANY' : 'GET'];
+    const line = safe.slice(0, m.index).split('\n').length;
+    const name = target.split('.').pop()!;
+    for (const routePath of paths) {
+      for (const method of methods) {
+        const id = `route:${filePath}:${line}:${method}:${routePath}`;
+        if (seen.has(id)) continue;
+        seen.add(id);
+        nodes.push({
+          id,
+          kind: 'route',
+          name: `${method} ${routePath}`,
+          qualifiedName: `${filePath}::${method}:${routePath}`,
+          filePath,
+          startLine: line,
+          endLine: line,
+          startColumn: 0,
+          endColumn: 0,
+          language: 'python',
+          updatedAt: now,
+        });
+        references.push({ fromNodeId: id, referenceName: name, referenceKind: 'references', line, column: 0, filePath, language: 'python' });
+      }
+    }
+    opener.lastIndex = open + args.length;
+  }
+  return { nodes, references };
+}
+
+/** The text between an opening `(` at `open` and its matching `)`, or null. Strings are skipped. */
+function balancedArgs(text: string, open: number): string | null {
+  let depth = 1;
+  let quote = '';
+  for (let i = open; i < text.length && i < open + 4000; i++) {
+    const ch = text[i]!;
+    if (quote) {
+      if (ch === '\\') i++;
+      else if (ch === quote) quote = '';
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === '(' || ch === '[' || ch === '{') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}') {
+      depth--;
+      if (depth === 0) return text.slice(open, i);
+    }
+  }
+  return null;
+}
+
 // Directory patterns
 const MODEL_DIRS = ['models', 'app/models', 'src/models'];
 const VIEW_DIRS = ['views', 'app/views', 'src/views', 'api/views'];
@@ -549,29 +641,12 @@ const VIEW_KINDS = new Set(['class', 'function']);
 const VARIABLE_KINDS = new Set(['variable']);
 const FUNCTION_KINDS = new Set(['function']);
 
-/**
- * Resolve a symbol by name using indexed queries instead of scanning all files.
- */
+/** A framework name heuristic's pick (see name-heuristic.ts), preferring these folders. */
 function resolveByNameAndKind(
-  name: string,
+  ref: UnresolvedRef,
   kinds: Set<string>,
   preferredDirPatterns: string[],
   context: ResolutionContext,
 ): string | null {
-  const candidates = context.getNodesByName(name);
-  if (candidates.length === 0) return null;
-
-  const kindFiltered = candidates.filter((n) => kinds.has(n.kind));
-  if (kindFiltered.length === 0) return null;
-
-  // Prefer candidates in framework-conventional directories
-  if (preferredDirPatterns.length > 0) {
-    const preferred = kindFiltered.filter((n) =>
-      preferredDirPatterns.some((d) => n.filePath.includes(d))
-    );
-    if (preferred.length > 0) return preferred[0]!.id;
-  }
-
-  // Fall back to any match
-  return kindFiltered[0]!.id;
+  return pickByNameAndKind(ref, kinds, (f) => preferredDirPatterns.some((d) => f.includes(d)), context);
 }
diff --git a/src/resolution/frameworks/react-router.ts b/src/resolution/frameworks/react-router.ts
index 85db31eee4..b13292272b 100644
--- a/src/resolution/frameworks/react-router.ts
+++ b/src/resolution/frameworks/react-router.ts
@@ -5,8 +5,11 @@
  * `<Route path="/payment" component={PaymentScreen}/>` (v5),
  * `<Route path="/payment" element={<PaymentScreen/>}/>` (v6) and
  * `createBrowserRouter([{ path, element }])` (v6.4+) each become a `route`
- * node named by its path, bound to the component that renders it. That is
- * half of what "how does this app flow" means. This file is the other half.
+ * node named by its path, bound to the component that renders it — and so
+ * does a table another file hands the router (`AppRoutes.map(… <Route
+ * {...rest}>)`, `useRoutes(routes)` with `routes` imported), read once every
+ * file is indexed. That is half of what "how does this app flow" means. This
+ * file is the other half.
  *
  * **Navigation is a string.** `history.push('/placeorder')` (v5, and the
  * `useHistory` hook), `navigate('/placeorder')` (v6's `useNavigate`),
@@ -28,11 +31,18 @@
  * in JavaScript, so the receiver has to name a router — a bare `push` is an
  * array's, and is never claimed.
  *
- * Known limits, both deliberate: a nested route's path is relative to its
- * parent (`<Route path="team">` inside `<Route path="/dashboard">`), and the
- * markup scan does not compose that tree, so only an absolute path is a
- * destination an href can name; and a splat (`/admin/*`) matches anything, so
- * it is never the answer to a concrete href.
+ * A nested route's path is relative to its parent's (`<Route path="team">`
+ * inside `<Route path="/dashboard">`, a data router's `children`); the markup
+ * scan composes that tree, a constant path (`paths.app.root.path`) included,
+ * and a `lazy: () => import('./routes/x')` route renders that module's default
+ * export (`frameworks/react.ts`). An index route (`index: true`, `<Route
+ * index>`) is the page at its parent's address, and a route around others —
+ * an object with `children`, a `<Route element>` with `<Route>`s inside — is
+ * the layout they render inside (a `references` edge marked `layout: true`).
+ * Known limits, deliberate: a splat (`/admin/*`) matches anything, so it is
+ * never the answer to a concrete href; and an index route at the top of a
+ * component's own `<Routes>` is at wherever another route mounts that
+ * component, which its file does not say, so it is no route at all.
  */
 
 import type { Language, Node } from '../../types';
@@ -53,6 +63,7 @@ import {
 // two arms). It lives in `nextjs.ts` because that is where it was first
 // needed; duplicating it here would be a second derivation of the same rule.
 import { destinationsForHref } from './nextjs';
+import { configHrefExpression, isTableRoute } from './react';
 
 const ROUTE_LANGUAGES: readonly Language[] = ['typescript', 'javascript', 'tsx', 'jsx'];
 
@@ -70,13 +81,27 @@ export const reactRouterRoot = appRootFor;
  *
  * Its id is a verbatim reconstruction of the node's own fields, which no
  * other framework's route id is: a server route carries its METHOD
- * (`route:file:12:POST:/login`), a file-based page carries no line.
+ * (`route:file:12:POST:/login`), a file-based page carries no line. A path
+ * built from a constant keeps the id it was extracted with, and a route read
+ * from a table another file hands the router says so (`…:12:table:/login`).
  */
 function isReactRouterRoute(node: Node): boolean {
-  return (
-    (node.language === 'tsx' || node.language === 'jsx') &&
-    node.id === `route:${node.filePath}:${node.startLine}:${node.name}`
-  );
+  const prefix = `route:${node.filePath}:${node.startLine}:`;
+  if ((node.language !== 'tsx' && node.language !== 'jsx') || !node.id.startsWith(prefix)) return false;
+  if (isTableRoute(node)) return true;
+  // Its name, or — for a path built from a constant, renamed after extraction
+  // — the path as the file wrote it; never a server route's `METHOD:`.
+  const rest = node.id.slice(prefix.length);
+  return rest === node.name || (!/^[A-Z]+:/.test(rest) && Boolean(node.signature?.startsWith('route-parts:')));
+}
+
+/**
+ * True for a route the table holds. A nested route's path is relative to its
+ * parent; without the tree it is not a destination. A splat matches
+ * everything, so it answers nothing.
+ */
+function isDestination(node: Node): boolean {
+  return isReactRouterRoute(node) && node.name.startsWith('/') && !node.name.endsWith('*');
 }
 
 /** `:id?` — a parameter React Router serves the route with or without. */
@@ -98,10 +123,7 @@ export function reactRouterTable(context: ResolutionContext): ReactRouterTable {
     return t;
   };
   for (const node of all) {
-    if (!isReactRouterRoute(node)) continue;
-    // A nested route's path is relative to its parent; without the tree it is
-    // not a destination. A splat matches everything, so it answers nothing.
-    if (!node.name.startsWith('/') || node.name.endsWith('*')) continue;
+    if (!isDestination(node)) continue;
     const root = reactRouterRoot(node.filePath);
     const path = node.name.length > 1 && node.name.endsWith('/') ? node.name.slice(0, -1) : node.name;
     addRouteTo(tableAt(root), path, node);
@@ -163,6 +185,12 @@ export const reactRouterResolver: FrameworkResolver = {
     return NAV_CALL.test(name);
   },
 
+  navigation: {
+    tails: ['push', 'replace', 'navigate', 'redirect'],
+    // A call matches against the table of the app its file is in.
+    scope: (route) => (isDestination(route) ? [reactRouterRoot(route.filePath)] : null),
+  },
+
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
     if (ref.referenceKind !== 'calls') return null;
     const verb = reactRouterNavVerb(ref.referenceName);
@@ -176,6 +204,11 @@ export const reactRouterResolver: FrameworkResolver = {
     const arg = firstArgumentText(lines, ref.line, ref.column, verb);
     if (arg === null) return null;
     let href = parseHrefExpression(arg);
+    // `navigate(paths.auth.login.getHref())`: a route-config object's href.
+    if (!href) {
+      const configured = configHrefExpression(arg, ref.filePath, context);
+      if (configured) href = parseHrefExpression(configured);
+    }
     if (!href) {
       const enclosing = context.getNodeById?.(ref.fromNodeId);
       const start = enclosing && enclosing.filePath === ref.filePath ? enclosing.startLine : Math.max(1, ref.line - 40);
diff --git a/src/resolution/frameworks/react.ts b/src/resolution/frameworks/react.ts
index 863aa764ea..50cc178fe1 100644
--- a/src/resolution/frameworks/react.ts
+++ b/src/resolution/frameworks/react.ts
@@ -5,17 +5,24 @@
  * Next.js pages, route handlers and navigation are `nextjs.ts`'s.
  */
 
-import { Node } from '../../types';
-import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
+import { Language, Node } from '../../types';
+import { FrameworkExtractionResult, FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { dependsOn } from './package-deps';
+import { resolveImportPath } from '../import-resolver';
+import { extractLocalExportAliases } from '../alias-binding';
+import { stripCommentsForRegex } from '../strip-comments';
+import { makeLineAt } from '../synth-utils';
+import { isTestPath } from '../../search/query-utils';
+import { matchBracket, skipString } from './object-literal';
+
+/** The languages React components, hooks and contexts are written and used in. */
+const REACT_SCRIPT_LANGUAGES: ReadonlySet<string> = new Set(['typescript', 'javascript', 'tsx', 'jsx']);
 
 export const reactResolver: FrameworkResolver = {
   name: 'react',
   // Includes 'tsx'/'jsx' so route extraction runs on JSX files (where
   // `<Route element={<X/>}>` routes live) — without them the .tsx/.jsx grammars
   // were filtered out of the extract pass and those routes were never indexed.
-  // (resolve() is unaffected — it runs for every detected framework regardless
-  // of language; only the extract pass filters on `languages`.)
   languages: ['javascript', 'typescript', 'tsx', 'jsx'],
 
   detect(context: ResolutionContext): boolean {
@@ -27,7 +34,35 @@ export const reactResolver: FrameworkResolver = {
     return allFiles.some((f) => f.endsWith('.jsx') || f.endsWith('.tsx'));
   },
 
+  // A data-router `lazy: () => import('./routes/x')` route names a module, not
+  // a symbol; a route's `layout:MainLayout` names the component around it.
+  claimsReference(name: string): boolean {
+    return name.startsWith(LAZY_ROUTE_PREFIX) || name.startsWith(LAYOUT_PREFIX);
+  },
+
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // Components, hooks and contexts are a script's: halo's Java
+    // `import org.springframework…SecurityContext` is no React context.
+    if (!REACT_SCRIPT_LANGUAGES.has(ref.language)) return null;
+    if (ref.referenceName.startsWith(LAZY_ROUTE_PREFIX)) {
+      const target = lazyRouteComponent(ref.referenceName.slice(LAZY_ROUTE_PREFIX.length), ref.filePath, context);
+      return target ? { original: ref, targetNodeId: target, confidence: 0.9, resolvedBy: 'framework' } : null;
+    }
+    // The layout a route renders inside: what happens in it — its header's
+    // links, its logout — happens on the route's screen too.
+    if (ref.referenceName.startsWith(LAYOUT_PREFIX)) {
+      const target = layoutComponent(ref.referenceName.slice(LAYOUT_PREFIX.length), ref, context);
+      return target ? { original: ref, targetNodeId: target, confidence: 0.9, resolvedBy: 'framework', metadata: { layout: true } } : null;
+    }
+    // A component, hook or context the file IMPORTS is the import's: the
+    // package's (`useQuery` from `@tanstack/react-query`, `<Button>` from a UI
+    // kit), or the module the import names, which import resolution finds.
+    // Framework resolution runs first, and a name lookup here bound trpc's
+    // tests' `useQuery` to a hook nested in one of trpc's own factories.
+    if (context.getImportMappings?.(ref.filePath, ref.language)?.some((m) => m.localName === ref.referenceName)) {
+      return null;
+    }
+
     // Pattern 1: Component references (PascalCase). Only from JSX-capable
     // files — a component is USED in markup, which only parses in .tsx/.jsx.
     // Without this gate, every PascalCase TYPE reference in plain .ts files
@@ -41,6 +76,16 @@ export const reactResolver: FrameworkResolver = {
       isPascalCase(ref.referenceName) &&
       !isBuiltInType(ref.referenceName)
     ) {
+      // What a route renders, when its own file declares it: the module a
+      // `const RegisterPage = Loadable(lazy(() => import('pages/auth/Register')))`
+      // loads, or else that declaration, which name matching binds — never a
+      // same-named component in another app of the repository.
+      if (ref.fromNodeId.startsWith(`route:${ref.filePath}:`)) {
+        const own = declaredComponent(ref.referenceName, ref.filePath, context);
+        if (own !== undefined) {
+          return own ? { original: ref, targetNodeId: own, confidence: 0.9, resolvedBy: 'framework' } : null;
+        }
+      }
       const result = resolveComponent(ref.referenceName, ref.filePath, context);
       if (result) {
         return {
@@ -54,7 +99,7 @@ export const reactResolver: FrameworkResolver = {
 
     // Pattern 2: Hook references (use*)
     if (ref.referenceName.startsWith('use') && ref.referenceName.length > 3) {
-      const result = resolveHook(ref.referenceName, context);
+      const result = resolveHook(ref.referenceName, ref.filePath, context, ref.language);
       if (result) {
         return {
           original: ref,
@@ -67,7 +112,7 @@ export const reactResolver: FrameworkResolver = {
 
     // Pattern 3: Context references
     if (ref.referenceName.endsWith('Context') || ref.referenceName.endsWith('Provider')) {
-      const result = resolveContext(ref.referenceName, context);
+      const result = resolveContext(ref.referenceName, ref, context);
       if (result) {
         return {
           original: ref,
@@ -99,8 +144,9 @@ export const reactResolver: FrameworkResolver = {
     // routes live in JSX files and were previously skipped entirely.
 
     // Read only each opening tag's own attributes, including expression values.
-    const declarations = scanRouteDeclarations(content, !/\.(?:ts|mts|cts)$/.test(filePath));
-    for (const { path: routePath, component, at } of declarations) {
+    const declarations = scanRouteDeclarations(content, allowsJsx(filePath));
+    for (const route of declarations) {
+      const { path: routePath, parts, at } = route;
       const line = content.slice(0, at).split('\n').length;
       const routeNode: Node = {
         id: `route:${filePath}:${line}:${routePath}`,
@@ -114,48 +160,481 @@ export const reactResolver: FrameworkResolver = {
         endColumn: 0,
         language: filePath.endsWith('.tsx') ? 'tsx' : 'jsx',
         updatedAt: now,
+        // A path built from a constant (`paths.app.root.path`) is named in postExtract.
+        ...(parts.some((p) => p.expr) ? { signature: ROUTE_PARTS_PREFIX + JSON.stringify(parts) } : {}),
       };
       nodes.push(routeNode);
-      if (component) {
-        references.push({
-          fromNodeId: routeNode.id,
-          referenceName: component,
-          referenceKind: 'references',
-          line,
-          column: 0,
-          filePath,
-          language: filePath.endsWith('.tsx') ? 'tsx' : 'jsx',
-        });
-      }
+      references.push(...routeReferences(route, routeNode.id, filePath, line));
     }
 
     // Next.js pages and route handlers are `frameworks/nextjs.ts`'s.
 
     return { nodes, references };
   },
+
+  /**
+   * Name the routes whose path is built from a constant — bulletproof-react's
+   * `path: paths.app.discussions.path` under `path: paths.app.root.path` is
+   * `/app/discussions` — by reading the constant's object literal where it is
+   * declared. Idempotent: the parts ride on the node's signature.
+   */
+  postExtract(context: ResolutionContext): Node[] {
+    const updates: Node[] = [];
+    for (const route of context.getNodesByKind('route')) {
+      if (!route.signature?.startsWith(ROUTE_PARTS_PREFIX)) continue;
+      let parts: RoutePart[];
+      try {
+        parts = JSON.parse(route.signature.slice(ROUTE_PARTS_PREFIX.length)) as RoutePart[];
+      } catch {
+        continue;
+      }
+      const values = parts.map((p) => p.lit ?? (p.expr ? constantPathValue(p.expr, route.filePath, context) : null));
+      if (values.some((v) => v === null)) continue;
+      const name = composeRoutePath(values as string[]);
+      if (name !== route.name) updates.push({ ...route, name });
+    }
+    return updates;
+  },
+
+  /** The routes of tables another file hands the router (`tableRoutes`). */
+  crossFileNodes(context: ResolutionContext) {
+    return { kind: 'route', owns: isTableRoute, ...tableRoutes(context) };
+  },
 };
 
+const LAZY_ROUTE_PREFIX = 'lazy-import:';
+const ROUTE_PARTS_PREFIX = 'route-parts:';
+const LAYOUT_PREFIX = 'layout:';
+
+/** One segment of a nested route's path: a literal, or a constant's member expression. */
+interface RoutePart {
+  lit?: string;
+  expr?: string;
+}
+
+/** React Router's nesting: a child path is relative unless it starts with `/`. */
+function composeRoutePath(parts: string[]): string {
+  let path = '';
+  for (const part of parts) {
+    if (part.startsWith('/')) path = part;
+    else if (part) path = `${path.replace(/\/+$/, '')}/${part}`;
+  }
+  return ('/' + path.replace(/^\/+/, '')).replace(/\/{2,}/g, '/').replace(/(.)\/$/, '$1');
+}
+
+/**
+ * The string a member expression like `paths.app.root.path` reads from a
+ * constant object literal — the constant found through the route file's
+ * import of its root name, or in the file itself.
+ */
+function constantPathValue(expr: string, fromFile: string, context: ResolutionContext): string | null {
+  const [root, ...keys] = expr.split('.');
+  if (!root || keys.length === 0) return null;
+  let file = fromFile;
+  let name = root;
+  const mapping = context.getImportMappings(fromFile, 'tsx').find((m) => m.localName === root) ??
+    context.getImportMappings(fromFile, 'typescript').find((m) => m.localName === root);
+  if (mapping) {
+    const resolved = resolveImportPath(mapping.source, fromFile, 'typescript', context);
+    if (!resolved) return null;
+    file = resolved;
+    if (mapping.exportedName && mapping.exportedName !== 'default' && mapping.exportedName !== '*') name = mapping.exportedName;
+  }
+  const decl = context.getNodesInFile(file).find((n) => n.name === name && (n.kind === 'constant' || n.kind === 'variable'));
+  if (!decl) return null;
+  const lines = context.readFile(file)?.split('\n') ?? [];
+  const text = lines.slice(decl.startLine - 1, decl.endLine).join('\n');
+  const open = text.indexOf('{', Math.max(0, text.search(new RegExp(`\\b${name}\\b`))));
+  return open < 0 ? null : readObjectPath(text, open, keys);
+}
+
+/**
+ * The href a route-config object names — `paths.app.discussion.getHref(id)`
+ * or `paths.app.discussion.path` against `export const paths = { app: {
+ * discussion: { path: 'discussions/:discussionId', getHref: (id: string) =>
+ * \`/app/discussions/${id}\` } } }` (bulletproof-react's `config/paths.ts`)
+ * — as the string or template literal it returns, ready for the href reader.
+ * A `${…}` glued to a segment (a `?redirectTo=` suffix) is dropped; one
+ * that is a whole segment stays a hole. Null for anything else.
+ */
+export function configHrefExpression(expr: string, fromFile: string, context: ResolutionContext): string | null {
+  const m = /^\s*([A-Za-z_$][\w$]*)((?:\s*\??\.\s*[A-Za-z_$][\w$]*)+)\s*(\((?:[^()]|\([^()]*\))*\))?\s*$/.exec(expr);
+  if (!m) return null;
+  const root = m[1]!;
+  const keys = m[2]!.split('.').map((k) => k.replace(/[?\s]/g, '')).filter(Boolean);
+  let file = fromFile;
+  let name = root;
+  const mapping = context.getImportMappings(fromFile, 'tsx').find((x) => x.localName === root) ??
+    context.getImportMappings(fromFile, 'typescript').find((x) => x.localName === root);
+  if (mapping) {
+    const resolved = resolveImportPath(mapping.source, fromFile, 'typescript', context);
+    if (!resolved) return null;
+    file = resolved;
+    if (mapping.exportedName && mapping.exportedName !== 'default' && mapping.exportedName !== '*') name = mapping.exportedName;
+  }
+  const decl = context.getNodesInFile(file).find((n) => n.name === name && (n.kind === 'constant' || n.kind === 'variable'));
+  if (!decl) return null;
+  const lines = context.readFile(file)?.split('\n') ?? [];
+  const text = lines.slice(decl.startLine - 1, decl.endLine).join('\n');
+  const open = text.indexOf('{', Math.max(0, text.search(new RegExp(`\\b${name}\\b`))));
+  if (open < 0) return null;
+  let value = readObjectValue(text, open, keys);
+  if (value === null) return null;
+  // A function's value is what it returns: `(id: string) => \`/app/…\``, `() => { return '/'; }`.
+  if (m[3] !== undefined) {
+    const body = /^(?:async\s+)?(?:\([^()]*(?:\([^()]*\)[^()]*)*\)|[A-Za-z_$][\w$]*)\s*(?::\s*[^=]+?)?=>\s*/.exec(value);
+    if (!body) return null;
+    value = value.slice(body[0].length).trim();
+    if (value.startsWith('{')) value = /\breturn\s+([`'"][\s\S]*?[`'"])\s*;?\s*}/.exec(value)?.[1] ?? '';
+  }
+  if (!/^[`'"]/.test(value)) return null;
+  // `/auth/login${redirectTo ? … : ''}`: a hole glued to a segment is a suffix, not a segment.
+  return value.startsWith('`') ? dropGluedTemplateHoles(value) : value;
+}
+
+/** Remove each `${…}` of a template literal that is not a whole path segment. */
+function dropGluedTemplateHoles(template: string): string {
+  let out = '';
+  for (let i = 0; i < template.length; i++) {
+    if (template[i] === '$' && template[i + 1] === '{') {
+      let depth = 0;
+      let j = i + 1;
+      for (; j < template.length; j++) {
+        if (template[j] === '{') depth++;
+        else if (template[j] === '}' && --depth === 0) break;
+      }
+      const hole = template.slice(i, j + 1);
+      const next = template[j + 1];
+      if (out.endsWith('/') && (next === '/' || next === '`' || next === '?' || next === undefined)) out += hole;
+      i = j;
+      continue;
+    }
+    out += template[i];
+  }
+  return out;
+}
+
+/** Walk `keys` into the object literal opening at `at`; the final value's source text, or null. */
+function readObjectValue(text: string, at: number, keys: string[]): string | null {
+  const skipString = (j: number): number => {
+    const quote = text[j]!;
+    for (j++; j < text.length && text[j] !== quote; j++) if (text[j] === '\\') j++;
+    return j + 1;
+  };
+  const skipValue = (j: number): number => {
+    let depth = 0;
+    for (; j < text.length; j++) {
+      const ch = text[j]!;
+      if (ch === '"' || ch === "'" || ch === '`') { j = skipString(j) - 1; continue; }
+      if (ch === '{' || ch === '[' || ch === '(') depth++;
+      else if (ch === '}' || ch === ']' || ch === ')') { if (depth === 0) return j; depth--; }
+      else if (ch === ',' && depth === 0) return j;
+    }
+    return j;
+  };
+  let i = at + 1;
+  while (i < text.length) {
+    const m = /^\s*(?:([A-Za-z_$][\w$]*)|["']([^"']+)["'])\s*:\s*/.exec(text.slice(i));
+    if (!m) {
+      const next = skipValue(i);
+      if (text[next] !== ',') return null;
+      i = next + 1;
+      continue;
+    }
+    const key = m[1] ?? m[2]!;
+    const valueAt = i + m[0].length;
+    const end = skipValue(valueAt);
+    if (key === keys[0]) {
+      if (keys.length === 1) return text.slice(valueAt, end).trim();
+      return text[valueAt] === '{' ? readObjectValue(text, valueAt, keys.slice(1)) : null;
+    }
+    if (text[end] !== ',') return null;
+    i = end + 1;
+  }
+  return null;
+}
+
+/** Walk `keys` into the object literal opening at `at`; the string literal at the end, or null. */
+function readObjectPath(text: string, at: number, keys: string[]): string | null {
+  const skipString = (j: number): number => {
+    const quote = text[j]!;
+    for (j++; j < text.length && text[j] !== quote; j++) if (text[j] === '\\') j++;
+    return j + 1;
+  };
+  const skipValue = (j: number): number => {
+    let depth = 0;
+    for (; j < text.length; j++) {
+      const ch = text[j]!;
+      if (ch === '"' || ch === "'" || ch === '`') { j = skipString(j) - 1; continue; }
+      if (ch === '{' || ch === '[' || ch === '(') depth++;
+      else if (ch === '}' || ch === ']' || ch === ')') { if (depth === 0) return j; depth--; }
+      else if (ch === ',' && depth === 0) return j;
+    }
+    return j;
+  };
+  let i = at + 1;
+  while (i < text.length) {
+    const m = /^\s*(?:([A-Za-z_$][\w$]*)|["']([^"']+)["'])\s*:\s*/.exec(text.slice(i));
+    if (!m) {
+      const next = skipValue(i);
+      if (text[next] !== ',') return null;
+      i = next + 1;
+      continue;
+    }
+    const key = m[1] ?? m[2]!;
+    const valueAt = i + m[0].length;
+    if (key === keys[0]) {
+      if (keys.length === 1) {
+        const lit = /^(["'])((?:\\.|(?!\1).)*)\1/.exec(text.slice(valueAt));
+        return lit ? lit[2]! : null;
+      }
+      return text[valueAt] === '{' ? readObjectPath(text, valueAt, keys.slice(1)) : null;
+    }
+    const end = skipValue(valueAt);
+    if (text[end] !== ',') return null;
+    i = end + 1;
+  }
+  return null;
+}
+
+/** The component a lazy route module renders: its default export, else its `Component` export. */
+function lazyRouteComponent(spec: string, fromFile: string, context: ResolutionContext): string | null {
+  const file = resolveImportPath(spec, fromFile, 'typescript', context);
+  if (!file) return null;
+  return exportedComponent(file, 'default', context) ?? exportedComponent(file, 'Component', context);
+}
+
+/** What a module can export as a component: a declaration, or a value holding one. */
+const EXPORTED_COMPONENT_KINDS = new Set(['function', 'component', 'class', 'constant', 'variable']);
+
+/** A barrel can forward another barrel; a few hops settle it. */
+const MAX_REEXPORT_HOPS = 4;
+
+/**
+ * The component `file` exports as `name`: one it declares — `export default
+ * Page`, `export function Component`, `export { Page as Component }` — or one
+ * it forwards from the module that declares it, as a barrel `index.ts` does:
+ * `export { default } from './page'`, `export { Page as Component } from
+ * './page'`, or `export * from './page'`, which forwards every name but the
+ * default. As in JavaScript, a name the file exports itself hides one an
+ * `export *` would forward, and a name two `export *` modules both forward is
+ * exported by neither.
+ */
+function exportedComponent(file: string, name: string, context: ResolutionContext, visited: ReadonlySet<string> = new Set()): string | null {
+  if (visited.has(file) || visited.size > MAX_REEXPORT_HOPS) return null;
+  const local = ownExport(stripCommentsForRegex(context.readFile(file) ?? '', 'typescript'), name);
+  if (local) return context.getNodesInFile(file).find((n) => n.name === local && EXPORTED_COMPONENT_KINDS.has(n.kind))?.id ?? null;
+  const language = scriptLanguage(file);
+  const reExports = context.getReExports?.(file, language) ?? [];
+  const through = new Set(visited).add(file);
+  const forwarded = (source: string, exported: string): string | null => {
+    const target = resolveImportPath(source, file, language, context);
+    return target ? exportedComponent(target, exported, context, through) : null;
+  };
+  for (const re of reExports) {
+    if (re.kind === 'named' && re.exportedName === name) return forwarded(re.source, re.originalName);
+  }
+  if (name === 'default') return null;
+  let found: string | null = null;
+  for (const re of reExports) {
+    if (re.kind !== 'wildcard') continue;
+    const id = forwarded(re.source, name);
+    if (id && found && id !== found) return null;
+    found ??= id;
+  }
+  return found;
+}
+
+/**
+ * The local name a module's own `export` gives `name`: `export default Page`
+ * (or `function Page`, `class Page`), `export function Component`, `export
+ * const Component`, `export { Page as Component }`. Null when it has none.
+ */
+function ownExport(source: string, name: string): string | null {
+  if (name === 'default') {
+    const declared = /\bexport\s+default\s+(?:async\s+)?(?:function\s*\*?\s*|class\s+)?([A-Za-z_$][\w$]*)/.exec(source)?.[1];
+    if (declared) return declared;
+  } else if (new RegExp(String.raw`\bexport\s+(?:async\s+)?(?:const|let|var|function|class)\s+${name.replace(/\$/g, '\\$')}(?![\w$])`).test(source)) {
+    return name;
+  }
+  return extractLocalExportAliases(source).find((a) => a.exportedName === name)?.localName ?? null;
+}
+
+/**
+ * A component `filePath` holds in a value of its own, for a route there that
+ * renders it: the component of the module a lazy declaration loads (`lazy(()
+ * => import('./x'))`, wrapped or not), null for a value that loads none it
+ * can find — the value is then the binding, by name — and undefined when the
+ * file declares no such value (a function or class component is found the
+ * usual way).
+ */
+function declaredComponent(name: string, filePath: string, context: ResolutionContext): string | null | undefined {
+  const own = (context.getNodesInFileNamed?.(filePath, name) ?? context.getNodesInFile(filePath).filter((n) => n.name === name))
+    .find((n) => n.kind === 'constant' || n.kind === 'variable');
+  if (!own) return undefined;
+  const lines = context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? [];
+  const text = lines.slice(own.startLine - 1, own.endLine).join('\n');
+  const spec = /=>\s*import\s*\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1];
+  return spec ? lazyRouteComponent(spec, filePath, context) : null;
+}
+
+/**
+ * The component a route's `layout:` reference names, found the way the
+ * route's own component is: through the route file's import of it, else
+ * declared in reach — or a lazily loaded layout module's component.
+ */
+function layoutComponent(spec: string, ref: UnresolvedRef, context: ResolutionContext): string | null {
+  if (spec.startsWith(LAZY_ROUTE_PREFIX)) return lazyRouteComponent(spec.slice(LAZY_ROUTE_PREFIX.length), ref.filePath, context);
+  const mapping = context.getImportMappings(ref.filePath, ref.language).find((m) => m.localName === spec);
+  if (!mapping) return resolveComponent(spec, ref.filePath, context);
+  const viaImport = context.resolveImport?.({ ...ref, referenceName: spec })?.targetNodeId;
+  if (viaImport) return viaImport;
+  // `import { default as AppRoot } from './routes/app/root'`: read the module the
+  // import names — never a same-named component somewhere else.
+  if (mapping.isDefault || mapping.exportedName === 'default') return lazyRouteComponent(mapping.source, ref.filePath, context);
+  const file = resolveImportPath(mapping.source, ref.filePath, ref.language, context);
+  return file ? context.getNodesInFile(file).find((n) => n.name === mapping.exportedName && COMPONENT_KINDS.has(n.kind))?.id ?? null : null;
+}
+
 interface RouteDeclaration {
+  /** The route's full path as far as the file tells: nesting composed, a constant part shown as `{expr}`. */
   path: string;
+  /** Its path parts, outermost first. */
+  parts: RoutePart[];
   component?: string;
+  /** A `lazy: () => import('…')` module. */
+  lazy?: string;
+  /**
+   * The route objects around it that render something, outermost first: the
+   * layouts it renders inside, each a component name or `lazy-import:…`.
+   */
+  layouts: string[];
+  at: number;
+}
+
+/** A path-bearing route object or `<Route>` element, with the extent its children sit in. */
+interface RouteScope {
+  part: RoutePart;
+  /** Where the route is named: its `path` (or `index`) property, or its `<Route` tag. */
+  at: number;
+  /** Its `{` or `<`: the scope holds every scope that opens after this and closes by `end`. */
+  start: number;
+  end: number;
+  component?: string;
+  lazy?: string;
+  /** A `<Route>` element: a route even with nothing to render (a `<Route path>` that only groups others). */
+  jsx?: boolean;
+  /**
+   * A layout at no address of its own: `{ element: <Shell/>, children }`, with
+   * neither `path` nor `index`, or a `<Route element={<RequireAuth/>}>` (no
+   * `path`, or `path=""`) around other `<Route>`s.
+   */
+  pathless?: boolean;
+  /** A `<Route index>` (or a `path=""` with nothing inside): the page at its parent's address. */
+  index?: boolean;
+  /** A `<Route path={paths.home}>`: an address the file does not spell out, so no route of its own. */
+  opaque?: boolean;
+}
+
+/**
+ * An identifier written where React Router reads routes — `[MainRoutes,
+ * LoginRoutes]`, `...ApiAuthorizationRoutes`, `children: adminRoutes`,
+ * `useRoutes(routes(isLoggedIn))` — naming a table declared elsewhere.
+ */
+interface TableName {
+  name: string;
+  /** `routes(isLoggedIn)`: the table is what the function returns. */
+  call: boolean;
+  /** Where it is written; inside a table, the route objects around it are its mount. */
   at: number;
 }
 
-/** Structural scanner: strings, comments, JSX and balanced expressions are units. */
+/** A place a file hands routes to React Router. */
+interface TableUse {
+  /** The table as the site names it; absent when the literal is written there (`useRoutes([…])`). */
+  name?: TableName;
+  /** The literal written there. */
+  literal?: number;
+  /** The routes around the site, outermost first: where the table is mounted. */
+  prefix: RoutePart[];
+  /** The layouts around the site, outermost first: what the table's routes render inside. */
+  layouts: string[];
+}
+
+interface RouteScan {
+  routes: RouteDeclaration[];
+  /** The tables a table names as more of its routes, each with the path parts and layouts it sits under. */
+  names: Array<TableName & { prefix: RoutePart[]; layouts: string[] }>;
+  /** Where the file hands a table to the router. */
+  uses: TableUse[];
+}
+
+/**
+ * The calls that hand React Router its routes: a data router, JSX routes made
+ * into one, or the `useRoutes` hook. Every route object in a file that makes
+ * one is a route.
+ */
+const ROUTER_CALL = /\b(?:createBrowserRouter|createHashRouter|createMemoryRouter|createRoutesFromElements|useRoutes)\b/;
+
+/** A router written as an element; the `<Route>`s at its top are at `/`. */
+const ROUTER_ELEMENT = /^(?:Browser|Hash|Memory|Native|Static|History|unstable_History)?Router$/;
+
+/** A route list's entry that names more routes: `MainRoutes`, `...authRoutes`, `...routes(user)`. */
+const NAMED_ENTRY = /^(?:\.\.\.\s*)?([A-Za-z_$][\w$]*)\s*(\([\s\S]*\))?$/;
+
+/** The routes a file's own text declares: its `<Route>` elements and, in a file that makes a router, its route objects. */
 function scanRouteDeclarations(source: string, allowJsx: boolean): RouteDeclaration[] {
-  const routes: RouteDeclaration[] = [];
-  const dataRouter = /\b(?:createBrowserRouter|createHashRouter|createMemoryRouter|createRoutesFromElements)\b/.test(source);
-  if (!dataRouter && !/<Route\b/.test(source)) return routes;
+  const objects = ROUTER_CALL.test(source);
+  if (!objects && !/<Route\b/.test(source)) return [];
+  return scanRoutes(source, allowJsx, { objects }).routes;
+}
+
+/**
+ * Structural scanner: strings, comments, JSX and balanced expressions are units.
+ *
+ * With `objects`, every route object in the file is read. With `table`, only
+ * the literal at that offset is — a table another file hands the router —
+ * its routes sitting under `table.prefix` and inside `table.layouts`, and the
+ * identifiers it names as more routes come back in `names`. With `uses`, the
+ * places the file hands a table to the router come back too.
+ *
+ * A route that renders something around others — a route object with
+ * `children`, a `<Route element>` with `<Route>`s inside — is the layout they
+ * render inside, and the address is theirs when one of them claims it: an
+ * `index` route, or a `''` path. A `<Route path>` that renders nothing only
+ * groups them; it is a route of its own until one of them claims its address.
+ */
+function scanRoutes(
+  source: string,
+  allowJsx: boolean,
+  options: { objects?: boolean; table?: { at: number; prefix: RoutePart[]; layouts?: string[] }; uses?: boolean }
+): RouteScan {
+  const scopes: RouteScope[] = [];
+  const names: TableName[] = [];
+  const sites: Array<{ name?: TableName; literal?: number; at: number }> = [];
+  /** Every `<Route>` tag: where it is, the props it spreads, its `path` expression. */
+  const routeTags: Array<{ at: number; spreads: string[]; path?: string }> = [];
+  /** Where the router itself is written (`createRoutesFromElements(…)`, `<BrowserRouter>…</BrowserRouter>`): its routes start at `/`. */
+  const routers: Array<{ start: number; end: number }> = [];
+  const objects = Boolean(options.objects || options.table);
   const literal = (value: string): string | undefined => {
     const match = /^(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)')$/.exec(value.trim());
     return match ? match[1] ?? match[2] : undefined;
   };
+  // A guard or boundary wrapping the screen (`<ProtectedRoute><AppRoot/></ProtectedRoute>`,
+  // `<AdminWrapper><Users/></AdminWrapper>`, `<Suspense>`) is not what the route
+  // renders; the first element inside it is.
+  const WRAPPER = /^(?:Suspense|ErrorBoundary|\w*(?:Guard|Provider|Wrapper|Route)|(?:Protected|Private|Auth|Require\w*)\w*)$/;
   const componentName = (value: string | undefined, jsx: boolean): string | undefined => {
     if (!value) return undefined;
-    const match = jsx
-      ? /^\s*<\s*([A-Z][\w]*)\s*(?=[\s/>])/.exec(value)
-      : /^\s*([A-Z][\w]*)\s*$/.exec(value);
-    return match?.[1];
+    if (!jsx) return /^\s*([A-Z][\w]*)\s*$/.exec(value)?.[1];
+    const inner = value.replace(/^\s*(?:\(\s*)?/, '');
+    if (!/^<\s*[A-Z]/.test(inner)) return undefined;
+    const { own, props } = elementTags(inner);
+    const content = (t: string): boolean => !WRAPPER.test(t) && t !== 'Outlet';
+    // Then a page handed to a guard as a prop (`<PrivateRoute component={<Profile />} />`),
+    // then the innermost wrapper: `<RequireAuth><Outlet /></RequireAuth>` renders the guard.
+    return own.find(content) ?? props.find(content) ?? [...own].reverse().find((t) => t !== 'Outlet') ?? own[0];
   };
   // The few characters before `at`, trailing whitespace skipped: enough for the
   // end-anchored checks below without copying the whole prefix per `/` or `<`.
@@ -177,7 +656,44 @@ function scanRouteDeclarations(source: string, allowJsx: boolean): RouteDeclarat
     }
     return at;
   };
-  function unit(at: number): number {
+  // `useRoutes(…)` / `createBrowserRouter(…)` hand the router a table; so does
+  // `AppRoutes.map(…)` when its callback renders a `<Route>` from each item.
+  const routerCall = (at: number): { map?: TableName } | null => {
+    if (!options.uses) return null;
+    let j = at - 1;
+    while (j >= 0 && /\s/.test(source[j]!)) j--;
+    if (source[j] !== 's' && source[j] !== 'r' && source[j] !== 'p') return null;
+    const before = source.slice(Math.max(0, at - 64), at);
+    if (/(?:^|[^\w$.])(?:useRoutes|create(?:Browser|Hash|Memory)Router)\s*$/.test(before)) return {};
+    const map = /(?:^|[^\w$.])([A-Za-z_$][\w$]*)\s*\??\.\s*map\s*$/.exec(before);
+    if (!map) return null;
+    return { map: { name: map[1]!, call: false, at: at - before.length + map.index + map[0].indexOf(map[1]!) } };
+  };
+  const routesFromElements = (at: number): boolean => {
+    let j = at - 1;
+    while (j >= 0 && /\s/.test(source[j]!)) j--;
+    if (source[j] !== 's' && source[j] !== 'n') return false;
+    return /(?:^|[^\w$.])createRoutesFrom(?:Elements|Children)\s*$/.test(source.slice(Math.max(0, at - 40), at));
+  };
+  const settle = (call: { map?: TableName }, open: number, close: number): void => {
+    const argAt = trivia(open + 1);
+    if (argAt >= close) return;
+    if (call.map) {
+      const tags = routeTags.filter((t) => t.at > argAt && t.at < close);
+      if (tags.length > 0 && mapsRouteFields(source.slice(argAt, close), tags)) sites.push({ name: call.map, at: open });
+      return;
+    }
+    if (source[argAt] === '[' || source[argAt] === '{') {
+      sites.push({ literal: argAt, at: open });
+      return;
+    }
+    const id = /^[A-Za-z_$][\w$]*/.exec(source.slice(argAt, close));
+    if (!id || /^createRoutesFrom(?:Elements|Children)$/.test(id[0])) return;
+    const next = trivia(argAt + id[0].length);
+    if (next === close || source[next] === ',') sites.push({ name: { name: id[0], call: false, at: argAt }, at: open });
+    else if (source[next] === '(') sites.push({ name: { name: id[0], call: true, at: argAt }, at: open });
+  };
+  function unit(at: number, routeList = false): number {
     const ch = source[at];
     if (ch === '"' || ch === "'" || ch === '`') {
       let i = at + 1;
@@ -213,72 +729,529 @@ function scanRouteDeclarations(source: string, allowJsx: boolean): RouteDeclarat
     }
     const close = ch === '{' ? '}' : ch === '[' ? ']' : ch === '(' ? ')' : undefined;
     if (!close) return at + 1;
+    const call = ch === '(' ? routerCall(at) : null;
+    const router = ch === '(' && routesFromElements(at);
     let i = at + 1;
     const fields = new Map<string, { value: string; at: number }>();
     while ((i = trivia(i)) < source.length && source[i] !== close) {
       // A property must start at an object entry, never inside its value.
       const key = ch === '{' ? /^(?:([A-Za-z_$][\w$]*)|["']([^"']+)["'])\s*:/.exec(source.slice(i)) : null;
       if (key) {
+        const name = key[1] ?? key[2]!;
         const start = i;
         const valueAt = trivia(i + key[0].length);
+        // A route's children are more routes, written in place or named.
+        const children = objects && name === 'children';
         i = valueAt;
         let valueEnd = i;
         while ((i = trivia(i)) < source.length && source[i] !== ',' && source[i] !== close) {
-          i = unit(i);
+          i = unit(i, children);
           valueEnd = i;
         }
-        fields.set(key[1] ?? key[2]!, { value: source.slice(valueAt, valueEnd).trim(), at: start });
+        const value = source.slice(valueAt, valueEnd).trim();
+        fields.set(name, { value, at: start });
+        if (children && /^[A-Za-z_$][\w$]*$/.test(value)) names.push({ name: value, call: false, at: valueAt });
       } else {
         // Skip a whole entry (spread, method, shorthand), but still visit nested units.
+        const entry = i;
         while ((i = trivia(i)) < source.length && source[i] !== ',' && source[i] !== close) i = unit(i);
+        if (routeList && ch === '[') {
+          const text = source.slice(entry, i).replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, '').trim();
+          const named = NAMED_ENTRY.exec(text);
+          const args = named?.[2] ? text.length - named[2].length : -1;
+          if (named && (args < 0 || matchBracket(text, args) === text.length - 1)) {
+            names.push({ name: named[1]!, call: args >= 0, at: entry });
+          }
+        }
       }
       if (source[i] === ',') i++;
     }
-    if (dataRouter && ch === '{' && source[i] === close) {
+    if (objects && ch === '{' && source[i] === close) {
       const pathField = fields.get('path');
       const path = pathField && literal(pathField.value);
+      const expr = pathField && path === undefined && /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(pathField.value) ? pathField.value : undefined;
       const component = componentName(fields.get('element')?.value, true)
         ?? componentName(fields.get('Component')?.value, false);
-      if (path !== undefined && component) routes.push({ path: path || '/', component, at: pathField!.at });
+      const lazy = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/.exec(fields.get('lazy')?.value ?? '')?.[1];
+      const index = fields.get('index');
+      if (pathField && (path !== undefined || expr)) {
+        scopes.push({ part: path !== undefined ? { lit: path } : { expr }, at: pathField.at, start: at, end: i, component, lazy });
+      } else if (!pathField && index?.value === 'true') {
+        // `{ index: true, element: <Home /> }` is the page at its parent's address.
+        scopes.push({ part: { lit: '' }, at: index.at, start: at, end: i, component, lazy });
+      } else if (!pathField && (component || lazy) && fields.has('children')) {
+        scopes.push({ part: { lit: '' }, at, start: at, end: i, component, lazy, pathless: true });
+      }
     }
+    if (call && i < source.length) settle(call, at, i);
+    if (router) routers.push({ start: at, end: i });
     return i < source.length ? i + 1 : i;
   }
   function jsx(at: number): number {
     const tag = /^<([\w.:-]*)/.exec(source.slice(at))!;
     let i = at + tag[0].length;
     const attrs = new Map<string, string>();
+    const spreads: string[] = [];
     while ((i = trivia(i)) < source.length && source[i] !== '>' && !source.startsWith('/>', i)) {
       const attr = /^[\w:-]+/.exec(source.slice(i));
-      if (!attr) { i = unit(i); continue; }
+      if (!attr) {
+        const from = i;
+        i = unit(i);
+        const spread = /^\{\s*\.\.\.\s*([A-Za-z_$][\w$]*)\s*\}$/.exec(source.slice(from, i));
+        if (spread) spreads.push(spread[1]!);
+        continue;
+      }
       i = trivia(i + attr[0].length);
-      if (source[i] !== '=') continue;
+      // A bare attribute is `true`: `<Route index element={<Home/>}/>`.
+      if (source[i] !== '=') {
+        attrs.set(attr[0], '{true}');
+        continue;
+      }
       i = trivia(i + 1);
       const start = i;
       i = unit(i);
       attrs.set(attr[0], source.slice(start, i));
     }
+    let scope: RouteScope | undefined;
+    // A `<Route>` with no address of its own, settled once its children are read.
+    let addressless: { scope: RouteScope; tags: number; page: boolean } | undefined;
+    // `<BrowserRouter>…</BrowserRouter>`: the routes at its top are at `/`.
+    const router = ROUTER_ELEMENT.test(tag[1]!) ? { start: at, end: source.length } : undefined;
+    if (router) routers.push(router);
     if (tag[1] === 'Route' && i < source.length) {
-      const path = literal(attrs.get('path') ?? '');
+      const pathText = attrs.get('path');
       const expression = (name: string) => attrs.get(name)?.replace(/^\{([\s\S]*)\}$/, '$1');
-      const component = componentName(expression('component'), false) ?? componentName(expression('element'), true);
-      if (path) routes.push({ path, component, at });
+      // `path="team"`, or the same string in braces: `path={"team"}`.
+      const path = literal(pathText ?? '') ?? literal(expression('path') ?? '');
+      routeTags.push({ at, spreads, path: expression('path')?.trim() });
+      // `element={<Outlet />}` renders the route inside it and nothing of its own.
+      const element = componentName(expression('element'), true)?.replace(/^Outlet$/, '') || undefined;
+      const component = componentName(expression('component'), false) ?? element;
+      const lazy = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/.exec(expression('lazy') ?? '')?.[1];
+      const route: RouteScope = { part: { lit: path ?? '' }, at, start: at, end: source.length, component, lazy, jsx: true };
+      if (path) scope = route;
+      else if (pathText === undefined || path === '') {
+        // `<Route index element={<Home/>}/>` is the page at its parent's address.
+        if (/^\{\s*true\s*\}$/.test(attrs.get('index') ?? '')) {
+          if (component || lazy) scope = { ...route, index: true };
+        } else {
+          // Otherwise it is a layout at no address of its own when routes sit
+          // inside it (`<Route element={<RequireAuth/>}>`), and `path=""` with
+          // an `element` and nothing inside is the page at its parent's
+          // address. Version 5's `<Route path="" component={NotFound}/>` is a
+          // catch-all, which no address names.
+          addressless = { scope: route, tags: routeTags.length, page: path === '' && Boolean(element || lazy) };
+        }
+      } else {
+        // `path={paths.home}`: an address the file does not spell out.
+        scope = { ...route, opaque: true };
+      }
+      if (scope) scopes.push(scope);
     }
-    if (source.startsWith('/>', i)) return i + 2;
+    const close = (end: number): number => {
+      if (scope) scope.end = end;
+      if (router) router.end = end;
+      if (addressless) {
+        const { scope: route, tags, page } = addressless;
+        route.end = end;
+        if (routeTags.length > tags) {
+          if (route.component || route.lazy) scopes.push({ ...route, pathless: true });
+        } else if (page) scopes.push({ ...route, index: true });
+      }
+      return end;
+    };
+    if (source.startsWith('/>', i)) return close(i + 2);
     i++;
     while (i < source.length) {
       if (source.startsWith('</', i)) {
         const end = source.indexOf('>', i + 2);
-        return end < 0 ? source.length : end + 1;
+        return close(end < 0 ? source.length : end + 1);
       }
       if (source[i] === '<' && /^<(?:[A-Za-z]|>)/.test(source.slice(i))) i = jsx(i);
       else if (source[i] === '{') i = unit(i);
       else i++;
     }
-    return i;
+    return close(i);
+  }
+  if (options.table) unit(trivia(options.table.at), true);
+  else {
+    let at = 0;
+    while ((at = trivia(at)) < source.length) at = unit(at);
+  }
+  // A child route's path is relative to the routes around it: compose each
+  // rendering route's path from the path-bearing scopes that contain it.
+  const prefix = options.table?.prefix ?? [];
+  const inherited = options.table?.layouts ?? [];
+  const renders = (s: RouteScope): boolean => Boolean(s.component || s.lazy);
+  const holds = (outer: RouteScope, start: number, end: number): boolean => outer.start < start && outer.end >= end;
+  const around = (start: number, end: number): RouteScope[] =>
+    scopes.filter((outer) => holds(outer, start, end)).sort((a, b) => a.start - b.start);
+  const shown = (p: RoutePart): string => p.lit ?? `{${p.expr}}`;
+  const layoutOf = (s: RouteScope): string => s.component ?? LAZY_ROUTE_PREFIX + s.lazy;
+  const partsOf = new Map<RouteScope, RoutePart[]>();
+  const pathOf = new Map<RouteScope, string>();
+  for (const scope of scopes) {
+    const parts = [...prefix, ...around(scope.start, scope.end).map((c) => c.part), scope.part];
+    partsOf.set(scope, parts);
+    pathOf.set(scope, composeRoutePath(parts.map(shown)));
+  }
+  // The page at its parent's address needs that address written down: a
+  // route around it whose path the file spells out, or the router itself. At
+  // the top of a component's own `<Routes>` it is wherever another route
+  // mounts the component (`<Route path="shop/*" element={<Shop/>}>`).
+  const inRouter = (s: RouteScope): boolean => routers.some((r) => r.start < s.start && r.end >= s.end);
+  const addressed = (s: RouteScope): boolean => {
+    if (!s.index) return true;
+    const outer = around(s.start, s.end);
+    return !outer.some((c) => c.opaque) && (outer.some((c) => Boolean(c.part.lit || c.part.expr)) || inRouter(s));
+  };
+  const pages = new Set(scopes.filter((s) => !s.pathless && !s.opaque && (s.jsx || renders(s)) && addressed(s)));
+  const layout = (c: RouteScope): boolean => renders(c) && !c.opaque;
+  const routes: RouteDeclaration[] = [];
+  for (const scope of pages) {
+    const path = pathOf.get(scope)!;
+    // A route around others is the layout they render inside; when one of
+    // them claims its address, the page there is that one — not the layout,
+    // nor a `<Route path>` that only groups them.
+    if (scopes.some((inner) => pages.has(inner) && !inner.jsx === !scope.jsx && renders(inner) &&
+      holds(scope, inner.start, inner.end) && pathOf.get(inner) === path)) continue;
+    // A route object renders inside the route objects around it; a `<Route>`,
+    // inside the routes around it of either kind.
+    const layouts = [...inherited, ...around(scope.start, scope.end)
+      .filter((c) => layout(c) && (scope.jsx || !c.jsx))
+      .map(layoutOf)];
+    routes.push({ path, parts: partsOf.get(scope)!, component: scope.component, lazy: scope.lazy, layouts, at: scope.at });
+  }
+  const mount = (at: number): { parts: RoutePart[]; layouts: string[] } => {
+    const outer = around(at, at);
+    return { parts: outer.map((c) => c.part), layouts: outer.filter(layout).map(layoutOf) };
+  };
+  return {
+    routes: routes.sort((a, b) => a.at - b.at),
+    names: names.map((n) => {
+      const { parts, layouts } = mount(n.at);
+      return { ...n, prefix: [...prefix, ...parts], layouts: [...inherited, ...layouts] };
+    }),
+    uses: sites.map((s) => {
+      const { parts, layouts } = mount(s.at);
+      return { name: s.name, literal: s.literal, prefix: parts, layouts };
+    }),
+  };
+}
+
+/**
+ * True when a `.map` callback renders a `<Route>` from the item's own route
+ * fields — `{...route}`, `{...rest}` destructured from it, `path={route.path}`
+ * or a `path` destructured from it — so the array it maps is a route table.
+ * A `<Route path={item.layout + item.path}>` composes a path the table does
+ * not hold, and a callback that renders links or menu entries maps a menu.
+ */
+function mapsRouteFields(callback: string, tags: ReadonlyArray<{ spreads: string[]; path?: string }>): boolean {
+  const head = /^(?:async\s+)?(?:function\b[^(]*)?\(\s*/.exec(callback);
+  let param: string | undefined;
+  const rest = new Set<string>();
+  const paths = new Set<string>();
+  const bind = (pattern: string): void => {
+    for (const entry of topLevelEntries(pattern.slice(1, -1))) {
+      const spread = /^\.\.\.\s*([A-Za-z_$][\w$]*)$/.exec(entry);
+      if (spread) rest.add(spread[1]!);
+      const path = /^path\s*(?::\s*([A-Za-z_$][\w$]*))?\s*(?:=[\s\S]*)?$/.exec(entry);
+      if (path) paths.add(path[1] ?? 'path');
+    }
+  };
+  if (head) {
+    const at = head[0].length;
+    if (callback[at] === '{') {
+      const close = matchBracket(callback, at);
+      if (close < 0) return false;
+      bind(callback.slice(at, close + 1));
+    } else param = /^[A-Za-z_$][\w$]*/.exec(callback.slice(at))?.[0];
+  } else {
+    param = /^(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(callback)?.[1];
+  }
+  if (param) {
+    // `const { element, ...rest } = route;` in the body.
+    const destructured = new RegExp(`\\b(?:const|let|var)\\s*(\\{[^{}]*\\})\\s*=\\s*${param.replace(/\$/g, '\\$')}\\s*[;\\n]`, 'g');
+    for (const m of callback.matchAll(destructured)) bind(m[1]!);
   }
-  let at = 0;
-  while ((at = trivia(at)) < source.length) at = unit(at);
-  return routes.sort((a, b) => a.at - b.at);
+  const ownPath = param ? new RegExp(`^${param.replace(/\$/g, '\\$')}\\s*\\??\\.\\s*path$`) : null;
+  return tags.some((t) =>
+    t.spreads.some((s) => s === param || rest.has(s)) ||
+    (t.path !== undefined && (ownPath?.test(t.path) || paths.has(t.path))));
+}
+
+/**
+ * The component tags of a JSX element and of what it nests, outermost first
+ * (`own`), and apart from them a page handed over in a `component`,
+ * `element` or `page` attribute (`props`). Any other attribute's elements
+ * are neither: `<Suspense fallback={<Loader />}><AdminPanel /></Suspense>`
+ * renders AdminPanel, never Loader.
+ */
+function elementTags(text: string): { own: string[]; props: string[] } {
+  const own: string[] = [];
+  const props: string[] = [];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== '<') continue;
+    const open = /^<\s*([A-Za-z][\w.:-]*)(?=[\s/>])/.exec(text.slice(i));
+    if (!open) continue;
+    if (/^[A-Z]\w*$/.test(open[1]!)) own.push(open[1]!);
+    // Skip the tag's attributes, expressions and strings whole.
+    let j = i + open[0].length;
+    let attr = '';
+    while (j < text.length && text[j] !== '>') {
+      const ch = text[j]!;
+      const name = /^[A-Za-z_$][\w$:-]*/.exec(text.slice(j, j + 64));
+      if (name) {
+        attr = name[0];
+        j += name[0].length;
+        continue;
+      }
+      const end = ch === '{' ? matchBracket(text, j) : ch === '"' || ch === "'" ? skipString(text, j) : j;
+      if (end < 0) break;
+      if (ch === '{' && /^(?:component|element|page)$/i.test(attr)) {
+        for (const m of text.slice(j, end).matchAll(/<\s*([A-Z]\w*)(?=[\s/>])/g)) props.push(m[1]!);
+      }
+      if (ch === '{' || ch === '"' || ch === "'") attr = '';
+      j = end + 1;
+    }
+    i = j;
+  }
+  return { own, props };
+}
+
+/** The comma-separated entries of a list's inside, nested brackets kept whole. */
+function topLevelEntries(text: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let from = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const end = skipString(text, i);
+      if (end < 0) break;
+      i = end;
+    } else if (ch === '{' || ch === '[' || ch === '(') depth++;
+    else if (ch === '}' || ch === ']' || ch === ')') depth--;
+    else if (ch === ',' && depth === 0) {
+      out.push(text.slice(from, i).trim());
+      from = i + 1;
+    }
+  }
+  out.push(text.slice(from).trim());
+  return out.filter(Boolean);
+}
+
+// =============================================================================
+// Route tables another file hands the router
+// =============================================================================
+
+/** The packages React Router's components and hooks are imported from. */
+const ROUTER_PACKAGES = ['react-router-dom', 'react-router', 'react-router-native'];
+
+/** At most this many tables are read from one project's consumers — a bound, not a budget anyone reaches. */
+const MAX_TABLES = 512;
+
+/** What a file that hands the router a table has to say: `useRoutes`, a data router, or a `<Route>` to map into. */
+const CONSUMER_HINT = /\buseRoutes\b|\bcreate(?:Browser|Hash|Memory)Router\b|<Route\b/;
+
+/** True for a route the table pass made — `route:<file>:<line>:table:<path>` — and for no route extraction makes. */
+export function isTableRoute(node: Node): boolean {
+  return node.kind === 'route' && node.id.startsWith(`route:${node.filePath}:${node.startLine}:table:`);
+}
+
+/** The references that bind a route: what it renders, and the layouts around it. */
+function routeReferences(route: RouteDeclaration, fromNodeId: string, filePath: string, line: number): UnresolvedRef[] {
+  const language = filePath.endsWith('.tsx') ? 'tsx' : 'jsx';
+  const ref = (referenceName: string): UnresolvedRef =>
+    ({ fromNodeId, referenceName, referenceKind: 'references', line, column: 0, filePath, language });
+  const refs: UnresolvedRef[] = [];
+  const target = route.component ?? (route.lazy ? LAZY_ROUTE_PREFIX + route.lazy : undefined);
+  if (target) refs.push(ref(target));
+  for (const layout of route.layouts) refs.push(ref(LAYOUT_PREFIX + layout));
+  return refs;
+}
+
+/**
+ * Routes written in a table that another file hands to the router.
+ *
+ * The ASP.NET Core React template keeps them in `AppRoutes.js` —
+ * `[{ index: true, element: <Home /> }, { path: '/counter', element:
+ * <Counter /> }, …]` — and renders them from `App.js` with
+ * `AppRoutes.map(({ element, ...rest }) => <Route {...rest} element={element} />)`;
+ * codedthemes' admin templates write one route object per file and pass
+ * `[MainRoutes, LoginRoutes]` to `createBrowserRouter`; many apps import
+ * `routes` into `useRoutes(routes)`. The table's own file never names the
+ * router, so its extraction cannot tell it from a menu's `{ path, element }`
+ * list. The evidence is the file that hands it over: a `useRoutes` or
+ * `create*Router` argument, or a `.map` whose callback renders a `<Route>`
+ * from the item's own fields. From there the import leads to the table, which
+ * is read the way a data router's is, and the tables it names in turn
+ * (`...ApiAuthorizationRoutes`, `children: adminRoutes`) are read under the
+ * path they sit at — and inside the layouts around them (`<Route
+ * element={<DashboardLayout/>}>{DashboardRoutes.map(…)}</Route>`) when the
+ * table is written in the same file. A file that makes a router itself had
+ * its route objects read when it was extracted; only the tables it names are
+ * new here.
+ */
+function tableRoutes(context: ResolutionContext): FrameworkExtractionResult {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const consumers = new Set<string>();
+  for (const pkg of ROUTER_PACKAGES) {
+    for (const n of context.getNodesByName(pkg)) {
+      if (n.kind === 'import' && !isTestPath(n.filePath)) consumers.add(n.filePath);
+    }
+  }
+  if (consumers.size === 0) return { nodes, references };
+  const queue: Array<{ file: string; at: number; prefix: string[]; layouts: string[] }> = [];
+  const queued = new Set<string>();
+  // A table renders inside the layouts around the place that names it. A
+  // route's `layout:` reference is resolved in the route's own file, so they
+  // go along only when that place is in the table's file.
+  const enqueue = (table: { file: string; at: number } | null, prefix: string[], from: string, layouts: string[]): void => {
+    if (!table || queued.size >= MAX_TABLES) return;
+    const key = `${table.file}\0${table.at}\0${prefix.join('\0')}`;
+    if (queued.has(key)) return;
+    queued.add(key);
+    queue.push({ ...table, prefix, layouts: table.file === from ? layouts : [] });
+  };
+  for (const file of [...consumers].sort()) {
+    const source = context.readFile(file);
+    // Most of the files that import React Router only link or navigate.
+    if (!source || !CONSUMER_HINT.test(source)) continue;
+    const scan = scanRoutes(source, allowsJsx(file), { objects: ROUTER_CALL.test(source), uses: true });
+    for (const use of scan.uses) {
+      const table = use.literal !== undefined ? { file, at: use.literal } : tableNamed(use.name!, file, context);
+      enqueue(table, pathValues(use.prefix, file, context), file, use.layouts);
+    }
+  }
+  const made = new Set<string>();
+  const now = Date.now();
+  for (let next = queue.shift(); next; next = queue.shift()) {
+    const { file, at, prefix, layouts } = next;
+    const source = context.readFile(file);
+    if (!source) continue;
+    const scan = scanRoutes(source, allowsJsx(file), { table: { at, prefix: prefix.map((lit) => ({ lit })), layouts } });
+    for (const named of scan.names) enqueue(tableNamed(named, file, context), pathValues(named.prefix, file, context), file, named.layouts);
+    if (ROUTER_CALL.test(source)) continue;
+    const lineAt = makeLineAt(source, 1);
+    for (const route of scan.routes) {
+      const line = lineAt(route.at);
+      const id = `route:${file}:${line}:table:${route.path}`;
+      if (made.has(id)) continue;
+      made.add(id);
+      const values = route.parts.map((p) => p.lit ?? (p.expr ? constantPathValue(p.expr, file, context) : null));
+      nodes.push({
+        id,
+        kind: 'route',
+        name: values.every((v) => v !== null) ? composeRoutePath(values as string[]) : route.path,
+        qualifiedName: `${file}::route:${route.path}`,
+        filePath: file,
+        startLine: line,
+        endLine: line,
+        startColumn: 0,
+        endColumn: 0,
+        language: file.endsWith('.tsx') ? 'tsx' : 'jsx',
+        updatedAt: now,
+      });
+      references.push(...routeReferences(route, id, file, line));
+    }
+  }
+  return { nodes, references };
+}
+
+/** Path parts as text: a constant read from where it is declared, or shown as `{expr}` when it cannot be. */
+function pathValues(parts: readonly RoutePart[], fromFile: string, context: ResolutionContext): string[] {
+  return parts.map((p) => p.lit ?? (p.expr ? constantPathValue(p.expr, fromFile, context) : null) ?? `{${p.expr}}`);
+}
+
+function allowsJsx(filePath: string): boolean {
+  return !/\.(?:ts|mts|cts)$/.test(filePath);
+}
+
+function scriptLanguage(filePath: string): Language {
+  return /\.tsx$/.test(filePath) ? 'tsx' : /\.[cm]?ts$/.test(filePath) ? 'typescript' : /\.jsx$/.test(filePath) ? 'jsx' : 'javascript';
+}
+
+/** The literal a table name stands for in `file`: declared there, or imported. */
+function tableNamed(named: TableName, file: string, context: ResolutionContext, depth = 0): { file: string; at: number } | null {
+  const source = context.readFile(file);
+  if (!source) return null;
+  const safe = stripCommentsForRegex(source, 'typescript');
+  const local = declaredTable(safe, named.name, named.call);
+  if (local !== null) return { file, at: local };
+  const language = scriptLanguage(file);
+  const mapping = context.getImportMappings(file, language).find((m) => m.localName === named.name);
+  if (!mapping || mapping.isNamespace || depth > 3) return null;
+  const target = resolveImportPath(mapping.source, file, language, context);
+  if (!target) return null;
+  return exportedTable(target, mapping.isDefault ? 'default' : mapping.exportedName, named.call, context, depth + 1);
+}
+
+/** The literal `file` exports as `exported`: `export default [ … ]`, `export default AppRoutes`, `export const routes = [ … ]`, re-exports followed. */
+function exportedTable(file: string, exported: string, call: boolean, context: ResolutionContext, depth: number): { file: string; at: number } | null {
+  const source = context.readFile(file);
+  if (!source) return null;
+  const safe = stripCommentsForRegex(source, 'typescript');
+  let local = exported;
+  if (exported === 'default') {
+    const m = /\bexport\s+default\s+/.exec(safe);
+    if (m) {
+      const after = m.index + m[0].length;
+      const inline = call ? returnedTable(safe, after) : safe[after] === '[' || safe[after] === '{' ? after : null;
+      if (inline !== null) return { file, at: inline };
+      local = /^([A-Za-z_$][\w$]*)\s*(?:;|\n|$)/.exec(safe.slice(after))?.[1] ?? '';
+    } else local = /\bexport\s*\{[^}]*?\b([A-Za-z_$][\w$]*)\s+as\s+default\b/.exec(safe)?.[1] ?? '';
+  } else {
+    // `export { appRoutes as routes }`
+    const alias = new RegExp(`\\bexport\\s*\\{[^}]*?\\b([A-Za-z_$][\\w$]*)\\s+as\\s+${exported.replace(/\$/g, '\\$')}\\b`).exec(safe);
+    if (alias) local = alias[1]!;
+  }
+  const at = local ? declaredTable(safe, local, call) : null;
+  if (at !== null) return { file, at };
+  if (depth > 3) return null;
+  // `export { routes } from './routes'`, `export { default as routes } from './routes'`, `export * from './routes'`.
+  const language = scriptLanguage(file);
+  for (const re of context.getReExports?.(file, language) ?? []) {
+    if (re.kind === 'named' && re.exportedName !== exported) continue;
+    const target = resolveImportPath(re.source, file, language, context);
+    if (!target) continue;
+    const found = exportedTable(target, re.kind === 'named' ? re.originalName : exported, call, context, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+/** Where `name`'s table literal opens, for `const name = [ … ]` (or a function returning one when `call`). */
+function declaredTable(safe: string, name: string, call: boolean): number | null {
+  const id = name.replace(/\$/g, '\\$');
+  const decl = new RegExp(`(?:^|[^\\w$.])(?:const|let|var)\\s+${id}\\s*(?::[^=;]*)?=\\s*`).exec(safe);
+  if (decl) {
+    const after = decl.index + decl[0].length;
+    if (call) return returnedTable(safe, after);
+    return safe[after] === '[' || safe[after] === '{' ? after : null;
+  }
+  if (!call) return null;
+  const fn = new RegExp(`(?:^|[^\\w$.])function\\s+${id}\\s*\\(`).exec(safe);
+  return fn ? returnedTable(safe, fn.index + fn[0].indexOf('function')) : null;
+}
+
+/** The table a function at `at` returns: `(user) => [ … ]`, `(user) => ([ … ])`, `function routes(user) { return [ … ]; }`. */
+function returnedTable(safe: string, at: number): number | null {
+  const head = /^(?:async\s+)?(?:function\b[^(]*\([^)]*\)|\([^)]*\)|[A-Za-z_$][\w$]*)\s*(?::[^={]*)?(=>)?\s*/.exec(safe.slice(at));
+  if (!head) return null;
+  let i = at + head[0].length;
+  if (head[1]) {
+    while (safe[i] === '(') {
+      i++;
+      while (/\s/.test(safe[i] ?? '')) i++;
+    }
+    if (safe[i] === '[') return i;
+  }
+  if (safe[i] !== '{') return null;
+  const close = matchBracket(safe, i);
+  const ret = /\breturn\s*(?:\(\s*)?\[/.exec(safe.slice(i, close < 0 ? safe.length : close));
+  return ret ? i + ret.index + ret[0].length - 1 : null;
 }
 
 /**
@@ -335,15 +1308,32 @@ function resolveComponent(
   return components.length === 1 ? components[0]!.id : null;
 }
 
+/** JS/TS (and their JSX dialects): modules where a cross-file name needs an import. */
+function isEsmLanguage(language?: string): boolean {
+  return language === 'typescript' || language === 'tsx' || language === 'javascript' || language === 'jsx';
+}
+
+
 /**
  * Resolve a custom hook reference using name-based lookup
  */
-function resolveHook(name: string, context: ResolutionContext): string | null {
+function resolveHook(name: string, fromFile: string, context: ResolutionContext, language?: string): string | null {
   const candidates = context.getNodesByName(name);
   if (candidates.length === 0) return null;
 
-  const hooks = candidates.filter((n) => n.kind === 'function' && n.name.startsWith('use'));
+  // A hook nested inside another function is only callable in there.
+  const nested = (n: Node): boolean =>
+    context.getNodesInFile(n.filePath).some((f) =>
+      f.id !== n.id && (f.kind === 'function' || f.kind === 'method') && f.startLine <= n.startLine && f.endLine >= n.endLine &&
+      (f.startLine < n.startLine || f.endLine > n.endLine));
+  const hooks = candidates.filter((n) => n.kind === 'function' && n.name.startsWith('use') && !nested(n));
   if (hooks.length === 0) return null;
+  const sameFile = hooks.find((n) => n.filePath === fromFile);
+  if (sameFile) return sameFile.id;
+  // A JS/TS module reaches another file's hook only by importing it — the
+  // import resolver's to follow (an imported name never gets here) — never
+  // by name alone.
+  if (isEsmLanguage(language)) return null;
 
   // Prefer hooks directories
   const HOOK_DIRS = ['/hooks/', '/src/hooks/', '/lib/hooks/', '/utils/hooks/'];
@@ -358,7 +1348,13 @@ function resolveHook(name: string, context: ResolutionContext): string | null {
 /**
  * Resolve a context reference using name-based lookup
  */
-function resolveContext(name: string, context: ResolutionContext): string | null {
+function resolveContext(name: string, ref: UnresolvedRef, context: ResolutionContext): string | null {
+  // In a JS/TS module only the file's own context is in reach by name; another
+  // file's comes through an import (trpc's adapters' `createContext?.(…)` is an
+  // option, not an example app's `createContext`).
+  if (isEsmLanguage(ref.language)) {
+    return context.getNodesByName(name).find((n) => n.filePath === ref.filePath)?.id ?? null;
+  }
   const candidates = context.getNodesByName(name);
   if (candidates.length === 0) {
     // Try without Context/Provider suffix
diff --git a/src/resolution/frameworks/ruby.ts b/src/resolution/frameworks/ruby.ts
index 9c9e5a683f..7d81024dc5 100644
--- a/src/resolution/frameworks/ruby.ts
+++ b/src/resolution/frameworks/ruby.ts
@@ -5,9 +5,28 @@
  */
 
 import { Node } from '../../types';
-import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
+import { FrameworkResolver, FrameworkExtractionResult, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
 
+/**
+ * A `resources` line's `only:` / `except:` action list, written any way Rails
+ * accepts it: `[:index, :show]`, `:show`, `%i[new create index]`, `%w(index
+ * show)`, `"show"`, or the older `:only => [...]`. Null when the option is
+ * absent. maybe's `only: %i[new create index]` was not read, so every
+ * resource drew all seven routes, four of them to actions that do not exist.
+ */
+function railsActionOption(tail: string, key: 'only' | 'except'): Set<string> | null {
+  const m = new RegExp(
+    String.raw`(?:\b${key}:|:${key}\s*=>)\s*(?:\[([^\]]*)\]|%[iIwW]\s*[\[(]([^\])]*)[\])]|:(\w+)|["'](\w+)["'])`
+  ).exec(tail);
+  if (!m) return null;
+  if (m[1] !== undefined) {
+    return new Set(m[1].split(',').map((v) => v.trim().replace(/^:/, '').replace(/^["']|["']$/g, '')).filter(Boolean));
+  }
+  if (m[2] !== undefined) return new Set(m[2].trim().split(/\s+/).filter(Boolean));
+  return new Set([m[3] ?? m[4]!]);
+}
+
 export const railsResolver: FrameworkResolver = {
   name: 'rails',
   languages: ['ruby'],
@@ -22,7 +41,7 @@ export const railsResolver: FrameworkResolver = {
   detect(context: ResolutionContext): boolean {
     // Check for Gemfile with rails
     const gemfile = context.readFile('Gemfile');
-    if (gemfile && gemfile.includes("'rails'")) {
+    if (gemfile && /\bgem\s+["'](?:rails|railties)["']/.test(gemfile)) {
       return true;
     }
 
@@ -31,10 +50,12 @@ export const railsResolver: FrameworkResolver = {
       return true;
     }
 
-    // Check for typical Rails directory structure
+    // Check for typical Rails directory structure — or a Rails engine's routes
+    // file anywhere (solidus keeps each engine's under `backend/config/`).
     return (
       context.fileExists('app/controllers/application_controller.rb') ||
-      context.fileExists('config/routes.rb')
+      context.fileExists('config/routes.rb') ||
+      context.getAllFiles().some((f) => /(?:^|\/)config\/routes\.rb$/.test(f))
     );
   },
 
@@ -113,6 +134,12 @@ export const railsResolver: FrameworkResolver = {
     const now = Date.now();
     const safe = stripCommentsForRegex(content, 'ruby');
 
+    // A routes file is read with its blocks: `namespace`, `scope`, nested
+    // `resources … do`, `member` / `collection`.
+    if (/\broutes\.draw\b/.test(safe) || /(?:^|\/)config\/routes\//.test(filePath)) {
+      return extractScopedRailsRoutes(filePath, safe);
+    }
+
     // get/post/put/patch/delete/match '/path', to: 'controller#action'
     // Also: get '/path' => 'controller#action'
     const routeRegex = /\b(get|post|put|patch|delete|match)\s+['"]([^'"]+)['"]\s*(?:,\s*to:\s*|=>\s*)['"]([^#'"]+)#([^'"]+)['"]/g;
@@ -157,11 +184,10 @@ export const railsResolver: FrameworkResolver = {
       const resName = match[2]!;
       const tail = match[3] || '';
       let actions = plural ? PLURAL_ACTIONS : SINGULAR_ACTIONS;
-      const only = tail.match(/only:\s*\[([^\]]*)\]/);
-      const except = tail.match(/except:\s*\[([^\]]*)\]/);
-      const symList = (s: string) => new Set(s.split(',').map((x) => x.trim().replace(/^:/, '')));
-      if (only) { const s = symList(only[1]!); actions = actions.filter((a) => s.has(a)); }
-      else if (except) { const s = symList(except[1]!); actions = actions.filter((a) => !s.has(a)); }
+      const only = railsActionOption(tail, 'only');
+      const except = railsActionOption(tail, 'except');
+      if (only) actions = actions.filter((a) => only.has(a));
+      else if (except) actions = actions.filter((a) => !except.has(a));
       // `resources :articles` → ArticlesController; `resource :user` → UsersController.
       const ctrl = plural ? resName : pluralize(resName);
       const line = safe.slice(0, match.index).split('\n').length;
@@ -192,6 +218,135 @@ export const railsResolver: FrameworkResolver = {
 
 // Helper functions
 
+interface RailsFrame {
+  kind: 'namespace' | 'scope' | 'resource' | 'member' | 'collection' | 'block';
+  /** Path prefix routes written inside this frame get. */
+  path: string;
+  /** Controller module prefix (`admin/`). */
+  module: string;
+  /** For a resource: its controller, collection path and member path. */
+  controller?: string;
+  collectionPath?: string;
+  memberPath?: string;
+}
+
+/**
+ * A Rails routes file with its nesting: `namespace :admin` prefixes paths and
+ * controllers (`/admin/zones` → `admin/zones#index`), `scope` its path and
+ * module, a `resources :products do` block nests its children under
+ * `/products/:product_id`, and `member` / `collection` blocks add
+ * `/products/:id/preview` / `/products/search` actions. Each `do`, and each
+ * `if` / `unless` / `case` / `begin` line, opens a frame an `end` closes.
+ */
+function extractScopedRailsRoutes(filePath: string, safe: string): FrameworkExtractionResult {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const now = Date.now();
+  const seen = new Set<string>();
+  const stack: RailsFrame[] = [{ kind: 'block', path: '', module: '' }];
+  const top = () => stack[stack.length - 1]!;
+  const join = (...parts: string[]) => ('/' + parts.join('/')).replace(/\/+/g, '/').replace(/(.)\/$/, '$1');
+  const sym = (s: string) => s.replace(/^:/, '').replace(/^["']|["']$/g, '');
+  const option = (tail: string, key: string) => new RegExp(`\\b${key}:\\s*(:\\w+|["'][^"']*["'])`).exec(tail)?.[1];
+  const emit = (method: string, path: string, target: string, line: number) => {
+    const id = `route:${filePath}:${line}:${method}:${path}:${target}`;
+    if (seen.has(id)) return;
+    seen.add(id);
+    nodes.push({
+      id, kind: 'route', name: `${method} ${path}`, qualifiedName: `${filePath}::route:${target}`,
+      filePath, startLine: line, endLine: line, startColumn: 0, endColumn: 0, language: 'ruby', updatedAt: now,
+    });
+    references.push({ fromNodeId: id, referenceName: target, referenceKind: 'references', line, column: 0, filePath, language: 'ruby' });
+  };
+  const lines = safe.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = i + 1;
+    let text = lines[i]!.trim();
+    if (!text) continue;
+    // A statement whose `[` / `(` continues on the next lines (`only: [\n :a,\n :b ]`).
+    const open = (t: string) => (t.match(/[[(]/g)?.length ?? 0) - (t.match(/[\])]/g)?.length ?? 0);
+    while (open(text) > 0 && i + 1 < lines.length && !/\bdo\s*(?:\|[^|]*\|)?\s*$/.test(text)) text += ' ' + lines[++i]!.trim();
+    if (/^end\b/.test(text)) {
+      if (stack.length > 1) stack.pop();
+      continue;
+    }
+    const opens = /\bdo\s*(?:\|[^|]*\|)?\s*$/.test(text);
+    const frame = top();
+    let pushed: RailsFrame | null = null;
+    let m: RegExpExecArray | null;
+    if ((m = /^namespace\s+(:\w+|["'][\w/-]+["'])(.*)$/.exec(text))) {
+      const name = sym(m[1]!);
+      const custom = option(m[2]!, 'path');
+      pushed = { kind: 'namespace', path: join(frame.path, custom !== undefined ? sym(custom) : name), module: `${frame.module}${name}/` };
+    } else if ((m = /^scope\b\s*\(?\s*(.*?)\)?\s*(?:do\b.*)?$/.exec(text)) && opens) {
+      const args = m[1]!;
+      const lead = /^(["'])([^"']*)\1/.exec(args)?.[2];
+      const pathOpt = option(args, 'path');
+      const moduleOpt = option(args, 'module');
+      const path = lead ?? (pathOpt ? sym(pathOpt) : '');
+      pushed = { kind: 'scope', path: join(frame.path, path), module: moduleOpt ? `${frame.module}${sym(moduleOpt)}/` : frame.module };
+    } else if ((m = /^(resources?)\s+:(\w+)(.*)$/.exec(text))) {
+      const plural = m[1] === 'resources';
+      const name = m[2]!;
+      const tail = m[3]!;
+      const segment = option(tail, 'path') ? sym(option(tail, 'path')!) : name;
+      const controller = frame.module + (option(tail, 'controller') ? sym(option(tail, 'controller')!) : plural ? name : pluralize(name));
+      const collectionPath = join(frame.path, segment);
+      const memberPath = plural ? join(collectionPath, ':id') : collectionPath;
+      let actions = plural ? PLURAL_ACTIONS : SINGULAR_ACTIONS;
+      const only = railsActionOption(tail, 'only');
+      const except = railsActionOption(tail, 'except');
+      if (only) actions = actions.filter((a) => only.has(a));
+      else if (except) actions = actions.filter((a) => !except.has(a));
+      for (const action of actions) {
+        const spec = RESTFUL_ROUTES[action]!;
+        const path = action === 'index' || action === 'create' ? collectionPath
+          : action === 'new' ? join(collectionPath, 'new')
+          : action === 'edit' ? join(memberPath, 'edit') : memberPath;
+        emit(spec.method, path, `${controller}#${action}`, line);
+      }
+      if (opens) {
+        const nested = plural ? join(collectionPath, `:${singularize(name)}_id`) : collectionPath;
+        pushed = { kind: 'resource', path: nested, module: frame.module, controller, collectionPath, memberPath };
+      }
+    } else if (/^member\b/.test(text) && opens) {
+      pushed = { ...frame, kind: 'member' };
+    } else if (/^collection\b/.test(text) && opens) {
+      pushed = { ...frame, kind: 'collection' };
+    } else if ((m = /^root\s*\(?\s*(?:to:\s*)?["']([\w/]+)#(\w+)["']/.exec(text))) {
+      emit('GET', join(frame.path) || '/', `${frame.module}${m[1]}#${m[2]}`, line);
+    } else if ((m = /^(get|post|put|patch|delete|match)\s*\(?\s*(:\w+|["'][^"']*["'])(.*)$/.exec(text))) {
+      const method = m[1]!.toUpperCase() === 'MATCH' ? 'ANY' : m[1]!.toUpperCase();
+      const raw = sym(m[2]!);
+      const tail = m[3]!;
+      const to = /(?:\bto:\s*|=>\s*)["']([\w/]+)#(\w+)["']/.exec(tail);
+      const resource = stack.slice().reverse().find((f) => f.kind === 'resource' || f.kind === 'member' || f.kind === 'collection');
+      if (to) {
+        const base = frame.kind === 'member' ? frame.memberPath! : frame.kind === 'collection' ? frame.collectionPath! : frame.path;
+        emit(method, join(base, raw), `${frame.module}${to[1]}#${to[2]}`, line);
+      } else if (resource?.controller && /^[\w-]+$/.test(raw)) {
+        const action = sym(option(tail, 'action') ?? raw).replace(/-/g, '_');
+        const base = frame.kind === 'collection' ? resource.collectionPath! : resource.memberPath!;
+        emit(method, join(base, raw), `${resource.controller}#${action}`, line);
+      }
+    }
+    if (pushed) {
+      if (opens) stack.push(pushed);
+    } else if (opens || /^(?:if|unless|case|begin|while|until)\b/.test(text)) {
+      stack.push({ ...frame, kind: 'block' });
+    }
+  }
+  return { nodes, references };
+}
+
+/** Naive singularize for a resource's nested `:x_id` segment. */
+function singularize(w: string): string {
+  if (/ies$/.test(w)) return w.slice(0, -3) + 'y';
+  if (/(ss|us)$/.test(w)) return w;
+  if (/(x|ch|sh|ses)$/.test(w) && w.endsWith('es')) return w.slice(0, -2);
+  return w.replace(/s$/, '');
+}
+
 // RESTful action → HTTP verb + path. `resources` gets all seven; a singular
 // `resource` omits `index`.
 const RESTFUL_ROUTES: Record<string, { method: string; path: (r: string) => string }> = {
@@ -226,9 +381,17 @@ function resolveControllerAction(ctrlPath: string, action: string, context: Reso
     const m = context.getNodesInFile(direct).find((n) => (n.kind === 'method' || n.kind === 'function') && n.name === action);
     if (m) return m.id;
   }
-  // Fall back: controller class by name, then the action method in its file.
+  // Fall back: controller class by name, then the action method in its file —
+  // only the ones whose path ends with the route's module path when there are
+  // any (an engine's `spree/admin/zones_controller.rb` for `admin/zones`).
   const cls = camelize(ctrlPath.split('/').pop()!) + 'Controller';
-  for (const ctrl of context.getNodesByName(cls).filter((n) => n.kind === 'class')) {
+  const suffix = `/${ctrlPath}_controller.rb`;
+  const all = context.getNodesByName(cls).filter((n) => n.kind === 'class');
+  // A controller of the route's own module that inherits the action is not
+  // another module's same-named controller that defines it.
+  const own = ctrlPath.includes('/') ? all.filter((n) => ('/' + n.filePath).endsWith(suffix)) : [];
+  const classes = own.length > 0 ? own : all;
+  for (const ctrl of classes) {
     const m = context.getNodesInFile(ctrl.filePath).find((n) => (n.kind === 'method' || n.kind === 'function') && n.name === action);
     if (m) return m.id;
   }
diff --git a/src/resolution/frameworks/rust.ts b/src/resolution/frameworks/rust.ts
index f4828a77ae..ffe15926a4 100644
--- a/src/resolution/frameworks/rust.ts
+++ b/src/resolution/frameworks/rust.ts
@@ -8,6 +8,18 @@ import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
 import { getCargoWorkspaceCrateMap } from './cargo-workspace';
+import { isRustNameInScope } from '../name-matcher';
+import { pickByNameAndKind } from './name-heuristic';
+
+/**
+ * Whether the item a name heuristic found is one the reference can name:
+ * `Context<'_>` under `use std::task::{Context, Poll}` is std's, not tokio's
+ * `runtime::context::Context` (642 of them).
+ */
+function inRustScope(id: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const node = context.getNodeById?.(id);
+  return !node || isRustNameInScope(node, ref, context);
+}
 
 const cargoWorkspaceMapCache = new WeakMap<ResolutionContext, Map<string, string>>();
 
@@ -31,8 +43,8 @@ export const rustResolver: FrameworkResolver = {
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
     // Pattern 1: Handler references
     if (ref.referenceName.endsWith('_handler') || ref.referenceName.startsWith('handle_')) {
-      const result = resolveByNameAndKind(ref.referenceName, FUNCTION_KINDS, HANDLER_DIRS, context);
-      if (result) {
+      const result = resolveByNameAndKind(ref, FUNCTION_KINDS, HANDLER_DIRS, context);
+      if (result && inRustScope(result, ref, context)) {
         return {
           original: ref,
           targetNodeId: result,
@@ -44,8 +56,8 @@ export const rustResolver: FrameworkResolver = {
 
     // Pattern 2: Service/Repository trait implementations
     if (ref.referenceName.endsWith('Service') || ref.referenceName.endsWith('Repository')) {
-      const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, SERVICE_DIRS, context);
-      if (result) {
+      const result = resolveByNameAndKind(ref, SERVICE_KINDS, SERVICE_DIRS, context);
+      if (result && inRustScope(result, ref, context)) {
         return {
           original: ref,
           targetNodeId: result,
@@ -57,8 +69,8 @@ export const rustResolver: FrameworkResolver = {
 
     // Pattern 3: Struct references (PascalCase)
     if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, STRUCT_KINDS, MODEL_DIRS, context);
-      if (result) {
+      const result = resolveByNameAndKind(ref, STRUCT_KINDS, MODEL_DIRS, context);
+      if (result && inRustScope(result, ref, context)) {
         return {
           original: ref,
           targetNodeId: result,
@@ -95,6 +107,13 @@ export const rustResolver: FrameworkResolver = {
     const references: UnresolvedRef[] = [];
     const now = Date.now();
     const safe = stripCommentsForRegex(content, 'rust');
+    // Where a handler's own name is written, for the handler expression `expr`
+    // ending at `exprEnd`: the Rust scope gate reads the reference's line, and
+    // rustfmt wraps a long `.route(` call so its handler sits below it (#2326).
+    const handlerSite = (exprEnd: number, expr: string, handler: string) => {
+      const offset = exprEnd - expr.length + expr.lastIndexOf(handler);
+      return { line: safe.slice(0, offset).split('\n').length, column: offset - safe.lastIndexOf('\n', offset - 1) - 1 };
+    };
 
     // Actix-web / Rocket attribute: #[get("/path")] fn handler(..)
     // Capture the method, path, and the fn identifier that follows.
@@ -153,12 +172,24 @@ export const rustResolver: FrameworkResolver = {
       const line = safe.slice(0, match.index).split('\n').length;
 
       const methodBody = args.slice(pathMatch[0].length);
+      const bodyAt = openIdx + 1 + pathMatch[0].length;
       const methodHandlerRegex = /\b(get|post|put|patch|delete|head|options|trace)\s*\(\s*([A-Za-z_][\w:]*)/g;
       let mh: RegExpExecArray | null;
+      // The method routers are the argument's top-level chain (`get(a).post(b)`);
+      // a `get(` nested in it — `get(|| async { cache.get(key) })` — is a call
+      // inside a closure handler, not a route.
+      let depth = 0;
+      let scanned = 0;
       while ((mh = methodHandlerRegex.exec(methodBody)) !== null) {
+        for (; scanned < mh.index; scanned++) {
+          if (methodBody[scanned] === '(') depth++;
+          else if (methodBody[scanned] === ')') depth--;
+        }
+        if (depth > 0) continue;
         const upper = mh[1]!.toUpperCase();
         const handler = mh[2]!.split('::').filter(Boolean).pop();
         if (!handler) continue;
+        const site = handlerSite(bodyAt + mh.index + mh[0].length, mh[2]!, handler);
 
         const routeNode: Node = {
           id: `route:${filePath}:${line}:${upper}:${routePath}`,
@@ -179,8 +210,8 @@ export const rustResolver: FrameworkResolver = {
           fromNodeId: routeNode.id,
           referenceName: handler,
           referenceKind: 'references',
-          line,
-          column: 0,
+          line: site.line,
+          column: site.column,
           filePath,
           language: 'rust',
         });
@@ -189,9 +220,10 @@ export const rustResolver: FrameworkResolver = {
 
     // Actix-web builder API (the dominant actix routing style; attribute macros
     // are handled above). The handler lives in `.to(handler)`, not `get(handler)`.
-    const pushActixRoute = (routePath: string, method: string, handlerExpr: string, line: number) => {
+    const pushActixRoute = (routePath: string, method: string, handlerExpr: string, line: number, exprEnd: number) => {
       const handler = handlerExpr.split('::').filter(Boolean).pop();
       if (!handler) return;
+      const site = handlerSite(exprEnd, handlerExpr, handler);
       const upper = method.toUpperCase();
       const routeNode: Node = {
         id: `route:${filePath}:${line}:${upper}:${routePath}`,
@@ -211,8 +243,8 @@ export const rustResolver: FrameworkResolver = {
         fromNodeId: routeNode.id,
         referenceName: handler,
         referenceKind: 'references',
-        line,
-        column: 0,
+        line: site.line,
+        column: site.column,
         filePath,
         language: 'rust',
       });
@@ -226,7 +258,16 @@ export const rustResolver: FrameworkResolver = {
       const after = match.index + match[0].length;
       // Bound the resource's method chain at the next resource() to avoid bleed.
       const nextRes = safe.indexOf('web::resource', after);
-      const end = Math.min(after + 500, nextRes === -1 ? safe.length : nextRes);
+      let end = Math.min(after + 500, nextRes === -1 ? safe.length : nextRes);
+      // ...and at the `)` of the call it is an argument of: in
+      // `.service(web::resource("/a").to(a)).route("/b", web::get().to(b))`, `b` is not `/a`'s.
+      for (let i = after, depth = 0; i < end; i++) {
+        if (safe[i] === '(') depth++;
+        else if (safe[i] === ')' && --depth < 0) {
+          end = i;
+          break;
+        }
+      }
       const chain = safe.slice(after, end);
 
       const methodTo = /web::(get|post|put|patch|delete|head)\s*\(\s*\)\s*\.to\s*\(\s*([A-Za-z_][\w:]*)/g;
@@ -234,13 +275,13 @@ export const rustResolver: FrameworkResolver = {
       let found = false;
       while ((m2 = methodTo.exec(chain)) !== null) {
         const mLine = startLine + chain.slice(0, m2.index).split('\n').length - 1;
-        pushActixRoute(routePath, m2[1]!, m2[2]!, mLine);
+        pushActixRoute(routePath, m2[1]!, m2[2]!, mLine, after + m2.index + m2[0].length);
         found = true;
       }
       // Direct `.resource("/x").to(handler)` (all methods) when no explicit verb route.
       if (!found) {
         const direct = chain.match(/^\s*\.to\s*\(\s*([A-Za-z_][\w:]*)/);
-        if (direct) pushActixRoute(routePath, 'ANY', direct[1]!, startLine);
+        if (direct) pushActixRoute(routePath, 'ANY', direct[1]!, startLine, after + direct[0].length);
       }
     }
 
@@ -248,7 +289,7 @@ export const rustResolver: FrameworkResolver = {
     const appRouteRegex = /\.route\s*\(\s*"([^"]+)"\s*,\s*web::(get|post|put|patch|delete|head)\s*\(\s*\)\s*\.to\s*\(\s*([A-Za-z_][\w:]*)/g;
     while ((match = appRouteRegex.exec(safe)) !== null) {
       const line = safe.slice(0, match.index).split('\n').length;
-      pushActixRoute(match[1]!, match[2]!, match[3]!, line);
+      pushActixRoute(match[1]!, match[2]!, match[3]!, line, match.index + match[0].length);
     }
 
     return { nodes, references };
@@ -277,30 +318,18 @@ function findMatchingParen(s: string, openIdx: number): number {
   return -1;
 }
 
-/**
- * Resolve a symbol by name using indexed queries instead of scanning all files.
- */
+/** A framework name heuristic's pick (see name-heuristic.ts): in scope by its `use`s and module paths. */
 function resolveByNameAndKind(
-  name: string,
+  ref: UnresolvedRef,
   kinds: Set<string>,
   preferredDirPatterns: string[],
   context: ResolutionContext,
 ): string | null {
-  const candidates = context.getNodesByName(name);
-  if (candidates.length === 0) return null;
-
-  const kindFiltered = candidates.filter((n) => kinds.has(n.kind));
-  if (kindFiltered.length === 0) return null;
-
-  // Prefer candidates in framework-conventional directories
-  const preferred = kindFiltered.filter((n) =>
-    preferredDirPatterns.some((d) => n.filePath.includes(d))
-  );
-
-  if (preferred.length > 0) return preferred[0]!.id;
-
-  // Fall back to any match
-  return kindFiltered[0]!.id;
+  return pickByNameAndKind(ref, kinds, (f) => preferredDirPatterns.some((d) => f.includes(d)), context, {
+    // The file is a module: a sibling file is another one, reached only through a `use`.
+    sameDirectory: false,
+    accept: (n) => isRustNameInScope(n, ref, context),
+  });
 }
 
 interface ModuleResolution {
diff --git a/src/resolution/frameworks/svelte.ts b/src/resolution/frameworks/svelte.ts
index d3271a6fc8..228c2248a4 100644
--- a/src/resolution/frameworks/svelte.ts
+++ b/src/resolution/frameworks/svelte.ts
@@ -45,6 +45,9 @@ const SVELTEKIT_MODULE_PREFIXES = [
 export const svelteResolver: FrameworkResolver = {
   name: 'svelte',
   languages: ['svelte'],
+  // Runes are written in `.svelte.ts` / `.svelte.js` modules too, and a
+  // SvelteKit `+page.ts` or `hooks.server.ts` imports `$lib/…` and `$app/…`.
+  resolveLanguages: ['svelte', 'typescript', 'javascript'],
 
   detect(context: ResolutionContext): boolean {
     // Check for svelte or @sveltejs/kit in package.json
@@ -80,8 +83,10 @@ export const svelteResolver: FrameworkResolver = {
       };
     }
 
-    // Pattern 2: Store auto-subscriptions ($storeName)
-    if (ref.referenceName.startsWith('$') && !ref.referenceName.startsWith('$$')) {
+    // Pattern 2: Store auto-subscriptions ($storeName) — a `.svelte`
+    // component's syntax only. In any other script `$n` is a name of its own
+    // (jQuery's `$el`, a compiler's `$n`), never the store `n`.
+    if (ref.language === 'svelte' && ref.referenceName.startsWith('$') && !ref.referenceName.startsWith('$$')) {
       const storeName = ref.referenceName.substring(1);
       const storeNode = context.getNodesByName(storeName).find(
         (n) => n.kind === 'variable' || n.kind === 'constant'
@@ -276,11 +281,14 @@ function filePathToSvelteKitRoute(filePath: string): string | null {
   const lastSlash = afterRoutes.lastIndexOf('/');
   const dirPath = lastSlash === -1 ? '' : afterRoutes.substring(0, lastSlash);
 
-  // Convert SvelteKit param syntax [param] to :param
-  let route = '/' + dirPath
-    .replace(/\[\.\.\.([^\]]+)\]/g, '*$1')  // [...rest] -> *rest
-    .replace(/\[{2}([^\]]+)\]{2}/g, ':$1?') // [[optional]] -> :optional?
-    .replace(/\[([^\]]+)\]/g, ':$1');        // [param] -> :param
+  // A `(group)` directory shares a layout and never appears in the URL:
+  // `(app)/(layout)/blocks` is `/blocks`. A parameter's `=matcher` checks
+  // its value and is no part of its name.
+  const segments = dirPath.split('/').filter((seg) => seg.length > 0 && !/^\(.*\)$/.test(seg));
+  let route = '/' + segments.join('/')
+    .replace(/\[\.\.\.([^\]=]+)(?:=[^\]]*)?\]/g, '*$1')  // [...rest] / [...rest=m] -> *rest
+    .replace(/\[{2}([^\]=]+)(?:=[^\]]*)?\]{2}/g, ':$1?') // [[optional]] -> :optional?
+    .replace(/\[([^\]=]+)(?:=[^\]]*)?\]/g, ':$1');        // [param] / [param=m] -> :param
 
   if (route === '/') return '/';
   // Remove trailing slash
diff --git a/src/resolution/frameworks/sveltekit-router.ts b/src/resolution/frameworks/sveltekit-router.ts
index bf105e9b89..95dcb09959 100644
--- a/src/resolution/frameworks/sveltekit-router.ts
+++ b/src/resolution/frameworks/sveltekit-router.ts
@@ -59,6 +59,14 @@ function isSvelteKitPage(node: Node): boolean {
   );
 }
 
+/**
+ * True for a page the table holds. `[...rest]` becomes `*rest`, which matches
+ * anything — never an answer.
+ */
+function inSvelteKitTable(node: Node): boolean {
+  return isSvelteKitPage(node) && node.name.startsWith('/') && !node.name.includes('*');
+}
+
 /** `:id?` — a parameter SvelteKit serves the route with or without. */
 function isOptionalParam(seg: string): boolean {
   return seg.startsWith(':') && seg.endsWith('?');
@@ -78,9 +86,7 @@ export function svelteKitTable(context: ResolutionContext): SvelteKitTable {
     return t;
   };
   for (const node of all) {
-    if (!isSvelteKitPage(node)) continue;
-    // `[...rest]` becomes `*rest`, which matches anything — never an answer.
-    if (!node.name.startsWith('/') || node.name.includes('*')) continue;
+    if (!inSvelteKitTable(node)) continue;
     const root = appRootFor(node.filePath);
     addRouteTo(tableAt(root), node.name, node);
     // `[[optional]]` is `:x?`: the route serves the path with and without it.
@@ -129,6 +135,12 @@ export const svelteKitRouterResolver: FrameworkResolver = {
     return NAV_CALL.test(name);
   },
 
+  navigation: {
+    tails: ['goto', 'redirect'],
+    // A call matches against the table of the app its file is in.
+    scope: (route) => (inSvelteKitTable(route) ? [appRootFor(route.filePath)] : null),
+  },
+
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
     // `import { redirect } from '@sveltejs/kit'` is not a navigation.
     if (ref.referenceKind !== 'calls') return null;
diff --git a/src/resolution/frameworks/swift.ts b/src/resolution/frameworks/swift.ts
index 5665bba956..9ad2e95b3b 100644
--- a/src/resolution/frameworks/swift.ts
+++ b/src/resolution/frameworks/swift.ts
@@ -7,6 +7,7 @@
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
 import { stripCommentsForRegex } from '../strip-comments';
+import { pickByNameAndKind } from './name-heuristic';
 
 // No extract(): a SwiftUI view is its own struct node, and a UIKit controller
 // its class. A one-line `component`/`class` twin per `struct X: View` (and per
@@ -39,9 +40,12 @@ export const swiftUIResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // Swift's conventions, for Swift's refs: an Objective-C `@interface SDDiskCache
+    // : NSObject <SDDiskCache>` is no SwiftUI view or model.
+    if (ref.language !== 'swift') return null;
     // Pattern 1: View references (SwiftUI views are PascalCase ending in View)
     if (ref.referenceName.endsWith('View') && /^[A-Z]/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, VIEW_KINDS, VIEW_DIRS, context);
+      const result = resolveByNameAndKind(ref, VIEW_KINDS, VIEW_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -54,7 +58,7 @@ export const swiftUIResolver: FrameworkResolver = {
 
     // Pattern 2: ViewModel/ObservableObject references
     if (ref.referenceName.endsWith('ViewModel') || ref.referenceName.endsWith('Store') || ref.referenceName.endsWith('Manager')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, VIEWMODEL_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, VIEWMODEL_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -67,7 +71,7 @@ export const swiftUIResolver: FrameworkResolver = {
 
     // Pattern 3: Model references
     if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, MODEL_KINDS, MODEL_DIRS, context);
+      const result = resolveByNameAndKind(ref, MODEL_KINDS, MODEL_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -105,9 +109,12 @@ export const uikitResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // Swift's conventions, for Swift's refs: an Objective-C `@interface SDDiskCache
+    // : NSObject <SDDiskCache>` is no SwiftUI view or model.
+    if (ref.language !== 'swift') return null;
     // Pattern 1: ViewController references
     if (ref.referenceName.endsWith('ViewController')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, VC_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, VC_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -120,7 +127,7 @@ export const uikitResolver: FrameworkResolver = {
 
     // Pattern 2: UIView subclass references
     if (ref.referenceName.endsWith('View') && !ref.referenceName.endsWith('ViewController')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, UIVIEW_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, UIVIEW_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -133,7 +140,7 @@ export const uikitResolver: FrameworkResolver = {
 
     // Pattern 3: Cell references
     if (ref.referenceName.endsWith('Cell')) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, CELL_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, CELL_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -146,7 +153,7 @@ export const uikitResolver: FrameworkResolver = {
 
     // Pattern 4: Delegate/DataSource references
     if (ref.referenceName.endsWith('Delegate') || ref.referenceName.endsWith('DataSource')) {
-      const result = resolveByNameAndKind(ref.referenceName, PROTOCOL_KINDS, [], context);
+      const result = resolveByNameAndKind(ref, PROTOCOL_KINDS, [], context);
       if (result) {
         return {
           original: ref,
@@ -193,20 +200,22 @@ export const vaporResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // Swift's conventions, for Swift's refs: an Objective-C `@interface SDDiskCache
+    // : NSObject <SDDiskCache>` is no SwiftUI view or model.
+    if (ref.language !== 'swift') return null;
     // Pattern 0: a route's handler — `use: SearchController.show` arrives as
     // `SearchController@show`, `use: self.index` / `use: index` as `@index`.
     // Resolved on the type the route names, never by the method's name alone:
     // every controller has a `show`. No match, or two, is left unresolved.
     const handler = VAPOR_HANDLER.exec(ref.referenceName);
     if (handler) {
-      if (ref.language !== 'swift') return null;
       const target = resolveVaporHandler(handler[1] ?? null, handler[2]!, ref, context);
       return target ? { original: ref, targetNodeId: target, confidence: 0.9, resolvedBy: 'framework' } : null;
     }
 
     // Pattern 1: Controller references
     if (ref.referenceName.endsWith('Controller')) {
-      const result = resolveByNameAndKind(ref.referenceName, VAPOR_CONTROLLER_KINDS, VAPOR_CONTROLLER_DIRS, context);
+      const result = resolveByNameAndKind(ref, VAPOR_CONTROLLER_KINDS, VAPOR_CONTROLLER_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -219,7 +228,7 @@ export const vaporResolver: FrameworkResolver = {
 
     // Pattern 2: Model references (Fluent)
     if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
-      const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, FLUENT_MODEL_DIRS, context);
+      const result = resolveByNameAndKind(ref, CLASS_KINDS, FLUENT_MODEL_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -232,7 +241,7 @@ export const vaporResolver: FrameworkResolver = {
 
     // Pattern 3: Middleware references
     if (ref.referenceName.endsWith('Middleware')) {
-      const result = resolveByNameAndKind(ref.referenceName, VAPOR_CONTROLLER_KINDS, VAPOR_MIDDLEWARE_DIRS, context);
+      const result = resolveByNameAndKind(ref, VAPOR_CONTROLLER_KINDS, VAPOR_MIDDLEWARE_DIRS, context);
       if (result) {
         return {
           original: ref,
@@ -330,10 +339,107 @@ export const vaporResolver: FrameworkResolver = {
       }
     }
 
+    // `routes.on(.POST, "x", use: handler)` names its method as the first argument.
+    // Arguments may hold one level of parentheses (`body: .collect(maxSize: "1mb")`);
+    // only unlabeled string arguments are path segments.
+    const onRegex = /\b(\w+)\.on\s*\(\s*\.([A-Z]+)\s*,\s*((?:(?:[^,()]|\([^()]*\))+,)*\s*)use:\s*([A-Za-z_][\w.]*)/g;
+    const pathArgs = (argText: string) => argText.split(',').filter((a) => /^\s*"[^"]*"\s*$/.test(a)).join(',');
+    while ((match = onRegex.exec(safe)) !== null) {
+      const [, receiver, method, segsStr, handlerExpr] = match;
+      const line = safe.slice(0, match.index).split('\n').length;
+      const routePath = (groupPrefix.get(receiver!) ?? '') + segJoin('', pathArgs(segsStr!)) || '/';
+      const id = `route:${filePath}:${line}:${method}:${routePath}`;
+      nodes.push({
+        id, kind: 'route', name: `${method} ${routePath}`, qualifiedName: `${filePath}::route:${routePath}`,
+        filePath, startLine: line, endLine: line, startColumn: 0, endColumn: match[0].length, language: 'swift', updatedAt: now,
+      });
+      const handlerName = vaporHandlerRef(handlerExpr!, receiverTypes);
+      if (handlerName) references.push({ fromNodeId: id, referenceName: handlerName, referenceKind: 'references', line, column: 0, filePath, language: 'swift' });
+    }
+
+    // A route whose handler is a trailing closure — `app.get("hello") { req in … }`,
+    // `app.webSocket("chat") { req, ws in … }`, `routes.on(.GET, "x") { … }`. It has
+    // no handler symbol; the closure's calls belong to the function registering it.
+    // An HTTP client's `req.client.get("https://…") { … }` is not a route.
+    const closureRegex = /\b(\w+)\.(get|post|put|patch|delete|head|options|webSocket|on)\s*\(([^()]*)\)\s*\{/g;
+    while ((match = closureRegex.exec(safe)) !== null) {
+      const [, receiver, verb, args] = match;
+      if (/\buse:/.test(args!) || receiver === 'client' || /^\s*"https?:/.test(args!)) continue;
+      // A route registration is a statement: `if let v = req.parameters.get("x") {`
+      // opens the `if` body, not a trailing closure.
+      const lineStart = safe.lastIndexOf('\n', match.index) + 1;
+      if (!/^\s*(?:(?:try|await)\s+)*$/.test(safe.slice(lineStart, match.index))) continue;
+      let method = verb === 'webSocket' ? 'WS' : verb!.toUpperCase();
+      let segs = args!;
+      if (verb === 'on') {
+        const on = /^\s*\.([A-Z]+)\s*,?(.*)$/s.exec(args!);
+        if (!on) continue;
+        method = on[1]!;
+        segs = on[2]!;
+      }
+      const line = safe.slice(0, match.index).split('\n').length;
+      const routePath = (groupPrefix.get(receiver!) ?? '') + segJoin('', segs) || '/';
+      const id = `route:${filePath}:${line}:${method}:${routePath}`;
+      nodes.push({
+        id, kind: 'route', name: `${method} ${routePath}`,
+        qualifiedName: `${filePath}::route:${routePath}`, filePath, startLine: line, endLine: line,
+        startColumn: 0, endColumn: match[0].length, language: 'swift', updatedAt: now,
+      });
+      // The closure IS the handler: its calls are the route's, as an Express
+      // inline handler's are, so Steps draws what `GET hello` does.
+      const open = match.index + match[0].length - 1;
+      const close = closingBrace(safe, open);
+      if (close > open) {
+        for (const name of closureCallNames(safe.slice(open + 1, close))) {
+          references.push({ fromNodeId: id, referenceName: name, referenceKind: 'calls', line, column: 0, filePath, language: 'swift' });
+        }
+      }
+    }
+
     return { nodes, references };
   },
 };
 
+/** The `}` matching the `{` at `open`; string literals are skipped. -1 when unbalanced. */
+function closingBrace(s: string, open: number): number {
+  let depth = 0;
+  for (let i = open; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"') {
+      for (i++; i < s.length && s[i] !== '"'; i++) if (s[i] === '\\') i++;
+      continue;
+    }
+    if (ch === '{') depth++;
+    else if (ch === '}' && --depth === 0) return i;
+  }
+  return -1;
+}
+
+/** Words Swift writes before a `(` that are not calls. */
+const SWIFT_NOT_CALLS = new Set(['if', 'guard', 'switch', 'while', 'for', 'return', 'catch', 'case', 'in', 'try', 'await', 'throw', 'some', 'any']);
+
+/**
+ * The calls a route closure's body makes, each once, keeping the receiver
+ * (`Todo.query`, `req.auth.require`) so they resolve as calls on it. A member
+ * of an expression (`a.b().c(`) names nothing this can follow.
+ */
+function closureCallNames(body: string): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const callRe = /((?:[A-Za-z_]\w*\s*[?!]?\.\s*)*)([A-Za-z_]\w*)\s*\(/g;
+  let m: RegExpExecArray | null;
+  while ((m = callRe.exec(body)) !== null) {
+    const callee = m[2]!;
+    const receiver = m[1]!.replace(/[\s?!]/g, '').replace(/\.$/, '');
+    if (!receiver && (SWIFT_NOT_CALLS.has(callee) || /[.)\]]\s*$/.test(body.slice(0, m.index)))) continue;
+    const name = receiver ? `${receiver}.${callee}` : callee;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
+
 // Directory patterns
 const VIEW_DIRS = ['/Views/', '/View/', '/Screens/', '/Components/', '/UI/'];
 const VIEWMODEL_DIRS = ['/ViewModels/', '/ViewModel/', '/Stores/', '/Managers/', '/Services/'];
@@ -448,29 +554,12 @@ const MODEL_KINDS = new Set(['struct', 'class']);
 const PROTOCOL_KINDS = new Set(['protocol']);
 const VAPOR_CONTROLLER_KINDS = new Set(['class', 'struct']);
 
-/**
- * Resolve a symbol by name using indexed queries instead of scanning all files.
- */
+/** A framework name heuristic's pick (see name-heuristic.ts), preferring these folders. */
 function resolveByNameAndKind(
-  name: string,
+  ref: UnresolvedRef,
   kinds: Set<string>,
   preferredDirPatterns: string[],
   context: ResolutionContext,
 ): string | null {
-  const candidates = context.getNodesByName(name);
-  if (candidates.length === 0) return null;
-
-  const kindFiltered = candidates.filter((n) => kinds.has(n.kind));
-  if (kindFiltered.length === 0) return null;
-
-  // Prefer candidates in framework-conventional directories
-  if (preferredDirPatterns.length > 0) {
-    const preferred = kindFiltered.filter((n) =>
-      preferredDirPatterns.some((d) => n.filePath.includes(d))
-    );
-    if (preferred.length > 0) return preferred[0]!.id;
-  }
-
-  // Fall back to any match
-  return kindFiltered[0]!.id;
+  return pickByNameAndKind(ref, kinds, (f) => preferredDirPatterns.some((d) => f.includes(d)), context);
 }
diff --git a/src/resolution/frameworks/tanstack-router.ts b/src/resolution/frameworks/tanstack-router.ts
index 844eefeffd..935389fabc 100644
--- a/src/resolution/frameworks/tanstack-router.ts
+++ b/src/resolution/frameworks/tanstack-router.ts
@@ -379,6 +379,12 @@ export const tanstackRouterResolver: FrameworkResolver = {
     return NAV_CALL.test(name);
   },
 
+  navigation: {
+    tails: ['navigate', 'redirect'],
+    // A call matches against the table of the app its file is in.
+    scope: (route) => (isTanstackRoute(route) ? [appRootFor(route.filePath)] : null),
+  },
+
   extract(filePath: string, content: string): FrameworkExtractionResult {
     // A file-based route file describes ONE route, so the file's own shape says
     // whether that route is a page. A file holding a code-based route TREE
diff --git a/src/resolution/frameworks/vue-router.ts b/src/resolution/frameworks/vue-router.ts
index 1a9884e8ba..f84dad897b 100644
--- a/src/resolution/frameworks/vue-router.ts
+++ b/src/resolution/frameworks/vue-router.ts
@@ -64,6 +64,7 @@ import {
   type RouteTable,
 } from './expo-router';
 import { destinationsForHref } from './nextjs';
+import { resolveImportPath } from '../import-resolver';
 
 const ROUTE_LANGUAGES: readonly Language[] = ['typescript', 'javascript', 'vue'];
 
@@ -72,75 +73,137 @@ const ROUTE_LANGUAGES: readonly Language[] = ['typescript', 'javascript', 'vue']
 // =============================================================================
 
 export interface VueRouteEntry {
-  /** `/profile/:username` — the path, in the form every other framework's routes use. */
+  /** `/profile/:username` — the full path, a child's joined onto its parents'. */
   path: string;
   /** `profile` — what `router.push({ name })` names, when the entry has one. */
   name: string | null;
   /** The component the entry names, by identifier or by the tail of its lazy import. */
   component: string | null;
+  /** `@/views/dashboard/index` — the file a lazy `() => import(…)` component names. */
+  spec: string | null;
+  /** The components of the parent routes it renders inside, outermost first. */
+  layouts: VueLayout[];
   line: number;
 }
 
+export interface VueLayout {
+  component: string;
+  spec: string | null;
+}
+
 /** A file that builds a router — the cheap gate before parsing anything. */
-const ROUTER_FACTORY = /\b(?:createRouter|createWebHistory|createWebHashHistory|createMemoryHistory)\s*\(|\bnew\s+VueRouter\s*\(/;
+const ROUTER_FACTORY = /\b(?:createRouter|createWebHistory|createWebHashHistory|createMemoryHistory)\s*\(|\bnew\s+(?:VueRouter|Router)\s*\(/;
 
 /** `routes: [` / `routes = [` — the array itself, for a file that only holds the table. */
 const ROUTES_ARRAY = /\broutes\s*[:=]\s*\[/;
 
+/** A file that imports from `vue-router`. */
+const VUE_ROUTER_IMPORT = /\bfrom\s*['"]vue-router['"]/;
+
+/** A file in a `router/` or `routes/` directory, or named `router.js` / `routes.ts`. */
+const ROUTE_FILE_PATH = /(?:^|\/)(?:router|routes)(?:\/|\.[cm]?[jt]s$)/;
+
 /**
- * Every top-level entry of a `routes: [...]` array.
+ * Where a routes table starts: a `routes: [` field, or a declaration named
+ * for what it holds — `export const constantRoutes = [`, `const routes:
+ * RouteRecordRaw[] = [`, vue-element-admin's per-module `const tableRouter = {`.
+ */
+const TABLE_OPENERS = /\broutes\s*[:=]\s*\[|\b(?:const|let|var)\s+(?:[A-Za-z_$][\w$]*)?(?:[Rr]outes?|[Rr]outers?)\s*(?::[^=;\n]*)?=\s*([[{])/g;
+
+/**
+ * Every route a file's routes tables declare.
  *
- * The array is walked, not pattern-matched: a `name` is written ABOVE the
+ * The tables are walked, not pattern-matched: a `name` is written ABOVE the
  * `path` it belongs to, so reading fields out of a window around each `path`
  * hands an entry its PREDECESSOR's name — vue-realworld's `login` came out as
- * `/register`, silently, for every route in the file. So each top-level `{…}`
- * is matched as a unit and only its own depth-1 fields are read; a nested
- * `children:` array, a `meta: {…}` and a lazy `component: () => import(…)`
- * are stepped over rather than searched.
+ * `/register`, silently, for every route in the file. So each `{…}` is
+ * matched as a unit and only its own depth-1 fields are read; a `meta: {…}`
+ * and a lazy `component: () => import(…)` are stepped over rather than
+ * searched, and `children` are walked in turn with the parent's path in front
+ * of theirs.
+ *
+ * A route with children is a layout: its component renders the outlet they
+ * fill. It is a screen of its own only when no child claims its address and
+ * it does not `redirect` elsewhere — vue-element-admin's `{ path: '/table',
+ * component: Layout, redirect: '/table/complex-table', children }` is the
+ * frame around four tables, not a fifth page.
  *
- * An entry whose path does not start with `/` is a child route, relative to a
- * parent this does not compose, and is not a destination on its own.
+ * A top-level entry whose path does not start with `/` (`*`, a catch-all) is
+ * not an address. A table is read from a file that builds a router, imports
+ * `vue-router`, or lives in a `router/` directory.
  */
-export function parseVueRoutes(content: string): VueRouteEntry[] {
-  if (!ROUTER_FACTORY.test(content) && !ROUTES_ARRAY.test(content)) return [];
+export function parseVueRoutes(content: string, filePath = ''): VueRouteEntry[] {
+  const routeFile = ROUTER_FACTORY.test(content) || ROUTES_ARRAY.test(content) || VUE_ROUTER_IMPORT.test(content) || ROUTE_FILE_PATH.test(filePath);
+  if (!routeFile) return [];
   const safe = stripCommentsForRegex(content, 'typescript');
   const out: VueRouteEntry[] = [];
   const seen = new Set<string>();
-  const arrays = /\broutes\s*[:=]\s*\[/g;
-  let a: RegExpExecArray | null;
-  while ((a = arrays.exec(safe)) !== null) {
-    const open = a.index + a[0].length - 1;
-    const close = matchBracket(safe, open);
-    if (close < 0) continue;
-    for (const obj of topLevelObjects(safe, open + 1, close)) {
-      const fields = readFields(safe, obj.start, obj.end);
-      const pathField = fields.get('path');
-      if (!pathField) continue;
-      const path = readStringAt(pathField.text.trimStart(), 0);
-      if (path === null || !path.startsWith('/')) continue;
-      const componentField = fields.get('component') ?? fields.get('components');
-      if (!componentField) continue; // no component in the entry → not a route object
-      const component = componentName(componentField.text);
-      if (!component) continue;
-      const nameField = fields.get('name');
-      const name = nameField ? readStringAt(nameField.text.trimStart(), 0) : null;
-      const line = safe.slice(0, pathField.at).split('\n').length;
-      const key = `${path} ${name ?? ''}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      out.push({ path, name, component, line });
+  const walked = new Set<number>();
+  const lineOf = (at: number) => safe.slice(0, at).split('\n').length;
+
+  const visit = (obj: { start: number; end: number }, prefix: string | null, layouts: VueLayout[], depth: number): void => {
+    const fields = readFields(safe, obj.start, obj.end);
+    const pathField = fields.get('path');
+    if (!pathField) return;
+    const own = readStringAt(pathField.text.trimStart(), 0);
+    if (own === null) return;
+    let path: string;
+    if (own.startsWith('/')) path = own;
+    else if (prefix === null) return; // a top-level `*` or relative path is no address
+    else path = own === '' ? prefix : `${prefix === '/' ? '' : prefix}/${own}`;
+    if (path.length > 1) path = path.replace(/\/+$/, '');
+
+    const componentField = fields.get('component') ?? fields.get('components');
+    const component = componentField ? componentOf(componentField.text) : null;
+
+    const children = fields.get('children');
+    let childClaimsAddress = false;
+    if (children && depth < 12) {
+      const open = safe.indexOf('[', children.at);
+      const close = open < 0 ? -1 : matchBracket(safe, open);
+      if (open >= 0 && close > open) {
+        const inner = component ? [...layouts, component] : layouts;
+        for (const child of topLevelObjects(safe, open + 1, close)) {
+          const childPath = readFields(safe, child.start, child.end).get('path');
+          const childOwn = childPath ? readStringAt(childPath.text.trimStart(), 0) : null;
+          if (childOwn === '' || childOwn === path) childClaimsAddress = true;
+          visit(child, path, inner, depth + 1);
+        }
+      }
     }
-    arrays.lastIndex = close;
+    if (!component) return;
+    if (children && (childClaimsAddress || fields.has('redirect'))) return;
+    const nameField = fields.get('name');
+    const name = nameField ? readStringAt(nameField.text.trimStart(), 0) : null;
+    const key = `${path} ${name ?? ''}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ path, name, component: component.component, spec: component.spec, layouts: [...layouts], line: lineOf(pathField.at) });
+  };
+
+  TABLE_OPENERS.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = TABLE_OPENERS.exec(safe)) !== null) {
+    const open = m.index + m[0].length - 1;
+    const close = matchBracket(safe, open);
+    if (close < 0 || walked.has(open)) continue;
+    walked.add(open);
+    if (safe[open] === '{') visit({ start: open, end: close }, null, [], 0);
+    else for (const obj of topLevelObjects(safe, open + 1, close)) visit(obj, null, [], 0);
+    TABLE_OPENERS.lastIndex = close;
   }
   return out;
 }
 
 /** The component an entry names: an identifier, or the file a lazy import names. */
-function componentName(value: string): string | null {
+function componentOf(value: string): VueLayout | null {
   const lazy = /\bimport\s*\(\s*['"`]([^'"`]+)['"`]/.exec(value);
-  if (lazy) return (lazy[1]!.split('/').pop() ?? '').replace(/\.\w+$/, '') || null;
+  if (lazy) {
+    const tail = (lazy[1]!.split('/').pop() ?? '').replace(/\.\w+$/, '');
+    return tail ? { component: tail, spec: lazy[1]! } : null;
+  }
   const ident = /^\s*([A-Z][A-Za-z0-9_]*)\s*$/.exec(value);
-  return ident?.[1] ?? null;
+  return ident ? { component: ident[1]!, spec: null } : null;
 }
 
 function languageForFile(filePath: string): Language {
@@ -175,11 +238,16 @@ function isVueConfigRoute(node: Node): boolean {
 function isNuxtPage(node: Node): boolean {
   return (
     node.language === 'vue' &&
-    node.filePath.includes('/pages/') &&
+    `/${node.filePath}`.includes('/pages/') &&
     node.id === `route:${node.filePath}:${node.name}:1`
   );
 }
 
+/** True for a route the table holds: a config route or a Nuxt page, at an absolute path. */
+function inVueTable(node: Node): boolean {
+  return (isVueConfigRoute(node) || isNuxtPage(node)) && node.name.startsWith('/');
+}
+
 const tables = new WeakMap<ResolutionContext, VueRouteTable>();
 
 export function vueRouteTable(context: ResolutionContext): VueRouteTable {
@@ -194,12 +262,10 @@ export function vueRouteTable(context: ResolutionContext): VueRouteTable {
     return t;
   };
   for (const node of all) {
-    const config = isVueConfigRoute(node);
-    if (!config && !isNuxtPage(node)) continue;
-    if (!node.name.startsWith('/')) continue;
+    if (!inVueTable(node)) continue;
     const root = appRootFor(node.filePath);
     addRouteTo(tableAt(root), node.name, node);
-    if (config) {
+    if (isVueConfigRoute(node)) {
       const group = configFiles.get(node.filePath);
       if (group) group.nodes.push(node);
       else configFiles.set(node.filePath, { root, nodes: [node] });
@@ -212,7 +278,7 @@ export function vueRouteTable(context: ResolutionContext): VueRouteTable {
     if (!content) continue;
     const byName = tableAt(group.root).byName;
     const byPath = new Map(group.nodes.map((n) => [n.name, n]));
-    for (const entry of parseVueRoutes(content)) {
+    for (const entry of parseVueRoutes(content, filePath)) {
       if (!entry.name) continue;
       const node = byPath.get(entry.path);
       if (node && !byName.has(entry.name)) byName.set(entry.name, node);
@@ -228,13 +294,13 @@ export function vueRouteTable(context: ResolutionContext): VueRouteTable {
 // =============================================================================
 
 /**
- * `router.push` / `.replace` (the Composition API), `$router.push` /
- * `.replace` (the Options API and templates), and Nuxt's `navigateTo`.
+ * `router.push` / `.replace` (the Composition API), `this.$router.push` /
+ * `$router.push` (the Options API and templates), and Nuxt's `navigateTo`.
  *
  * As everywhere else, `push` and `replace` need a receiver that names a
  * router: an unqualified `push` is an array's.
  */
-const NAV_CALL = /^\$?router\.(?:push|replace)$|^navigateTo$/;
+const NAV_CALL = /^(?:this\.)?\$?router\.(?:push|replace)$|^navigateTo$/;
 
 /** The verb a navigation call name stands for, or null. */
 export function vueNavVerb(name: string): string | null {
@@ -282,6 +348,56 @@ function vueComponentNamed(name: string, fromFile: string, context: ResolutionCo
   return near.length === 1 ? near[0]! : null;
 }
 
+/** `import:@/views/Login#Login` for a lazy component, the bare name for an identifier. */
+function componentRefName(component: string, spec: string | null): string {
+  return spec === null ? component : `import:${spec}#${component}`;
+}
+
+/**
+ * The component a route's reference names. A lazy import names a FILE, and
+ * the component is that file's: vue-element-admin's views are all
+ * `…/index.vue`, so the name alone (`index`) fits dozens. The import is
+ * resolved as the router file would resolve it, or — through an alias the
+ * resolver doesn't know, like vben's `#/views/…` — by the one file in the
+ * same app whose path ends the way the specifier does.
+ */
+function routeComponent(encoded: string, fromFile: string, context: ResolutionContext): Node | null {
+  const lazy = /^import:(.+)#([^#]+)$/.exec(encoded);
+  // `component: Layout` — the file's own import of it says which file that is
+  // (`import Layout from '@/layout'`, a `layout/index.vue`).
+  const spec = lazy ? lazy[1]! : (context.getImportMappings(fromFile, languageForFile(fromFile)).find((m) => m.localName === encoded)?.source ?? null);
+  const name = lazy ? lazy[2]! : encoded;
+  if (spec !== null) {
+    const file = resolveImportPath(spec, fromFile, 'vue', context) ?? fileBySuffix(spec, fromFile, context);
+    const component = file ? componentInFile(file, context) : null;
+    if (component) return component;
+  }
+  return name === 'index' ? null : vueComponentNamed(name, fromFile, context);
+}
+
+function componentInFile(file: string, context: ResolutionContext): Node | null {
+  const nodes = context.getNodesInFile(file);
+  return nodes.find((n) => n.kind === 'component') ?? nodes.find((n) => n.kind === 'function' && /^[A-Z]/.test(n.name)) ?? null;
+}
+
+const COMPONENT_EXTENSIONS = ['', '.vue', '.tsx', '.jsx', '.ts', '.js', '/index.vue', '/index.tsx', '/index.ts', '/index.js'];
+
+/** The one file under `fromFile`'s app whose path ends like `spec` minus its alias (`#/`, `@/`, `~/`). */
+function fileBySuffix(spec: string, fromFile: string, context: ResolutionContext): string | null {
+  const rest = spec.replace(/^(?:[@#~$][\w-]*\/|\.{1,2}\/)+/, '');
+  if (rest === spec || rest.length === 0) return null;
+  const root = appRootFor(fromFile);
+  const hits = new Set<string>();
+  for (const file of context.getAllFiles()) {
+    if (!file.startsWith(root)) continue;
+    for (const ext of COMPONENT_EXTENSIONS) {
+      const tail = rest + ext;
+      if (file === tail || file.endsWith('/' + tail)) hits.add(file);
+    }
+  }
+  return hits.size === 1 ? [...hits][0]! : null;
+}
+
 // =============================================================================
 // The resolver
 // =============================================================================
@@ -289,17 +405,24 @@ function vueComponentNamed(name: string, fromFile: string, context: ResolutionCo
 export const vueRouterResolver: FrameworkResolver = {
   name: 'vue-router',
   languages: [...ROUTE_LANGUAGES],
+  appDependencies: ['vue-router', 'nuxt', 'nuxt3'],
 
   detect(context: ResolutionContext): boolean {
     return dependsOn(context, 'vue-router', 'nuxt', 'nuxt3');
   },
 
   claimsReference(name: string): boolean {
-    return NAV_CALL.test(name);
+    return NAV_CALL.test(name) || name.startsWith('import:') || name.startsWith('layout:');
+  },
+
+  navigation: {
+    tails: ['push', 'replace', 'navigateTo'],
+    // A call matches against the table of the app its file is in.
+    scope: (route) => (inVueTable(route) ? [appRootFor(route.filePath)] : null),
   },
 
   extract(filePath: string, content: string): FrameworkExtractionResult {
-    const entries = parseVueRoutes(content);
+    const entries = parseVueRoutes(content, filePath);
     if (entries.length === 0) return { nodes: [], references: [] };
     const language = languageForFile(filePath);
     const now = Date.now();
@@ -329,7 +452,7 @@ export const vueRouterResolver: FrameworkResolver = {
         // a `calls` edge to a component as the page a screen renders.
         references.push({
           fromNodeId: node.id,
-          referenceName: entry.component,
+          referenceName: componentRefName(entry.component, entry.spec),
           referenceKind: 'calls',
           line: entry.line,
           column: 0,
@@ -338,11 +461,30 @@ export const vueRouterResolver: FrameworkResolver = {
           candidates: [entry.component],
         });
       }
+      // The layouts around it: what they render — a sidebar, a navbar — is on
+      // this screen too.
+      for (const layout of entry.layouts) {
+        references.push({
+          fromNodeId: node.id,
+          referenceName: `layout:${componentRefName(layout.component, layout.spec)}`,
+          referenceKind: 'references',
+          line: entry.line,
+          column: 0,
+          filePath,
+          language,
+        });
+      }
     }
     return { nodes, references };
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    if (ref.referenceKind === 'references' && isVueRouteRef(ref) && ref.referenceName.startsWith('layout:')) {
+      const layout = routeComponent(ref.referenceName.slice('layout:'.length), ref.filePath, context);
+      return layout
+        ? { original: ref, targetNodeId: layout.id, confidence: 0.95, resolvedBy: 'framework', metadata: { layout: true } }
+        : null;
+    }
     if (ref.referenceKind !== 'calls') return null;
 
     // A route naming the component it renders — this resolver's own reference,
@@ -350,7 +492,7 @@ export const vueRouterResolver: FrameworkResolver = {
     // `Login` view AND a `login` action in a store, and only one of them is
     // the screen.
     if (isVueRouteRef(ref)) {
-      const component = vueComponentNamed(ref.referenceName, ref.filePath, context);
+      const component = routeComponent(ref.referenceName, ref.filePath, context);
       return component
         ? { original: ref, targetNodeId: component.id, confidence: 0.95, resolvedBy: 'framework' }
         : null;
diff --git a/src/resolution/frameworks/vue.ts b/src/resolution/frameworks/vue.ts
index c830885be3..044221afc6 100644
--- a/src/resolution/frameworks/vue.ts
+++ b/src/resolution/frameworks/vue.ts
@@ -1,12 +1,17 @@
 /**
  * Vue / Nuxt Framework Resolver
  *
- * Handles Vue component references, compiler macros (defineProps, etc.),
- * Nuxt auto-imports, and Nuxt file-based routing patterns.
+ * Handles Vue component references, compiler macros (defineProps, etc.) and
+ * Nuxt auto-imports; `nuxtResolver` reads Nuxt's file-based routes.
  */
 
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
+import { dependsOn } from './package-deps';
+import { pageComponentRef, resolvePageComponent } from './page-component';
+
+/** The languages a Vue app's scripts are written in. */
+const VUE_SCRIPT_LANGUAGES: ReadonlySet<string> = new Set(['vue', 'javascript', 'typescript', 'tsx', 'jsx']);
 
 /**
  * Vue 3 compiler macros — compiler-provided, not user code
@@ -101,6 +106,11 @@ export const vueResolver: FrameworkResolver = {
   },
 
   resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // Vue's macros, auto-imports and components are a script's, never a
+    // backend's: mealie's Python `QueryFilterBuilder(...)` is not the
+    // `QueryFilterBuilder.vue` component.
+    if (!VUE_SCRIPT_LANGUAGES.has(ref.language)) return null;
+
     // Pattern 1: Vue compiler macros (defineProps, defineEmits, etc.)
     if (VUE_COMPILER_MACROS.has(ref.referenceName)) {
       return {
@@ -111,8 +121,10 @@ export const vueResolver: FrameworkResolver = {
       };
     }
 
-    // Pattern 2: Nuxt auto-imported composables
-    if (NUXT_AUTO_IMPORTS.has(ref.referenceName)) {
+    // Pattern 2: Nuxt auto-imported composables — unless the file declares
+    // its own function of that name, which shadows the auto-import: elk's
+    // lists page calls its own `clearError(true)`, not Nuxt's (#2340).
+    if (NUXT_AUTO_IMPORTS.has(ref.referenceName) && !declaresOwnFunction(ref, context)) {
       return {
         original: ref,
         targetNodeId: ref.fromNodeId,
@@ -186,20 +198,43 @@ export const vueResolver: FrameworkResolver = {
 
     return null;
   },
+};
+
+/**
+ * Nuxt's file-based routes: `pages/` screens, `server/api/` endpoints and
+ * `middleware/`. Its own resolver, detected only in a Nuxt app: a plain Vue
+ * app keeps its views in a `pages/` folder just as often (halo's console
+ * does), and those are components a router config names, not addresses.
+ */
+export const nuxtResolver: FrameworkResolver = {
+  name: 'nuxt',
+  appDependencies: ['nuxt', 'nuxt3', '@nuxt/kit'],
+
+  detect(context: ResolutionContext): boolean {
+    if (dependsOn(context, 'nuxt', 'nuxt3', '@nuxt/kit')) return true;
+    return context.getAllFiles().some((f) => /(?:^|\/)nuxt\.config\.(?:[cm]?[jt]s)$/.test(f));
+  },
+
+  resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    // A page route names the component its file is.
+    return resolvePageComponent(ref, context);
+  },
 
   extract(filePath: string, _content: string) {
     const nodes: Node[] = [];
+    const references: UnresolvedRef[] = [];
     const now = Date.now();
 
-    // Normalize to forward slashes
-    const normalized = filePath.replace(/\\/g, '/');
+    // Forward slashes, and a leading `/` so an app at the repository root
+    // (`pages/index.vue`) is found by the same `/pages/` search as a nested one.
+    const normalized = '/' + filePath.replace(/\\/g, '/');
 
     // Detect Nuxt page routes (pages/ directory)
     const pagesIndex = normalized.indexOf('/pages/');
     if (pagesIndex !== -1 && normalized.endsWith('.vue')) {
       const routePath = filePathToNuxtRoute(normalized, pagesIndex + '/pages/'.length);
       if (routePath !== null) {
-        nodes.push({
+        const route: Node = {
           id: `route:${filePath}:${routePath}:1`,
           kind: 'route',
           name: routePath,
@@ -211,7 +246,9 @@ export const vueResolver: FrameworkResolver = {
           endColumn: 0,
           language: 'vue',
           updatedAt: now,
-        });
+        };
+        nodes.push(route);
+        references.push(pageComponentRef(route, '.vue', 'vue'));
       }
     }
 
@@ -221,8 +258,10 @@ export const vueResolver: FrameworkResolver = {
       const afterApi = normalized.substring(apiIndex + '/server/api/'.length);
       const routeName = afterApi
         .replace(/\.[^/.]+$/, '') // Remove extension
-        .replace(/\/index$/, ''); // index -> parent path
-      const apiRoute = '/api/' + routeName;
+        .replace(/(?:^|\/)index$/, '') // index -> parent path
+        .replace(/\[\.\.\.([^\]]+)\]/g, '*$1') // [...slug] -> *slug
+        .replace(/\[([^\]]+)\]/g, ':$1'); // [id] -> :id, as a page's params are
+      const apiRoute = routeName === '' ? '/api' : '/api/' + routeName;
 
       nodes.push({
         id: `route:${filePath}:${apiRoute}:1`,
@@ -260,10 +299,17 @@ export const vueResolver: FrameworkResolver = {
       });
     }
 
-    return { nodes, references: [] };
+    return { nodes, references };
   },
 };
 
+/** Does the reference's own file declare a function (or a const holding one) by that name? */
+function declaresOwnFunction(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return context
+    .getNodesInFile(ref.filePath)
+    .some((n) => n.name === ref.referenceName && (n.kind === 'function' || n.kind === 'constant' || n.kind === 'variable'));
+}
+
 /**
  * Check if string is PascalCase
  */
@@ -317,7 +363,7 @@ function filePathToNuxtRoute(normalized: string, afterPagesStart: number): strin
   const withoutExt = afterPages.replace(/\.vue$/, '');
 
   // Remove /index suffix (index.vue -> parent route)
-  const withoutIndex = withoutExt.replace(/\/index$/, '');
+  const withoutIndex = withoutExt.replace(/(?:^|\/)index$/, '');
 
   // Convert Nuxt param syntax [param] to :param
   let route = '/' + withoutIndex
diff --git a/src/resolution/go-module.ts b/src/resolution/go-module.ts
index 03f6b9b237..73ff77de67 100644
--- a/src/resolution/go-module.ts
+++ b/src/resolution/go-module.ts
@@ -7,6 +7,12 @@
  * — `github.com/example/myproject/pkga` — as a third-party package, so
  * resolution falls through to name-matching with path proximity and returns
  * a tiny fraction of the real call sites. See issue #388.
+ *
+ * A project can hold several modules — a Go backend in `server/` next to a
+ * frontend, or etcd's root module beside `server/go.mod` and
+ * `client/v3/go.mod` — so the resolver reads the `go.mod` nearest every
+ * directory with indexed Go files and maps an import path to the module
+ * that declares the longest prefix of it (#2322).
  */
 
 import * as fs from 'fs';
@@ -20,15 +26,11 @@ export interface GoModule {
 }
 
 /**
- * Read the `go.mod` file at the project root and extract the module path.
- * Returns `null` if no `go.mod` exists or it has no `module` directive.
- *
- * Limitation: only the project-root `go.mod` is read. Nested `go.mod` files
- * (Go workspaces, monorepos with multiple modules) are not yet resolved —
- * a follow-up if a real repro shows up.
+ * Read the `go.mod` file in `moduleDir` and extract the module path.
+ * Returns `null` if no `go.mod` exists there or it has no `module` directive.
  */
-export function loadGoModule(projectRoot: string): GoModule | null {
-  const goModPath = path.join(projectRoot, 'go.mod');
+export function loadGoModule(moduleDir: string): GoModule | null {
+  const goModPath = path.join(moduleDir, 'go.mod');
   let content: string;
   try {
     content = fs.readFileSync(goModPath, 'utf-8');
@@ -43,5 +45,37 @@ export function loadGoModule(projectRoot: string): GoModule | null {
   // Strip optional quoting around the module path.
   const modulePath = match[1]!.replace(/^["']|["']$/g, '');
   if (!modulePath) return null;
-  return { modulePath, rootDir: projectRoot };
+  return { modulePath, rootDir: moduleDir };
+}
+
+/**
+ * The module an import path belongs to: the one whose module path equals it
+ * or is a `/`-bounded prefix of it. Nested modules (`example.com/app` and
+ * `example.com/app/tools`) take the longest module path, as Go does; two
+ * modules declaring the same path prefer `own`, the importing file's module.
+ * `null` for the standard library and third-party modules.
+ */
+export function findGoModuleForImport(
+  importPath: string,
+  modules: readonly GoModule[],
+  own?: GoModule | null
+): GoModule | null {
+  let best: GoModule | null = null;
+  for (const mod of own && !modules.includes(own) ? [...modules, own] : modules) {
+    if (importPath !== mod.modulePath && !importPath.startsWith(`${mod.modulePath}/`)) continue;
+    const length = best ? best.modulePath.length : -1;
+    if (mod.modulePath.length > length || (mod.modulePath.length === length && mod === own)) best = mod;
+  }
+  return best;
+}
+
+/**
+ * The project-relative directory (`/`-separated, `.` for the project root)
+ * of the package `importPath` names inside module `mod`: the module's own
+ * directory followed by the rest of the import path.
+ */
+export function goModulePackageDir(importPath: string, mod: GoModule, projectRoot: string): string {
+  const modDir = path.relative(projectRoot, mod.rootDir).split(path.sep).join('/');
+  const rest = importPath === mod.modulePath ? '' : importPath.slice(mod.modulePath.length + 1);
+  return path.posix.join(modDir, rest);
 }
diff --git a/src/resolution/import-resolver.ts b/src/resolution/import-resolver.ts
index 70e018f57a..651825f41f 100644
--- a/src/resolution/import-resolver.ts
+++ b/src/resolution/import-resolver.ts
@@ -11,12 +11,16 @@ import { UnresolvedRef, ResolvedRef, ResolutionContext, ImportMapping, ReExport
 import { applyAliases } from './path-aliases';
 import { extractLocalExportAliases } from './alias-binding';
 import { resolveWorkspaceImport } from './workspace-packages';
+import { stripCommentsForRegex } from './strip-comments';
+import { dartDirectiveFile } from './dart-libraries';
+import { moduleTail } from '../db/reference-tail';
 import {
   resolveMethodOnType,
   resolveObjectLiteralMember,
   resolveObjectLiteralBinding,
   localReceiverTypePatterns,
   normalizeInferredTypeName,
+  goRefQualifier,
 } from './name-matcher';
 
 /**
@@ -108,6 +112,8 @@ interface FileExportIndex {
 
 const DEFAULT_BINDING_KINDS = new Set<string>(['function', 'class', 'component', 'constant', 'variable']);
 const DEFAULT_EXPORT_BINDING_RE = /^[ \t]*export\s+default\s+([A-Za-z_$][\w$]*)\s*;?[ \t]*$/m;
+/** Any `export default …` statement: the module is an ES module with a default export. */
+const ESM_DEFAULT_EXPORT_RE = /^[ \t]*export\s+default\b/m;
 const JS_FAMILY_FILE = /\.(?:[cm]?[jt]sx?)$/;
 
 /** The identifier `export default NAME` names in a JS-family file, or null. */
@@ -119,6 +125,24 @@ function defaultExportBinding(filePath: string, context: ResolutionContext): str
 }
 const fileExportIndexes = new WeakMap<ResolutionContext, Map<string, FileExportIndex>>();
 
+/**
+ * `module.exports = …` (also `exports = module.exports = …`): the name it
+ * binds (`createApplication`, `function name(`, `class Name`) or the module
+ * it forwards (`require('./lib/express')`), or null.
+ */
+const COMMONJS_DEFAULT_EXPORT =
+  /^[ \t]*(?:exports\s*=\s*)?module\.exports\s*=\s*(?:exports\s*=\s*)?(?:require\(\s*['"]([^'"]+)['"]\s*\)\s*;?[ \t]*$|(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)\s*\(|class\s+([A-Za-z_$][\w$]*)|([A-Za-z_$][\w$]*)\s*;?[ \t]*$)/m;
+
+function commonJsDefaultExport(filePath: string, context: ResolutionContext): { source?: string; name?: string } | null {
+  if (!JS_FAMILY_FILE.test(filePath)) return null;
+  if (context.fileContains && !context.fileContains(filePath, 'module.exports')) return null;
+  const source = context.readFile(filePath);
+  if (!source || !source.includes('module.exports')) return null;
+  const m = COMMONJS_DEFAULT_EXPORT.exec(source);
+  if (!m) return null;
+  return m[1] ? { source: m[1] } : { name: m[2] ?? m[3] ?? m[4] };
+}
+
 function getFileExportIndex(filePath: string, context: ResolutionContext): FileExportIndex {
   let perFile = fileExportIndexes.get(context);
   if (!perFile) {
@@ -158,6 +182,28 @@ function defaultExportBindingNode(filePath: string, idx: FileExportIndex, contex
   return idx.defaultBinding ?? undefined;
 }
 
+/**
+ * The declaration a module default-exports: the component a single-file
+ * component file is, else what an `export default NAME` statement names, else
+ * the first exported function or class (`export default class Foo`).
+ */
+function esmDefaultExport(filePath: string, idx: FileExportIndex, context: ResolutionContext): Node | undefined {
+  return idx.defaultComponent ?? defaultExportBindingNode(filePath, idx, context) ?? idx.defaultFnClass;
+}
+
+/**
+ * Whether the module has an ESM default export at all: it is a single-file
+ * component, or a JS-family file with an `export default` statement. A
+ * CommonJS module has none, though its `exports.x = function` declarations are
+ * exported and would feed the first-exported-function guess.
+ */
+function hasEsmDefaultExport(filePath: string, idx: FileExportIndex, context: ResolutionContext): boolean {
+  if (idx.defaultComponent) return true;
+  if (!JS_FAMILY_FILE.test(filePath)) return false;
+  const source = context.readFile(filePath);
+  return !!source && source.includes('default') && ESM_DEFAULT_EXPORT_RE.test(source);
+}
+
 /** What this file exports as `name`: an exported declaration, else a local export clause's binding. */
 function exportedByName(filePath: string, idx: FileExportIndex, name: string, context: ResolutionContext): Node | undefined {
   const direct = idx.byName.get(name);
@@ -188,6 +234,7 @@ export function clearImportResolverMemos(context: ResolutionContext): void {
   luaFileBasenameIndexes.delete(context);
   cobolCopybookIndexes.delete(context);
   pythonModuleFileMemos.delete(context);
+  PY_MODULE_SYMBOLS.delete(context);
 }
 
 export function resolveImportPath(
@@ -240,7 +287,7 @@ function resolveImportPathUncached(
   }
 
   // Handle absolute/aliased imports (like @/ or src/)
-  const aliased = resolveAliasedImport(importPath, projectRoot, language, context);
+  const aliased = resolveAliasedImport(importPath, projectRoot, language, context, fromFile);
   if (aliased) return aliased;
 
   // C/C++ include directory search: when neither relative nor aliased
@@ -389,11 +436,17 @@ const RUST_STDLIB_ROOTS = new Set(['std', 'core', 'alloc', 'proc_macro']);
  * (tsconfig/jsconfig `paths`). Without that check, custom prefixes
  * like `@components/*` would fail the bare-specifier heuristic and
  * be classified as external before alias resolution can run.
+ *
+ * `aliasPrefixes: false` skips that check, for a caller that has already
+ * asked `resolveImportPath` whether an alias maps the specifier to a file.
+ * Matching a prefix proves nothing by itself: a catch-all `"*"` pattern
+ * (`"*": ["./typings/*"]`) has an empty prefix and matches every package.
  */
-function isExternalImport(
+export function isExternalImport(
   importPath: string,
   language: Language,
-  context?: ResolutionContext
+  context?: ResolutionContext,
+  options: { aliasPrefixes?: boolean } = {}
 ): boolean {
   // Relative imports are not external
   if (importPath.startsWith('.')) {
@@ -416,7 +469,7 @@ function isExternalImport(
       return true;
     }
     // Project-defined alias prefix? Treat as local.
-    const aliases = context?.getProjectAliases?.();
+    const aliases = options.aliasPrefixes === false ? null : context?.getProjectAliases?.();
     if (aliases) {
       for (const pat of aliases.patterns) {
         if (importPath.startsWith(pat.prefix)) return false;
@@ -444,9 +497,10 @@ function isExternalImport(
     }
     // In-module imports look like `<module-path>/sub/pkg` — local to
     // this project. Without the module-path check we'd flag every
-    // cross-package call in a Go monorepo as external (issue #388).
-    const mod = context?.getGoModule?.();
-    if (mod && (importPath === mod.modulePath || importPath.startsWith(mod.modulePath + '/'))) {
+    // cross-package call in a Go monorepo as external (issue #388) — and,
+    // for a module whose go.mod is below the root or beside other modules,
+    // every import of it (#2322).
+    if (context?.getGoPackageDir?.(importPath) != null) {
       return false;
     }
     // `internal/` packages stay local even when go.mod is missing —
@@ -505,9 +559,10 @@ function resolveRelativeImport(
   const basePath = path.resolve(fromDir, importPath);
   const relativePath = path.relative(projectRoot, basePath).replace(/\\/g, '/');
 
-  // Try each extension
+  // Try each extension. `require('..')` up to the project root is its `index.js`.
   for (const ext of extensions) {
-    const candidatePath = relativePath + ext;
+    if (relativePath === '' && !ext.startsWith('/')) continue;
+    const candidatePath = relativePath === '' ? ext.slice(1) : relativePath + ext;
     if (context.fileExists(candidatePath)) {
       return candidatePath;
     }
@@ -576,7 +631,8 @@ function resolveAliasedImport(
   importPath: string,
   projectRoot: string,
   language: Language,
-  context: ResolutionContext
+  context: ResolutionContext,
+  fromFile?: string
 ): string | null {
   const extensions = EXTENSION_RESOLUTION[language] || [];
   const tryWithExt = (basePath: string): string | null => {
@@ -588,9 +644,12 @@ function resolveAliasedImport(
     return findSourceForEmittedSpecifier(basePath, language, context);
   };
 
-  // 1. Project tsconfig/jsconfig paths.
-  const aliasMap = context.getProjectAliases?.();
-  if (aliasMap) {
+  // 1. tsconfig/jsconfig paths: the config nearest the importing file (an
+  //    app of a monorepo keeps its own `@/*`), then the project root's.
+  const nearest = fromFile ? context.getNearestAliases?.(fromFile) : null;
+  const rootMap = context.getProjectAliases?.();
+  for (const aliasMap of nearest && nearest !== rootMap ? [nearest, rootMap] : [rootMap]) {
+    if (!aliasMap) continue;
     const candidates = applyAliases(importPath, aliasMap, projectRoot);
     for (const c of candidates) {
       const hit = tryWithExt(c);
@@ -865,6 +924,28 @@ export function isCobolCopybookRef(ref: UnresolvedRef): boolean {
   return ref.language === 'cobol' && ref.referenceKind === 'imports';
 }
 
+/**
+ * Is this a Dart `import`, `export` or `part`? Its name is the URI, which
+ * names one file (see ./dart-libraries) or none — `dart:async`, a package from
+ * outside the project, a generated part nobody committed — and never a
+ * symbol: the name-matcher took the URI's last segment for a file name
+ * (`package:flutter/foundation.dart` went to riverpod's own foundation.dart)
+ * or bound it to the file's own `import` node.
+ */
+export function isDartImportRef(ref: UnresolvedRef): boolean {
+  return ref.language === 'dart' && ref.referenceKind === 'imports';
+}
+
+/**
+ * Is this a Lua / Luau `require`? It names a module file (see
+ * resolveLuaRequire) or a module from outside the project, never a symbol:
+ * the name-matcher bound `local lfs = require "lfs"` and `local Signal =
+ * require(script.Parent.Signal)` to the local each is assigned to.
+ */
+export function isLuaRequireRef(ref: UnresolvedRef): boolean {
+  return (ref.language === 'lua' || ref.language === 'luau') && ref.referenceKind === 'imports';
+}
+
 /**
  * Resolve a PHP include/require path to a project-relative file path.
  *
@@ -913,7 +994,7 @@ export function extractImportMappings(
     // whole SFC (markup + styles included) is safe.
     mappings.push(...extractJSImports(content));
   } else if (language === 'python') {
-    mappings.push(...extractPythonImports(content));
+    mappings.push(...extractPythonImports(stripCommentsForRegex(content, 'python')));
   } else if (language === 'go') {
     mappings.push(...extractGoImports(content));
   } else if (language === 'java' || language === 'kotlin') {
@@ -933,8 +1014,15 @@ export function extractImportMappings(
 function extractJSImports(content: string): ImportMapping[] {
   const mappings: ImportMapping[] = [];
 
-  // ES6 imports
-  const importRegex = /import\s+(?:(\w+)\s*,?\s*)?(?:\{([^}]+)\})?\s*(?:(\*)\s+as\s+(\w+))?\s*from\s*['"]([^'"]+)['"]/g;
+  // ES6 imports. `import type { X }` / `import type * as ns` is TypeScript's
+  // type-only form, not a default import named `type` — which every such
+  // line used to add, making `type.innerType()` a call on an import.
+  // (`import type from './x'` still binds `type`: backtracking gives it back.)
+  // A binding is any JS identifier, `$` included: `\w` stops at the `$` of
+  // `import $store from './store'`, failing the whole statement. A default
+  // binding is never followed by `{`, so the `${` of a code generator's
+  // `` `import ${name} from '${src}'` `` is no binding.
+  const importRegex = /import\s+(?:type\s+(?=[{*]|(?!from(?![\w$]))[A-Za-z_$]))?(?:([A-Za-z_$][\w$]*)(?![\w${])\s*,?\s*)?(?:\{([^}]+)\})?\s*(?:(\*)\s+as\s+([A-Za-z_$][\w$]*))?\s*from\s*['"]([^'"]+)['"]/g;
 
   let match;
   while ((match = importRegex.exec(content)) !== null) {
@@ -953,15 +1041,18 @@ function extractJSImports(content: string): ImportMapping[] {
 
     // Named imports
     if (namedImports) {
-      const names = namedImports.split(',').map((s) => s.trim());
+      // `{ util, type objectUtil }`: an inline `type` modifier is not part of the name.
+      const names = namedImports.split(',').map((s) => s.trim().replace(/^type\s+(?=[A-Za-z_$])/, ''));
       for (const name of names) {
-        const aliasMatch = name.match(/(\w+)\s+as\s+(\w+)/);
+        const aliasMatch = name.match(/([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)/);
         if (aliasMatch) {
           mappings.push({
             localName: aliasMatch[2]!,
             exportedName: aliasMatch[1]!,
             source: source!,
-            isDefault: false,
+            // `{ default as X }` is the default import spelled as a named one;
+            // no module declares an export named `default` to find.
+            isDefault: aliasMatch[1] === 'default',
             isNamespace: false,
           });
         } else if (name) {
@@ -988,17 +1079,18 @@ function extractJSImports(content: string): ImportMapping[] {
     }
   }
 
-  // Require statements
-  const requireRegex = /(?:const|let|var)\s+(?:(\w+)|{([^}]+)})\s*=\s*require\(['"]([^'"]+)['"]\)/g;
+  // Require statements — each declarator of a list too (`var express = require('../'),
+  // request = require('supertest')`), and a member of the module (`require('./utils').methods`).
+  const requireRegex = /(?:\b(?:const|let|var)\s+|,\s*)(?:([A-Za-z_$][\w$]*)|{([^}]+)})\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)(?:\s*\.\s*([A-Za-z_$][\w$]*))?/g;
   while ((match = requireRegex.exec(content)) !== null) {
-    const [, defaultName, destructured, source] = match;
+    const [, defaultName, destructured, source, member] = match;
 
     if (defaultName) {
       mappings.push({
         localName: defaultName,
-        exportedName: 'default',
+        exportedName: member ?? 'default',
         source: source!,
-        isDefault: true,
+        isDefault: member === undefined,
         isNamespace: false,
       });
     }
@@ -1006,7 +1098,7 @@ function extractJSImports(content: string): ImportMapping[] {
     if (destructured) {
       const names = destructured.split(',').map((s) => s.trim());
       for (const name of names) {
-        const aliasMatch = name.match(/(\w+)\s*:\s*(\w+)/);
+        const aliasMatch = name.match(/([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$]*)/);
         if (aliasMatch) {
           mappings.push({
             localName: aliasMatch[2]!,
@@ -1037,13 +1129,14 @@ function extractJSImports(content: string): ImportMapping[] {
 function extractPythonImports(content: string): ImportMapping[] {
   const mappings: ImportMapping[] = [];
 
-  // from X import Y
-  const fromImportRegex = /from\s+([\w.]+)\s+import\s+([^#\n]+)/g;
+  // from X import Y, and the parenthesized form `from X import (\n Y,\n Z,\n)`
+  const fromImportRegex = /from\s+([\w.]+)\s+import\s+(\([^)]*\)|[^#\n]+)/g;
   let match;
 
   while ((match = fromImportRegex.exec(content)) !== null) {
     const [, source, imports] = match;
-    const names = imports!.split(',').map((s) => s.trim());
+    const names = imports!.trim().replace(/^\(|\)$/g, '')
+      .split(',').map((s) => s.trim());
 
     for (const name of names) {
       const aliasMatch = name.match(/(\w+)\s+as\s+(\w+)/);
@@ -1085,50 +1178,85 @@ function extractPythonImports(content: string): ImportMapping[] {
 }
 
 /**
- * Extract Go import mappings
+ * Extract Go import mappings. An import is bound to the name written before
+ * its path, or else to the name of the package it imports — which the path
+ * alone doesn't settle: `k8s.io/api/core/v1` is package `v1`, while
+ * `go.yaml.in/yaml/v3` and `gopkg.in/yaml.v3` are `yaml`, and
+ * `github.com/mattn/go-sqlite3` is `sqlite3`. So an unaliased import keeps its
+ * last path element and also takes the name goimports assumes for the path,
+ * unless another of the file's imports is bound to that name.
  */
 function extractGoImports(content: string): ImportMapping[] {
-  const mappings: ImportMapping[] = [];
-
-  // import "path" or import alias "path"
-  const singleImportRegex = /import\s+(?:(\w+)\s+)?["']([^"']+)["']/g;
+  const specs: Array<{ name: string | undefined; source: string }> = [];
+  // Only the imports, which Go puts before any other declaration, and without
+  // their comments: a word in one is no name — `"fmt" // for printing` used to
+  // name the next import `printing`. A name is on its path's own line.
+  const code = stripCommentsForRegex(content.slice(0, goImportsEnd(content)), 'go');
+
+  // import "path" or import name "path"
+  const singleImportRegex = /\bimport\s+(?:([A-Za-z_]\w*)[ \t]*)?["']([^"']+)["']/g;
   let match;
-
-  while ((match = singleImportRegex.exec(content)) !== null) {
-    const [, alias, source] = match;
-    const packageName = source!.split('/').pop()!;
-    mappings.push({
-      localName: alias || packageName,
-      exportedName: '*',
-      source: source!,
-      isDefault: false,
-      isNamespace: true,
-    });
+  while ((match = singleImportRegex.exec(code)) !== null) {
+    specs.push({ name: match[1], source: match[2]! });
   }
 
   // import ( ... ) block
-  const blockImportRegex = /import\s*\(\s*([^)]+)\s*\)/gs;
-  while ((match = blockImportRegex.exec(content)) !== null) {
-    const block = match[1]!;
-    const lineRegex = /(?:(\w+)\s+)?["']([^"']+)["']/g;
+  const blockImportRegex = /\bimport\s*\(\s*([^)]+)\s*\)/g;
+  while ((match = blockImportRegex.exec(code)) !== null) {
+    const lineRegex = /(?:([A-Za-z_]\w*|\.)[ \t]*)?["']([^"']+)["']/g;
     let lineMatch;
-
-    while ((lineMatch = lineRegex.exec(block)) !== null) {
-      const [, alias, source] = lineMatch;
-      const packageName = source!.split('/').pop()!;
-      mappings.push({
-        localName: alias || packageName,
-        exportedName: '*',
-        source: source!,
-        isDefault: false,
-        isNamespace: true,
-      });
+    while ((lineMatch = lineRegex.exec(match[1]!)) !== null) {
+      specs.push({ name: lineMatch[1], source: lineMatch[2]! });
     }
   }
 
+  const mapping = (localName: string, source: string): ImportMapping =>
+    ({ localName, exportedName: '*', source, isDefault: false, isNamespace: true });
+  // A dot import (`. "pkg"`) binds no name of its own; it stays listed under
+  // its last path element.
+  const mappings = specs.map(({ name, source }) =>
+    mapping(name === undefined || name === '.' ? source.split('/').pop()! : name, source));
+  const bound = new Set(mappings.map((m) => m.localName));
+  const assumed = new Map<string, string[]>();
+  for (const { name, source } of specs) {
+    if (name !== undefined) continue;
+    const assumedName = goAssumedPackageName(source);
+    if (assumedName && !bound.has(assumedName)) assumed.set(assumedName, [...(assumed.get(assumedName) ?? []), source]);
+  }
+  // Two imports that assume one name can't both be that package.
+  for (const [localName, sources] of assumed) {
+    if (sources.length === 1) mappings.push(mapping(localName, sources[0]!));
+  }
   return mappings;
 }
 
+/**
+ * Where a Go file's imports end: at its first other top-level declaration, a
+ * line opening with `func`, `type`, `var` or `const` outside a block comment.
+ */
+function goImportsEnd(content: string): number {
+  const decl = /^(?:func|type|var|const)\b/gm;
+  for (let m; (m = decl.exec(content)) !== null;) {
+    if (content.lastIndexOf('/*', m.index) <= content.lastIndexOf('*/', m.index)) return m.index;
+  }
+  return content.length;
+}
+
+/**
+ * The package name goimports assumes for an import path
+ * (ImportPathToAssumedName): its last element that isn't a major version
+ * (`go.yaml.in/yaml/v3` → `yaml`), without a `go-` prefix
+ * (`github.com/mattn/go-sqlite3` → `sqlite3`), cut where an identifier can't
+ * go on (`gopkg.in/yaml.v3` → `yaml`).
+ */
+function goAssumedPackageName(importPath: string): string {
+  const elements = importPath.split('/');
+  let base = elements[elements.length - 1]!;
+  if (elements.length > 1 && /^v\d+$/.test(base)) base = elements[elements.length - 2]!;
+  if (base.startsWith('go-')) base = base.slice(3);
+  return /^[\p{L}\p{Nd}_]*/u.exec(base)![0];
+}
+
 /**
  * Extract Java / Kotlin import mappings.
  *
@@ -1149,8 +1277,8 @@ function extractJavaImports(content: string): ImportMapping[] {
   const stripped = content
     .replace(/\/\*[\s\S]*?\*\//g, '')
     .replace(/\/\/[^\n]*/g, '');
-  // `import [static] <fqn>[.*];`
-  const re = /^\s*import\s+(static\s+)?([\w.]+(?:\.\*)?)\s*;/gm;
+  // `import [static] <fqn>[.*];` — and Kotlin's `import <fqn> [as Alias]`, with no `;`.
+  const re = /^\s*import\s+(static\s+)?([\w.]+(?:\.\*)?)(?:\s+as\s+([\w]+))?\s*(?:;|$)/gm;
   let match: RegExpExecArray | null;
   while ((match = re.exec(stripped)) !== null) {
     const fqn = match[2]!;
@@ -1159,11 +1287,11 @@ function extractJavaImports(content: string): ImportMapping[] {
     // through the wildcard. (Future enhancement: enumerate package files.)
     if (fqn.endsWith('.*')) continue;
     const parts = fqn.split('.');
-    const localName = parts[parts.length - 1];
+    const localName = match[3] ?? parts[parts.length - 1];
     if (!localName) continue;
     mappings.push({
       localName,
-      exportedName: localName,
+      exportedName: parts[parts.length - 1]!,
       source: fqn,
       isDefault: false,
       isNamespace: false,
@@ -1325,11 +1453,11 @@ export function extractReExports(content: string, language: Language): ReExport[
   // out of scope.)
   const cleaned = stripJsComments(content);
 
-  // Wildcard: `export * from '...'` or `export * as ns from '...'`
-  const wildcardRe = /export\s*\*(?:\s+as\s+\w+)?\s*from\s*['"]([^'"]+)['"]/g;
+  // Wildcard: `export * from '...'`; `export * as ns from '...'` exports `ns` alone.
+  const wildcardRe = /export\s*\*(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*from\s*['"]([^'"]+)['"]/g;
   let m: RegExpExecArray | null;
   while ((m = wildcardRe.exec(cleaned)) !== null) {
-    out.push({ kind: 'wildcard', source: m[1]! });
+    out.push(m[1] ? { kind: 'namespace', exportedName: m[1], source: m[2]! } : { kind: 'wildcard', source: m[2]! });
   }
 
   // Named: `export { a, b as c } from '...'`
@@ -1340,7 +1468,7 @@ export function extractReExports(content: string, language: Language): ReExport[
     for (const raw of inner.split(',')) {
       const item = raw.trim();
       if (!item) continue;
-      const aliasMatch = item.match(/^(\w+)\s+as\s+(\w+)$/);
+      const aliasMatch = item.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
       if (aliasMatch) {
         out.push({
           kind: 'named',
@@ -1348,7 +1476,7 @@ export function extractReExports(content: string, language: Language): ReExport[
           originalName: aliasMatch[1]!,
           source,
         });
-      } else if (/^\w+$/.test(item)) {
+      } else if (/^[A-Za-z_$][\w$]*$/.test(item)) {
         out.push({
           kind: 'named',
           exportedName: item,
@@ -1408,6 +1536,26 @@ export function resolveJvmImport(
   };
 }
 
+/** `Alias` / `Alias.member` through a renaming Kotlin import, by the imported FQN. */
+function resolveJvmAlias(ref: UnresolvedRef, imports: ImportMapping[], context: ResolutionContext): ResolvedRef | null {
+  const dot = ref.referenceName.indexOf('.');
+  const root = dot < 0 ? ref.referenceName : ref.referenceName.slice(0, dot);
+  const imp = imports.find((m) => m.localName === root && m.localName !== m.exportedName);
+  if (!imp) return null;
+  const parts = imp.source.split('.');
+  // The package is some prefix of the FQN; the rest is the type path (`Outer::Inner`).
+  for (let i = parts.length - 1; i > 0; i--) {
+    const target = context.getNodesByQualifiedName(`${parts.slice(0, i).join('.')}::${parts.slice(i).join('::')}`)[0];
+    if (!target) continue;
+    const member = dot < 0 ? null : ref.referenceName.slice(dot + 1);
+    if (member === null) return { original: ref, targetNodeId: target.id, confidence: 0.9, resolvedBy: 'import' };
+    if (member.includes('.')) return null;
+    const found = context.getNodesByQualifiedName(`${target.qualifiedName}::${member}`)[0];
+    return found ? { original: ref, targetNodeId: found.id, confidence: 0.9, resolvedBy: 'import' } : null;
+  }
+  return null;
+}
+
 /**
  * Pick the same-FQN candidate closest to `fromPath` by shared directory
  * prefix, preferring an `expect` declaration on a tie. Used to keep a Kotlin
@@ -1480,10 +1628,116 @@ export function resolvePhpImportedStaticCall(
   return { original: ref, targetNodeId: methods[0]!.id, confidence: 0.95, resolvedBy: 'import' };
 }
 
+const JS_MODULE_LANGUAGES: ReadonlySet<string> = new Set(['javascript', 'jsx', 'typescript', 'tsx', 'arkts']);
+
+/**
+ * A module specifier written as a path — relative (`./x`, `../x`), rooted, or
+ * an alias with a folder in it (`@/lib/x`, `~/x`, `$lib/x`) — rather than an
+ * imported binding's name or a bare package (`react`, `lodash`).
+ */
+function isJsPathSpecifier(name: string): boolean {
+  return name.startsWith('./') || name.startsWith('../') || name === '.' || name === '..' ||
+    (name.includes('/') && !/\s/.test(name) && !/^@[\w.-]+\/[\w.-]+$/.test(name));
+}
+
+/**
+ * A JS/TS `imports` reference that names a module by path. It names a FILE, not
+ * a symbol, so it skips the resolver's name-exists pre-filter — a CommonJS
+ * `require('./x')` has no import node of that name to pass it.
+ */
+export function isJsPathImportRef(ref: UnresolvedRef): boolean {
+  return ref.referenceKind === 'imports' && JS_MODULE_LANGUAGES.has(ref.language) && isJsPathSpecifier(ref.referenceName);
+}
+
+/** PHP reference kinds whose name is a class name, written as in the source. */
+const PHP_CLASS_NAME_REFS: ReadonlySet<string> = new Set(['instantiates', 'extends', 'implements', 'references']);
+
+/**
+ * A PHP class name written with a namespace in it (#2256). `use App\Fields as
+ * Field;` aliases a namespace, so `new Field\FirstName()`, `extends Field\Base`
+ * and `Field\FirstName::make()` all name `App\Fields\FirstName`. PHP reads a
+ * qualified name one way: a leading `\` makes it absolute; otherwise a first
+ * segment a `use` imports is replaced by what it imports, and any other name is
+ * relative to the current namespace. Both extractors emit the written name
+ * verbatim, and with no `.` or `::` in it the pre-filter would drop it.
+ * undefined means the ref is not a qualified class name (or names a method the
+ * class inherits); null means it is but no single project class has that name
+ * — it lives outside the project — so name fallbacks must not guess.
+ */
+export function resolvePhpQualifiedClassRef(
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): ResolvedRef | null | undefined {
+  if (ref.language !== 'php') return undefined;
+  let name = ref.referenceName;
+  let member: string | null = null;
+  if (ref.referenceKind === 'calls') {
+    // A static call on the class: `Field\FirstName::make()` is written `Field\FirstName.make`.
+    const call = /^(.*\\[^\\.:]+)(?:\.|::)(\w+)$/.exec(name);
+    if (!call) return undefined;
+    name = call[1]!;
+    member = call[2]!;
+  } else if (!PHP_CLASS_NAME_REFS.has(ref.referenceKind)) {
+    return undefined;
+  }
+  const separator = name.indexOf('\\');
+  if (separator < 0) return undefined;
+
+  let fqn: string;
+  if (separator === 0) {
+    fqn = name.slice(1);
+  } else {
+    const head = name.slice(0, separator);
+    const imp = context.getImportMappings(ref.filePath, ref.language).find((i) => i.localName === head);
+    if (imp) {
+      fqn = imp.source.replace(/^\\/, '') + name.slice(separator);
+    } else {
+      // `namespace App;` applies until the next namespace statement.
+      const namespace = context.getNodesInFile(ref.filePath)
+        .filter((n) => n.kind === 'namespace' && n.startLine <= ref.line)
+        .sort((a, b) => b.startLine - a.startLine)[0];
+      fqn = namespace ? `${namespace.qualifiedName}\\${name}` : name;
+    }
+  }
+
+  const cut = fqn.lastIndexOf('\\');
+  const qualifiedName = cut < 0 ? fqn : `${fqn.slice(0, cut)}::${fqn.slice(cut + 1)}`;
+  const classes = context.getNodesByQualifiedName(qualifiedName)
+    .filter((n) => n.language === 'php' && STATIC_MEMBER_CONTAINERS.has(n.kind));
+  // A type mention can name something other than a class (a namespaced
+  // constant or function), so it keeps the ordinary strategies.
+  if (classes.length !== 1) return ref.referenceKind === 'references' ? undefined : null;
+  const owner = classes[0]!;
+  if (!member) return { original: ref, targetNodeId: owner.id, confidence: 0.95, resolvedBy: 'import' };
+  const methods = context.getNodesByQualifiedName(`${owner.qualifiedName}::${member}`)
+    .filter((n) => n.language === 'php' && n.kind === 'method' && n.filePath === owner.filePath);
+  // A method the class inherits is left to the strategies that walk supertypes.
+  if (methods.length !== 1) return undefined;
+  return { original: ref, targetNodeId: methods[0]!.id, confidence: 0.95, resolvedBy: 'import' };
+}
+
 export function resolveViaImport(
   ref: UnresolvedRef,
   context: ResolutionContext
 ): ResolvedRef | null {
+  // A JS/TS module specifier — `import './polyfills'`, the module of `import x
+  // from '../lib/a'`, a CommonJS `require('./application')` — names a FILE,
+  // found the way the runtime finds it: extensions, `index` files, path
+  // aliases. Matching the basename instead missed every extensionless one
+  // (the common spelling) and could land on a same-named file elsewhere.
+  if (isJsPathImportRef(ref)) {
+    const file = resolveImportPath(ref.referenceName, ref.filePath, ref.language, context);
+    const fileNode = file && file !== ref.filePath ? context.getNodesInFile(file).find((n) => n.kind === 'file') : undefined;
+    if (fileNode) return { original: ref, targetNodeId: fileNode.id, confidence: 0.9, resolvedBy: 'import' };
+  }
+  // A Dart `import` / `export` URI names a library file, and a `part` URI one
+  // of the library's own files: `package:app/x.dart` is app's lib/x.dart, any
+  // other path is from the file the directive is in.
+  if (isDartImportRef(ref)) {
+    const file = dartDirectiveFile(ref.filePath, ref.referenceName, context);
+    const fileNode = file && file !== ref.filePath ? context.getNodesInFile(file).find((n) => n.kind === 'file') : undefined;
+    return fileNode ? { original: ref, targetNodeId: fileNode.id, confidence: 0.9, resolvedBy: 'import' } : null;
+  }
   // C/C++ #include references — resolve directly to the included file
   // (file→file edge), bypassing symbol lookup. The extractor emits these
   // with `referenceKind: 'imports'` and `referenceName: <include path>`
@@ -1678,6 +1932,13 @@ export function resolveViaImport(
     if (moduleFile) return moduleFile;
   }
 
+  // Kotlin's `import app.model.Outer.Inner as Made`: `Made.create()` is the
+  // aliased class's member, found by its FQN — nothing else binds the alias.
+  if (ref.language === 'kotlin' && ref.referenceKind !== 'imports') {
+    const aliased = resolveJvmAlias(ref, imports, context);
+    if (aliased) return aliased;
+  }
+
   // Check if the reference name matches any import
   for (const imp of imports) {
     if (imp.localName === ref.referenceName || ref.referenceName.startsWith(imp.localName + '.')) {
@@ -1708,9 +1969,7 @@ export function resolveViaImport(
           context,
           new Set()
         ) ?? (ref.language === 'python'
-          ? context.getNodesInFile(resolvedPath).find(n =>
-              n.name === (memberName ?? exportedName) && !n.qualifiedName.includes('::') &&
-              (n.kind === 'class' || n.kind === 'function' || n.kind === 'variable' || n.kind === 'constant'))
+          ? pythonModuleSymbol(resolvedPath, memberName ?? exportedName, context, 0)
           : undefined);
 
         if (targetNode) {
@@ -1843,16 +2102,10 @@ function resolvePythonModuleMember(
     }
     if (!resolvedPath || resolvedPath === ref.filePath) continue;
 
-    // Find the member as a top-level definition in the module file. Exclude
-    // `method` so `mod.foo` never lands on a same-named class method.
-    const target = context.getNodesInFile(resolvedPath).find(
-      (n) =>
-        n.name === member &&
-        (n.kind === 'function' ||
-          n.kind === 'class' ||
-          n.kind === 'variable' ||
-          n.kind === 'constant')
-    );
+    // Find the member as a top-level definition in the module file, or one it
+    // re-exports (a package's `__init__.py`). Exclude `method` so `mod.foo`
+    // never lands on a same-named class method.
+    const target = pythonModuleSymbol(resolvedPath, member, context, 0);
     if (target) {
       return { original: ref, targetNodeId: target.id, confidence: 0.85, resolvedBy: 'import' };
     }
@@ -2022,6 +2275,49 @@ function resolveModuleImportToFile(
  */
 const pythonModuleFileMemos = new WeakMap<ResolutionContext, Map<string, { module: Node[]; pkg: Node[] }>>();
 
+/**
+ * A top-level class / function / value named `name` in a Python module, or
+ * one the module re-exports — `from .users import *`, `from .users import
+ * User` — a few packages deep. netbox's `from users.models import User` names
+ * `users/models/__init__.py`, which star-imports `.users`, where `User` is.
+ */
+const PY_MODULE_SYMBOLS = new WeakMap<ResolutionContext, Map<string, Node | null>>();
+
+function pythonModuleSymbol(file: string, name: string, context: ResolutionContext, depth: number): Node | undefined {
+  let memo = PY_MODULE_SYMBOLS.get(context);
+  if (!memo) PY_MODULE_SYMBOLS.set(context, (memo = new Map()));
+  const key = `${file}\0${name}`;
+  const hit = memo.get(key);
+  if (hit !== undefined) return hit ?? undefined;
+  // (A cycle of star imports reads as "not here" while it is being walked.)
+  memo.set(key, null);
+  const found = pythonModuleSymbolUncached(file, name, context, depth);
+  memo.set(key, found ?? null);
+  return found;
+}
+
+function pythonModuleSymbolUncached(file: string, name: string, context: ResolutionContext, depth: number): Node | undefined {
+  const own = context.getNodesInFile(file).find((n) =>
+    n.name === name && !n.qualifiedName.includes('::') &&
+    (n.kind === 'class' || n.kind === 'function' || n.kind === 'variable' || n.kind === 'constant'));
+  if (own || depth >= 3) return own;
+  // Re-exported by name (`from .users import User`), else through a star import
+  // (`from .users import *` — not among the import mappings, so read here).
+  const sources: Array<{ source: string; exported: string }> = context.getImportMappings(file, 'python')
+    .filter((imp) => !imp.isNamespace && imp.localName === name)
+    .map((imp) => ({ source: imp.source, exported: imp.exportedName }));
+  for (const m of (context.readFile(file) ?? '').matchAll(/^\s*from\s+([\w.]+)\s+import\s+\*/gm)) {
+    sources.push({ source: m[1]!, exported: name });
+  }
+  for (const { source, exported } of sources) {
+    const target = resolveImportPath(source, file, 'python', context) ?? findPythonModuleFile(source, context, file)?.filePath ?? null;
+    if (!target || target === file) continue;
+    const found = pythonModuleSymbol(target, exported, context, depth + 1);
+    if (found) return found;
+  }
+  return undefined;
+}
+
 function findPythonModuleFile(
   mod: string,
   context: ResolutionContext,
@@ -2279,57 +2575,66 @@ function resolveJavaImportedReference(
 
 /**
  * Resolve a Go cross-package qualified reference (`pkga.FuncX`) by matching
- * the package alias against an in-module import, stripping the module prefix
- * to a project-relative directory, and locating the exported symbol in any
- * `.go` file under that directory. Returns `null` for stdlib / third-party
- * imports (no `go.mod`-relative match) so the rest of `resolveViaImport`
- * can still try the file-based path.
+ * the package alias against an in-project import, mapping the import to the
+ * package's project directory, and locating the exported symbol in a `.go`
+ * file directly in that directory. Returns `null` for stdlib / third-party
+ * imports (no project module declares them) so the rest of
+ * `resolveViaImport` can still try the file-based path.
  */
 function resolveGoCrossPackageReference(
   ref: UnresolvedRef,
   imports: ImportMapping[],
   context: ResolutionContext
 ): ResolvedRef | null {
-  const mod = context.getGoModule?.();
-  if (!mod) return null;
-
   // Qualified call: receiver before `.`, member after. A bare reference
-  // (no dot) is a same-file/in-package call — handled elsewhere.
+  // (no dot) is a same-package name — unless the source spells a package in
+  // front of it: `store.Manager` in a field or a signature, which the index
+  // keeps as `Manager` (#2322).
   const dotIdx = ref.referenceName.indexOf('.');
-  if (dotIdx <= 0) return null;
+  if (dotIdx <= 0) {
+    const imp = goRefQualifier(ref, context);
+    return imp ? findGoPackageMember(ref.referenceName, imp, ref, context) : null;
+  }
   const receiver = ref.referenceName.substring(0, dotIdx);
   const memberName = ref.referenceName.substring(dotIdx + 1);
   if (!memberName) return null;
+  // A parameter or local named like the import holds the call there:
+  // `store := newStore()`, then `store.Get(k)` is no call into package store.
+  if (!goRefQualifier(ref, context)) return null;
 
   for (const imp of imports) {
     if (imp.localName !== receiver) continue;
-    // Only in-module imports map to a known directory.
-    if (imp.source !== mod.modulePath && !imp.source.startsWith(mod.modulePath + '/')) {
-      continue;
-    }
-    const pkgDir = imp.source === mod.modulePath
-      ? ''
-      : imp.source.substring(mod.modulePath.length + 1);
+    const found = findGoPackageMember(memberName, imp, ref, context);
+    if (found) return found;
+  }
+  return null;
+}
 
-    // Look up the member by name and pick the candidate whose file lives
-    // directly in the package directory. Match the immediate parent dir
-    // exactly so a call to `pkga.FuncX` doesn't accidentally land on a
-    // `FuncX` declared in `pkga/subpkg/`.
-    const candidates = context.getNodesByName(memberName);
-    for (const node of candidates) {
-      if (node.language !== 'go') continue;
-      if (!node.isExported) continue;
-      const fp = node.filePath.replace(/\\/g, '/');
-      const lastSlash = fp.lastIndexOf('/');
-      const fileDir = lastSlash >= 0 ? fp.substring(0, lastSlash) : '';
-      if (fileDir === pkgDir) {
-        return {
-          original: ref,
-          targetNodeId: node.id,
-          confidence: 0.9,
-          resolvedBy: 'import',
-        };
-      }
+/**
+ * The exported `memberName` of the project package `imp` names, looked up in
+ * the package's directory: its module's directory followed by the rest of
+ * the import path (#2322). Matched on the immediate directory so `pkga.FuncX`
+ * never lands on a `FuncX` declared in `pkga/subpkg/`. Null when the import
+ * is no project package.
+ */
+function findGoPackageMember(
+  memberName: string,
+  imp: ImportMapping,
+  ref: UnresolvedRef,
+  context: ResolutionContext
+): ResolvedRef | null {
+  const pkgDir = context.getGoPackageDir?.(imp.source, ref.filePath);
+  if (pkgDir == null) return null;
+  for (const node of context.getNodesByName(memberName)) {
+    if (node.language !== 'go') continue;
+    if (!node.isExported) continue;
+    if (path.posix.dirname(node.filePath.replace(/\\/g, '/')) === pkgDir) {
+      return {
+        original: ref,
+        targetNodeId: node.id,
+        confidence: 0.9,
+        resolvedBy: 'import',
+      };
     }
   }
   return null;
@@ -2412,23 +2717,50 @@ function findExportedSymbolWalk(
     // resolves and the component shows a false 0 callers (#629).
     // A component file IS its default export; otherwise the statement that
     // names the binding beats the first-exported-function guess.
-    const direct =
-      exportIndex.defaultComponent ?? defaultExportBindingNode(filePath, exportIndex, context) ?? exportIndex.defaultFnClass;
+    const direct = esmDefaultExport(filePath, exportIndex, context);
     if (direct) return direct;
+    // CommonJS: `module.exports = createApplication`, or `= require('./lib/express')`.
+    const commonJs = commonJsDefaultExport(filePath, context);
+    if (commonJs?.source) {
+      const next = resolveImportPath(commonJs.source, filePath, language, context);
+      if (next) return findExportedSymbol(next, want, language, context, visited, depth + 1);
+    } else if (commonJs?.name) {
+      const bound = nodesInFileNamed(filePath, commonJs.name, context)
+        .filter((n) => DEFAULT_BINDING_KINDS.has(n.kind))
+        .sort((a, b) => a.startLine - b.startLine || a.startColumn - b.startColumn)[0];
+      if (bound) return bound;
+    }
   } else if (want.isNamespace && want.memberName) {
     const direct = exportedByName(filePath, exportIndex, want.memberName, context);
     if (direct) return direct;
   } else {
     const direct = exportedByName(filePath, exportIndex, want.exportedName, context);
     if (direct) return direct;
+    // `require('./x').default` and `const { default: X } = require('./x')` read
+    // the `default` property of module.exports. A CommonJS module sets it by
+    // name (`exports.default = fn`, the dual `module.exports.default = X`),
+    // found just above. A module written as an ES module sets it to its
+    // default export, `export default class Foo`, which is no named export —
+    // the answer when the module has no such property. Only in the module
+    // asked for: `export * from` never forwards a default.
+    if (
+      depth === 0 &&
+      want.exportedName === 'default' &&
+      ESM_IMPORT_LANGUAGES.has(language) &&
+      hasEsmDefaultExport(filePath, exportIndex, context)
+    ) {
+      const esmDefault = esmDefaultExport(filePath, exportIndex, context);
+      if (esmDefault) return esmDefault;
+    }
   }
 
   // 2. Re-export hit: the file forwards the symbol to another module.
   const reExports = context.getReExports?.(filePath, language) ?? [];
   if (reExports.length === 0) return undefined;
 
-  // Look for explicit `export { want } from './other'` (with optional rename).
-  const targetName = want.isDefault ? 'default' : want.exportedName;
+  // Look for explicit `export { want } from './other'` (with optional rename) — for
+  // `ns.member` through `import * as ns`, the member is the name wanted.
+  const targetName = want.isDefault ? 'default' : want.isNamespace && want.memberName ? want.memberName : want.exportedName;
   for (const rex of reExports) {
     if (rex.kind === 'named' && rex.exportedName === targetName) {
       const next = resolveImportPath(rex.source, filePath, language, context);
@@ -2452,6 +2784,20 @@ function findExportedSymbolWalk(
     }
   }
 
+  // `z.core.util.fn` through `export * as core from './core'`: the member continues in that module.
+  if (want.isNamespace && want.memberName) {
+    const dot = want.memberName.indexOf('.');
+    const head = dot < 0 ? want.memberName : want.memberName.slice(0, dot);
+    const rex = dot < 0 ? undefined : reExports.find((r) => r.kind === 'namespace' && r.exportedName === head);
+    if (rex) {
+      const next = resolveImportPath(rex.source, filePath, language, context);
+      const rest = want.memberName.slice(dot + 1);
+      return next
+        ? findExportedSymbol(next, { ...want, exportedName: rest.split('.')[0]!, memberName: rest }, language, context, visited, depth + 1)
+        : undefined;
+    }
+  }
+
   // 3. Wildcard re-export: `export * from './other'` — try every
   //    forwarding source. This is the barrel-of-barrels case.
   for (const rex of reExports) {
@@ -2670,3 +3016,39 @@ export function isBoundToOutOfRepoImport(
   }
   return false;
 }
+
+/**
+ * The tail a reference that failed to resolve is parked under when its name
+ * is an import binding the module it imports does not declare by that name:
+ * a default import (`import tagsController from './tag/tag.controller'`, a
+ * CommonJS `require`), a namespace import, or an aliased one (`import {
+ * Component as Wrapper }`, `{ default as X }`). Resolution reaches it through
+ * the module, so a sync's retry has to find it by the module: under the
+ * module's {@link moduleTail} ('module:tag'), the key a sync looks up for
+ * every file it adds or changes. Its own name, the default tail, is one the
+ * module never declares, so the file that appears or gains the export never
+ * found it. A sync still looks it up by that name as well: a binding its
+ * module never resolves is linked by the name alone.
+ *
+ * Only a whole-name reference to the binding — the import itself, a call,
+ * `new`, a JSX tag, a value — and only for a module of the project: a member
+ * read (`NS.member`) waits for the member's name, and a package's binding
+ * keeps its tail. Undefined for every other reference.
+ */
+export function importBindingTail(ref: UnresolvedRef, context: ResolutionContext): string | undefined {
+  if (!ESM_IMPORT_LANGUAGES.has(ref.language) || !IDENTIFIER.test(ref.referenceName)) return undefined;
+  const binding = context.getImportMappings(ref.filePath, ref.language).find((m) => m.localName === ref.referenceName);
+  if (!binding || (!binding.isDefault && !binding.isNamespace && binding.exportedName === binding.localName)) return undefined;
+  if (isExternalImport(binding.source, ref.language, context) &&
+      // A monorepo app's own tsconfig alias (`#/views/…`): isExternalImport reads the root's only.
+      !context.getNearestAliases?.(ref.filePath)?.patterns.some((p) => p.prefix !== '' && binding.source.startsWith(p.prefix))) {
+    return undefined;
+  }
+  // `..` names a folder through the importing file's own location.
+  const modulePath = binding.source.startsWith('.')
+    ? path.posix.join(path.posix.dirname(ref.filePath), binding.source)
+    : binding.source;
+  return moduleTail(modulePath) || undefined;
+}
+
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index bfc87eff3d..e04f9a274d 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -21,25 +21,38 @@ import {
   isImportableKind,
   CPP_DEFINE_SIGNATURE,
 } from './types';
-import { matchJsStoreBindingCall, isUnresolvedJsMemberCall, isVisibleAcrossFiles, matchReference, matchFunctionRef, matchDottedCallChain, matchScopedCallChain, matchMethodCall, sameLanguageFamily, crossesCodeBoundary, gateLanguageMatch, dumpNameMatcherProfile, clearNameMatcherMemos } from './name-matcher';
+import { isPythonSelfCall, matchJsStoreBindingCall, isUnresolvedJsMemberCall, matchObjectPathCall, thisScopeCaller, isVisibleAcrossFiles, matchReference, matchFunctionRef, matchDottedCallChain, matchScopedCallChain, matchMethodCall, sameLanguageFamily, crossesCodeBoundary, gateLanguageMatch, dumpNameMatcherProfile, clearNameMatcherMemos, isRustNameInScope, CASE_INSENSITIVE_LANGUAGES, isDartMemberRead, matchDartMemberRead, isDartChainLink, matchDartChainLink, isDartAnnotation, matchDartAnnotation, isStdMethodName, isGoUnknownQualified, isGoBareName, goTypePositionTarget, GO_TYPE_KINDS, matchGoAssertedCall } from './name-matcher';
 import { isVisibleCppMacro, clearCppMacroVisibility } from './cpp-macro-visibility';
 import { isCppConstructorRef, matchCppConstructor } from './cpp-constructor';
+import { isCppSupertypeRef, matchCppSupertype, clearCppSupertypeMemos } from './cpp-supertypes';
 import { gateSwiftTypeTarget, clearSwiftTypeVisibility, swiftExtendedConformances } from './swift-type-visibility';
-import { resolveViaImport, resolvePhpImportedStaticCall, resolveJvmImport, extractImportMappings, extractReExports, loadCppIncludeDirs, isPhpIncludePathRef, isCobolCopybookRef, isNixPathImportRef, isBoundToOutOfRepoImport, clearImportResolverMemos, resolveImportPath } from './import-resolver';
-import { ResolverPool, minRefsForPool } from './resolver-pool';
+import { clearDartLibraryMemos } from './dart-libraries';
+import { clearVbnetReceiverMemos, isVbMemberRead, isVbPathCall, matchVbMemberRead, matchVbPathCall } from './vbnet-receivers';
+import { gateTypeParameter, clearTypeParameterMemos } from './type-parameters';
+import { gateDartLocal, clearDartLocalScopeMemos } from './dart-local-scope';
+import { clearCppTypeAliasMemos } from './cpp-type-aliases';
+import { clearCppIncluderMemos } from './cpp-includers';
+import { matchShopifyThemeFile } from './shopify-themes';
+import { resolveViaImport, resolvePhpImportedStaticCall, resolvePhpQualifiedClassRef, resolveJvmImport, extractImportMappings, extractReExports, loadCppIncludeDirs, isPhpIncludePathRef, isCobolCopybookRef, isNixPathImportRef, isDartImportRef, isLuaRequireRef, isJsPathImportRef, isBoundToOutOfRepoImport, importBindingTail, clearImportResolverMemos, resolveImportPath, isExternalImport } from './import-resolver';
+import { ResolverPool, minRefsForPool, shouldEngageAdaptively } from './resolver-pool';
 import { resolveAliasBinding } from './alias-binding';
-import { detectFrameworks } from './frameworks';
+import { detectFrameworks, getResolvingFrameworks } from './frameworks';
 import { synthesizeCallbackEdges } from './callback-synthesizer';
 import { createYielder, type MaybeYield } from './cooperative-yield';
 import { MAX_SOURCE_FILE_SIZE_BYTES } from '../file-limits';
 import { loadProjectAliases, type AliasMap } from './path-aliases';
-import { loadGoModule, type GoModule } from './go-module';
+import { findGoModuleForImport, goModulePackageDir, loadGoModule, type GoModule } from './go-module';
 import { loadWorkspacePackages, type WorkspacePackages } from './workspace-packages';
 import { logDebug } from '../errors';
 import { lexicalPathWithinRoot } from '../utils';
-import type { ReExport } from './types';
+import type { CrossFileNodes, ReExport } from './types';
+import { resurrectRefFromDroppedEdge } from './resurrect-ref';
 import { LRUCache } from './lru-cache';
 import { JS_BUILT_INS } from './js-builtins';
+import { builtinModules } from 'module';
+import { parse as parseJsonc } from 'jsonc-parser';
+
+const NODE_BUILTINS = new Set(builtinModules);
 
 /** Node kinds that can declare supertypes (extends/implements). */
 const SUPERTYPE_BEARING_KINDS = new Set<Node['kind']>([
@@ -223,6 +236,8 @@ export class ReferenceResolver {
   private queries: QueryBuilder;
   private context: ResolutionContext;
   private frameworks: FrameworkResolver[] = [];
+  /** `frameworks` narrowed to those that resolve each reference language (see getResolvingFrameworks). */
+  private frameworksByLanguage = new Map<Language, FrameworkResolver[]>();
   // Chained static-factory/fluent call refs the first pass couldn't resolve,
   // collected in-memory and left pending in the DB until the post-pass
   // finishes, so a restart can recover the queue (#1577). Drained by
@@ -302,8 +317,19 @@ export class ReferenceResolver {
   // `null` = computed and absent. Treated as immutable for the
   // resolver's lifetime; callers re-create the resolver if config changes.
   private projectAliases: AliasMap | null | undefined = undefined;
-  // go.mod module path. Same lazy/immutable convention as projectAliases.
-  private goModule: GoModule | null | undefined = undefined;
+  // Per directory: the aliases of the nearest non-root tsconfig declaring `paths`.
+  private dirAliases = new Map<string, AliasMap | null>();
+  // Per project-relative directory ('' = the root): the module of the nearest
+  // go.mod at or above it, up to the project root. Same lazy/immutable
+  // convention as dirAliases.
+  private goModuleByDir = new Map<string, GoModule | null>();
+  // The project's Go modules: the root one plus every module that owns an
+  // indexed .go file. Depends on the file set, like knownFiles, so
+  // clearCaches drops it.
+  private goModules: GoModule[] | null = null;
+  // getGoPackageDir answers, keyed by import path and the importing file's
+  // module. Derived from goModules, so dropped with it.
+  private goPackageDirs = new Map<string, string | null>();
   // Monorepo workspace member packages. Same lazy/immutable convention.
   private workspacePackages: WorkspacePackages | null | undefined = undefined;
 
@@ -336,9 +362,20 @@ export class ReferenceResolver {
    */
   initialize(): void {
     this.frameworks = detectFrameworks(this.context);
+    this.frameworksByLanguage.clear();
     this.clearCaches();
   }
 
+  /** The detected frameworks whose `resolve()` reads a reference written in `language`. */
+  private frameworksFor(language: Language): FrameworkResolver[] {
+    let frameworks = this.frameworksByLanguage.get(language);
+    if (!frameworks) {
+      frameworks = getResolvingFrameworks(this.frameworks, language);
+      this.frameworksByLanguage.set(language, frameworks);
+    }
+    return frameworks;
+  }
+
   /**
    * Run each framework resolver's cross-file finalization pass and persist
    * the returned node updates. Idempotent — safe to call after every indexAll
@@ -364,10 +401,63 @@ export class ReferenceResolver {
         });
       }
     }
+    for (const fw of this.frameworks) {
+      if (!fw.crossFileNodes) continue;
+      try {
+        updated += this.reconcileCrossFileNodes(fw.crossFileNodes(this.context));
+      } catch (err) {
+        logDebug(`Framework '${fw.name}' crossFileNodes failed`, {
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
     if (updated > 0) this.clearCaches();
     return updated;
   }
 
+  /**
+   * Bring a framework's cross-file nodes in line with what it wants now:
+   * insert the new ones with their references (pending, for the resolution
+   * that follows), rename the ones whose name changed, and remove the ones it
+   * no longer wants. A removed node's incoming resolution edges go back to
+   * being the references that made them, exactly as when a file is deleted,
+   * so they rebind elsewhere or park as failed. Unchanged nodes are not
+   * touched, so their edges survive. Returns the number of nodes changed.
+   */
+  private reconcileCrossFileNodes(result: CrossFileNodes): number {
+    const wanted = new Map<string, Node>();
+    for (const node of result.nodes) if (result.owns(node)) wanted.set(node.id, node);
+    const existing = new Map<string, Node>();
+    for (const node of this.queries.getNodesByKind(result.kind)) if (result.owns(node)) existing.set(node.id, node);
+    let changed = 0;
+    for (const [id, old] of existing) {
+      if (wanted.has(id)) continue;
+      const refs = this.queries.getCrossFileIncomingEdgesWithTarget(old.filePath)
+        .filter((e) => e.target === id)
+        .map((e) => resurrectRefFromDroppedEdge(e))
+        .filter((r): r is UnresolvedReference => r !== null);
+      if (refs.length > 0) this.queries.insertUnresolvedRefsBatch(refs);
+      this.queries.deleteNode(id);
+      changed++;
+    }
+    const added: Node[] = [];
+    for (const [id, node] of wanted) {
+      const old = existing.get(id);
+      if (!old) added.push(node);
+      else if (old.name !== node.name || old.qualifiedName !== node.qualifiedName) {
+        this.queries.updateNode(node);
+        changed++;
+      }
+    }
+    if (added.length > 0) {
+      this.queries.insertNodes(added);
+      const ids = new Set(added.map((n) => n.id));
+      this.queries.insertUnresolvedRefsBatch(result.references.filter((r) => ids.has(r.fromNodeId)));
+      changed += added.length;
+    }
+    return changed;
+  }
+
   /**
    * Pre-build lightweight caches for resolution.
    * Node lookups are now handled by indexed SQLite queries instead of
@@ -438,8 +528,12 @@ export class ReferenceResolver {
     this.supertypeGen++;
     this.nodesByKindCache.clear();
     this.fileExistsMemo.clear();
+    this.manifestScopes.clear();
     this.knownNames = null;
+    this.knownLowerNames = null;
     this.knownFiles = null;
+    this.goModules = null;
+    this.goPackageDirs.clear();
     this.cachesWarmed = false;
     // The import-resolver's and name-matcher's per-context memos assume the
     // same stable window as the caches above — drop them together.
@@ -448,9 +542,59 @@ export class ReferenceResolver {
       clearNameMatcherMemos(this.context);
       clearCppMacroVisibility(this.context);
       clearSwiftTypeVisibility(this.context);
+      clearDartLibraryMemos(this.context);
+      clearVbnetReceiverMemos(this.context);
+      clearTypeParameterMemos(this.context);
+      clearDartLocalScopeMemos(this.context);
+      clearCppTypeAliasMemos(this.context);
+      clearCppSupertypeMemos(this.context);
+      clearCppIncluderMemos(this.context);
     }
   }
 
+  /**
+   * The module of the nearest `go.mod` at or above project-relative `dir`
+   * ('' = the root), never above the project root (#2322). Each directory
+   * is read at most once: every directory the walk passes is memoized.
+   */
+  private nearestGoModule(dir: string): GoModule | null {
+    const walked: string[] = [];
+    let found: GoModule | null | undefined;
+    for (;;) {
+      found = this.goModuleByDir.get(dir);
+      if (found !== undefined) break;
+      walked.push(dir);
+      found = loadGoModule(path.join(this.projectRoot, dir));
+      if (found || dir === '') break;
+      dir = goDirOf(dir);
+    }
+    for (const d of walked) this.goModuleByDir.set(d, found);
+    return found;
+  }
+
+  /**
+   * The project's Go modules: the root `go.mod`'s, and the nearest `go.mod`
+   * of every directory holding an indexed `.go` file — so an ignored or
+   * vendored tree, which holds no indexed file, adds none, and nothing walks
+   * the disk. The go tool ignores `testdata/` and `_`/`.`-prefixed
+   * directories, so a module there serves only its own files (#2322).
+   */
+  private getGoModules(): GoModule[] {
+    if (this.goModules) return this.goModules;
+    const dirs = new Set<string>(['']);
+    for (const file of this.knownFiles ?? this.queries.getAllFilePaths()) {
+      if (file.endsWith('.go')) dirs.add(goDirOf(file));
+    }
+    const modules = new Set<GoModule>();
+    for (const dir of dirs) {
+      const mod = this.nearestGoModule(dir);
+      const modDir = mod ? path.relative(this.projectRoot, mod.rootDir).split(path.sep).join('/') : '';
+      if (mod && !/(?:^|\/)(?:testdata|[_.][^/]*)(?:\/|$)/.test(modDir)) modules.add(mod);
+    }
+    this.goModules = [...modules];
+    return this.goModules;
+  }
+
   /** `readFile` through the LRU content cache (null = read failed, also cached). */
   private readFileCached(filePath: string): string | null {
     if (this.fileCache.has(filePath)) {
@@ -499,6 +643,19 @@ export class ReferenceResolver {
   private createContext(): ResolutionContext {
     return {
       resolveImport: (ref) => resolveViaImport(ref, this.context),
+      // A path alias makes an import the project's only when it maps the
+      // import to a file the index holds. Matching its prefix is not enough:
+      // cord-field's `"*": ["./typings/*"]` matches every package, and
+      // counting the match bound 169 imports of `@mui/material`'s Typography
+      // to its own. Nor is a path that exists on disk: home-assistant's
+      // `"lit/decorators": ["./node_modules/lit/decorators.js"]` lands in
+      // `node_modules`, topcoder's `config` package on its `config/` folder.
+      isOutOfRepoImport: (source, fromFile, language) => {
+        if (!isExternalImport(source, language, this.context, { aliasPrefixes: false })) return false;
+        const resolved = resolveImportPath(source, fromFile, language, this.context);
+        if (resolved !== null && this.isIndexedFile(resolved)) return false;
+        return this.isDeclaredOutsidePackage(source, fromFile);
+      },
       getNodesInFile: (filePath: string) => {
         if (!this.nodeCache.has(filePath)) {
           this.nodeCache.set(filePath, this.queries.getNodesByFile(filePath));
@@ -764,11 +921,40 @@ export class ReferenceResolver {
         return this.projectAliases;
       },
 
-      getGoModule: () => {
-        if (this.goModule === undefined) {
-          this.goModule = loadGoModule(this.projectRoot);
+      getNearestAliases: (fromFile: string) => {
+        let dir = path.posix.dirname(fromFile.replace(/\\/g, '/'));
+        const walked: string[] = [];
+        let found: AliasMap | null = null;
+        while (dir && dir !== '.' && dir !== '/') {
+          const hit = this.dirAliases.get(dir);
+          if (hit !== undefined) {
+            found = hit;
+            break;
+          }
+          walked.push(dir);
+          const abs = path.join(this.projectRoot, dir);
+          if (['tsconfig.json', 'jsconfig.json'].some((name) => fs.existsSync(path.join(abs, name)))) {
+            const aliases = loadProjectAliases(abs);
+            if (aliases) {
+              found = aliases;
+              break;
+            }
+          }
+          dir = path.posix.dirname(dir);
         }
-        return this.goModule;
+        for (const d of walked) this.dirAliases.set(d, found);
+        return found;
+      },
+
+      getGoPackageDir: (importPath: string, fromFile?: string) => {
+        const own = fromFile === undefined ? null : this.nearestGoModule(goDirOf(fromFile));
+        const key = `${importPath}\0${own?.rootDir ?? ''}`;
+        const hit = this.goPackageDirs.get(key);
+        if (hit !== undefined) return hit;
+        const mod = findGoModuleForImport(importPath, this.getGoModules(), own);
+        const dir = mod ? goModulePackageDir(importPath, mod, this.projectRoot) : null;
+        this.goPackageDirs.set(key, dir);
+        return dir;
       },
 
       getWorkspacePackages: () => {
@@ -802,6 +988,8 @@ export class ReferenceResolver {
       getCppIncludeDirs: () => {
         return loadCppIncludeDirs(this.projectRoot);
       },
+
+      getCppIncludeNodes: () => this.queries.getCppIncludeNodes(),
     };
   }
 
@@ -843,7 +1031,7 @@ export class ReferenceResolver {
         resolved.push(result);
         byMethod[result.resolvedBy] = (byMethod[result.resolvedBy] || 0) + 1;
       } else {
-        unresolved.push(ref);
+        unresolved.push(this.parkable(ref));
       }
 
       // Report progress every 1% to avoid too many updates
@@ -873,6 +1061,21 @@ export class ReferenceResolver {
     };
   }
 
+  /** Lowercased `knownNames`, built the first time a case-insensitive language asks. */
+  private knownLowerNames: Set<string> | null = null;
+
+  /** `hasAnyPossibleMatch` for a language whose names ignore case: the name, or any `.`/`::`/`->` part of it. */
+  private hasAnyPossibleMatchIgnoringCase(name: string): boolean {
+    if (!this.knownNames) return true;
+    if (!this.knownLowerNames || this.knownLowerNames.size === 0) {
+      this.knownLowerNames = new Set();
+      for (const known of this.knownNames) this.knownLowerNames.add(known.toLowerCase());
+    }
+    const lower = name.toLowerCase();
+    if (this.knownLowerNames.has(lower)) return true;
+    return lower.split(/::|->|\./).some((part) => part.length > 0 && this.knownLowerNames!.has(part));
+  }
+
   /**
    * Check if a reference name has any possible match in the codebase.
    * Uses the pre-built knownNames set to skip expensive resolution
@@ -981,10 +1184,27 @@ export class ReferenceResolver {
     if (isVisibleCppMacro(ref, this.context)) return null;
     // A Swift type reference never lands on an `extension X {}` node, nor on a
     // nested type it cannot name bare (see ./swift-type-visibility).
-    const candidate = gateSwiftTypeTarget(this.gateTargetKind(this.resolveOneInner(ref), ref), ref, this.context);
-    const resolved = candidate?.resolvedBy === 'framework'
-      ? this.gateFrameworkLanguage(candidate, ref)
-      : this.gateLanguage(candidate, ref);
+    // A name a declaration around the reference declares as a type parameter
+    // (`def f[A]`, `class Foo<T>`) is that parameter (see ./type-parameters),
+    // and a Dart call to a parameter or local calls that (./dart-local-scope).
+    const candidate = gateDartLocal(
+      gateTypeParameter(
+        gateSwiftTypeTarget(this.gateTargetKind(this.resolveOneInner(ref), ref), ref, this.context),
+        ref,
+        this.context,
+      ),
+      ref,
+      this.context,
+    );
+    const scoped = this.gateRustScope(candidate, ref);
+    const resolved = this.gateSuperSelfCall(
+      scoped?.resolvedBy === 'framework' ? this.gateFrameworkLanguage(scoped, ref) : this.gateLanguage(scoped, ref),
+      ref,
+    );
+    // A Dart class whose field holds its own type (`class Node { Node? next; }`)
+    // names itself: a self-edge that says nothing (#2327).
+    if (resolved && ref.language === 'dart' && ref.referenceKind === 'references' &&
+        resolved.targetNodeId === ref.fromNodeId) return null;
     if (!resolved || ref.referenceKind !== 'calls') return resolved;
 
     const target = this.nodeById(resolved.targetNodeId);
@@ -1006,6 +1226,32 @@ export class ReferenceResolver {
     // A local C++ object construction (`T obj(args)`, ref `ns::T::T/1`)
     // resolves ONLY to a constructor of the lexically nearest `T` (#1839).
     if (isCppConstructorRef(ref)) return matchCppConstructor(ref, this.context);
+    // A C or C++ base class is the one C++ name lookup finds from where the
+    // class is declared — never a namesake of another namespace or language,
+    // which a framework's heuristics or name matching would take (see
+    // ./cpp-supertypes).
+    if (isCppSupertypeRef(ref)) return matchCppSupertype(ref, this.context);
+
+    // A Dart member read (`x.area`) links the getter the receiver's type
+    // reaches, as a call, or nothing — never a guess by name (#2338).
+    if (isDartMemberRead(ref)) return matchDartMemberRead(ref, this.context);
+    // So does a later link of a Dart call chain (`X.autoDispose.family(…)`,
+    // `events.map(f).transform(…)`), which arrives by its bare name: a member
+    // of what the chain's head and links are declared to be, or nothing (#750).
+    if (isDartChainLink(ref, this.context)) return matchDartChainLink(ref, this.context);
+    // A Dart annotation (`@riverpod`, `@Riverpod(…)`) is a constant or a
+    // constructor call, as written — never a method or function by its name.
+    if (isDartAnnotation(ref)) return matchDartAnnotation(ref, this.context);
+    // A Go call through a type assertion (`srv.(KVServer).Range(ctx, in)`),
+    // which arrives by its bare name, is to a method of the asserted type, or
+    // to nothing the project declares.
+    const asserted = matchGoAssertedCall(ref, this.context);
+    if (asserted !== undefined) return asserted;
+
+    // A section or snippet a Shopify theme's file names is that theme's own,
+    // or nothing: Shopify never looks in another theme (see ./shopify-themes).
+    const themeFile = matchShopifyThemeFile(ref, this.context);
+    if (themeFile !== undefined) return themeFile;
 
     // Skip built-in/external references
     if (this.isBuiltInOrExternal(ref)) {
@@ -1029,6 +1275,13 @@ export class ReferenceResolver {
       return this.resolveCfmlComponentPath(ref);
     }
 
+    // A PHP class written with a namespace in it — `new Alias\X()` through a
+    // `use Ns as Alias;` namespace alias, `extends Sub\Base`, `\Ns\X::make()`
+    // (#2256). The pre-filter below would drop most of these before any import
+    // strategy ran, and PHP gives each one exactly one meaning; resolve it first.
+    const phpQualified = resolvePhpQualifiedClassRef(ref, this.context);
+    if (phpQualified !== undefined) return this.gateLanguage(phpQualified, ref);
+
     // Fast pre-filter: skip if no symbol with this name exists anywhere
     // AND the name doesn't match a local import. The import escape is
     // necessary because re-export rename chains (`import { login }
@@ -1038,8 +1291,9 @@ export class ReferenceResolver {
     // ArkTS chained-attribute refs carry a leading dot (`.titleStyle`) that
     // routes them to the decorator-gated matcher; the symbol itself is
     // indexed under the bare name, so the existence check strips the dot.
-    // Nix static path imports (`import ./x.nix`) name a FILE, not a symbol —
-    // they bypass the symbol-existence check and resolve via resolveViaImport.
+    // Nix static path imports (`import ./x.nix`) and JS/TS module paths
+    // (`require('./x')`) name a FILE, not a symbol — they bypass the
+    // symbol-existence check and resolve via resolveViaImport.
     let existenceName =
       ref.language === 'arkts' && ref.referenceName.startsWith('.')
         ? ref.referenceName.slice(1)
@@ -1047,17 +1301,37 @@ export class ReferenceResolver {
     // Erlang refs carry the call-site arity (`f/1`, `mod::f/2` — #1610); the
     // name index stores bare names, so existence is checked arity-less.
     if (ref.language === 'erlang') existenceName = existenceName.replace(/\/\d{1,3}$/, '');
+    // A C or C++ name written from the global scope (`::_pbi::PrivateAccess::
+    // GenerateParseTable`, `::memset`) exists when the name under the `::` does.
+    if ((ref.language === 'cpp' || ref.language === 'c') && existenceName.startsWith('::')) {
+      existenceName = existenceName.slice(2);
+    }
     const tPre = this.profileStages ? process.hrtime.bigint() : 0n;
     const preFilterPass =
       isNixPathImportRef(ref) ||
+      isJsPathImportRef(ref) ||
       this.hasAnyPossibleMatch(existenceName) ||
+      // PHP, Pascal, CFML, COBOL and VB.NET names ignore case: `formatprice()`
+      // calls `FormatPrice`, which the exact-name set never lists.
+      (CASE_INSENSITIVE_LANGUAGES.has(ref.language) && this.hasAnyPossibleMatchIgnoringCase(existenceName)) ||
       this.matchesAnyImport(ref) ||
-      this.frameworks.some((f) => f.claimsReference?.(ref.referenceName));
+      this.frameworksFor(ref.language).some((f) => f.claimsReference?.(ref.referenceName));
     if (this.profileStages) this.stageAdd('preFilter', ref, preFilterPass, tPre);
     if (!preFilterPass) {
       return this.gateLanguage(matchJsStoreBindingCall(ref, this.context), ref);
     }
 
+    // A VB.NET member read (`AppSession.SessionId`, #2305; `x.Normal`,
+    // `Me._h.Title`) means what VB.NET's scoping says its receiver is — a
+    // project type, whose member and the type itself it links, or a value,
+    // whose declared type's member it links — and no framework, import or
+    // name strategy guesses past that. Nor past a `With` block's call through
+    // a receiver path (`.Run()` in `With Me._h`).
+    if (isVbMemberRead(ref)) return this.gateLanguage(matchVbMemberRead(ref, this.context), ref);
+    if (isVbPathCall(ref)) {
+      return this.gateLanguage(matchVbPathCall(ref, this.context, (name) => isStdMethodName('vbnet', name)), ref);
+    }
+
     // Function-as-value refs (#756) get a dedicated, strictly-gated path:
     // import-based resolution first (an imported callback resolves through its
     // import, the most precise cross-file signal), then matchFunctionRef
@@ -1116,13 +1390,21 @@ export class ReferenceResolver {
 
     const candidates: ResolvedRef[] = [];
 
-    // Strategy 1: Try framework-specific resolution. Cross-language bridges
-    // are deliberately preserved (Drupal `routing.yml` → PHP controller, RN
-    // JS → native `calls`); other code references obey the shared family gate.
+    // Strategy 1: Try framework-specific resolution, by the frameworks that
+    // read this reference's language: Express's `logger` middleware rule took
+    // a Go method's `*zap.Logger` result for the method itself (etcd).
+    // Cross-language bridges are deliberately preserved (Drupal `routing.yml`
+    // → PHP controller, RN JS → native `calls`); each lists the language its
+    // references are written in. Other code references obey the shared
+    // family gate.
     const tFw = this.profileStages ? process.hrtime.bigint() : 0n;
     let fwEarly: ResolvedRef | null = null;
-    for (const framework of this.frameworks) {
-      const result = this.gateFrameworkLanguage(framework.resolve(ref, this.context), ref);
+    for (const framework of this.frameworksFor(ref.language)) {
+      const resolved = this.gateFrameworkLanguage(framework.resolve(ref, this.context), ref);
+      // Name the resolver on the edge (`metadata.framework`): a Swift→ObjC or
+      // React Native bridge hop says how it got into the graph, as a
+      // synthesized edge's `synthesizedBy` does.
+      const result = resolved ? { ...resolved, metadata: { ...resolved.metadata, framework: framework.name } } : null;
       if (result) {
         if (result.confidence >= 0.9) {
           fwEarly = result; // High confidence, return immediately (below)
@@ -1135,7 +1417,18 @@ export class ReferenceResolver {
     if (fwEarly) return fwEarly;
     // A retained untyped chain supplies effect/call-site evidence only. In
     // particular, importing its root does not make the root its call target.
-    if (isUnresolvedJsMemberCall(ref)) return null;
+    // A path through module namespaces is not untyped: `z.coerce.number()`
+    // after `import * as z`, where the barrel has `export * as coerce`.
+    if (isUnresolvedJsMemberCall(ref)) {
+      const root = ref.referenceName.slice(0, ref.referenceName.indexOf('.'));
+      const namespace = this.context.getImportMappings(ref.filePath, ref.language).some((m) => m.isNamespace && m.localName === root);
+      // `App.utils.fmt()` through a path an object literal was hung on (#2300).
+      if (!namespace) return this.gateLanguage(matchObjectPathCall(ref, this.context), ref);
+      const viaNamespace = this.gateLanguage(resolveViaImport(ref, this.context), ref);
+      const target = viaNamespace ? this.nodeById(viaNamespace.targetNodeId) : null;
+      return target && (target.kind === 'function' || target.kind === 'method' || target.kind === 'class' || target.kind === 'constant' || target.kind === 'variable')
+        ? viaNamespace : null;
+    }
 
     // Strategy 2: Try import-based resolution
     // A TS/JS/Python call-receiver chain (`useStore.getState().reset`, #1683)
@@ -1152,7 +1445,12 @@ export class ReferenceResolver {
     }
 
     const tImp = this.profileStages ? process.hrtime.bigint() : 0n;
-    const importResult = this.gateLanguage(resolveViaImport(ref, this.context), ref);
+    // `self.get_ip()` is a method call on the instance even when the file
+    // also imports a function named `get_ip`: the import never names it.
+    const selfCall = ref.language === 'python' && ref.referenceKind === 'calls' &&
+      this.context.getImportMappings(ref.filePath, ref.language).some((m) => m.localName === ref.referenceName) &&
+      isPythonSelfCall(ref, this.context);
+    const importResult = selfCall ? null : this.gateLanguage(resolveViaImport(ref, this.context), ref);
     if (this.profileStages) this.stageAdd('viaImport', ref, !!importResult, tImp);
     if (importResult) {
       if (importResult.confidence >= 0.9) return importResult;
@@ -1168,8 +1466,11 @@ export class ReferenceResolver {
     // bind outside its module directory), so the name-matcher's
     // qualified-name fallback would only ever add wrong cross-module edges.
     // Nix static path imports are file references for the same reason —
-    // falling through would let "./x.nix" name-match an unrelated node.
-    if (isPhpIncludePathRef(ref) || isCobolCopybookRef(ref) || isNixPathImportRef(ref) || ref.language === 'terraform') {
+    // falling through would let "./x.nix" name-match an unrelated node. So
+    // is a Dart import's URI: `package:flutter/foundation.dart` matched by
+    // its last segment went to riverpod's own foundation.dart. And a Lua
+    // `require`, whose leaf matched the local it is assigned to.
+    if (isPhpIncludePathRef(ref) || isCobolCopybookRef(ref) || isNixPathImportRef(ref) || isDartImportRef(ref) || isLuaRequireRef(ref) || ref.language === 'terraform') {
       return candidates.length > 0
         ? candidates.reduce((best, curr) =>
             curr.confidence > best.confidence ? curr : best
@@ -1353,22 +1654,36 @@ export class ReferenceResolver {
    * ref's line), so a sibling must not inherit this row's failure (#1269).
    */
   private static partitionFailedCleanup(unresolved: UnresolvedRef[]): {
-    byRowId: Array<{ rowId: number; referenceName: string }>;
-    legacyKeys: Array<{ fromNodeId: string; referenceName: string; referenceKind: string }>;
+    byRowId: Array<{ rowId: number; referenceName: string; referenceKind: string; nameTail?: string }>;
+    legacyKeys: Array<{ fromNodeId: string; referenceName: string; referenceKind: string; nameTail?: string }>;
   } {
-    const byRowId: Array<{ rowId: number; referenceName: string }> = [];
-    const legacyKeys: Array<{ fromNodeId: string; referenceName: string; referenceKind: string }> = [];
+    const byRowId: Array<{ rowId: number; referenceName: string; referenceKind: string; nameTail?: string }> = [];
+    const legacyKeys: Array<{ fromNodeId: string; referenceName: string; referenceKind: string; nameTail?: string }> = [];
     for (const r of unresolved) {
-      if (r.rowId != null) byRowId.push({ rowId: r.rowId, referenceName: r.referenceName });
+      if (r.rowId != null) byRowId.push({ rowId: r.rowId, referenceName: r.referenceName, referenceKind: r.referenceKind, nameTail: r.nameTail });
       else legacyKeys.push({
         fromNodeId: r.fromNodeId,
         referenceName: r.referenceName,
         referenceKind: r.referenceKind,
+        nameTail: r.nameTail,
       });
     }
     return { byRowId, legacyKeys };
   }
 
+  /**
+   * `ref`, which no strategy resolved, with the tail it is parked under when
+   * that is not the one its name gives: a reference through an import
+   * binding the module doesn't declare by that name waits for the module
+   * (see importBindingTail). Decided here, where the file's import mappings
+   * are still cached from the attempt — in a resolver-pool worker too.
+   */
+  private parkable(ref: UnresolvedRef): UnresolvedRef {
+    const tail = importBindingTail(ref, this.context);
+    if (tail) ref.nameTail = tail;
+    return ref;
+  }
+
   /** A deferred attempt is unfinished work, not a final failure (#1577). */
   private nonDeferredFailures(unresolved: UnresolvedRef[]): UnresolvedRef[] {
     return unresolved.filter((ref) => ref.rowId == null || !this.deferredRowIds.has(ref.rowId));
@@ -1603,7 +1918,7 @@ export class ReferenceResolver {
         resolved.push(result);
         byMethod[result.resolvedBy] = (byMethod[result.resolvedBy] || 0) + 1;
       } else {
-        unresolved.push(ref);
+        unresolved.push(this.parkable(ref));
       }
       // Fast-path the per-ref yield check: awaiting the async no-op costs a
       // microtask hop per ref, which dominates at ~10⁵ refs (see MaybeYield).
@@ -1723,7 +2038,7 @@ export class ReferenceResolver {
         resolved.push(result);
         byMethod[result.resolvedBy] = (byMethod[result.resolvedBy] || 0) + 1;
       } else {
-        unresolved.push(ref);
+        unresolved.push(this.parkable(ref));
       }
     }
     this.deferredRowIds.clear(); // the admission side now owns both queues
@@ -2016,7 +2331,7 @@ export class ReferenceResolver {
         adaptiveSeqRefs += batch.length;
         const remaining = total - processed - batch.length;
         const projectedMs = (adaptiveSeqMs / Math.max(1, adaptiveSeqRefs)) * Math.max(0, remaining);
-        if (projectedMs >= ADAPTIVE_ENGAGE_SETTLE_MS) {
+        if (shouldEngageAdaptively(projectedMs, remaining, ADAPTIVE_ENGAGE_SETTLE_MS)) {
           if (process.env.CODEGRAPH_SYNTH_TIMINGS) {
             console.error(`[pool-timing] adaptive engage: projected ${Math.round(projectedMs)}ms sequential settle over ${remaining} remaining refs`);
           }
@@ -2288,6 +2603,91 @@ export class ReferenceResolver {
     return this.frameworks.map((f) => f.name);
   }
 
+  /** True when a detected router binds navigation calls to its routes (see {@link reopenNavigationsFor}). */
+  hasNavigationRouters(): boolean {
+    return this.frameworks.some((f) => f.navigation !== undefined);
+  }
+
+  /**
+   * Put back in the pending set the navigation calls `routes` — route nodes a
+   * sync added, removed or renamed ({@link changedRoutes}) — may now resolve
+   * differently, for the sync's resolution sweep: the calls parked as failed,
+   * and the calls whose `navigates` edges a router's resolver made. Calls in
+   * `changedFilePaths` are left alone; the sync resolved them against the new
+   * routes already. Returns the number of references put back.
+   *
+   * A navigation call names its route by path (`navigate('/login')`) and its
+   * reference by the router's method (`navigate`, `history.push`), so a route
+   * table that changed in another file is invisible to the rest of sync. A
+   * call parked as failed while its route was missing is keyed on `push`,
+   * which no synced file defines, and a resolved call keeps the route it bound
+   * to while a better one was missing (a catch-all, a parameter route, one arm
+   * of a conditional) or a route renamed under it. A full index resolves every
+   * call against the final table. Each router says which calls a route of its
+   * own can answer (`FrameworkResolver.navigation`): the method tails, and the
+   * apps whose files match against that route's table. A name more of those
+   * calls share than `perNameCeiling` is skipped, as the symbol retry skips a
+   * common tail.
+   */
+  reopenNavigationsFor(routes: readonly Node[], changedFilePaths: readonly string[] = [], perNameCeiling: number = 500): number {
+    if (routes.length === 0) return 0;
+    const plans: Array<{ router: FrameworkResolver; scopes: string[] }> = [];
+    const tails = new Set<string>();
+    for (const router of this.frameworks) {
+      if (!router.navigation) continue;
+      const scopes = new Set<string>();
+      for (const route of routes) {
+        for (const scope of router.navigation.scope(route, this.context) ?? []) scopes.add(scope);
+      }
+      if (scopes.size === 0) continue;
+      plans.push({ router, scopes: [...scopes] });
+      for (const tail of router.navigation.tails) tails.add(tail);
+    }
+    if (plans.length === 0) return 0;
+    const claimed = (name: string, filePath: string): boolean =>
+      plans.some(({ router, scopes }) => scopes.some((scope) => filePath.startsWith(scope)) && router.claimsReference?.(name) === true);
+
+    const fresh = new Set(changedFilePaths);
+    const failed = new Map<string, number[]>();
+    for (const ref of this.queries.getFailedCallsByTail([...tails])) {
+      if (fresh.has(ref.filePath) || !claimed(ref.referenceName, ref.filePath)) continue;
+      const rowIds = failed.get(ref.referenceName);
+      if (rowIds) rowIds.push(ref.rowId);
+      else failed.set(ref.referenceName, [ref.rowId]);
+    }
+    const resolved = new Map<string, Array<Edge & { edgeId: number; sourceFilePath: string; sourceLanguage: Language }>>();
+    for (const edge of this.queries.getResolvedNavigations()) {
+      const name = edge.metadata?.refName;
+      if (typeof name !== 'string' || fresh.has(edge.sourceFilePath) || !claimed(name, edge.sourceFilePath)) continue;
+      const edges = resolved.get(name);
+      if (edges) edges.push(edge);
+      else resolved.set(name, [edge]);
+    }
+
+    const rowIds: number[] = [];
+    const edgeIds: number[] = [];
+    const refs: UnresolvedReference[] = [];
+    // A conditional's arms are edges of one call: it goes back as one reference.
+    const sites = new Set<string>();
+    for (const name of new Set([...failed.keys(), ...resolved.keys()])) {
+      const rows = failed.get(name) ?? [];
+      const edges = resolved.get(name) ?? [];
+      if (rows.length + edges.length > perNameCeiling) continue;
+      for (const rowId of rows) rowIds.push(rowId);
+      for (const edge of edges) {
+        const ref = resurrectRefFromDroppedEdge(edge);
+        if (!ref) continue;
+        edgeIds.push(edge.edgeId);
+        const site = `${ref.fromNodeId}\0${ref.referenceName}\0${ref.line}\0${ref.column}`;
+        if (sites.has(site)) continue;
+        sites.add(site);
+        refs.push(ref);
+      }
+    }
+    if (edgeIds.length > 0) this.queries.replaceResolutionEdgesWithUnresolvedRefs(edgeIds, refs);
+    return this.queries.reopenFailedReferences(rowIds) + refs.length;
+  }
+
   /**
    * True when `receiver` is a local name bound by an import that resolves to a
    * file IN THIS PROJECT — the only case where letting a python
@@ -2330,10 +2730,13 @@ export class ReferenceResolver {
   private isBuiltInOrExternal(ref: UnresolvedRef): boolean {
     const name = ref.referenceName;
     const isJsTs = ref.language === 'typescript' || ref.language === 'javascript'
-      || ref.language === 'tsx' || ref.language === 'jsx' || ref.language === 'arkts';
+      || ref.language === 'tsx' || ref.language === 'jsx' || ref.language === 'arkts'
+      || ref.language === 'vue' || ref.language === 'svelte' || ref.language === 'astro';
 
-    // JavaScript/TypeScript built-ins
-    if (isJsTs && JS_BUILT_INS.has(name)) {
+    // JavaScript/TypeScript built-ins — unless the file imports its own
+    // binding of that name (`import Map from './Map.svelte'`).
+    if (isJsTs && JS_BUILT_INS.has(name) &&
+        !this.context.getImportMappings(ref.filePath, ref.language).some((m) => m.localName === name)) {
       return true;
     }
 
@@ -2445,12 +2848,15 @@ export class ReferenceResolver {
     // when there's no user node with this name — then name-matching would
     // produce zero edges anyway and the filter just short-circuits work.
     if (ref.language === 'c' || ref.language === 'cpp') {
+      // A leading `::` names the global scope: `::std::move` is `std::move`,
+      // `::memset` is `memset`.
+      const scoped = name.startsWith('::') ? name.slice(2) : name;
       // C++ std:: namespace prefix — safe to filter unconditionally,
       // since `std::foo` is never a user-defined qualified name in
       // tree-sitter output.
-      if (name.startsWith('std::')) return true;
-      if (C_BUILT_INS.has(name) || CPP_BUILT_INS.has(name)) {
-        return !this.hasAnyPossibleMatch(name);
+      if (scoped.startsWith('std::')) return true;
+      if (C_BUILT_INS.has(scoped) || CPP_BUILT_INS.has(scoped)) {
+        return !this.hasAnyPossibleMatch(scoped);
       }
     }
 
@@ -2627,8 +3033,11 @@ export class ReferenceResolver {
   private resolveThisMemberFnRef(ref: UnresolvedRef): ResolvedRef | null {
     const member = ref.referenceName.slice('this.'.length);
     if (!member) return null;
-    const fromNode = this.nodeById(ref.fromNodeId);
-    if (!fromNode) return null;
+    const written = this.nodeById(ref.fromNodeId);
+    if (!written) return null;
+    // Inside an object literal: its own method's `this` is the object, an
+    // arrow member's is the method around the literal (#2300).
+    const fromNode = thisScopeCaller(written, this.context);
     // A hook declared at class-body level (Ruby `before_action :authenticate`)
     // attributes to the CLASS node itself — its qualified name IS the scope.
     // For members, strip the member segment.
@@ -2715,8 +3124,9 @@ export class ReferenceResolver {
     for (const ref of deferred) {
       await maybeYield();
       const member = ref.referenceName.slice('this.'.length);
-      const fromNode = this.nodeById(ref.fromNodeId);
-      if (!fromNode || !member) continue;
+      const written = this.nodeById(ref.fromNodeId);
+      if (!written || !member) continue;
+      const fromNode = thisScopeCaller(written, this.context);
       // Class-body-level hooks (Ruby) attribute to the CLASS node itself.
       let className: string;
       if (SUPERTYPE_BEARING_KINDS.has(fromNode.kind) || fromNode.kind === 'module') {
@@ -2795,7 +3205,12 @@ export class ReferenceResolver {
    * framework, import, name-match, chain, CFML component path.
    *
    * For `imports`: the target must be importable. A member that only exists
-   * inside a type never is.
+   * inside a type never is, and neither is the import statement the reference
+   * was written in.
+   *
+   * For a Go type position: the target is a type of the package Go reads the
+   * name from, moved there when a strategy found a method, a function or
+   * another package's type (see goTypePositionTarget).
    *
    * For `extends`/`implements`, it cannot be describing a real supertype when:
    *
@@ -2828,15 +3243,40 @@ export class ReferenceResolver {
     if (ref.referenceKind === 'calls') {
       const target = this.nodeById(result.targetNodeId);
       if (target?.kind === 'constant' && CPP_DEFINE_SIGNATURE.test(target.signature ?? '')) return null;
+      // A Go call made through an expression — `h.Validate().Error()`, a
+      // `.Metrics()` chained onto the line above — calls a method of whatever
+      // the expression is. A type is called only bare (`T(x)`, `(*T)(x)`) or
+      // through its package; as a struct here it read as an instantiation.
+      if (target && ref.language === 'go' && GO_TYPE_KINDS.has(target.kind) &&
+          !ref.referenceName.includes('.') && !isGoBareName(ref, this.context)) return null;
     }
 
     // An `imports` reference names something importable — never a member that
-    // only exists inside a type.
+    // only exists inside a type, nor its own import statement. A module path
+    // that names no file (`./missing`, `stdio.h`, `pkg.mod`, a C# `using` of
+    // an outside namespace) reaches the statement by its qualified name; as an
+    // edge to itself it is never retried, while a failed ref is retried by the
+    // sync that adds the file it names.
     if (ref.referenceKind === 'imports') {
       const target = this.nodeById(result.targetNodeId);
+      if (target?.kind === 'import' && target.filePath === ref.filePath) return null;
       return target && !isImportableKind(target.kind) ? null : result;
     }
 
+    // A Go alias names its type as an embedding does (below): written through
+    // a package that is none of the file's imports as indexed, the type found
+    // by its bare name is another package's namesake, or the alias itself.
+    if (ref.language === 'go' && ref.referenceKind === 'references' &&
+        this.nodeById(ref.fromNodeId)?.kind === 'type_alias' && isGoUnknownQualified(ref, this.context)) return null;
+
+    // A Go type position — a parameter or result type, a composite literal's
+    // type — names a type of the package Go reads it from (route handlers are
+    // `references` too, but values).
+    if (ref.language === 'go' && (ref.referenceKind === 'instantiates' ||
+        (ref.referenceKind === 'references' && this.nodeById(ref.fromNodeId)?.kind !== 'route'))) {
+      return goTypePositionTarget(result, ref, this.context);
+    }
+
     if (!isInheritanceRef(ref)) return result;
     const target = this.nodeById(result.targetNodeId);
     if (target && !isSupertypeTarget(target)) {
@@ -2845,9 +3285,119 @@ export class ReferenceResolver {
       result = { ...result, targetNodeId: type.id };
     }
     if (isBoundToOutOfRepoImport(ref, this.context)) return null;
+    // A Go type embedded through a package (`clientv3.KV`) is that package's.
+    // When the package is none of the file's imports as indexed (clientv3
+    // imported unaliased as `go.etcd.io/etcd/client/v3`), a type found by its
+    // bare name is some other package's namesake.
+    if (ref.language === 'go' && isGoUnknownQualified(ref, this.context)) return null;
     return result;
   }
 
+  /**
+   * `super.didMoveToWindow()` inside an override of `didMoveToWindow` calls
+   * the PARENT's implementation, never the method making the call. Extraction
+   * keeps a `super` call under the bare method name, so every strategy found
+   * the enclosing method itself: one expo-camera view had eleven of its
+   * overrides "calling" themselves. The parent's method is usually a
+   * framework's (UIKit, Android, React); a self-edge is never it. Real
+   * recursion keeps its edge — only a call written through `super` / `base`
+   * (C#) / `[super …]` (Objective-C) / `parent::` (PHP) / `super().` (Python)
+   * is declined.
+   */
+  private gateSuperSelfCall(result: ResolvedRef | null, ref: UnresolvedRef): ResolvedRef | null {
+    if (!result || ref.referenceKind !== 'calls' || result.targetNodeId !== ref.fromNodeId) return result;
+    const name = ref.referenceName.slice(Math.max(ref.referenceName.lastIndexOf('.'), ref.referenceName.lastIndexOf(':')) + 1);
+    if (!/^[A-Za-z_$][\w$]*$/.test(name)) return result;
+    const line = (this.context.getFileLines?.(ref.filePath) ?? this.context.readFile(ref.filePath)?.split(/\r?\n/))?.[ref.line - 1];
+    if (!line) return result;
+    const escaped = name.replace(/\$/g, '\\$');
+    const viaSuper = new RegExp(
+      String.raw`(?:\b(?:super|base)\s*(?:\(\s*(?:[\w.]+\s*,\s*\w+)?\s*\))?\s*\??\.\s*|\[\s*super\s+|\bparent\s*::\s*)` + escaped + String.raw`\b`,
+    );
+    return viaSuper.test(line) ? null : result;
+  }
+
+  /**
+   * A bare Rust name reaches only what is in scope — every strategy's result,
+   * a framework resolver's `Ok(x)` → `struct Ok` construction included (see
+   * isRustNameInScope).
+   */
+  private gateRustScope(result: ResolvedRef | null, ref: UnresolvedRef): ResolvedRef | null {
+    if (!result || ref.language !== 'rust' || !/^[A-Za-z_]\w*$/.test(ref.referenceName)) return result;
+    const target = this.nodeById(result.targetNodeId);
+    return target && !isRustNameInScope(target, ref, this.context) ? null : result;
+  }
+
+  /** Is `filePath` (project-relative) one of the files the index holds? */
+  private isIndexedFile(filePath: string): boolean {
+    const normalized = filePath.replace(/\\/g, '/');
+    return this.knownFiles ? this.knownFiles.has(normalized) : this.queries.getFileByPath(normalized) !== null;
+  }
+
+  /** The repository's own package name, from its root package.json; null without one. */
+  /** Per directory: the package names its package.json and every enclosing one own and depend on. */
+  private manifestScopes = new Map<string, { own: Set<string>; deps: Set<string> }>();
+
+  /**
+   * Is `source` a package from outside the repository? Only when the importing
+   * file's package.json (or an enclosing one) declares it, or it is a Node
+   * built-in or a runtime's virtual module. A specifier nothing declares is
+   * an alias this resolver does not know — SvelteKit's `$lib/…`, Nuxt's
+   * `~/…`, a nested app's own `@/…` — and stays the project's.
+   */
+  private isDeclaredOutsidePackage(source: string, fromFile: string): boolean {
+    // Deno's standard library is `@std/…` from JSR.
+    if (/^(?:node|bun|jsr|npm|https?):/.test(source) || source.startsWith('@std/') || NODE_BUILTINS.has(source)) return true;
+    const name = source.startsWith('@') ? source.split('/').slice(0, 2).join('/') : source.split('/')[0]!;
+    const normalized = fromFile.replace(/\\/g, '/');
+    const scope = this.manifestScope(normalized.includes('/') ? normalized.slice(0, normalized.lastIndexOf('/')) : '');
+    if (scope.own.has(name)) return false;
+    if (scope.deps.has(name)) return true;
+    // SvelteKit's `$app/…` and Astro's `astro:…` belong to the framework —
+    // unless this repository is that framework.
+    const provider = source.startsWith('astro:') ? 'astro' : /^\$(?:app|env|service-worker)(?:\/|$)/.test(source) ? '@sveltejs/kit' : null;
+    return provider !== null && !scope.own.has(provider) && !this.context.getWorkspacePackages?.()?.byName.has(provider);
+  }
+
+  private manifestScope(dir: string): { own: Set<string>; deps: Set<string> } {
+    const memo = this.manifestScopes.get(dir);
+    if (memo) return memo;
+    const parent = dir === '' ? null : this.manifestScope(dir.includes('/') ? dir.slice(0, dir.lastIndexOf('/')) : '');
+    let scope = parent ?? { own: new Set<string>(), deps: new Set<string>() };
+    try {
+      const json = JSON.parse(this.context.readFile(dir ? `${dir}/package.json` : 'package.json') ?? 'null') as Record<string, unknown> | null;
+      if (json && typeof json === 'object') {
+        scope = { own: new Set(scope.own), deps: new Set(scope.deps) };
+        if (typeof json.name === 'string' && json.name.length > 0) scope.own.add(json.name);
+        for (const field of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+          const deps = json[field];
+          if (!deps || typeof deps !== 'object') continue;
+          for (const [dep, version] of Object.entries(deps)) {
+            // `workspace:*`, `file:../shared`, `link:…`: a package in this repository.
+            if (typeof version === 'string' && /^(?:workspace|file|link|portal):/.test(version)) scope.own.add(dep);
+            else scope.deps.add(dep);
+          }
+        }
+      }
+    } catch { /* no or unreadable package.json */ }
+    // A Deno import map names packages the same way — an entry that maps to a
+    // registry or a URL, not one that maps to a path in the repository.
+    for (const file of ['deno.json', 'deno.jsonc']) {
+      const raw = this.context.readFile(dir ? `${dir}/${file}` : file);
+      if (!raw) continue;
+      const json = parseJsonc(raw) as { imports?: Record<string, unknown> } | undefined;
+      const imports = json && typeof json === 'object' ? json.imports : undefined;
+      if (!imports || typeof imports !== 'object') continue;
+      for (const [key, target] of Object.entries(imports)) {
+        if (typeof target !== 'string' || !/^(?:jsr|npm|https?):/.test(target)) continue;
+        if (scope === parent) scope = { own: new Set(scope.own), deps: new Set(scope.deps) };
+        scope.deps.add(key.replace(/\/$/, ''));
+      }
+    }
+    this.manifestScopes.set(dir, scope);
+    return scope;
+  }
+
   /** The one supertype-kind node a TypeScript value shares its name and file with. */
   private sameNamedTypeOfValue(value: Node): Node | null {
     if (value.kind !== 'constant' && value.kind !== 'variable') return null;
@@ -2879,6 +3429,26 @@ export class ReferenceResolver {
   }
 }
 
+/** The project-relative directory holding `p` ('' for the project root). */
+function goDirOf(p: string): string {
+  const dir = path.posix.dirname(p.replace(/\\/g, '/'));
+  return dir === '.' || dir === '/' ? '' : dir;
+}
+
+/**
+ * The routes a sync added, removed or renamed: `before` is every route node
+ * before the sync changed a file, `after` every one after its post-extract
+ * pass, and a route whose file and path are on one side only changed. A route
+ * renamed in place — the same node under a new path — is in the result twice,
+ * as its old self and its new one.
+ */
+export function changedRoutes(before: readonly Node[], after: readonly Node[]): Node[] {
+  const key = (route: Node): string => `${route.filePath}\0${route.name}`;
+  const beforeKeys = new Set(before.map(key));
+  const afterKeys = new Set(after.map(key));
+  return [...before.filter((route) => !afterKeys.has(key(route))), ...after.filter((route) => !beforeKeys.has(key(route)))];
+}
+
 /**
  * Create a reference resolver instance
  */
diff --git a/src/resolution/js-builtins.ts b/src/resolution/js-builtins.ts
index ef0d88cd96..3d877759e1 100644
--- a/src/resolution/js-builtins.ts
+++ b/src/resolution/js-builtins.ts
@@ -29,6 +29,8 @@ export const JS_BUILTIN_METHODS = new Set([
   'prependListener', 'prependOnceListener', 'listeners', 'rawListeners',
   'listenerCount', 'eventNames', 'setMaxListeners', 'getMaxListeners',
   'next', 'return', 'throw', 'drop', 'take', 'toArray',
+  // fetch's Response / Request / Blob bodies.
+  'text', 'json', 'arrayBuffer', 'blob', 'formData',
 ]);
 
 /**
diff --git a/src/resolution/name-matcher.ts b/src/resolution/name-matcher.ts
index d2675bddd8..58618bb5b2 100644
--- a/src/resolution/name-matcher.ts
+++ b/src/resolution/name-matcher.ts
@@ -4,11 +4,21 @@
  * Handles symbol name matching for reference resolution.
  */
 
+import * as fs from 'fs';
 import * as path from 'path';
 import { Language, Node } from '../types';
-import { UnresolvedRef, ResolvedRef, ResolutionContext, isSupertypeTarget, CPP_DEFINE_SIGNATURE, isInheritanceRef, isImportableKind } from './types';
+import { UnresolvedRef, ResolvedRef, ResolutionContext, ImportMapping, isSupertypeTarget, CPP_DEFINE_SIGNATURE, isInheritanceRef, isImportableKind } from './types';
 import { blankStringContents, stripCommentsForRegex } from './strip-comments';
 import { JS_BUILT_INS, JS_BUILTIN_METHODS, TS_PRIMITIVE_TYPES } from './js-builtins';
+import { SWIFT_TYPE_PATH_CALL, resolveSwiftTypePathCall } from './swift-type-visibility';
+import { dartImportPrefixes, dartLibrarySees, dartPrefixSees, inSameDartLibrary } from './dart-libraries';
+import { isDartLocallyBound } from './dart-local-scope';
+import { breakVbTie, isVbMemberInScope, isVbNestedTypeInScope, isVbTypeQualifiedBy, matchVbTypedCall, preferVbProject, sameVbProject } from './vbnet-receivers';
+import { cppAliasedTypeName, cppTypeSegments, isCppPointerType, resolveCppAliasedType, stripCppTemplateArguments } from './cpp-type-aliases';
+import { cppIncludedFile, cppIncluders } from './cpp-includers';
+import { isTestPath } from '../search/query-utils';
+import { isMinifiedContent } from '../extraction/generated-detection';
+import { getCargoWorkspaceCrateMap } from './frameworks/cargo-workspace';
 /**
  * Ceiling on how many same-named definitions a FUZZY name-match strategy will
  * score. A name defined more times than this is "ubiquitous" — a method/symbol
@@ -276,6 +286,17 @@ function matchMemberFunctionRef(ref: UnresolvedRef, context: ResolutionContext):
     if (ref.language === 'python') {
       const cls = pythonRefClass(receiver, ref, context);
       if (cls) return result(pythonMembers(cls, member, ref, context));
+      // `mod.global` / an imported `global` itself — never a deeper chain (`mod.global.field`).
+      const segments = receiver.split('.');
+      const hit = segments.length <= 2 ? context.resolveImport?.({ ...ref, referenceName: receiver, referenceKind: 'references' }) : null;
+      const global = hit && context.getNodeById?.(hit.targetNodeId);
+      // A local import of the root binds what the file imports, unless the file imports it from two places.
+      if (global && global.name === segments[segments.length - 1] && isPythonModuleGlobal(global, context) &&
+          pythonImportKeys(segments[0]!, ref.filePath, context).size === 1 &&
+          !pythonGlobalBindings(segments[0]!, ref.filePath, context).some(b => b.kind !== 'import') &&
+          !pythonBindsLocally(segments[0]!, ref, context, false)) {
+        return result(pythonGlobalMembers(global, member, ref, context));
+      }
     }
     const imported = context.resolveImport?.(ref);
     const node = imported && context.getNodeById?.(imported.targetNodeId);
@@ -283,8 +304,12 @@ function matchMemberFunctionRef(ref: UnresolvedRef, context: ResolutionContext):
   }
   if (ref.language === 'go') {
     if (receiver.includes('.')) return matchGoFieldChainCall(receiver, member, ref, context);
-    const type = inferLocalReceiverType(receiver, ref, context);
-    if (type) return resolveMethodOnType(type, member, ref, context, 0.9, 'function-ref');
+    const decl: { raw?: string } = {};
+    const type = inferLocalReceiverType(receiver, ref, context, decl);
+    if (type) {
+      return resolveMethodOnType(type, member, ref, context, 0.9, 'function-ref',
+        goDeclaredTypePackage(decl.raw, ref.filePath, context));
+    }
     const types = context.getNodesByName(receiver).filter(n => n.language === 'go' && (n.kind === 'struct' || n.kind === 'interface'));
     if (types.length) return types.length === 1 ? resolveMethodOnType(receiver, member, ref, context, 0.9, 'function-ref') : null;
   } else {
@@ -300,6 +325,11 @@ function matchMemberFunctionRef(ref: UnresolvedRef, context: ResolutionContext):
       type = pythonFieldType(receiver, owner, ref, context);
     } else {
       type = pythonLocalType(receiver, ref, context);
+      const global = type === null
+        ? context.getNodesInFile(ref.filePath).find(n => n.name === receiver && isPythonModuleGlobal(n, context)) : undefined;
+      if (global && !pythonBindsLocally(receiver, ref, context, true)) {
+        return result(pythonGlobalMembers(global, member, ref, context));
+      }
     }
     // A type name used directly (`Store.fetch`) is scoped just like an annotation.
     if (!type && /^[A-Z]\w*$/.test(receiver)) type = receiver;
@@ -320,12 +350,26 @@ function matchMemberFunctionRef(ref: UnresolvedRef, context: ResolutionContext):
     }
   }
   // Unknown receivers retain the old unique-or-drop discipline, across ALL
-  // files. Tests and abstract-looking bodies are candidates too.
-  return result(context.getNodesByName(member), 0.8);
+  // files. Tests and abstract-looking bodies are candidates too. A lone method
+  // stands only when the receiver is named after its owner: netbox's
+  // `device=self.parent.device` is a model field, not the project's one
+  // `device` method (a GraphQL filter's). A veto, never a filter — filtering
+  // first would promote some other lone match into a new guess.
+  const unique = result(context.getNodesByName(member), 0.8);
+  const target = unique ? context.getNodeById?.(unique.targetNodeId) : null;
+  return target && target.kind === 'method' && !sharesReceiverWord(receiverLink(receiver), target) ? null : unique;
 }
 
 function pythonRefClass(name: string, ref: UnresolvedRef, context: ResolutionContext): Node | null {
   const imports = context.getImportMappings(ref.filePath, 'python');
+  // `import pkg.mod` then `pkg.mod.Cls`: the mapping keys the module by its last segment.
+  const module = imports.find(i => i.isNamespace && name.startsWith(`${i.source}.`) &&
+    /^\w+$/.test(name.slice(i.source.length + 1)));
+  if (module) {
+    // Two modules with the same last segment (`import a.foo`, `import b.foo`) share the key: refuse.
+    if (imports.filter(i => i.localName === module.localName).length !== 1) return null;
+    name = `${module.localName}.${name.slice(module.source.length + 1)}`;
+  }
   if (imports.some(i => i.localName === name.split('.')[0])) {
     const hit = context.resolveImport?.({ ...ref, referenceName: name, referenceKind: 'references' });
     const node = hit && context.getNodeById?.(hit.targetNodeId);
@@ -400,6 +444,545 @@ function pythonLocalType(receiver: string, ref: UnresolvedRef, context: Resoluti
   return caller?.signature?.match(new RegExp(`\\b${receiver}\\s*:\\s*["']?([\\w.]+)`))?.[1] ?? null;
 }
 
+/** A module-scope Python variable (not a class attribute or a function local). */
+function isPythonModuleGlobal(node: Node, context: ResolutionContext): boolean {
+  return node.language === 'python' && (node.kind === 'variable' || node.kind === 'constant') &&
+    !context.getNodesInFile(node.filePath).some(n =>
+      (n.kind === 'class' || n.kind === 'function' || n.kind === 'method') &&
+      n.startLine <= node.startLine && n.endLine >= node.startLine);
+}
+
+/** How one line binds a name: `global`, a plain `name = value` / `name: T`, an import, or any other binding. */
+type PythonBinding =
+  | { kind: 'global' }
+  | { kind: 'assign'; type: string | null; value: string; line: number }
+  | { kind: 'import'; key: string }
+  | { kind: 'other' };
+
+const PYTHON_STATEMENT_STARTS = new WeakMap<ResolutionContext, Map<string, boolean[]>>();
+/** Per line: does it start a statement (bracket depth 0, no `\` continuation)? String contents are skipped. */
+function pythonStatementStarts(filePath: string, context: ResolutionContext): boolean[] {
+  let files = PYTHON_STATEMENT_STARTS.get(context);
+  if (!files) { files = new Map(); PYTHON_STATEMENT_STARTS.set(context, files); }
+  let starts = files.get(filePath);
+  if (starts) return starts;
+  starts = [];
+  let depth = 0;
+  let continued = false;
+  for (const line of pythonMemberLines(filePath, context)) {
+    starts.push(depth === 0 && !continued);
+    let quote = '';
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i]!;
+      if (quote) { if (c === '\\') i++; else if (c === quote) quote = ''; continue; }
+      if (c === '"' || c === "'") quote = c;
+      else if (c === '(' || c === '[' || c === '{') depth++;
+      else if (c === ')' || c === ']' || c === '}') depth = Math.max(0, depth - 1);
+    }
+    continued = /\\\s*$/.test(line);
+  }
+  files.set(filePath, starts);
+  return starts;
+}
+
+/** Line indexes that belong to `scope` itself (null: the module), not to a def or class nested in it. */
+function pythonOwnLines(scope: Node | null, filePath: string, context: ResolutionContext): number[] {
+  const count = pythonMemberLines(filePath, context).length;
+  const from = scope ? scope.startLine : 1;
+  const to = scope ? Math.min(scope.endLine, count) : count;
+  const nested = new Uint8Array(to - from + 1);
+  for (const n of context.getNodesInFile(filePath)) {
+    if ((n.kind !== 'function' && n.kind !== 'method' && n.kind !== 'class') || n.id === scope?.id) continue;
+    if (n.startLine < from || n.endLine > to || (scope && n.startLine <= scope.startLine)) continue;
+    nested.fill(1, n.startLine - from, n.endLine - from + 1);
+  }
+  const own: number[] = [];
+  for (let l = from; l <= to; l++) if (!nested[l - from]) own.push(l - 1);
+  return own;
+}
+
+/** Split `a = b = value` at its top-level assignment operators; null when the line assigns nothing. */
+function pythonAssignment(line: string): { targets: string[]; value: string; augmented: boolean } | null {
+  const targets: string[] = [];
+  let depth = 0;
+  let quote = '';
+  let start = 0;
+  let augmented = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i]!;
+    if (quote) { if (c === '\\') i++; else if (c === quote) quote = ''; continue; }
+    if (c === '"' || c === "'") { quote = c; continue; }
+    if (c === '(' || c === '[' || c === '{') { depth++; continue; }
+    if (c === ')' || c === ']' || c === '}') { depth--; continue; }
+    if (c !== '=' || depth !== 0) continue;
+    const prev = line[i - 1] ?? '';
+    if (line[i + 1] === '=') { i++; continue; } // ==
+    if (prev === '!' || prev === ':') continue; // != and the walrus
+    if ((prev === '<' || prev === '>') && line[i - 2] !== prev) continue; // <= >=
+    const op = line.slice(start, i).match(/(?:\/\/|\*\*|>>|<<|[-+*/%&|^@])$/)?.[0];
+    if (op) augmented = true;
+    targets.push(line.slice(start, i - (op?.length ?? 0)));
+    start = i + 1;
+  }
+  return targets.length ? { targets, value: line.slice(start), augmented } : null;
+}
+
+/**
+ * Every way the statement starting at line `index` binds `name`, read across
+ * its continuation lines. Only statement lines can assign or import; any line
+ * can bind through `as`, a loop, a lambda or the walrus.
+ */
+function pythonLineBindings(lines: string[], index: number, statements: boolean[], name: string): PythonBinding[] {
+  let line = lines[index]!;
+  if (statements[index]) for (let j = index + 1; j < lines.length && !statements[j]; j++) line += '\n' + lines[j];
+  const out: PythonBinding[] = [];
+  // An import statement can name `name` on a continuation line: `from x import (\n    name,\n)`.
+  const imported = statements[index] ? line.match(/^\s*(?:from\s+([\w.]+)\s+)?import\s+([\s\S]*)$/) : null;
+  if (imported) {
+    const names = imported[2]!;
+    // `from x import *` can bind any name.
+    if (imported[1] && names.trim() === '*') return [{ kind: 'other' }];
+    if (!names.includes(name)) return out;
+    for (const part of names.replace(/[()\\]/g, ' ').split(',')) {
+      const m = part.trim().match(/^([\w.]+)(?:\s+as\s+(\w+))?$/);
+      const local = m && (m[2] ?? (imported[1] ? m[1]! : m[1]!.split('.')[0]!));
+      if (local !== name) continue;
+      out.push({ kind: 'import', key: imported[1] ? `${imported[1]}:${m![1]}` : `${m![2] ? m![1] : local}:*` });
+    }
+    return out;
+  }
+  if (!line.includes(name)) return out;
+  const word = new RegExp(`(?<![\\w.])${name}\\b(?!\\s*[.\\[])`);
+  if (!word.test(line)) return out;
+  const declared = line.match(/^\s*(global|nonlocal)\s+([\w\s,]+)$/);
+  if (declared) {
+    return declared[2]!.split(',').some(s => s.trim() === name)
+      ? [declared[1] === 'global' ? { kind: 'global' } : { kind: 'other' }] : [];
+  }
+  if (statements[index]) {
+    // A `case` pattern binds its capture names (`case [name]:`, `case Cls(k=name):`, `case name:`).
+    if (/^\s*case\b/.test(line)) return [{ kind: 'other' }];
+    const assignment = pythonAssignment(line);
+    if (assignment) {
+      const target = assignment.targets.length === 1 && !assignment.augmented ? assignment.targets[0]!.trim() : '';
+      const annotated = target.match(new RegExp(`^${name}\\s*:\\s*["']?([\\w.]+)["']?$`));
+      if (target === name || annotated) {
+        out.push({ kind: 'assign', type: annotated?.[1] ?? null, value: assignment.value.trim(), line: index });
+      } else if (assignment.targets.some(t => word.test(t))) {
+        out.push({ kind: 'other' });
+      }
+    } else {
+      const annotated = line.match(new RegExp(`^\\s*${name}\\s*:\\s*["']?([\\w.]+)["']?\\s*$`));
+      if (annotated) out.push({ kind: 'assign', type: annotated[1]!, value: '', line: index });
+      else if (new RegExp(`^\\s*del\\b`).test(line)) out.push({ kind: 'other' });
+    }
+  }
+  if (new RegExp(`\\b${name}[ \\t]*:=|\\bas[ \\t]+${name}\\b`).test(line)) out.push({ kind: 'other' });
+  for (const loop of line.matchAll(/\bfor\s+([^:]+?)\s+in\b/g)) if (word.test(loop[1]!)) out.push({ kind: 'other' });
+  for (const lambda of line.matchAll(/\blambda\b([^:]*):/g)) if (word.test(lambda[1]!)) out.push({ kind: 'other' });
+  return out;
+}
+
+/**
+ * Whether `name`, read at the ref, is bound by the calling function or one that
+ * encloses it (parameter, assignment, loop, `as`, lambda, import) rather than
+ * being the module global. With `importsBind` false, an import of the name is
+ * not a shadow: it binds the same module the file imports.
+ */
+function pythonBindsLocally(name: string, ref: UnresolvedRef, context: ResolutionContext, importsBind: boolean): boolean {
+  const lines = pythonMemberLines(ref.filePath, context);
+  const statements = pythonStatementStarts(ref.filePath, context);
+  const param = new RegExp(`[(,]\\s*\\*{0,2}${name}\\s*[:=,)]`);
+  const scopes = context.getNodesInFile(ref.filePath).filter(n =>
+    (n.kind === 'function' || n.kind === 'method') && n.startLine <= ref.line && n.endLine >= ref.line)
+    .sort((a, b) => b.startLine - a.startLine);
+  for (const scope of scopes) {
+    const own = pythonOwnLines(scope, ref.filePath, context);
+    const bindings = own.flatMap(i => pythonLineBindings(lines, i, statements, name));
+    if (bindings.some(b => b.kind === 'global')) return false;
+    const def = own.find(i => /^\s*(?:async\s+)?def\b/.test(lines[i]!));
+    let header = scope.signature ?? '';
+    for (let j = def ?? lines.length; j < lines.length && (j === def || !statements[j]); j++) header += lines[j];
+    if (param.test(header)) return true;
+    if (bindings.some(b => b.kind !== 'global' && (b.kind !== 'import' || importsBind))) return true;
+  }
+  return false;
+}
+
+/** Distinct sources a file imports `name` from, at any scope (`from a import x` → `a:x`). */
+function pythonImportKeys(name: string, filePath: string, context: ResolutionContext): Set<string> {
+  return pythonNameScan(context, `imports\0${filePath}\0${name}`, () => scanPythonImportKeys(name, filePath, context));
+}
+
+const PYTHON_NAME_SCANS = new WeakMap<ResolutionContext, Map<string, unknown>>();
+/** Per-file, per-name scans are shared by every ref in the file; cleared with the other memos on sync. */
+function pythonNameScan<T>(context: ResolutionContext, key: string, scan: () => T): T {
+  let memo = PYTHON_NAME_SCANS.get(context);
+  if (!memo) { memo = new Map(); PYTHON_NAME_SCANS.set(context, memo); }
+  if (!memo.has(key)) memo.set(key, scan());
+  return memo.get(key) as T;
+}
+
+function scanPythonImportKeys(name: string, filePath: string, context: ResolutionContext): Set<string> {
+  const lines = pythonMemberLines(filePath, context);
+  const statements = pythonStatementStarts(filePath, context);
+  const keys = new Set<string>();
+  for (let i = 0; i < lines.length; i++) {
+    if (!statements[i] || !/\bimport\b/.test(lines[i]!)) continue;
+    for (const b of pythonLineBindings(lines, i, statements, name)) if (b.kind === 'import') keys.add(b.key);
+  }
+  return keys;
+}
+
+/** Every binding of module global `name` in `filePath`: at module scope, and in each function that declares it `global`. */
+function pythonGlobalBindings(name: string, filePath: string, context: ResolutionContext): PythonBinding[] {
+  return pythonNameScan(context, `globals\0${filePath}\0${name}`, () => scanPythonGlobalBindings(name, filePath, context));
+}
+
+function scanPythonGlobalBindings(name: string, filePath: string, context: ResolutionContext): PythonBinding[] {
+  const lines = pythonMemberLines(filePath, context);
+  const statements = pythonStatementStarts(filePath, context);
+  const scopes = context.getNodesInFile(filePath).filter(n => n.kind === 'class' || n.kind === 'function' || n.kind === 'method');
+  const regions = [pythonOwnLines(null, filePath, context)];
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*global\b/.test(lines[i]!) || !pythonLineBindings(lines, i, statements, name).length) continue;
+    const scope = scopes.filter(n => n.startLine <= i + 1 && n.endLine >= i + 1).sort((a, b) => b.startLine - a.startLine)[0];
+    if (scope && scope.kind !== 'class') regions.push(pythonOwnLines(scope, filePath, context));
+  }
+  const script = pythonMainBlockLines(filePath, context);
+  return regions.flatMap(region => region.filter(i => !script.has(i)).flatMap(i => pythonLineBindings(lines, i, statements, name)))
+    .filter(b => b.kind !== 'global');
+}
+
+const PYTHON_GLOBAL_CLASSES = new WeakMap<ResolutionContext, Map<string, Node[] | null>>();
+/**
+ * The classes a module global can hold. It has no static type (`conn = None`,
+ * rebound by `global conn; conn = Backend()`), so its type is the set of
+ * classes its module assigns to it: at module scope, or in a function that
+ * declares it `global`. Any other binding of it there (an opaque value, a
+ * tuple target, `for`/`with`/import, a star import, a `globals()` write)
+ * makes the type unknown (null). Production writes from other modules
+ * (`settings.conn = X`) join the set; see pythonExternalWrites.
+ */
+function pythonGlobalClasses(global: Node, ref: UnresolvedRef, context: ResolutionContext): Node[] | null {
+  let memo = PYTHON_GLOBAL_CLASSES.get(context);
+  if (!memo) { memo = new Map(); PYTHON_GLOBAL_CLASSES.set(context, memo); }
+  if (memo.has(global.id)) return memo.get(global.id)!;
+  const own = pythonOwnGlobalWrites(global, context);
+  const external = own && pythonExternalWrites(global, context);
+  // Each type is resolved in the file that wrote it (its imports name the class).
+  const writes = external && !external.unknown ? [...external.writes, ...own!] : null;
+  let classes: Node[] | null = writes && [];
+  const seen = new Set<string>();
+  for (const write of writes ?? []) {
+    const cls = pythonRefClass(write.type, { ...ref, filePath: write.file }, context);
+    if (!cls) { classes = null; break; }
+    if (!seen.has(cls.id)) { seen.add(cls.id); classes!.push(cls); }
+  }
+  memo.set(global.id, classes);
+  return classes;
+}
+
+/**
+ * The types the global's own module writes to it, or null when a binding
+ * there leaves its type unknown — whatever other modules write, so they are
+ * not read (#2332).
+ */
+function pythonOwnGlobalWrites(global: Node, context: ResolutionContext): Array<{ type: string; file: string }> | null {
+  return pythonNameScan(context, `own\0${global.id}`, () => {
+    const file = global.filePath;
+    if (pythonDynamicGlobalWrite(global.name, file, context)) return null;
+    const writes: Array<{ type: string; file: string }> = [];
+    for (const b of pythonGlobalBindings(global.name, file, context)) {
+      if (b.kind !== 'assign') return null;
+      const constructor = b.value && b.value !== 'None' ? pythonConstructorCall(b.value) : null;
+      if (b.type) {
+        // `conn: Base = make()` trusts the annotation; `conn: A = B()` contradicts it.
+        if (constructor && constructor.split('.').pop() !== b.type.split('.').pop()) return null;
+        writes.push({ type: b.type, file });
+        continue;
+      }
+      if (b.value === 'None') continue;
+      if (!constructor) return null;
+      writes.push({ type: constructor, file });
+    }
+    return writes;
+  });
+}
+
+/**
+ * The repo files a Python module path can name from `fromFile`. Relative
+ * paths (`..settings`) resolve exactly; absolute ones match a file path
+ * suffix, so a source root (`src/`) still resolves — and two files sharing
+ * the tail (`x/settings.py`, `y/settings.py`) both come back.
+ */
+function pythonModuleFiles(dotted: string, fromFile: string, context: ResolutionContext): string[] {
+  const dots = dotted.match(/^\.+/)?.[0].length ?? 0;
+  const parts = dotted.slice(dots).split('.').filter(Boolean);
+  if (!parts.length) return [];
+  let dir = '';
+  if (dots) {
+    dir = path.posix.dirname(fromFile.replace(/\\/g, '/'));
+    for (let i = 1; i < dots; i++) dir = path.posix.dirname(dir);
+    if (dir === '.') dir = '';
+  }
+  const rel = [dir, ...parts].filter(Boolean).join('/');
+  const matches = (file: string, want: string) => dots ? file === want : file === want || file.endsWith(`/${want}`);
+  const last = parts[parts.length - 1]!;
+  return [
+    ...context.getNodesByName(`${last}.py`), ...context.getNodesByName(`${last}.pyi`), ...context.getNodesByName('__init__.py'),
+  ].filter(n => n.kind === 'file' && (matches(n.filePath, `${rel}.py`) || matches(n.filePath, `${rel}.pyi`) || matches(n.filePath, `${rel}/__init__.py`)))
+    .map(n => n.filePath);
+}
+
+/**
+ * How `filePath` spells the module `moduleFile`: `aliases` import exactly that
+ * file; `ambiguous` could also be another file sharing its dotted tail.
+ * `import a.b` binds `a`, so that module is spelled `a.b` (the mapping's
+ * last-segment `localName` is not a binding); `import a.b as c` binds `c`.
+ */
+function pythonModuleAliases(filePath: string, moduleFile: string, context: ResolutionContext): { aliases: string[]; ambiguous: string[] } {
+  const aliases = new Set<string>();
+  const ambiguous = new Set<string>();
+  for (const m of context.getImportMappings(filePath, 'python')) {
+    const files = pythonImportedFiles(m, filePath, context);
+    if (!files.includes(moduleFile)) continue;
+    // The mapping cannot tell `import a.b` from `import a.b as b`; the source line can.
+    // Exactly this module (not `other.a.b`), outside string literals.
+    const explicit = new RegExp(`\\bimport\\s[^\\n]*(?<![\\w.])${m.source.replace(/\./g, '\\.')}\\s+as\\s+${m.localName}\\b`);
+    const plainDotted = m.isNamespace && m.source.includes('.') && m.localName === m.source.split('.').pop() &&
+      !pythonMemberLines(filePath, context).some(line => explicit.test(blankPythonStrings(line)));
+    (files.length === 1 ? aliases : ambiguous).add(plainDotted ? m.source : m.localName);
+  }
+  return { aliases: [...aliases], ambiguous: [...ambiguous] };
+}
+
+const PYTHON_IMPORTED_FILES = new WeakMap<ResolutionContext, WeakMap<ImportMapping, string[]>>();
+/**
+ * The repo files an import of `filePath` can name. Every global's write scan
+ * asks again of the same files (#2332); kept for as long as the resolver keeps
+ * the mapping itself, so the memo never outlives its import cache.
+ */
+function pythonImportedFiles(m: ImportMapping, filePath: string, context: ResolutionContext): string[] {
+  let memo = PYTHON_IMPORTED_FILES.get(context);
+  if (!memo) PYTHON_IMPORTED_FILES.set(context, (memo = new WeakMap()));
+  let files = memo.get(m);
+  if (!files) {
+    const dotted = m.isNamespace ? m.source
+      : /^\.+$/.test(m.source) ? `${m.source}${m.exportedName}` : `${m.source}.${m.exportedName}`;
+    memo.set(m, (files = pythonModuleFiles(dotted, filePath, context)));
+  }
+  return files;
+}
+
+const PYTHON_MAIN_GUARD = /^if\s+(?:__name__\s*==\s*(['"])__main__\1|(['"])__main__\2\s*==\s*__name__)\s*:/;
+/** Line indexes inside a top-level `if __name__ == "__main__":` block — script code, not module state. */
+function pythonMainBlockLines(filePath: string, context: ResolutionContext): Set<number> {
+  return pythonNameScan(context, `main\0${filePath}`, () => {
+    const lines = pythonMemberLines(filePath, context);
+    const inside = new Set<number>();
+    for (let i = 0; i < lines.length; i++) {
+      const guard = lines[i]!.match(PYTHON_MAIN_GUARD);
+      if (!guard) continue;
+      if (lines[i]!.slice(guard[0].length).trim()) inside.add(i); // `if __name__ == "__main__": stmt`
+      for (let j = i + 1; j < lines.length && !/^\S/.test(lines[j]!); j++) inside.add(j);
+    }
+    return inside;
+  });
+}
+
+/** Blank single-line string contents (triple-quoted strings are already blanked by the comment stripper). */
+function blankPythonStrings(text: string): string {
+  return text.replace(/(['"])(?:\\.|(?!\1)[^\\\n])*\1/g, m => m[0] + ' '.repeat(m.length - 2) + m[0]);
+}
+
+/** Test code installs doubles: the narrow test-suite set, plus pytest's `conftest.py` wherever it sits. */
+function isPythonTestFile(filePath: string): boolean {
+  return isTestPath(filePath) || /(?:^|\/)conftest\.py$/.test(filePath.replace(/\\/g, '/'));
+}
+
+/**
+ * Writes to module global `global` from OTHER files. A production write
+ * `<module>.<name> = Cls(...)` adds a type; any other production write
+ * (another value, a tuple target, `setattr`) makes the type unknown. Test
+ * files install doubles (`settings.conn = MagicMock()`, `monkeypatch.setattr`)
+ * that do not define the production type; they are recorded as `writers`, and
+ * a ref inside a writer resolves nothing through the global.
+ */
+function pythonExternalWrites(global: Node, context: ResolutionContext): { writes: Array<{ type: string; file: string }>; unknown: boolean; writers: Set<string> } {
+  return pythonNameScan(context, `external\0${global.id}`, () => {
+    const out = { writes: [] as Array<{ type: string; file: string }>, unknown: false, writers: new Set<string>() };
+    const name = global.name;
+    const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const file of pythonWriteCandidates(name, context)) {
+      if (file === global.filePath) continue;
+      const test = isPythonTestFile(file);
+      const { aliases, ambiguous } = pythonModuleAliases(file, global.filePath, context);
+      if (!test && !aliases.length && !ambiguous.length) continue;
+      const spell = (names: string[]) => `(?:${names.map(escape).join('|')})`;
+      // Test files: any receiver (the double may sit on any spelling of the module).
+      const receiver = test ? '[\\w.]+' : spell([...aliases, ...ambiguous]);
+      const target = new RegExp(`(?<![\\w.])${receiver}\\.${name}\\b(?!\\s*[.\\[(])`);
+      const exact = new RegExp(`^${test ? receiver : spell(aliases.length ? aliases : ['\\0'])}\\.${name}(?:\\s*:[^=]*)?$`);
+      const dynamic = new RegExp(`\\b(?:setattr|patch\\.object)\\s*\\(\\s*${receiver}\\s*,\\s*['"]${name}['"]` +
+        `|(?<![\\w.])${receiver}\\.__dict__\\s*(?:\\[|\\.\\s*update\\s*\\()`);
+      const lines = pythonMemberLines(file, context);
+      const statements = pythonStatementStarts(file, context);
+      const script = pythonMainBlockLines(file, context);
+      for (let i = 0; i < lines.length; i++) {
+        if (!statements[i] || script.has(i)) continue;
+        let statement = lines[i]!;
+        for (let j = i + 1; j < lines.length && !statements[j]; j++) statement += '\n' + lines[j];
+        if (!statement.includes(name)) continue;
+        const assignment = pythonAssignment(statement);
+        const assigned = assignment?.targets.some(t => target.test(t.trim())) ?? false;
+        if (!assigned && !dynamic.test(statement)) continue;
+        if (test) { out.writers.add(file); continue; }
+        // A write through an ambiguous spelling may land on another module: unknown.
+        const single = assignment && assignment.targets.length === 1 && !assignment.augmented && exact.test(assignment.targets[0]!.trim());
+        const value = single ? assignment!.value.trim() : '';
+        if (value === 'None') continue;
+        const constructor = value ? pythonConstructorCall(value) : null;
+        if (!constructor) { out.unknown = true; return out; }
+        out.writes.push({ type: constructor, file });
+      }
+    }
+    return out;
+  });
+}
+
+/**
+ * The Python files that can write a module global named `name`, in path
+ * order: those that spell it after a dot (`settings.conn = X`) or a quote
+ * (`setattr(settings, "conn", X)`), and those that write through `.__dict__`,
+ * whose statement may spell it anywhere. Comment stripping only blanks text,
+ * so whatever a stripped statement spells, the file's text spells too. The
+ * files are indexed once per pass, instead of every global reading every
+ * Python file (#2332).
+ */
+function pythonWriteCandidates(name: string, context: ResolutionContext): string[] {
+  const index = pythonNameScan(context, 'write-candidates', () => {
+    const files = context.getAllFiles().filter(f => /\.pyi?$/.test(f));
+    const spelled = new Map<string, number[]>();
+    const dict: Array<{ at: number; words: string }> = [];
+    files.forEach((file, at) => {
+      const source = context.readFile(file) ?? '';
+      const names = new Set<string>();
+      for (const m of source.matchAll(/[.'"](\w+)/g)) names.add(m[1]!);
+      for (const n of names) {
+        const list = spelled.get(n);
+        // A capture is a sliced view that would pin the file's whole text: key a flat copy.
+        if (list) list.push(at); else spelled.set(Buffer.from(n).toString(), [at]);
+      }
+      // A word-only name is in the text exactly when it is in one of its words.
+      if (names.has('__dict__')) dict.push({ at, words: [...new Set(source.match(/\w+/g))].join('\n') });
+    });
+    return { files, spelled, dict };
+  });
+  // The index holds ASCII words; any other name is looked for in every file's text.
+  if (!/^\w+$/.test(name)) return index.files.filter(f => context.readFile(f)?.includes(name));
+  const hits = new Set(index.spelled.get(name));
+  for (const { at, words } of index.dict) if (words.includes(name)) hits.add(at);
+  return [...hits].sort((a, b) => a - b).map(at => index.files[at]!);
+}
+
+/**
+ * Whether the global's own module can write it through its namespace dict:
+ * `globals()` / `vars()` / `sys.modules[__name__]` used as anything but a
+ * literal-key read or `.get`, or a literal-key write of this name. Read per
+ * statement (continuations joined), with string contents ignored.
+ */
+function pythonDynamicGlobalWrite(name: string, filePath: string, context: ResolutionContext): boolean {
+  const lines = pythonMemberLines(filePath, context);
+  const statements = pythonStatementStarts(filePath, context);
+  const script = pythonMainBlockLines(filePath, context);
+  // `vars()` is the module dict only at module scope; inside a function it is the locals.
+  const moduleLines = new Set(pythonOwnLines(null, filePath, context));
+  for (let i = 0; i < lines.length; i++) {
+    if (!statements[i] || script.has(i)) continue;
+    let statement = lines[i]!;
+    for (let j = i + 1; j < lines.length && !statements[j]; j++) statement += '\n' + lines[j];
+    const code = blankPythonStrings(statement);
+    const namespace = moduleLines.has(i)
+      ? /\bglobals\(\s*\)|\bvars\(\s*\)|\bsys\.modules\s*\[\s*__name__\s*\]/g
+      : /\bglobals\(\s*\)|\bsys\.modules\s*\[\s*__name__\s*\]/g;
+    const uses = code.match(namespace)?.length ?? 0;
+    if (!uses) continue;
+    const targets = pythonAssignment(statement)?.targets ?? [];
+    let safe = 0;
+    for (const m of statement.matchAll(/\bglobals\(\s*\)\s*(?:\[\s*(['"])(\w+)\1\s*\]|\.\s*get\s*\()/g)) {
+      const key = m[2];
+      const written = key !== undefined && targets.some(t => t.includes(m[0]));
+      if (written && key === name) return true;
+      safe++;
+    }
+    if (uses > safe) return true;
+  }
+  return false;
+}
+
+/**
+ * The method a module global's value can dispatch to: one class resolves to
+ * its own method; several bind to the nearest declaration they all inherit,
+ * as a base-typed receiver does. Otherwise, no edge.
+ */
+function pythonGlobalMembers(global: Node, member: string, ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  // Unknown from its own module alone: no edge, and no other module to read.
+  if (!pythonOwnGlobalWrites(global, context)) return [];
+  // A test that installs its own double sees the double, not the production type.
+  if (pythonExternalWrites(global, context).writers.has(ref.filePath)) return [];
+  const classes = pythonGlobalClasses(global, ref, context);
+  if (!classes) return [];
+  const targets = [...new Map(classes.flatMap(cls => pythonMembers(cls, member, ref, context)).map(n => [n.id, n])).values()];
+  if (targets.length <= 1) return targets;
+  // Several targets: the nearest declaration every candidate class inherits,
+  // whether or not a candidate overrides it.
+  const owner = (n: Node) => context.getNodesInFile(n.filePath).find(c =>
+    c.kind === 'class' && n.qualifiedName === `${c.qualifiedName}::${member}`);
+  const declarations = new Map<string, { decl: Node; cls: Node }>();
+  const queue = [...targets];
+  while (queue.length && declarations.size < 32) {
+    const decl = queue.shift()!;
+    const cls = decl && owner(decl);
+    if (!cls || declarations.has(decl.id)) continue;
+    declarations.set(decl.id, { decl, cls });
+    queue.push(...pythonBases(cls, ref, context).flatMap(base => pythonMembers(base, member, ref, context)));
+  }
+  const inherits = (cls: Node, base: Node) => cls.id === base.id || pythonDerivesFrom(cls, base, ref, context);
+  const shared = [...declarations.values()].filter(d => classes.every(c => inherits(c, d.cls)));
+  const nearest = shared.filter(d => shared.every(o => inherits(d.cls, o.cls)));
+  return nearest.length === 1 ? [nearest[0]!.decl] : targets;
+}
+
+/** `Cls(...)` / `pkg.mod.Cls(...)` as the WHOLE (possibly multi-line) value; else null (`Cls() if x else y`). */
+function pythonConstructorCall(text: string): string | null {
+  // `(Cls())` is the same value; peel parentheses that wrap the whole expression.
+  for (let wrapped = text.trim(); wrapped.startsWith('('); ) {
+    let depth = 0;
+    let close = -1;
+    for (let i = 0; i < wrapped.length && close < 0; i++) {
+      if (wrapped[i] === '(') depth++;
+      else if (wrapped[i] === ')' && --depth === 0) close = i;
+    }
+    if (close !== wrapped.length - 1) break;
+    text = wrapped = wrapped.slice(1, -1).trim();
+  }
+  const callee = text.match(/^((?:[A-Za-z_]\w*\.)*[A-Z]\w*)\s*\(/);
+  if (!callee) return null;
+  let depth = 0;
+  let quote = '';
+  for (let i = callee[0].length - 1; i < text.length; i++) {
+    const c = text[i]!;
+    if (quote) { if (c === '\\') i++; else if (c === quote) quote = ''; continue; }
+    if (c === '"' || c === "'") quote = c;
+    else if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') {
+      if (--depth === 0) return /^[\s\\]*$/.test(text.slice(i + 1)) ? callee[1]! : null;
+    }
+  }
+  return null;
+}
+
 /** Read a field's own annotation/initializer, or a constructor parameter assigned to it. */
 function pythonFieldType(receiver: string, owner: Node, ref: UnresolvedRef, context: ResolutionContext): string | null {
   const lines = pythonMemberLines(ref.filePath, context);
@@ -512,7 +1095,7 @@ export function matchFunctionRef(
     };
   }
 
-  let candidates = context
+  const named = context
     .getNodesByName(ref.referenceName)
     .filter(
       (n) =>
@@ -522,7 +1105,27 @@ export function matchFunctionRef(
         sameLanguageFamily(n.language, ref.language) &&
         n.id !== ref.fromNodeId // a function registering itself is not a dependency edge
     );
+  // A function declared inside another is in scope only in there: httpx's
+  // `self._build_auth(auth)` passes its own parameter, not the `auth` a test
+  // defines inside `test_custom_auth`. Those still count against a lone
+  // cross-file guess below — a name several functions use for themselves is
+  // as likely a local's.
+  let candidates = named.filter((n) => isLexicallyReachable(n, ref, context) &&
+    // A Dart constructor is torn off through its class, never by a bare name.
+    !isDartConstructor(n, context));
   if (candidates.length === 0) return null;
+  // A Python name the function around it binds — a parameter, an assignment —
+  // is that local's value: httpx's `auth_flow(self, request)` handing `request`
+  // on is not the package's `request()` function. A pytest fixture is what a
+  // test's parameter of its name receives.
+  if (ref.language === 'python' && !candidates.some((n) => isFixtureInReach(n, ref.filePath, context)) &&
+      isPythonLocallyBound(ref.referenceName, ref, context)) return null;
+  // Likewise a JS/TS parameter or local: lodash's `baseHas(object, key)` passes its own `object`.
+  const jsLocal = jsFunctionLocalScope(ref.referenceName, ref, context);
+  if (jsLocal) {
+    candidates = candidates.filter((n) => n.filePath === ref.filePath && n.startLine >= jsLocal.start && n.startLine <= jsLocal.end);
+    if (candidates.length === 0) return null;
+  }
 
   // Swift implicit-self: a bare identifier can name a METHOD only of the
   // ENCLOSING type (`Button(action: handleTap)` written inside that type) —
@@ -582,8 +1185,11 @@ export function matchFunctionRef(
   }
 
   // Cross-file (imported names the import resolver didn't already claim):
-  // only an unambiguous match resolves.
-  if (candidates.length === 1) {
+  // only an unambiguous match resolves — or, in Python, the one in reach of
+  // a name the file imports (netbox's `sender=CustomField` beside a test's
+  // own nested `CustomField`).
+  if (candidates.length === 1 && (named.length === 1 ||
+      (ref.language === 'python' && pythonFromImports(ref.filePath, context).has(ref.referenceName)))) {
     return {
       original: ref,
       targetNodeId: candidates[0]!.id,
@@ -596,6 +1202,8 @@ export function matchFunctionRef(
 
 /** Languages with no nested named functions: nesting in the graph is never a scope. */
 const NO_NESTED_FUNCTIONS = new Set<string>(['c', 'cpp']);
+/** Types a function body can declare for itself. */
+const LOCAL_TYPE_KINDS = new Set<string>(['class', 'struct', 'enum', 'interface', 'trait', 'type_alias']);
 
 /**
  * A function nested inside another FUNCTION is only callable from within its
@@ -608,12 +1216,32 @@ const NO_NESTED_FUNCTIONS = new Set<string>(['c', 'cpp']);
  * unaffected (their parent resolves to a class-like node), as are top-level
  * symbols and C++ namespace-prefixed names (the prefix has no node).
  */
-function isLexicallyReachable(
+export function isLexicallyReachable(
   candidate: Node,
   ref: UnresolvedRef,
   context: ResolutionContext
 ): boolean {
-  if (candidate.kind !== 'function') return true;
+  // An object literal's member is reached through its object (#2300): a bare
+  // `load()` or `setTimeout(load)` never means `App.load`, whatever shares
+  // the name — see isObjectMemberReachableByName for the ways that do.
+  if (candidate.kind === 'function' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName) &&
+      !isObjectMemberReachableByName(candidate, ref, context)) return false;
+  // An object hung on a path (`App.utils = {…}`, `$.event.special.swipe =
+  // {…}`) is a property, not a binding: no bare name reaches it — a
+  // `this.swipe()` elsewhere is not that object. One hung on the global object
+  // (`window.App = {…}`) is the global `App`.
+  if (isPathHolder(candidate) && isObjectLiteralOwner(candidate) && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName) &&
+      !HOST_GLOBAL_PREFIX.test(lastQualifiedSegment(candidate.qualifiedName))) return false;
+  // A `val` / `const` declared in a function body is that body's alone —
+  // okio's `(source as Source).buffer()` bound to a `val buffer = Buffer()`
+  // inside another test file's `pipe()`.
+  if (candidate.kind === 'variable' || candidate.kind === 'constant' || (candidate.kind === 'field' && candidate.language === 'scala')) {
+    const scope = localDeclarationScope(candidate, context);
+    return scope === null || (ref.filePath === candidate.filePath && ref.line >= scope.start && ref.line <= scope.end);
+  }
+  // A function — or a type (`case class B()` in a test method), or a method
+  // of such a type — declared inside a function is only in scope in there.
+  if (candidate.kind !== 'function' && candidate.kind !== 'method' && !LOCAL_TYPE_KINDS.has(candidate.kind)) return true;
   // C and C++ have no nested named functions, so a function the graph shows
   // inside another is an extraction artifact, not a scope: tree-sitter-c
   // cannot parse a macro call whose arguments are designated initializers
@@ -622,23 +1250,110 @@ function isLexicallyReachable(
   // the file, nesting every function after it. Trusting that nesting rejected
   // 117 real calls into pid.c on that tree; the functions are reachable.
   if (NO_NESTED_FUNCTIONS.has(candidate.language)) return true;
-  const qn = candidate.qualifiedName;
-  if (!qn || !qn.includes('::')) return true;
-  const parentQn = qn.slice(0, qn.lastIndexOf('::'));
-  const containers = context
-    .getNodesByQualifiedName(parentQn)
-    .filter(
-      (p) =>
-        p.filePath === candidate.filePath &&
-        (p.kind === 'function' || p.kind === 'method') &&
-        p.startLine <= candidate.startLine &&
-        p.endLine >= candidate.endLine
-    );
-  if (containers.length === 0) return true;
-  return (
-    ref.filePath === candidate.filePath &&
-    containers.some((p) => ref.line >= p.startLine && ref.line <= p.endLine)
-  );
+  const scope = lexicalScopeOf(candidate, context);
+  return scope === null || (ref.filePath === candidate.filePath && ref.line >= scope.start && ref.line <= scope.end);
+}
+
+/** Per context: node id → the function body (or Scala block) a declaration is local to. */
+const LOCAL_DECL_MEMO = new WeakMap<ResolutionContext, Map<string, { start: number; end: number } | null>>();
+
+/**
+ * The lines a variable declaration is in scope for when it is local: the
+ * innermost function or method of its file whose lines hold it — or, for a
+ * Scala `val` the graph files under its class but written inside a block of
+ * the class body (cats' `test("…") { val f = … }`), that block. Null for a
+ * declaration at file, class or object level. A Lua global assigned inside a
+ * function is still global; C and C++ nesting is not trusted (see below).
+ */
+function localDeclarationScope(candidate: Node, context: ResolutionContext): { start: number; end: number } | null {
+  if (NO_NESTED_FUNCTIONS.has(candidate.language)) return null;
+  let memo = LOCAL_DECL_MEMO.get(context);
+  if (!memo) LOCAL_DECL_MEMO.set(context, (memo = new Map()));
+  const hit = memo.get(candidate.id);
+  if (hit !== undefined) return hit;
+  let scope: { start: number; end: number } | null = null;
+  if (!((candidate.language === 'lua' || candidate.language === 'luau') && !isLuaLocal(candidate, context))) {
+    for (const n of context.getNodesInFile(candidate.filePath)) {
+      if ((n.kind !== 'function' && n.kind !== 'method') || n.id === candidate.id) continue;
+      if (n.startLine > candidate.startLine || n.endLine < candidate.startLine || n.startLine === n.endLine) continue;
+      if (n.startLine === candidate.startLine && (n.startColumn ?? 0) >= (candidate.startColumn ?? 0)) continue;
+      if (!scope || n.endLine - n.startLine < scope.end - scope.start) scope = { start: n.startLine, end: n.endLine };
+    }
+    if (!scope && candidate.kind === 'field' && candidate.language === 'scala') scope = scalaBlockOf(candidate, context);
+  }
+  memo.set(candidate.id, scope);
+  return scope;
+}
+
+/** The `{ … }` block, deeper than its class body, that a Scala `val` is written in; null for a member. */
+function scalaBlockOf(candidate: Node, context: ResolutionContext): { start: number; end: number } | null {
+  const owner = candidate.qualifiedName.includes('::') ? candidate.qualifiedName.slice(0, candidate.qualifiedName.lastIndexOf('::')) : '';
+  const cls = context.getNodesInFile(candidate.filePath).find((n) =>
+    n.qualifiedName === owner && (n.kind === 'class' || n.kind === 'trait' || n.kind === 'struct' || n.kind === 'module'));
+  if (!cls || cls.startLine >= candidate.startLine) return null;
+  const lines = context.getFileLines?.(candidate.filePath) ?? context.readFile(candidate.filePath)?.split(/\r?\n/) ?? [];
+  const clean = (l: string) => l.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)'/g, '""').replace(/\/\/.*$/, '');
+  // Depth at the start of each line, counted from the class header; the body is depth 1.
+  const opens: number[] = [];
+  let depth = 0;
+  for (let line = cls.startLine; line < candidate.startLine; line++) {
+    for (const ch of clean(lines[line - 1] ?? '')) {
+      if (ch === '{') { depth++; opens.push(line); }
+      else if (ch === '}') { depth = Math.max(0, depth - 1); opens.pop(); }
+    }
+  }
+  if (depth <= 1) return null;
+  const start = opens[opens.length - 1]!;
+  let d = depth;
+  for (let line = candidate.startLine; line <= cls.endLine; line++) {
+    for (const ch of clean(lines[line - 1] ?? '')) {
+      if (ch === '{') d++;
+      else if (ch === '}' && --d < depth) return { start, end: line };
+    }
+  }
+  return { start, end: cls.endLine };
+}
+
+/** Per context: a candidate's scoping function body, or null when nothing scopes it. */
+const LEXICAL_SCOPE_MEMO = new WeakMap<ResolutionContext, Map<string, { start: number; end: number } | null>>();
+
+/**
+ * The innermost function or method BODY that scopes a declaration, walking out
+ * through its qualified name (`test_x::Request::User::has_perm` → `test_x`).
+ * A method directly on a class is reachable through its instances, and an
+ * object-literal method a function returns through the object — neither is
+ * scoped by the function it sits in.
+ */
+function lexicalScopeOf(candidate: Node, context: ResolutionContext): { start: number; end: number } | null {
+  let memo = LEXICAL_SCOPE_MEMO.get(context);
+  if (!memo) {
+    memo = new Map();
+    LEXICAL_SCOPE_MEMO.set(context, memo);
+  }
+  const hit = memo.get(candidate.id);
+  if (hit !== undefined) return hit;
+  let scope: { start: number; end: number } | null = null;
+  const own = candidate.qualifiedName ?? '';
+  const parentQn = own.includes('::') ? own.slice(0, own.lastIndexOf('::')) : '';
+  let qn = own;
+  while (qn.includes('::')) {
+    qn = qn.slice(0, qn.lastIndexOf('::'));
+    const container = context
+      .getNodesByQualifiedName(qn)
+      .find(
+        (p) =>
+          p.filePath === candidate.filePath &&
+          (p.kind === 'function' || p.kind === 'method') &&
+          p.startLine <= candidate.startLine &&
+          p.endLine >= candidate.endLine
+      );
+    if (!container) continue;
+    if (candidate.kind === 'method' && qn === parentQn) break;
+    scope = { start: container.startLine, end: container.endLine };
+    break;
+  }
+  memo.set(candidate.id, scope);
+  return scope;
 }
 
 /** Languages whose module boundary is `import`/`export` (or CommonJS). */
@@ -659,8 +1374,9 @@ const HAS_IMPORT_STATEMENT = /^[ \t]*import[\s{*'"]/m;
  * CommonJS shapes cover files that never use ESM syntax at all, in both the dot
  * and the bracket form; and `declare global` contributes names to every file
  * whether or not the module exports anything of its own. Kept as a source test
- * rather than a node scan precisely because `isExported` is set only from an
- * `export_statement` ancestor, so `const x = …; export { x }` and
+ * rather than a node scan precisely because `isExported` is set only where a
+ * declaration is written (an `export_statement` around it, or a `declare
+ * module` / `declare global` body), so `const x = …; export { x }` and
  * `module.exports = { x }` both read as unexported on the node.
  */
 const HAS_ESM_EXPORT = /^[ \t]*export[\s{*]|^[ \t]*declare\s+global\b/m;
@@ -748,10 +1464,373 @@ function isCrossFileReachable(
   return (
     candidate.filePath === ref.filePath ||
     !ESM_FAMILY.has(candidate.language) ||
-    !isSealedModule(candidate.filePath, context)
+    (!isSealedModule(candidate.filePath, context) && !isUnexportedModuleBinding(candidate, context))
   );
 }
 
+const ESM_BINDING_KINDS: ReadonlySet<string> = new Set(['function', 'variable', 'constant', 'class', 'interface', 'type_alias', 'enum', 'component']);
+const ESM_EXPORT_LISTS = new WeakMap<ResolutionContext, Map<string, { module: boolean; names: Set<string> }>>();
+
+/**
+ * Whether `candidate` is a top-level binding of an ES module that the module
+ * doesn't export — declared without `export` and absent from its `export { … }`
+ * / `export default x` lists. No other file can name it. The sealed-module
+ * rule above covers files that export nothing; this is the same boundary per
+ * symbol: sveltekit's `generate_manifest.js` keeps an unexported `resolve`
+ * that twenty other files' `resolve(…)` calls went to. Classic scripts,
+ * CommonJS, `declare global` and `.d.ts` files, members of a class or
+ * namespace (qualified names), names a default-exported or returned object
+ * literal lists,
+ * and anything not declared by a statement of its own (an object literal's
+ * member, `proto.x = function x() {}`) are exempt.
+ */
+function isUnexportedModuleBinding(candidate: Node, context: ResolutionContext): boolean {
+  if (candidate.isExported || !ESM_BINDING_KINDS.has(candidate.kind)) return false;
+  if (candidate.qualifiedName.includes('::') || /\.d\.[cm]?ts$/.test(candidate.filePath)) return false;
+  let memo = ESM_EXPORT_LISTS.get(context);
+  if (!memo) ESM_EXPORT_LISTS.set(context, (memo = new Map()));
+  let info = memo.get(candidate.filePath);
+  if (!info) {
+    const source = context.readFile(candidate.filePath) ?? '';
+    const code = blankStringContents(stripCommentsForRegex(source, 'typescript'));
+    const module = (HAS_IMPORT_STATEMENT.test(code) || HAS_ESM_EXPORT.test(code)) &&
+      !HAS_CJS_EXPORT.test(source) && !/\bdeclare\s+global\b/.test(code);
+    const names = new Set<string>();
+    if (module) {
+      for (const m of source.matchAll(/^[ \t]*export\s+(?:type\s+)?\{([^}]*)\}/gm)) {
+        for (const item of m[1]!.split(',')) {
+          const local = item.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0]!.trim();
+          if (local) names.add(local);
+        }
+      }
+      for (const m of source.matchAll(/^[ \t]*export\s+(?:default|=)\s+([A-Za-z_$][\w$]*)\s*;?\s*$/gm)) names.add(m[1]!);
+      // `export default { getAdapter, adapters: known }` exposes its shorthand and
+      // value names; so does a `return { getDefaultActivityRoute, … }` (a
+      // composable hands the function out through its result).
+      for (const m of code.matchAll(/^[ \t]*export\s+default\s+\{([^}]*)\}|\breturn\s*\{([^{}]*)\}/gm)) {
+        for (const item of (m[1] ?? m[2])!.split(',')) {
+          const value = item.includes(':') ? item.split(':').pop()! : item;
+          const id = /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(value)?.[1];
+          if (id) names.add(id);
+        }
+      }
+    }
+    info = { module, names };
+    memo.set(candidate.filePath, info);
+  }
+  if (!info.module || info.names.has(candidate.name)) return false;
+  const line = (context.getFileLines?.(candidate.filePath) ?? context.readFile(candidate.filePath)?.split('\n'))?.[candidate.startLine - 1] ?? '';
+  // Its own line says `export` (a node's flag can miss a form), or it is
+  // `prototype.toString = function toString() {…}`, reached through instances.
+  if (/^\s*export\b/.test(line)) return false;
+  // Only a declaration statement is a module binding: an object literal's
+  // member (a zustand store action `setZipUri: (v) => set(…)`) is reached
+  // through the object, and so is `proto.x = function x() {}`.
+  return /^\s*(?:declare\s+)?(?:async\s+)?(?:function\*?|const|let|var|(?:abstract\s+)?class|interface|type|enum)\s/.test(line);
+}
+
+const LUA_LOCALS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** Whether a Lua variable or function is declared `local` (`local x = …`, `local function f`, `local a, x = …`). */
+function isLuaLocal(candidate: Node, context: ResolutionContext): boolean {
+  if (candidate.kind !== 'variable' && candidate.kind !== 'constant' && candidate.kind !== 'function') return false;
+  let memo = LUA_LOCALS.get(context);
+  if (!memo) LUA_LOCALS.set(context, (memo = new Map()));
+  const hit = memo.get(candidate.id);
+  if (hit !== undefined) return hit;
+  const line = (context.getFileLines?.(candidate.filePath) ?? context.readFile(candidate.filePath)?.split(/\r?\n/))?.[candidate.startLine - 1] ?? '';
+  const local = /^\s*local\b/.test(line);
+  memo.set(candidate.id, local);
+  return local;
+}
+
+const JVM_CALLABLE_KINDS: ReadonlySet<string> = new Set(['method', 'function']);
+const JVM_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'interface', 'enum', 'struct', 'trait', 'type_alias', 'annotation']);
+
+/**
+ * A test suite — a test source set, a `tests/` / `__tests__/` / `spec/`
+ * directory, a `FooTest.kt` / `test_foo.py` / `foo.test.ts` / `foo_unittest.cc`
+ * file — as opposed to test-support code a project ships (`testing/`,
+ * `fakes/`, a `*-test` module like kotlinx-coroutines-test), which its own
+ * code may use.
+ */
+function isTestSuitePath(filePath: string): boolean {
+  if (!isTestPath(filePath)) return false;
+  const lower = filePath.toLowerCase();
+  const name = lower.slice(lower.lastIndexOf('/') + 1);
+  const original = filePath.slice(filePath.lastIndexOf('/') + 1);
+  // (`…Spec.java` alone is no test: halo's `IndexSpecs`, okhttp's `ConnectionSpec`.)
+  if (name.startsWith('test_') || /[._-](?:test|tests|unittest|unittests)\.[a-z0-9]+$|[._](?:spec|specs)\.[a-z0-9]+$/.test(name) ||
+      // CamelCase suffixes where the language names tests so: not `useTests.ts`, a React hook.
+      /(?:Test|Tests|TestCase)\.(?:java|kt|kts|swift|cs|scala|groovy|m|mm|vb|fs)$/.test(original) || name === 'conftest.py') return true;
+  return /(?:^|\/)(?:tests?|__tests__|specs?|e2e)\//.test(lower) || /(?:^|\/)[A-Za-z0-9]*(?:Test|Tests|Spec)\//.test(filePath);
+}
+
+const fileStem = (filePath: string): string => {
+  const name = filePath.slice(filePath.lastIndexOf('/') + 1);
+  const dot = name.lastIndexOf('.');
+  return dot > 0 ? name.slice(0, dot) : name;
+};
+
+/**
+ * Whether a C or C++ file named like a test suite is part of `ref`'s
+ * translation unit after all. A file is in every translation unit that
+ * includes it, whatever its name says: protobuf's conformance framework is
+ * `conformance_test.h` (`ConformanceTestSuite`) and `test_runner.h`, which the
+ * suites and runners include, so binary_json_conformance_suite.cc's
+ * `suite_.ReportFailure(…)` is `ConformanceTestSuite::ReportFailure`. A
+ * definition in a source file counts through the header it implements: the
+ * one named like it that it includes (`conformance_test.cc` →
+ * `conformance_test.h`), when that header is a test suite's too — jemalloc's
+ * test `test/unit/hash.c` includes the library's `hash.h` to test it.
+ */
+function isIncludedCppTestSuite(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if ((candidate.language !== 'c' && candidate.language !== 'cpp') || (ref.language !== 'c' && ref.language !== 'cpp')) return false;
+  if (cppIncluders(candidate.filePath, context).has(ref.filePath)) return true;
+  const stem = fileStem(candidate.filePath);
+  for (const include of context.getNodesInFile(candidate.filePath)) {
+    if (include.kind !== 'import' || fileStem(include.name) !== stem) continue;
+    const header = cppIncludedFile(include, context);
+    if (header && header !== candidate.filePath && fileStem(header) === stem && isTestSuitePath(header) &&
+        cppIncluders(header, context).has(ref.filePath)) return true;
+  }
+  return false;
+}
+
+const MINIFIED_SCRIPTS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** A minified / bundled script, by name (`jquery.min.js`) or by its text. */
+function isMinifiedScript(filePath: string, context: ResolutionContext): boolean {
+  if (!/\.(?:m?js|cjs)$/i.test(filePath)) return false;
+  let memo = MINIFIED_SCRIPTS.get(context);
+  if (!memo) MINIFIED_SCRIPTS.set(context, (memo = new Map()));
+  let hit = memo.get(filePath);
+  if (hit === undefined) {
+    hit = /[.-]min\.m?js$/i.test(filePath) || isMinifiedContent(filePath, context.readFile(filePath) ?? '');
+    memo.set(filePath, hit);
+  }
+  return hit;
+}
+
+/** Per context: every package the project's JVM sources declare. */
+const JVM_PACKAGES = new WeakMap<ResolutionContext, Set<string>>();
+
+/**
+ * Whether a Java file binds `name` with a single-type (or static) import from
+ * a package the project does not declare — `import java.lang.reflect.Field;`,
+ * `import static org.junit.Assert.assertEquals;`. A nested class of a project
+ * type (`import com.acme.Outer.Inner;`) is under a project package, so it is not.
+ */
+function isJavaOutsideImport(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const binding = context.getImportMappings(ref.filePath, ref.language).find((m) => m.localName === name);
+  if (!binding) return false;
+  // A member the file declares itself is in scope before any import —
+  // Exposed's `toLocalDateTime(value)` inside the column type that defines it —
+  // in the same namespace only: gson's `new URI(…)` is `java.net.URI` beside
+  // `TypeAdapters`' field `URI`, as a type always is beside a value.
+  const call = ref.referenceKind === 'calls' && name === ref.referenceName;
+  const kinds = call ? JVM_CALLABLE_KINDS : JVM_TYPE_KINDS;
+  if ((context.getNodesInFileNamed?.(ref.filePath, name) ?? context.getNodesInFile(ref.filePath).filter((n) => n.name === name))
+    .some((n) => kinds.has(n.kind))) return false;
+  let packages = JVM_PACKAGES.get(context);
+  if (!packages) {
+    packages = new Set<string>();
+    for (const n of context.getNodesByKind('namespace')) {
+      if (n.language === 'java' || n.language === 'kotlin' || n.language === 'scala') packages.add(n.qualifiedName);
+    }
+    JVM_PACKAGES.set(context, packages);
+  }
+  const parts = binding.source.split('.');
+  for (let i = 1; i < parts.length; i++) {
+    if (packages.has(parts.slice(0, i).join('.'))) return false;
+  }
+  return true;
+}
+
+/** Lua's global functions, and the test runner's: `local type = type` is the standard library's `type`. */
+const LUA_GLOBAL_FUNCTIONS: ReadonlySet<string> = new Set([
+  'assert', 'error', 'ipairs', 'pairs', 'next', 'type', 'tostring', 'tonumber', 'setmetatable', 'getmetatable',
+  'rawget', 'rawset', 'rawequal', 'rawlen', 'select', 'pcall', 'xpcall', 'unpack', 'print', 'load', 'loadstring',
+  'loadfile', 'dofile', 'collectgarbage', 'require', 'setfenv', 'getfenv', 'newproxy', 'typeof', 'warn', 'tick', 'wait',
+  'describe', 'it', 'before_each', 'after_each', 'setup', 'teardown', 'lazy_setup', 'lazy_teardown', 'pending', 'finally',
+  'insulate', 'expose',
+]);
+
+/** `require "m"` (or a loader named for it — kong's `reload_module("spec.internal.misc")`), then any `.member`s. */
+const LUA_REQUIRE_ALIAS = /^(?:require|[A-Za-z_]\w*(?:[Rr]equire|_module|[Ii]mport))\s*\(?\s*(["'])([^"']+)\1\s*\)?((?:\s*\.\s*[A-Za-z_]\w*)*)\s*$/;
+const LUA_NAME_ALIAS = /^([A-Za-z_]\w*)((?:\s*\.\s*[A-Za-z_]\w*)*)\s*$/;
+
+/**
+ * A bare Lua call through a `local` alias, followed to what the alias names:
+ *
+ *   local splitn = require("kong.tools.string").splitn   → the module's `splitn`
+ *   local select_listener = utils.select_listener        → through `local utils = require …`
+ *   local fmt = string.format / local type = type        → the standard library's: no edge
+ *
+ * Kong localizes every global and module function it uses this way, so its
+ * calls stopped at a same-file variable — 8,000 of them, most for the
+ * standard library. `undefined` when the call is not through such an alias
+ * (it resolves as before), null when the alias names nothing in the project.
+ */
+function luaAliasTarget(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null | undefined {
+  const decl = luaLocalDecl(ref.referenceName, ref.filePath, ref.line, context);
+  if (!decl) return undefined;
+  const target = luaAliasOf(decl, context, 0);
+  if (target === undefined) return undefined;
+  if (target === null) return null;
+  return { original: ref, targetNodeId: target.id, confidence: 0.9, resolvedBy: 'import' };
+}
+
+/** The `local name = …` in scope at `line` of `file`: the nearest one above it that no other function holds. */
+function luaLocalDecl(name: string, file: string, line: number, context: ResolutionContext): Node | null {
+  const nodes = context.getNodesInFile(file);
+  const fns = nodes.filter((n) => n.kind === 'function' || n.kind === 'method');
+  let best: Node | null = null;
+  for (const n of nodes) {
+    if (n.name !== name || n.kind !== 'variable' || n.startLine > line || !n.signature) continue;
+    if (fns.some((f) => f.startLine <= n.startLine && n.startLine <= f.endLine && !(f.startLine <= line && line <= f.endLine))) continue;
+    if (!isLuaLocal(n, context)) continue;
+    if (!best || n.startLine > best.startLine) best = n;
+  }
+  // A function's own locals are not nodes: kong's `local clear_header =
+  // kong.response.clear_header` inside an access handler. Read the nearest
+  // one above the call within the innermost function around it.
+  const fn = fns.filter((f) => f.startLine <= line && line <= f.endLine && f.startLine < line)
+    .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+  if (fn && (!best || best.startLine < fn.startLine)) {
+    const lines = context.getFileLines?.(file) ?? context.readFile(file)?.split(/\r?\n/) ?? [];
+    const decl = new RegExp(`^\\s*local\\s+${name}\\s*=\\s*(.+?)\\s*$`);
+    for (let at = line - 1; at > fn.startLine; at--) {
+      const m = decl.exec(lines[at - 1] ?? '');
+      if (!m) continue;
+      const fileNode = nodes.find((n) => n.kind === 'file');
+      if (!fileNode) break;
+      return { ...fileNode, name, kind: 'variable', signature: `= ${m[1]}`, startLine: at, endLine: at };
+    }
+  }
+  return best;
+}
+
+/** Where a Lua alias is written: its file, line and name, and a node there to resolve `require`s from. */
+interface LuaSite { file: string; line: number; name: string; node: Node }
+
+/**
+ * What a Lua alias variable names: a project function (or the module's own
+ * global), null for the standard library or an outside module, `undefined`
+ * for an initializer that is not an alias.
+ */
+function luaAliasOf(decl: Node, context: ResolutionContext, depth: number): Node | null | undefined {
+  const rhs = decl.signature!.replace(/^\s*=\s*/, '').trim();
+  return luaAliasExpr(rhs, { file: decl.filePath, line: decl.startLine, name: decl.name, node: decl }, context, depth);
+}
+
+const luaMembers = (chain: string): string[] => chain.split('.').map((s) => s.trim()).filter(Boolean);
+
+function luaAliasExpr(rhs: string, site: LuaSite, context: ResolutionContext, depth: number): Node | null | undefined {
+  const req = LUA_REQUIRE_ALIAS.exec(rhs);
+  if (req) return luaModuleMember(req[2]!, luaMembers(req[3]!), site.node, context, depth);
+  const named = LUA_NAME_ALIAS.exec(rhs);
+  if (!named) return undefined;
+  const root = named[1]!;
+  const path = luaMembers(named[2]!);
+  const rootDecl = root === site.name ? null : luaLocalDecl(root, site.file, site.line - 1, context);
+  if (rootDecl) {
+    const module = LUA_REQUIRE_ALIAS.exec(rootDecl.signature!.replace(/^\s*=\s*/, '').trim());
+    if (module && path.length > 0) return luaModuleMember(module[2]!, [...luaMembers(module[3]!), ...path], rootDecl, context, depth);
+    return undefined;
+  }
+  if (path.length === 0) return LUA_GLOBAL_FUNCTIONS.has(root) ? null : undefined;
+  if (!LUA_LIBRARY_TABLES.has(root)) {
+    // A member of a global table the host provides — kong's `local clear_header =
+    // kong.response.clear_header` — is the one method of a table named after its holder.
+    const member = path[path.length - 1]!;
+    const holder = path.length > 1 ? path[path.length - 2]! : root;
+    const owned = context.getNodesByName(member).filter((n) =>
+      (n.language === 'lua' || n.language === 'luau') && n.kind === 'method' && sharesReceiverWord(holder, n) &&
+      !(isTestPath(n.filePath) && !isTestPath(site.file)));
+    return owned.length === 1 ? owned[0]! : undefined;
+  }
+  if (path.length !== 1) return undefined;
+  // A library function the project patches itself (kong's `ngx.sleep`) is the project's —
+  // a test's stand-in (`function ngx.get_phase()` in a spec) only for that test.
+  const patched = context.getNodesByName(path[0]!).filter((n) =>
+    (n.kind === 'function' || n.kind === 'method') && n.qualifiedName.split(/::|\./)[0] === root &&
+    (n.filePath === site.file || !isTestPath(n.filePath)));
+  return patched.length === 1 ? patched[0]! : null;
+}
+
+/** Per-context memo: `file\0a.b` → what that module member is. */
+const LUA_MEMBERS = new WeakMap<ResolutionContext, Map<string, Node | null | undefined>>();
+
+/** `member` of the module `require(name)` returns, from `decl`'s file: its function of that name. */
+function luaModuleMember(name: string, path: string[], decl: Node, context: ResolutionContext, depth: number): Node | null | undefined {
+  const file = luaModuleFile(name, decl, context);
+  if (!file) return null;
+  // `require "kong.conf_loader"` called directly: the module's returned value.
+  if (path.length === 0) return undefined;
+  let memo = LUA_MEMBERS.get(context);
+  if (!memo) LUA_MEMBERS.set(context, (memo = new Map()));
+  const key = `${file}\0${path.join('.')}`;
+  if (memo.has(key)) return memo.get(key);
+  memo.set(key, null); // a cycle of re-exports names nothing
+  const found = luaMemberIn(file, path, context, depth);
+  memo.set(key, found);
+  return found;
+}
+
+function luaMemberIn(file: string, path: string[], context: ResolutionContext, depth: number): Node | null | undefined {
+  const member = path[path.length - 1]!;
+  const nodes = context.getNodesInFile(file);
+  const inFile = nodes.filter((n) => n.name === member);
+  const fns = inFile.filter((n) => n.kind === 'function' || n.kind === 'method');
+  if (fns.length > 0) {
+    const owner = path.length > 1 ? path[path.length - 2]! : null;
+    return fns.find((n) => owner !== null && n.qualifiedName.endsWith(`${owner}::${member}`)) ??
+      fns.find((n) => n.kind === 'method') ?? fns[0]!;
+  }
+  if (depth >= 3) return null;
+  // The module exports something under this name: `return { check = check_phase }`,
+  // `_M.check = check_phase`, `kong_exec = cmd.kong_exec,` (spec helpers' table).
+  const source = (context.readFile(file) ?? '')
+    .replace(/--\[(=*)\[[\s\S]*?\]\1\]/g, (c) => c.replace(/[^\n]/g, ''))
+    .replace(/--[^\n]*/g, '');
+  const exported = new RegExp(`(?:^|[\\s{,.])${member}\\s*=\\s*([A-Za-z_]\\w*(?:\\s*\\.\\s*[A-Za-z_]\\w*)*)\\s*(?:[,;}]|$)`, 'm').exec(source);
+  if (exported && exported[1] !== member) {
+    const rhs = exported[1]!;
+    const line = source.slice(0, exported.index).split('\n').length + 1;
+    if (/^[A-Za-z_]\w*$/.test(rhs)) {
+      const fn = nodes.find((n) => n.name === rhs && (n.kind === 'function' || n.kind === 'method'));
+      if (fn) return fn;
+    }
+    const at = nodes.find((n) => n.kind === 'file') ?? nodes[0];
+    const next = at ? luaAliasExpr(rhs, { file, line, name: member, node: at }, context, depth + 1) : undefined;
+    if (next !== undefined) return next;
+  }
+  // The module re-exports an alias of its own (`local splitn = require(…).splitn`).
+  const alias = inFile.find((n) => n.kind === 'variable' && n.signature && isLuaLocal(n, context));
+  if (alias) {
+    const next = luaAliasOf(alias, context, depth + 1);
+    if (next !== undefined) return next;
+  }
+  const global = inFile.find((n) => n.kind === 'variable' && !isLuaLocal(n, context));
+  return global ?? null;
+}
+
+/** The project file `require(name)` loads from `decl`'s file, or null for a module outside it. */
+function luaModuleFile(name: string, decl: Node, context: ResolutionContext): string | null {
+  const resolved = context.resolveImport?.({
+    fromNodeId: decl.id,
+    referenceName: name,
+    referenceKind: 'imports',
+    line: decl.startLine,
+    column: 0,
+    filePath: decl.filePath,
+    language: decl.language,
+  });
+  if (!resolved) return null;
+  return context.getNodeById?.(resolved.targetNodeId)?.filePath ?? null;
+}
+
 /**
  * Languages in which `visibility: 'private'` on a definition means no other
  * FILE can name it: a Kotlin `private fun` is file- or class-local, and the
@@ -839,15 +1918,806 @@ function rustModuleDir(filePath: string): string {
   return path.posix.join(dir, base.replace(/\.rs$/, ''));
 }
 
+interface GoQualification {
+  /** The package name written before the reference's name, as spelled. */
+  written?: string;
+  /** The file's import that name is. */
+  imported?: ImportMapping;
+  /**
+   * For a call through a parameter or local that takes an import's name, the
+   * type it is declared as, when its declaration writes one (`*tokenJWT`,
+   * `clock.PassiveClock`), and the import that type is written through —
+   * `clock` in a parameter `clock clock.PassiveClock`, `atomic` in
+   * `cache := &atomic.Bool{}` — or its value comes from: `reflect` in
+   * `value := reflect.New(t)`.
+   */
+  declaredType?: string;
+  typePackage?: ImportMapping;
+}
+
+const GO_QUALIFIERS = new WeakMap<ResolutionContext, Map<string, GoQualification>>();
+
+function goRefQualification(ref: UnresolvedRef, context: ResolutionContext): GoQualification {
+  if (ref.referenceKind === 'imports') return {};
+  const name = ref.referenceName.split('.').pop()!;
+  if (!/^[A-Za-z_]\w*$/.test(name)) return {};
+  let memo = GO_QUALIFIERS.get(context);
+  if (!memo) GO_QUALIFIERS.set(context, (memo = new Map()));
+  const key = `${ref.filePath}\0${ref.line}\0${ref.column}\0${ref.referenceName}`;
+  const hit = memo.get(key);
+  if (hit !== undefined) return hit;
+  let written: string | undefined;
+  const dot = ref.referenceName.indexOf('.');
+  if (dot >= 0) {
+    // A dotted reference spells its receiver, and only the first segment can
+    // be a package: `klog` in `klog.Infof`, `s` in `s.cache.Get`. Reading
+    // the line for it found nothing where the name is spelled again —
+    // harbor's `Digest:` key beside `digest.Digest(dig)` — and another
+    // selector's where one comes first: `klog` for `err.Error` in
+    // `klog.Error(err.Error())`.
+    const head = ref.referenceName.slice(0, dot);
+    if (/^[A-Za-z_]\w*$/.test(head)) written = head;
+  } else {
+    const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1] ?? '';
+    const at = Math.max(0, ref.column);
+    // The qualifier right before the name at the reference's column, or the
+    // line's only spelling of the name. A variadic `...chunks.Meta` is written
+    // through `chunks` too: the ellipsis is no receiver.
+    written = line.startsWith(name, at) ? /(?:^|[^\w.]|\.{3})([A-Za-z_]\w*)\.$/.exec(line.slice(0, at))?.[1]
+      : !new RegExp(`(?<![\\w.])${name}\\b`).test(line) ? new RegExp(`(?:^|[^\\w.]|\\.{3})([A-Za-z_]\\w*)\\.${name}\\b`).exec(line)?.[1] : undefined;
+  }
+  const imports = context.getImportMappings(ref.filePath, 'go');
+  let imported = written ? imports.find((m) => m.localName === written) : undefined;
+  let declaredType: string | undefined;
+  let typePackage: ImportMapping | undefined;
+  // A call through a parameter or local that takes the import's name is a
+  // call on that variable: etcd's `jwt, err := newTokenProviderJWT(…)`, then
+  // `jwt.assign(…)` beside `import "github.com/golang-jwt/jwt/v5"`; harbor's
+  // testify suites' `func (suite *DaoTestSuite) …` beside testify's `suite`.
+  // A type's qualifier is always a package, and a value read through one
+  // (`quota.Name`) is no call.
+  const local = imported && dot >= 0 && ref.referenceKind === 'calls' ? goLocalDecl(written!, ref, context) : undefined;
+  if (local) {
+    declaredType = local.type;
+    // A value a package outside the project hands out is of a type it
+    // declares: kubernetes' `clock := clocktesting.NewFakePassiveClock(…)`
+    // has no project method `Now`.
+    const qualifier = /^[*&\s]*([A-Za-z_]\w*)\.[A-Za-z_]\w*$/.exec(declaredType ?? '')?.[1] ?? local.from;
+    typePackage = qualifier ? imports.find((m) => m.localName === qualifier) : undefined;
+    written = undefined;
+    imported = undefined;
+  }
+  const found = { written, imported, declaredType, typePackage };
+  memo.set(key, found);
+  return found;
+}
+
 /**
- * Whether `candidate` can be NAMED from a reference in `ref`'s file at all,
- * given what its language says about the definition's visibility. A
- * definition the language makes file-local is not a candidate for a
- * cross-file name match, however well the names agree:
- *
- * - **C / C++**: a `static` function defined in a SOURCE file is local to
- *   that translation unit; one in a header is part of every unit that
- *   includes it and stays visible. On a 2,109-file betaflight tree 145
+ * The import a Go reference is written through — `context` in
+ * `context.Context`, `store` in `store.Manager` — taken from a dotted
+ * reference's receiver, else read from its line, since the index keeps only
+ * the name. Undefined for a name written bare, or through anything that isn't
+ * one of the file's imports there.
+ */
+export function goRefQualifier(ref: UnresolvedRef, context: ResolutionContext): ImportMapping | undefined {
+  return goRefQualification(ref, context).imported;
+}
+
+/**
+ * Whether a Go reference is written through a package that is none of its
+ * file's imports as the index knows them: `clientv3` in `clientv3.KV` under an
+ * unaliased `import "go.etcd.io/etcd/client/v3"`, a package named neither by
+ * its path's last element (`v3`) nor by the name goimports assumes for it
+ * (`client`). Which package that is cannot be told from here.
+ */
+export function isGoUnknownQualified(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const { written, imported } = goRefQualification(ref, context);
+  return written !== undefined && imported === undefined;
+}
+
+/**
+ * What a Go type position — a parameter or result type, a composite
+ * literal's type — names: a type, which Go reads from one package. A method
+ * or a function is never it; Go reaches those only through a value or a
+ * package. Whichever strategy found a declaration of the name, the type is
+ * the one of that name in the reference's own package for a bare name, or in
+ * the imported project package for `pkg.T`. Without one there, a method or
+ * function of the name is nothing the reference means. etcd's
+ * `func (ti *treeIndex) KeyIndex(keyi *keyIndex) *keyIndex` linked both
+ * `keyIndex` types to the method `treeIndex.keyIndex` beside it,
+ * prometheus's `(ec2Client, error)` result to the method the line declares,
+ * and its `&config_util.URL{…}` (an outside package) to `Target.URL`. A bare
+ * name that found another package's type means its own package's type of
+ * that name when there is one: prometheus's `prompb` builds its own
+ * `Histogram_CountInt`, not the `write/v2` one.
+ */
+export function goTypePositionTarget(result: ResolvedRef, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const target = context.getNodeById?.(result.targetNodeId);
+  if (!target || target.language !== 'go') return result;
+  const isType = GO_TYPE_KINDS.has(target.kind);
+  // A composite literal keeps its package in the name (`config_util.URL`);
+  // a parameter type leaves it on the line.
+  const dot = ref.referenceName.lastIndexOf('.');
+  const name = ref.referenceName.slice(dot + 1);
+  // The package's directory; null for a package outside the project,
+  // undefined for a qualifier that is none of the file's imports as indexed.
+  let pkgDir: string | null | undefined;
+  let bare = false;
+  if (dot >= 0) {
+    pkgDir = goImportPackageDir(ref.referenceName.slice(0, dot), ref.filePath, context);
+  } else {
+    const { written, imported } = goRefQualification(ref, context);
+    bare = written === undefined;
+    if (bare) pkgDir = goPackageDir(ref.filePath);
+    else if (imported) pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath) ?? null;
+  }
+  if (isType && (!bare || goPackageDir(target.filePath) === pkgDir)) return result;
+  const types = pkgDir ? goPackageTypes(name, pkgDir, context) : [];
+  if (types.length > 0) return { ...result, targetNodeId: preferCallSiteFile(types, ref.filePath)[0]!.id };
+  return isType ? result : null;
+}
+
+/**
+ * Whether a Go reference is written through an imported package from outside
+ * the project's modules — `context.Context`, `fmt.Errorf`, a third-party
+ * `gin.H` — or is a call on a variable declared as such a package's type:
+ * kubernetes' `clock.Now()` on a parameter `clock clock.PassiveClock`.
+ */
+function isGoExternalQualified(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const { imported, typePackage } = goRefQualification(ref, context);
+  const pkg = imported ?? typePackage;
+  if (!pkg) return false;
+  return !(pkg.source.startsWith('.') || pkg.source.includes('/internal/') ||
+    context.getGoPackageDir?.(pkg.source, ref.filePath) != null);
+}
+
+/**
+ * Whether `candidate` lives in the project package a Go reference is written
+ * through, when it is one: `store.Manager` names the `Manager` of the
+ * directory the `store` import maps to, never a same-named symbol of another
+ * package (#2322).
+ */
+function isInGoQualifierPackage(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  // A package never holds a method: a call or method value landing on one is
+  // made through a variable that shadows the import — prometheus's
+  // `labels := &maxHeap{}`, then `labels.get()`.
+  if (candidate.kind === 'method' && (ref.referenceKind === 'calls' || ref.referenceKind === 'function_ref')) return true;
+  const imported = goRefQualifier(ref, context);
+  if (!imported) return true;
+  const pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath);
+  return pkgDir == null || goPackageDir(candidate.filePath) === pkgDir;
+}
+
+/**
+ * A Go file's blocks and the names its functions declare: the receivers,
+ * parameters and results of every `func` with a body, and each name a `:=`,
+ * `var` or `const` declares.
+ */
+interface GoScopeIndex {
+  /** The source, comments and string contents blanked, offsets kept. */
+  code: string;
+  lineStarts: number[];
+  /** Offsets of every `{` and `}`, with the innermost block open after each. */
+  events: number[];
+  open: number[];
+  close: Map<number, number>;
+  decls: Map<string, GoDecl[]>;
+  /** Where each declared name is bound, read on demand: [start, end, declaration]. */
+  scopes: Map<string, Array<[number, number, GoDecl]>>;
+}
+
+interface GoDecl {
+  /** Offset of the declared name. */
+  at: number;
+  /**
+   * A statement's local, an `if` / `for` / `switch` header's, a `select`
+   * case's, or a parameter of the function whose body opens at `body`.
+   */
+  kind: 'local' | 'header' | 'case' | 'param';
+  body?: number;
+  /** The declared type as written, when the declaration writes one. */
+  type?: string;
+  /** The package a `:=` takes its value from: `clocktesting` in `clock := clocktesting.NewFakeClock(…)`. */
+  from?: string;
+}
+
+const GO_SCOPE_INDEXES = new WeakMap<ResolutionContext, Map<string, GoScopeIndex | null>>();
+const GO_TYPE_KEYWORDS: ReadonlySet<string> = new Set(['chan', 'func', 'interface', 'map', 'struct']);
+
+/**
+ * The parameter or local of the Go function around `ref` that `name` is
+ * there, if one is. Go gives an identifier the innermost block that declares
+ * it, from the end of its declaration on: a header's names live in its
+ * statement's blocks (`else` included), a `select` case's in its clause, a
+ * parameter in its function's body.
+ */
+function goLocalDecl(name: string, ref: UnresolvedRef, context: ResolutionContext): GoDecl | undefined {
+  const index = goScopeIndex(ref.filePath, context);
+  if (!index?.decls.has(name)) return undefined;
+  const at = (index.lineStarts[ref.line - 1] ?? index.code.length) + Math.max(0, ref.column);
+  let found: [number, number, GoDecl] | undefined;
+  for (const scope of goScopesOf(index, name)) {
+    if (at > scope[0] && at < scope[1] && (!found || scope[0] > found[0])) found = scope;
+  }
+  return found?.[2];
+}
+
+function goScopeIndex(filePath: string, context: ResolutionContext): GoScopeIndex | null {
+  let memo = GO_SCOPE_INDEXES.get(context);
+  if (!memo) GO_SCOPE_INDEXES.set(context, (memo = new Map()));
+  const hit = memo.get(filePath);
+  if (hit !== undefined) return hit;
+  const lines = context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/);
+  const index = lines ? readGoScopes(blankGoCode(lines.join('\n'))) : null;
+  // Refs arrive file by file; a few files' worth is all a pass revisits.
+  if (memo.size >= 64) memo.delete(memo.keys().next().value!);
+  memo.set(filePath, index);
+  return index;
+}
+
+function isGoIdentChar(c: number): boolean {
+  return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+}
+
+function readGoScopes(code: string): GoScopeIndex {
+  const lineStarts = [0];
+  for (let i = code.indexOf('\n'); i >= 0; i = code.indexOf('\n', i + 1)) lineStarts.push(i + 1);
+  const events: number[] = [];
+  const open: number[] = [];
+  const close = new Map<number, number>();
+  const stack: number[] = [];
+  const braces = /[{}]/g;
+  for (let m = braces.exec(code); m; m = braces.exec(code)) {
+    const i = m.index;
+    if (code.charCodeAt(i) === 123) stack.push(i);
+    else {
+      const at = stack.pop();
+      if (at !== undefined) close.set(at, i);
+    }
+    events.push(i);
+    open.push(stack.length > 0 ? stack[stack.length - 1]! : -1);
+  }
+  const decls = new Map<string, GoDecl[]>();
+  const add = (name: string, decl: GoDecl): void => {
+    if (name === '_') return;
+    const list = decls.get(name);
+    if (list) list.push(decl);
+    else decls.set(name, [decl]);
+  };
+  // `a, b := …`: the identifiers before each `:=`.
+  for (let i = code.indexOf(':='); i >= 0; i = code.indexOf(':=', i + 2)) {
+    const names: Array<[string, number]> = [];
+    let p = i;
+    for (;;) {
+      while (p > 0 && (code[p - 1] === ' ' || code[p - 1] === '\t')) p--;
+      let s = p;
+      while (s > 0 && isGoIdentChar(code.charCodeAt(s - 1))) s--;
+      if (s === p || /\d/.test(code[s]!) || code[s - 1] === '.') break;
+      names.push([code.slice(s, p), s]);
+      p = s;
+      while (p > 0 && (code[p - 1] === ' ' || code[p - 1] === '\t')) p--;
+      if (code[p - 1] !== ',') break;
+      p--;
+    }
+    if (names.length === 0) continue;
+    const first = names[names.length - 1]![1];
+    const lead = code.slice(code.lastIndexOf('\n', first - 1) + 1, first);
+    const kind = /^\s*(?:\}\s*else\s+)?(?:if|for|switch)\b/.test(lead) ? 'header' : /^\s*case\b/.test(lead) ? 'case' : 'local';
+    // `x := &pkg.T{…}` writes the type it declares; `x := pkg.New(…)` the
+    // package its value comes from.
+    const rhs = code.slice(i + 2, i + 160);
+    const type = names.length === 1 ? /^[ \t]*&?[ \t]*([A-Za-z_]\w*\.[A-Za-z_]\w*)[ \t]*\{/.exec(rhs)?.[1] : undefined;
+    const from = /^[ \t]*&?[ \t]*([A-Za-z_]\w*)\.[A-Za-z_]\w*[ \t]*[({]/.exec(rhs)?.[1];
+    for (const [name, at] of names) add(name, { at, kind, type, from });
+  }
+  // `var x T`, `var a, b = …`, `const (…)`: names before a type, an `=` or
+  // the line's end — in a group, on lines outside the brackets of a value
+  // spanning several (`http.MethodHead,` in a `[]string{…}` is no name).
+  const spec = /[ \t]*([A-Za-z_]\w*(?:[ \t]*,[ \t]*[A-Za-z_]\w*)*)(?=[ \t]*(?:\n|$|=(?!=))|[ \t]+(?:[*[A-Za-z_(]|<-))/y;
+  const addSpec = (at: number): void => {
+    spec.lastIndex = at;
+    const s = spec.exec(code);
+    if (!s) return;
+    const type = /^[ \t]+([^\s=;][^=;\n]*?)[ \t]*(?:[=;\n]|$)/.exec(code.slice(at + s[0].length, at + s[0].length + 160))?.[1];
+    let p = at + s[0].length - s[1]!.length;
+    for (const part of s[1]!.split(',')) {
+      const name = part.trim();
+      add(name, { at: p + part.indexOf(name), kind: 'local', type });
+      p += part.length + 1;
+    }
+  };
+  for (const m of code.matchAll(/(?<![\w.])(?:var|const)\b[ \t]*/g)) {
+    const start = m.index! + m[0].length;
+    if (code[start] !== '(') { addSpec(start); continue; }
+    const end = goClosing(code, start);
+    addSpec(start + 1);
+    let depth = 0;
+    for (let i = start + 1; i < end; i++) {
+      const c = code[i];
+      if (c === '(' || c === '[' || c === '{') depth++;
+      else if (c === ')' || c === ']' || c === '}') depth--;
+      else if (c === '\n' && depth === 0) addSpec(i + 1);
+    }
+  }
+  // Each `func`'s receiver, parameters and results, bound in its body. A
+  // `[]func(…)` or `chan func(…)` is a type, whatever brace follows it.
+  for (const m of code.matchAll(/(?<![\w.])func\b/g)) {
+    if (/(?:\]|\bchan)[ \t]*$/.test(code.slice(Math.max(0, m.index! - 8), m.index!))) continue;
+    const sig = goSignature(code, m.index! + 4);
+    if (!sig) continue;
+    for (const [from, to] of sig.groups) {
+      for (const [name, at, type] of goParamNames(code, from, to)) add(name, { at, kind: 'param', body: sig.body, type });
+    }
+  }
+  return { code, lineStarts, events, open, close, decls, scopes: new Map() };
+}
+
+/** The offset of the bracket closing the one at `at`, or the end of `code`. */
+function goClosing(code: string, at: number): number {
+  let depth = 0;
+  for (let i = at; i < code.length; i++) {
+    const c = code[i];
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if ((c === ')' || c === ']' || c === '}') && --depth === 0) return i;
+  }
+  return code.length;
+}
+
+/**
+ * The parameter lists of the `func` whose keyword ends at `at` — receiver,
+ * parameters, results — as the offsets inside their parentheses, and the
+ * offset of its body's `{`. Null for a function type, which has no body.
+ */
+function goSignature(code: string, at: number): { groups: Array<[number, number]>; body: number } | null {
+  const groups: Array<[number, number]> = [];
+  let p = at;
+  const skip = (): void => { while (code[p] === ' ' || code[p] === '\t') p++; };
+  const group = (): boolean => {
+    if (code[p] !== '(') return false;
+    const end = goClosing(code, p);
+    groups.push([p + 1, end]);
+    p = end + 1;
+    skip();
+    return true;
+  };
+  // `func Name[T any](…)`, `func (r T) Name(…)`, or a literal / type `func(…)`.
+  const name = (): boolean => {
+    const m = /^[A-Za-z_]\w*/.exec(code.slice(p, p + 128));
+    if (!m || GO_TYPE_KEYWORDS.has(m[0])) return false;
+    let q = p + m[0].length;
+    while (code[q] === ' ' || code[q] === '\t') q++;
+    if (code[q] === '[') q = goClosing(code, q) + 1;
+    while (code[q] === ' ' || code[q] === '\t') q++;
+    if (code[q] !== '(') return false;
+    p = q;
+    return true;
+  };
+  skip();
+  if (code[p] !== '(') {
+    if (!name() || !group()) return null;
+  } else {
+    group();
+    if (name() && !group()) return null;
+  }
+  if (code[p] === '(') group();
+  // A result type up to the body; a function type ends at a `,`, `)`, `}`,
+  // `=`, `;` or the line's end instead.
+  let depth = 0;
+  for (; p < code.length; p++) {
+    const c = code[p];
+    if (c === '(' || c === '[') depth++;
+    else if (c === ')' || c === ']') { if (--depth < 0) return null; }
+    else if (c === '{') {
+      if (depth > 0) continue;
+      // `struct{…}` / `interface{…}` is the result type's own brace.
+      if (/(?:struct|interface)\s*$/.test(code.slice(Math.max(0, p - 12), p))) { p = goClosing(code, p); continue; }
+      return { groups, body: p };
+    } else if (depth === 0 && (c === '\n' || c === ',' || c === ';' || c === '=' || c === '}')) return null;
+  }
+  return null;
+}
+
+/**
+ * The names a Go parameter list between `from` and `to` declares, with the
+ * type each is declared as: `(a, b int, c string)` declares a and b as `int`
+ * and c as `string`; `(int, pkg.T)` and `(*T, ...U)` declare none.
+ */
+function goParamNames(code: string, from: number, to: number): Array<[string, number, string]> {
+  const parts: Array<[number, number]> = [];
+  let depth = 0;
+  let start = from;
+  for (let i = from; i < to; i++) {
+    const c = code[i];
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    else if (c === ',' && depth === 0) { parts.push([start, i]); start = i + 1; }
+  }
+  parts.push([start, to]);
+  const names: Array<[string, number, string]> = [];
+  let grouped: Array<[string, number]> = [];
+  for (const [s, e] of parts) {
+    const text = code.slice(s, e);
+    const m = /^\s*([A-Za-z_]\w*)/.exec(text);
+    if (!m || GO_TYPE_KEYWORDS.has(m[1]!)) continue;
+    const rest = text.slice(m[0].length);
+    // `pkg.T` is a type; a variadic `args ...T` is a name.
+    if (/^\s*\.(?!\.\.)/.test(rest)) continue;
+    const at = s + m[0].length - m[1]!.length;
+    if (/^\s*$/.test(rest)) { grouped.push([m[1]!, at]); continue; }
+    // `a, b int`: the names before a typed one share its type.
+    const type = rest.trim();
+    for (const [name, nameAt] of grouped) names.push([name, nameAt, type]);
+    grouped = [];
+    names.push([m[1]!, at, type]);
+  }
+  // A list with no typed name names no parameters: its lone identifiers are types.
+  return names;
+}
+
+/** The innermost `{…}` holding an offset, as [open, close] — null outside every block. */
+function goBlockAt(index: GoScopeIndex, offset: number): [number, number] | null {
+  let lo = 0;
+  let hi = index.events.length - 1;
+  let at = -1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (index.events[mid]! < offset) { at = mid; lo = mid + 1; } else hi = mid - 1;
+  }
+  const open = at < 0 ? -1 : index.open[at]!;
+  return open < 0 ? null : [open, index.close.get(open) ?? index.code.length];
+}
+
+/** Where the statement declaring at `at` ends: its line's end, or a `;`, outside brackets. */
+function goStatementEnd(code: string, at: number): number {
+  let depth = 0;
+  for (let i = at; i < code.length; i++) {
+    const c = code[i];
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') { if (--depth < 0) return i; }
+    else if ((c === '\n' || c === ';') && depth === 0) return i;
+  }
+  return code.length;
+}
+
+/**
+ * The blocks of the `if` / `for` / `switch` statement whose header declares
+ * at `at`: gofmt ends a header's line with its block's `{` (a composite
+ * literal's in the header has more on its line), and an `else` chain keeps
+ * the header's names.
+ */
+function goHeaderBlocks(index: GoScopeIndex, at: number): Array<[number, number]> {
+  const code = index.code;
+  const blocks: Array<[number, number]> = [];
+  let depth = 0;
+  for (let i = at; i < code.length; i++) {
+    const c = code[i];
+    if (c === '(' || c === '[') depth++;
+    else if (c === ')' || c === ']') depth--;
+    else if (c === '}') break;
+    else if (c === '{') {
+      const end = index.close.get(i) ?? code.length;
+      if (depth !== 0 || !/^[ \t]*(?:\n|$)/.test(code.slice(i + 1, i + 80))) { i = end; continue; }
+      blocks.push([i, end]);
+      const chained = /^[ \t]*else\b[ \t]*/.exec(code.slice(end + 1, end + 40));
+      if (!chained) break;
+      i = end + chained[0].length;
+      depth = 0;
+    }
+  }
+  return blocks;
+}
+
+function goScopesOf(index: GoScopeIndex, name: string): Array<[number, number, GoDecl]> {
+  const hit = index.scopes.get(name);
+  if (hit) return hit;
+  const scopes: Array<[number, number, GoDecl]> = [];
+  for (const d of index.decls.get(name) ?? []) {
+    if (d.kind === 'param') {
+      scopes.push([d.body!, index.close.get(d.body!) ?? index.code.length, d]);
+      continue;
+    }
+    // Outside every block it is a package-level name, which no import shares.
+    const block = goBlockAt(index, d.at);
+    if (!block) continue;
+    if (d.kind === 'header') {
+      for (const [start, end] of goHeaderBlocks(index, d.at)) scopes.push([start, end, d]);
+      continue;
+    }
+    const from = goStatementEnd(index.code, d.at);
+    let to = block[1];
+    if (d.kind === 'case') {
+      const clause = /\n[ \t]*(?:case\b|default[ \t]*:)/g;
+      clause.lastIndex = from;
+      for (let m = clause.exec(index.code); m && m.index < to; m = clause.exec(index.code)) {
+        if (goBlockAt(index, m.index + 1)?.[0] === block[0]) { to = m.index; break; }
+      }
+    }
+    if (from < to) scopes.push([from, to, d]);
+  }
+  index.scopes.set(name, scopes);
+  return scopes;
+}
+
+/**
+ * Go source with its comments and the contents of its strings and runes
+ * blanked: offsets and newlines stay, so a regex match still maps to its
+ * line and column.
+ */
+function blankGoCode(src: string): string {
+  const parts: string[] = [];
+  let last = 0;
+  const blank = (from: number, to: number): void => {
+    parts.push(src.slice(last, from));
+    const newline = src.indexOf('\n', from);
+    parts.push(newline < 0 || newline >= to ? ' '.repeat(to - from) : src.slice(from, to).replace(/[^\n]/g, ' '));
+    last = to;
+  };
+  const special = /[/"'`]/g;
+  for (let m = special.exec(src); m; m = special.exec(src)) {
+    const i = m.index;
+    const c = src.charCodeAt(i);
+    if (c === 47) {
+      const d = src.charCodeAt(i + 1);
+      if (d === 47) { // `//`
+        const end = src.indexOf('\n', i);
+        blank(i, end < 0 ? src.length : end);
+      } else if (d === 42) { // `/*`
+        const end = src.indexOf('*/', i + 2);
+        blank(i, end < 0 ? src.length : end + 2);
+      } else continue;
+      special.lastIndex = last;
+    } else if (c === 96) { // a raw string
+      const end = src.indexOf('`', i + 1);
+      blank(i + 1, end < 0 ? src.length : end);
+      special.lastIndex = last + 1;
+    } else { // "…" or '…'
+      let j = i + 1;
+      while (j < src.length) {
+        const d = src.charCodeAt(j);
+        if (d === 92) { j += 2; continue; }
+        if (d === c || d === 10) break;
+        j++;
+      }
+      blank(i + 1, Math.min(j, src.length));
+      special.lastIndex = last + 1;
+    }
+  }
+  parts.push(src.slice(last));
+  return parts.join('');
+}
+
+const PHP_CLASS_KINDS: ReadonlySet<string> = new Set(['class', 'interface', 'trait', 'enum']);
+/**
+ * Whether a bare PHP class name at `ref` can mean `candidate`. An unqualified
+ * class name is the current namespace's class or the one a `use` imports —
+ * PHP never falls back to another namespace for classes. koel's `extends
+ * Request` (under `use Saloon\Http\Request;`, `use App\Http\Requests\API\Request;`,
+ * or in `App\Http\Requests\API` itself) all went to the first `Request` indexed.
+ */
+function isPhpClassVisible(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.language !== 'php' || candidate.language !== 'php' || !PHP_CLASS_KINDS.has(candidate.kind)) return true;
+  const name = ref.referenceName;
+  if (!/^[A-Za-z_]\w*$/.test(name) || /^(?:self|static|parent)$/i.test(name)) return true;
+  const fqn = candidate.qualifiedName.replace(/::/g, '\\');
+  const scope = phpFileScope(ref.filePath, context);
+  const imported = scope.uses.get(name);
+  if (imported !== undefined) return imported.toLowerCase() === fqn.toLowerCase();
+  return fqn.toLowerCase() === (scope.namespace ? `${scope.namespace}\\${name}` : name).toLowerCase();
+}
+
+const JAVA_TYPE_KINDS_VISIBLE: ReadonlySet<string> = new Set(['class', 'interface', 'enum', 'record', 'annotation']);
+const JAVA_FILE_SCOPES = new WeakMap<ResolutionContext, Map<string, { pkg: string; single: Set<string>; demand: Set<string> }>>();
+const JAVA_ANCESTORS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/** A Java file's package, its single-type imports and its on-demand (`.*`) imports, static ones included. */
+function javaFileScope(file: string, context: ResolutionContext): { pkg: string; single: Set<string>; demand: Set<string> } {
+  let memo = JAVA_FILE_SCOPES.get(context);
+  if (!memo) JAVA_FILE_SCOPES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const text = stripCommentsForRegex(context.readFile(file) ?? '', 'java');
+  const pkg = /^\s*package\s+([\w.]+)\s*;/m.exec(text)?.[1] ?? '';
+  const single = new Set<string>();
+  const demand = new Set<string>();
+  for (const m of text.matchAll(/^\s*import\s+(?:static\s+)?([\w.]+?)(\.\*)?\s*;/gm)) (m[2] ? demand : single).add(m[1]!);
+  const scope = { pkg, single, demand };
+  memo.set(file, scope);
+  return scope;
+}
+
+/** The simple names of the Java types `qn` extends or implements, a few levels up. */
+function javaAncestorNames(qn: string, context: ResolutionContext, depth = 0): Set<string> {
+  let memo = JAVA_ANCESTORS.get(context);
+  if (!memo) JAVA_ANCESTORS.set(context, (memo = new Map()));
+  const hit = memo.get(qn);
+  if (hit) return hit;
+  const names = new Set<string>();
+  memo.set(qn, names);
+  for (const decl of context.getNodesByQualifiedName(qn)) {
+    if (decl.language !== 'java' || !JAVA_TYPE_KINDS_VISIBLE.has(decl.kind)) continue;
+    const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+    let header = '';
+    for (let i = decl.startLine - 1; i < Math.min(lines.length, decl.startLine + 6) && !header.includes('{'); i++) header += `${lines[i] ?? ''} `;
+    const list = /\b(?:extends|implements)\b([^{]*)/.exec(header.split('{')[0]!)?.[1] ?? '';
+    for (const m of list.replace(/<[^<>]*(?:<[^<>]*>[^<>]*)*>/g, '').matchAll(/([A-Za-z_]\w*)\s*(?=,|$|\bimplements\b|\s*$)/g)) {
+      if (m[1] !== 'implements' && m[1] !== 'extends') names.add(m[1]!);
+    }
+  }
+  if (depth < 4) {
+    for (const base of [...names]) {
+      for (const t of context.getNodesByName(base)) {
+        if (t.language !== 'java' || !JAVA_TYPE_KINDS_VISIBLE.has(t.kind) || t.qualifiedName === qn) continue;
+        for (const up of javaAncestorNames(t.qualifiedName, context, depth + 1)) names.add(up);
+      }
+    }
+  }
+  return names;
+}
+
+/**
+ * Whether a bare Java type name at `ref` can mean `candidate`. A top-level type
+ * is in reach from its own package and through a single-type or on-demand
+ * import; a nested type from inside its owner (or a type deriving from it) or
+ * through an import of it or of its owner's members. halo's `Context`,
+ * retrofit's `Builder`, jsoup's `Attribute` (meant: `Evaluator.Attribute`)
+ * reached a same-named type nothing imported.
+ */
+function isJavaTypeVisible(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.language !== 'java' || candidate.language !== 'java') return true;
+  if (!/^[A-Za-z_$][\w$]*$/.test(ref.referenceName)) return true;
+  // A constructor is in reach where its type is: lombok's `@Builder` and
+  // okhttp's `new OkHttpClient.Builder()` are no project `Builder`'s constructor.
+  if (candidate.kind === 'method') {
+    const segs = candidate.qualifiedName.split('::');
+    if (segs.length < 2 || segs[segs.length - 2] !== candidate.name || ref.referenceKind === 'calls') return true;
+    const owner = context.getNodesInFile(candidate.filePath).find((n) =>
+      n.qualifiedName === segs.slice(0, -1).join('::') && JAVA_TYPE_KINDS_VISIBLE.has(n.kind));
+    return !owner || isJavaTypeVisible(owner, ref, context);
+  }
+  // An enum constant by its bare name: inside its enum, a `case` label, a
+  // static import, or written through its enum — never `java.lang.Character`'s
+  // `Character.MIN_SUPPLEMENTARY_CODE_POINT` (jsoup's `TokenType.Character`).
+  if (candidate.kind === 'enum_member') {
+    if (candidate.filePath === ref.filePath) return true;
+    const segs = candidate.qualifiedName.split('::');
+    const enumName = segs[segs.length - 2] ?? '';
+    const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1] ?? '';
+    const name = ref.referenceName.replace(/\$/g, '\\$');
+    if (new RegExp(`\\bcase\\b[^:;]*\\b${name}\\b`).test(line) || new RegExp(`\\b${enumName}\\s*\\.\\s*${name}\\b`).test(line)) return true;
+    const here = javaFileScope(ref.filePath, context);
+    const enumFqn = [javaFileScope(candidate.filePath, context).pkg, ...segs.slice(1, -1)].filter((p) => p !== '').join('.');
+    return here.single.has(`${enumFqn}.${ref.referenceName}`) || here.demand.has(enumFqn);
+  }
+  if (!JAVA_TYPE_KINDS_VISIBLE.has(candidate.kind)) return true;
+  const segs = candidate.qualifiedName.split('::');
+  const candidateScope = javaFileScope(candidate.filePath, context);
+  // The QN leads with the package when there is one.
+  const typePath = candidateScope.pkg && segs[0] === candidateScope.pkg ? segs.slice(1) : segs;
+  const fqn = [candidateScope.pkg, ...typePath].filter((p) => p !== '').join('.');
+  const here = javaFileScope(ref.filePath, context);
+  // Written with a qualifier — `RequestFactory.Builder`, `java.util.Map`, an
+  // inner class's `outer.new Inner()` — the qualifier says which: the owner
+  // (or the package) of this candidate.
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1] ?? '';
+  if (new RegExp(`\\.\\s*new\\s+${ref.referenceName.replace(/\$/g, '\\$')}\\b`).test(line)) return true;
+  // (A type annotation may sit between them: jsoup's `Range.@Nullable Spans`.)
+  const qualifiers = [...line.matchAll(new RegExp(`([A-Za-z_$][\\w$.]*)\\s*\\.\\s*(?:@[\\w.]+(?:\\([^)]*\\))?\\s+)*${ref.referenceName.replace(/\$/g, '\\$')}\\b`, 'g'))].map((m) => m[1]!);
+  // Nested only inside a type the file declares; a class local to a method is
+  // the lexical rule's to judge.
+  const ownerQn = segs.slice(0, -1).join('::');
+  const ownerNode = segs.length > 1
+    ? context.getNodesInFile(candidate.filePath).find((n) => n.qualifiedName === ownerQn && n.kind !== 'namespace' && n.kind !== 'file')
+    : undefined;
+  if (ownerNode && !JAVA_TYPE_KINDS_VISIBLE.has(ownerNode.kind)) return true;
+  const nested = ownerNode !== undefined;
+  const ownerName = nested ? ownerNode.name : '';
+  if (qualifiers.some((q) => (nested && (q === ownerName || q.endsWith(`.${ownerName}`))) || (!nested && q === candidateScope.pkg))) return true;
+  if (!nested) {
+    if (candidate.filePath === ref.filePath || candidateScope.pkg === here.pkg) return true;
+    return here.single.has(fqn) || here.demand.has(candidateScope.pkg);
+  }
+  // Nested: inside its owner, a subtype of it, or imported.
+  const enclosing = context.getNodesInFile(ref.filePath)
+    .filter((p) => JAVA_TYPE_KINDS_VISIBLE.has(p.kind) && p.startLine <= ref.line && p.endLine >= ref.line);
+  if (enclosing.some((p) => p.qualifiedName === ownerQn || p.qualifiedName.startsWith(`${ownerQn}::`))) return true;
+  // An anonymous class (`new NodeFilter() { … }`, named `<NodeFilter$anon@N>`) derives from what it instantiates.
+  const supertypesAround = (p: Node): string[] => {
+    const anon = /<([A-Za-z_$][\w$]*)\$anon@\d+>$/.exec(p.name)?.[1] ?? /<([A-Za-z_$][\w$]*)\$anon@\d+>/.exec(p.qualifiedName.split('::').pop() ?? '')?.[1];
+    if (!anon) return [...javaAncestorNames(p.qualifiedName, context)];
+    const ups = [anon];
+    for (const t of context.getNodesByName(anon)) if (t.language === 'java' && JAVA_TYPE_KINDS_VISIBLE.has(t.kind)) ups.push(...javaAncestorNames(t.qualifiedName, context));
+    return ups;
+  };
+  if (enclosing.some((p) => supertypesAround(p).includes(ownerName))) return true;
+  const ownerFqn = fqn.slice(0, fqn.lastIndexOf('.'));
+  return here.single.has(fqn) || here.demand.has(ownerFqn);
+}
+
+const SCALA_OBJECT_PACKAGES = new WeakMap<ResolutionContext, Map<string, string | null>>();
+
+/** The full package a Scala file's `package object X` opens (`algebra`, `cats.syntax`), or null for none. */
+function scalaPackageObjectPackage(file: string, context: ResolutionContext): string | null {
+  let memo = SCALA_OBJECT_PACKAGES.get(context);
+  if (!memo) SCALA_OBJECT_PACKAGES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit !== undefined) return hit;
+  const text = context.readFile(file) ?? '';
+  const object = /^\s*package\s+object\s+([\w$]+)/m.exec(text)?.[1];
+  const pkg = object ? [...scalaPackageClauses(text), object].join('.') : null;
+  memo.set(file, pkg);
+  return pkg;
+}
+
+/** A Scala file's package clauses, in order (`package cats` / `package laws` → cats, laws). */
+function scalaPackageClauses(text: string): string[] {
+  return [...text.matchAll(/^\s*package\s+(?!object\b)([\w.]+)\s*$/gm)].flatMap((m) => m[1]!.split('.'));
+}
+
+/**
+ * Whether a member of a Scala package object is in scope at `ref`: from its
+ * package and the packages under it, or from a file that imports something
+ * through the package (`import algebra._`, `import algebra.Eq`).
+ */
+function isScalaPackageObjectMemberVisible(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const objectPkg = scalaPackageObjectPackage(candidate.filePath, context);
+  if (objectPkg === null) return true;
+  const text = context.readFile(ref.filePath) ?? '';
+  const here = scalaPackageClauses(text).join('.');
+  if (here === objectPkg || here.startsWith(`${objectPkg}.`)) return true;
+  const last = objectPkg.split('.').pop()!;
+  return new RegExp(`^\\s*import\\s+[^\\n]*\\b${last.replace(/\$/g, '\\$')}\\b`, 'm').test(text);
+}
+
+const SFC_SCRIPT_RANGES = new WeakMap<ResolutionContext, Map<string, Array<{ start: number; end: number; exported: boolean }>>>();
+
+/**
+ * Whether a declaration in a `.svelte` / `.vue` file is the component's own:
+ * anything but the component itself, unless it sits in a block that can export
+ * — Svelte's `<script module>` (`context="module"`), or a Vue `<script>` that
+ * is not `setup` — or is a type a Vue `<script setup>` exports.
+ */
+function isSfcPrivate(n: Node, context: ResolutionContext): boolean {
+  const svelte = n.filePath.endsWith('.svelte');
+  if ((!svelte && !n.filePath.endsWith('.vue')) || n.kind === 'component' || n.kind === 'file') return false;
+  let memo = SFC_SCRIPT_RANGES.get(context);
+  if (!memo) SFC_SCRIPT_RANGES.set(context, (memo = new Map()));
+  let ranges = memo.get(n.filePath);
+  if (!ranges) {
+    ranges = [];
+    const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+    let open: { start: number; exported: boolean } | null = null;
+    lines.forEach((text, i) => {
+      const tag = /<script\b([^>]*)>/i.exec(text);
+      if (tag && !open) {
+        const attrs = tag[1] ?? '';
+        open = { start: i + 1, exported: svelte ? /\bmodule\b|context\s*=\s*["']module["']/.test(attrs) : !/\bsetup\b/.test(attrs) };
+      }
+      if (open && /<\/script\s*>/i.test(text)) {
+        ranges!.push({ ...open, end: i + 1 });
+        open = null;
+      }
+    });
+    memo.set(n.filePath, ranges);
+  }
+  const block = ranges.find((r) => n.startLine >= r.start && n.startLine <= r.end);
+  if (block?.exported) return false;
+  // Vue hoists the types `<script setup>` exports: mealie imports CrudTable.vue's `TableConfig`.
+  if (!svelte && block) {
+    const line = context.getFileLines?.(n.filePath)?.[n.startLine - 1] ?? context.readFile(n.filePath)?.split(/\r?\n/)[n.startLine - 1] ?? '';
+    if (/^\s*export\s+(?:declare\s+)?(?:interface|type|enum)\b/.test(line)) return false;
+  }
+  return true;
+}
+
+/**
+ * Whether `candidate` can be NAMED from a reference in `ref`'s file at all,
+ * given what its language says about the definition's visibility. A
+ * definition the language makes file-local is not a candidate for a
+ * cross-file name match, however well the names agree:
+ *
+ * - **C / C++**: a `static` function defined in a SOURCE file is local to
+ *   that translation unit; one in a header is part of every unit that
+ *   includes it and stays visible. On a 2,109-file betaflight tree 145
  *   cross-file calls resolved onto a `static` in another `.c` (#1730) —
  *   `usbd_get_descriptor` onto the `static get_device_descriptor` of
  *   whichever USB class file ranked first.
@@ -876,7 +2746,43 @@ function rustModuleDir(filePath: string): string {
  * checks its own survivor as well, since nothing runs after it.
  */
 export function isVisibleAcrossFiles(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  // Go's `context.Context`, `http.Handler`: written through a package from
+  // outside the module, so nothing in it — not even the same file's method
+  // `Stream.Context` (fiber's 85 `context.Context` parameters went there).
+  // Through one of the project's packages, only that package's symbol: a
+  // `job.OPCommand` result type is not the method `Context.OPCommand`.
+  if (ref.language === 'go' && candidate.language === 'go' &&
+      (isGoExternalQualified(ref, context) || !isInGoQualifierPackage(candidate, ref, context))) return false;
   if (candidate.filePath === ref.filePath) return true;
+  // A vendored minified bundle's names are mangled: healthchecks' 369 `$(…)`
+  // (jQuery, a global) went to a one-letter helper inside bootstrap-native.min.js.
+  if (isMinifiedScript(candidate.filePath, context)) return false;
+  // A test suite is not linked into the program: typeorm's `Record<K, V>` is
+  // not a test entity `Record`, tokio's `Output` not a `runtime/tests` type.
+  // A C or C++ file the reference's translation unit includes is, whatever
+  // its name.
+  if (isTestSuitePath(candidate.filePath) && !isTestPath(ref.filePath) && !isIncludedCppTestSuite(candidate, ref, context)) return false;
+  // A Svelte component's instance script, or a Vue SFC's `<script setup>`, is
+  // private to the component: shadcn-svelte's 838 `<Item.Root>` (a namespace
+  // import) went to a `type Item` one example component declares for itself.
+  if (isSfcPrivate(candidate, context)) return false;
+  // A bare PHP class name is its namespace's class, or the one a `use` names.
+  if (!isPhpClassVisible(candidate, ref, context)) return false;
+  // A bare Java type name is its package's, an import's, or a nested type in reach.
+  if (!isJavaTypeVisible(candidate, ref, context)) return false;
+  // A Dart `extension on Token { … }` has no name: `Token` is analyzer's type,
+  // not bloc_lint's extension block (84 refs went there).
+  if (dartExtensionDecl(candidate, context)?.named === false) return false;
+  // And it applies only in its own library: flutter_test's `find.text(…)` is
+  // no other file's `extension on TaskStatus { String get text }`.
+  if (isDartUnnamedExtensionMember(candidate, context) && !inSameDartLibrary(ref.filePath, candidate.filePath, context)) return false;
+  // A Scala package object's member is in scope in its package and those under
+  // it, or through an import: cats.laws' `Eq` is the `cats` package object's
+  // alias, not the `algebra` one's (752 refs went there).
+  if (candidate.language === 'scala' && ref.language === 'scala' && !isScalaPackageObjectMemberVisible(candidate, ref, context)) return false;
+  if (candidate.language === 'csharp' && ref.language === 'csharp' && CSHARP_TYPE_KINDS.has(candidate.kind) &&
+      /^[A-Za-z_]\w*$/.test(ref.referenceName) &&
+      (!isCsharpTypeVisible(candidate, ref, context) || !isCsharpNestedTypeInScope(candidate, ref, context))) return false;
   const lang = candidate.language as string;
   if (lang === 'c' || lang === 'cpp') {
     return (
@@ -897,13 +2803,35 @@ export function isVisibleAcrossFiles(candidate: Node, ref: UnresolvedRef, contex
     return ref.filePath.startsWith(owner + '/');
   }
   if (PRIVATE_IS_FILE_LOCAL.has(lang)) return candidate.visibility !== 'private';
+  // An R test file runs in an environment of its own (testthat): its top-level
+  // `c <- ggplot(…)` is not what the package's 2,843 `c(…)` calls mean. The
+  // `helper-*.R` / `setup-*.R` files are sourced for every test, so theirs are shared.
+  if (lang === 'r' && (candidate.kind === 'variable' || candidate.kind === 'constant') &&
+      /(?:^|\/)tests?\//.test(candidate.filePath) && !/(?:^|\/)(?:helper|setup)[^/]*\.[rR]$/.test(candidate.filePath)) return false;
+  // A Lua `local` belongs to its chunk: kong's spec helpers' `local it = it`
+  // took busted's `it(…)` in every other spec file, 4,166 times. Its module
+  // can still hand it out — `return { check = check_phase }` — to a file that
+  // names it through a `require` alias.
+  if ((lang === 'lua' || lang === 'luau') && isLuaLocal(candidate, context)) {
+    return ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName) &&
+      luaAliasTarget(ref, context)?.targetNodeId === candidate.id;
+  }
   // JS/TS/ArkTS sealed modules + markdown/JSON call-target guards (#1719).
   // Same predicate matchByExactName / matchFuzzy apply to their survivors so a
   // rejection here cannot fall through to a promoted runner-up.
   return isCrossFileReachable(candidate, ref, context);
 }
 
-const JS_FAMILY = new Set<string>(['typescript', 'tsx', 'javascript', 'jsx']);
+/**
+ * Languages whose calls are JS/TS calls — Vue, Svelte and Astro components'
+ * scripts and template expressions included: a bare `t('key')` in a `.vue`
+ * file resolves lexically exactly as in a `.ts` one.
+ */
+const JS_FAMILY = new Set<string>(['typescript', 'tsx', 'javascript', 'jsx', 'vue', 'svelte', 'astro']);
+const JS_TS = new Set<string>(['typescript', 'tsx', 'javascript', 'jsx']);
+
+/** Languages whose identifiers resolve regardless of case. */
+export const CASE_INSENSITIVE_LANGUAGES = new Set<string>(['php', 'pascal', 'cfml', 'cfscript', 'cfquery', 'cobol', 'vbnet']);
 
 /**
  * Whether a JS/TS `calls` ref is a RECEIVER-LESS call — `serialize(x)`, not
@@ -916,6 +2844,78 @@ const JS_FAMILY = new Set<string>(['typescript', 'tsx', 'javascript', 'jsx']);
  * enclosing method itself least of all, which the same-file proximity term
  * used to pick over the module-scope function the call actually means.
  */
+/**
+ * The receiver a call the extractor recorded by its bare name is written on,
+ * read from the source: TS/JS keeps `this.container.classList.toggle()` and
+ * `window.$events.listen()` bare, Scala `requestToArmeria(request).execute()`
+ * and `_.get.whenRequestMatchesPartial(…)`. `'self'` for `this.m()` /
+ * `self.m()` / `super.m()` / `super().m()`; null for a call written bare (or
+ * not found). `links` are the member names between `this` and the method.
+ */
+function bareCallReceiver(ref: UnresolvedRef, context: ResolutionContext): { receiver: string; links: string[] } | null {
+  if (ref.referenceKind !== 'calls' || !/^[A-Za-z_$][\w$]*$/.test(ref.referenceName)) return null;
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/);
+  if (!lines) return null;
+  const name = ref.referenceName.replace(/\$/g, '\\$');
+  const call = new RegExp(`(?<![\\w$])${name}\\s*(?:<[^<>()]*>|\\[(?:[^\\[\\]]|\\[[^\\[\\]]*\\])*\\])?\\s*[({]`);
+  // Search the ref's own line first: a minified bundle is one line, and
+  // joining it to the lines after it copied all of it for every call on it
+  // (about 1 MB a call on go-ethereum's graphiql.min.js). Every match starts
+  // with the name, so a match with no `name` before it on the line is where
+  // the joined lines match first too. Otherwise (no match, as for a call that
+  // continues on the next line, or the name earlier) the joined lines decide.
+  const span = lines.slice(ref.line - 1, ref.line + 7);
+  const from = Math.max(0, ref.column);
+  let text = span[0]?.slice(from) ?? '';
+  let at = call.exec(text);
+  if (!at || text.indexOf(ref.referenceName) < at.index) {
+    text = span.join('\n').slice(from);
+    at = call.exec(text);
+  }
+  if (!at) return null;
+  const before = text.slice(0, at.index).replace(/\s+$/, '');
+  if (!/\??\.$/.test(before)) return null;
+  const head = before.replace(/\??\.$/, '').replace(/\s+$/, '');
+  if (/(?:^|[^\w$.])(?:this|self|super|Self)$/.test(head) || /(?:^|[^\w$.])super\s*\([^()]*\)$/.test(head)) return { receiver: 'self', links: [] };
+  const chain = /(?:^|[^\w$.#])((?:this|super)(?:\s*\??\.\s*#?[\w$]+)+)$/.exec(head);
+  const links = chain ? chain[1]!.split('.').slice(1).map((l) => l.replace(/[\s?]/g, '')) : [];
+  return { receiver: head.slice(-40), links };
+}
+
+/**
+ * Whether a Python call recorded by its bare name was written on the instance,
+ * `self.get_ip(request)`. The extractor drops the `self.`, so a same-named name
+ * the file imports would otherwise claim the method call (#2074 follow-up).
+ */
+export function isPythonSelfCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return ref.language === 'python' && bareCallReceiver(ref, context)?.receiver === 'self';
+}
+
+/** Whether a call recorded by its bare name is written on something other than the caller's own object. */
+function isCollapsedNonRecursion(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const written = bareCallReceiver(ref, context);
+  if (!written || written.receiver === 'self') return false;
+  return !(JS_FAMILY.has(ref.language) && isCollapsedSelfRecursion({ root: 'this', links: written.links }, ref, context));
+}
+
+function isCollapsedSelfRecursion(chain: { root: string; links: string[] }, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (chain.root !== 'this' || chain.links.length !== 1 || chain.links[0]!.includes('(')) return false;
+  const field = chain.links[0]!.replace(/^#/, '');
+  const caller = context.getNodeById?.(ref.fromNodeId);
+  const cut = caller ? caller.qualifiedName.lastIndexOf('::') : -1;
+  if (!caller || cut <= 0) return false;
+  const owner = caller.qualifiedName.slice(0, cut).split('::').pop()!;
+  const cls = context.getNodesInFile(ref.filePath).find((n) =>
+    n.kind === 'class' && n.name === owner && n.startLine <= ref.line && n.endLine >= ref.line);
+  if (!cls) return false;
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/) ?? [];
+  const body = lines.slice(cls.startLine - 1, cls.endLine).join('\n');
+  const f = field.replace(/\$/g, '\\$');
+  const declared = new RegExp(`(?:^|[\\s(,])#?${f}\\s*[?!]?\\s*:\\s*([A-Za-z_$][\\w$]*)`, 'm').exec(body)?.[1] ??
+    new RegExp(`\\bthis\\.${f}\\s*=\\s*new\\s+([A-Za-z_$][\\w$]*)`).exec(body)?.[1];
+  return declared === owner;
+}
+
 function isBareJsCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
   return JS_FAMILY.has(ref.language) && isReceiverLessCall(ref, context);
 }
@@ -934,67 +2934,4473 @@ function isBareGoCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
 }
 
 /**
- * Whether a PHP `calls` ref is a bare function call — `redirect($url)`,
- * `view('books.show')` — rather than `$this->redirect()` / `$obj->view()` /
- * `Foo::view()`. PHP has no implicit `$this`: a call written without a
- * receiver can only be a function, so a method, field or property that shares
- * the name is never what it calls. Name-matching used to bind BookStack's
- * every `return redirect(…)` to ApiDocsController::redirect and every
- * `return view(…)` to a `$view` field.
- *
- * PHP refs record the column of the call EXPRESSION — `$this->setPageTitle(`
- * sits at `$this` — so a bare call is the one whose text at its column is the
- * name itself (a leading `\` for a fully qualified function is allowed).
+ * Whether a Go reference's name is written bare, so that Go reads it from the
+ * reference's own package: a type `Node` (variadic `...Node` too), a composite
+ * literal `&Event{}`, a route's handler `Index`, a call `Walk(v, n)` or a
+ * conversion `(*Block)(pb)`. Not `parser.Node` or `...chunks.Meta`, written
+ * through an import, nor a name reached through a value: `err[i].Error()`, a
+ * `.String()` chained onto the line above, a route's handler `h.Follow`.
+ */
+export function isGoBareName(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const name = ref.referenceName;
+  if (ref.language !== 'go' || !/^[A-Za-z_]\w*$/.test(name)) return false;
+  if (ref.referenceKind === 'calls' && isReceiverLessCall(ref, context)) return true;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
+    ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1];
+  if (line === undefined) return false;
+  // A call's column is its expression's: only a conversion's parenthesized
+  // type is still bare there.
+  if (ref.referenceKind === 'calls') {
+    return line[ref.column] === '(' && new RegExp(`^\\(\\s*\\*?\\s*${name}\\s*\\)\\s*\\(`).test(line.slice(ref.column));
+  }
+  if (line.startsWith(name, ref.column)) {
+    let end = ref.column;
+    while (end > 0 && WHITESPACE.test(line[end - 1]!)) end--;
+    return line[end - 1] !== '.' || (end >= 3 && line.slice(end - 3, end) === '...');
+  }
+  // A route's handler is recorded at the start of its line: its spelling
+  // there, outside the path string.
+  const code = line.replace(/"(?:[^"\\]|\\.)*"|`[^`]*`/g, (s) => ' '.repeat(s.length));
+  return new RegExp(`(?<![\\w.])${name}\\b`).test(code);
+}
+
+/**
+ * Whether an R call is a plain function call — `range(x)`, `vars(a)` — not a
+ * ggproto / R6 method through `obj$m(…)` or `self$m(…)`. A method is only
+ * reached through its object: ggplot2's `range(data$x)` (base R's) went to a
+ * Coord's `range` method.
+ */
+function isBareRCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.language !== 'r' || ref.referenceKind !== 'calls' || !/^[A-Za-z_.][\w.]*$/.test(ref.referenceName)) return false;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (!line) return false;
+  const m = new RegExp(`(?<![\\w.])${ref.referenceName.replace(/\./g, '\\.')}\\s*\\(`).exec(line);
+  return !!m && !/(?:\$|@|::)\s*$/.test(line.slice(0, m.index));
+}
+
+/**
+ * Whether a PHP `calls` ref is a bare function call — `redirect($url)`,
+ * `view('books.show')` — rather than `$this->redirect()` / `$obj->view()` /
+ * `Foo::view()`. PHP has no implicit `$this`: a call written without a
+ * receiver can only be a function, so a method, field or property that shares
+ * the name is never what it calls. Name-matching used to bind BookStack's
+ * every `return redirect(…)` to ApiDocsController::redirect and every
+ * `return view(…)` to a `$view` field.
+ *
+ * PHP refs record the column of the call EXPRESSION — `$this->setPageTitle(`
+ * sits at `$this` — so a bare call is the one whose text at its column is the
+ * name itself (a leading `\` for a fully qualified function is allowed).
+ */
+function isBarePhpCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.language !== 'php' || ref.referenceKind !== 'calls') return false;
+  if (!/^\w+$/.test(ref.referenceName)) return false;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
+    ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return false;
+  const at = line[ref.column] === '\\' ? ref.column + 1 : ref.column;
+  if (!line.startsWith(ref.referenceName, at)) return false;
+  CALL_OPENER.lastIndex = at + ref.referenceName.length;
+  if (!CALL_OPENER.test(line)) return false;
+  let end = at;
+  while (end > 0 && WHITESPACE.test(line[end - 1]!)) end--;
+  // `$obj->name(` / `Foo::name(` / `$obj?->name(`, should a column ever land on
+  // the name — but not `'size' => filesize($zip)` or `$x ? a : name()`.
+  return !(end > 1 && ((line[end - 1] === '>' && line[end - 2] === '-') || (line[end - 1] === ':' && line[end - 2] === ':')));
+}
+
+function isReceiverLessCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.referenceKind !== 'calls') return false;
+  if (ref.referenceName.includes('.')) return false;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
+    ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return false;
+  // `^<name>\s*[(<]` at the call's column, without compiling a pattern per call.
+  if (!line.startsWith(ref.referenceName, ref.column)) return false;
+  CALL_OPENER.lastIndex = ref.column + ref.referenceName.length;
+  if (!CALL_OPENER.test(line)) return false;
+  // Nothing but whitespace, an operator or an opener may precede a bare call:
+  // read the text before the column backwards, past trailing whitespace,
+  // instead of end-anchoring a pattern that scans the prefix from its start.
+  let end = Math.min(ref.column, line.length);
+  while (end > 0 && WHITESPACE.test(line[end - 1]!)) end--;
+  if (end === 0 || !RECEIVER_TAIL_CHAR.test(line[end - 1]!)) return true;
+  let start = end;
+  while (start > 0 && WORD_CHAR.test(line[start - 1]!)) start--;
+  return BARE_CALL_KEYWORDS.has(line.slice(start, end));
+}
+
+/** `\s*[(<]` from a given index (sticky) — an optional call's `?.(` too. */
+const CALL_OPENER = /\s*(?:\?\.\s*)?[(<]/y;
+const WHITESPACE = /\s/;
+const WORD_CHAR = /\w/;
+/** A character that ends a receiver: `.`, a word character, `$`, `]` or `)`. */
+const RECEIVER_TAIL_CHAR = /[.\w$\])]/;
+/**
+ * Keywords after which a name starts an expression, so the call has no
+ * receiver — Go's `if Type(b) != Series`, `switch dirType(name)` included.
+ */
+const BARE_CALL_KEYWORDS: ReadonlySet<string> = new Set([
+  'return', 'await', 'yield', 'typeof', 'void', 'new', 'else', 'case', 'throw', 'in', 'of', 'instanceof', 'go', 'defer',
+  'if', 'switch', 'for', 'range',
+]);
+
+/**
+ * A C# / VB.NET reference whose site is a TYPE position: `Type sourceType`,
+ * `List<int>`, `new TypeMap()`, `Exception? e`, `Dictionary<string, Type>`,
+ * VB's `As Type` / `New List(Of T)`. Read from the source at the reference's
+ * column; anything else — a member read (`Builder.Services`), a method group
+ * (`MapGet("/x", GetItems)`), a route's handler — keeps every candidate.
+ */
+function isDotNetTypeRef(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.language !== 'csharp' && ref.language !== 'vbnet') return false;
+  if (ref.referenceKind !== 'references' && ref.referenceKind !== 'instantiates' &&
+    ref.referenceKind !== 'type_of' && ref.referenceKind !== 'returns') return false;
+  const name = ref.referenceName;
+  if (!/^[A-Za-z_]\w*$/.test(name)) return false;
+  // `new TypeMap()` constructs a type; the reference's column is the `new`.
+  if (ref.referenceKind === 'instantiates') return true;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
+    ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined || !line.startsWith(name, ref.column)) return false;
+  const before = line.slice(0, ref.column);
+  const after = line.slice(ref.column + name.length);
+  if (ref.language === 'vbnet') return /\b(?:As|New|Of)\s+$/i.test(before);
+  if (/\bnew\s+$/.test(before)) return true;
+  // `Type name` — a declaration names its type first.
+  if (/^\s+@?[A-Za-z_]/.test(after)) return !/^\s+(?:is|as|and|or|not|when|in|switch|with)\b/.test(after);
+  // `List<int>`, `Type?`, `Type[]`, and the arguments of a generic.
+  if (/^<|^\?(?![.?\[])|^\[\s*[,\]]/.test(after)) return true;
+  return /^\s*[,>]/.test(after) && /<[^<>()]*$/.test(before);
+}
+
+/**
+ * Whether a candidate can be what a .NET type position names. A property, a
+ * method (a constructor is one) or an enum case shares the type's name, not
+ * its meaning: AutoMapper's `Type sourceType` bound to an attribute's `Type`
+ * property and `TypeMap typeMap` to a `TypeMap` property beside the `TypeMap`
+ * class. A field never names a type either, nor does a constant — the kind a
+ * C# `const` / `static readonly` field gets: jellyfin's `new Version(5, 18)`
+ * bound to a claim-name `const string Version`, and serilog's `static
+ * readonly Meter Meter = new(…)` to itself.
+ */
+function canNameInTypePosition(n: Node): boolean {
+  return !(n.kind === 'property' || n.kind === 'method' || n.kind === 'enum_member' || n.kind === 'field' ||
+    n.kind === 'constant');
+}
+
+/**
+ * The shape of a Python call that reaches the resolver as a bare name — the
+ * column is the call's start. `bare`: `get(1)`, which cannot mean a method
+ * (Python has no implicit self). `chained`: a receiver the extractor could not
+ * keep — `User.objects.get(…)`, `self.client.login(…)`, `request.POST.get(…)`
+ * arrive as `get` / `login`, and can only mean a member of what the chain
+ * names last (`POST`, `client`, `objects`). netbox bound 3,610 `.all()` calls
+ * to one `UserConfig.all`, healthchecks 880 `objects.get` to a test case's
+ * `get`. `self.x()` / `cls.x()`, and a chain split across lines, are null:
+ * today's behavior.
+ */
+type PythonCallShape = { kind: 'bare' } | { kind: 'chained'; owner: string };
+
+function pythonCallShape(ref: UnresolvedRef, context: ResolutionContext): PythonCallShape | null {
+  if (ref.language !== 'python' || ref.referenceKind !== 'calls') return null;
+  const name = ref.referenceName;
+  if (!/^[A-Za-z_]\w*$/.test(name)) return null;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return null;
+  const text = line.slice(ref.column);
+  if (text.startsWith(name) && /^\s*\(/.test(text.slice(name.length))) return { kind: 'bare' };
+  if (new RegExp(String.raw`^(?:self|cls)\s*\.\s*${name}\s*\(`).test(text)) return null;
+  // The call starts at its receiver, so everything up to `.name(` is the receiver chain.
+  const chain = new RegExp(String.raw`^(.*?)\.\s*${name}\s*\(`).exec(text);
+  if (!chain) return null;
+  const owner = /(\w+)\s*(?:\([^()]*\)|\[[^\[\]]*\])?\s*$/.exec(chain[1]!)?.[1];
+  return owner ? { kind: 'chained', owner } : null;
+}
+
+/** Can a Python call of this shape mean the candidate? */
+function fitsPythonCallShape(n: Node, shape: PythonCallShape, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (shape.kind === 'bare') {
+    if (n.kind === 'method') return false;
+    if (n.filePath === ref.filePath) return true;
+    // `from django.shortcuts import render`: the call is the package's.
+    if (isPythonNameImportedFromOutside(ref.referenceName, ref, context)) return false;
+    // `view = UserView.as_view()` … `view(request)`: the file's own value —
+    // unless it is a pytest fixture, which a test takes as a parameter of that name.
+    return isFixtureInReach(n, ref.filePath, context) || !isPythonLocallyBound(ref.referenceName, ref, context);
+  }
+  // A member of what the chain names: a method of a class of that name, or a
+  // function / class in a module of that name (`helpers.slugify()`).
+  if (n.kind === 'method') {
+    // `self.store.fetch()` on a `Store`, `self.user_service.find()` on a `UserService`.
+    const cut = n.qualifiedName.lastIndexOf('::');
+    const owner = cut >= 0 ? n.qualifiedName.slice(0, cut).split('::').pop()! : '';
+    const plain = (s: string): string => s.replace(/_/g, '').toLowerCase();
+    return owner !== '' && plain(owner) === plain(shape.owner);
+  }
+  const parts = n.filePath.split('/');
+  const stem = parts[parts.length - 1]!.replace(/\.pyi?$/, '');
+  return stem === shape.owner || (stem === '__init__' && parts[parts.length - 2] === shape.owner);
+}
+
+/**
+ * A pytest fixture: `@pytest.fixture` / `@fixture`, or anything a `conftest.py`
+ * defines. Python decorators are not kept on the node, so they are read from
+ * the lines above its `def` (a decorator's arguments may span lines).
+ */
+function isPytestFixture(n: Node, context: ResolutionContext): boolean {
+  if (/(?:^|\/)conftest\.py$/.test(n.filePath) || (n.decorators ?? []).some((d) => /(?:^|\.)fixture\b/.test(d))) return true;
+  return isDecoratedFixture(n, context);
+}
+
+/**
+ * A fixture a test at `filePath` can take by name: one its own module defines,
+ * or one a `conftest.py` of its directory or a parent does. A test module's
+ * fixture is that module's alone — pytest's `_run_both(func)` is handing on its
+ * parameter, not a doc example's `func` fixture.
+ */
+function isFixtureInReach(n: Node, filePath: string, context: ResolutionContext): boolean {
+  if (n.filePath === filePath) return isPytestFixture(n, context);
+  const conftest = /^(.*?)(?:^|\/)conftest\.py$/.exec(n.filePath);
+  if (conftest !== null) return conftest[1] === '' || filePath.startsWith(`${conftest[1]}/`);
+  // A fixture module a `conftest.py` above the test pulls in — `from
+  // tests.fixtures.cli import *`, or `pytest_plugins = ["tests.fixtures.cli"]`.
+  if (!isPytestFixture(n, context)) return false;
+  return pluggedFixtureModules(filePath, context).some((m) => n.filePath === m || n.filePath.endsWith(`/${m}`));
+}
+
+const PY_PLUGGED_MODULES = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/** The module files (`tests/fixtures/cli.py`) the `conftest.py` files above `filePath` star-import or list in `pytest_plugins`. */
+function pluggedFixtureModules(filePath: string, context: ResolutionContext): string[] {
+  let memo = PY_PLUGGED_MODULES.get(context);
+  if (!memo) PY_PLUGGED_MODULES.set(context, (memo = new Map()));
+  const dir = filePath.includes('/') ? filePath.slice(0, filePath.lastIndexOf('/')) : '';
+  const hit = memo.get(dir);
+  if (hit) return hit;
+  const modules: string[] = [];
+  for (let d = dir; ; d = d.includes('/') ? d.slice(0, d.lastIndexOf('/')) : '') {
+    const text = context.readFile(d ? `${d}/conftest.py` : 'conftest.py');
+    if (text) {
+      for (const m of text.matchAll(/^\s*from\s+([\w.]+)\s+import\s+\*/gm)) modules.push(`${m[1]!.replace(/\./g, '/')}.py`);
+      const plugins = /^\s*pytest_plugins\s*=\s*[[(]([^\])]*)[\])]/m.exec(text)?.[1] ?? '';
+      for (const m of plugins.matchAll(/["']([\w.]+)["']/g)) modules.push(`${m[1]!.replace(/\./g, '/')}.py`);
+    }
+    if (!d) break;
+  }
+  memo.set(dir, modules);
+  return modules;
+}
+
+const PY_FIXTURE_TYPES = new WeakMap<ResolutionContext, Map<string, string | null>>();
+
+/**
+ * The class a pytest fixture returns, for a test parameter of its name — the
+ * fixture in reach (the test's module, else the nearest `conftest.py` above
+ * it) whose body returns or yields `Cls(…)`, directly or through a local
+ * assigned `Cls(…)`. Null for anything else (a parameter that is no fixture's,
+ * a fixture returning a call of a function).
+ */
+function pythonFixtureReturnType(receiver: string, ref: UnresolvedRef, context: ResolutionContext): string | null {
+  if (!/^[a-z_]\w*$/.test(receiver) || receiver === 'self' || receiver === 'cls') return null;
+  let memo = PY_FIXTURE_TYPES.get(context);
+  if (!memo) PY_FIXTURE_TYPES.set(context, (memo = new Map()));
+  const key = `${ref.fromNodeId}\0${receiver}`;
+  const hit = memo.get(key);
+  if (hit !== undefined) return hit;
+  let type: string | null = null;
+  const caller = context.getNodeById?.(ref.fromNodeId);
+  const lines = caller ? context.getFileLines?.(caller.filePath) ?? context.readFile(caller.filePath)?.split(/\r?\n/) ?? [] : [];
+  // The receiver must be the test's own parameter.
+  const signature = caller && (caller.kind === 'function' || caller.kind === 'method')
+    ? lines.slice(caller.startLine - 1, caller.startLine + 4).join(' ').split(/\)\s*(?:->[^:]*)?:/)[0] ?? '' : '';
+  if (new RegExp(`[(,]\\s*${receiver}\\s*(?:[:=,)]|$)`).test(signature)) {
+    const fixtures = context.getNodesByName(receiver)
+      .filter((n) => n.kind === 'function' && n.language === 'python' && isFixtureInReach(n, ref.filePath, context))
+      .sort((a, b) => (a.filePath === ref.filePath ? -1 : 0) - (b.filePath === ref.filePath ? -1 : 0) || b.filePath.length - a.filePath.length);
+    const fixture = fixtures[0];
+    if (fixture) {
+      const body = (context.getFileLines?.(fixture.filePath) ?? context.readFile(fixture.filePath)?.split(/\r?\n/) ?? [])
+        .slice(fixture.startLine, fixture.endLine).join('\n');
+      const returned = /^\s*(?:return|yield)\s+([A-Za-z_][\w.]*)\s*(\()?/m.exec(body);
+      if (returned) {
+        const direct = returned[2] ? returned[1]! : new RegExp(`^\\s*${returned[1]!.replace(/\./g, '\\.')}\\s*=\\s*([A-Za-z_][\\w.]*)\\s*\\(`, 'm').exec(body)?.[1];
+        const cls = direct?.split('.').pop();
+        if (cls && /^[A-Z]/.test(cls)) type = cls;
+      }
+    }
+  }
+  memo.set(key, type);
+  return type;
+}
+
+function isDecoratedFixture(n: Node, context: ResolutionContext): boolean {
+  if (n.language !== 'python' || n.kind !== 'function') return false;
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+  // Upward through the decorator lines: each one starts with `@`, or sits inside one's parentheses.
+  let open = 0;
+  for (let i = n.startLine - 2; i >= 0 && i >= n.startLine - 16; i--) {
+    const text = lines[i]?.trim() ?? '';
+    open += (text.match(/\)/g)?.length ?? 0) - (text.match(/\(/g)?.length ?? 0);
+    if (open > 0) continue;
+    if (!text.startsWith('@')) return false;
+    if (/^@(?:\w+\.)*fixture\b/.test(text)) return true;
+  }
+  return false;
+}
+
+const PY_LOCAL_BINDS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+/**
+ * The file isPythonLocallyBound last read: its code lines, and per name
+ * whether its module binds it. Refs arrive grouped by file, so one file per
+ * context spares re-stripping the file for every function and name (#2332).
+ */
+const PY_LOCAL_FILE = new WeakMap<ResolutionContext, { filePath: string; lines: string[]; module: Map<string, boolean> }>();
+/** The ref isPythonLocallyBound last answered, and the answer. */
+const PY_LOCAL_LAST = new WeakMap<ResolutionContext, { ref: UnresolvedRef; name: string; bound: boolean }>();
+
+/**
+ * Whether the function around a Python call — or its module, at top level —
+ * binds `name` itself: an assignment (`view = X.as_view()`, `a, view = …`,
+ * `view: T = …`), a parameter, a `for` / `with … as` / `except … as` target.
+ * DRF's tests write `view = SomeView.as_view()` then `view(request)`, and
+ * every such call went to one test file's `def view`.
+ */
+function isPythonLocallyBound(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  // fitsPythonCallShape asks once per same-named candidate, and finding the
+  // function around the call reads every node in the file: answer a ref once (#2332).
+  const last = PY_LOCAL_LAST.get(context);
+  if (last?.ref === ref && last.name === name) return last.bound;
+  const bound = pythonLocalBinding(name, ref, context);
+  PY_LOCAL_LAST.set(context, { ref, name, bound });
+  return bound;
+}
+
+/** isPythonLocallyBound's answer, kept per calling function and name. */
+function pythonLocalBinding(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const fn = context.getNodesInFile(ref.filePath)
+    .filter((f) => (f.kind === 'function' || f.kind === 'method') && f.startLine <= ref.line && f.endLine >= ref.line)
+    .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+  let memo = PY_LOCAL_BINDS.get(context);
+  if (!memo) PY_LOCAL_BINDS.set(context, (memo = new Map()));
+  const key = `${ref.filePath}\0${fn?.id ?? ''}\0${name}\0${fn ? '' : ref.line}`;
+  const hit = memo.get(key);
+  if (hit !== undefined) return hit;
+  // An imported name is the import's (the import resolver's to follow).
+  if (pythonFromImports(ref.filePath, context).has(name)) {
+    memo.set(key, false);
+    return false;
+  }
+  // Code only: `{% user_display user as user_display %}` in a docstring binds nothing.
+  let file = PY_LOCAL_FILE.get(context);
+  if (file?.filePath !== ref.filePath) {
+    const lines = stripCommentsForRegex(context.readFile(ref.filePath) ?? '', 'python').split(/\r?\n/);
+    PY_LOCAL_FILE.set(context, (file = { filePath: ref.filePath, lines, module: new Map() }));
+  }
+  const lines = file.lines;
+  const n = name;
+  const assigns = new RegExp(`^\\s*(?:[\\w\\s,*()\\[\\]]*,\\s*)?\\(?\\*?${n}\\)?\\s*(?:,[\\w\\s,*()\\[\\]]*)?(?::[^=]+)?=(?!=)`);
+  const targets = new RegExp(`\\bfor\\s+[\\w\\s,()]*\\b${n}\\b[\\w\\s,()]*\\s+in\\b|\\bas\\s+${n}\\b`);
+  const params = new RegExp(`[(,]\\s*\\*{0,2}${n}\\s*(?:[:=,)]|$)`);
+  let bound = false;
+  if (fn) {
+    // The signature up to its `:` (it may span lines), then the body above the call.
+    let i = fn.startLine - 1;
+    let signature = '';
+    for (; i < Math.min(lines.length, fn.startLine + 20); i++) {
+      signature += lines[i] ?? '';
+      if (/\)\s*(?:->[^:]*)?:\s*(?:#.*)?$/.test(lines[i] ?? '')) break;
+    }
+    bound = params.test(signature.replace(/^[^(]*/, ''));
+    for (let line = i + 1; !bound && line < ref.line - 1; line++) {
+      const text = lines[line] ?? '';
+      bound = assigns.test(text) || targets.test(text);
+    }
+  }
+  // A module-level binding (`view = api_view(['GET'])(handler)`).
+  if (!bound) {
+    let module = file.module.get(n);
+    if (module === undefined) {
+      const top = new RegExp(`^(?:[\\w,\\s]*,\\s*)?${n}\\s*(?:,[\\w\\s,]*)?(?::[^=]+)?=(?!=)`);
+      module = lines.some(line => top.test(line));
+      file.module.set(n, module);
+    }
+    bound = module;
+  }
+  memo.set(key, bound);
+  return bound;
+}
+
+const PY_IMPORTS = new WeakMap<ResolutionContext, Map<string, Map<string, string>>>();
+const PY_MODULE_LOCAL = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** `name` → the module a `from <module> import name` line takes it from, per file. */
+function pythonFromImports(filePath: string, context: ResolutionContext): Map<string, string> {
+  let memo = PY_IMPORTS.get(context);
+  if (!memo) {
+    memo = new Map();
+    PY_IMPORTS.set(context, memo);
+  }
+  const hit = memo.get(filePath);
+  if (hit) return hit;
+  const names = new Map<string, string>();
+  const text = context.readFile(filePath) ?? '';
+  for (const m of text.matchAll(/^\s*from\s+([\w.]+)\s+import\s+(\([^)]*\)|[^\n#]+)/gm)) {
+    const module = m[1]!;
+    for (const item of m[2]!.replace(/[()]/g, '').split(',')) {
+      const bound = /(\w+)\s*$/.exec(item.trim())?.[1];
+      if (bound && bound !== '*') names.set(bound, module);
+    }
+  }
+  memo.set(filePath, names);
+  return names;
+}
+
+function isPythonNameImportedFromOutside(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const module = pythonFromImports(ref.filePath, context).get(name);
+  if (!module || module.startsWith('.')) return false;
+  let memo = PY_MODULE_LOCAL.get(context);
+  if (!memo) {
+    memo = new Map();
+    PY_MODULE_LOCAL.set(context, memo);
+  }
+  let local = memo.get(module);
+  if (local === undefined) {
+    const rel = module.replace(/\./g, '/');
+    local = context.getAllFiles().some((f) =>
+      f === `${rel}.py` || f.endsWith(`/${rel}.py`) || f === `${rel}/__init__.py` || f.endsWith(`/${rel}/__init__.py`));
+    memo.set(module, local);
+  }
+  return !local;
+}
+
+const JAVA_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'interface', 'enum', 'struct', 'record', 'trait']);
+const JAVA_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const JAVA_STATIC_IMPORTS = new WeakMap<ResolutionContext, Map<string, { owners: Set<string>; members: Set<string> }>>();
+
+/**
+ * A bare Java call — `verify(mock)`, `helper()`, `this.x()`, `super.x()` —
+ * reaches a method of a class around it, of one of that class's supertypes, or
+ * one the file imports statically. Not some other class's method of that name:
+ * halo's tests' Mockito `verify(…)` and `eq(…)` bound 1,038 calls to an
+ * `EmailVerificationService.verify` and 845 to a builder's `eq`. Supertypes are
+ * read from the declarations — the resolved `extends` edges do not exist yet on
+ * the first pass.
+ */
+function isJavaMethodInScope(method: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const owner = method.qualifiedName.slice(0, cut).split('::').pop()!;
+  const imports = javaStaticImportsOf(ref.filePath, context);
+  if (imports.owners.has(owner) || imports.members.has(`${owner}.${ref.referenceName}`)) return true;
+  const around = context
+    .getNodesInFile(ref.filePath)
+    .filter((n) => JAVA_TYPE_KINDS.has(n.kind) && n.startLine <= ref.line && n.endLine >= ref.line);
+  const seen = new Set<string>();
+  const queue = around.map((n) => n.name);
+  while (queue.length > 0 && seen.size < 40) {
+    const name = queue.shift()!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    if (name === owner) return true;
+    queue.push(...javaSupertypesOf(name, context));
+  }
+  return false;
+}
+
+/** The simple names a Java type's declarations extend or implement. */
+function javaSupertypesOf(typeName: string, context: ResolutionContext): string[] {
+  let memo = JAVA_SUPERS.get(context);
+  if (!memo) {
+    memo = new Map();
+    JAVA_SUPERS.set(context, memo);
+  }
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const names: string[] = [];
+  for (const decl of context.getNodesByName(typeName)) {
+    if (decl.language !== 'java' || !JAVA_TYPE_KINDS.has(decl.kind)) continue;
+    const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+    const head = lines.slice(decl.startLine - 1, decl.startLine + 5).join(' ');
+    const clause = /\b(?:extends|implements)\b([^{]*)\{/.exec(head)?.[1] ?? '';
+    const flat = clause.replace(/<[^<>]*(?:<[^<>]*>[^<>]*)*>/g, '');
+    for (const m of flat.matchAll(/([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g)) {
+      const simple = m[1]!.split('.').pop()!;
+      if (simple !== 'extends' && simple !== 'implements') names.push(simple);
+    }
+  }
+  memo.set(typeName, names);
+  return names;
+}
+
+/** A Java file's `import static a.b.Owner.member;` / `import static a.b.Owner.*;`. */
+function javaStaticImportsOf(filePath: string, context: ResolutionContext): { owners: Set<string>; members: Set<string> } {
+  let memo = JAVA_STATIC_IMPORTS.get(context);
+  if (!memo) {
+    memo = new Map();
+    JAVA_STATIC_IMPORTS.set(context, memo);
+  }
+  const hit = memo.get(filePath);
+  if (hit) return hit;
+  const found = { owners: new Set<string>(), members: new Set<string>() };
+  const text = context.readFile(filePath) ?? '';
+  for (const m of text.matchAll(/^\s*import\s+static\s+([\w.$]+)\s*\.\s*(\*|[\w$]+)\s*;/gm)) {
+    const owner = m[1]!.split('.').pop()!;
+    if (m[2] === '*') found.owners.add(owner);
+    else found.members.add(`${owner}.${m[2]}`);
+  }
+  memo.set(filePath, found);
+  return found;
+}
+
+const DART_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'interface', 'enum', 'mixin', 'extension', 'struct', 'trait']);
+const DART_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/**
+ * Whether a bare Dart call can reach `method`: only a method of the class it
+ * is written in, or of what that class extends, mixes in or implements (an
+ * extension's `on` type included). riverpod's tests' `test(…)` — package:test's
+ * function — went to `ProviderContainer.test` 2,360 times; shelf's `expect(…)`
+ * to a test handler's `expect` method. Outside any class (`main`), no method.
+ */
+function isDartMethodInScope(method: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return dartMemberDepth(method, ref, context) < Infinity;
+}
+
+const DART_CONSTRUCTORS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/**
+ * Whether a Dart method is a named constructor — `Foo.named(…)`, `factory
+ * Foo.of(…)`, `const Foo.value(…)`, `const factory Foo.x() = _X;` — read from
+ * its declaration. Dart reaches one only through its class (`Foo.value(…)`,
+ * the tear-off `Foo.value`), never by a bare name: a parameter `value` passed
+ * on is not `const BlocProvider.value(…)`.
+ */
+function isDartConstructor(n: Node, context: ResolutionContext): boolean {
+  if (n.language !== 'dart' || n.kind !== 'method') return false;
+  let memo = DART_CONSTRUCTORS.get(context);
+  if (!memo) DART_CONSTRUCTORS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  const owner = cut > 0 ? n.qualifiedName.slice(0, cut).split('::').pop()! : '';
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+  const head = (lines[n.startLine - 1] ?? '').slice(n.startColumn);
+  const escape = (name: string): string => name.replace(/\$/g, '\\$');
+  const constructor = owner !== '' &&
+    new RegExp(String.raw`^(?:(?:const|factory|external)\s+)*${escape(owner)}\s*\.\s*${escape(n.name)}(?![\w$])`).test(head);
+  memo.set(n.id, constructor);
+  return constructor;
+}
+
+/**
+ * How many supertype steps separate the class a Dart call is written in from
+ * `method`'s owner: 0 for its own member, Infinity when the owner is not in
+ * its hierarchy at all. An extension's member is in scope when the extension
+ * is `on` a type of that hierarchy — a bare `requireElement()` inside a
+ * notifier is `this.requireElement()`, the `on AnyNotifier` extension's — and
+ * ranks after every real member, as Dart resolves it.
+ */
+function dartMemberDepth(method: Node, ref: UnresolvedRef, context: ResolutionContext): number {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return 0;
+  const owner = method.qualifiedName.slice(0, cut).split('::').pop()!;
+  const hierarchy = dartHierarchyAt(ref, context);
+  const own = hierarchy.get(owner);
+  if (own !== undefined) return own;
+  const decl = context
+    .getNodesInFile(method.filePath)
+    .find((n) => n.name === owner && DART_TYPE_KINDS.has(n.kind) && n.startLine <= method.startLine && n.endLine >= method.endLine);
+  if (!decl) return Infinity;
+  const head = dartHeadOf(decl, context);
+  if (!head.extension) return Infinity;
+  const on = Math.min(...head.supers.map((t) => hierarchy.get(t) ?? Infinity));
+  return on === Infinity ? Infinity : DART_EXTENSION_RANK + on;
+}
+
+/** Past any real member's depth: an extension member only applies when no instance member does. */
+const DART_EXTENSION_RANK = 1000;
+/** Past any lineage's depth (at most 40): an extension on a type parameter is the least specific. */
+const DART_UNIVERSAL_RANK = 100;
+const DART_HIERARCHIES = new WeakMap<ResolutionContext, WeakMap<UnresolvedRef, Map<string, number>>>();
+
+/** Every type the classes around a Dart call site are, by supertype distance (at most 40). */
+function dartHierarchyAt(ref: UnresolvedRef, context: ResolutionContext): Map<string, number> {
+  let memo = DART_HIERARCHIES.get(context);
+  if (!memo) {
+    memo = new WeakMap();
+    DART_HIERARCHIES.set(context, memo);
+  }
+  const hit = memo.get(ref);
+  if (hit) return hit;
+  const depths = new Map<string, number>();
+  const queue: Array<[string, number]> = context
+    .getNodesInFile(ref.filePath)
+    .filter((n) => DART_TYPE_KINDS.has(n.kind) && n.startLine <= ref.line && n.endLine >= ref.line)
+    .map((n) => [n.name, 0]);
+  while (queue.length > 0 && depths.size < 40) {
+    const [name, depth] = queue.shift()!;
+    if (depths.has(name)) continue;
+    depths.set(name, depth);
+    for (const sup of dartSupertypesOf(name, context)) queue.push([sup, depth + 1]);
+  }
+  memo.set(ref, depths);
+  return depths;
+}
+
+/**
+ * Of the in-scope members a bare Dart call could mean, the nearest: a
+ * subclass's override, or the class that implements what an interface only
+ * declares. bloc's `emit(…)` in a `Cubit` is `BlocBase.emit`, not the
+ * `Emittable` interface's.
+ */
+function nearestDartMembers(candidates: Node[], ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  const members = candidates.filter(isDartMember);
+  if (members.length < 2) return candidates;
+  const depth = new Map(members.map((n) => [n.id, dartMemberDepth(n, ref, context)]));
+  const nearest = Math.min(...depth.values());
+  return candidates.filter((n) => !depth.has(n.id) || depth.get(n.id) === nearest);
+}
+
+/** A member of a Dart type — a method, or an abstract member written without a body (extracted as a `function` owned by the type). */
+function isDartMember(n: Node): boolean {
+  return n.kind === 'method' || (n.kind === 'function' && n.qualifiedName.includes('::'));
+}
+
+/**
+ * A value a Dart type holds — an enum constant, a `static const` / `final` —
+ * which a bare name reaches only from inside the type, like its methods:
+ * bloc's brick hook calls `info(…)` on mason's `Logger`, and the call went to
+ * bloc_lint's enum constant `LinterRuleState.info`.
+ */
+function isDartTypeValue(n: Node): boolean {
+  return n.language === 'dart' && (n.kind === 'enum_member' || VALUE_KINDS.has(n.kind)) && n.qualifiedName.includes('::');
+}
+
+/** What a Dart library declares at its top level: a function, a type, a typedef, a top-level `final` / `const`. */
+const DART_LIBRARY_DECL_KINDS: ReadonlySet<string> = new Set(['function', 'class', 'enum', 'type_alias', 'constant', 'variable', 'interface', 'struct', 'trait', 'mixin', 'extension']);
+
+function isDartLibraryDecl(n: Node): boolean {
+  return n.language === 'dart' && DART_LIBRARY_DECL_KINDS.has(n.kind) && !n.qualifiedName.includes('::');
+}
+
+/**
+ * Whether a Dart name written without a receiver — a call, a type — can mean
+ * `candidate` when it is declared at the top level of a library: the caller's
+ * own library declares it, or a library the caller imports without a prefix
+ * exports it, `show` / `hide` and `export` chains followed (see
+ * ./dart-libraries). A name written through an import prefix (`p.Report`)
+ * means only what the imports with that prefix export. riverpod's generated
+ * `async.g.dart` (`part of 'async.dart'`) calls the `family(…)` async.dart
+ * declares, and the call went to annotated.dart's `family` beside it; a test's
+ * `fakeAsync(…)` from package:fake_async went to a vendored copy no file imports.
+ */
+function isDartTopLevelVisible(candidate: Node, ref: UnresolvedRef, context: ResolutionContext, prefix: string | null = null): boolean {
+  if (!isDartLibraryDecl(candidate)) return true;
+  return prefix === null
+    ? dartLibrarySees(ref.filePath, candidate.filePath, candidate.name, context)
+    : dartPrefixSees(ref.filePath, prefix, candidate.filePath, candidate.name, context);
+}
+
+/**
+ * The import prefix a Dart type name is written through — the `p` of
+ * `p.Report`, `p.Color.red` — or null. A type reference's column is the
+ * name's start; on a line with non-ASCII text before it the nearest whole-word
+ * occurrence stands in.
+ */
+function dartImportPrefixOf(ref: UnresolvedRef, context: ResolutionContext): string | null {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1];
+  if (line === undefined) return null;
+  const name = ref.referenceName;
+  const isWord = (at: number) => line.startsWith(name, at) && !/[\w$]/.test(line[at - 1] ?? '') && !/[\w$]/.test(line[at + name.length] ?? '');
+  let start = isWord(ref.column) ? ref.column : -1;
+  for (let at = line.indexOf(name); start < 0 && at >= 0; at = line.indexOf(name, at + 1)) {
+    if (isWord(at)) start = at;
+  }
+  if (start < 0) return null;
+  return /([A-Za-z_$][\w$]*)\s*\.\s*$/.exec(line.slice(0, start))?.[1] ?? null;
+}
+
+/**
+ * A library's own top-level declaration shadows every import of its name, so
+ * when the caller's library declares one, the imported namesakes are no
+ * candidates. (A function nested in another body is not the library's.)
+ */
+function preferOwnDartLibrary(candidates: Node[], ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  if (candidates.filter(isDartLibraryDecl).length < 2) return candidates;
+  const own = candidates.filter((n) =>
+    isDartLibraryDecl(n) && inSameDartLibrary(ref.filePath, n.filePath, context) && isLexicallyReachable(n, ref, context));
+  return own.length === 0 ? candidates : candidates.filter((n) => !isDartLibraryDecl(n) || own.includes(n));
+}
+
+/**
+ * A Dart call through an import prefix — `http.get(…)` after `import
+ * 'package:http/http.dart' as http;`, `fmt.describe(…)`, `kit.Widget()` —
+ * calls a top-level declaration a library imported with that prefix exports,
+ * `export` chains and `show` / `hide` followed, or nothing of the project:
+ * never a member found by its name. riverpod's docs' 25 `http.get(…)` calls
+ * went to a docs example's `Http::get`, by their receiver's capitalized name.
+ * Undefined when the receiver is no import prefix there, or a parameter, local
+ * or member of that name hides it.
+ */
+function matchDartPrefixedCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null | undefined {
+  const parts = DART_MEMBER_READ.exec(ref.referenceName);
+  if (!parts || !dartImportPrefixes(ref.filePath, context).has(parts[1]!)) return undefined;
+  const prefix = parts[1]!;
+  const name = parts[2]!;
+  const at = dartPrefixedCallSite(ref, prefix, name, context);
+  // `const p.Box.named()` reaches here as `p.named`: no call of a top-level `named`.
+  if (at < 0) return null;
+  if (isDartNameHidden(prefix, ref, at, context)) return undefined;
+  const found = dartPrefixedDecls(prefix, name, ref, context);
+  return found.length === 1 ? { original: ref, targetNodeId: found[0]!.id, confidence: 0.9, resolvedBy: 'import' } : null;
+}
+
+/** The top-level Dart declarations named `name` that the imports written with `prefix` bring into the reference's library. */
+function dartPrefixedDecls(prefix: string, name: string, ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  return context.getNodesByName(name).filter((n) => isDartLibraryDecl(n) && dartPrefixSees(ref.filePath, prefix, n.filePath, name, context));
+}
+
+/**
+ * Where `prefix` starts in the code of a Dart call written `prefix.name(…)`,
+ * or -1 when the call is written otherwise: `const p.Box.named()` arrives as
+ * `p.named`. (The reference's column sits just past `name`.)
+ */
+function dartPrefixedCallSite(ref: UnresolvedRef, prefix: string, name: string, context: ResolutionContext): number {
+  const code = dartCodeOf(ref.filePath, context);
+  const start = code ? dartNameStart({ ...ref, referenceName: name }, code) : -1;
+  if (!code || start < 0) return -1;
+  const text = code.text;
+  let k = start - 1;
+  while (k >= 0 && /\s/.test(text[k]!)) k--;
+  if (text[k] !== '.' || text[k - 1] === '.' || text[k - 1] === '?') return -1;
+  k--;
+  while (k >= 0 && /\s/.test(text[k]!)) k--;
+  const end = k + 1;
+  while (k >= 0 && /[\w$]/.test(text[k]!)) k--;
+  if (text.slice(k + 1, end) !== prefix) return -1;
+  while (k >= 0 && /\s/.test(text[k]!)) k--;
+  return text[k] === '.' ? -1 : end - prefix.length;
+}
+
+/**
+ * Whether a parameter or local around offset `at`, or a member of the type the
+ * reference is written in, is named `name`: it hides a library-level name
+ * there — an import prefix among them — as Dart's scopes nest.
+ */
+function isDartNameHidden(name: string, ref: UnresolvedRef, at: number, context: ResolutionContext): boolean {
+  if (isDartLocallyBound(ref.filePath, name, at, context)) return true;
+  const own = dartEnclosingType(ref, context);
+  return own !== null && (classMemberType(own, name, context) !== null ||
+    context.getNodesByName(name).some((n) => n.filePath === own.filePath && n.qualifiedName === `${own.qualifiedName}::${name}`));
+}
+
+/**
+ * The import prefix a Dart call through a type is written with — the `p` of
+ * `p.Box<int>.named(…)`, which arrives as `Box.named` with its column on the
+ * prefix — or null.
+ */
+function dartTypeCallPrefix(typeName: string, member: string, ref: UnresolvedRef, context: ResolutionContext): string | null {
+  const prefixes = dartImportPrefixes(ref.filePath, context);
+  if (prefixes.size === 0) return null;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1];
+  if (line === undefined) return null;
+  const written = new RegExp(String.raw`(?<![\w$.])([A-Za-z_$][\w$]*)\s*\.\s*${typeName.replace(/\$/g, '\\$')}\s*` +
+    String.raw`(?:<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?\s*\.\s*${member.replace(/\$/g, '\\$')}(?![\w$])`, 'g');
+  // The one at the reference's column, else the first: a column counted in bytes misses after non-ASCII text.
+  const found = [...line.matchAll(written)].filter((m) => prefixes.has(m[1]!));
+  return (found.find((m) => m.index === ref.column) ?? found[0])?.[1] ?? null;
+}
+
+/**
+ * Whether a bare Dart reference really is receiver-less at its call site. The
+ * extractor keeps one receiver level, so the later links of a chain —
+ * `LoginState().withEmail(e).withPassword(p)` — arrive as bare names; their
+ * line shows `.withPassword(` all the same. (A Dart ref's column sits just
+ * past the name; the name's start is found either way.) A spread's
+ * `...items()` is no receiver.
+ */
+function isReceiverLessDartCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return true;
+  const name = ref.referenceName;
+  let start = -1;
+  if (line.startsWith(name, ref.column)) start = ref.column;
+  else if (ref.column >= name.length && line.startsWith(name, ref.column - name.length)) start = ref.column - name.length;
+  else start = line.indexOf(name);
+  if (start < 0) return true;
+  const before = line.slice(0, start);
+  return !/\.\s*$/.test(before) || /(?:^|[^.])\.\.\.\s*$/.test(before);
+}
+
+/**
+ * A later link of a Dart call chain — `Provider.autoDispose.family<…>(…)`,
+ * `events.map(mapper).transform(…)`, `const LoginState().withEmail(e)` — which
+ * the extractor records by its bare name, its receiver dropped.
+ */
+export function isDartChainLink(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return ref.language === 'dart' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName) &&
+    !isReceiverLessDartCall(ref, context);
+}
+
+/**
+ * A Dart chain link calls a member of what the chain before it evaluates to,
+ * typed from evidence alone: the chain's head (a type, a constructor call, a
+ * string, `this` / `super`, a variable, field or getter with a declared type)
+ * and each link's declared type (a method's or getter's return type, a
+ * field's type, what a static constant is initialized with). Without that
+ * evidence it links nothing — never a member found by its name: bloc's
+ * `events.map(mapper).transform(…)` is a Stream's, not angular_bloc's
+ * `BlocPipe.transform`, and riverpod's `FutureProvider.autoDispose.family(…)`
+ * is the `family` getter of the builder `autoDispose` holds, not whichever
+ * builder's `family` sat nearest (#750).
+ */
+export function matchDartChainLink(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  if (!context.getNodesByName(ref.referenceName).some((n) => n.language === 'dart')) return null;
+  const code = dartCodeOf(ref.filePath, context);
+  const start = code ? dartNameStart(ref, code) : -1;
+  if (!code || start < 0) return null;
+  // `x.name` / `x?.name`: the receiver ends before the dot. `..name` is a cascade's.
+  let end = start - 1;
+  while (end >= 0 && /\s/.test(code.text[end]!)) end--;
+  if (code.text[end] !== '.' || code.text[end - 1] === '.') return null;
+  end--;
+  if (code.text[end] === '?') end--;
+  while (end >= 0 && /\s/.test(code.text[end]!)) end--;
+  const chain = readDartChain(code.text, end);
+  const receiver = chain ? typeDartChain(chain, ref, context, 0) : null;
+  if (!receiver) return null;
+  // Static members are the type's own: `p.Provider.autoDispose(…)` calls the
+  // constant, as `Provider.autoDispose(…)` does.
+  if (receiver.static) {
+    const member = dartStaticMember(receiver.type, ref.referenceName, ref, context, dartOwnerOf(receiver));
+    return member && member.kind !== 'enum_member'
+      ? { original: ref, targetNodeId: member.id, confidence: 0.85, resolvedBy: 'qualified-name' } : null;
+  }
+  const member = dartMemberOf(receiver.type, ref.referenceName, ref, context, (n) => !isDartSetter(n, context), receiver.viaSuper ? 1 : 0)?.node;
+  return member ? { original: ref, targetNodeId: member.id, confidence: 0.85, resolvedBy: 'instance-method' } : null;
+}
+
+/**
+ * Lookups that hand back an instance of the one type they are given:
+ * provider's and flutter_bloc's `context.read<T>()` / `watch<T>()` /
+ * `BlocProvider.of<T>(context)`, get_it's `get<T>()`, GetX's `find<T>()`, and
+ * Flutter's `findAncestorStateOfType<T>()` family.
+ */
+const DART_TYPE_ARGUMENT_LOOKUPS: ReadonlySet<string> = new Set([
+  'read', 'watch', 'get', 'find', 'of', 'maybeOf', 'call', 'dependOnInheritedWidgetOfExactType',
+  'getInheritedWidgetOfExactType', 'findAncestorStateOfType', 'findAncestorWidgetOfExactType', 'findRootAncestorStateOfType',
+]);
+
+/** Words that can stand before a Dart name without being its declared type. */
+const DART_NON_TYPE_WORDS: ReadonlySet<string> = new Set([
+  'final', 'var', 'late', 'const', 'required', 'covariant', 'static', 'external', 'return', 'await', 'yield', 'throw',
+  'new', 'in', 'is', 'as', 'case', 'else', 'if', 'for', 'while', 'do', 'switch', 'assert', 'this', 'super', 'get', 'set',
+  'operator', 'async', 'sync', 'show', 'hide', 'typedef', 'extends', 'with', 'implements', 'on',
+]);
+
+/** A link of a Dart chain: `.name`, `.name<…>(…)` (`call`), or a subscript `[…]` (`index`). */
+interface DartChainLink { name: string; typeArgs: string[]; call: boolean; index: boolean }
+
+/**
+ * What a Dart chain starts from: a name (`x`, `Foo`, `foo(…)`, `Foo<T>(…)`,
+ * with the keyword written before it — `const`, `new`, `as`, `await` — and
+ * where it starts), a string literal, or a parenthesized expression.
+ */
+type DartChainHead =
+  | { kind: 'name'; name: string; typeArgs: string[]; call: boolean; keyword: string; at: number }
+  | { kind: 'string' }
+  | { kind: 'paren'; open: number; close: number };
+
+interface DartChain { head: DartChainHead; links: DartChainLink[] }
+
+/**
+ * What a Dart chain evaluates to: an instance of `type`, or (`static`) the
+ * type itself, before a static member — of the type `owner` declares, when
+ * the chain says which file that is (`p.Box` names the one `p` brings in).
+ */
+interface DartValue { type: string; static: boolean; viaSuper?: boolean; owner?: string }
+
+/**
+ * A Dart file's code with comments and string contents blanked, where each
+ * line starts, and the files of its library it names: its `part`s and the
+ * file it is `part of`.
+ */
+interface DartCode { text: string; lineStarts: number[]; parts: string[]; partOf: string | null }
+
+const DART_CODE = new WeakMap<ResolutionContext, Map<string, DartCode | null>>();
+
+function dartCodeOf(filePath: string, context: ResolutionContext): DartCode | null {
+  let memo = DART_CODE.get(context);
+  if (!memo) DART_CODE.set(context, (memo = new Map()));
+  const hit = memo.get(filePath);
+  if (hit !== undefined) return hit;
+  const source = context.readFile(filePath);
+  let code: DartCode | null = null;
+  if (source !== null) {
+    const text = blankDartCode(source);
+    const lineStarts = [0];
+    for (let i = 0; i < text.length; i++) if (text[i] === '\n') lineStarts.push(i + 1);
+    const sibling = (uri: string): string => path.posix.normalize(path.posix.join(path.posix.dirname(filePath), uri));
+    const parts = [...source.matchAll(/^\s*part\s+['"]([^'"]+)['"]\s*;/gm)].map((m) => sibling(m[1]!));
+    const partOf = /^\s*part\s+of\s+['"]([^'"]+)['"]\s*;/m.exec(source)?.[1];
+    code = { text, lineStarts, parts, partOf: partOf ? sibling(partOf) : null };
+  }
+  // Refs arrive file by file, so a few files' worth is enough.
+  if (memo.size >= 64) memo.delete(memo.keys().next().value!);
+  memo.set(filePath, code);
+  return code;
+}
+
+/**
+ * Dart source with comments and string contents blanked, offsets kept: a
+ * literal keeps its quotes, and an interpolation's code (`'${a.b()}'`) stays,
+ * so a chain inside one reads like any other.
+ */
+function blankDartCode(source: string): string {
+  const out = source.split('');
+  const n = source.length;
+  const blank = (from: number, to: number): void => {
+    for (let k = from; k < to && k < n; k++) if (out[k] !== '\n' && out[k] !== '\r') out[k] = ' ';
+  };
+  type Literal = { quote: string; triple: boolean; raw: boolean };
+  // The literals an open `${…}` returns to, with the brace depth around each.
+  const outer: Array<{ literal: Literal; depth: number }> = [];
+  let literal: Literal | null = null;
+  let depth = 0;
+  let i = 0;
+  while (i < n) {
+    const c = source[i]!;
+    if (literal) {
+      if (!literal.raw && c === '\\') {
+        blank(i, i + 2);
+        i += 2;
+      } else if (!literal.raw && c === '$' && source[i + 1] === '{') {
+        blank(i, i + 2);
+        outer.push({ literal, depth });
+        literal = null;
+        depth = 0;
+        i += 2;
+      } else if (source.startsWith(literal.triple ? literal.quote.repeat(3) : literal.quote, i)) {
+        i += literal.triple ? 3 : 1;
+        literal = null;
+      } else if (!literal.triple && c === '\n') {
+        literal = null;
+        i++;
+      } else {
+        blank(i, i + 1);
+        i++;
+      }
+      continue;
+    }
+    if (c === '/' && source[i + 1] === '/') {
+      const eol = source.indexOf('\n', i);
+      const stop = eol < 0 ? n : eol;
+      blank(i, stop);
+      i = stop;
+    } else if (c === '/' && source[i + 1] === '*') {
+      let nest = 1;
+      let j = i + 2;
+      while (j < n && nest > 0) {
+        if (source[j] === '/' && source[j + 1] === '*') { nest++; j += 2; }
+        else if (source[j] === '*' && source[j + 1] === '/') { nest--; j += 2; }
+        else j++;
+      }
+      blank(i, j);
+      i = j;
+    } else if (c === "'" || c === '"') {
+      const triple = source.startsWith(c.repeat(3), i);
+      literal = { quote: c, triple, raw: source[i - 1] === 'r' && !/[\w$]/.test(source[i - 2] ?? '') };
+      i += triple ? 3 : 1;
+    } else {
+      if (outer.length > 0 && c === '{') depth++;
+      else if (outer.length > 0 && c === '}') {
+        if (depth === 0) {
+          blank(i, i + 1);
+          ({ literal, depth } = outer.pop()!);
+          i++;
+          continue;
+        }
+        depth--;
+      }
+      i++;
+    }
+  }
+  return out.join('');
+}
+
+/** Where a Dart ref's name starts in its file's code. Its column sits just past the name (or on it). */
+function dartNameStart(ref: UnresolvedRef, code: DartCode): number {
+  const from = code.lineStarts[ref.line - 1];
+  if (from === undefined) return -1;
+  const line = code.text.slice(from, code.lineStarts[ref.line] ?? code.text.length);
+  const name = ref.referenceName;
+  let start = -1;
+  if (line.startsWith(name, ref.column)) start = ref.column;
+  else if (ref.column >= name.length && line.startsWith(name, ref.column - name.length)) start = ref.column - name.length;
+  else start = line.indexOf(name);
+  return start < 0 ? -1 : from + start;
+}
+
+/** The offset of the `open` bracket matching the `close` one at `at`, read backwards; -1 past `limit` characters. */
+function dartOpening(text: string, at: number, open: string, close: string, limit = 20000): number {
+  let depth = 0;
+  for (let k = at; k >= 0 && at - k < limit; k--) {
+    if (text[k] === close) depth++;
+    else if (text[k] === open && --depth === 0) return k;
+    else if (open === '<' && /[;{}=]/.test(text[k]!)) return -1;
+  }
+  return -1;
+}
+
+/** The simple name a Dart type is written as: `Foo` for `p.Foo<Bar>?`. */
+function dartSimpleTypeName(text: string): string | null {
+  const name = text.replace(/<[\s\S]*$/, '').replace(/\?/g, '').trim().split('.').pop()!.trim();
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? name : null;
+}
+
+/**
+ * The links and head of the Dart expression whose last character is at
+ * `end`, read backwards: `FutureProvider.autoDispose` → `FutureProvider`
+ * then `.autoDispose`; `events.map(mapper)` → `events` then `.map(…)`. Null
+ * for a shape the walk does not read — a cascade section, a number, a call
+ * of an expression.
+ */
+function readDartChain(text: string, end: number): DartChain | null {
+  const links: DartChainLink[] = [];
+  let i = end;
+  const skip = (): void => {
+    while (i >= 0 && /\s/.test(text[i]!)) i--;
+  };
+  for (let step = 0; step < 32; step++) {
+    skip();
+    while (text[i] === '!') {
+      i--;
+      skip();
+    }
+    if (text[i] === ']') {
+      const open = dartOpening(text, i, '[', ']');
+      if (open < 0) return null;
+      links.push({ name: '', typeArgs: [], call: false, index: true });
+      i = open - 1;
+      continue;
+    }
+    if (text[i] === "'" || text[i] === '"') return { head: { kind: 'string' }, links: links.reverse() };
+    let call = false;
+    let typeArgs: string[] = [];
+    if (text[i] === ')') {
+      const close = i;
+      const open = dartOpening(text, i, '(', ')');
+      if (open < 0) return null;
+      i = open - 1;
+      skip();
+      if (text[i] === '>') {
+        const lt = dartOpening(text, i, '<', '>', 400);
+        if (lt < 0) return null;
+        typeArgs = splitCppTopLevel(text.slice(lt + 1, i));
+        i = lt - 1;
+        skip();
+      }
+      if (!/[\w$]/.test(text[i] ?? '')) {
+        // `(…)` with no name before it is the head — unless an expression is called: `f()(…)`.
+        if (typeArgs.length > 0 || text[i] === ')' || text[i] === ']') return null;
+        return { head: { kind: 'paren', open, close }, links: links.reverse() };
+      }
+      call = true;
+    } else if (text[i] === '>') {
+      // `BlocProvider<CounterCubit>.value(…)`: a type written with its arguments.
+      const lt = dartOpening(text, i, '<', '>', 400);
+      if (lt < 0) return null;
+      typeArgs = splitCppTopLevel(text.slice(lt + 1, i));
+      i = lt - 1;
+      skip();
+    }
+    const nameEnd = i + 1;
+    while (i >= 0 && /[\w$]/.test(text[i]!)) i--;
+    const name = text.slice(i + 1, nameEnd);
+    if (!/^[A-Za-z_$][\w$]*$/.test(name)) return null;
+    let j = i;
+    while (j >= 0 && /\s/.test(text[j]!)) j--;
+    if (text[j] === '.') {
+      // `obj..a().b()`: a cascade section's receiver is the cascade's target.
+      if (text[j - 1] === '.') return null;
+      links.push({ name, typeArgs, call, index: false });
+      i = j - 1;
+      if (text[i] === '?') i--;
+      continue;
+    }
+    const keyword = /([A-Za-z_]\w*)$/.exec(text.slice(Math.max(0, j - 10), j + 1))?.[1] ?? '';
+    return { head: { kind: 'name', name, typeArgs, call, keyword, at: i + 1 }, links: links.reverse() };
+  }
+  return null;
+}
+
+/** What a Dart chain evaluates to, link by link, or null where the evidence runs out. */
+function typeDartChain(chain: DartChain, ref: UnresolvedRef, context: ResolutionContext, depth: number): DartValue | null {
+  if (depth > 3) return null;
+  const head = chain.head;
+  let links = chain.links;
+  let value: DartValue | null;
+  if (head.kind === 'string') value = { type: 'String', static: false };
+  else if (head.kind === 'paren') value = typeDartParen(head, ref, context, depth);
+  else {
+    // `p.Provider.autoDispose`: an import prefix names a library, so the chain
+    // starts at the link after it, which names what that library exports.
+    const first = links[0];
+    if (!head.call && head.typeArgs.length === 0 && first && !first.index && dartImportPrefixes(ref.filePath, context).has(head.name) &&
+        !isDartNameHidden(head.name, ref, head.at, context)) {
+      value = typeDartPrefixedHead(head.name, first, ref, context, depth);
+      links = links.slice(1);
+    } else {
+      // `const Foo.named(…)`: the named constructor is the head's own link.
+      if ((head.keyword === 'const' || head.keyword === 'new') && !head.call && links[0]?.call) links = links.slice(1);
+      value = typeDartHead(head, ref, context, depth);
+    }
+  }
+  for (const link of links) {
+    // Every Dart object's `toString()` returns a String, whatever it is.
+    if (link.name === 'toString' && link.call && link.typeArgs.length === 0) {
+      value = { type: 'String', static: false };
+      continue;
+    }
+    const next = value ? typeDartLink(value, link, ref, context, depth) : null;
+    // A lookup nothing declared answers for hands back the type it is given,
+    // whatever it is called on: `context.read<LoginCubit>()` on Flutter's
+    // BuildContext, or on an untyped `(context) =>` parameter.
+    const given = !next && link.call && link.typeArgs.length === 1 && DART_TYPE_ARGUMENT_LOOKUPS.has(link.name) &&
+      !(value && dartLinkDeclared(value, link, ref, context)) ? dartSimpleTypeName(link.typeArgs[0]!) : null;
+    // An untyped value stays untyped until a link says what it makes.
+    value = next ?? (given ? { type: given, static: false } : null);
+  }
+  return value;
+}
+
+/** Whether the type a Dart chain has reached declares the member a link names. */
+function dartLinkDeclared(value: DartValue, link: DartChainLink, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return value.static
+    ? dartStaticMember(value.type, link.name, ref, context, dartOwnerOf(value)) !== null
+    : dartMemberOf(value.type, link.name, ref, context, (n) => !isDartSetter(n, context), value.viaSuper ? 1 : 0) !== null;
+}
+
+/** Which of the types named like a chain's value it is: the one its `owner` file declares, when the chain said. */
+function dartOwnerOf(value: DartValue): ((type: Node) => boolean) | undefined {
+  return value.owner === undefined ? undefined : (type) => type.filePath === value.owner;
+}
+
+/** `(x as Foo)` is a Foo; any other parenthesized expression is what its last operand is: `(a ?? Todo(…))`. */
+function typeDartParen(head: { open: number; close: number }, ref: UnresolvedRef, context: ResolutionContext, depth: number): DartValue | null {
+  const code = dartCodeOf(ref.filePath, context);
+  if (!code) return null;
+  const inner = code.text.slice(head.open + 1, head.close);
+  const cast = /\bas\s+((?:[A-Za-z_$][\w$]*\.)?[A-Za-z_$][\w$]*)\s*(?:<[^()]*>)?\s*\??\s*$/.exec(inner);
+  if (cast) {
+    const type = dartSimpleTypeName(cast[1]!);
+    return type ? { type, static: false } : null;
+  }
+  let end = head.close - 1;
+  while (end > head.open && /\s/.test(code.text[end]!)) end--;
+  return dartExpressionValue(code.text, end, ref, context, depth);
+}
+
+/** The value of the Dart expression ending at `end`: an instance, never a type, and never an awaited one. */
+function dartExpressionValue(text: string, end: number, ref: UnresolvedRef, context: ResolutionContext, depth: number): DartValue | null {
+  const chain = readDartChain(text, end);
+  if (!chain || (chain.head.kind === 'name' && chain.head.keyword === 'await')) return null;
+  const value = typeDartChain(chain, ref, context, depth + 1);
+  return value && !value.static ? value : null;
+}
+
+/** What a Dart chain's head evaluates to. */
+function typeDartHead(
+  head: { name: string; typeArgs: string[]; call: boolean; keyword: string },
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  depth: number,
+): DartValue | null {
+  const name = head.name;
+  if (name === 'this' || name === 'super') {
+    const own = dartEnclosingType(ref, context);
+    return own ? { type: own.name, static: false, viaSuper: name === 'super' } : null;
+  }
+  if (head.keyword === 'const' || head.keyword === 'new' || head.keyword === 'as') return { type: name, static: false };
+  if (head.keyword === 'is') return null;
+  const isType = context.getNodesByName(name).some((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind));
+  if (head.call) {
+    // `Foo(…)` constructs a Foo; `foo(…)` is what the function says it returns,
+    // or — a variable holding a callable, riverpod's `family(0)` — what its `call` does.
+    if (isType) return { type: name, static: false };
+    const fn = dartFunctionNamed(name, ref, context);
+    if (fn) {
+      const type = dartReturnType(fn, head.typeArgs, context);
+      return type ? { type, static: false } : null;
+    }
+    const held = dartVariableType(name, ref, context, depth);
+    return held ? dartCallResult(held, head.typeArgs, ref, context) : null;
+  }
+  // `Foo.` before a static member — a type outside the project included, whose members nothing reaches.
+  if (isType || (/^[A-Z]/.test(name) && !context.getNodesByName(name).some((n) => n.language === 'dart' && (n.kind === 'constant' || n.kind === 'variable')))) {
+    return { type: name, static: true };
+  }
+  const type = dartVariableType(name, ref, context, depth);
+  return type ? { type, static: false } : null;
+}
+
+/**
+ * What the first link after an import prefix evaluates to — `p.Provider`
+ * before a static member, `p.Report(…)`, `p.make(…)`, `p.config` — read from
+ * the top-level declarations the prefixed import brings in, and nothing when
+ * it brings in none of that name: a package outside the repository, whatever
+ * the project declares under the name elsewhere.
+ */
+function typeDartPrefixedHead(prefix: string, link: DartChainLink, ref: UnresolvedRef, context: ResolutionContext, depth: number): DartValue | null {
+  const found = dartPrefixedDecls(prefix, link.name, ref, context);
+  const types = found.filter((n) => DART_TYPE_KINDS.has(n.kind));
+  if (types.length > 0) {
+    return { type: link.name, static: !link.call, owner: types.length === 1 ? types[0]!.filePath : undefined };
+  }
+  if (found.length !== 1) return null;
+  const decl = found[0]!;
+  if (decl.kind === 'function') {
+    const type = link.call ? dartReturnType(decl, link.typeArgs, context) : null;
+    return type ? { type, static: false } : null;
+  }
+  if (decl.kind !== 'constant' && decl.kind !== 'variable') return null;
+  const held = dartConstantType(decl, ref, context, depth);
+  if (!held) return null;
+  return link.call ? dartCallResult(held, link.typeArgs, ref, context) : { type: held, static: false };
+}
+
+/** What one link of a Dart chain makes of the value before it. */
+function typeDartLink(value: DartValue, link: DartChainLink, ref: UnresolvedRef, context: ResolutionContext, depth: number): DartValue | null {
+  if (link.index) return null;
+  if (value.static) {
+    const member = dartStaticMember(value.type, link.name, ref, context, dartOwnerOf(value));
+    if (!member) {
+      // `BlocProvider.value(…)`, `AsyncValue.data(…)`: a constructor the index holds no node for.
+      return link.call && context.getNodesByName(value.type).some((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind))
+        ? { type: value.type, static: false } : null;
+    }
+    if (member.kind === 'enum_member') return link.call ? null : { type: value.type, static: false };
+    if (member.kind === 'constant') {
+      // `FutureProvider.autoDispose`: the value the static constant holds.
+      const held = dartConstantType(member, ref, context, depth);
+      if (!held) return null;
+      return link.call ? dartCallResult(held, link.typeArgs, ref, context) : { type: held, static: false };
+    }
+    return typeDartMemberUse(member, link, ref, context);
+  }
+  const member = dartMemberOf(value.type, link.name, ref, context, (n) => !isDartSetter(n, context), value.viaSuper ? 1 : 0)?.node;
+  if (member) return typeDartMemberUse(member, link, ref, context);
+  // A field mints no node: its declared type is read from its class.
+  if (link.call) return null;
+  const field = dartFieldType(value.type, link.name, ref, context, depth);
+  return field ? { type: field, static: false } : null;
+}
+
+/** What using a member makes: a method's call or a getter's read is its declared return type; a getter called is its value called. */
+function typeDartMemberUse(member: Node, link: DartChainLink, ref: UnresolvedRef, context: ResolutionContext): DartValue | null {
+  const getter = isDartGetter(member, context);
+  const type = dartReturnType(member, getter ? [] : link.typeArgs, context);
+  if (!type) return null;
+  if (getter) return link.call ? dartCallResult(type, link.typeArgs, ref, context) : { type, static: false };
+  // A method named without a call is a tear-off: a function, not its result.
+  return link.call ? { type, static: false } : null;
+}
+
+/** What calling a value of `type` returns — its `call` method's declared return type. */
+function dartCallResult(type: string, typeArgs: string[], ref: UnresolvedRef, context: ResolutionContext): DartValue | null {
+  const call = dartMemberOf(type, 'call', ref, context, (n) => !isDartGetter(n, context))?.node;
+  const result = call ? dartReturnType(call, typeArgs, context) : null;
+  return result ? { type: result, static: false } : null;
+}
+
+const DART_RETURN_TYPES = new WeakMap<ResolutionContext, Map<string, { type: string; own: string[] } | null>>();
+
+/**
+ * A Dart function's declared return type as a simple name, a type parameter
+ * of its own replaced by the type argument the call gives (`T read<T>()`
+ * called as `read<Foo>()` is a Foo); a type parameter of its class
+ * (`State get state` in `BlocBase<State>`) says nothing without the
+ * receiver's own arguments.
+ */
+function dartReturnType(fn: Node, typeArgs: string[], context: ResolutionContext): string | null {
+  let memo = DART_RETURN_TYPES.get(context);
+  if (!memo) DART_RETURN_TYPES.set(context, (memo = new Map()));
+  let info = memo.get(fn.id);
+  if (info === undefined) {
+    info = null;
+    const type = fn.returnType ? dartSimpleTypeName(fn.returnType) : null;
+    if (type) {
+      // `static T of<T …>(…)` in `BlocProvider<T …>`: the function's own parameter is the one meant.
+      const own = declaredTypeParameters(fn, context);
+      const cut = fn.qualifiedName.lastIndexOf('::');
+      const owner = cut > 0 && !own.includes(type) ? context.getNodesInFile(fn.filePath).find((n) => DART_TYPE_KINDS.has(n.kind) &&
+        n.qualifiedName === fn.qualifiedName.slice(0, cut) && n.startLine <= fn.startLine && n.endLine >= fn.endLine) : undefined;
+      if (!owner || !declaredTypeParameters(owner, context).includes(type)) info = { type, own };
+    }
+    memo.set(fn.id, info);
+  }
+  if (!info) return null;
+  const at = info.own.indexOf(info.type);
+  if (at < 0) return info.type;
+  return typeArgs[at] ? dartSimpleTypeName(typeArgs[at]!) : null;
+}
+
+/** The innermost Dart class, mixin, enum or extension a reference sits in. */
+function dartEnclosingType(ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  let own: Node | null = null;
+  for (const n of context.getNodesInFile(ref.filePath)) {
+    if (DART_TYPE_KINDS.has(n.kind) && n.startLine <= ref.line && n.endLine >= ref.line && (!own || n.startLine >= own.startLine)) own = n;
+  }
+  return own;
+}
+
+/**
+ * The static member `name` the Dart type `typeName` itself declares — a
+ * static method or getter, a named constructor or factory, a static
+ * constant, an enum value — preferring the call site's file, then the
+ * nearest. Static members are not inherited. `isOwner` narrows the types of
+ * that name to the one meant (the one an import prefix brings in).
+ */
+function dartStaticMember(
+  typeName: string,
+  name: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  isOwner: (type: Node) => boolean = () => true,
+): Node | null {
+  const owners = context.getNodesByName(typeName).filter((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind) && isOwner(n));
+  if (owners.length === 0) return null;
+  const found = context.getNodesByName(name).filter((m) => m.language === 'dart' &&
+    (m.kind === 'method' || m.kind === 'function' || m.kind === 'constant' || m.kind === 'enum_member') &&
+    owners.some((o) => o.filePath === m.filePath && m.qualifiedName === `${o.qualifiedName}::${name}`) &&
+    !isDartSetter(m, context) && isDartStaticMember(m, context));
+  if (found.length <= 1) return found[0] ?? null;
+  return found.find((m) => m.filePath === ref.filePath) ??
+    found.reduce((a, b) => (computePathProximity(ref.filePath, b.filePath) > computePathProximity(ref.filePath, a.filePath) ? b : a));
+}
+
+/**
+ * Whether a member of a Dart type is reached through the type itself: a
+ * static member, constant or enum value, or a named constructor or factory
+ * (`factory ProviderContainer.test(…)`) — not an instance member sharing a
+ * constructor's name (`AsyncValue`'s `error` getter beside its
+ * `AsyncValue.error(…)` factory, even declared on the line above it).
+ */
+function isDartStaticMember(m: Node, context: ResolutionContext): boolean {
+  return m.isStatic === true || m.kind === 'constant' || m.kind === 'enum_member' || isDartConstructor(m, context);
+}
+
+/**
+ * The function a bare Dart call `name(…)` means: a member of the type around
+ * it (an implicit `this.`), else a function of the file, else the one
+ * function of that name the project declares.
+ */
+function dartFunctionNamed(name: string, ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  const own = dartEnclosingType(ref, context);
+  const member = own ? dartMemberOf(own.name, name, ref, context, (n) => !isDartGetter(n, context) && !isDartSetter(n, context))?.node : undefined;
+  if (member) return member;
+  return dartLibraryPick(context.getNodesByName(name).filter((n) => n.language === 'dart' && n.kind === 'function' && !n.qualifiedName.includes('::')), ref, context);
+}
+
+/**
+ * Of same-named top-level Dart declarations, the one the call's library
+ * holds — its own file, then a `part` of it (riverpod_generator's
+ * `depFamilyProvider` in `missing_dependencies.g.dart`) — else the only one.
+ */
+function dartLibraryPick(nodes: Node[], ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  const own = nodes.find((n) => n.filePath === ref.filePath);
+  if (own) return own;
+  const library = dartLibraryFiles(ref.filePath, context);
+  const shared = nodes.filter((n) => library.has(n.filePath));
+  if (shared.length === 1) return shared[0]!;
+  return nodes.length === 1 ? nodes[0]! : null;
+}
+
+/** The files of a Dart file's library: itself, its `part`s, and the file it is `part of` with that file's parts. */
+function dartLibraryFiles(filePath: string, context: ResolutionContext): Set<string> {
+  const files = new Set([filePath]);
+  const code = dartCodeOf(filePath, context);
+  for (const part of code?.parts ?? []) files.add(part);
+  if (code?.partOf) {
+    files.add(code.partOf);
+    for (const part of dartCodeOf(code.partOf, context)?.parts ?? []) files.add(part);
+  }
+  return files;
+}
+
+/**
+ * The declared type of a Dart variable a chain starts from: a local or
+ * parameter the code around the call declares (the nearest declaration wins,
+ * and an untyped one ends the search), a field or getter of the class around
+ * it, or a top-level variable.
+ */
+function dartVariableType(name: string, ref: UnresolvedRef, context: ResolutionContext, depth: number): string | null {
+  const local = dartLocalType(name, ref, context, depth);
+  if (local !== undefined) return local;
+  const field = inferMemberReceiverType(name, ref, context);
+  if (field) return dartSimpleTypeName(field);
+  const own = dartEnclosingType(ref, context);
+  const getter = own ? dartMemberOf(own.name, name, ref, context, (n) => isDartGetter(n, context))?.node : undefined;
+  if (getter) return dartReturnType(getter, [], context);
+  const top = dartLibraryPick(context.getNodesByName(name).filter((n) => n.language === 'dart' && n.kind === 'constant' && !n.qualifiedName.includes('::')), ref, context);
+  return top ? dartConstantType(top, ref, context, depth) : null;
+}
+
+/**
+ * The type of the nearest declaration of `name` before the call, within the
+ * function around it: its declared type (`final Ticker _ticker`, `Foo? x`,
+ * `(BuildContext context)`), else what its initializer evaluates to (`final
+ * todo = Todo(…)`). Null for a declaration that says no type (a `for (final
+ * x in …)` variable, an untyped closure parameter); undefined for none.
+ */
+function dartLocalType(name: string, ref: UnresolvedRef, context: ResolutionContext, depth: number): string | null | undefined {
+  const code = dartCodeOf(ref.filePath, context);
+  const at = code ? dartNameStart(ref, code) : -1;
+  if (!code || at < 0) return undefined;
+  const start = code.lineStarts[enclosingScopeStartLine(ref, context) - 1] ?? 0;
+  const scope = code.text.slice(start, at);
+  const uses = dartNameUses(code, ref.filePath, name, context);
+  // The last use before the call: uses are in file order.
+  let lo = 0;
+  let hi = uses.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (uses[mid]! < at) lo = mid + 1;
+    else hi = mid;
+  }
+  for (let u = lo - 1; u >= 0 && uses[u]! >= start; u--) {
+    const pos = uses[u]! - start;
+    const before = scope.slice(Math.max(0, pos - 120), pos);
+    const after = scope.slice(pos + name.length);
+    const declared = /([A-Za-z_$][\w$]*)\s*(<[^;{}()=]*>)?\s*\??\s+$/.exec(before);
+    const typed = declared && !DART_NON_TYPE_WORDS.has(declared[1]!) && /^\s*(?:[=;,)}]|in\b)/.test(after) &&
+      !/^\s*==/.test(after) ? declared[1]! : null;
+    if (typed) return typed;
+    // `final x = …`, `var x = …`: the initializer says the type.
+    if (/(?:^|[^\w$])(?:final|var|late|const)\s+$/.test(before)) {
+      const init = /^\s*=(?![=>])/.exec(after);
+      return init ? dartInitializerType(code.text, start + pos + name.length + init[0].length, ref, context, depth) : null;
+    }
+    // A closure's untyped parameter — `(context, state) =>` — or a `catch (e)`;
+    // not an argument of a call, `foo(x, (a) {…})`, nor an `if (x) {`.
+    if (/^\s*[,)]/.test(after) && /[(,]\s*$/.test(before)) {
+      const open = dartGroupOpen(code.text, start + pos);
+      const close = open < 0 ? -1 : dartGroupClose(code.text, open);
+      const callee = /([\w$]*)\s*(?:<[^;{}()]*>)?\s*$/.exec(code.text.slice(Math.max(0, open - 60), Math.max(0, open)))?.[1] ?? '';
+      if (callee === 'catch') return null;
+      if (close >= 0 && !/[\w$>)\]]\s*$/.test(code.text.slice(Math.max(0, open - 60), Math.max(0, open))) &&
+          /^\)\s*(?:async\s*\*?|sync\s*\*)?\s*(?:=>|\{)/.test(code.text.slice(close, close + 30))) return null;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The `>` closing a Dart type argument list opened at `open` — one followed
+ * by a call, a member or another `>`, which a comparison's `<` never is — or -1.
+ */
+function dartTypeArgumentsEnd(text: string, open: number): number {
+  let depth = 0;
+  for (let k = open; k < text.length && k - open < 400; k++) {
+    const ch = text[k];
+    if (ch === '<') depth++;
+    else if (ch === '>' && --depth === 0) return /^\s*[(.>?]/.test(text.slice(k + 1, k + 4)) ? k : -1;
+    else if (ch === ';' || ch === '{' || ch === '}' || ch === '=') return -1;
+  }
+  return -1;
+}
+
+/** The `(` of the parenthesized group around offset `at`, read backwards; -1 when there is none nearby. */
+function dartGroupOpen(text: string, at: number): number {
+  let parens = 0;
+  let braces = 0;
+  for (let k = at - 1; k >= 0 && at - k < 4000; k--) {
+    const ch = text[k];
+    if (ch === '}') braces++;
+    else if (ch === '{') {
+      if (braces-- === 0) return -1;
+    } else if (braces > 0) continue;
+    else if (ch === ')') parens++;
+    else if (ch === '(') {
+      if (parens-- === 0) return k;
+    } else if (ch === ';') return -1;
+  }
+  return -1;
+}
+
+/** The `)` closing the `(` at `open`; -1 when it is not found nearby. */
+function dartGroupClose(text: string, open: number): number {
+  let depth = 0;
+  for (let k = open; k < text.length && k - open < 8000; k++) {
+    if (text[k] === '(') depth++;
+    else if (text[k] === ')' && --depth === 0) return k;
+  }
+  return -1;
+}
+
+const DART_NAME_USES = new WeakMap<ResolutionContext, Map<string, number[]>>();
+
+/** Where a name is written in a Dart file's code — not as a member (`.name`) — read once per file and name. */
+function dartNameUses(code: DartCode, filePath: string, name: string, context: ResolutionContext): number[] {
+  let memo = DART_NAME_USES.get(context);
+  if (!memo) DART_NAME_USES.set(context, (memo = new Map()));
+  const key = `${filePath}|${name}`;
+  const hit = memo.get(key);
+  if (hit) return hit;
+  const uses = [...code.text.matchAll(new RegExp(`(?<![\\w$.])${name.replace(/\$/g, '\\$')}(?![\\w$])`, 'g'))].map((m) => m.index!);
+  if (memo.size >= 4096) memo.delete(memo.keys().next().value!);
+  memo.set(key, uses);
+  return uses;
+}
+
+/** What the Dart expression starting at `from` evaluates to, read back from where its statement ends. */
+function dartInitializerType(text: string, from: number, ref: UnresolvedRef, context: ResolutionContext, depth: number): string | null {
+  let nest = 0;
+  let k = from;
+  for (; k < text.length && k - from < 4000; k++) {
+    const ch = text[k]!;
+    // `AsyncNotifierProvider.family<A, B, C>(…)`: a type argument list's commas end nothing.
+    if (ch === '<' && /[\w$]/.test(text[k - 1] ?? '')) {
+      const close = dartTypeArgumentsEnd(text, k);
+      if (close > 0) {
+        k = close;
+        continue;
+      }
+    }
+    if (ch === '(' || ch === '[' || ch === '{') nest++;
+    else if (ch === ')' || ch === ']' || ch === '}') {
+      if (nest === 0) break;
+      nest--;
+    } else if ((ch === ';' || ch === ',') && nest === 0) break;
+  }
+  let end = k - 1;
+  while (end >= from && /\s/.test(text[end]!)) end--;
+  if (end < from) return null;
+  return dartExpressionValue(text, end, ref, context, depth)?.type ?? null;
+}
+
+/**
+ * The type a Dart constant is declared with — `static const Foo x = …`,
+ * `final Foo? x` — or, with none written, what its initializer evaluates to:
+ * riverpod's `static const autoDispose = AutoDisposeFutureProviderBuilder();`.
+ */
+function dartConstantType(constant: Node, ref: UnresolvedRef, context: ResolutionContext, depth: number): string | null {
+  const code = dartCodeOf(constant.filePath, context);
+  const from = code?.lineStarts[constant.startLine - 1];
+  if (!code || from === undefined) return null;
+  const head = new RegExp(`\\b(?:const|final|var)\\s+(?:([A-Za-z_$][\\w$.]*)\\s*(?:<[^;=]*>)?\\s*\\??\\s+)?${constant.name.replace(/\$/g, '\\$')}\\s*=(?![=>])`)
+    .exec(code.text.slice(from, from + 600));
+  if (!head) return null;
+  if (head[1] && !DART_NON_TYPE_WORDS.has(head[1])) return dartSimpleTypeName(head[1]);
+  const site: UnresolvedRef = { ...ref, filePath: constant.filePath, line: constant.startLine, column: 0 };
+  return dartInitializerType(code.text, from + head.index + head[0].length, site, context, depth + 1);
+}
+
+/**
+ * The type a Dart class — or a type it extends, mixes in or implements —
+ * declares a field `name` with (`final ProviderPointerManager _pointerManager`),
+ * or what the field is initialized with (`final _cache = Cache()`).
+ */
+function dartFieldType(typeName: string, name: string, ref: UnresolvedRef, context: ResolutionContext, depth: number): string | null {
+  const lineage = [...dartLineage(typeName, context)].sort((a, b) => a[1] - b[1]);
+  for (const [owner] of lineage) {
+    for (const decl of context.getNodesByName(owner)) {
+      if (decl.language !== 'dart' || !DART_TYPE_KINDS.has(decl.kind)) continue;
+      const declared = classMemberType(decl, name, context);
+      if (declared) return dartSimpleTypeName(declared);
+      // An abstract getter mints no node: `ProviderElement? get _listenedElement;`.
+      const getter = new RegExp(String.raw`(?:^|[\s;{}])([A-Za-z_$][\w$]*)\s*(?:<[^;{}=]*>)?\s*\??\s+get\s+${name.replace(/\$/g, '\\$')}\s*;`);
+      for (const { text } of classMemberLines(decl, context)) {
+        const m = text.includes(name) ? getter.exec(text) : null;
+        if (m && !DART_NON_TYPE_WORDS.has(m[1]!)) return dartSimpleTypeName(m[1]!);
+      }
+      const code = dartCodeOf(decl.filePath, context);
+      const from = code?.lineStarts[decl.startLine - 1];
+      const to = code?.lineStarts[decl.endLine];
+      if (!code || from === undefined) continue;
+      const init = new RegExp(`\\b(?:final|var|late)\\s+${name.replace(/\$/g, '\\$')}\\s*=(?![=>])`).exec(code.text.slice(from, to));
+      if (init) {
+        const site: UnresolvedRef = { ...ref, filePath: decl.filePath, line: decl.startLine, column: 0 };
+        return dartInitializerType(code.text, from + init.index + init[0].length, site, context, depth + 1);
+      }
+    }
+  }
+  return null;
+}
+
+/** The simple names a Dart type's declarations extend, mix in, implement, or (an extension / mixin) sit `on`. */
+function dartSupertypesOf(typeName: string, context: ResolutionContext): string[] {
+  let memo = DART_SUPERS.get(context);
+  if (!memo) {
+    memo = new Map();
+    DART_SUPERS.set(context, memo);
+  }
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const names: string[] = [];
+  for (const decl of context.getNodesByName(typeName)) {
+    if (decl.language !== 'dart' || !DART_TYPE_KINDS.has(decl.kind)) continue;
+    names.push(...dartHeadOf(decl, context).supers);
+  }
+  memo.set(typeName, names);
+  return names;
+}
+
+const DART_HEAD_WORDS: ReadonlySet<string> = new Set(['extends', 'with', 'implements', 'on']);
+
+/**
+ * A Dart type declaration's head, read from source up to its body: the
+ * supertypes it names, and whether it is an `extension` (whose one supertype
+ * is the type it extends). Comments and type arguments are dropped first, so
+ * riverpod's `class $NotifierProviderElement< // … NotifierT extends
+ * $Notifier<ValueT>, ValueT > extends $ClassProviderElement<…> with
+ * ElementWithFuture<…>` reads as `extends $ClassProviderElement with
+ * ElementWithFuture`, and `class A = B with C;` as its mixin application.
+ */
+function dartHeadOf(decl: Node, context: ResolutionContext): { supers: string[]; extension: boolean } {
+  const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+  const text = lines
+    .slice(decl.startLine - 1, Math.min(decl.endLine, decl.startLine + 40))
+    .join('\n')
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/\/\/[^\n]*/g, ' ');
+  let depth = 0;
+  let flat = '';
+  for (const ch of text) {
+    if (ch === '<') depth++;
+    else if (ch === '>') depth = Math.max(0, depth - 1);
+    else if (depth === 0) {
+      if (ch === '{' || ch === ';') break;
+      flat += ch;
+    }
+  }
+  const keyword = /\b(class|mixin|extension|enum)\b/.exec(flat);
+  const head = keyword ? flat.slice(keyword.index) : flat;
+  const clause = /(?:\b(?:extends|with|implements|on)\b|=)([\s\S]*)$/.exec(head)?.[1] ?? '';
+  return {
+    supers: [...clause.matchAll(/[A-Za-z_$][\w$]*/g)].map((m) => m[0]).filter((w) => !DART_HEAD_WORDS.has(w)),
+    extension: keyword?.[1] === 'extension' && !/^extension\s+type\b/.test(head),
+  };
+}
+
+const DART_LINEAGES = new WeakMap<ResolutionContext, Map<string, Map<string, number>>>();
+const DART_EXTENSION_OWNERS = new WeakMap<ResolutionContext, Map<string, DartExtensionOwner | null>>();
+const DART_GETTERS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** A Dart type and every type it extends, mixes in or implements, by supertype distance (at most 40). */
+function dartLineage(typeName: string, context: ResolutionContext): Map<string, number> {
+  let memo = DART_LINEAGES.get(context);
+  if (!memo) DART_LINEAGES.set(context, (memo = new Map()));
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const depths = new Map<string, number>();
+  const queue: Array<[string, number]> = [[typeName, 0]];
+  while (queue.length > 0 && depths.size < 40) {
+    const [name, depth] = queue.shift()!;
+    if (depths.has(name)) continue;
+    depths.set(name, depth);
+    for (const sup of dartSupertypesOf(name, context)) queue.push([sup, depth + 1]);
+  }
+  memo.set(typeName, depths);
+  return depths;
+}
+
+/**
+ * The extension a Dart member is declared in — the types it is `on`, whether
+ * it is named, and whether it is `on` a type parameter of its own (`extension
+ * ObjectX<T> on T`, which every type has) — or null for a class's, mixin's or
+ * enum's member.
+ */
+interface DartExtensionOwner { on: string[]; named: boolean; universal: boolean }
+
+function dartExtensionOwner(member: Node, context: ResolutionContext): DartExtensionOwner | null {
+  let memo = DART_EXTENSION_OWNERS.get(context);
+  if (!memo) DART_EXTENSION_OWNERS.set(context, (memo = new Map()));
+  const hit = memo.get(member.id);
+  if (hit !== undefined) return hit;
+  let found: DartExtensionOwner | null = null;
+  const cut = member.qualifiedName.lastIndexOf('::');
+  if (cut > 0) {
+    const ownerQn = member.qualifiedName.slice(0, cut);
+    const owner = context.getNodesInFile(member.filePath).find((n) => n.qualifiedName === ownerQn && n.kind === 'class' &&
+      n.startLine <= member.startLine && n.endLine >= member.startLine);
+    const decl = owner ? dartExtensionDecl(owner, context) : null;
+    if (owner && decl) {
+      const on = dartHeadOf(owner, context).supers;
+      found = { on, named: decl.named, universal: on.length === 1 && declaredTypeParameters(owner, context).includes(on[0]!) };
+    }
+  }
+  memo.set(member.id, found);
+  return found;
+}
+
+/** Whether a Dart member is a getter — declared `get <name>`, a method its readers run. */
+function isDartGetter(n: Node, context: ResolutionContext): boolean {
+  if (n.language !== 'dart' || n.kind !== 'method') return false;
+  let memo = DART_GETTERS.get(context);
+  if (!memo) DART_GETTERS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+  // The declaration from its start, and the next line for a return type that wraps.
+  const head = `${(lines[n.startLine - 1] ?? '').slice(n.startColumn)} ${lines[n.startLine] ?? ''}`;
+  const getter = new RegExp(String.raw`^[^={;]*?\bget\s+${n.name.replace(/\$/g, '\\$')}(?![\w$])`).test(head);
+  memo.set(n.id, getter);
+  return getter;
+}
+
+const DART_SETTERS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** Whether a Dart member is a setter — declared `set <name>(…)`, which no call or read runs. */
+function isDartSetter(n: Node, context: ResolutionContext): boolean {
+  if (n.language !== 'dart' || n.kind !== 'method') return false;
+  let memo = DART_SETTERS.get(context);
+  if (!memo) DART_SETTERS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  const line = (context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [])[n.startLine - 1] ?? '';
+  const setter = new RegExp(String.raw`^[^={;]*?\bset\s+${n.name.replace(/\$/g, '\\$')}\s*\(`).test(line.slice(n.startColumn));
+  memo.set(n.id, setter);
+  return setter;
+}
+
+/**
+ * The Dart member `name` a value of type `typeName` reaches, as Dart finds it:
+ * the nearest one the type or a type it extends, mixes in or implements
+ * declares, else one an extension on such a type adds — an extension applies
+ * only where no instance member answers, and an unnamed one only in its own
+ * library. `accept` narrows the candidates (a read wants a getter). Ties go to
+ * the call site's own file, then the nearest directory — riverpod's translated
+ * docs carry their own copy of each example's extension. `minDepth` 1 skips
+ * the type's own members, as `super.` does.
+ */
+function dartMemberOf(
+  typeName: string,
+  name: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  accept: (n: Node) => boolean,
+  minDepth = 0,
+): { node: Node; viaExtension: boolean } | null {
+  const lineage = dartLineage(typeName, context);
+  const depthOf = (t: string): number => {
+    const depth = lineage.get(t);
+    return depth === undefined || depth < minDepth ? Infinity : depth;
+  };
+  let best: Node[] = [];
+  let bestRank = Infinity;
+  let isProjectType: boolean | undefined;
+  for (const m of context.getNodesByName(name)) {
+    if (m.language !== 'dart' || !isDartMember(m) || !accept(m)) continue;
+    const extension = dartExtensionOwner(m, context);
+    let rank: number;
+    if (extension) {
+      if (!extension.named && !inSameDartLibrary(ref.filePath, m.filePath, context)) continue;
+      // `extension ObjectX<T> on T` reaches every type, after every extension
+      // that names one of its lineage — when the type is the project's, so
+      // what it declares is known: a List's own `cast` is not ObjectX's.
+      const on = extension.universal
+        ? (isProjectType ??= context.getNodesByName(typeName).some((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind)))
+          ? DART_UNIVERSAL_RANK : Infinity
+        : Math.min(...extension.on.map(depthOf));
+      if (on === Infinity) continue;
+      rank = DART_EXTENSION_RANK + on;
+    } else {
+      const owner = m.qualifiedName.slice(0, Math.max(0, m.qualifiedName.lastIndexOf('::'))).split('::').pop()!;
+      const depth = depthOf(owner);
+      if (depth === Infinity) continue;
+      rank = depth;
+    }
+    if (rank < bestRank) {
+      bestRank = rank;
+      best = [m];
+    } else if (rank === bestRank) {
+      best.push(m);
+    }
+  }
+  if (best.length === 0) return null;
+  const node = best.find((n) => n.filePath === ref.filePath) ??
+    best.reduce((a, b) => (computePathProximity(ref.filePath, b.filePath) > computePathProximity(ref.filePath, a.filePath) ? b : a));
+  return { node, viaExtension: bestRank >= DART_EXTENSION_RANK };
+}
+
+/** `x.area` / `Config.instance`: the receiver and member of a Dart member read. */
+const DART_MEMBER_READ = /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/;
+
+/**
+ * Whether a ref is a Dart member read — `x.area`, which the extractor records
+ * as a `references` ref named `<receiver>.<member>`. No other Dart reference
+ * carries a dotted name: a type is one identifier, a static read names only
+ * its type.
+ */
+export function isDartMemberRead(ref: UnresolvedRef): boolean {
+  return ref.language === 'dart' && ref.referenceKind === 'references' && DART_MEMBER_READ.test(ref.referenceName);
+}
+
+/**
+ * A Dart member read runs code only when the member is a getter, so it links
+ * — as a call — the getter the receiver's type reaches: declared on the type, a
+ * type it extends, mixes in or implements, or added by an extension on one of
+ * them (`s.label` on an enum `Shape` through `extension ShapeInfo on Shape`),
+ * or nothing: a field read, a getter of a type outside the project, a receiver
+ * whose type is not written down. Never a same-named getter found by name alone
+ * (#2338).
+ */
+export function matchDartMemberRead(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const parts = DART_MEMBER_READ.exec(ref.referenceName);
+  if (!parts) return null;
+  const receiver = parts[1]!;
+  const member = parts[2]!;
+  // Most reads are of fields, which mint no nodes: check for a getter first.
+  if (!context.getNodesByName(member).some((n) => isDartGetter(n, context))) return null;
+  // A type named directly reads its static getter (`Config.instance`); a
+  // variable is typed by its declaration — a parameter or local in scope, else
+  // a field of the class the read is written in (`final Box box;`).
+  const typeName = /^[A-Z]/.test(receiver) &&
+    context.getNodesByName(receiver).some((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind))
+    ? receiver
+    : inferLocalReceiverType(receiver, ref, context) ?? inferMemberReceiverType(receiver, ref, context);
+  if (!typeName) return null;
+  const found = dartMemberOf(typeName, member, ref, context, (n) => isDartGetter(n, context));
+  if (!found) return null;
+  return { original: ref, targetNodeId: found.node.id, confidence: 0.9, resolvedBy: 'instance-method', edgeKind: 'calls' };
+}
+
+/**
+ * Whether a ref is a Dart annotation — `@riverpod`, `@Riverpod(keepAlive:
+ * true)`, `@meta.immutable` — which the extractor records by its last name, at
+ * the `@`.
+ */
+export function isDartAnnotation(ref: UnresolvedRef): boolean {
+  return ref.language === 'dart' && ref.referenceKind === 'decorates';
+}
+
+/**
+ * A Dart annotation is a constant expression: a `const` variable, or a call of
+ * a `const` constructor. So it links, as it is written, a constant or (called)
+ * a class its library can see, through the import prefix it is written with;
+ * a static constant, an enum value or (called) a named constructor of the
+ * type it is written through (`@Foo.value`, `@Foo.named(…)`); or, on a
+ * member, a static constant of the type around it. Never a method, a
+ * getter or a function: riverpod's 506 `@riverpod` annotations went to
+ * riverpod_analyzer_utils' extension getter `riverpod`, not riverpod_annotation's
+ * `const riverpod = Riverpod();`.
+ */
+export function matchDartAnnotation(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const name = ref.referenceName;
+  if (!context.getNodesByName(name).some((n) => n.language === 'dart')) return null;
+  const written = dartAnnotationAt(ref, context);
+  if (!written) return null;
+  const { names, call } = written;
+  let pool: Node[];
+  let resolvedBy: ResolvedRef['resolvedBy'] = 'exact-match';
+  if (names.length === 1 || (names.length === 2 && dartImportPrefixes(ref.filePath, context).has(names[0]!))) {
+    const prefix = names.length === 2 ? names[0]! : null;
+    const own = prefix === null && !call ? dartEnclosingStatic(name, ref, context) : null;
+    if (own) return { original: ref, targetNodeId: own.id, confidence: 0.9, resolvedBy };
+    pool = context.getNodesByName(name).filter((n) => isDartLibraryDecl(n) &&
+      (call ? isDartAnnotationClass(n, context) : n.kind === 'constant') && isDartTopLevelVisible(n, ref, context, prefix));
+    if (prefix === null) pool = preferOwnDartLibrary(pool, ref, context);
+  } else if (names.length === 2 || (names.length === 3 && dartImportPrefixes(ref.filePath, context).has(names[0]!))) {
+    const prefix = names.length === 3 ? names[0]! : null;
+    let owners = context.getNodesByName(names[names.length - 2]!).filter((n) =>
+      isDartLibraryDecl(n) && DART_TYPE_KINDS.has(n.kind) && isDartTopLevelVisible(n, ref, context, prefix));
+    if (prefix === null) owners = preferOwnDartLibrary(owners, ref, context);
+    pool = context.getNodesByName(name).filter((m) => m.language === 'dart' &&
+      owners.some((o) => o.filePath === m.filePath && m.qualifiedName === `${o.qualifiedName}::${name}`) &&
+      (call ? isDartConstructor(m, context) : m.kind === 'constant' || m.kind === 'enum_member'));
+    resolvedBy = 'qualified-name';
+  } else {
+    return null;
+  }
+  if (pool.length <= 1) return pool[0] ? { original: ref, targetNodeId: pool[0].id, confidence: 0.9, resolvedBy } : null;
+  // Libraries this cannot establish see every file's declarations.
+  const best = findBestMatch(ref, pool, context);
+  return best
+    ? { original: ref, targetNodeId: best.id, confidence: computePathProximity(ref.filePath, best.filePath) >= 30 ? 0.7 : 0.4, resolvedBy }
+    : null;
+}
+
+/** A class a Dart annotation can call a constructor of: not an extension, which has none. */
+function isDartAnnotationClass(n: Node, context: ResolutionContext): boolean {
+  return n.kind === 'class' && dartExtensionDecl(n, context) === null;
+}
+
+/**
+ * The static constant or enum value `name` of the type a Dart annotation is
+ * written in, which a member's annotation names bare. A class's own
+ * annotations stand outside its body.
+ */
+function dartEnclosingStatic(name: string, ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  let own: Node | null = null;
+  for (const n of context.getNodesInFile(ref.filePath)) {
+    if (DART_TYPE_KINDS.has(n.kind) && n.id !== ref.fromNodeId && n.startLine <= ref.line && n.endLine >= ref.line &&
+        (!own || n.startLine >= own.startLine)) own = n;
+  }
+  if (!own) return null;
+  const qualifiedName = `${own.qualifiedName}::${name}`;
+  return context.getNodesByName(name).find((m) => m.language === 'dart' && m.filePath === ref.filePath &&
+    m.qualifiedName === qualifiedName && (m.kind === 'constant' || m.kind === 'enum_member')) ?? null;
+}
+
+/**
+ * How a Dart annotation is written — the names of `@p.Foo.named(…)` up to the
+ * one its ref records, and whether it is called — read from its `@`. The
+ * extractor records the last name, or the one a type argument list follows
+ * (`@Foo<int>.named(…)` is `Foo`'s).
+ */
+function dartAnnotationAt(ref: UnresolvedRef, context: ResolutionContext): { names: string[]; call: boolean } | null {
+  const code = dartCodeOf(ref.filePath, context);
+  const from = code?.lineStarts[ref.line - 1];
+  if (!code || from === undefined) return null;
+  const to = code.lineStarts[ref.line] ?? code.text.length;
+  // On a line with non-ASCII text before it, the `@` whose names fit stands in.
+  const ats = [from + ref.column];
+  for (let k = code.text.indexOf('@', from); k >= 0 && k < to; k = code.text.indexOf('@', k + 1)) {
+    if (k !== from + ref.column) ats.push(k);
+  }
+  for (const at of ats) {
+    const read = code.text[at] === '@' ? readDartAnnotation(code.text, at + 1) : null;
+    const end = read ? (read.typeArgsAt >= 0 ? read.typeArgsAt : read.names.length - 1) : -1;
+    if (read && read.names[end] === ref.referenceName) return { names: read.names.slice(0, end + 1), call: read.call };
+  }
+  return null;
+}
+
+/** A Dart annotation's dotted names, which of them a type argument list follows, and whether `(` comes next on its line. */
+function readDartAnnotation(text: string, i: number): { names: string[]; typeArgsAt: number; call: boolean } | null {
+  const names: string[] = [];
+  let typeArgsAt = -1;
+  const identifier = /[ \t]*([A-Za-z_$][\w$]*)[ \t]*/y;
+  while (names.length < 8) {
+    identifier.lastIndex = i;
+    const m = identifier.exec(text);
+    if (!m) return null;
+    names.push(m[1]!);
+    i = identifier.lastIndex;
+    if (text[i] === '<' && typeArgsAt < 0) {
+      const close = dartTypeArgumentsEnd(text, i);
+      if (close < 0) return null;
+      typeArgsAt = names.length - 1;
+      for (i = close + 1; text[i] === ' ' || text[i] === '\t'; i++);
+    }
+    if (text[i] !== '.') break;
+    i++;
+  }
+  return { names, typeArgsAt, call: text[i] === '(' };
+}
+
+/**
+ * A member an extension adds to `typeName` — `s.shout()` on an enum `Shape`
+ * through `extension ShapeInfo on Shape` — when the type itself declares none
+ * (#2338). An inherited instance member is left to the strategies that
+ * resolve it today.
+ */
+function dartExtensionMemberOf(typeName: string, name: string, ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  const found = dartMemberOf(typeName, name, ref, context, () => true);
+  return found?.viaExtension ? found.node : null;
+}
+
+/**
+ * A Dart call through a type's name — `BlocProvider.value(…)`, riverpod's
+ * `FutureProvider.autoDispose(…)` — is to one of that type's own constructors
+ * or static members, or to nothing the project declares. Dart inherits none
+ * of them, so a guess past the type is always wrong: flutter_bloc's
+ * `BlocProvider.value(…)` went to `RepositoryProvider`'s `value` 89 times,
+ * riverpod's `Family2Family._()` to the `EmptyFamily2Family._` declared above
+ * it, and the SDK's `Uri.parse(…)`, past bloc_lint's `extension on Uri`, to a
+ * project `parse`. A static constant's callee is the value it holds (`static
+ * const autoDispose = AutoDisposeFutureProviderBuilder();`). The member is
+ * found as a chain's static link finds it (dartStaticMember). Written through
+ * an import prefix (`p.Box<int>.named(…)`, which arrives as `Box.named`), the
+ * type is the one that import brings in, if any. Undefined when the receiver
+ * names no Dart type of the project.
+ */
+function matchDartTypeMemberCall(
+  typeName: string,
+  member: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): ResolvedRef | null | undefined {
+  const types = context.getNodesByName(typeName).filter((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind));
+  const prefix = types.length > 0 || /^[_$]*[A-Z]/.test(typeName) ? dartTypeCallPrefix(typeName, member, ref, context) : null;
+  const isOwner = (n: Node): boolean => prefix === null || dartPrefixSees(ref.filePath, prefix, n.filePath, typeName, context);
+  if (!types.some(isOwner)) return prefix === null ? undefined : null;
+  const own = dartStaticMember(typeName, member, ref, context, isOwner);
+  return own && own.kind !== 'enum_member'
+    ? { original: ref, targetNodeId: own.id, confidence: 0.85, resolvedBy: 'qualified-name' } : null;
+}
+
+/**
+ * How a bare Rust or Go name is written at its call: `path` after `::` (left
+ * to the path strategies), `chained` after a `.` — with the receiver it is
+ * written on, call and type arguments dropped — or `bare`. The extractors
+ * keep one receiver level, so `sym.filename().map(From::from)` and
+ * `child.Flags().String("f", …)` arrive as bare `map` / `String`.
+ */
+function rustGoCallShape(ref: UnresolvedRef, context: ResolutionContext): { shape: 'path' } | { shape: 'bare' } | { shape: 'chained'; receiver: string } | null {
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split('\n');
+  let line = lines?.[ref.line - 1];
+  if (line === undefined) return null;
+  const name = ref.referenceName;
+  const at = new RegExp(`(?<![\\w$])${name}\\s*(?:\\(|::<|!)`);
+  let start = line.startsWith(name, ref.column) ? ref.column : -1;
+  if (start < 0) {
+    const m = at.exec(line);
+    start = m ? m.index : -1;
+  }
+  // A link further down a chain the call's line starts — `bat()\n  .arg(…)\n  .stdout(…)` —
+  // is recorded at the chain's first line.
+  for (let next = ref.line; start < 0 && lines && next < Math.min(lines.length, ref.line + 20); next++) {
+    const m = /^\s*\./.test(lines[next]!) ? at.exec(lines[next]!) : null;
+    if (m) {
+      // Named after the chain's head: `Command::new("true")` for its `.stdout(…)`.
+      if (/^\s*\.\s*$/.test(lines[next]!.slice(0, m.index))) {
+        return { shape: 'chained', receiver: rustGoReceiverName(line.trimEnd().replace(/[?;]+$/, '')) };
+      }
+      line = lines[next]!;
+      start = m.index;
+    }
+  }
+  if (start < 0) return null;
+  const before = line.slice(0, start);
+  if (/::\s*$/.test(before)) return { shape: 'path' };
+  if (!/\.\s*$/.test(before)) return { shape: 'bare' };
+  return { shape: 'chained', receiver: rustGoReceiverName(before.replace(/\?\s*\.\s*$/, '')) };
+}
+
+/**
+ * The receiver a Rust / Go `….name(` is written on, as its path and dotted
+ * identifiers with arguments dropped — `Command::new("x").short_flag('f')` →
+ * `Command::new.short_flag`, a macro `arg!(…)` → `arg`, a Go composite
+ * literal `(JSON{data})` → `JSON`. Read backwards to the expression's start.
+ */
+function rustGoReceiverName(text: string): string {
+  let out = '';
+  let i = text.replace(/\s*\.\s*$/, '').length - 1;
+  const src = text.replace(/\s*\.\s*$/, '');
+  while (i >= 0) {
+    const ch = src[i]!;
+    if (ch === ')' || ch === ']' || ch === '}') {
+      const open = ch === ')' ? '(' : ch === ']' ? '[' : '{';
+      let depth = 0;
+      let j = i;
+      for (; j >= 0; j--) {
+        if (src[j] === ch) depth++;
+        else if (src[j] === open && --depth === 0) break;
+      }
+      if (j < 0) return '';
+      // `(JSON{data})` — a parenthesized composite literal names its type.
+      if (ch === ')' && out === '') {
+        const literal = /^\(\s*&?\s*([A-Za-z_][\w.]*)\s*\{/.exec(src.slice(j, i + 1));
+        if (literal) return literal[1]!;
+      }
+      i = j - 1;
+    } else if (/[\w$.:!]/.test(ch)) {
+      if (ch !== '!') out = ch + out;
+      i--;
+    } else break;
+  }
+  return out.replace(/^[.:]+|[.:]+$/g, '');
+}
+
+/**
+ * Whether a Rust / Go call of that shape can mean `n`. A bare call never
+ * reaches a method (Rust needs `self.` / `Type::`, Go a receiver): axum's
+ * routing `get(handler)` went to a cookie jar's `get`. A chained call reaches
+ * a method of what its receiver is named after (or of `self`), never a free
+ * function: tokio's `sym.filename().map(…)` went to `MutexGuard::map` 156
+ * times, cobra's `c.Flags().String(…)` to a test type's `String`.
+ */
+function isRustGoCallTarget(n: Node, shape: ReturnType<typeof rustGoCallShape>): boolean {
+  if (!shape || shape.shape === 'path') return true;
+  const member = n.kind === 'method';
+  if (shape.shape === 'bare') return !member;
+  if (!member) return n.kind !== 'function';
+  // A name the standard library's own types all carry (`unwrap`, `clone`,
+  // `iter`, Go's `String` / `Get`) needs a receiver named after the owner; a
+  // project-specific one keeps its match — clap's `flag("n").short('n')` is
+  // `Arg::short`, cobra's `c.Root().Name()` `Command::Name`.
+  // Go's `w.Header().Get(…)` / `r.Header.Set(…)`: net/http's Header map.
+  if (n.language === 'go' && /(?:^|\.)Header$/.test(shape.receiver) && /^(?:Get|Set|Add|Del|Values|Clone|Write)$/.test(n.name)) return false;
+  const std = (n.language === 'go' ? GO_STD_METHODS : RUST_STD_METHODS).has(n.name);
+  return !std || /^(?:self|Self)$/.test(shape.receiver) || (shape.receiver !== '' && sharesReceiverWord(shape.receiver, n));
+}
+
+/**
+ * Kotlin's scope functions and standard collection / string / conversion
+ * methods: on an untyped chain link (`builder.apply { … }`, `list.map { … }`)
+ * they are the standard library's, never a project type's same-named member.
+ * Names project types commonly carry (`get`, `write`, `close`, `add`) are left
+ * out — okio's `sink.write(…)` is its own Buffer's.
+ */
+const KOTLIN_STD_METHODS: ReadonlySet<string> = new Set([
+  'apply', 'also', 'let', 'run', 'takeIf', 'takeUnless', 'toString', 'equals', 'hashCode', 'map', 'mapNotNull',
+  'mapIndexed', 'filter', 'filterNot', 'filterIsInstance', 'forEach', 'forEachIndexed', 'first', 'firstOrNull',
+  'last', 'lastOrNull', 'single', 'singleOrNull', 'isEmpty', 'isNotEmpty', 'isNullOrEmpty', 'isNullOrBlank',
+  'isBlank', 'isNotBlank', 'orEmpty', 'joinToString', 'toList', 'toMutableList', 'toSet', 'toMutableSet', 'toMap',
+  'toTypedArray', 'any', 'all', 'none', 'count', 'sumOf', 'maxOf', 'minOf', 'maxOrNull', 'minOrNull', 'sortedBy',
+  'sortedByDescending', 'sorted', 'sortedWith', 'reversed', 'drop', 'dropLast', 'take', 'takeLast', 'zip',
+  'flatMap', 'flatten', 'distinct', 'groupBy', 'associate', 'associateBy', 'associateWith', 'partition',
+  'contains', 'containsKey', 'getOrElse', 'getOrNull', 'getOrPut', 'getOrDefault', 'trim', 'trimEnd', 'trimStart',
+  'split', 'substring', 'startsWith', 'endsWith', 'replace', 'lowercase', 'uppercase', 'toInt', 'toLong',
+  'toDouble', 'toFloat', 'toIntOrNull', 'toLongOrNull', 'encodeToByteArray', 'decodeToString',
+  'copyOf', 'copyOfRange', 'indexOf', 'lastIndexOf', 'withIndex', 'asSequence', 'asList', 'ifEmpty', 'ifBlank',
+  'padStart', 'padEnd', 'repeat', 'lines', 'toCharArray', 'coerceAtLeast', 'coerceAtMost', 'coerceIn',
+]);
+
+/**
+ * Methods of .NET's base types, collections, streams, strings, LINQ and
+ * reflection — names a project type overrides or wraps, which a call through
+ * an untyped receiver means only when the receiver is named after the owner.
+ * Newtonsoft's `reader.Value.ToString()` went to its JValue's `ToString`,
+ * `table.Columns.Add(…)` to a name table's `Add`.
+ */
+const CSHARP_STD_METHODS: ReadonlySet<string> = new Set([
+  'ToString', 'Equals', 'GetHashCode', 'GetType', 'CompareTo', 'Add', 'AddRange', 'Remove', 'RemoveAt', 'RemoveAll',
+  'Contains', 'ContainsKey', 'ContainsValue', 'Clear', 'Insert', 'IndexOf', 'CopyTo', 'ToArray', 'ToList',
+  'ToDictionary', 'GetEnumerator', 'MoveNext', 'Reset', 'TryGetValue', 'GetValueOrDefault', 'TryAdd', 'Write',
+  'WriteLine', 'WriteAsync', 'WriteLineAsync', 'Read', 'ReadAsync', 'ReadLine', 'ReadToEnd', 'Flush', 'FlushAsync',
+  'Close', 'Dispose', 'DisposeAsync', 'Parse', 'TryParse', 'Format', 'Join', 'Split', 'Replace', 'Substring', 'Trim',
+  'TrimStart', 'TrimEnd', 'StartsWith', 'EndsWith', 'ToUpper', 'ToLower', 'ToUpperInvariant', 'ToLowerInvariant',
+  'Select', 'Where', 'First', 'FirstOrDefault', 'Single', 'SingleOrDefault', 'Last', 'LastOrDefault', 'Any', 'All',
+  'Count', 'Sum', 'Max', 'Min', 'OrderBy', 'OrderByDescending', 'GroupBy', 'Skip', 'Take', 'Distinct', 'Concat',
+  'Cast', 'OfType', 'Aggregate', 'Invoke', 'DynamicInvoke', 'GetMethod', 'GetProperty', 'GetField', 'GetConstructor',
+  'GetCustomAttributes', 'GetGenericArguments', 'MakeGenericType', 'IsAssignableFrom', 'ConfigureAwait', 'Wait',
+  'ContinueWith', 'Append', 'AppendLine', 'Peek', 'Push', 'Pop', 'Enqueue', 'Dequeue', 'HasFlag', 'Find', 'FindAll',
+  'ForEach', 'Sort', 'Reverse', 'Clone', 'Seek', 'SetLength',
+]);
+
+/** The same .NET names as VB.NET writes them — in any case. */
+const VBNET_STD_METHODS: ReadonlySet<string> = new Set([...CSHARP_STD_METHODS].map((m) => m.toLowerCase()));
+
+/**
+ * A request handler the web framework dispatches to: a Django / DRF / Flask
+ * view's `get` / `post` / …, a controller's `index` / `store` / `update` /
+ * `destroy`. Nothing calls one through an instance by name, so a guess from
+ * a Django test's `client.post(…)` (allauth: 425 times on a
+ * ClientRegistrationView) or an Eloquent `$page->update(…)` is never one.
+ */
+const DISPATCHED_OWNER = /(?:View|ViewSet|APIView|Controller|Endpoint|ViewMixin)$/;
+const DISPATCHED_ACTIONS: ReadonlySet<string> = new Set([
+  'get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'index', 'show', 'store', 'update', 'destroy',
+  'create', 'edit', 'list', 'retrieve', 'partial_update',
+]);
+
+/** A test double's name: Fake…, Mock…, Stub…, Dummy…, Spy…, …Fake, …Mock, …Stub. */
+const TEST_DOUBLE_OWNER = /\b(?:fake|mock|mocked|stub|dummy|spy)\b/i;
+
+/** A method of a test double (`MockedResponse`, `_FakeHTTPResponse`) the receiver and the calling file never name. */
+function isUnnamedTestDouble(method: Node, receiver: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut <= 0) return false;
+  const owner = method.qualifiedName.slice(0, cut).split(/::|\./).pop()!;
+  if (!TEST_DOUBLE_OWNER.test(splitCamelCase(owner).join(' '))) return false;
+  if (splitCamelCase(receiverLink(receiver)).some((w) => TEST_DOUBLE_OWNER.test(w))) return false;
+  return !(context.readFile(ref.filePath) ?? '').includes(owner);
+}
+
+/**
+ * The link of a dotted receiver its value is named after: the last, or for a
+ * constant (`InitializationPhase.CONTROLLERS`, `Foo.INSTANCE`) the type it
+ * belongs to.
+ */
+function receiverLink(receiver: string): string {
+  const links = receiver.split('.');
+  const last = links[links.length - 1]!;
+  return links.length > 1 && /^[A-Z][A-Z0-9_]+$/.test(last) ? links[links.length - 2]! : last;
+}
+
+/** The standard-library method names of a language whose receiver-less guesses need the receiver to name the owner. */
+function stdMethodNames(language: string): ReadonlySet<string> | null {
+  switch (language) {
+    case 'go': return GO_STD_METHODS;
+    case 'rust': return RUST_STD_METHODS;
+    case 'kotlin': return KOTLIN_STD_METHODS;
+    case 'csharp': return CSHARP_STD_METHODS;
+    case 'vbnet': return VBNET_STD_METHODS;
+    case 'dart': return DART_STD_METHODS;
+    default: return null;
+  }
+}
+
+/** Whether `name` is one of `language`'s standard-library method names (VB.NET's in any case). */
+export function isStdMethodName(language: string, name: string): boolean {
+  return stdMethodNames(language)?.has(language === 'vbnet' ? name.toLowerCase() : name) ?? false;
+}
+
+/** Methods of Dart's String, List, Iterable, Map and Set — names a project type rarely carries itself. */
+const DART_STD_METHODS: ReadonlySet<string> = new Set([
+  'endsWith', 'startsWith', 'contains', 'split', 'substring', 'trim', 'trimLeft', 'trimRight', 'toLowerCase',
+  'toUpperCase', 'replaceAll', 'replaceFirst', 'replaceRange', 'indexOf', 'lastIndexOf', 'padLeft', 'padRight',
+  'codeUnitAt', 'allMatches', 'firstMatch', 'hasMatch', 'addAll', 'removeAt', 'removeWhere', 'removeLast',
+  'retainWhere', 'insertAll', 'where', 'whereType', 'forEach', 'toList', 'toSet', 'join', 'reduce', 'fold',
+  'any', 'every', 'firstWhere', 'lastWhere', 'singleWhere', 'containsKey', 'containsValue', 'putIfAbsent',
+  'sublist', 'take', 'takeWhile', 'skip', 'skipWhile', 'expand', 'cast', 'compareTo', 'elementAt', 'followedBy',
+  'asMap', 'getRange', 'setAll', 'fillRange', 'shuffle', 'sort', 'indexWhere', 'lastIndexWhere',
+]);
+
+/**
+ * Whether a receiver is named after the owner of `method` — for a Dart
+ * extension, after the type it is `on`: getx's `ext.endsWith(".avi")` on a
+ * String shares a word with `RxStringExt`, none with its `Rx<String>`.
+ */
+function receiverNamesOwner(receiver: string, method: Node, context: ResolutionContext): boolean {
+  if (method.language === 'dart') {
+    const cut = method.qualifiedName.lastIndexOf('::');
+    const owner = cut > 0 ? method.qualifiedName.slice(0, cut).split('::').pop()! : '';
+    const decl = owner ? context.getNodesByName(owner).find((n) => n.language === 'dart' && n.filePath === method.filePath) : undefined;
+    const line = decl ? (context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [])[decl.startLine - 1] ?? '' : '';
+    const on = /\bextension\s+\w*\s*(?:<[^>]*>)?\s*on\s+([\w<>, ?]+?)\s*\{/.exec(line)?.[1];
+    if (on) return sharesReceiverWord(receiver, { ...method, qualifiedName: `${on.replace(/[<>, ?]+/g, '')}::${method.name}` });
+  }
+  return sharesReceiverWord(receiver, method);
+}
+
+/**
+ * The Dart `extension` declaration a class node stands for, read from its
+ * head past the annotations the node starts with (riverpod's `@internal
+ * extension ContainerReadElement on ProviderContainer`): `named` false for
+ * `extension on X`.
+ */
+function dartExtensionDecl(n: Node, context: ResolutionContext): { named: boolean } | null {
+  if (n.language !== 'dart' || n.kind !== 'class') return null;
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+  const head = lines.slice(n.startLine - 1, Math.min(n.endLine, n.startLine + 5)).join('\n')
+    .replace(/^\s*(?:(?:@[\w$.]+(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\/[^\n]*)\s*)*/, '');
+  if (!/^extension\b(?!\s+type\b)/.test(head)) return null;
+  // A generic one has no name either: riverpod's `extension<PointerT extends
+  // _PointerBase, ProviderT extends ProviderOrFamily> on Map<…>` took the
+  // `Map` type references of riverpod's own library.
+  return { named: !/^extension\s*(?:<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?\s*on\b/.test(head) };
+}
+
+/** Whether a Dart method belongs to an unnamed `extension on X`, visible only in its own library. */
+function isDartUnnamedExtensionMember(method: Node, context: ResolutionContext): boolean {
+  if (method.language !== 'dart' || method.kind !== 'method') return false;
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut <= 0) return false;
+  const ownerQn = method.qualifiedName.slice(0, cut);
+  const owner = context.getNodesInFile(method.filePath).find((n) => n.qualifiedName === ownerQn && n.kind === 'class' &&
+    n.startLine <= method.startLine && n.endLine >= method.startLine);
+  return owner !== undefined && dartExtensionDecl(owner, context)?.named === false;
+}
+
+const CSHARP_ALIASES = new WeakMap<ResolutionContext, Map<string, Map<string, string>>>();
+
+/**
+ * The type a C# file's `using Name = Some.Namespace.Type;` (or `global using`)
+ * aliases `name` to, as its simple name — or null.
+ */
+function csharpUsingAlias(name: string, ref: UnresolvedRef, context: ResolutionContext): string | null {
+  if (!/^[A-Za-z_]\w*$/.test(name)) return null;
+  let memo = CSHARP_ALIASES.get(context);
+  if (!memo) {
+    memo = new Map();
+    CSHARP_ALIASES.set(context, memo);
+  }
+  let aliases = memo.get(ref.filePath);
+  if (!aliases) {
+    aliases = new Map();
+    const source = context.readFile(ref.filePath) ?? '';
+    for (const m of source.matchAll(/^\s*(?:global\s+)?using\s+([A-Za-z_]\w*)\s*=\s*(?:global::)?([\w.]+)\s*(?:<[^;>]*>)?\s*;/gm)) {
+      aliases.set(m[1]!, m[2]!.split('.').pop()!);
+    }
+    memo.set(ref.filePath, aliases);
+  }
+  return aliases.get(name) ?? null;
+}
+
+/** The receiver a Kotlin chain link `….name(` / `?.name {` is written on, or null for a call with none. */
+function kotlinChainReceiver(ref: UnresolvedRef, context: ResolutionContext): string | null {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return null;
+  const name = ref.referenceName;
+  let start = line.startsWith(name, ref.column) ? ref.column : -1;
+  if (start < 0) {
+    const m = new RegExp(`(?<![\\w$])${name}\\s*[({]`).exec(line);
+    start = m ? m.index : -1;
+  }
+  if (start < 0) {
+    // An infix call on an expression — `alias(libs.x) apply false` — whose
+    // receiver the extractor could not name.
+    const infix = new RegExp(`(?<=[\\w)\\]"'}]\\s+)${name}\\s+(?=[^\\s=])`).exec(line);
+    return infix ? rustGoReceiverName(line.slice(0, infix.index).trimEnd()) : null;
+  }
+  const before = line.slice(0, start);
+  if (!/\.\s*$/.test(before)) return null;
+  return rustGoReceiverName(before.replace(/\?\s*\.\s*$/, '').replace(/!!\s*$/, ''));
+}
+
+const KOTLIN_BITWISE_INFIX: ReadonlySet<string> = new Set(['and', 'or', 'xor', 'shl', 'shr', 'ushr', 'inv']);
+const KOTLIN_NUMBER_TYPES: ReadonlySet<string> = new Set(['Byte', 'Short', 'Int', 'Long', 'UByte', 'UShort', 'UInt', 'ULong', 'Char']);
+
+/**
+ * A project's bitwise extension on a number type — okio's `infix fun
+ * Byte.and(mask: Int)` — is indistinguishable, without the operand's type,
+ * from the standard library's own `Int.and` / `Long.shr` members every other
+ * `x and 0xff` / `h shr 8` calls; neither is a safe edge.
+ */
+function isKotlinNumberBitwise(n: Node, ref: UnresolvedRef): boolean {
+  if (ref.language !== 'kotlin' || !KOTLIN_BITWISE_INFIX.has(n.name)) return false;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  return cut > 0 && KOTLIN_NUMBER_TYPES.has(n.qualifiedName.slice(0, cut).split(/::|\./).pop()!);
+}
+
+/** Whether a bare Kotlin name is written with no receiver at its call — not a later link of a chain (`….name(`). */
+function isReceiverLessKotlinCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return false;
+  const name = ref.referenceName;
+  let start = line.startsWith(name, ref.column) && !/[\w$]/.test(line[ref.column - 1] ?? '') ? ref.column : -1;
+  if (start < 0) {
+    const m = new RegExp(`(?<![\\w$])${name.replace(/\$/g, '\\$')}\\s*[({<]`).exec(line);
+    start = m ? m.index : -1;
+  }
+  return start >= 0 && !/[.:]\s*$/.test(line.slice(0, start));
+}
+
+/**
+ * Whether a bare `require(…)` / `check(…)` / `assert(…)` is Kotlin's
+ * precondition: its condition is a comparison or boolean expression, or a
+ * lazy message follows it.
+ */
+function isKotlinPreconditionCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (!/^(?:require|check|assert)$/.test(ref.referenceName)) return false;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  const at = line ? new RegExp(`(?<![\\w.])${ref.referenceName}\\s*\\(`).exec(line) : null;
+  if (!line || !at) return false;
+  let depth = 0;
+  let args = '';
+  let rest = '';
+  for (let i = at.index + at[0].length; i < line.length; i++) {
+    const ch = line[i]!;
+    if (ch === '(') depth++;
+    else if (ch === ')' && depth-- === 0) {
+      rest = line.slice(i + 1);
+      break;
+    }
+    args += ch;
+  }
+  return /[<>=!]=|&&|\|\||(?:^|[\s(])!|\s[<>]\s|\bis\b|\bin\b|\btrue\b|\bfalse\b/.test(args) || /^\s*\{/.test(rest);
+}
+
+const KOTLIN_RECEIVER_TYPES = new WeakMap<ResolutionContext, Set<string>>();
+
+/**
+ * Every type a Kotlin function type in the project takes as its receiver —
+ * `Module` in `typealias ModuleDeclaration = Module.() -> Unit`, `Scope` in
+ * `Scope.(ParametersHolder) -> T`, `JdbcTransaction` in `statement:
+ * JdbcTransaction.(TestDB) -> Unit`. A lambda of such a type runs with that
+ * receiver, so a bare call inside one reaches its members.
+ */
+function kotlinReceiverTypes(context: ResolutionContext): Set<string> {
+  const hit = KOTLIN_RECEIVER_TYPES.get(context);
+  if (hit) return hit;
+  const types = new Set<string>();
+  const outside = new Set<string>();
+  for (const file of context.getAllFiles()) {
+    if (!/\.kts?$/.test(file)) continue;
+    const source = stripCommentsForRegex(context.readFile(file) ?? '', 'java');
+    for (const m of source.matchAll(/\b([A-Z]\w*)(?:<[^<>()]*(?:<[^<>()]*>[^<>()]*)*>)?\s*\.\s*\(/g)) types.add(m[1]!);
+    // An extension on a type from outside the project (`fun
+    // MacrobenchmarkScope.waitForContent()`, `fun StringBuilder.padInt(…)`)
+    // is written to be called inside that library's lambdas.
+    for (const m of source.matchAll(/\bfun\s+(?:<[^>]*>\s*)?([A-Z]\w*(?:\.[A-Z]\w*)*)(?:<[^<>()]*(?:<[^<>()]*>[^<>()]*)*>)?\??\.[A-Za-z_`][\w`]*\s*\(/g)) {
+      for (const part of m[1]!.split('.')) outside.add(part);
+    }
+  }
+  for (const name of outside) {
+    if (!context.getNodesByName(name).some((n) => MEMBER_CLASS_KINDS.has(n.kind) && (n.language === 'kotlin' || n.language === 'java'))) types.add(name);
+  }
+  // A receiver's members include those it inherits: Exposed's `mergeFrom`
+  // body runs on a MergeTableStatement, whose `whenMatchedDelete` is
+  // MergeStatement's.
+  const queue = [...types];
+  while (queue.length > 0 && types.size < 5000) {
+    const name = queue.shift()!;
+    for (const decl of context.getNodesByName(name)) {
+      if (decl.language !== 'kotlin' || !MEMBER_CLASS_KINDS.has(decl.kind)) continue;
+      for (const sup of classHeadSupertypes(decl, context)) {
+        if (!types.has(sup)) {
+          types.add(sup);
+          queue.push(sup);
+        }
+      }
+    }
+  }
+  KOTLIN_RECEIVER_TYPES.set(context, types);
+  return types;
+}
+
+/**
+ * What the Android framework and AndroidX classes a Kotlin class commonly
+ * extends inherit, so an extension on `ComponentCallbacks` or
+ * `ComponentActivity` is in reach of an `AppCompatActivity` subclass.
+ */
+const KOTLIN_PLATFORM_SUPERS: Readonly<Record<string, readonly string[]>> = {
+  AppCompatActivity: ['FragmentActivity'], FragmentActivity: ['ComponentActivity'],
+  ComponentActivity: ['Activity', 'LifecycleOwner', 'ViewModelStoreOwner', 'SavedStateRegistryOwner'],
+  Activity: ['ContextThemeWrapper', 'ComponentCallbacks2'], ContextThemeWrapper: ['ContextWrapper'],
+  ContextWrapper: ['Context'], Application: ['ContextWrapper', 'ComponentCallbacks2'],
+  Service: ['ContextWrapper', 'ComponentCallbacks2'], ComponentCallbacks2: ['ComponentCallbacks'],
+  Fragment: ['ComponentCallbacks', 'LifecycleOwner', 'ViewModelStoreOwner', 'SavedStateRegistryOwner'],
+  DialogFragment: ['Fragment'], AppCompatDialogFragment: ['DialogFragment'],
+  BottomSheetDialogFragment: ['AppCompatDialogFragment'], AndroidViewModel: ['ViewModel'],
+};
+
+const KOTLIN_HIERARCHIES = new WeakMap<ResolutionContext, WeakMap<UnresolvedRef, Set<string>>>();
+
+/**
+ * The Kotlin types a bare call is written inside — the classes and objects
+ * around it and the receiver of the extension function it is in — and what
+ * they inherit.
+ */
+function kotlinHierarchyAt(ref: UnresolvedRef, context: ResolutionContext): Set<string> {
+  let memo = KOTLIN_HIERARCHIES.get(context);
+  if (!memo) {
+    memo = new WeakMap();
+    KOTLIN_HIERARCHIES.set(context, memo);
+  }
+  const hit = memo.get(ref);
+  if (hit) return hit;
+  const queue: string[] = [];
+  for (const n of context.getNodesInFile(ref.filePath)) {
+    if (n.startLine > ref.line || n.endLine < ref.line) continue;
+    if (MEMBER_CLASS_KINDS.has(n.kind)) queue.push(n.name);
+    // `fun Foo.bar() { baz() }`: Foo is the implicit receiver.
+    else if ((n.kind === 'method' || n.kind === 'function') && n.qualifiedName.includes('::')) {
+      queue.push(n.qualifiedName.slice(0, n.qualifiedName.lastIndexOf('::')).split(/::|\./).pop()!);
+    }
+  }
+  // A Gradle build script runs on the Project (a settings script on Settings).
+  if (ref.filePath.endsWith('.gradle.kts')) queue.push(/(?:^|\/)settings\.gradle\.kts$/.test(ref.filePath) ? 'Settings' : 'Project');
+  // The same read from the source's braces, which also sees an anonymous
+  // `object : Table("t") { … }` and survives a class the parser lost.
+  for (const frame of kotlinBraceFrames(ref.filePath, context)) {
+    if (frame.start <= ref.line && frame.end >= ref.line) queue.push(...frame.names);
+  }
+  const names = new Set<string>();
+  while (queue.length > 0 && names.size < 60) {
+    const name = queue.shift()!;
+    if (names.has(name)) continue;
+    names.add(name);
+    queue.push(...(KOTLIN_PLATFORM_SUPERS[name] ?? []));
+    for (const decl of context.getNodesByName(name)) {
+      if (decl.language === 'kotlin' && MEMBER_CLASS_KINDS.has(decl.kind)) queue.push(...classHeadSupertypes(decl, context));
+    }
+  }
+  memo.set(ref, names);
+  return names;
+}
+
+const KOTLIN_FRAMES = new WeakMap<ResolutionContext, Map<string, Array<{ start: number; end: number; names: string[] }>>>();
+
+/**
+ * The type bodies of a Kotlin file by line range, read from its braces: each
+ * `class` / `object` / `interface` body with its name and supertypes, an
+ * anonymous `object : Base(…)` with its base, and an extension function's
+ * body with its receiver type.
+ */
+function kotlinBraceFrames(file: string, context: ResolutionContext): Array<{ start: number; end: number; names: string[] }> {
+  let memo = KOTLIN_FRAMES.get(context);
+  if (!memo) {
+    memo = new Map();
+    KOTLIN_FRAMES.set(context, memo);
+  }
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const frames: Array<{ start: number; end: number; names: string[] }> = [];
+  const source = blankStringContents(stripCommentsForRegex(context.readFile(file) ?? '', 'java'));
+  const stack: Array<{ start: number; names: string[] | null }> = [];
+  let line = 1;
+  let pending = '';
+  for (const ch of source) {
+    if (ch === '\n') line++;
+    if (ch === '{') {
+      // `with(x) {`, `x.apply {`, `x.run {`: a receiver of whatever type x is.
+      const scoped = /(?:\bwith\s*\([^{}]*\)|\.\s*(?:apply|run)(?:\s*<[^<>]*>)?)\s*$/.test(pending);
+      let names = scoped ? ['*'] : kotlinHeadNames(pending);
+      // `single { get() }`: a lambda runs on the receiver its function's parameter type names.
+      if (!scoped && (!names || names.length === 0)) {
+        const call = /(?:^|[^\w$])([a-z_]\w*)\s*(?:<[^<>{}]*>)?\s*(?:\([^(){}]*\))?\s*$/.exec(pending)?.[1];
+        const receiver = call && !KOTLIN_BLOCK_WORDS.has(call) ? kotlinLambdaReceiver(call, context) : null;
+        if (receiver) names = [receiver];
+      }
+      stack.push({ start: line, names });
+      pending = '';
+    } else if (ch === '}') {
+      const open = stack.pop();
+      if (open?.names && open.names.length > 0) frames.push({ start: open.start, end: line, names: open.names });
+      pending = '';
+    } else if (ch === ';') pending = '';
+    else if (pending.length < 600) pending += ch;
+    else pending = pending.slice(300) + ch;
+  }
+  memo.set(file, frames);
+  return frames;
+}
+
+/** Words before a `{` that open a block, not a lambda argument. */
+const KOTLIN_BLOCK_WORDS: ReadonlySet<string> = new Set([
+  'if', 'else', 'for', 'while', 'do', 'when', 'try', 'catch', 'finally', 'init', 'get', 'set', 'constructor',
+  'fun', 'class', 'object', 'interface', 'return', 'by', 'lazy', 'apply', 'run', 'also', 'let', 'with', 'use',
+]);
+
+const KOTLIN_LAMBDA_RECEIVERS = new WeakMap<ResolutionContext, Map<string, string | null>>();
+
+/**
+ * The receiver a lambda passed to the project's `name` runs with: the type
+ * before `.(` in its last parameter's function type, directly or through a
+ * typealias — koin's `single(…, definition: Definition<T>)` with `typealias
+ * Definition<T> = Scope.(ParametersHolder) -> T` runs its lambda on a Scope.
+ * Null unless every `name` agrees.
+ */
+function kotlinLambdaReceiver(name: string, context: ResolutionContext): string | null {
+  let memo = KOTLIN_LAMBDA_RECEIVERS.get(context);
+  if (!memo) KOTLIN_LAMBDA_RECEIVERS.set(context, (memo = new Map()));
+  if (memo.has(name)) return memo.get(name)!;
+  const receiverOf = (type: string, depth: number): string | null => {
+    const direct = /^\s*(?:suspend\s+)?([A-Z]\w*)(?:<[^<>]*(?:<[^<>]*>[^<>]*)*>)?\s*\.\s*\(/.exec(type);
+    if (direct) return direct[1]!;
+    const alias = /^\s*([A-Z]\w*)\b/.exec(type)?.[1];
+    if (!alias || depth > 2) return null;
+    for (const decl of context.getNodesByName(alias)) {
+      if (decl.language !== 'kotlin' || decl.kind !== 'type_alias') continue;
+      const text = (context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [])[decl.startLine - 1] ?? '';
+      const rhs = /=\s*(.+)$/.exec(text)?.[1];
+      if (rhs) return receiverOf(rhs, depth + 1);
+    }
+    return null;
+  };
+  const found = new Set<string>();
+  for (const fn of context.getNodesByName(name)) {
+    if (fn.language !== 'kotlin' || (fn.kind !== 'function' && fn.kind !== 'method')) continue;
+    const lines = context.getFileLines?.(fn.filePath) ?? context.readFile(fn.filePath)?.split(/\r?\n/) ?? [];
+    const head = lines.slice(fn.startLine - 1, fn.startLine + 11).join(' ');
+    const open = head.search(new RegExp(`\\b${name}\\s*\\(`));
+    if (open < 0) continue;
+    let depth = 0;
+    let end = -1;
+    for (let i = head.indexOf('(', open); i < head.length; i++) {
+      if (head[i] === '(') depth++;
+      else if (head[i] === ')' && --depth === 0) { end = i; break; }
+    }
+    if (end < 0) continue;
+    const params = splitCppTopLevel(head.slice(head.indexOf('(', open) + 1, end));
+    const last = params[params.length - 1];
+    const type = last ? /:\s*([\s\S]+?)(?:\s*=\s*[^=>][\s\S]*)?$/.exec(last.replace(/^\s*(?:noinline|crossinline)\s+/, ''))?.[1] : undefined;
+    const receiver = type ? receiverOf(type, 0) : null;
+    if (receiver) found.add(receiver);
+  }
+  const result = found.size === 1 ? [...found][0]! : null;
+  memo.set(name, result);
+  return result;
+}
+
+/** The type names a Kotlin block head introduces: a type declaration's name and supertypes, or an extension function's receiver. */
+function kotlinHeadNames(head: string): string[] | null {
+  let depth = 0;
+  let flat = '';
+  for (const ch of head) {
+    if (ch === '<' || ch === '(') depth++;
+    else if (ch === '>' || ch === ')') depth = Math.max(0, depth - 1);
+    else if (depth === 0) flat += ch;
+  }
+  const decl = /\b(?:class|interface|object)\b(?:\s+([A-Za-z_]\w*))?([^=]*)$/.exec(flat);
+  if (decl) {
+    const supers = /:\s*([\s\S]*)$/.exec(decl[2] ?? '')?.[1] ?? '';
+    const names = [...supers.replace(/\bwhere\b[\s\S]*$/, '').matchAll(/([A-Z]\w*)\s*(?=,|$|\bby\b)/g)].map((m) => m[1]!);
+    return decl[1] ? [decl[1], ...names] : names;
+  }
+  const receiver = /\bfun\s+(?:<[^>]*>\s*)?([A-Z]\w*)(?:<[^>]*>)?\??\.[A-Za-z_]\w*\s*\(/.exec(head)?.[1];
+  return receiver ? [receiver] : null;
+}
+
+/**
+ * Whether a bare Kotlin call can reach method `n`: a member of a type around
+ * the call or of what it inherits, or of a type the project's function types
+ * take as a lambda receiver (a DSL). koin's `error("…")` — Kotlin's — went to
+ * a Logger's `error`, and `module { … }` in one test to another test class's
+ * private `module`.
+ */
+function isKotlinMemberReachable(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  // A Gradle script's bare calls — `plugins { }`, `dependencies { }`,
+  // `api(projects.core)` — run on the build tool's own types: never a member
+  // of a class the project declares (nowinandroid's `Graph.plugins()`, a lint
+  // registry's `api` property). Build logic's extensions on Gradle's types
+  // (`NamedDomainObjectContainer.createSourceSet(…)`) stay.
+  if (ref.filePath.endsWith('.kts')) {
+    if (n.kind !== 'method' && n.kind !== 'field' && n.kind !== 'property') return true;
+    const cut = n.qualifiedName.lastIndexOf('::');
+    const owner = cut > 0 ? n.qualifiedName.slice(0, cut).split(/::|\./).pop()! : '';
+    return owner !== '' && !context.getNodesByName(owner).some((c) => isMethodOwnerKind(c) || c.kind === 'module');
+  }
+  // A Java class's method, too: Kotlin calls it bare only from a subclass or through a static import.
+  if (n.kind !== 'method' || (n.language !== 'kotlin' && n.language !== 'java')) return true;
+  // `require(n >= 0) { … }`, `check(!closed)`: Kotlin's preconditions, not a
+  // member `require(byteCount: Long)` of the type around the call.
+  if (isKotlinPreconditionCall(ref, context)) return false;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut <= 0) return true;
+  const path = n.qualifiedName.slice(0, cut).split(/::|\./);
+  let owner = path.pop()!;
+  const companion = owner === 'Companion' && path.length > 0;
+  if (companion) owner = path.pop()!;
+  // A (Java) constructor is the type's, called by its name.
+  if (n.name === owner) return true;
+  const hierarchy = kotlinHierarchyAt(ref, context);
+  if (hierarchy.has('*') || kotlinReceiverTypes(context).has(owner) || hierarchy.has(owner)) return true;
+  // `import okio.TestUtil.deepCopy` / `import okio.TestUtil.*` names an object's members.
+  const pkg = kotlinFileScope(n.filePath, context).pkg;
+  const objectPath = (pkg ? `${pkg}.${owner}` : owner) + (companion ? '.Companion' : '');
+  const here = kotlinFileScope(ref.filePath, context);
+  return here.imports.has(`${objectPath}.${n.name}`) || here.stars.has(objectPath);
+}
+
+/**
+ * Of the members a bare Kotlin call can reach, the ones the code around it
+ * reaches — its class, an extension's receiver, the lambda it is in — before
+ * those only a lambda type somewhere in the project could: koin's `get()` in
+ * `Scope.new(…)` is Scope's, not Koin's.
+ */
+function lexicalKotlinMembers(candidates: Node[], ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  if (candidates.length < 2) return candidates;
+  const hierarchy = kotlinHierarchyAt(ref, context);
+  if (hierarchy.has('*')) return candidates;
+  const lexical = candidates.filter((n) => {
+    if (n.kind !== 'method') return false;
+    const path = n.qualifiedName.slice(0, Math.max(0, n.qualifiedName.lastIndexOf('::'))).split(/::|\./);
+    let owner = path.pop() ?? '';
+    if (owner === 'Companion') owner = path.pop() ?? '';
+    return hierarchy.has(owner);
+  });
+  return lexical.length > 0 ? lexical : candidates;
+}
+
+/** Whether a standard-named Kotlin chain link can mean `n`: only through a receiver named after its owner. */
+function isKotlinStdChainTarget(n: Node, receiver: string): boolean {
+  if (n.kind !== 'method' && n.kind !== 'function') return true;
+  return receiver === 'this' || (receiver !== '' && sharesReceiverWord(receiver, n));
+}
+
+/**
+ * How a Swift call is written: `bare` (implicit self, or a free function),
+ * through `self.` / `super.`, or `chained` on some other receiver. The
+ * extractor keeps one receiver level, so `super.init(…)`,
+ * `axis.entries.removeAll()` and `min(a, b)` all arrive as bare names.
+ */
+interface SwiftCallShape {
+  shape: 'bare' | 'self' | 'super' | 'chained';
+  /** A chained call's receiver, calls and subscripts dropped. */
+  receiver: string;
+  /** The first argument's label, if any. */
+  label: string;
+  /** `name[…]`: a subscript of a value, not a call. */
+  subscript: boolean;
+  /** `URLEncodedFormDecoder().decode(…)`: the type the link before the call constructs. */
+  constructed?: string;
+}
+
+function swiftCallShape(ref: UnresolvedRef, context: ResolutionContext): SwiftCallShape | null {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return null;
+  const name = ref.referenceName;
+  let start = line.startsWith(name, ref.column) && !/[\w$]/.test(line[ref.column - 1] ?? '') ? ref.column : -1;
+  if (start < 0) {
+    const m = new RegExp(`(?<![\\w$])${name}\\s*[({<[]`).exec(line);
+    start = m ? m.index : -1;
+  }
+  if (start < 0) return null;
+  const before = line.slice(0, start);
+  const after = line.slice(start + name.length);
+  const base = { receiver: '', label: '', subscript: /^\s*\[/.test(after) };
+  if (!/\.\s*$/.test(before)) return { ...base, shape: 'bare' };
+  // `self.m(` — not `self[i].m(` or `self.items.m(`, which are chains.
+  const plain = /(?:^|[^\w$.)\]])(self|Self|super)\s*[?!]?\s*\.\s*$/.exec(before)?.[1];
+  if (plain) return { ...base, shape: plain === 'super' ? 'super' : 'self' };
+  return {
+    ...base,
+    shape: 'chained',
+    receiver: rustGoReceiverName(before.replace(/[?!]\s*\./g, '.')),
+    label: /^\s*\(\s*([A-Za-z_]\w*)\s*:(?!:)/.exec(after)?.[1] ?? '',
+    constructed: /(?<![\w$.])([A-Z][\w$]*)\s*(?:<[^<>()]*>)?\s*\([^()]*\)\s*[?!]?\s*\.\s*$/.exec(before)?.[1],
+  };
+}
+
+/** Argument labels the standard library's collection and string methods take. */
+const SWIFT_STD_LABELS: ReadonlySet<string> = new Set([
+  'contentsOf', 'where', 'by', 'at', 'keepingCapacity', 'separator', 'forKey', 'of', 'into', 'in', 'options',
+  'maxSplits', 'omittingEmptySubsequences', 'with', 'after', 'before', 'upTo', 'through', 'offsetBy', 'default',
+]);
+
+/**
+ * Whether a Swift method's declaration takes the argument label a call gives
+ * first (`func contains(jpeg marker: JPEGMarker)` for `data.kf.contains(jpeg:
+ * .SOF2)`). Labels are part of a Swift method's name, so one the standard
+ * library's namesakes never take identifies the project's.
+ */
+function swiftDeclaresLabel(n: Node, label: string, context: ResolutionContext): boolean {
+  if (label === '' || SWIFT_STD_LABELS.has(label)) return false;
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+  const head = lines.slice(n.startLine - 1, n.startLine + 3).join(' ');
+  return new RegExp(`\\bfunc\\s+${n.name}\\s*(?:<[^>]*>)?\\s*\\(\\s*${label}\\b`).test(head);
+}
+
+/**
+ * What the standard library's collection types and protocols refine, so a
+ * project extension of `Collection` is in reach of a type that conforms to
+ * `RandomAccessCollection`. UIKit / AppKit ancestry comes from the
+ * Objective-C table.
+ */
+const SWIFT_STD_SUPERS: Readonly<Record<string, readonly string[]>> = {
+  RandomAccessCollection: ['BidirectionalCollection'], BidirectionalCollection: ['Collection'],
+  MutableCollection: ['Collection'], RangeReplaceableCollection: ['Collection'], Collection: ['Sequence'],
+  LazySequenceProtocol: ['Sequence'], LazyCollectionProtocol: ['Collection', 'LazySequenceProtocol'],
+  StringProtocol: ['BidirectionalCollection'],
+  Array: ['RandomAccessCollection', 'MutableCollection', 'RangeReplaceableCollection'],
+  ArraySlice: ['RandomAccessCollection', 'MutableCollection', 'RangeReplaceableCollection'],
+  ContiguousArray: ['RandomAccessCollection', 'MutableCollection', 'RangeReplaceableCollection'],
+  String: ['StringProtocol', 'RangeReplaceableCollection'], Substring: ['StringProtocol', 'RangeReplaceableCollection'],
+  Dictionary: ['Collection'], Set: ['Collection', 'SetAlgebra'], Range: ['RandomAccessCollection'],
+  ClosedRange: ['RandomAccessCollection'],
+};
+
+/** Swift declarations a member hangs off: types, protocols, and extensions (extracted as classes). */
+const SWIFT_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'enum', 'interface']);
+const SWIFT_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'property', 'field', 'enum_member']);
+const SWIFT_DECLS = new WeakMap<ResolutionContext, Map<string, { supers: string[]; projectType: boolean }>>();
+const SWIFT_HIERARCHIES = new WeakMap<ResolutionContext, WeakMap<UnresolvedRef, Map<string, number>>>();
+
+/**
+ * What the project declares a Swift type as: the supertypes and protocols
+ * every declaration and extension of it names, and whether any of them is
+ * the type itself rather than an extension of an outside one
+ * (`extension Sequence`).
+ */
+function swiftDeclOf(typeName: string, context: ResolutionContext): { supers: string[]; projectType: boolean } {
+  let memo = SWIFT_DECLS.get(context);
+  if (!memo) {
+    memo = new Map();
+    SWIFT_DECLS.set(context, memo);
+  }
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const system = OBJC_SYSTEM_SUPERS[typeName];
+  const info = { supers: [...(SWIFT_STD_SUPERS[typeName] ?? (system ? [system] : []))], projectType: false };
+  for (const decl of context.getNodesByName(typeName)) {
+    if (decl.language !== 'swift' || !SWIFT_TYPE_KINDS.has(decl.kind)) continue;
+    const head = swiftHeadOf(decl, context);
+    info.supers.push(...head.supers);
+    if (!head.extension) info.projectType = true;
+  }
+  memo.set(typeName, info);
+  return info;
+}
+
+/**
+ * A Swift declaration's head, read up to its body with comments, attribute
+ * arguments and generic parameters dropped: `@objc(ChartViewBase) open class
+ * ChartViewBase<T>: NSUIView, ChartDataProvider where T: Equatable {` →
+ * NSUIView, ChartDataProvider.
+ */
+function swiftHeadOf(decl: Node, context: ResolutionContext): { supers: string[]; extension: boolean } {
+  const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+  const text = lines
+    .slice(decl.startLine - 1, Math.min(decl.endLine, decl.startLine + 20))
+    .join('\n')
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/\/\/[^\n]*/g, ' ');
+  let depth = 0;
+  let flat = '';
+  for (const ch of text) {
+    if (ch === '<' || ch === '(') depth++;
+    else if (ch === '>' || ch === ')') depth = Math.max(0, depth - 1);
+    else if (depth === 0) {
+      if (ch === '{') break;
+      flat += ch;
+    }
+  }
+  const head = /\b(class|struct|enum|protocol|extension|actor)\s+[\w.]+\s*([\s\S]*)$/.exec(flat);
+  if (!head) return { supers: [], extension: false };
+  const clause = /^:([\s\S]*?)(?:\bwhere\b|$)/.exec(head[2]!.trim())?.[1] ?? '';
+  return {
+    supers: clause.split(',').map((item) => /([A-Za-z_]\w*)\s*$/.exec(item.trim())?.[1]).filter((w): w is string => !!w),
+    extension: head[1] === 'extension',
+  };
+}
+
+/** The Swift types around a call (depth 0) and what they inherit or conform to, by distance. */
+function swiftHierarchyAt(ref: UnresolvedRef, context: ResolutionContext): Map<string, number> {
+  let memo = SWIFT_HIERARCHIES.get(context);
+  if (!memo) {
+    memo = new WeakMap();
+    SWIFT_HIERARCHIES.set(context, memo);
+  }
+  const hit = memo.get(ref);
+  if (hit) return hit;
+  const depths = new Map<string, number>();
+  const queue: Array<[string, number]> = context
+    .getNodesInFile(ref.filePath)
+    .filter((n) => SWIFT_TYPE_KINDS.has(n.kind) && n.startLine <= ref.line && n.endLine >= ref.line)
+    .map((n) => [n.name.split('.').pop()!, 0]);
+  while (queue.length > 0 && depths.size < 40) {
+    const [name, depth] = queue.shift()!;
+    if (depths.has(name)) continue;
+    depths.set(name, depth);
+    for (const sup of swiftDeclOf(name, context).supers) queue.push([sup, depth + 1]);
+  }
+  memo.set(ref, depths);
+  return depths;
+}
+
+/** A Swift type and every supertype and protocol the project says it has. */
+function swiftTypeClosure(typeName: string, context: ResolutionContext): Set<string> {
+  const seen = new Set<string>();
+  const queue = [typeName];
+  while (queue.length > 0 && seen.size < 40) {
+    const name = queue.shift()!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    queue.push(...swiftDeclOf(name, context).supers);
+  }
+  return seen;
+}
+
+/**
+ * Of the in-scope members a bare / `self.` / `super.` Swift call could mean,
+ * the nearest: the type's own, else its superclass's — Alamofire's
+ * `self.cancel()` in a DownloadRequest extension is DownloadRequest's
+ * override, not Request's.
+ */
+function nearestSwiftMembers(candidates: Node[], ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  const hierarchy = swiftHierarchyAt(ref, context);
+  const depthOf = (n: Node): number | undefined => {
+    if (!SWIFT_MEMBER_KINDS.has(n.kind) && n.kind !== 'constant' && n.kind !== 'variable') return undefined;
+    const cut = n.qualifiedName.lastIndexOf('::');
+    return cut > 0 ? hierarchy.get(n.qualifiedName.slice(0, cut).split(/::|\./).pop()!) : undefined;
+  };
+  const depths = candidates.map(depthOf).filter((d): d is number => d !== undefined);
+  if (depths.length < 2) return candidates;
+  const nearest = Math.min(...depths);
+  return candidates.filter((n) => {
+    const d = depthOf(n);
+    return d === undefined || d === nearest;
+  });
+}
+
+/**
+ * Methods of Swift's standard collections, strings and optionals and of
+ * Foundation / UIKit views — names a project type rarely carries itself.
+ * Ones it often does (`cancel`, `resume`, `store`, `validate`, `load`) are
+ * left out: Alamofire's `request.resume()`, Kingfisher's `cache.store(…)`.
+ */
+const SWIFT_STD_METHODS: ReadonlySet<string> = new Set([
+  'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast', 'removeValue', 'contains', 'map',
+  'compactMap', 'flatMap', 'filter', 'reduce', 'forEach', 'sorted', 'sort', 'first', 'last', 'min', 'max',
+  'firstIndex', 'lastIndex', 'index', 'enumerated', 'reversed', 'joined', 'split', 'prefix', 'suffix',
+  'dropFirst', 'dropLast', 'allSatisfy', 'randomElement', 'shuffled', 'popLast', 'replaceSubrange',
+  'replacingOccurrences', 'components', 'trimmingCharacters', 'hasPrefix', 'hasSuffix', 'lowercased',
+  'uppercased', 'appending', 'updateValue', 'merge', 'merging', 'union', 'intersection', 'subtracting',
+  'formUnion', 'isEqual', 'addSubview', 'removeFromSuperview', 'setNeedsDisplay', 'setNeedsLayout',
+  'layoutIfNeeded', 'addGestureRecognizer', 'addTarget', 'addObserver', 'removeObserver', 'eraseToAnyPublisher',
+]);
+
+/**
+ * Whether a Swift file's declarations are visible from another file as far as
+ * separate modules go: one under a `…Tests` directory (SwiftPM's
+ * `Tests/VaporTests`, Xcode's `KingfisherTests`) or in a playground only from
+ * inside it.
+ */
+function isSwiftTargetVisible(declFile: string, fromFile: string): boolean {
+  const segments = declFile.split('/').slice(0, -1);
+  const target = segments.findIndex((seg) => /Tests$|\.playground$/.test(seg));
+  if (target < 0) return true;
+  const prefix = segments.slice(0, target + 1).join('/') + '/';
+  return fromFile.startsWith(prefix);
+}
+
+/**
+ * Whether a Swift call of that shape can mean `n`. A member reached with no
+ * receiver or through `self.` belongs to a type around the call or to what
+ * it inherits or conforms to — `super.` to the latter only; top-level code
+ * has no implicit self. Charts' `min(a, b)` went to a range type's `min`
+ * field, `super.init(…)` to an Objective-C demo's `init` 170 times. A member
+ * reached down a longer chain keeps its match unless its name is one the
+ * standard types all carry: `axis.entries.removeAll()` is the array's, not
+ * a chart data class's (unless the receiver names the owner, or the owner
+ * is an outside type the project only extends).
+ */
+function isSwiftCallTarget(n: Node, shape: SwiftCallShape | null, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (!shape) return true;
+  // A global `let` / `var` from another file is subscripted, not called —
+  // Charts' `min(a, b)` went to a playground page's `let min = 20.0`.
+  if ((n.kind === 'constant' || n.kind === 'variable') && n.filePath !== ref.filePath && !shape.subscript) return false;
+  // A test target imports the module it tests, never the reverse.
+  if (!isSwiftTargetVisible(n.filePath, ref.filePath)) return false;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  const owner = cut > 0 ? n.qualifiedName.slice(0, cut).split(/::|\./).pop()! : null;
+  if (!SWIFT_MEMBER_KINDS.has(n.kind) && !(owner !== null && (n.kind === 'constant' || n.kind === 'variable'))) {
+    if (n.kind !== 'function') return true;
+    return shape.shape === 'bare' || owner !== null || (shape.shape === 'chained' && /^[A-Z]/.test(shape.receiver));
+  }
+  if (owner === null) return true;
+  if (shape.shape === 'chained') {
+    // A member of what the link before constructs, or of what that inherits:
+    // vapor's `URLEncodedFormDecoder().decode(…)` is not a request's private
+    // `_URLQueryContainer.decode`, `JSONDecoder().decode(…)` no project type's.
+    // (A capitalized C function — realm's `RLMObjectBaseObjectSchema(obj)!` — constructs nothing.)
+    if (shape.constructed && !context.getNodesByName(shape.constructed).some((f) => f.kind === 'function')) {
+      return swiftTypeClosure(shape.constructed, context).has(owner);
+    }
+    // A property the type around the call declares with a type — Kingfisher's
+    // `var cache: ImageCache!` — is that type: `cache.imageCachedType(…)` is
+    // ImageCache's, not a test subclass's override.
+    const typed = /^(?:self\.)?[A-Za-z_]\w*$/.test(shape.receiver) ? inferMemberReceiverType(shape.receiver, ref, context) : null;
+    if (typed && /^[A-Z]/.test(typed)) return swiftTypeClosure(typed, context).has(owner);
+    if (shape.receiver === '' || !SWIFT_STD_METHODS.has(n.name)) return true;
+    return sharesReceiverWord(shape.receiver.split('.').pop()!, n) || !swiftDeclOf(owner, context).projectType ||
+      swiftDeclaresLabel(n, shape.label, context);
+  }
+  const depth = swiftHierarchyAt(ref, context).get(owner);
+  return depth !== undefined && (shape.shape !== 'super' || depth > 0);
+}
+
+/**
+ * Methods of Rust's Option / Result / iterators / collections / strings /
+ * smart pointers — names a project type rarely carries itself. Ones it often
+ * does (`get`, `set`, `insert`, `next`, `call`, `read`) are left out: serde's
+ * `Attr::set`, clap's own `get`.
+ */
+const RUST_STD_METHODS: ReadonlySet<string> = new Set([
+  'unwrap', 'unwrap_or', 'unwrap_or_else', 'unwrap_or_default', 'unwrap_err', 'unwrap_unchecked', 'expect',
+  'expect_err', 'ok', 'err', 'map', 'map_err', 'map_or', 'map_or_else', 'and_then', 'or_else', 'ok_or',
+  'ok_or_else', 'is_some', 'is_none', 'is_ok', 'is_err', 'is_some_and', 'as_ref', 'as_mut', 'as_deref', 'clone',
+  'cloned', 'copied', 'iter', 'iter_mut', 'into_iter', 'collect', 'enumerate', 'zip', 'rev', 'chain', 'skip',
+  'step_by', 'peekable', 'flat_map', 'filter_map', 'flatten', 'any', 'all', 'len', 'is_empty', 'push', 'push_str',
+  'pop', 'extend', 'drain', 'clear', 'retain', 'truncate', 'reserve', 'with_capacity', 'capacity', 'sort',
+  'sort_by', 'sort_by_key', 'dedup', 'split_off', 'contains_key', 'to_string', 'to_owned', 'to_vec', 'as_str',
+  'as_bytes', 'as_slice', 'as_ptr', 'into', 'try_into', 'borrow', 'borrow_mut', 'deref', 'deref_mut', 'chars',
+  'bytes', 'lines', 'starts_with', 'ends_with', 'trim', 'to_lowercase', 'to_uppercase', 'windows', 'chunks',
+  'then', 'then_some', 'eq', 'cmp', 'partial_cmp', 'read_to_end', 'read_to_string', 'fetch_add', 'fetch_sub',
+  // std::process::Command's pipes and the assert_cmd assertions tests chain
+  // onto it (not `arg` / `env`, which clap's own builders carry)
+  'current_dir', 'stdout', 'stderr', 'stdin', 'success', 'failure',
+]);
+
+/**
+ * Methods of Go's standard types and interfaces — `fmt.Stringer`, `error`,
+ * `http.ResponseWriter`, `sync` locks, `reflect`, `time`. Ones a project type
+ * often carries itself (`Get`, `Set`, `Close`, `Value`, `Next`) are left out:
+ * gin's `c.Set(…)` is its Context's.
+ */
+const GO_STD_METHODS: ReadonlySet<string> = new Set([
+  'String', 'Error', 'Unwrap', 'Is', 'As', 'Header', 'WriteHeader', 'WriteString', 'Lock', 'Unlock', 'RLock',
+  'RUnlock', 'Err', 'Deadline', 'Int', 'Bool', 'Float64', 'Int64', 'Uint64', 'Bytes', 'Len', 'Cap', 'Seconds',
+  'Unix', 'Before', 'After', 'Equal', 'IsNil', 'IsValid', 'Elem', 'NumField', 'Interface', 'Kind',
+]);
+
+const SCALA_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'trait', 'interface', 'enum', 'struct', 'module', 'namespace']);
+const SCALA_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'field', 'property', 'variable', 'constant']);
+const SCALA_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const SCALA_IMPORTS = new WeakMap<ResolutionContext, Map<string, { owners: Set<string>; members: Set<string>; values: Set<string> }>>();
+
+/**
+ * Whether a bare Scala name can mean the member `n`, read at its site. Three
+ * shapes:
+ * - a later link of a chain (`fa.iterator.map(f)` — the extractor keeps one
+ *   receiver level, the line still shows the dot): the receiver must be named
+ *   after `n`'s owner (`Foo.bar` on object Foo). cats's chained `.map(…)` went
+ *   to a lazy-list ops class's `map` 186 times;
+ * - a name the enclosing definition binds — a parameter `f: A => B`, a
+ *   `val` — is that local: `f(true)` is not a case class's field `f` (396);
+ * - otherwise a member of the types around it or their `extends` / `with`
+ *   supertypes, of a companion, of the same file, or of an object the file
+ *   imports (`import Foo._`, `import Foo.{bar}`).
+ */
+function isScalaMemberInScope(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return true;
+  const name = ref.referenceName;
+  const at = new RegExp(`(?<![\\w$])${name.replace(/[$]/g, '\\$')}\\b`).exec(line);
+  if (!at) return true;
+  const before = line.slice(0, at.index);
+  if (/\.\s*$/.test(before)) {
+    // A later link of a chain: a member of what the receiver is named after,
+    // never a package object's function — unless it is an `extension` method.
+    if (n.filePath === ref.filePath) return true;
+    // A type or object as a chain link (`pkg.Obj(…)`) is named by what holds it:
+    // cats' `arbitrary[Int].map { … }` is no call of alleycats' `object map`.
+    if (SCALA_TYPE_KINDS.has(n.kind)) {
+      // Scala qualified names leave the package out: a top-level type's holder is its file's package.
+      const outer = n.qualifiedName.split('::').slice(-2, -1)[0];
+      const holder = outer !== undefined ? outer.split('.').pop()!
+        : [...(context.readFile(n.filePath) ?? '').matchAll(/^\s*package\s+([\w.]+)\s*$/gm)].pop()?.[1]?.split('.').pop() ?? '';
+      return holder !== '' && scalaReceiverName(before).split('.').pop() === holder;
+    }
+    if (!SCALA_MEMBER_KINDS.has(n.kind)) return n.kind !== 'function' || isScalaExtensionMethod(n, context);
+    const receiver = scalaReceiverName(before);
+    return receiver !== '' && sharesReceiverWord(receiver, n);
+  }
+  const local = scalaLocalBinder(name, ref, context);
+  if (local) return n.filePath === ref.filePath && n.startLine >= local.startLine && n.endLine <= local.endLine;
+  if (!SCALA_MEMBER_KINDS.has(n.kind)) return true;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0 || n.filePath === ref.filePath) return true;
+  const owner = n.qualifiedName.slice(0, cut).split('::').pop()!;
+  const imports = scalaImportsOf(ref.filePath, context);
+  if (imports.owners.has(owner) || imports.members.has(`${owner}.${name}`)) return true;
+  // `import builder._` brings in a VALUE's members, of a type the file doesn't say.
+  if (imports.values.size > 0) return true;
+  // An imported object's inherited members: `import sttp.client4._` is
+  // `package object client4 extends SttpApi`, so `multipart(…)` is SttpApi's.
+  if (scalaImportedSupertypes(ref.filePath, imports, context).has(owner)) return true;
+  const around = context
+    .getNodesInFile(ref.filePath)
+    .filter((t) => SCALA_TYPE_KINDS.has(t.kind) && t.startLine <= ref.line && t.endLine >= ref.line);
+  if (around.length === 0) return true;
+  const seen = new Set<string>();
+  const queue = [...around.map((t) => t.name), ...scalaAnonymousBases(ref, context)];
+  while (queue.length > 0 && seen.size < 60) {
+    const typeName = queue.shift()!;
+    if (seen.has(typeName)) continue;
+    seen.add(typeName);
+    if (typeName === owner) return true;
+    queue.push(...scalaSupertypesOf(typeName, context));
+  }
+  return false;
+}
+
+/**
+ * The types an anonymous class around a Scala site instantiates — `new
+ * scopt.OptionParser[Config]("scopt") { head("scopt") }` puts OptionParser's
+ * members in scope. Read backwards over the open braces above the site.
+ */
+function scalaAnonymousBases(ref: UnresolvedRef, context: ResolutionContext): string[] {
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split('\n') ?? [];
+  const bases: string[] = [];
+  let depth = 0;
+  for (let i = ref.line - 1; i >= 0 && i >= ref.line - 400; i--) {
+    const text = lines[i]!;
+    for (let c = text.length - 1; c >= 0; c--) {
+      if (text[c] === '}') depth++;
+      else if (text[c] === '{') {
+        if (depth > 0) { depth--; continue; }
+        const head = /\bnew\s+([\w.]+(?:\s*\[[^\]]*\])?(?:\s*\([^)]*\))?(?:\s+with\s+[\w.]+(?:\s*\[[^\]]*\])?)*)\s*$/.exec(text.slice(0, c));
+        if (head) for (const m of head[1]!.replace(/\[[^\]]*\]|\([^)]*\)/g, '').split(/\s+with\s+/)) bases.push(m.trim().split('.').pop()!);
+      }
+    }
+  }
+  return bases;
+}
+
+/**
+ * The receiver a Scala `….name` is written on, as its dotted identifiers with
+ * call and type arguments dropped: `proc("bash").call()` → `proc`,
+ * `Alternative[List].unite` → `Alternative`, `checker.value.onWrite` →
+ * `checker.value`. Read backwards to the expression's start.
+ */
+function scalaReceiverName(before: string): string {
+  const text = before.replace(/\s*\.\s*$/, '');
+  let out = '';
+  let i = text.length - 1;
+  while (i >= 0) {
+    const ch = text[i]!;
+    if (ch === ')' || ch === ']') {
+      const open = ch === ')' ? '(' : '[';
+      let depth = 0;
+      for (; i >= 0; i--) {
+        if (text[i] === ch) depth++;
+        else if (text[i] === open && --depth === 0) break;
+      }
+      if (i < 0) return '';
+      i--;
+    } else if (/[\w$.]/.test(ch)) {
+      out = ch + out;
+      i--;
+    } else break;
+  }
+  return out.replace(/^\.+|\.+$/g, '');
+}
+
+/** Whether a Scala function is declared in an `extension (…)` block. */
+function isScalaExtensionMethod(n: Node, context: ResolutionContext): boolean {
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split('\n') ?? [];
+  return lines.slice(Math.max(0, n.startLine - 4), n.startLine).some((l) => /^\s*extension\b/.test(l));
+}
+
+/**
+ * The definition around a Scala site that binds `name` itself — a parameter, a
+ * `val` / `var` / `def`, a lambda or `for` parameter — or null.
+ */
+function scalaLocalBinder(name: string, ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  const nodes = context.getNodesInFile(ref.filePath);
+  const innermost = (kinds: ReadonlySet<string>) => nodes
+    .filter((f) => kinds.has(f.kind) && f.startLine <= ref.line && f.endLine >= ref.line)
+    .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+  const fn = innermost(SCALA_FUNCTION_KINDS);
+  // A test suite's body runs in its class: `test("…") { forAll { (e: E, f: A => B) => f(1) } }`.
+  const scope = fn ?? innermost(SCALA_TYPE_KINDS);
+  if (!scope) return null;
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split('\n') ?? [];
+  const text = lines.slice(scope.startLine - 1, ref.line).join('\n');
+  const n = name.replace(/[$]/g, '\\$');
+  const binder = new RegExp(`(?:[(,\\[]\\s*(?:implicit\\s+|using\\s+)?${n}\\s*:)|(?:\\b(?:val|var|def|lazy\\s+val)\\s+${n}\\b)|(?:(?<![\\w$.])${n}\\s*(?:=>|<-))|(?:\\(\\s*${n}\\s*(?:,[^)]*)?\\)\\s*=>)`, 'g');
+  if (fn) return binder.test(text) ? fn : null;
+  // In a class body, a binder counts only inside a block still open at the site —
+  // not a sibling test's `val f`, not the class's own members at its body's depth.
+  const blockAt: number[] = new Array(text.length);
+  const open: number[] = [];
+  let next = 0;
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '{') { open.push(++next); depth++; }
+    else if (ch === '}') { open.pop(); depth--; }
+    blockAt[i] = open.length > 1 ? open[open.length - 1]! : 0;
+  }
+  const live = new Set(open.slice(1));
+  for (const m of text.matchAll(binder)) {
+    const block = blockAt[m.index!] ?? 0;
+    if (block !== 0 && live.has(block)) return scope;
+  }
+  return null;
+}
+
+const SCALA_FUNCTION_KINDS: ReadonlySet<string> = new Set(['method', 'function']);
+
+/** The simple names a Scala type's declarations extend or mix in. */
+function scalaSupertypesOf(typeName: string, context: ResolutionContext): string[] {
+  let memo = SCALA_SUPERS.get(context);
+  if (!memo) SCALA_SUPERS.set(context, (memo = new Map()));
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const names: string[] = [typeName];
+  for (const decl of context.getNodesByName(typeName)) {
+    if (decl.language !== 'scala' || !SCALA_TYPE_KINDS.has(decl.kind)) continue;
+    const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+    const text = lines.slice(decl.startLine - 1, decl.startLine + 12).join(' ');
+    let depth = 0;
+    let flat = '';
+    for (const ch of text) {
+      if (ch === '[' || ch === '(') depth++;
+      else if (ch === ']' || ch === ')') depth = Math.max(0, depth - 1);
+      else if (depth === 0) {
+        if (ch === '{' || ch === '=') break;
+        flat += ch;
+      }
+    }
+    const clause = /\bextends\b(.*)$/.exec(flat)?.[1] ?? '';
+    for (const m of clause.matchAll(/([A-Za-z_][\w.]*)/g)) {
+      const simple = m[1]!.split('.').pop()!;
+      if (simple !== 'with' && simple !== 'derives' && simple !== typeName) names.push(simple);
+    }
+  }
+  memo.set(typeName, names.slice(1));
+  return names.slice(1);
+}
+
+const SCALA_IMPORTED_SUPERS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+const SCALA_PACKAGE_OBJECTS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/** `package object client4 extends SttpApi with …` — the graph holds no node for one. */
+function scalaPackageObjects(context: ResolutionContext): Map<string, string[]> {
+  const hit = SCALA_PACKAGE_OBJECTS.get(context);
+  if (hit) return hit;
+  const out = new Map<string, string[]>();
+  for (const file of context.getAllFiles()) {
+    if (!file.endsWith('.scala') || (context.fileContains && !context.fileContains(file, 'package object'))) continue;
+    const source = context.readFile(file) ?? '';
+    for (const m of source.matchAll(/\bpackage\s+object\s+([\w$]+)\s+extends\s+([^{\n]+)/g)) {
+      const names = m[2]!.replace(/\[[^\]]*\]/g, '').split(/\bwith\b/).map((t) => t.trim().split('.').pop()!.replace(/\(.*$/, '').trim()).filter(Boolean);
+      out.set(m[1]!, [...(out.get(m[1]!) ?? []), ...names]);
+    }
+  }
+  SCALA_PACKAGE_OBJECTS.set(context, out);
+  return out;
+}
+
+/** Every supertype of the objects a Scala file imports wholesale (`import Obj._`). */
+function scalaImportedSupertypes(file: string, imports: { owners: Set<string> }, context: ResolutionContext): Set<string> {
+  let memo = SCALA_IMPORTED_SUPERS.get(context);
+  if (!memo) SCALA_IMPORTED_SUPERS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const seen = new Set<string>();
+  // Code in `package sttp.client4` (or under it) sees `package object client4`'s members unimported.
+  const packages = [...(context.readFile(file) ?? '').matchAll(/^\s*package\s+([\w.]+)\s*$/gm)].flatMap((m) => m[1]!.split('.'));
+  const queue = [...imports.owners, ...packages];
+  const packageObjects = scalaPackageObjects(context);
+  while (queue.length > 0 && seen.size < 120) {
+    const typeName = queue.shift()!;
+    for (const sup of [...scalaSupertypesOf(typeName, context), ...(packageObjects.get(typeName) ?? [])]) {
+      if (!seen.has(sup)) { seen.add(sup); queue.push(sup); }
+    }
+  }
+  memo.set(file, seen);
+  return seen;
+}
+
+/** A Scala file's `import a.b.Obj._` / `import a.b.Obj.*` owners and `import a.b.Obj.{x, y}` / `Obj.x` members. */
+function scalaImportsOf(file: string, context: ResolutionContext): { owners: Set<string>; members: Set<string>; values: Set<string> } {
+  let memo = SCALA_IMPORTS.get(context);
+  if (!memo) SCALA_IMPORTS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const found = { owners: new Set<string>(), members: new Set<string>(), values: new Set<string>() };
+  const source = context.readFile(file) ?? '';
+  for (const m of source.matchAll(/^\s*import\s+([\w.]+?)\.(?:(_|\*)|\{([^}]*)\}|([\w$]+))\s*$/gm)) {
+    const owner = m[1]!.split('.').pop()!;
+    // `import builder._` — rooted at a value the file declares, whose type it doesn't say.
+    const root = m[1]!.split('.')[0]!;
+    if (/^[a-z]/.test(root) && (root === m[1] || new RegExp(`\\b(?:val|var|lazy\\s+val)\\s+${root}\\b|[(,]\\s*${root}\\s*:`).test(source))) {
+      found.values.add(owner);
+    }
+    if (m[2]) found.owners.add(owner);
+    else for (const member of (m[3] ?? m[4] ?? '').split(',')) {
+      const id = member.trim().split(/\s*=>\s*/)[0]!;
+      if (id === '_' || id === '*') found.owners.add(owner);
+      else if (id) found.members.add(`${owner}.${id}`);
+    }
+  }
+  memo.set(file, found);
+  return found;
+}
+
+const CSHARP_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'interface', 'enum', 'struct', 'record']);
+const CSHARP_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'property', 'field', 'enum_member', 'constant', 'event']);
+const CSHARP_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const CSHARP_STATIC_USINGS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/**
+ * Whether a bare C# name — `TestContext`, `Easing`, `Helper()` — can mean the
+ * member `n`: C# reads a bare name as a member of the types around it (outer
+ * classes included) or of their base types, or of a `using static` type.
+ * Never some unrelated class's: eShop's `TestContext.CancellationToken` in
+ * one test class went to another test class's `TestContext` property, MAUI's
+ * `Easing.Linear` to an animation class's `Easing`. Chain links the line
+ * shows a receiver for are not judged.
+ */
+function isCsharpMemberInScope(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (!CSHARP_MEMBER_KINDS.has(n.kind)) return true;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0 || !hasNoReceiverOnLine(ref, context)) return true;
+  const owner = n.qualifiedName.slice(0, cut).split(/::|\./).pop()!;
+  if (csharpStaticUsings(ref.filePath, context).has(owner)) return true;
+  const around = context
+    .getNodesInFile(ref.filePath)
+    .filter((t) => CSHARP_TYPE_KINDS.has(t.kind) && t.startLine <= ref.line && t.endLine >= ref.line);
+  // No type around the name: the declaration wasn't recovered — nothing to judge by.
+  if (around.length === 0) return true;
+  const seen = new Set<string>();
+  const queue = around.map((t) => t.name);
+  while (queue.length > 0 && seen.size < 40) {
+    const name = queue.shift()!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    if (name === owner) return true;
+    queue.push(...csharpSupertypesOf(name, context));
+  }
+  return false;
+}
+
+/** The simple names a C# type's declarations (every `partial` one) derive from. */
+function csharpSupertypesOf(typeName: string, context: ResolutionContext): string[] {
+  let memo = CSHARP_SUPERS.get(context);
+  if (!memo) CSHARP_SUPERS.set(context, (memo = new Map()));
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const names: string[] = [];
+  for (const decl of context.getNodesByName(typeName)) {
+    if (decl.language !== 'csharp' || !CSHARP_TYPE_KINDS.has(decl.kind)) continue;
+    const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+    let head = lines.slice(decl.startLine - 1, decl.startLine + 8).join(' ');
+    head = head.slice(0, (head.indexOf('{') + 1 || head.length + 1) - 1);
+    let depth = 0;
+    let flat = '';
+    for (const ch of head) {
+      if (ch === '<' || ch === '(') depth++;
+      else if (ch === '>' || ch === ')') depth = Math.max(0, depth - 1);
+      else if (depth === 0) flat += ch;
+    }
+    const bases = new RegExp(`\\b${typeName}\\s*:\\s*(.*?)(?:\\bwhere\\b|$)`).exec(flat)?.[1] ?? '';
+    for (const m of bases.matchAll(/([A-Za-z_][\w.]*)/g)) names.push(m[1]!.split('.').pop()!);
+  }
+  memo.set(typeName, names);
+  return names;
+}
+
+/**
+ * The types a C# file sees through static usings: its own `using static
+ * A.B.Type;`, any file's `global using static`, and `<Using Include="A.B.Type"
+ * Static="true"/>` in the `.csproj` / `Directory.Build.props` files above it
+ * (AutoMapper imports its ExpressionBuilder helpers project-wide that way).
+ */
+function csharpStaticUsings(file: string, context: ResolutionContext): Set<string> {
+  let memo = CSHARP_STATIC_USINGS.get(context);
+  if (!memo) CSHARP_STATIC_USINGS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const owners = new Set<string>(csharpProjectStaticUsings(path.posix.dirname(file), context, memo));
+  for (const m of (context.readFile(file) ?? '').matchAll(/^\s*(?:global\s+)?using\s+static\s+([\w.]+)\s*;/gm)) owners.add(m[1]!.split('.').pop()!);
+  memo.set(file, owners);
+  return owners;
+}
+
+/** Static usings that apply to every file under `dir`: project files on the way up, and every `global using static`. */
+function csharpProjectStaticUsings(dir: string, context: ResolutionContext, memo: Map<string, Set<string>>): Set<string> {
+  const key = `dir:${dir}`;
+  const hit = memo.get(key);
+  if (hit) return hit;
+  let owners: Set<string>;
+  if (dir === '.' || dir === '' || dir === '/') {
+    owners = new Set();
+    for (const f of context.getAllFiles()) {
+      if (!f.endsWith('.cs')) continue;
+      const text = context.readFile(f) ?? '';
+      if (!text.includes('global using static')) continue;
+      for (const m of text.matchAll(/^\s*global\s+using\s+static\s+([\w.]+)\s*;/gm)) owners.add(m[1]!.split('.').pop()!);
+    }
+  } else {
+    owners = new Set(csharpProjectStaticUsings(path.posix.dirname(dir), context, memo));
+  }
+  let entries: string[] = [];
+  try {
+    entries = fs.readdirSync(path.join(context.getProjectRoot(), dir === '.' ? '' : dir));
+  } catch {
+    entries = [];
+  }
+  for (const entry of entries) {
+    if (!/\.(?:csproj|props)$/i.test(entry)) continue;
+    let text = '';
+    try {
+      text = fs.readFileSync(path.join(context.getProjectRoot(), dir === '.' ? '' : dir, entry), 'utf8');
+    } catch {
+      continue;
+    }
+    for (const m of text.matchAll(/<Using\s+Include\s*=\s*"([\w.]+)"[^>]*\bStatic\s*=\s*"true"/gi)) owners.add(m[1]!.split('.').pop()!);
+  }
+  memo.set(key, owners);
+  return owners;
+}
+
+const CSHARP_NAMESPACE_SCOPES = new WeakMap<ResolutionContext, Map<string, { namespaces: string[]; usings: Set<string>; aliases: Map<string, string> }>>();
+const CSHARP_PROJECT_USINGS = new WeakMap<ResolutionContext, Map<string, { usings: Set<string>; project: boolean }>>();
+
+/**
+ * The namespaces a C# file's code runs in and the ones it imports: its
+ * `namespace` declarations, its `using X;`, the `global using X;` of its
+ * project's files (every file's, outside any project) and the
+ * `<Using Include="X" />` of the project files above it.
+ */
+function csharpNamespaceScope(file: string, context: ResolutionContext): { namespaces: string[]; usings: Set<string>; aliases: Map<string, string> } {
+  let memo = CSHARP_NAMESPACE_SCOPES.get(context);
+  if (!memo) CSHARP_NAMESPACE_SCOPES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const text = stripCommentsForRegex(context.readFile(file) ?? '', 'java');
+  const namespaces = [...text.matchAll(/^\s*namespace\s+([\w.]+)/gm)].map((m) => m[1]!);
+  let projectMemo = CSHARP_PROJECT_USINGS.get(context);
+  if (!projectMemo) CSHARP_PROJECT_USINGS.set(context, (projectMemo = new Map()));
+  const project = csharpProjectUsings(path.posix.dirname(file), context, projectMemo);
+  const usings = new Set<string>(project.usings);
+  if (!project.project) for (const u of csharpGlobalUsings('.', context)) usings.add(u);
+  const aliases = new Map<string, string>();
+  for (const m of text.matchAll(/^\s*(?:global\s+)?using\s+(?!static\b)(?:([A-Za-z_]\w*)\s*=\s*)?([\w.]+)\s*;/gm)) {
+    if (m[1]) aliases.set(m[1], m[2]!);
+    else usings.add(m[2]!);
+  }
+  const scope = { namespaces, usings, aliases };
+  memo.set(file, scope);
+  return scope;
+}
+
+/**
+ * The `<Using Include="X" />` of the project files from `dir` up, and the
+ * `global using X;` of each project's own files — a global using is its
+ * project's alone: serilog's Serilog.Tests and Serilog.PerformanceTests each
+ * `global using` their own `Support` namespace, and both define `Some`.
+ * `project` says whether a `.csproj` sits at `dir` or above it.
+ */
+function csharpProjectUsings(dir: string, context: ResolutionContext, memo: Map<string, { usings: Set<string>; project: boolean }>): { usings: Set<string>; project: boolean } {
+  const key = dir;
+  const hit = memo.get(key);
+  if (hit) return hit;
+  const root = dir === '.' || dir === '' || dir === '/';
+  const parent = root ? null : csharpProjectUsings(path.posix.dirname(dir), context, memo);
+  const usings = new Set<string>(parent?.usings ?? []);
+  let project = parent?.project ?? false;
+  let entries: string[] = [];
+  try {
+    entries = fs.readdirSync(path.join(context.getProjectRoot(), root ? '' : dir));
+  } catch {
+    entries = [];
+  }
+  for (const entry of entries) {
+    if (!/\.(?:csproj|props)$/i.test(entry)) continue;
+    let text = '';
+    try {
+      text = fs.readFileSync(path.join(context.getProjectRoot(), root ? '' : dir, entry), 'utf8');
+    } catch {
+      continue;
+    }
+    if (/\.csproj$/i.test(entry) && !project) {
+      project = true;
+      for (const u of csharpGlobalUsings(root ? '.' : dir, context)) usings.add(u);
+    }
+    for (const m of text.matchAll(/<Using\s+Include\s*=\s*"([\w.]+)"(?![^>]*\bStatic\s*=\s*"true")[^>]*>/gi)) usings.add(m[1]!);
+    // The SDK's implicit usings (serilog's own `System.TimeProvider` polyfill is seen through them).
+    if (/<ImplicitUsings>\s*(?:enable|true)\s*<\/ImplicitUsings>/i.test(text)) {
+      for (const ns of CSHARP_IMPLICIT_USINGS) usings.add(ns);
+    }
+  }
+  const result = { usings, project };
+  memo.set(key, result);
+  return result;
+}
+
+const CSHARP_GLOBAL_USINGS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/** The `global using X;` of the `.cs` files under `dir` (`.` = the whole repository). */
+function csharpGlobalUsings(dir: string, context: ResolutionContext): Set<string> {
+  let memo = CSHARP_GLOBAL_USINGS.get(context);
+  if (!memo) CSHARP_GLOBAL_USINGS.set(context, (memo = new Map()));
+  const hit = memo.get(dir);
+  if (hit) return hit;
+  const usings = new Set<string>();
+  const prefix = dir === '.' ? '' : `${dir}/`;
+  for (const f of context.getAllFiles()) {
+    if (!f.endsWith('.cs') || !f.startsWith(prefix) || (context.fileContains && !context.fileContains(f, 'global using'))) continue;
+    for (const m of (context.readFile(f) ?? '').matchAll(/^\s*global\s+using\s+(?!static\b)([\w.]+)\s*;/gm)) usings.add(m[1]!);
+  }
+  memo.set(dir, usings);
+  return usings;
+}
+
+/** The namespaces `<ImplicitUsings>enable</ImplicitUsings>` imports into every file (Microsoft.NET.Sdk). */
+const CSHARP_IMPLICIT_USINGS: readonly string[] = [
+  'System', 'System.Collections.Generic', 'System.IO', 'System.Linq', 'System.Net.Http', 'System.Threading', 'System.Threading.Tasks',
+];
+
+/**
+ * Whether a bare C# type name can mean `n` — a type in namespace `N` is seen
+ * from `N` and the namespaces inside it, and through a `using N;` —
+ * Newtonsoft's `async Task` tests (`using System.Threading.Tasks;`) bound
+ * `Task` to a test class of that name in `Newtonsoft.Json.Tests.Schema`, 433
+ * times. A type in the global namespace is seen everywhere.
+ */
+function isCsharpTypeVisible(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const cut = n.qualifiedName.indexOf('::');
+  if (cut < 0) return true;
+  const ns = n.qualifiedName.slice(0, cut);
+  // A nested type (`Outer::Inner`) is judged by its outermost type's namespace.
+  const scope = csharpNamespaceScope(ref.filePath, context);
+  // `using License = AutoMapper.Licensing.License;` names that type, whatever the file's usings.
+  const aliased = scope.aliases.get(ref.referenceName);
+  if (aliased !== undefined) return aliased === `${ns}.${n.qualifiedName.slice(cut + 2).replace(/::/g, '.')}`;
+  if (scope.namespaces.some((own) => own === ns || own.startsWith(ns + '.'))) return true;
+  return scope.usings.has(ns);
+}
+
+/**
+ * Whether a bare C# name can reach `n` as a nested type: only from inside the
+ * type that declares it (any partial part, any depth) or a class deriving from
+ * it. AutoMapper's tests each declare their own nested `Source`, and a
+ * same-file `new Source()` went to whichever test class came first.
+ */
+function isCsharpNestedTypeInScope(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const owner = n.qualifiedName.slice(0, cut);
+  const ownerType = context.getNodesInFile(n.filePath).find((p) => CSHARP_TYPE_KINDS.has(p.kind) && p.qualifiedName === owner);
+  // Declared in a namespace, not a type.
+  if (!ownerType) return true;
+  const enclosing = context.getNodesInFile(ref.filePath)
+    .filter((p) => CSHARP_TYPE_KINDS.has(p.kind) && p.startLine <= ref.line && p.endLine >= ref.line);
+  if (enclosing.some((p) => p.qualifiedName === owner || p.qualifiedName.startsWith(`${owner}::`))) return true;
+  // Inherited: a type around the ref derives from the owner (`class SourceA :
+  // Source`), through any partial part — Newtonsoft's JsonTextReader.Async.cs
+  // is `partial class JsonTextReader` with no base list, reading JsonReader's `State`.
+  return enclosing.some((p) => csharpAncestorNames(p.qualifiedName, context).has(ownerType.name));
+}
+
+const CSHARP_ANCESTORS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/** The simple names of the C# types `qn` derives from, through every partial part and base, a few levels up. */
+function csharpAncestorNames(qn: string, context: ResolutionContext, depth = 0): Set<string> {
+  let memo = CSHARP_ANCESTORS.get(context);
+  if (!memo) CSHARP_ANCESTORS.set(context, (memo = new Map()));
+  const hit = memo.get(qn);
+  if (hit) return hit;
+  const names = new Set<string>();
+  memo.set(qn, names); // a cycle reads what is gathered so far
+  for (const decl of context.getNodesByQualifiedName(qn)) {
+    if (decl.language !== 'csharp' || !CSHARP_TYPE_KINDS.has(decl.kind)) continue;
+    const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+    let header = '';
+    for (let i = decl.startLine - 1; i < Math.min(lines.length, decl.startLine + 6) && !header.includes('{'); i++) header += `${lines[i] ?? ''} `;
+    const list = /:\s*([^{;]*)/.exec(header.split('{')[0]!.replace(/\bwhere\b[\s\S]*$/, ''))?.[1] ?? '';
+    for (const base of splitCppTopLevel(list)) {
+      const name = /([A-Za-z_]\w*)\s*(?:<.*)?$/.exec(base.trim())?.[1];
+      if (name) names.add(name);
+    }
+  }
+  if (depth < 4) {
+    for (const base of [...names]) {
+      for (const t of context.getNodesByName(base)) {
+        if (t.language !== 'csharp' || !CSHARP_TYPE_KINDS.has(t.kind) || t.qualifiedName === qn) continue;
+        for (const up of csharpAncestorNames(t.qualifiedName, context, depth + 1)) names.add(up);
+      }
+    }
+  }
+  return names;
+}
+
+const OBJC_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const OBJC_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'property', 'field']);
+
+/**
+ * How a bare Objective-C name is written at its site: `c-call` for C call
+ * syntax (`completionBlock()` — a function, a block or a function pointer,
+ * never a method), `self-send` for a message to `self` / `super` /
+ * `[self class]`, whose receiver the extractor drops; null otherwise.
+ */
+function objcCallShape(ref: UnresolvedRef, context: ResolutionContext): 'c-call' | 'self-send' | 'super-send' | null {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return null;
+  const name = ref.referenceName.split(':')[0]!;
+  if (!name) return null;
+  const at = new RegExp(`(?<![\\w.])${name}\\b`, 'g');
+  let m: RegExpExecArray | null;
+  let shape: 'c-call' | 'self-send' | 'super-send' | null = null;
+  while ((m = at.exec(line))) {
+    const before = line.slice(0, m.index);
+    const after = line.slice(m.index + name.length);
+    if (/^\s*\(/.test(after) && !/\[\s*[\w.]+\s+$/.test(before)) shape ??= 'c-call';
+    else if (/\[\s*super\s+$/.test(before)) return 'super-send';
+    else if (/\[\s*(?:self|\[\s*self\s+class\s*\])\s+$/.test(before)) return 'self-send';
+  }
+  return shape;
+}
+
+/**
+ * The classes a message to `self` / `super` can reach: the class it is
+ * written in and every class that one inherits from (read from its
+ * `@interface Name : Super` declarations; category methods are indexed under
+ * the class they extend). Null outside any class.
+ */
+function objcHierarchyAt(ref: UnresolvedRef, context: ResolutionContext): Set<string> | null {
+  const inFile = context.getNodesInFile(ref.filePath);
+  let here = inFile
+    .filter((c) => c.kind === 'class' && c.startLine <= ref.line && c.endLine >= ref.line)
+    .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0]?.name;
+  // An `@implementation` whose range the index lost still names its class in
+  // its methods: `SDWebImageDownloaderDecryptor::initWithBlock:`.
+  if (!here) {
+    const method = inFile.find((c) => c.kind === 'method' && c.startLine <= ref.line && c.endLine >= ref.line && c.qualifiedName.includes('::'));
+    here = method?.qualifiedName.slice(0, method.qualifiedName.lastIndexOf('::'));
+  }
+  if (!here) return null;
+  const seen = new Set<string>();
+  const queue = [here];
+  while (queue.length > 0 && seen.size < 30) {
+    const name = queue.shift()!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    queue.push(...objcSupertypesOf(name, context));
+  }
+  return seen;
+}
+
+/**
+ * Whether a message to `self` / `super` can mean `n`: a method of a class in
+ * the sender's hierarchy — SDWebImage's `[self class]` went to SDWeakProxy's
+ * `class` 71 times. When tree-sitter-objc loses an `@implementation`
+ * (AFNetworking's AFURLSessionManager) its methods are indexed as functions:
+ * one in the sender's own file, or in the file named after a class of its
+ * hierarchy, still counts (as does any, when the sender's own class was lost
+ * too). A function elsewhere is never what `[super init]` sends to.
+ */
+function isObjcSelfSendTarget(n: Node, ref: UnresolvedRef, context: ResolutionContext, toSuper = false): boolean {
+  const hierarchy = objcHierarchyAt(ref, context);
+  if (OBJC_MEMBER_KINDS.has(n.kind)) {
+    const cut = n.qualifiedName.lastIndexOf('::');
+    if (cut < 0 || hierarchy === null) return true;
+    const owner = n.qualifiedName.slice(0, cut);
+    // `[super init]` goes past the class it is written in.
+    return hierarchy.has(owner) && !(toSuper && owner === [...hierarchy][0]);
+  }
+  if (n.filePath === ref.filePath) return !toSuper;
+  if (hierarchy === null) return true;
+  const base = n.filePath.slice(n.filePath.lastIndexOf('/') + 1).replace(/\.\w+$/, '');
+  return hierarchy.has(base) && !(toSuper && base === [...hierarchy][0]);
+}
+
+/**
+ * UIKit / AppKit superclasses, for a category on a system class: an
+ * `UIImageView (WebCache)` method sending `[self sd_internalSetImageWithURL:…]`
+ * reaches the `UIView (WebCache)` category.
+ */
+const OBJC_SYSTEM_SUPERS: Readonly<Record<string, string>> = {
+  UIResponder: 'NSObject', UIView: 'UIResponder', UIViewController: 'UIResponder', UIWindow: 'UIView',
+  UIControl: 'UIView', UIButton: 'UIControl', UITextField: 'UIControl', UISwitch: 'UIControl', UISlider: 'UIControl',
+  UISegmentedControl: 'UIControl', UIStepper: 'UIControl', UIPageControl: 'UIControl', UIDatePicker: 'UIControl',
+  UIRefreshControl: 'UIControl', UIStackView: 'UIView', UINavigationBar: 'UIView', UIToolbar: 'UIView',
+  UITabBar: 'UIView', UISearchBar: 'UIView', UIVisualEffectView: 'UIView', UIActivityIndicatorView: 'UIView',
+  UIProgressView: 'UIView', UIPickerView: 'UIView', UITableViewHeaderFooterView: 'UIView',
+  UITableViewController: 'UIViewController', UICollectionViewController: 'UIViewController',
+  UINavigationController: 'UIViewController', UITabBarController: 'UIViewController',
+  UIPageViewController: 'UIViewController', UISplitViewController: 'UIViewController',
+  UIAlertController: 'UIViewController', UIHostingController: 'UIViewController',
+  UIImageView: 'UIView', UILabel: 'UIView', UIScrollView: 'UIView', UITableView: 'UIScrollView',
+  UICollectionView: 'UIScrollView', UITextView: 'UIScrollView', UITableViewCell: 'UIView',
+  UICollectionReusableView: 'UIView', UICollectionViewCell: 'UICollectionReusableView',
+  MKAnnotationView: 'UIView', MKMapView: 'UIView',
+  NSResponder: 'NSObject', NSView: 'NSResponder', NSViewController: 'NSResponder', NSWindow: 'NSResponder',
+  NSControl: 'NSView', NSImageView: 'NSControl', NSButton: 'NSControl', NSTextField: 'NSControl', NSTableView: 'NSControl',
+};
+
+/**
+ * Whether an Objective-C receiver's type owns `method`, in its hierarchy: the
+ * receiver names a class (`[AllTypesObject objectsInRealm:…]` — a class
+ * method inherited from RLMObject), or is a property one of whose
+ * `@property … Type *name` declarations gives such a type
+ * (`managed.anyDataObj` → RLMSet, for `containsObject:`).
+ */
+function objcReceiverReaches(receiver: string, method: Node, context: ResolutionContext): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return false;
+  const owner = method.qualifiedName.slice(0, cut);
+  let types: string[] = [];
+  if (/^[A-Z]\w*$/.test(receiver)) {
+    if (context.getNodesByName(receiver).some((n) => n.kind === 'class' && n.language === 'objc')) types = [receiver];
+  } else if (receiver.includes('.')) types = objcPropertyTypes(receiver.split('.').pop()!, context);
+  const seen = new Set<string>();
+  const queue = [...types];
+  while (queue.length > 0 && seen.size < 40) {
+    const name = queue.shift()!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    if (name === owner) return true;
+    queue.push(...objcSupertypesOf(name, context));
+  }
+  return false;
+}
+
+/** The classes the `@property … Type *name` declarations of `name` give. */
+function objcPropertyTypes(name: string, context: ResolutionContext): string[] {
+  const types = new Set<string>();
+  const decl = new RegExp(`@property\\s*(?:\\([^)]*\\)\\s*)?([A-Z]\\w*)\\s*(?:<[^;]*>\\s*)?\\*\\s*(?:_Nullable\\s+|_Nonnull\\s+)?${name}\\b`);
+  for (const n of context.getNodesByName(name)) {
+    if (n.kind !== 'property' || n.language !== 'objc') continue;
+    const line = context.getFileLines?.(n.filePath)?.[n.startLine - 1] ?? context.readFile(n.filePath)?.split('\n')[n.startLine - 1] ?? '';
+    const t = decl.exec(line)?.[1];
+    if (t) types.add(t);
+  }
+  return [...types];
+}
+
+/** The superclasses an Objective-C class's `@interface` declarations name. */
+function objcSupertypesOf(name: string, context: ResolutionContext): string[] {
+  let memo = OBJC_SUPERS.get(context);
+  if (!memo) OBJC_SUPERS.set(context, (memo = new Map()));
+  const hit = memo.get(name);
+  if (hit) return hit;
+  const supers: string[] = [];
+  for (const decl of context.getNodesByName(name)) {
+    if (decl.kind !== 'class' || decl.language !== 'objc') continue;
+    const line = context.getFileLines?.(decl.filePath)?.[decl.startLine - 1] ?? context.readFile(decl.filePath)?.split('\n')[decl.startLine - 1] ?? '';
+    const sup = /@interface\s+\w+\s*:\s*(\w+)/.exec(line)?.[1];
+    if (sup && !supers.includes(sup)) supers.push(sup);
+  }
+  const system = OBJC_SYSTEM_SUPERS[name];
+  if (supers.length === 0 && system) supers.push(system);
+  memo.set(name, supers);
+  return supers;
+}
+
+const VB_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'property', 'field', 'enum_member', 'constant', 'variable']);
+
+/**
+ * What a VB.NET member access is written on, read at the call site: the
+ * extractor keeps a call's last name only, so `Me.CMB.Buttons.Add(x)` and
+ * `New System.Drawing.Size(1, 2)` arrive as bare `Add` / `Size`. Returns null
+ * for a genuinely bare name, `''` for a `With` block's `.Name`, else the
+ * text before the dot (`Me.CMB.Buttons`, `System.Drawing`).
+ */
+function vbReceiverOf(ref: UnresolvedRef, context: ResolutionContext): string | null {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return null;
+  const lower = line.toLowerCase();
+  const name = ref.referenceName.toLowerCase();
+  let start = lower.startsWith(name, ref.column) ? ref.column : -1;
+  if (start < 0) {
+    // The reference starts at its receiver or its `New`, so the name is the
+    // first one there or after: `st.Language = New Language(…)` constructs
+    // a Language through no receiver, and `Me.Size = New System.Drawing.Size(…)`
+    // through `System.Drawing`, not `Me`.
+    const at = new RegExp(`(?<![\\w])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w])`, 'g');
+    at.lastIndex = Math.max(0, ref.column);
+    const m = at.exec(lower) ?? (at.lastIndex = 0, at.exec(lower));
+    start = m ? m.index : -1;
+  }
+  if (start < 0) return null;
+  const before = line.slice(0, start);
+  const dot = /([\w.()]*?)\s*\.\s*$/.exec(before);
+  if (!dot) return null;
+  // `GetService(Of TrayNotifierService).Notify()` — the type argument names the receiver.
+  const typeArg = /\(\s*Of\s+([\w.]+)\s*\)\s*\.\s*$/i.exec(before);
+  if (typeArg) return typeArg[1]!;
+  return dot[1]!.replace(/\([^()]*\)/g, '');
+}
+
+/**
+ * Whether a VB.NET member access can mean `n`: through `Me` / `MyBase` /
+ * `MyClass`, or through a name that is `n`'s own type or module
+ * (`Module1.Log()`, `Colors.Red`). Any other receiver has a type nothing here
+ * names — SCrawler's `New System.Drawing.Size(…)` went to a nested enum's
+ * `Size` case 713 times, its designer's `Controls.Add(…)` to a collection
+ * class's `Add` 547.
+ */
+function isVbMemberReachable(n: Node, receiver: string): boolean {
+  if (!VB_MEMBER_KINDS.has(n.kind)) return true;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const last = receiver.split('.').pop()!.toLowerCase();
+  if (/^(?:me|mybase|myclass)$/.test(last) && !receiver.includes('.')) return true;
+  const owner = n.qualifiedName.slice(0, cut).split(/::|\./).pop()!.toLowerCase();
+  return last !== '' && last === owner;
+}
+
+/**
+ * Whether a VB.NET call has no receiver, or one the extractor drops (`Me`,
+ * `MyClass`, `MyBase`) — a call isVbMemberInScope judges. A name its line
+ * doesn't show (a link of a chain continued from the line above) is not.
+ */
+function isVbScopedCall(ref: UnresolvedRef, receiver: string | null, context: ResolutionContext): boolean {
+  if (ref.language !== 'vbnet' || ref.referenceKind !== 'calls' || !/^\w+$/.test(ref.referenceName)) return false;
+  return receiver === null ? hasNoReceiverOnLine(ref, context) : /^(?:me|mybase|myclass)$/i.test(receiver);
+}
+
+/** Whether a VB.NET call or construction names its target with nothing before it (`New Point(4, 285)`). */
+function isVbUnqualifiedName(ref: UnresolvedRef, receiver: string | null, context: ResolutionContext): boolean {
+  if (ref.language !== 'vbnet' || (ref.referenceKind !== 'calls' && ref.referenceKind !== 'instantiates')) return false;
+  return receiver === null && /^\w+$/.test(ref.referenceName) && hasNoReceiverOnLine(ref, context);
+}
+
+const CFML_CHAINS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/**
+ * Whether a bare CFML call written in a component can mean `method`: its own
+ * component's, or one of the components it `extends` (read from source — a
+ * dotted path matched against the indexed files by its longest suffix). A
+ * call in a `.cfm` template is not judged: a ColdBox view runs inside the
+ * renderer's scope. coldbox's `now()` — the built-in — went to a date
+ * helper's `now` 228 times; chained `.then()` calls arrive bare too, and keep
+ * their method.
+ */
+function isCfmlMethodInScope(method: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (!/\.cfc$/i.test(ref.filePath) || !hasNoReceiverOnLine(ref, context)) return true;
+  return cfmlChain(ref.filePath, context).has(method.filePath);
+}
+
+/** A component file and every component file it extends. */
+function cfmlChain(file: string, context: ResolutionContext): Set<string> {
+  let memo = CFML_CHAINS.get(context);
+  if (!memo) CFML_CHAINS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const chain = new Set<string>();
+  const queue = [file];
+  while (queue.length > 0 && chain.size < 30) {
+    const f = queue.shift()!;
+    if (chain.has(f)) continue;
+    chain.add(f);
+    const text = context.readFile(f) ?? '';
+    const head = text.slice(0, text.search(/\bfunction\b|<cffunction/i) >>> 0 || text.length);
+    const ext = /\bextends\s*=\s*["']?([\w.\/:-]+)["']?/i.exec(head)?.[1];
+    if (ext) queue.push(...cfmlComponentFiles(ext, f, context));
+  }
+  memo.set(file, chain);
+  return chain;
+}
+
+/** The indexed `.cfc` files a component path names: the same directory first, else the longest path suffix. */
+function cfmlComponentFiles(dotted: string, from: string, context: ResolutionContext): string[] {
+  const segments = dotted.replace(/\//g, '.').split('.').filter(Boolean);
+  const name = segments[segments.length - 1]!.toLowerCase();
+  const files = [...new Set(context.getNodesByLowerName(name)
+    .filter((n) => n.kind === 'class' && /\.cfc$/i.test(n.filePath))
+    .map((n) => n.filePath))];
+  if (files.length === 0) return [];
+  const dir = from.slice(0, from.lastIndexOf('/') + 1);
+  if (segments.length === 1) {
+    const local = files.filter((f) => f.slice(0, f.lastIndexOf('/') + 1) === dir);
+    return local.length > 0 ? local : files;
+  }
+  for (let take = segments.length; take >= 1; take--) {
+    const suffix = '/' + segments.slice(-take).join('/').toLowerCase() + '.cfc';
+    const hits = files.filter((f) => ('/' + f.toLowerCase()).endsWith(suffix));
+    if (hits.length > 0) return hits;
+  }
+  return files;
+}
+
+const NO_RECEIVER_LINES = new WeakMap<ResolutionContext, WeakMap<UnresolvedRef, boolean>>();
+
+/**
+ * Whether a bare reference is receiver-less at its call site, name case
+ * aside: the name is not preceded by a `.` on its line (true when the line
+ * can't tell). An extractor that keeps one receiver level hands the later
+ * links of a chain (`newFuture(f).then(g)`) over bare.
+ */
+function hasNoReceiverOnLine(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  // Asked once per CANDIDATE by the per-language scope filters, though only
+  // the ref decides it — a bare `init()` in a CFML codebase has hundreds of
+  // same-named methods, each re-reading the line (#2091).
+  let memo = NO_RECEIVER_LINES.get(context);
+  if (!memo) NO_RECEIVER_LINES.set(context, (memo = new WeakMap()));
+  let answer = memo.get(ref);
+  if (answer === undefined) memo.set(ref, (answer = readNoReceiverOnLine(ref, context)));
+  return answer;
+}
+
+function readNoReceiverOnLine(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (line === undefined) return true;
+  const lower = line.toLowerCase();
+  const name = ref.referenceName.toLowerCase();
+  let start = -1;
+  if (lower.startsWith(name, ref.column)) start = ref.column;
+  else if (ref.column >= name.length && lower.startsWith(name, ref.column - name.length)) start = ref.column - name.length;
+  else start = lower.search(new RegExp(`(?<![\\w$])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\(`));
+  // Not on its line at all: a link of a chain written across lines.
+  if (start < 0) return false;
+  return !/\.\s*$/.test(line.slice(0, start));
+}
+
+const RUBY_ANCESTRY = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/**
+ * Whether a bare Ruby call written inside a class body can mean `method`: a
+ * receiver-less call is a call on `self`, so it reaches the class's own
+ * methods, its superclasses', and those of the modules any of them
+ * `include`s, `extend`s or `prepend`s — read from source, resolved against
+ * the lexical nesting (`class Foo < Base` inside `module RuboCop::Cop` is
+ * `RuboCop::Cop::Base`). A call in a module body, a block at the top of a
+ * file (a spec, a DSL) or a script is not judged: a module's methods run on
+ * whatever includes it, and a block may be evaluated on anything. rubocop's
+ * `format(…)` — Kernel's — went to the LSP runtime's `format` 411 times.
+ */
+function isRubyMethodInScope(method: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const here = context
+    .getNodesInFile(ref.filePath)
+    .filter((n) => (n.kind === 'class' || n.kind === 'module') && n.startLine <= ref.line && n.endLine >= ref.line)
+    .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+  if (!here || here.kind !== 'class') return true;
+  return rubyAncestry(here.qualifiedName, context).has(method.qualifiedName.slice(0, cut));
+}
+
+/** A Ruby class's qualified name, those of its superclasses, and of every module mixed into any of them. */
+function rubyAncestry(qn: string, context: ResolutionContext): Set<string> {
+  let memo = RUBY_ANCESTRY.get(context);
+  if (!memo) RUBY_ANCESTRY.set(context, (memo = new Map()));
+  const hit = memo.get(qn);
+  if (hit) return hit;
+  const seen = new Set<string>();
+  const queue = [qn];
+  while (queue.length > 0 && seen.size < 60) {
+    const q = queue.shift()!;
+    if (seen.has(q)) continue;
+    seen.add(q);
+    for (const decl of context.getNodesByQualifiedName(q)) {
+      if (decl.language !== 'ruby' || (decl.kind !== 'class' && decl.kind !== 'module')) continue;
+      const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+      const outer = q.includes('::') ? q.slice(0, q.lastIndexOf('::')) : '';
+      const sup = /^\s*class\s+[\w:]+\s*<\s*(::)?([A-Z][\w:]*)/.exec(lines[decl.startLine - 1] ?? '');
+      if (sup) queue.push(rubyConstantQn(sup[2]!, sup[1] ? '' : outer, context));
+      for (const line of lines.slice(decl.startLine, decl.endLine)) {
+        const mix = /^\s*(?:include|extend|prepend)\s+([A-Z:][\w:]*(?:\s*,\s*[A-Z:][\w:]*)*)/.exec(line);
+        if (!mix) continue;
+        for (const name of mix[1]!.split(/\s*,\s*/)) {
+          queue.push(name.startsWith('::') ? rubyConstantQn(name.slice(2), '', context) : rubyConstantQn(name, q, context));
+        }
+      }
+    }
+  }
+  memo.set(qn, seen);
+  return seen;
+}
+
+/** The class or module a constant written inside `scope` names: the nearest enclosing namespace that has it, else the name itself. */
+function rubyConstantQn(name: string, scope: string, context: ResolutionContext): string {
+  for (let prefix = scope; ; prefix = prefix.includes('::') ? prefix.slice(0, prefix.lastIndexOf('::')) : '') {
+    const qn = prefix ? `${prefix}::${name}` : name;
+    if (context.getNodesByQualifiedName(qn).some((n) => n.language === 'ruby' && (n.kind === 'class' || n.kind === 'module'))) return qn;
+    if (!prefix) return name;
+  }
+}
+
+const KOTLIN_FILE_SCOPES = new WeakMap<ResolutionContext, Map<string, { pkg: string; imports: Set<string>; stars: Set<string> }>>();
+/** Packages every Kotlin file imports without writing it. */
+const KOTLIN_DEFAULT_IMPORTS: ReadonlySet<string> = new Set([
+  'kotlin', 'kotlin.annotation', 'kotlin.collections', 'kotlin.comparisons', 'kotlin.io', 'kotlin.ranges',
+  'kotlin.sequences', 'kotlin.text', 'kotlin.jvm', 'java.lang', 'kotlin.js',
+]);
+const KOTLIN_ENCLOSING_KINDS: ReadonlySet<string> = new Set([
+  'class', 'interface', 'enum', 'struct', 'trait', 'protocol', 'module', 'namespace', 'function', 'method',
+]);
+
+/** A Kotlin file's `package` and the names and packages its `import`s bring in. */
+function kotlinFileScope(file: string, context: ResolutionContext): { pkg: string; imports: Set<string>; stars: Set<string> } {
+  let memo = KOTLIN_FILE_SCOPES.get(context);
+  if (!memo) KOTLIN_FILE_SCOPES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const text = (context.readFile(file) ?? '').replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/`/g, '');
+  const pkg = /^\s*package\s+([\w.]+)/m.exec(text)?.[1] ?? '';
+  const imports = new Set<string>();
+  const stars = new Set<string>();
+  for (const m of text.matchAll(/^\s*import\s+([\w.]+?)(\.\*)?(?:\s+as\s+\w+)?\s*;?\s*(?:\/\/.*)?$/gm)) {
+    if (m[2]) stars.add(m[1]!);
+    else imports.add(m[1]!);
+  }
+  const scope = { pkg, imports, stars };
+  memo.set(file, scope);
+  return scope;
+}
+
+/**
+ * Whether a top-level Kotlin declaration — a function, an extension function
+ * (indexed under its receiver type, `JdbcTransaction::assertEquals`), a
+ * property — can be named from the file a call is written in: its own
+ * package, an `import` of it, or a star import of its package. A member of a
+ * class is not judged here; a lambda's receiver can put any type's members in
+ * scope. Exposed's tests call `assertEquals(…)` from kotlin.test and JUnit, or
+ * import the JDBC suite's extension; the calls went to the R2DBC suite's
+ * extension 3,075 times.
+ */
+function isKotlinTopLevelVisible(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (n.language !== 'kotlin' || n.filePath === ref.filePath) return true;
+  const enclosed = context
+    .getNodesInFile(n.filePath)
+    .some((o) => o.id !== n.id && KOTLIN_ENCLOSING_KINDS.has(o.kind) && o.startLine <= n.startLine && o.endLine >= n.endLine &&
+      (o.startLine < n.startLine || o.endLine > n.endLine));
+  if (enclosed) return true;
+  const pkg = kotlinFileScope(n.filePath, context).pkg;
+  const here = kotlinFileScope(ref.filePath, context);
+  return pkg === here.pkg || here.stars.has(pkg) || here.imports.has(pkg ? `${pkg}.${n.name}` : n.name) || KOTLIN_DEFAULT_IMPORTS.has(pkg);
+}
+
+const PHP_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'trait', 'interface', 'enum']);
+const PHP_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/**
+ * How a bare PHP method name was written at its call site: `$this->m()` /
+ * `self::m()` / `static::m()` are the enclosing class's own (or inherited)
+ * methods, `parent::m()` an ancestor's; null for anything else.
+ */
+function phpSelfReceiver(ref: UnresolvedRef, context: ResolutionContext): 'self' | 'parent' | null {
+  if (ref.language !== 'php' || ref.referenceKind !== 'calls' || !/^\w+$/.test(ref.referenceName)) return null;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (!line) return null;
+  const name = ref.referenceName;
+  if (new RegExp(String.raw`\$this\s*\??->\s*${name}\s*\(|\b(?:self|static)\s*::\s*${name}\s*\(`).test(line)) return 'self';
+  if (new RegExp(String.raw`\bparent\s*::\s*${name}\s*\(`).test(line)) return 'parent';
+  return null;
+}
+
+/**
+ * Whether `method` belongs to the class the call is written in, one it
+ * extends, or a trait any of them uses — read from source, since the
+ * resolver's supertype edges don't exist yet on the first pass, and resolved
+ * the way PHP resolves a class name: through the file's `namespace` and `use`
+ * imports (aliases included) to one fully qualified class. A parent outside
+ * the repository (PHPUnit's TestCase, Orchestra's) ends the chain. Drupal's
+ * `$this->assertEquals()` is PHPUnit's; it went to the one in-repo
+ * `assertEquals`, a comparator's, 8,832 times.
+ */
+function isPhpMethodInScope(method: Node, ref: UnresolvedRef, via: 'self' | 'parent', context: ResolutionContext): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const ownerQn = method.qualifiedName.slice(0, cut);
+  const enclosing = context
+    .getNodesInFile(ref.filePath)
+    .filter((n) => PHP_TYPE_KINDS.has(n.kind) && n.startLine <= ref.line && n.endLine >= ref.line)
+    .sort((a, b) => b.startLine - a.startLine)[0];
+  // Inside a trait, `$this` is whichever class uses it: Laravel's
+  // ValidatesAttributes calls the Validator's `getValue()`.
+  if (!enclosing || enclosing.kind === 'trait') return true;
+  const up = phpAncestry(via === 'parent' ? phpSupertypeQns(enclosing, context) : [enclosing.qualifiedName], context);
+  if (up.qns.has(ownerQn)) return true;
+  // A base class may call what a subclass defines (BookStack's Entity calls
+  // `$this->chapter()`, a Page method): the owner descends from the caller.
+  if (via === 'self' && phpAncestry([ownerQn], context).qns.has(enclosing.qualifiedName)) return true;
+  // Past an ancestor outside the repository (Orchestra's TestCase) that
+  // ancestor's members are unseen — the repository's traits it uses among
+  // them. A trait's method may still be the one meant; an unrelated class's
+  // (Drupal's comparator `assertEquals`) never is.
+  return up.leavesRepo && context.getNodesByQualifiedName(ownerQn).some((d) => d.kind === 'trait');
+}
+
+/**
+ * Whether a PHP receiver is named after a class that has `method` in its
+ * ancestry: `$page->save()` → Page, which extends Entity; `$newRole->users()`
+ * → Role. BookStack's `$role->save()` is not Entity's (Role is a Model).
+ */
+function phpReceiverReaches(receiver: string, method: Node, context: ResolutionContext): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return false;
+  const owner = method.qualifiedName.slice(0, cut);
+  const last = receiver.split('.').pop()!.replace(/^\$/, '');
+  if (!last) return false;
+  const words = splitCamelCase(last);
+  const names = new Set([last, words[words.length - 1] ?? last].map((w) => w.charAt(0).toUpperCase() + w.slice(1)));
+  for (const name of names) {
+    for (const decl of context.getNodesByName(name)) {
+      if (decl.language !== 'php' || !PHP_TYPE_KINDS.has(decl.kind)) continue;
+      if (phpAncestry([decl.qualifiedName], context).qns.has(owner)) return true;
+    }
+  }
+  return false;
+}
+
+/** Every type `start` reaches through `extends` and trait `use`, and whether it left the repository on the way. */
+function phpAncestry(start: readonly string[], context: ResolutionContext): { qns: Set<string>; leavesRepo: boolean } {
+  const qns = new Set<string>();
+  const queue = [...start];
+  let leavesRepo = false;
+  while (queue.length > 0 && qns.size < 80) {
+    const qn = queue.shift()!;
+    if (qns.has(qn)) continue;
+    qns.add(qn);
+    const decls = context.getNodesByQualifiedName(qn).filter((d) => d.language === 'php' && PHP_TYPE_KINDS.has(d.kind));
+    if (decls.length === 0) leavesRepo = true;
+    for (const decl of decls) queue.push(...phpSupertypeQns(decl, context));
+  }
+  return { qns, leavesRepo };
+}
+
+const PHP_FILE_SCOPES = new WeakMap<ResolutionContext, Map<string, { namespace: string; uses: Map<string, string> }>>();
+
+/** A PHP file's `namespace` and its `use A\B\C [as D];` imports, alias → fully qualified name. */
+function phpFileScope(file: string, context: ResolutionContext): { namespace: string; uses: Map<string, string> } {
+  let memo = PHP_FILE_SCOPES.get(context);
+  if (!memo) PHP_FILE_SCOPES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const text = context.readFile(file) ?? '';
+  const namespace = /^\s*namespace\s+([\w\\]+)\s*[;{]/m.exec(text)?.[1] ?? '';
+  const uses = new Map<string, string>();
+  // File-level imports sit before the first type; a trait `use` inside a class body is not one.
+  const header = text.slice(0, text.search(/^\s*(?:(?:abstract|final|readonly)\s+)*(?:class|trait|interface|enum)\s/m) >>> 0 || text.length);
+  for (const m of header.matchAll(/^\s*use\s+(?:function\s+|const\s+)?([\w\\]+)(?:\s+as\s+(\w+))?\s*;/gm)) {
+    const fqn = m[1]!.replace(/^\\/, '');
+    uses.set(m[2] ?? fqn.split('\\').pop()!, fqn);
+  }
+  const scope = { namespace, uses };
+  memo.set(file, scope);
+  return scope;
+}
+
+/** The qualified name (`A\B::C`) a PHP class name written in `file` refers to. */
+function phpTypeQn(name: string, file: string, context: ResolutionContext): string {
+  let fqn: string;
+  if (name.startsWith('\\')) fqn = name.slice(1);
+  else {
+    const { namespace, uses } = phpFileScope(file, context);
+    const [head, ...rest] = name.split('\\');
+    const imported = uses.get(head!);
+    fqn = imported ? [imported, ...rest].join('\\') : namespace ? `${namespace}\\${name}` : name;
+  }
+  const at = fqn.lastIndexOf('\\');
+  return at < 0 ? fqn : `${fqn.slice(0, at)}::${fqn.slice(at + 1)}`;
+}
+
+/** The qualified names a PHP class or trait extends and the traits it uses. */
+function phpSupertypeQns(decl: Node, context: ResolutionContext): string[] {
+  let memo = PHP_SUPERS.get(context);
+  if (!memo) {
+    memo = new Map();
+    PHP_SUPERS.set(context, memo);
+  }
+  const hit = memo.get(decl.id);
+  if (hit) return hit;
+  const names: string[] = [];
+  const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+  const head = lines.slice(decl.startLine - 1, decl.startLine + 4).join(' ');
+  const extended = /\bextends\s+([^{]*?)(?:\bimplements\b|\{)/.exec(head)?.[1] ?? '';
+  for (const m of extended.matchAll(/(\\?[A-Za-z_][\w\\]*)/g)) names.push(m[1]!);
+  // `use StringTranslationTrait, MessengerTrait;` at the top of the body —
+  // one per line or one list across several (Laravel's Command, Model).
+  const bodyLines = lines.slice(decl.startLine, Math.min(decl.endLine, decl.startLine + 80));
+  const firstFunction = bodyLines.findIndex((l) => /\bfunction\b/.test(l));
+  const body = bodyLines.slice(0, firstFunction < 0 ? bodyLines.length : firstFunction).join('\n');
+  for (const used of body.matchAll(/^\s*use\s+([\w\\,\s]+?)\s*[;{]/gm)) {
+    for (const t of used[1]!.split(',')) if (t.trim()) names.push(t.trim());
+  }
+  const qns = names.map((n) => phpTypeQn(n, decl.filePath, context));
+  memo.set(decl.id, qns);
+  return qns;
+}
+
+/** Names the Rust prelude puts in every module; a project item of the same name needs a `use` to shadow one. */
+const RUST_PRELUDE = new Set([
+  'Ok', 'Err', 'Some', 'None', 'Result', 'Option', 'Box', 'Vec', 'String', 'Default', 'Drop', 'Iterator',
+  'IntoIterator', 'From', 'Into', 'Clone', 'Copy', 'Send', 'Sync', 'Sized', 'ToString', 'ToOwned', 'PartialEq',
+  'Eq', 'PartialOrd', 'Ord', 'AsRef', 'AsMut', 'Fn', 'FnMut', 'FnOnce', 'Extend', 'drop',
+]);
+
+interface RustUses {
+  /** Every identifier in the file's project `use` trees — not `std::` / `core::` / `alloc::` ones. */
+  names: Set<string>;
+  /** `X` of each `use …::X::*` (`super` for `use super::*`). */
+  globs: Set<string>;
+  /** Names the file imports from outside the project — `use std::task::{Context, Poll}`, `use futures::Stream`. */
+  external: Set<string>;
+  /** The items the file's project `use`s bind — their leaves, not the paths they walk. */
+  bound: Set<string>;
+}
+
+const RUST_CRATES = new WeakMap<ResolutionContext, Set<string>>();
+const RUST_DEPENDENCIES = new WeakMap<ResolutionContext, Set<string>>();
+
+/**
+ * The crates the project's manifests depend on (`[dependencies]`,
+ * `[dev-dependencies]`, `[build-dependencies]`, per-target ones), by the name
+ * code writes them (`futures_util`), less the project's own.
+ */
+function rustDependencyCrates(context: ResolutionContext): Set<string> {
+  const hit = RUST_DEPENDENCIES.get(context);
+  if (hit) return hit;
+  const deps = new Set<string>();
+  const manifests = ['Cargo.toml', ...[...getCargoWorkspaceCrateMap(context).values()].map((dir) => `${dir}/Cargo.toml`)];
+  for (const manifest of new Set(manifests)) {
+    const text = context.readFile(manifest) ?? '';
+    let inDeps = false;
+    for (const raw of text.split(/\r?\n/)) {
+      const line = raw.replace(/#.*$/, '').trim();
+      const header = /^\[([^\]]+)\]$/.exec(line);
+      if (header) {
+        const table = header[1]!.trim();
+        // `[dependencies.tokio]` names one dependency in its header.
+        const named = /(?:^|\.)(?:dev-|build-)?dependencies\.([A-Za-z0-9_-]+)$/.exec(table);
+        if (named) deps.add(named[1]!.replace(/-/g, '_'));
+        inDeps = /(?:^|\.)(?:dev-|build-)?dependencies$/.test(table);
+        continue;
+      }
+      const key = inDeps ? /^([A-Za-z0-9_-]+)\s*=/.exec(line)?.[1] : undefined;
+      if (key) deps.add(key.replace(/-/g, '_'));
+    }
+  }
+  for (const own of rustProjectCrates(context)) deps.delete(own);
+  RUST_DEPENDENCIES.set(context, deps);
+  return deps;
+}
+
+/** The project's own crate names (`tokio`, `tokio_util`), from its Cargo.toml files. */
+function rustProjectCrates(context: ResolutionContext): Set<string> {
+  const hit = RUST_CRATES.get(context);
+  if (hit) return hit;
+  const crates = new Set<string>();
+  // The manifests are not indexed files: the root's package, and the workspace's members.
+  const root = /\[package\][^[]*?\bname\s*=\s*"([^"]+)"/.exec(context.readFile('Cargo.toml') ?? '')?.[1];
+  if (root) crates.add(root.replace(/-/g, '_'));
+  for (const name of getCargoWorkspaceCrateMap(context).keys()) crates.add(name.replace(/-/g, '_'));
+  RUST_CRATES.set(context, crates);
+  return crates;
+}
+const RUST_USES = new WeakMap<ResolutionContext, Map<string, RustUses>>();
+
+function rustUsesOf(filePath: string, context: ResolutionContext): RustUses {
+  let memo = RUST_USES.get(context);
+  if (!memo) {
+    memo = new Map();
+    RUST_USES.set(context, memo);
+  }
+  const hit = memo.get(filePath);
+  if (hit) return hit;
+  const uses: RustUses = { names: new Set(), globs: new Set(), external: new Set(), bound: new Set() };
+  const leaves = (tree: string): string[] => [
+    ...[...tree.matchAll(/([A-Za-z_]\w*)\s*(?=[,}]|$|\s+as\b)|\bas\s+([A-Za-z_]\w*)/g)]
+      .map((leaf) => leaf[2] ?? leaf[1]!).filter((id) => id !== 'self' && id !== 'as'),
+    // `use std::io::{self, Read}` binds `io` too.
+    ...[...tree.matchAll(/([A-Za-z_]\w*)\s*::\s*\{[^{}]*\bself\b/g)].map((m) => m[1]!),
+  ];
+  // Comments first: a doc comment's prose ("…use the Option…") is not a `use`.
+  const text = stripCommentsForRegex(context.readFile(filePath) ?? '', 'rust');
+  const dependencies = rustDependencyCrates(context);
+  for (const m of text.matchAll(/(?:^|[;{}\s])use\s+([^;]{1,2000});/g)) {
+    const tree = m[1]!;
+    const root = /^\s*(?:::)?([A-Za-z_]\w*)/.exec(tree)?.[1] ?? '';
+    // Outside: the standard library or a crate the manifests depend on — not a
+    // module of the project's (`mod support { … }` inline in a test).
+    const outside = root === 'std' || root === 'core' || root === 'alloc' || (root !== '' && dependencies.has(root));
+    // The items it binds: each leaf (`as` aliases by their alias), never the path it walks.
+    if (outside) {
+      for (const id of leaves(tree)) uses.external.add(id);
+      continue;
+    }
+    for (const id of leaves(tree)) uses.bound.add(id);
+    for (const id of tree.matchAll(/[A-Za-z_]\w*/g)) uses.names.add(id[0]);
+    for (const g of tree.matchAll(/(\w+)\s*::\s*(?:\{[^}]*)?\*/g)) uses.globs.add(g[1]!);
+  }
+  memo.set(filePath, uses);
+  return uses;
+}
+
+/** The module a Rust file is: `src/glob.rs` → `glob`, `src/walk/mod.rs` → `walk`. */
+function rustModuleName(filePath: string): string {
+  const parts = filePath.split('/');
+  const base = parts[parts.length - 1]!.replace(/\.rs$/, '');
+  return base === 'mod' || base === 'lib' || base === 'main' ? parts[parts.length - 2] ?? base : base;
+}
+
+/** Does one of the file's globs bring in this candidate's module (or, for `use super::*`, its parent's)? */
+function rustGlobCovers(uses: RustUses, candidate: Node, ref: UnresolvedRef): boolean {
+  if (uses.globs.has(rustModuleName(candidate.filePath))) return true;
+  if (!uses.globs.has('super')) return false;
+  const dir = (p: string): string => p.slice(0, p.lastIndexOf('/'));
+  // `use super::*` in a child module: the parent's file, or a sibling in the parent's directory.
+  return dir(candidate.filePath) === dir(ref.filePath) || dir(candidate.filePath) === dir(dir(ref.filePath));
+}
+
+/**
+ * Whether a bare Rust name can mean this candidate. An enum's variant is in
+ * scope bare only through a `use` of it or of its enum's `*`, and never
+ * names a TYPE — ripgrep's every `Some(x)` bound to its `EncodingMode::Some`
+ * variant, every `Ok(x)` to `ParseResult::Ok`. A prelude name (`Ok`,
+ * `Result`, `Box`) is the prelude's unless the file defines it or imports a
+ * project item of that name — serde's macro-hygiene tests declare `struct
+ * Ok`, `struct Result`, and serde bound its own `Ok(…)` and `Result<…>` to them.
+ */
+export function isRustNameInScope(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const name = ref.referenceName;
+  // Bare in the SOURCE: the index keeps `crate::error::Result` by its last
+  // segment, and a path is not a prelude lookup.
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  // A variant path — `Mode::A`, `mode::Mode::B`, a `Mode::C(x)` pattern, or
+  // `Self::A` in an impl, where the reference names the impl's type (#2328) —
+  // reads the enum that declares that variant, and nothing else: ripgrep's
+  // `Match::None` is `ignore`'s enum, not the matcher's `struct Match`. An
+  // associated const or function read the same way (`Limits::MAX`, `Mode::ALL`)
+  // is not a variant, so it references no type.
+  const at = line === undefined ? '' : line.slice(ref.column);
+  const typeRead = ref.referenceKind === 'references' && /^\w+$/.test(name);
+  const viaSelf = typeRead && name !== 'Self' && /^Self\s*::/.test(at);
+  const variant = typeRead && (viaSelf || (at.startsWith(name) && !/^\w/.test(at.slice(name.length))))
+    ? /^\w+\s*::\s*([A-Z]\w*)/.exec(at)?.[1] : undefined;
+  if (variant !== undefined && !declaresRustVariant(candidate, variant, context)) return false;
+  // Written through a path on its line (`jsont::SubMatch { … }`, `io::Result<…>`),
+  // wherever the reference's column points. `Self::A` names the impl's type, not
+  // whatever path the line writes elsewhere.
+  const pathed = line === undefined || viaSelf ? null
+    : (line.startsWith(name, ref.column) && /::\s*$/.test(line.slice(0, ref.column)) ? /((?:[A-Za-z_]\w*\s*::\s*)*)([A-Za-z_]\w*)?\s*::\s*$/.exec(line.slice(0, ref.column))
+      : !new RegExp(`(?<![\\w$:])${name}\\b`).test(line) ? new RegExp(`((?:[A-Za-z_]\\w*\\s*::\\s*)*)([A-Za-z_]\\w*)\\s*::\\s*${name}\\b`).exec(line) : null);
+  if (pathed) {
+    // Through a path: `crate::` / `self::` / `super::` look it up relatively;
+    // `io::Result` is the `io` module's — tokio's `runtime/task` alias is not —
+    // and a path from std (`std::io::Error`) is std's.
+    const seg = pathed[2] ?? '';
+    const root = /^([A-Za-z_]\w*)/.exec(pathed[1] ?? '')?.[1] ?? seg;
+    // `Self::Error` in a signature is the enclosing impl's (or trait's) own
+    // associated type, and `V::Value` an associated type of a generic's bound —
+    // never a struct of that name: serde's 334 `Self::Error`s went to
+    // `de::value::Error`.
+    if (ref.referenceKind === 'references' && (pathed[1] ?? '') === '' && line !== undefined) {
+      if (seg === 'Self') return candidate.kind === 'type_alias' && isInEnclosingRustImpl(candidate, ref, context);
+      if (isRustGenericParam(seg, ref, context)) return false;
+    }
+    if ((root === 'std' || root === 'core' || root === 'alloc') && candidate.filePath !== ref.filePath) return false;
+    // A project crate's name re-exports as `crate::` does: `clap::Command` is clap_builder's.
+    if (seg === '' || seg === 'crate' || seg === 'self' || seg === 'super' || seg === 'Self' || candidate.filePath === ref.filePath ||
+        rustProjectCrates(context).has(seg)) return true;
+    // `io::Error` under `use std::io;` is std's, whatever `io/` directory the project has.
+    const pathUses = rustUsesOf(ref.filePath, context);
+    if (pathUses.external.has(seg) && !pathUses.bound.has(seg)) return false;
+    return rustModuleName(candidate.filePath) === seg || candidate.filePath.includes(`/${seg}/`) ||
+      candidate.qualifiedName.split('::').includes(seg);
+  }
+  if (candidate.kind === 'enum_member') {
+    if (ref.referenceKind === 'references') return false;
+    const uses = rustUsesOf(ref.filePath, context);
+    const cut = candidate.qualifiedName.lastIndexOf('::');
+    const owner = cut >= 0 ? candidate.qualifiedName.slice(0, cut).split('::').pop()! : '';
+    return (owner !== '' && uses.globs.has(owner)) || (uses.names.has(name) && uses.names.has(owner));
+  }
+  if (candidate.filePath === ref.filePath) return true;
+  const uses = rustUsesOf(ref.filePath, context);
+  // `use std::task::{Context, Poll}`: the file's `Context` is std's, not tokio's
+  // `runtime::context::Context`. (A method call `.env(…)` is no imported name.)
+  if (uses.external.has(name) && !uses.bound.has(name) && line !== undefined) {
+    // Not on its line at all: a later link of a chain written across lines (`Arg::new(…)\n.env(…)`).
+    const at = new RegExp(`(?<![\\w$])${name}\\b`).exec(line.slice(Math.max(0, ref.column)));
+    if (at && !/\.\s*$/.test(line.slice(0, Math.max(0, ref.column) + at.index))) return false;
+  }
+  if (!RUST_PRELUDE.has(name)) {
+    // Another file's item — a type, a function — is in scope only through a
+    // `use` that binds it or a glob over its module: tokio's `Context<'_>` is
+    // not `runtime::task::trace`'s `Context` unless the file brings that one
+    // in. A method is reached through a value, never a `use`.
+    if (TYPE_MEMBER_KINDS.has(candidate.kind) || ref.referenceKind === 'imports' ||
+        candidate.kind === 'file' || candidate.kind === 'module' || candidate.kind === 'namespace') return true;
+    return uses.bound.has(name) || rustGlobCovers(uses, candidate, ref);
+  }
+  return uses.names.has(name) || rustGlobCovers(uses, candidate, ref);
+}
+
+/** Whether `type` is a Rust enum that declares `variant` (#2328). */
+function declaresRustVariant(type: Node, variant: string, context: ResolutionContext): boolean {
+  if (type.kind !== 'enum') return false;
+  const qualified = `${type.qualifiedName}::${variant}`;
+  const named = context.getNodesInFileNamed?.(type.filePath, variant) ?? context.getNodesInFile(type.filePath);
+  return named.some((n) => n.kind === 'enum_member' && n.qualifiedName === qualified);
+}
+
+/** The line of the `impl` / `trait` header above `ref` in its file (0 for none). */
+function rustEnclosingImplLine(ref: UnresolvedRef, context: ResolutionContext): number {
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/) ?? [];
+  for (let i = ref.line - 1; i >= 0; i--) {
+    if (/^\s*(?:pub(?:\([^)]*\))?\s+)?(?:unsafe\s+)?(?:impl|trait)\b/.test(lines[i] ?? '')) return i + 1;
+  }
+  return 0;
+}
+
+/** Whether `candidate` is declared in the same `impl` / `trait` block as `ref`, above it. */
+function isInEnclosingRustImpl(candidate: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const header = rustEnclosingImplLine(ref, context);
+  return header > 0 && candidate.filePath === ref.filePath && candidate.startLine >= header && candidate.startLine <= ref.line;
+}
+
+/** Whether `name` is a generic type parameter of the function or impl around `ref` (`fn f<V: Visitor>`, `impl<'de, E>`). */
+function isRustGenericParam(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (!/^[A-Z]\w*$/.test(name)) return false;
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/) ?? [];
+  const from = Math.max(0, rustEnclosingImplLine(ref, context) - 1);
+  const text = lines.slice(from, ref.line).join('\n');
+  return new RegExp(`<[^<>]*(?:<[^<>]*>[^<>]*)*\\b${name}\\b\\s*(?:[:,>=])`).test(text);
+}
+
+/** What only exists inside a type, reachable through a receiver alone. */
+const TYPE_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'property', 'field', 'enum_member']);
+
+/** Per-context memo: `file\0name` → "the file binds this name locally". */
+/** Whether `n` lies outside the function that binds the reference's name itself (see jsFunctionLocalScope). */
+function isOutsideJsLocal(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  // `const indexName = this.dataSource.namingStrategy.indexName(…)`: a member, whatever the local's name.
+  if (ref.referenceKind === 'calls' && bareCallReceiver(ref, context) !== null) return false;
+  const scope = jsFunctionLocalScope(ref.referenceName, ref, context);
+  return scope !== null && !(n.filePath === ref.filePath && n.startLine >= scope.start && n.startLine <= scope.end);
+}
+
+const JS_FN_LOCAL_MEMO = new WeakMap<ResolutionContext, Map<string, { start: number; end: number } | null>>();
+
+/**
+ * The lines of the JS/TS function a reference sits in when that function binds
+ * the name itself — a parameter, or a `var`/`let`/`const` above the reference.
+ * Such a name is the local, never a same-named function declared elsewhere:
+ * every lodash helper lives inside `runInContext`, so `baseHas(object, key)`'s
+ * `object` and `mixin`'s `object(this.__wrapped__)` reached a `function
+ * object() {}` an IIFE declares there. Null when the function does not bind it.
+ */
+function jsFunctionLocalScope(name: string, ref: UnresolvedRef, context: ResolutionContext): { start: number; end: number } | null {
+  if (!JS_FAMILY.has(ref.language) || !/^[A-Za-z_$][\w$]*$/.test(name)) return null;
+  let memo = JS_FN_LOCAL_MEMO.get(context);
+  if (!memo) JS_FN_LOCAL_MEMO.set(context, (memo = new Map()));
+  const key = `${ref.fromNodeId}\0${name}\0${ref.line}`;
+  const hit = memo.get(key);
+  if (hit !== undefined) return hit;
+  let scope: { start: number; end: number } | null = null;
+  const fn = context.getNodeById?.(ref.fromNodeId);
+  if (fn && (fn.kind === 'function' || fn.kind === 'method') && fn.startLine <= ref.line && fn.endLine >= ref.line &&
+      jsCodeBindsName(name, fn, ref.filePath, ref.line, context)) {
+    scope = { start: fn.startLine, end: fn.endLine };
+  }
+  memo.set(key, scope);
+  return scope;
+}
+
+/**
+ * Per context, by `file\0first line\0reference line\0name`: whether the code
+ * from a function's first line through a reference's binds the name. Every
+ * function that starts on the same line has that code — all of a minified
+ * script's do — so they share the answer (#2334).
+ */
+const JS_CODE_BINDS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/**
+ * Whether the function's code in `filePath`, from its first line through
+ * `line` (a reference's, or a JSX tag's), declares `name`, or names it in a
+ * parameter list.
+ */
+export function jsCodeBindsName(name: string, fn: Node, filePath: string, line: number, context: ResolutionContext): boolean {
+  let memo = JS_CODE_BINDS.get(context);
+  if (!memo) JS_CODE_BINDS.set(context, (memo = new Map()));
+  const key = `${filePath}\0${fn.startLine}\0${line}\0${name}`;
+  let binds = memo.get(key);
+  if (binds === undefined) {
+    const text = jsFunctionCodeThrough(fn, filePath, line, context);
+    const { param } = localBindingPatterns(name, 'g');
+    const n = name.replace(/\$/g, '\\$');
+    // A plain declaration. Destructuring re-binds what a call returns under
+    // the same name — `const { t } = useI18n()`, `const { getLabel } =
+    // useProps(props)` — which is the same-named function more often than not.
+    const declared = new RegExp(`\\b(?:const|let|var)\\s+${n}\\b(?!\\s*[,\\]}])`).test(text);
+    // A parameter list — never a control-flow head (`if (openMarkerClose) {`).
+    // A return type stays on its line, never a ternary's `: data.slice()` below `filter(canRowExpand)`.
+    // The leading `(?=\()` (every match opens a list) keeps the lookbehind to
+    // where one opens. Node 22's V8 stops optimizing the regexes a process
+    // compiles once it has generated about a megabyte of regex code, which a
+    // resolver pool worker soon has, and then tried the lookbehind at every
+    // position, each time reading back through the run of blanks before it:
+    // go-ethereum's graphiql.min.js, a 980 KB line whose last 962 KB the
+    // stripper blanks (it reads the `//` closing `/Trident\//` as a comment),
+    // never resolved.
+    const parameter = new RegExp(`(?=\\()(?<!\\b(?:if|while|for|switch|with)\\s*)${param.source.replace('(?::[^=;{]*)?', '(?::[^=;{}()\\n]*)?')}`);
+    binds = declared || parameter.test(text);
+    memo.set(key, binds);
+  }
+  return binds;
+}
+
+/**
+ * Per context: the comment-stripped lines of the functions jsCodeBindsName
+ * read last, and where each line ends in that text, most recent last.
  */
-function isBarePhpCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
-  if (ref.language !== 'php' || ref.referenceKind !== 'calls') return false;
-  if (!/^\w+$/.test(ref.referenceName)) return false;
-  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
-    ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
-  if (line === undefined) return false;
-  const at = line[ref.column] === '\\' ? ref.column + 1 : ref.column;
-  if (!line.startsWith(ref.referenceName, at)) return false;
-  CALL_OPENER.lastIndex = at + ref.referenceName.length;
-  if (!CALL_OPENER.test(line)) return false;
-  let end = at;
-  while (end > 0 && WHITESPACE.test(line[end - 1]!)) end--;
-  // `$obj->name(` / `Foo::name(` / `$obj?->name(`, should a column ever land on the name.
-  return !(end > 0 && (line[end - 1] === '>' || line[end - 1] === ':'));
-}
+const JS_FN_CODE = new WeakMap<ResolutionContext, Map<string, { code: string; lineEnds: number[] }>>();
+const JS_FN_CODE_KEEP = 64;
 
-function isReceiverLessCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
-  if (ref.referenceKind !== 'calls') return false;
-  if (ref.referenceName.includes('.')) return false;
-  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
-    ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
-  if (line === undefined) return false;
-  // `^<name>\s*[(<]` at the call's column, without compiling a pattern per call.
-  if (!line.startsWith(ref.referenceName, ref.column)) return false;
-  CALL_OPENER.lastIndex = ref.column + ref.referenceName.length;
-  if (!CALL_OPENER.test(line)) return false;
-  // Nothing but whitespace, an operator or an opener may precede a bare call:
-  // read the text before the column backwards, past trailing whitespace,
-  // instead of end-anchoring a pattern that scans the prefix from its start.
-  let end = Math.min(ref.column, line.length);
-  while (end > 0 && WHITESPACE.test(line[end - 1]!)) end--;
-  if (end === 0 || !RECEIVER_TAIL_CHAR.test(line[end - 1]!)) return true;
-  let start = end;
-  while (start > 0 && WORD_CHAR.test(line[start - 1]!)) start--;
-  return BARE_CALL_KEYWORDS.has(line.slice(start, end));
+/**
+ * The function's lines from its first through `line`, comments blanked.
+ * Stripping looks at most one character ahead — past a line's end, a
+ * newline, which completes no comment marker — so this is the whole
+ * function's stripped text cut at that line's end. Stripping the lines again
+ * for every reference took time in the square of a large function's length;
+ * in a minified script, every function's text runs to the end of its one
+ * line (#2334).
+ */
+function jsFunctionCodeThrough(fn: Node, filePath: string, line: number, context: ResolutionContext): string {
+  let fns = JS_FN_CODE.get(context);
+  if (!fns) JS_FN_CODE.set(context, (fns = new Map()));
+  const key = `${filePath}\0${fn.startLine}\0${fn.endLine}`;
+  let own = fns.get(key);
+  if (own) {
+    fns.delete(key);
+  } else {
+    const lines = (context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? [])
+      .slice(fn.startLine - 1, fn.endLine);
+    let end = -1;
+    own = { code: stripCommentsForRegex(lines.join('\n'), 'javascript'), lineEnds: lines.map((text) => (end += text.length + 1)) };
+    if (fns.size >= JS_FN_CODE_KEEP) fns.delete(fns.keys().next().value!);
+  }
+  fns.set(key, own);
+  // Through `line`, or the file's last when it ends sooner.
+  const last = Math.min(line, fn.startLine - 1 + own.lineEnds.length) - fn.startLine;
+  return last < 0 ? '' : own.code.slice(0, own.lineEnds[last]);
 }
 
-/** `\s*[(<]` from a given index (sticky). */
-const CALL_OPENER = /\s*[(<]/y;
-const WHITESPACE = /\s/;
-const WORD_CHAR = /\w/;
-/** A character that ends a receiver: `.`, a word character, `$`, `]` or `)`. */
-const RECEIVER_TAIL_CHAR = /[.\w$\])]/;
-/** Keywords after which a name starts an expression, so the call has no receiver. */
-const BARE_CALL_KEYWORDS: ReadonlySet<string> = new Set([
-  'return', 'await', 'yield', 'typeof', 'void', 'new', 'else', 'case', 'throw', 'in', 'of', 'instanceof', 'go', 'defer',
-]);
-
-/** Per-context memo: `file\0name` → "the file binds this name locally". */
 const LOCAL_BINDING_MEMO = new WeakMap<ResolutionContext, Map<string, boolean>>();
 
 /**
@@ -1175,11 +7581,24 @@ export function matchByExactName(
   // findBestMatch — O(K²) per package, the dominant cost of "Resolving refs" on
   // large import-heavy (front-end + back-end) repos (#915).
   const bareJs = isBareJsCall(ref, context);
-  const bareGo = isBareGoCall(ref, context);
+  const bareNoMembers = isBareGoCall(ref, context) || isBareRCall(ref, context);
+  const solidityBare = isReceiverLessSolidityCall(ref, context);
   const barePhp = isBarePhpCall(ref, context);
+  const luaBareCall = (ref.language === 'lua' || ref.language === 'luau') && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  // A type, a value or an import the file binds from a package outside the
+  // repository names nothing in it, whatever kind of reference it is.
+  if (!bareJs && JS_FAMILY.has(ref.language) && ref.referenceKind !== 'calls' &&
+      /^[A-Za-z_$][\w$]*$/.test(ref.referenceName) && isOutOfRepoBinding(ref.referenceName, ref, context)) {
+    return null;
+  }
   if (bareJs) {
     const storeAction = matchJsStoreBindingCall(ref, context);
     if (storeAction) return storeAction;
+    const returned = matchDestructuredCallResult(ref, context);
+    if (returned) return returned;
+    // `import { useQuery } from '@tanstack/react-query'`: the call means the
+    // package's, and no same-named project symbol.
+    if (isOutOfRepoBinding(ref.referenceName, ref, context)) return null;
   }
   // Every rule below judges one candidate on its own, so they run as ONE pass,
   // the kind/language checks before the ones that read source: a common name
@@ -1196,16 +7615,89 @@ export function matchByExactName(
   // upstream's language gate on the chosen result.
   const cMacroCall = ref.referenceKind === 'calls' && (ref.language === 'c' || ref.language === 'cpp') &&
     sameName.some((n) => n.kind === 'constant' && CPP_DEFINE_SIGNATURE.test(n.signature ?? ''));
-  const candidates = sameName.filter((n) =>
+  const typeRef = isDotNetTypeRef(ref, context);
+  const rustBare = ref.language === 'rust' && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  const pythonShape = pythonCallShape(ref, context);
+  const javaBare = ref.language === 'java' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const dartBare = ref.language === 'dart' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName) && isReceiverLessDartCall(ref, context);
+  // A Dart type name — a declared type, a supertype, the `Color` of `Color.red` — is in scope as a call is, or through its import prefix.
+  const dartTypeRef = ref.language === 'dart' && (ref.referenceKind === 'references' || isInheritanceRef(ref)) && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const dartPrefix = dartTypeRef ? dartImportPrefixOf(ref, context) : null;
+  const kotlinCall = ref.language === 'kotlin' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const kotlinBare = kotlinCall && isReceiverLessKotlinCall(ref, context);
+  const rubyBare = ref.language === 'ruby' && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*[?!]?$/.test(ref.referenceName);
+  const cfmlBare = (ref.language === 'cfml' || ref.language === 'cfscript') && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  const vbReceiver = ref.language === 'vbnet' && (ref.referenceKind === 'calls' || ref.referenceKind === 'instantiates') && /^\w+$/.test(ref.referenceName)
+    ? vbReceiverOf(ref, context) : null;
+  const vbScoped = isVbScopedCall(ref, vbReceiver, context);
+  const vbUnqualified = isVbUnqualifiedName(ref, vbReceiver, context);
+  const objcShape = ref.language === 'objc' && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*:*(?:\w+:)*$/.test(ref.referenceName)
+    ? objcCallShape(ref, context) : null;
+  const csharpBare = ref.language === 'csharp' && (ref.referenceKind === 'calls' || ref.referenceKind === 'references') && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  const scalaBare = ref.language === 'scala' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const rustGoShape = (ref.language === 'rust' || ref.language === 'go') && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName)
+    ? rustGoCallShape(ref, context) : null;
+  const kotlinStdChain = ref.language === 'kotlin' && ref.referenceKind === 'calls' && KOTLIN_STD_METHODS.has(ref.referenceName)
+    ? kotlinChainReceiver(ref, context) : null;
+  const swiftShape = ref.language === 'swift' && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName)
+    ? swiftCallShape(ref, context) : null;
+  const phpSelf = phpSelfReceiver(ref, context);
+  const filtered = sameName.filter((n) =>
+    !(kotlinStdChain !== null && !isKotlinStdChainTarget(n, kotlinStdChain)) &&
+    !(swiftShape && !isSwiftCallTarget(n, swiftShape, ref, context)) &&
+    !(rustGoShape && !isRustGoCallTarget(n, rustGoShape)) &&
+    !(scalaBare && !isScalaMemberInScope(n, ref, context)) &&
+    !(csharpBare && !isCsharpMemberInScope(n, ref, context)) &&
+    !(objcShape === 'c-call' && OBJC_MEMBER_KINDS.has(n.kind)) &&
+    !(objcShape === 'self-send' && !isObjcSelfSendTarget(n, ref, context)) &&
+    !(objcShape === 'super-send' && !isObjcSelfSendTarget(n, ref, context, true)) &&
+    !(vbReceiver !== null && !isVbMemberReachable(n, vbReceiver)) &&
+    !(vbReceiver && !/^(?:me|mybase|myclass)$/i.test(vbReceiver) && !isVbTypeQualifiedBy(n, vbReceiver, ref.filePath, context)) &&
+    !(vbScoped && !isVbMemberInScope(n, ref, context)) &&
+    !(vbUnqualified && !isVbNestedTypeInScope(n, ref, context)) &&
+    !(rubyBare && n.kind === 'method' && !isRubyMethodInScope(n, ref, context)) &&
+    !(cfmlBare && n.kind === 'method' && !isCfmlMethodInScope(n, ref, context)) &&
+    !(javaBare && n.kind === 'method' && !isJavaMethodInScope(n, ref, context)) &&
+    !(kotlinCall && !isKotlinTopLevelVisible(n, ref, context)) &&
+    !(kotlinBare && !isKotlinMemberReachable(n, ref, context)) &&
+    !isKotlinNumberBitwise(n, ref) &&
+    !(solidityBare && !isSolidityMemberInScope(n, ref, context)) &&
+    !(dartBare && isDartMember(n) && !isDartMethodInScope(n, ref, context)) &&
+    // A Dart constructor is reached through its class (`Foo.named(…)`,
+    // `@Foo.named(…)`), never by its name alone: not a bare call, not the
+    // last link of a chain, not an annotation (riverpod's 210 `@internal`
+    // annotations went to its providers' `internal` constructors).
+    !(ref.language === 'dart' && isDartConstructor(n, context)) &&
+    !(dartBare && isDartTypeValue(n) && !isDartMethodInScope(n, ref, context)) &&
+    !((dartBare || dartTypeRef) && !isDartTopLevelVisible(n, ref, context, dartPrefix)) &&
+    !(phpSelf && (n.kind !== 'method' || !isPhpMethodInScope(n, ref, phpSelf, context))) &&
+    !(pythonShape && !fitsPythonCallShape(n, pythonShape, ref, context)) &&
+    !(rustBare && !isRustNameInScope(n, ref, context)) &&
     !(cMacroCall && n.kind !== 'function' && n.kind !== 'method') &&
+    !(typeRef && !canNameInTypePosition(n)) &&
+    // A Scala type position (`Arbitrary[B]`) never names a method: an
+    // `implicit def A: Order[A]` shares its name with half of cats' type
+    // parameters. Scala's value references only read a file's own vals.
+    // Nor does a kind-projector placeholder (`F[*]`, `G[?]`): cats' 567 `*`
+    // type arguments went to an algebra `Sign`'s `*` method.
+    !(ref.language === 'scala' && ref.referenceKind === 'references' && /^(?:[A-Z]|[^\w\s]+$)/.test(ref.referenceName) &&
+      (n.kind === 'method' || n.kind === 'function')) &&
     // Type/value references retain same-family eligibility: a native namesake
     // must not hide the actual web type. Calls still gate only the winner.
     (!valueRef || sameLanguageFamily(n.language, ref.language)) &&
     n.kind !== 'import' &&
-    // A receiver-less JS/TS or Go call cannot reach a method (#1714, #1857).
-    !((bareJs || bareGo) && n.kind === 'method') &&
+    // A receiver-less JS/TS or Go call cannot reach a member of a type — a
+    // method (#1714, #1857), nor a property, field or case: mocha's global
+    // `it(…)` bound to an interface's `it` property, `describe(…)` to a
+    // command class's `describe` string.
+    !((bareJs || bareNoMembers) && TYPE_MEMBER_KINDS.has(n.kind)) &&
     // A bare PHP call is a function call: nothing else is callable without a receiver.
     !(barePhp && n.kind !== 'function') &&
+    // Nor is a table's method (`function M.x`, `function M:x`) in Lua, without its table.
+    !(luaBareCall && n.kind === 'method') &&
+    // A Vue component's own method is `this.m()` inside that component — not
+    // `this.$refs['input'].click()` on an element another component renders.
+    !(ref.referenceKind === 'calls' && JS_FAMILY.has(ref.language) && isVueComponentMethod(n) && !isThisCallInOwnFile(n, ref, context)) &&
     // An `extends`/`implements` ref names a supertype, so anything that can't
     // BE one is not a candidate at all. This is eligibility, not
     // ranking: kind is only a scoring bonus below (and none is awarded for
@@ -1220,6 +7712,25 @@ export function matchByExactName(
     (!importRef || isImportableKind(n.kind)) &&
     // Nested locals are only reachable from inside their container (#1230).
     isLexicallyReachable(n, ref, context) &&
+    // A C# type name is a type its namespaces can see — ahead of the ranking,
+    // so a visible namesake wins where the veto after it would drop the
+    // ref: eShop's `WebhookType.OrderPaid` under `using Webhooks.API.Model;`.
+    // A bare PHP class name, only its namespace's or the imported one — ahead of
+    // the ranking, so koel's `extends Request` under `use App\Http\Requests\API\Request;`
+    // is that class, not the first `Request` indexed.
+    isPhpClassVisible(n, ref, context) &&
+    // Likewise a bare Java type name: retrofit's tests' `new Builder()` is not
+    // a wire converter test's nested `CrashingPhone.Builder`.
+    isJavaTypeVisible(n, ref, context) &&
+    dartExtensionDecl(n, context)?.named !== false &&
+    // A Scala package object's member, only where it is in scope — ahead of
+    // the ranking, so cats.laws' `Eq` can be the `cats` package object's.
+    !(ref.language === 'scala' && n.language === 'scala' && n.filePath !== ref.filePath &&
+      !isScalaPackageObjectMemberVisible(n, ref, context)) &&
+    // A nested type, only from inside its owner: AutoMapper's same-file `new
+    // Source()` in one test class is not the previous test class's `Source`.
+    !(ref.language === 'csharp' && n.language === 'csharp' && CSHARP_TYPE_KINDS.has(n.kind) && /^[A-Za-z_]\w*$/.test(ref.referenceName) &&
+      (!isCsharpNestedTypeInScope(n, ref, context) || (n.filePath !== ref.filePath && !isCsharpTypeVisible(n, ref, context)))) &&
     // Preserve import ranking; calls reject the winner without promoting another.
     (!importRef || n.filePath === ref.filePath ||
       !ESM_FAMILY.has(n.language) || !isSealedModule(n.filePath, context)) &&
@@ -1227,6 +7738,10 @@ export function matchByExactName(
     // file's symbol of that name, so a bare call has no cross-file candidate.
     !(bareJs && n.filePath !== ref.filePath && isLocallyBoundJsName(ref.referenceName, ref.filePath, context))
   );
+  const candidates = dartBare ? nearestDartMembers(preferOwnDartLibrary(filtered, ref, context), ref, context)
+    : dartTypeRef && dartPrefix === null ? preferOwnDartLibrary(filtered, ref, context)
+    : swiftShape && swiftShape.shape !== 'chained' ? nearestSwiftMembers(filtered, ref, context)
+    : kotlinBare ? lexicalKotlinMembers(filtered, ref, context) : filtered;
 
   if (candidates.length === 0) {
     return null;
@@ -1296,7 +7811,36 @@ export function matchByQualifiedName(
         )
       : nodes;
 
-  const candidates = keepForRef(context.getNodesByQualifiedName(ref.referenceName));
+  // A C or C++ name written from the global scope (`::hpb::CreateMessage`,
+  // `::operator delete`) is the declaration of exactly that name. The suffix
+  // match below would take one nested in another namespace or class: for
+  // fmt's mock `test::open`, the `::open(…)` it wraps. Nor is it a declaration
+  // inside a namespace a macro opens, which only looks global in the index
+  // (fmt's `struct pipe`); step 5 of matchReference reads those.
+  if ((ref.language === 'cpp' || ref.language === 'c') && ref.referenceName.startsWith('::')) {
+    const global = keepForRef(context.getNodesByQualifiedName(ref.referenceName.slice(2))).filter((n) =>
+      (n.language === 'cpp' || n.language === 'c') &&
+      !cppMacroNamespaceFrames(n.filePath, context).some((f) => f.start <= n.startLine && f.end >= n.startLine));
+    const chosen = preferCallSiteFile(global, ref.filePath)[0];
+    if (!chosen) return null;
+    return {
+      original: ref,
+      targetNodeId: chosen.id,
+      confidence: global.length === 1 || chosen.filePath === ref.filePath ? 0.95 : 0.85,
+      resolvedBy: 'qualified-name',
+    };
+  }
+
+  let candidates = keepForRef(context.getNodesByQualifiedName(ref.referenceName));
+  // A C# `using X.Y;` names a namespace: one the project declares, else it is
+  // the file's own (external) using — never another file's using of that name.
+  // That own using ends the lookup here, and resolveOne drops it (an import
+  // never names its own statement), so the ref parks as failed.
+  if (ref.language === 'csharp' && ref.referenceKind === 'imports') {
+    const namespaces = candidates.filter((n) => n.kind === 'namespace');
+    candidates = namespaces.length > 0 ? preferCallSiteFile(namespaces, ref.filePath).slice(0, 1)
+      : candidates.filter((n) => n.kind !== 'import' || n.filePath === ref.filePath);
+  }
 
   if (candidates.length === 1) {
     return {
@@ -1400,9 +7944,10 @@ export function preferCallSiteFile(nodes: Node[], callSiteFile: string): Node[]
 
 /**
  * Languages whose object literals declare callable members — `export const
- * api = { call() {…}, get: () => {…} }` used as a namespace (#1573).
+ * api = { call() {…}, get: () => {…} }` used as a namespace (#1573) — including
+ * the script blocks of single-file components (#2300).
  */
-const OBJECT_LITERAL_LANGUAGES = new Set<string>(['typescript', 'tsx', 'javascript', 'jsx', 'arkts']);
+const OBJECT_LITERAL_LANGUAGES = new Set<string>(['typescript', 'tsx', 'javascript', 'jsx', 'arkts', 'vue', 'svelte', 'astro']);
 
 /** True when `inner`'s source range lies within `outer`'s (lines, then columns on a shared line). */
 function rangeWithin(inner: Node, outer: Node): boolean {
@@ -1628,6 +8173,533 @@ export function resolveObjectLiteralBinding(
   return null;
 }
 
+// ── Object literals that own their members (#2300) ──────────────────────────────
+//
+// A named object literal — `const App = {…}`, the same inside an IIFE or a
+// function, `App = {…}`, or one hung on a path (`window.App = {…}`, `App.utils
+// = {…}`) — makes each function member a node qualified under its owner
+// (`App::init`, `window.App::init`). An owner is a constant or variable whose
+// initializer is an object literal. A member is reached THROUGH its object:
+// `App.init()`, `window.App.init()`, `App.utils.fmt()`, a sibling's
+// `this.init()`, a `const { init } = App` binding — never by its name alone.
+
+/**
+ * A path on the global object — `window.`, `globalThis.`. (`self` is the
+ * global only in a worker; in page code it is far more often `var self = this`.)
+ */
+const HOST_GLOBAL_PREFIX = /^(?:window|globalThis)\./;
+
+/** The last `::` segment of a qualified name. */
+function lastQualifiedSegment(qualifiedName: string): string {
+  const cut = qualifiedName.lastIndexOf('::');
+  return cut < 0 ? qualifiedName : qualifiedName.slice(cut + 2);
+}
+
+/**
+ * The path a constant or variable is reached by: its name, or — for an object
+ * hung on a path by assignment — that path, any global-object root dropped
+ * (`window.App = {…}` defines the global `App`; `App.utils = {…}` is `App.utils`).
+ */
+function holderPath(n: Node): string {
+  const last = lastQualifiedSegment(n.qualifiedName);
+  return last.includes('.') ? last.replace(HOST_GLOBAL_PREFIX, '') : n.name;
+}
+
+/** Whether a constant or variable was hung on a dotted path by assignment rather than declared. */
+function isPathHolder(n: Node): boolean {
+  return lastQualifiedSegment(n.qualifiedName).includes('.');
+}
+
+/** Whether `n` holds an object literal: an owner its members can belong to. */
+function isObjectLiteralOwner(n: Node): boolean {
+  return (n.kind === 'constant' || n.kind === 'variable') && JS_FAMILY.has(n.language) && /^=\s*\{/.test(n.signature ?? '');
+}
+
+const OBJECT_OWNER_OF = new WeakMap<ResolutionContext, Map<string, Node | null>>();
+
+/**
+ * The object literal a function node is a member of — its qualified parent,
+ * an owner in its file whose extent holds it — or null for every other
+ * function: a declaration, a helper nested in a function, a function inside
+ * an initializer that is not an object literal (a module IIFE's own helpers).
+ */
+function objectLiteralOwnerOf(n: Node, context: ResolutionContext): Node | null {
+  if (n.kind !== 'function' || !JS_FAMILY.has(n.language)) return null;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut <= 0) return null;
+  let memo = OBJECT_OWNER_OF.get(context);
+  if (!memo) OBJECT_OWNER_OF.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  const parent = n.qualifiedName.slice(0, cut);
+  const owner = context.getNodesByQualifiedName(parent).find((o) =>
+    o.filePath === n.filePath && o.id !== n.id && isObjectLiteralOwner(o) && rangeWithin(n, o)) ?? null;
+  memo.set(n.id, owner);
+  return owner;
+}
+
+/** The node a qualified name's parent names, in `n`'s file and holding it. */
+function qualifiedParentOf(n: Node, context: ResolutionContext): Node | null {
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut <= 0) return null;
+  return context.getNodesByQualifiedName(n.qualifiedName.slice(0, cut))
+    .find((p) => p.filePath === n.filePath && p.id !== n.id && rangeWithin(n, p)) ?? null;
+}
+
+/** An arrow function's text: `(a) =>`, `async (a) =>`, `a =>`, `<T>(a: T) =>` — not `name(…) {`, `function …`. */
+const ARROW_HEAD = /^(?:async\s*)?(?:[(<]|[A-Za-z_$][\w$]*\s*=>)/;
+
+/** Whether an object literal's member is an arrow function — one that has no `this` of its own. */
+function isArrowMember(n: Node, context: ResolutionContext): boolean {
+  const line = (context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split('\n'))?.[n.startLine - 1] ?? '';
+  return ARROW_HEAD.test(line.slice(n.startColumn));
+}
+
+const THIS_CALLERS = new WeakMap<ResolutionContext, Map<string, Node>>();
+
+/**
+ * The caller whose scope `this` belongs to, for code written in `caller`
+ * (#2300). An object literal's own method — `load() {…}`, `load: function () {…}`
+ * — has the object: it is returned as is, so its qualified parent is the
+ * owner. An arrow member has no `this` of its own, and a value written in the
+ * literal runs where the literal is: both take the `this` of the code around
+ * the literal, a class method's in `class App { api() { return { load: () =>
+ * this.x() } } }`. Any other caller is its own scope.
+ */
+export function thisScopeCaller(caller: Node, context: ResolutionContext): Node {
+  if (!JS_FAMILY.has(caller.language)) return caller;
+  let memo = THIS_CALLERS.get(context);
+  if (!memo) THIS_CALLERS.set(context, (memo = new Map()));
+  const hit = memo.get(caller.id);
+  if (hit) return hit;
+  let cur = caller;
+  for (let depth = 0; depth < 8; depth++) {
+    const owner = isObjectLiteralOwner(cur) ? cur
+      : objectLiteralOwnerOf(cur, context) !== null && isArrowMember(cur, context) ? objectLiteralOwnerOf(cur, context) : null;
+    if (!owner) break;
+    const up = qualifiedParentOf(owner, context);
+    if (!up) break;
+    cur = up;
+  }
+  memo.set(caller.id, cur);
+  return cur;
+}
+
+/** The object literal `this` is inside `caller`, when it is one: the owner of an object's own method. */
+function thisObjectOf(caller: Node, context: ResolutionContext): Node | null {
+  const scope = thisScopeCaller(caller, context);
+  const owner = objectLiteralOwnerOf(scope, context);
+  return owner && !isArrowMember(scope, context) ? owner : null;
+}
+
+/** Whether (line, column) falls inside `n`'s source range. */
+function positionWithin(line: number, column: number, n: Node): boolean {
+  const end = n.endLine ?? n.startLine;
+  if (line < n.startLine || line > end) return false;
+  if (line === n.startLine && column < n.startColumn) return false;
+  return !(line === end && column >= n.endColumn);
+}
+
+/**
+ * What the object-literal lookups read from a JS/TS file (#2300), each part
+ * built on first use: its source with comments and string contents blanked
+ * (offsets kept), its `{…}` blocks, the scopes it binds a name in and the
+ * names it destructures off a path. References arrive file by file, so only
+ * the last few files' are kept: no file is read twice in a row, and a large
+ * project's files are never all held at once (#2334).
+ */
+interface JsFileScan {
+  source: string | null;
+  code?: string | null;
+  blocks?: JsBlockIndex | null;
+  bindings?: Map<string, Array<[number, number]>>;
+  destructured?: Map<string, Set<string>>;
+}
+
+const JS_FILE_SCANS = new WeakMap<ResolutionContext, Map<string, JsFileScan>>();
+const JS_FILE_SCANS_KEEP = 32;
+
+function jsFileScan(filePath: string, context: ResolutionContext): JsFileScan {
+  let files = JS_FILE_SCANS.get(context);
+  if (!files) JS_FILE_SCANS.set(context, (files = new Map()));
+  let scan = files.get(filePath);
+  if (scan) {
+    files.delete(filePath); // re-added below: the most recently read goes last
+  } else {
+    const source = context.readFile(filePath);
+    scan = { source: typeof source === 'string' ? source : null };
+    if (files.size >= JS_FILE_SCANS_KEEP) files.delete(files.keys().next().value!);
+  }
+  files.set(filePath, scan);
+  return scan;
+}
+
+function scannedCode(scan: JsFileScan): string | null {
+  if (scan.code === undefined) {
+    scan.code = scan.source === null ? null : blankStringContents(stripCommentsForRegex(scan.source, 'typescript'));
+  }
+  return scan.code;
+}
+
+/** A JS/TS file's source with comments and string contents blanked, offsets kept. */
+function maskedJsSource(filePath: string, context: ResolutionContext): string | null {
+  return scannedCode(jsFileScan(filePath, context));
+}
+
+/**
+ * Whether a reference by NAME alone can mean an object literal's member. Only
+ * three ways write one: the owner's own `this.load()` (a sibling member), a
+ * named function expression calling itself (`load: function load() { load() }`),
+ * and a binding destructured off the owner (`const { load } = App`). A bare
+ * `load()`, a callback `setTimeout(load)`, `window.Other.load()` mean a
+ * function of that name — or nothing.
+ */
+function isObjectMemberReachableByName(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const owner = objectLiteralOwnerOf(n, context);
+  if (!owner) return true;
+  if (ref.filePath === n.filePath) {
+    if (ref.referenceKind === 'calls' && positionWithin(ref.line, ref.column, owner) &&
+        bareCallReceiver(ref, context)?.receiver === 'self') {
+      // `this` must be that object: written in one of its own methods, not in an arrow member.
+      const caller = context.getNodeById?.(ref.fromNodeId);
+      if (caller && thisObjectOf(caller, context)?.id === owner.id) return true;
+    }
+    if (positionWithin(ref.line, ref.column, n)) {
+      const line = (context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split('\n'))?.[n.startLine - 1] ?? '';
+      const self = new RegExp(`^(?:async\\s+)?function\\s*\\*?\\s*${n.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w$])`);
+      if (self.test(line.slice(n.startColumn))) return true;
+    }
+  }
+  return destructuresMember(ref.filePath, holderPath(owner), n.name, context);
+}
+
+/** `{ … } = App` / `= window.App.utils`: a pattern destructured off a plain path (the whole right-hand side). */
+const DESTRUCTURED_OFF_PATH = /\{([^{}]*)\}\s*=\s*(?:(?:window|globalThis)\s*\.\s*)?([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)(?![\w$])(?!\s*[.(\[])/g;
+/**
+ * A `}` then `=` with only space and comments between — what any such pattern
+ * holds, read off the raw text. Each comment form matches one way only (a
+ * line comment through its newline, a block comment to its first `*\/`), so
+ * a `////////` banner can't make the match backtrack without end.
+ */
+const CLOSE_THEN_ASSIGN = /\}(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/|\/\/[^\n]*\n)*=(?!=)/;
+
+/**
+ * Whether a file binds `member` by destructuring it off the object at `path`:
+ * `{ load }` or `{ a, load = fallback }` off `App` — not `{ x: load }`, which
+ * binds `load` to `App.x`. The file's patterns are read once, on first use.
+ */
+function destructuresMember(filePath: string, path: string, member: string, context: ResolutionContext): boolean {
+  const scan = jsFileScan(filePath, context);
+  if (!scan.destructured) {
+    const paths = new Map<string, Set<string>>();
+    const code = scan.source !== null && CLOSE_THEN_ASSIGN.test(scan.source) ? scannedCode(scan) : null;
+    for (const m of code?.matchAll(DESTRUCTURED_OFF_PATH) ?? []) {
+      const own = [...destructuredKeys(m[1]!)].filter(([name, key]) => name === key).map(([name]) => name);
+      if (own.length === 0) continue;
+      const at = m[2]!.replace(/\s+/g, '');
+      const names = paths.get(at);
+      if (names) for (const name of own) names.add(name);
+      else paths.set(at, new Set(own));
+    }
+    scan.destructured = paths;
+  }
+  return scan.destructured.get(path)?.has(member) ?? false;
+}
+
+/** A file's `{…}` blocks: for any offset, the innermost one open there (see jsBlockAt). */
+interface JsBlockIndex {
+  lineStarts: number[];
+  /** Offsets of every `{` and `}`, in order. */
+  events: number[];
+  /** The innermost block still open just after each event (its `{` offset), -1 at the top level. */
+  open: number[];
+  close: Map<number, number>;
+  length: number;
+}
+
+function jsBlockIndex(filePath: string, context: ResolutionContext): JsBlockIndex | null {
+  const scan = jsFileScan(filePath, context);
+  if (scan.blocks === undefined) {
+    const code = scannedCode(scan);
+    scan.blocks = code === null ? null : readJsBlocks(code);
+  }
+  return scan.blocks;
+}
+
+function readJsBlocks(code: string): JsBlockIndex {
+  const lineStarts = [0];
+  const events: number[] = [];
+  const open: number[] = [];
+  const close = new Map<number, number>();
+  const stack: number[] = [];
+  for (let i = 0; i < code.length; i++) {
+    const ch = code.charCodeAt(i);
+    if (ch === 10) { lineStarts.push(i + 1); continue; }
+    if (ch === 123) stack.push(i);
+    else if (ch === 125) {
+      const at = stack.pop();
+      if (at !== undefined) close.set(at, i);
+    } else continue;
+    events.push(i);
+    open.push(stack.length > 0 ? stack[stack.length - 1]! : -1);
+  }
+  return { lineStarts, events, open, close, length: code.length };
+}
+
+/** The offset of (line, column) in a file. */
+function jsOffset(index: JsBlockIndex, line: number, column: number): number {
+  return (index.lineStarts[line - 1] ?? index.length) + column;
+}
+
+/** The innermost `{…}` holding an offset, as [open, close] — null at the file's top level. */
+function jsBlockAt(index: JsBlockIndex, offset: number): [number, number] | null {
+  let lo = 0;
+  let hi = index.events.length - 1;
+  let at = -1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (index.events[mid]! < offset) { at = mid; lo = mid + 1; } else hi = mid - 1;
+  }
+  const open = at < 0 ? -1 : index.open[at]!;
+  return open < 0 ? null : [open, index.close.get(open) ?? index.length];
+}
+
+/**
+ * The offset ranges a JS/TS file binds `name` in: a declaration's or a
+ * function/class name's enclosing block (the whole file at the top level), a
+ * parameter's function body (an expression-bodied arrow's, to the end of its
+ * enclosing block). The patterns are isLocallyBoundJsName's; only the scope is
+ * added, so one function's parameter does not shadow a global in another.
+ */
+function bindingScopes(name: string, filePath: string, context: ResolutionContext): Array<[number, number]> {
+  const scan = jsFileScan(filePath, context);
+  const memo = (scan.bindings ??= new Map());
+  const hit = memo.get(name);
+  if (hit) return hit;
+  const scopes: Array<[number, number]> = [];
+  const code = scannedCode(scan);
+  const index = jsBlockIndex(filePath, context);
+  if (code && index && code.includes(name)) {
+    const blockOf = (at: number): [number, number] => jsBlockAt(index, at) ?? [-1, code.length];
+    // The body a parameter list (ending in `{` or `=>`) opens.
+    const bodyAfter = (start: number, end: number): [number, number] => {
+      if (code[end - 1] === '{') return [end - 1, index.close.get(end - 1) ?? code.length];
+      let i = end;
+      while (i < code.length && /\s/.test(code[i]!)) i++;
+      if (code[i] === '{') return [i, index.close.get(i) ?? code.length];
+      return [start, blockOf(start)[1]];
+    };
+    const { decl, fn, param } = localBindingPatterns(name, 'g');
+    for (const m of code.matchAll(decl)) scopes.push(blockOf(m.index!));
+    for (const m of code.matchAll(fn)) scopes.push(blockOf(m.index!));
+    for (const m of code.matchAll(param)) scopes.push(bodyAfter(m.index!, m.index! + m[0].length));
+    const arrow = new RegExp(`(?<![\\w$.])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=>`, 'g');
+    for (const m of code.matchAll(arrow)) scopes.push(bodyAfter(m.index!, m.index! + m[0].length));
+  }
+  memo.set(name, scopes);
+  return scopes;
+}
+
+/** Whether a binding of `name` in the reference's own file encloses the reference. */
+function bindsNameAt(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const index = jsBlockIndex(ref.filePath, context);
+  if (!index) return false;
+  const at = jsOffset(index, ref.line, ref.column);
+  return bindingScopes(name, ref.filePath, context).some(([start, end]) => at > start && at < end);
+}
+
+/**
+ * Where a same-file holder of an object can be seen from: the block it is
+ * declared in (an IIFE's, a function's), or the whole file for one at the top
+ * level — and for a path hung by assignment, which is a property of its root
+ * object wherever that is. Returns the depth to rank by (the block's `{`
+ * offset; -1 for the whole file), or null when the reference cannot see it —
+ * outside its block, or where the calling function binds the root name itself.
+ */
+function holderScopeAt(holder: Node, ref: UnresolvedRef, viaGlobal: boolean, context: ResolutionContext): number | null {
+  let depth = -1;
+  // A single-file component's source holds its template and styles too, whose
+  // braces are not blocks: a holder there is read as the script's top level.
+  if (!isPathHolder(holder) && JS_TS.has(holder.language)) {
+    const index = jsBlockIndex(holder.filePath, context);
+    const block = index ? jsBlockAt(index, jsOffset(index, holder.startLine, holder.startColumn)) : null;
+    if (index && block) {
+      const at = jsOffset(index, ref.line, ref.column);
+      if (at <= block[0] || at >= block[1]) return null;
+      depth = block[0];
+    }
+  }
+  const root = viaGlobal ? null : holderPath(holder).split('.')[0]!;
+  const local = root ? jsFunctionLocalScope(root, ref, context) : null;
+  if (local && !(holder.filePath === ref.filePath && holder.startLine >= local.start && holder.startLine <= local.end)) return null;
+  return depth;
+}
+
+const CLASSIC_SCRIPTS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/**
+ * Whether a JS/TS file is a classic script — no `import`, `export`, CommonJS
+ * export or `require(…)` — whose top-level names are globals every other
+ * script on the page shares (#2300).
+ */
+function isClassicScript(filePath: string, context: ResolutionContext): boolean {
+  let memo = CLASSIC_SCRIPTS.get(context);
+  if (!memo) CLASSIC_SCRIPTS.set(context, (memo = new Map()));
+  const hit = memo.get(filePath);
+  if (hit !== undefined) return hit;
+  const source = context.readFile(filePath);
+  let classic = false;
+  if (typeof source === 'string' && !/\.mjs$|\.cjs$/i.test(filePath) && !HAS_CJS_EXPORT.test(source)) {
+    const code = maskedJsSource(filePath, context) ?? '';
+    classic = !HAS_IMPORT_STATEMENT.test(code) && !HAS_ESM_EXPORT.test(code) && !/(?:^|[^\w$.])require\s*\(/.test(code);
+  }
+  memo.set(filePath, classic);
+  return classic;
+}
+
+const GLOBAL_HOLDERS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** Whether a holder in another file is a global: on the global object, or at the top level of a classic script. */
+function isGlobalHolder(n: Node, context: ResolutionContext): boolean {
+  let memo = GLOBAL_HOLDERS.get(context);
+  if (!memo) GLOBAL_HOLDERS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  let global: boolean;
+  if (HOST_GLOBAL_PREFIX.test(lastQualifiedSegment(n.qualifiedName))) global = true;
+  else if (!JS_TS.has(n.language) || !isClassicScript(n.filePath, context)) global = false;
+  else if (!isPathHolder(n)) {
+    const index = jsBlockIndex(n.filePath, context);
+    global = !!index && jsBlockAt(index, jsOffset(index, n.startLine, n.startColumn)) === null;
+  } else {
+    // `App.utils = {…}` is global when `App` is: declared at a classic script's top level, or on the global object.
+    const root = holderPath(n).split('.')[0]!;
+    global = context.getNodesByName(root).some((r) => (r.kind === 'constant' || r.kind === 'variable') &&
+      JS_FAMILY.has(r.language) && holderPath(r) === root && r.id !== n.id && isGlobalHolder(r, context));
+  }
+  memo.set(n.id, global);
+  return global;
+}
+
+/**
+ * Resolve `member` on the object a dotted `path` names, at `ref` (#2300):
+ * `App` for `App.init()` / `window.App.init()`, `App.utils` for
+ * `App.utils.fmt()`. A same-file holder the reference can see comes first, the
+ * innermost; then — when the file neither imports nor binds the path's root —
+ * a global one: `window.App = {…}` anywhere, or a classic script's top-level
+ * `App`. Several equally near holders that all have the member are no answer.
+ * `host` is the global object the call was written on (`window.App.init()`),
+ * null for a bare `App.init()`. Undefined when no holder of the path exists at
+ * all (so a caller can try its other strategies), null when one exists but
+ * none has the member.
+ */
+function resolveObjectPathMember(
+  path: string,
+  member: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  host: string | null,
+): ResolvedRef | null | undefined {
+  const viaGlobal = host !== null;
+  const tail = path.slice(path.lastIndexOf('.') + 1);
+  const named = context.getNodesByName(tail).filter((n) =>
+    (n.kind === 'constant' || n.kind === 'variable') && OBJECT_LITERAL_LANGUAGES.has(n.language) &&
+    sameLanguageFamily(n.language, ref.language) && holderPath(n) === path);
+  if (named.length === 0) return undefined;
+  const hitOn = (holder: Node): ResolvedRef | null =>
+    resolveObjectLiteralMember(holder, member, ref, context, 0.85, 'instance-method') ??
+    resolveObjectLiteralBinding(holder, member, ref, context);
+
+  const local = named
+    .filter((n) => n.filePath === ref.filePath)
+    .map((n) => ({ n, depth: holderScopeAt(n, ref, viaGlobal, context) }))
+    .filter((e): e is { n: Node; depth: number } => e.depth !== null)
+    .sort((a, b) => b.depth - a.depth);
+  if (local.length > 0) {
+    // The nearest holders only: an outer one is shadowed where an inner one exists.
+    const nearest = local.filter((e) => e.depth === local[0]!.depth);
+    for (const { n } of nearest) {
+      const hit = hitOn(n);
+      if (hit) return hit;
+    }
+    return null;
+  }
+
+  const hits = named
+    .filter((n) => n.filePath !== ref.filePath && isObjectLiteralOwner(n) && isGlobalHolder(n, context))
+    .map((n) => ({ n, hit: hitOn(n) }))
+    .filter((e): e is { n: Node; hit: ResolvedRef } => e.hit !== null);
+  if (hits.length === 0) return null;
+  // A global is what the call names only where nothing nearer binds the name:
+  // the file's own import of it, a parameter or local around the call — or,
+  // for `window.App`, a `window` of its own. (Checked once a global holder has
+  // the member: it reads the calling file.)
+  const root = path.split('.')[0]!;
+  if (host !== null ? bindsNameAt(host, ref, context)
+    : isImportBinding(root, ref, context) || bindsNameAt(root, ref, context)) return null;
+  const targets = new Set(hits.map((e) => e.hit.targetNodeId));
+  if (targets.size === 1) return { ...hits[0]!.hit, confidence: 0.8 };
+  // The same namespace defined twice (a page's copy and a build's): the caller's own directory decides, or nothing does.
+  const dir = ref.filePath.slice(0, ref.filePath.lastIndexOf('/') + 1);
+  const near = hits.filter((e) => e.n.filePath.startsWith(dir) && !e.n.filePath.slice(dir.length).includes('/'));
+  return new Set(near.map((e) => e.hit.targetNodeId)).size === 1 ? { ...near[0]!.hit, confidence: 0.75 } : null;
+}
+
+/**
+ * `a.b.m()` through a namespace an object literal was hung on (`App.utils =
+ * {…}` then `App.utils.fmt()`, #2300). Identifier-rooted chains carry no type
+ * (#1566), so nothing else may resolve them: this answers only when a holder
+ * of exactly that path exists, and is null otherwise.
+ */
+export function matchObjectPathCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  if (ref.referenceKind !== 'calls' || !JS_FAMILY.has(ref.language)) return null;
+  const dot = ref.referenceName.lastIndexOf('.');
+  if (dot <= 0) return null;
+  let path = ref.referenceName.slice(0, dot);
+  const host = HOST_GLOBAL_PREFIX.test(path) ? path.slice(0, path.indexOf('.')) : null;
+  if (host !== null) path = path.slice(host.length + 1);
+  if (!path.includes('.') && host === null) return null;
+  return resolveObjectPathMember(path, ref.referenceName.slice(dot + 1), ref, context, host) ?? null;
+}
+
+/** `(` after optional space, at `lastIndex`. */
+const OPEN_PAREN_AT = /\s*\(/y;
+
+/** `window.App.utils` at the end of a receiver's text → host `window`, path `App.utils`. */
+const HOST_GLOBAL_RECEIVER =/(?:^|[^\w$.])(window|globalThis)\s*\??\.\s*([A-Za-z_$][\w$]*(?:\s*\??\.\s*[A-Za-z_$][\w$]*)*)$/;
+
+/**
+ * A call the extractor recorded by its bare name although it was written on
+ * an object (#2300): `window.App.init()` — the `window` chain keeps its bare
+ * name as the project-global escape (#1707) — and `this.render()` inside an
+ * object literal's member. Both name the owner of the member they call, which
+ * is tried first. Undefined when the call is neither, or no such owner has the
+ * member (the bare-name strategies then run as before).
+ */
+export function matchCollapsedObjectCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | undefined {
+  if (ref.referenceKind !== 'calls' || !JS_FAMILY.has(ref.language) || !/^[A-Za-z_$][\w$]*$/.test(ref.referenceName)) return undefined;
+  // A call written bare starts with its own name and `(`: no receiver to read.
+  const line = (context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/))?.[ref.line - 1];
+  if (line?.startsWith(ref.referenceName, ref.column)) {
+    OPEN_PAREN_AT.lastIndex = ref.column + ref.referenceName.length;
+    if (OPEN_PAREN_AT.test(line)) return undefined;
+  }
+  const written = bareCallReceiver(ref, context);
+  if (!written) return undefined;
+  if (written.receiver === 'self') {
+    // The object literal `this` is — the owner of the method the call is
+    // written in (an arrow member's `this` is the code around the literal's) —
+    // when it has the member.
+    const caller = context.getNodeById?.(ref.fromNodeId);
+    const owner = caller ? thisObjectOf(caller, context) : null;
+    const hit = owner ? resolveObjectLiteralMember(owner, ref.referenceName, ref, context, 0.85, 'instance-method') : null;
+    return hit ?? undefined;
+  }
+  const host = HOST_GLOBAL_RECEIVER.exec(written.receiver);
+  if (!host) return undefined;
+  return resolveObjectPathMember(host[2]!.replace(/[\s?]/g, ''), ref.referenceName, ref, context, host[1]!) ?? undefined;
+}
+
 // Exported for the precedence unit tests (#1079): they assert the
 // preferredFqn → same-file → matches[0] ordering directly.
 export function resolveMethodOnType(
@@ -1644,6 +8716,8 @@ export function resolveMethodOnType(
    * `dao/converter/` and `service/converter/`), the FQN's
    * file-path-suffix picks the right one — the disambiguation
    * signal Java imports carry but the call site doesn't (#314).
+   * For Go it is the project-relative directory of the package that
+   * declares `typeName`, when that is known (resolveGoMethodInPackage).
    */
   preferredFqn?: string,
   /** Recursion guard for the supertype/conformance walk. */
@@ -1675,6 +8749,10 @@ export function resolveMethodOnType(
       }
     }
   }
+  if (ref.language === 'go' && preferredFqn !== undefined) {
+    const scoped = resolveGoMethodInPackage(typeName, methodName, preferredFqn, matches, ref, context, confidence, resolvedBy, depth);
+    if (scoped !== undefined) return scoped;
+  }
   if (matches.length === 0) {
     // Conformance fallback: the method may be defined on a supertype `typeName`
     // extends, or on a protocol / trait it conforms to (e.g. a Swift protocol-
@@ -1695,10 +8773,17 @@ export function resolveMethodOnType(
       });
       if (viaSupers) return viaSupers;
     }
+    // A Dart extension's member: no declaration of the type has it, so an
+    // extension `on` the type (or a supertype) supplies it — `s.shout()` on an
+    // enum through `extension ShapeInfo on Shape` (#2338).
+    if (ref.language === 'dart' && depth === 0) {
+      const viaExtension = dartExtensionMemberOf(typeName, methodName, ref, context);
+      if (viaExtension) return { original: ref, targetNodeId: viaExtension.id, confidence, resolvedBy };
+    }
     return null;
   }
 
-  if (matches.length > 1 && preferredFqn) {
+  if (matches.length > 1 && preferredFqn && ref.language !== 'go') {
     const ext = ref.language === 'kotlin' ? '.kt' : '.java';
     const fqnPath = preferredFqn.replace(/\./g, '/') + ext;
     const chosen = matches.find((m) => {
@@ -1743,11 +8828,39 @@ const CPP_NON_TYPE_TOKENS = new Set([
   'sizeof', 'alignof', 'typeid', 'and', 'or', 'not', 'xor',
 ]);
 
+/**
+ * Does a `>` in a declared C++ type close no `<`? Then the type began on an
+ * earlier line — rocksdb's `std::unique_ptr<BlobContents>>>& blob_reqs` under
+ * `autovector<std::pair<BlobRangeReadRequest*,` — or the text is an
+ * expression (`i < a->b->c`).
+ */
+function cppTypeBeganAbove(typeName: string): boolean {
+  let depth = 0;
+  for (const c of typeName) {
+    if (c === '<') depth++;
+    else if (c === '>' && --depth < 0) return true;
+  }
+  return false;
+}
+
+/**
+ * The last name of a declared C++ type: `const std::vector<std::pair<int,
+ * Foo>>&` → `vector`, `ns::Table<int, Box<int>>` → `Table`. Null when the text
+ * names no type.
+ */
 function normalizeCppTypeName(typeName: string): string | null {
-  const normalized = typeName
-    .replace(/\b(const|volatile|mutable|typename|class|struct)\b/g, ' ')
-    .replace(/[&*]+/g, ' ')
-    .replace(/<[^>]*>/g, ' ')
+  // Without its head, what is left of a type begun above names a template
+  // argument's type, not the declared one.
+  if (cppTypeBeganAbove(typeName)) return null;
+  // Template arguments go with the ones nested in them. Cut at their first
+  // `>`, `Table<int, Box<int>>` was `Table >`, which names no type: a call
+  // on it never reached Table's method, and a capitalized name no class has
+  // ruled out any guess as well.
+  const normalized = stripCppTemplateArguments(
+    typeName
+      .replace(/\b(const|volatile|mutable|typename|class|struct)\b/g, ' ')
+      .replace(/[&*]+/g, ' '),
+  )
     .replace(/\s+/g, ' ')
     .trim();
 
@@ -1770,11 +8883,211 @@ function buildDeclaratorRegex(escapedReceiver: string): RegExp {
   );
 }
 
+/** What C++ receiver inference made of a receiver's declared type. */
+interface CppReceiverDeclaration {
+  /**
+   * The declared type is an alias: `followed` to the type it names, or
+   * `unreadable` when that type is a template parameter's (`using Type =
+   * GenericType;`, `typename Traits::Field`) or a `decltype(…)` — no
+   * particular class.
+   */
+  aliased?: 'followed' | 'unreadable';
+  /** The type as written in the declaration, without following an alias (`Table`). */
+  written?: string;
+  /** The type is reached through a pointer (`Table* t`, `using Field = const FieldDescriptor*;`). */
+  pointer?: boolean;
+  /** The type is one of the project's class templates, whose specializations may add members. */
+  classTemplate?: boolean;
+  /** The declared type as written (`std::vector<Slice>*`). */
+  raw?: string;
+  /** The declaration is the calling function's own, or a member of its class (isCppCallersDeclaration). */
+  callers?: boolean;
+  /**
+   * On its way back to the declaration the scan passed one of the receiver
+   * it could not read a type from — `auto x = Make();`, `for (Foo& x : xs)`,
+   * `auto [x, y] = …` — so the declaration it found is an earlier variable's.
+   */
+  shadowed?: boolean;
+}
+
+/**
+ * A declared C++ type as receiver inference reads it: its own last segment,
+ * or, when it is an alias the caller's own declaration uses, the type the
+ * alias names (cpp-type-aliases.ts) — null when that type can't be known. An
+ * alias is never a class, so its own name is never looked up as one: that is
+ * how protobuf's `Field f; f->number()` (`using Field = const
+ * FieldDescriptor*;`) reached the generated `Field` message's `number`.
+ */
+function cppDeclaredType(
+  raw: string,
+  normalized: string,
+  inCallerScope: boolean,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  found?: CppReceiverDeclaration,
+): string | null {
+  // A declaration read from elsewhere (an earlier function, another class)
+  // may not be this receiver's, so it is taken as it was before aliases
+  // were followed.
+  if (!inCallerScope) return normalized;
+  const aliased = resolveCppAliasedType(raw, ref, context);
+  if (aliased === undefined) return normalized;
+  if (found) {
+    found.aliased = aliased ? 'followed' : 'unreadable';
+    found.written = normalized;
+    found.pointer = aliased ? aliased.pointer : isCppPointerType(raw);
+    found.classTemplate = aliased?.classTemplate ?? false;
+  }
+  return aliased ? cppAliasedTypeName(aliased) : null;
+}
+
+const CPP_CLASSES_IN_FILE = new WeakMap<ResolutionContext, Map<string, Node[]>>();
+
+/** The classes, structs and unions a C or C++ file declares. */
+function cppClassesIn(file: string, context: ResolutionContext): Node[] {
+  let memo = CPP_CLASSES_IN_FILE.get(context);
+  if (!memo) CPP_CLASSES_IN_FILE.set(context, (memo = new Map()));
+  let classes = memo.get(file);
+  if (!classes) {
+    classes = context.getNodesInFile(file).filter((n) => n.kind === 'class' || n.kind === 'struct' || n.kind === 'union');
+    memo.set(file, classes);
+  }
+  return classes;
+}
+
+/**
+ * Is line `line` of `file`, which declares a C++ receiver, the calling
+ * function's own code, or a member declaration of the caller's class?
+ * Receiver inference reads back to the top of the file and through the
+ * header, so a declaration it finds elsewhere — an earlier function, another
+ * class in the header, a class nested in the caller's (rocksdb's
+ * `MultiScan::MultiScanIterator` has a `scan_opts_` of its own) — may be
+ * another variable of the same name. (The scan has blanked comments.)
+ */
+function isCppCallersDeclaration(file: string, line: number, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const caller = context.getNodeById?.(ref.fromNodeId);
+  if (!caller || (caller.kind !== 'method' && caller.kind !== 'function')) return false;
+  if (file === ref.filePath && line >= caller.startLine && line <= ref.line) return true;
+  const cut = caller.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return false;
+  let innermost: Node | undefined;
+  for (const cls of cppClassesIn(file, context)) {
+    if (line < cls.startLine || line > (cls.endLine ?? cls.startLine)) continue;
+    if (!innermost || cls.startLine >= innermost.startLine) innermost = cls;
+  }
+  return innermost?.qualifiedName === caller.qualifiedName.slice(0, cut);
+}
+
+/**
+ * The operator the C++ member call at `ref` is written with: `.` for
+ * `receiver.method(…)`, `->` through a pointer, iterator or smart pointer, or
+ * null when the source doesn't show it.
+ */
+function cppMemberOperator(receiver: string, ref: UnresolvedRef, context: ResolutionContext): '.' | '->' | null {
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/);
+  const at = lines?.[ref.line - 1]?.slice(ref.column);
+  if (!lines || !at?.startsWith(receiver)) return null;
+  let rest = at.slice(receiver.length);
+  // `symbols_by_parent_` ending its line, `.insert(…)` starting the next.
+  for (let next = ref.line; !rest.trim() && next < Math.min(lines.length, ref.line + 3); next++) rest = lines[next]!;
+  const op = /^\s*(\.|->)/.exec(rest)?.[1];
+  return op === '.' || op === '->' ? op : null;
+}
+
+/** Is the C++ member call at `ref` written `receiver.method(…)`, not through `->`? */
+function isCppDotCall(receiver: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return cppMemberOperator(receiver, ref, context) === '.';
+}
+
+/** Kinds that declare a C or C++ type name. */
+const CPP_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'union', 'enum', 'interface', 'type_alias']);
+
+/** The C and C++ types the project declares under `name`. */
+function cppTypesNamed(name: string, context: ResolutionContext): Node[] {
+  return context.getNodesByName(name).filter((n) => (n.language === 'cpp' || n.language === 'c') && CPP_TYPE_KINDS.has(n.kind));
+}
+
+/**
+ * Is a C++ declared type, as written (`std::vector<Slice>*`, `const
+ * absl::flat_hash_set<int>&`), one from outside the project with a lowercase
+ * name, as the standard library's and abseil's are? (isUndeclaredTypeName
+ * takes the capitalized ones.) The name is qualified, by namespaces that are
+ * no project type's (`Foo::kMask & key` reads like a declaration of `key`),
+ * and the project declares no type of that name: in `std` itself for a
+ * `std::` name (googletest's `testing::internal::string` is no
+ * `std::string`), anywhere for any other, since a namespace a macro opens
+ * (fmt's `FMT_BEGIN_NAMESPACE`) is in no qualified name. An unqualified name
+ * is not known to be std's: fmt's `using namespace std;` is inside `namespace
+ * adl { … }`, and its `basic_string_view` is fmt's own. Nor is a type whose
+ * `>`s outnumber its `<`s: the end of a declaration begun on an earlier line
+ * (`autovector<std::pair<Req*,` above `std::unique_ptr<Blob>>>& reqs`). A
+ * `_t` name has no members of its own: it is a scalar (`std::size_t`, so
+ * the declaration is another variable's), a tag, or a trait that names
+ * another type (rocksdb's `std::conditional_t<kIsDigested, void*, Slice>
+ * dict`).
+ */
+function isCppLibraryType(raw: string, context: ResolutionContext): boolean {
+  if ((raw.match(/</g)?.length ?? 0) !== (raw.match(/>/g)?.length ?? 0)) return false;
+  const segments = cppTypeSegments(raw);
+  if (!segments || segments.length < 2) return false;
+  const name = segments[segments.length - 1]!;
+  if (!/^[a-z]/.test(name) || /_t$/.test(name)) return false;
+  if (segments.slice(0, -1).some((s) => cppTypesNamed(s, context).length > 0)) return false;
+  const declared = cppTypesNamed(name, context);
+  if (segments[0] !== 'std') return declared.length === 0;
+  const spelled = segments.join('::');
+  return !declared.some((n) => n.qualifiedName === spelled || n.qualifiedName.endsWith(`::${spelled}`));
+}
+
+/**
+ * A C++ source line as code, for reading declarations: null for a line of a
+ * comment (`// …`, ` * …`), else the line with its comments blanked, columns
+ * kept. Receiver inference read leveldb's `// … non-null imm_` as a
+ * declaration of `imm_` with the type `null`.
+ */
+function cppCodeOf(line: string): string | null {
+  if (/^\s*(?:\/\/|\*)/.test(line)) return null;
+  let code = line.replace(/\/\*.*?\*\//g, (c) => ' '.repeat(c.length));
+  // A block comment opening here runs past the line.
+  const open = code.indexOf('/*');
+  if (open >= 0) code = code.slice(0, open);
+  const comment = code.indexOf('//');
+  return comment >= 0 ? code.slice(0, comment) : code;
+}
+
+/**
+ * Does `line` declare the receiver in a form the declarator pattern doesn't
+ * read: a range-`for` variable (`for (const Foo& x : xs)`) or a structured
+ * binding (`auto [x, y] = …`)?
+ */
+function cppRebindsReceiver(line: string, escapedReceiver: string): boolean {
+  return new RegExp(String.raw`\bfor\s*\(.*\b${escapedReceiver}\s*:(?!:)`).test(line) ||
+    new RegExp(String.raw`\bauto\s*&{0,2}\s*\[[^\]]*\b${escapedReceiver}\b[^\]]*\]`).test(line);
+}
+
+/** Record the C++ declaration receiver inference settles on. */
+function noteCppDeclaration(found: CppReceiverDeclaration | undefined, raw: string, callers: boolean): void {
+  if (!found) return;
+  found.raw = raw;
+  found.callers = callers;
+  found.pointer = isCppPointerType(raw);
+}
+
+/**
+ * A type name that reads as a type (capitalized) yet names no class, struct
+ * or interface the project declares: one from outside the project.
+ */
+function isUndeclaredTypeName(typeName: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  return /^[A-Z]/.test(typeName) &&
+    !context.getNodesByName(typeName).some((n) => isMethodOwnerKind(n) && sameLanguageFamily(n.language, ref.language));
+}
+
 function inferCppReceiverType(
   receiverName: string,
   ref: UnresolvedRef,
   context: ResolutionContext,
   depth = 0,
+  found?: CppReceiverDeclaration,
 ): string | null {
   // Per-file lines cache when available — this runs per `receiver->method()`
   // ref and re-splitting the file each time is the same quadratic as the
@@ -1790,7 +9103,9 @@ function inferCppReceiverType(
   const declaratorRegex = buildDeclaratorRegex(escapedReceiver);
 
   for (let i = callLineIndex; i >= 0; i--) {
-    const line = lines[i];
+    const text = lines[i];
+    if (!text || !receiverPattern.test(text)) continue;
+    const line = cppCodeOf(text);
     if (!line || !receiverPattern.test(line)) continue;
 
     const declaratorMatch = line.match(declaratorRegex);
@@ -1801,10 +9116,20 @@ function inferCppReceiverType(
         // from the initializer (call return type / construction) (#645).
         const initType = inferCppAutoInitializerType(line, receiverName, ref, context, depth);
         if (initType) return initType;
-        // No usable initializer on this line — keep scanning earlier ones.
+        // No usable initializer on this line — keep scanning earlier ones,
+        // where what is declared is an earlier variable.
+        if (found) found.shadowed = true;
       } else if (normalized) {
-        return normalized;
+        const inCallerScope = isCppCallersDeclaration(ref.filePath, i + 1, ref, context);
+        noteCppDeclaration(found, declaratorMatch[1]!, inCallerScope);
+        return cppDeclaredType(declaratorMatch[1]!, normalized, inCallerScope, ref, context, found);
+      } else if (found && cppTypeBeganAbove(declaratorMatch[1] ?? '')) {
+        // The end of a declaration begun on an earlier line, maybe the
+        // receiver's: one found further up may be another variable.
+        found.shadowed = true;
       }
+    } else if (found && cppRebindsReceiver(line, escapedReceiver)) {
+      found.shadowed = true;
     }
   }
 
@@ -1821,12 +9146,19 @@ function inferCppReceiverType(
       : (context.readFile(headerPath)?.split(/\r?\n/) ?? null);
     if (!headerLines) continue;
 
-    for (const line of headerLines) {
-      if (!receiverPattern.test(line)) continue;
+    for (let i = 0; i < headerLines.length; i++) {
+      const text = headerLines[i]!;
+      if (!receiverPattern.test(text)) continue;
+      const line = cppCodeOf(text);
+      if (!line) continue;
       const declaratorMatch = line.match(declaratorRegex);
       if (!declaratorMatch) continue;
       const normalized = normalizeCppTypeName(declaratorMatch[1] ?? '');
-      if (normalized && normalized !== 'auto') return normalized;
+      if (normalized && normalized !== 'auto') {
+        const inCallerScope = isCppCallersDeclaration(headerPath, i + 1, ref, context);
+        noteCppDeclaration(found, declaratorMatch[1]!, inCallerScope);
+        return cppDeclaredType(declaratorMatch[1]!, normalized, inCallerScope, ref, context, found);
+      }
     }
   }
 
@@ -2086,6 +9418,21 @@ export function matchDottedCallChain(
   const factoryMethod = inner.slice(lastDot + 1);
   if (!factoryClass || !factoryMethod) return null;
   const ret = lookupCalleeReturnType(`${factoryClass}::${factoryMethod}`, ref, context);
+  if (ref.language === 'dart') {
+    const declared = ret
+      ? resolveMethodOnType(ret, method, ref, context, 0.85, 'instance-method', importedFqnOf(ret, ref, context))
+      : null;
+    if (declared) return declared;
+    // A generic factory returns its type parameter — `static T of<T>(…)` in
+    // flutter_bloc's BlocProvider — and one outside the project declares
+    // nothing here, so `BlocProvider.of<CounterCubit>(context).increment()`
+    // had no type to look `increment` up on. The call site has it: read the
+    // chain there as a later link of a chain is read (#750), where `of<T>`'s
+    // T is the type argument the call gives. The edge belongs to this ref, not
+    // to the bare name it was looked up by (see the gin runaway above).
+    const link = matchDartChainLink({ ...ref, referenceName: method }, context);
+    return link ? { ...link, original: ref } : null;
+  }
   if (!ret) {
     // Objective-C: a class-message factory — `[X alloc]`, `[X new]`,
     // `[X sharedFoo]` — returns an instance of the RECEIVER class `X` by
@@ -2223,6 +9570,12 @@ export function normalizeInferredTypeName(raw: string): string | null {
   return seg;
 }
 
+/**
+ * A Java / C# type's optional type arguments (one level of nesting) and array
+ * ranks, as a regex source: `<L, R>`, `<string, List<int>>`, `[]`, `[,]`.
+ */
+const TYPE_ARGS = '(?:<[^;=(){}<>]*(?:<[^;=(){}<>]*>[^;=(){}<>]*)*>)?\\s*(?:\\[[\\s,]*\\]\\s*)*';
+
 /**
  * Per-language patterns that recover a local variable's (or typed parameter's)
  * type from its declaration/initializer. Each regex captures the type in group
@@ -2254,7 +9607,7 @@ const PATTERN_MEMO_CAP = 8192;
  * ReferenceResolver.clearCaches calls clearNameMatcherMemos alongside
  * clearImportResolverMemos.
  */
-type InferScanState = { hi: number; ansIdx: number; ansType: string | null };
+type InferScanState = { hi: number; ansIdx: number; ansType: string | null; ansRaw?: string };
 const INFER_SCAN_STATES = new WeakMap<ResolutionContext, Map<string, InferScanState>>();
 
 /** Awaited inference caches are scoped to the resolver's stable-source window.
@@ -2283,15 +9636,102 @@ function getInferScanStates(context: ResolutionContext): Map<string, InferScanSt
 export function clearNameMatcherMemos(context: ResolutionContext): void {
   INFER_SCAN_STATES.delete(context);
   PYTHON_MEMBER_LINES.delete(context);
+  PYTHON_STATEMENT_STARTS.delete(context);
+  PYTHON_GLOBAL_CLASSES.delete(context);
+  PYTHON_NAME_SCANS.delete(context);
+  PYTHON_IMPORTED_FILES.delete(context);
   AWAITED_TYPE_MEMO.delete(context);
   AWAITED_FILES.delete(context);
   C_STATIC_MEMO.delete(context);
   RUST_TRAIT_IMPL_MEMO.delete(context);
+  RUST_USES.delete(context);
+  RUST_CRATES.delete(context);
+  RUST_DEPENDENCIES.delete(context);
+  LEXICAL_SCOPE_MEMO.delete(context);
+  KOTLIN_LAMBDA_RECEIVERS.delete(context);
+  SCALA_IMPORTED_SUPERS.delete(context);
+  SCALA_PACKAGE_OBJECTS.delete(context);
+  LOCAL_DECL_MEMO.delete(context);
+  JAVA_SUPERS.delete(context);
+  PHP_SUPERS.delete(context);
+  DART_SUPERS.delete(context);
+  DART_HIERARCHIES.delete(context);
+  DART_LINEAGES.delete(context);
+  DART_EXTENSION_OWNERS.delete(context);
+  DART_GETTERS.delete(context);
+  DART_CONSTRUCTORS.delete(context);
+  DART_SETTERS.delete(context);
+  DART_CODE.delete(context);
+  DART_RETURN_TYPES.delete(context);
+  DART_NAME_USES.delete(context);
+  SWIFT_DECLS.delete(context);
+  KOTLIN_RECEIVER_TYPES.delete(context);
+  KOTLIN_HIERARCHIES.delete(context);
+  KOTLIN_FRAMES.delete(context);
+  CPP_NS_MACROS.delete(context);
+  CPP_NS_FRAMES.delete(context);
+  CPP_NS_ALIASES.delete(context);
+  CPP_CLASSES_IN_FILE.delete(context);
+  SOLIDITY_SUPERS.delete(context);
+  DECLARED_SUPERS.delete(context);
+  INHERITED_METHODS.delete(context);
+  MEMBER_SHADOWS.delete(context);
+  MEMBER_WALKS.delete(context);
+  MEMBER_LINES.delete(context);
+  SOLIDITY_HIERARCHIES.delete(context);
+  MEMBER_TYPE_MEMO.delete(context);
+  CSHARP_ALIASES.delete(context);
+  SWIFT_HIERARCHIES.delete(context);
+  KOTLIN_FILE_SCOPES.delete(context);
+  RUBY_ANCESTRY.delete(context);
+  CFML_CHAINS.delete(context);
+  NO_RECEIVER_LINES.delete(context);
+  OBJC_SUPERS.delete(context);
+  CSHARP_SUPERS.delete(context);
+  CSHARP_STATIC_USINGS.delete(context);
+  CSHARP_NAMESPACE_SCOPES.delete(context);
+  CSHARP_PROJECT_USINGS.delete(context);
+  CSHARP_GLOBAL_USINGS.delete(context);
+  CSHARP_ANCESTORS.delete(context);
+  PY_FIXTURE_TYPES.delete(context);
+  PY_PLUGGED_MODULES.delete(context);
+  SCALA_OBJECT_PACKAGES.delete(context);
+  GO_QUALIFIERS.delete(context);
+  GO_SCOPE_INDEXES.delete(context);
+  GO_EMBEDS.delete(context);
+  GO_ALIAS_TARGETS.delete(context);
+  GO_DOT_IMPORTS.delete(context);
+  JAVA_FILE_SCOPES.delete(context);
+  JAVA_ANCESTORS.delete(context);
+  SCALA_SUPERS.delete(context);
+  SCALA_IMPORTS.delete(context);
+  ESM_EXPORT_LISTS.delete(context);
+  JS_FILE_SCANS.delete(context);
+  OBJECT_OWNER_OF.delete(context);
+  THIS_CALLERS.delete(context);
+  GLOBAL_HOLDERS.delete(context);
+  CLASSIC_SCRIPTS.delete(context);
+  LUA_LOCALS.delete(context);
+  LUA_MEMBERS.delete(context);
+  JVM_PACKAGES.delete(context);
+  MINIFIED_SCRIPTS.delete(context);
+  PY_LOCAL_BINDS.delete(context);
+  PY_LOCAL_FILE.delete(context);
+  PY_LOCAL_LAST.delete(context);
+  OVERLOAD_SETS.delete(context);
+  PHP_FILE_SCOPES.delete(context);
+  JAVA_STATIC_IMPORTS.delete(context);
+  PY_IMPORTS.delete(context);
+  PY_MODULE_LOCAL.delete(context);
   SEALED_MODULES.delete(context);
   LOCAL_BINDING_MEMO.delete(context);
   LOCAL_BINDING_SITES.delete(context);
   SELECTOR_NAMES.delete(context);
   GET_STATE_FILES.delete(context);
+  DESTRUCTURED_FILES.delete(context);
+  JS_FN_LOCAL_MEMO.delete(context);
+  JS_CODE_BINDS.delete(context);
+  JS_FN_CODE.delete(context);
   TS_FIELD_DECL_MEMO.delete(context);
   TS_CLASS_LINES.delete(context);
   TARGET_LANGUAGE.delete(context);
@@ -2333,7 +9773,12 @@ function buildLocalReceiverTypePatterns(language: Language, r: string): RegExp[]
       ];
     case 'python':
       return [
-        new RegExp(`\\b${r}\\b\\s*=\\s*([A-Z][\\w.]*)\\s*\\(`), // lg = Logger(...)
+        // group = VLANGroup.objects.create(…) — a Django manager call that
+        // returns one instance of the model (not `filter`/`all`, a QuerySet).
+        new RegExp(`(?:^|;)\\s*${r}\\s*=(?!=)\\s*([A-Z]\\w*)\\.objects\\.(?:create|get|first|last|latest|earliest|get_by_natural_key)\\s*\\(`),
+        // lg = Logger(...) — a statement of its own: `prefix=IPNetwork(…),`
+        // inside a call's arguments is a keyword argument, not a binding.
+        new RegExp(`(?:^|;)\\s*${r}\\s*=(?!=)\\s*([A-Z][\\w.]*)\\s*\\((?![^\\n]*,\\s*$)`),
         // A quoted forward reference (`lg: "Logger"`, `lg: 'pkg.Logger'`) is the
         // same annotation — and what every file under `from __future__ import
         // annotations` or with a not-yet-defined class writes. The unquoted
@@ -2345,7 +9790,8 @@ function buildLocalReceiverTypePatterns(language: Language, r: string): RegExp[]
     case 'java':
       return [
         new RegExp(`\\b${r}\\b\\s*=\\s*new\\s+([A-Za-z_][\\w.]*)`), // = new Logger()
-        new RegExp(`\\b([A-Z][\\w.]*)\\s+${r}\\b\\s*[=;,)]`), // Logger lg;  / param
+        new RegExp(`\\b([A-Z][\\w.]*)\\s*${TYPE_ARGS}\\s+${r}\\b\\s*[=;,)]`), // Logger lg;  / Pair<L, R> pair / String[] args
+        new RegExp(`\\bfor\\s*\\(\\s*(?:final\\s+)?([A-Z][\\w.]*)\\s*${TYPE_ARGS}\\s+${r}\\s*:`), // for (Element el : els)
       ];
     case 'kotlin':
       return [
@@ -2355,7 +9801,15 @@ function buildLocalReceiverTypePatterns(language: Language, r: string): RegExp[]
     case 'csharp':
       return [
         new RegExp(`\\b${r}\\b\\s*=\\s*new\\s+([A-Za-z_][\\w.]*)`), // = new Logger()
-        new RegExp(`\\b([A-Z][\\w.]*)\\s+${r}\\b\\s*[=;,)]`), // Logger lg;  / param
+        new RegExp(`\\b([A-Z][\\w.]*)\\s*${TYPE_ARGS}\\??\\s+${r}\\b\\s*[=;,)]`), // Logger lg;  / List<string> names / JProperty? p
+        new RegExp(`\\bforeach\\s*\\(\\s*([A-Z][\\w.]*)\\s*${TYPE_ARGS}\\??\\s+${r}\\s+in\\b`), // foreach (JProperty p in props)
+      ];
+    case 'objc':
+      return [
+        // FMResultSet *rs = …  /  NSString * _Nullable name;  /  a block's ^(FMResultSet *rs)
+        new RegExp(`\\b([A-Z]\\w*)\\s*(?:<[^<>;]*>\\s*)?\\*\\s*(?:(?:_Nullable|_Nonnull|__strong|__weak|__unsafe_unretained|const)\\s+)*${r}\\b(?!\\s*\\()`),
+        // a method parameter: - (void)read:(nullable FMResultSet *)rs
+        new RegExp(`\\(\\s*(?:(?:nullable|nonnull|__kindof)\\s+)*([A-Z]\\w*)\\s*(?:<[^<>)]*>\\s*)?\\*[^)]*\\)\\s*${r}\\b`),
       ];
     case 'swift':
       return [
@@ -2374,6 +9828,14 @@ function buildLocalReceiverTypePatterns(language: Language, r: string): RegExp[]
       return [
         new RegExp(`\\b${r}\\b\\s*:=\\s*&?([A-Za-z_][\\w.]*)\\s*{`), // lg := Logger{} / &Logger{}
         new RegExp(`\\bvar\\s+${r}\\s+\\*?([A-Za-z_][\\w.]*)`), // var lg Logger / *Logger
+        // A method receiver or parameter of an unexported type — `func (s
+        // *server)`, `func (c *cache[T])`, `func handle(h *handler)`, a line
+        // of a multi-line parameter list or `var (…)` block. Lowercase types
+        // are accepted only where a parameter list puts them: after `(`, `,`
+        // or nothing, and before `,`, `)` or the line's end — unlike the
+        // keyword-free pattern below, which a lowercase `ident type` pair in
+        // ordinary code would satisfy (#2323).
+        new RegExp(`(?:^|[(,])\\s*${r}\\s+\\*?([a-z_]\\w*)\\s*(?:\\[[^\\]]*\\])?\\s*(?:[,)]|$)`), // func (s *server) / f(h *handler)
         // A typed parameter / method receiver (`func use(lg Logger)`,
         // `func (l Logger) M()`) — name-before-type with no `var`/`:=` (#1125).
         // PascalCase-guarded (unlike the anchored patterns above) to keep the
@@ -2467,6 +9929,349 @@ function buildLocalReceiverTypePatterns(language: Language, r: string): RegExp[]
   }
 }
 
+/** Languages whose fields and properties declare their type where the class declares them. */
+const MEMBER_TYPED_LANGUAGES: ReadonlySet<string> = new Set(['csharp', 'java', 'kotlin', 'swift']);
+const MEMBER_CLASS_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'interface', 'enum', 'record']);
+const MEMBER_TYPE_MEMO = new WeakMap<ResolutionContext, Map<string, string | null>>();
+/** Words that can stand where a declaration's type does without being one. */
+const MEMBER_TYPE_NON_TYPES: ReadonlySet<string> = new Set([
+  'return', 'new', 'case', 'throw', 'else', 'in', 'out', 'ref', 'params', 'await', 'yield', 'is', 'as', 'using',
+  'var', 'val', 'goto', 'nameof', 'typeof', 'sizeof', 'default', 'when', 'where', 'get', 'set', 'init',
+  'class', 'interface', 'enum', 'struct', 'record', 'object', 'namespace', 'package', 'import', 'extends',
+  'implements', 'fun', 'static', 'final', 'abstract', 'sealed', 'override', 'virtual', 'delegate', 'event',
+]);
+
+/**
+ * The type a C# / Java / Kotlin receiver has as a field or property of the
+ * class around the call — `private readonly JsonWriter _innerWriter;`,
+ * `public JsonReader Reader { get; }`, `private val sink: BufferedSink` — or
+ * null when the class declares no such member or the calling method binds
+ * the name itself. Only the class's own lines are read, never a method body
+ * or a nested type. Newtonsoft's `_innerWriter.WriteValue(…)` inside
+ * TraceJsonWriter went to TraceJsonWriter's own `WriteValue` by name.
+ */
+function inferMemberReceiverType(receiver: string, ref: UnresolvedRef, context: ResolutionContext): string | null {
+  const name = receiver.replace(/^(?:this|self)\./, '');
+  if (!/^[A-Za-z_]\w*$/.test(name)) return null;
+  const inFile = context.getNodesInFile(ref.filePath).filter((n) => n.language === ref.language);
+  let cls: Node | undefined;
+  let fn: Node | undefined;
+  for (const n of inFile) {
+    if (n.startLine > ref.line || n.endLine < ref.line) continue;
+    if (MEMBER_CLASS_KINDS.has(n.kind) && (!cls || n.startLine >= cls.startLine)) cls = n;
+    else if ((n.kind === 'method' || n.kind === 'function') && (!fn || n.startLine >= fn.startLine)) fn = n;
+  }
+  if (!cls) return null;
+  const found = memberTypeThroughHierarchy(cls, name, context);
+  if (!found) return null;
+  // A lambda parameter, `var` local, `out` variable or `foreach` binding in
+  // the calling method shadows the field, and the local inference that ran
+  // first cannot type those.
+  return fn && bindsNameItself(fn, name, context) ? null : found;
+}
+
+const MEMBER_SHADOWS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+const MEMBER_WALKS = new WeakMap<ResolutionContext, Map<string, string | null>>();
+
+/** Whether a C# / Java / Kotlin function body binds `name` itself — a `var`/`val`, an `out` or loop variable, a lambda parameter. */
+function bindsNameItself(fn: Node, name: string, context: ResolutionContext): boolean {
+  let memo = MEMBER_SHADOWS.get(context);
+  if (!memo) MEMBER_SHADOWS.set(context, (memo = new Map()));
+  const key = `${fn.id}|${name}`;
+  const hit = memo.get(key);
+  if (hit !== undefined) return hit;
+  const lines = context.getFileLines?.(fn.filePath) ?? context.readFile(fn.filePath)?.split(/\r?\n/) ?? [];
+  const body = lines.slice(fn.startLine - 1, fn.endLine).join('\n');
+  const r = name.replace(/\$/g, '\\$');
+  const binds = new RegExp(`\\b(?:var|val|let|out\\s+[\\w.<>?]+|foreach\\s*\\(\\s*[\\w.<>?,\\s]+?)\\s+${r}\\b|\\bfor\\s*\\([^;)]*\\s${r}\\s*:|\\b${r}\\s*=>|[(,]\\s*${r}\\s*(?:,[^()]*)?\\)\\s*=>|\\b${r}\\s*(?:,[^{}]*)?->`).test(body);
+  memo.set(key, binds);
+  return binds;
+}
+
+/**
+ * The type `cls` declares a member `name` with, or one of its supertypes
+ * does — the class's own members first, then those it inherits (a base
+ * class's `internal readonly JsonSerializer Serializer;`), each inherited
+ * class carrying what its type parameters stand for in the class the walk
+ * came from (`: IntegrationTest<DatabaseInitializer>`).
+ */
+function memberTypeThroughHierarchy(cls: Node, name: string, context: ResolutionContext): string | null {
+  let memo = MEMBER_WALKS.get(context);
+  if (!memo) MEMBER_WALKS.set(context, (memo = new Map()));
+  const key = `${cls.id}|${name}`;
+  if (memo.has(key)) return memo.get(key)!;
+  let result: string | null = null;
+  const seen = new Set<string>();
+  const queue: Array<{ type: Node; args: Map<string, string> }> = [{ type: cls, args: new Map() }];
+  while (queue.length > 0 && seen.size < 8) {
+    const { type, args } = queue.shift()!;
+    if (seen.has(type.id)) continue;
+    seen.add(type.id);
+    const found = classMemberType(type, name, context);
+    if (found) {
+      if (type === cls) {
+        result = found;
+        break;
+      }
+      // A member typed by the declaring class's own type parameter
+      // (`protected TFixture Fixture { get; }`) is the argument the subclass
+      // gave it, else its bound — with neither, only `object`'s members.
+      const given = args.get(found);
+      if (given) {
+        result = given;
+        break;
+      }
+      const bound = typeParameterBoundIn(found, [type], context);
+      result = bound === undefined ? found : bound ?? 'object';
+      break;
+    }
+    for (const sup of classHeadSupertypes(type, context)) {
+      const given = headTypeArguments(type, sup, context).map((a) => args.get(a) ?? a);
+      for (const decl of context.getNodesByName(sup)) {
+        if (decl.language !== type.language || !MEMBER_CLASS_KINDS.has(decl.kind)) continue;
+        const params = declaredTypeParameters(decl, context);
+        queue.push({ type: decl, args: new Map(params.map((p, i) => [p, given[i] ?? ''] as [string, string]).filter(([, a]) => a !== '')) });
+      }
+    }
+  }
+  memo.set(key, result);
+  return result;
+}
+
+/** The first `<…>` of a declaration's head, split at its top-level commas. */
+function angleArguments(text: string): string[] {
+  const open = text.indexOf('<');
+  if (open < 0) return [];
+  const out: string[] = [];
+  let depth = 0;
+  let cur = '';
+  for (const ch of text.slice(open + 1)) {
+    if (ch === '<') depth++;
+    else if (ch === '>' && depth-- === 0) break;
+    if (ch === ',' && depth === 0) {
+      out.push(cur);
+      cur = '';
+    } else cur += ch;
+  }
+  out.push(cur);
+  return out.map((a) => a.trim());
+}
+
+/** The type parameters a class declares: `TDbContextFixture` for `class IntegrationTest<TDbContextFixture>`. */
+function declaredTypeParameters(decl: Node, context: ResolutionContext): string[] {
+  const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+  const head = lines.slice(decl.startLine - 1, decl.startLine + 3).join(' ');
+  const at = new RegExp(`\\b${decl.name}\\s*<`).exec(head);
+  if (!at) return [];
+  return angleArguments(head.slice(at.index)).map((p) => /([A-Za-z_]\w*)\s*(?:extends\b.*|:.*)?$/.exec(p.replace(/^(?:in|out|reified)\s+/, ''))?.[1] ?? '');
+}
+
+/** The type arguments a class's head gives a supertype, as simple names: `DatabaseInitializer` for `: IntegrationTest<ParameterizedQueries.DatabaseInitializer>`. */
+function headTypeArguments(cls: Node, sup: string, context: ResolutionContext): string[] {
+  const lines = context.getFileLines?.(cls.filePath) ?? context.readFile(cls.filePath)?.split(/\r?\n/) ?? [];
+  const head = lines.slice(cls.startLine - 1, cls.startLine + 8).join(' ').split('{')[0]!;
+  const at = new RegExp(`(?:[:,]|\\bextends|\\bimplements)\\s*(?:[\\w.]+\\.)?${sup}\\s*<`).exec(head);
+  if (!at) return [];
+  return angleArguments(head.slice(at.index)).map((a) => a.replace(/<[\s\S]*$/, '').split('.').pop()!.trim());
+}
+
+/**
+ * The supertypes a class declaration names in its own head, for the
+ * languages whose heads say it plainly: Pascal `TX = class(TBase, IFoo)`,
+ * Python `class X(Base):`, Ruby `class X < Base`, PHP / TS / JS `extends
+ * Base`, and the Java-family heads.
+ */
+const DECLARED_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const INHERITED_METHODS = new WeakMap<ResolutionContext, Map<string, Node | null>>();
+
+function declaredSupertypes(cls: Node, context: ResolutionContext): string[] {
+  let memo = DECLARED_SUPERS.get(context);
+  if (!memo) DECLARED_SUPERS.set(context, (memo = new Map()));
+  const hit = memo.get(cls.id);
+  if (hit) return hit;
+  const supers = readDeclaredSupertypes(cls, context);
+  memo.set(cls.id, supers);
+  return supers;
+}
+
+function readDeclaredSupertypes(cls: Node, context: ResolutionContext): string[] {
+  switch (cls.language) {
+    case 'java': case 'csharp': case 'kotlin': return classHeadSupertypes(cls, context);
+    case 'dart': return dartSupertypesOf(cls.name, context);
+    case 'swift': return swiftDeclOf(cls.name, context).supers;
+    case 'objc': return objcSupertypesOf(cls.name, context);
+    case 'scala': return scalaSupertypesOf(cls.name, context);
+    default: break;
+  }
+  const lines = context.getFileLines?.(cls.filePath) ?? context.readFile(cls.filePath)?.split(/\r?\n/) ?? [];
+  const head = lines.slice(cls.startLine - 1, cls.startLine + 2).join(' ');
+  const names = (text: string | undefined): string[] =>
+    text ? [...text.matchAll(/([A-Za-z_][\w.:\\]*)/g)].map((m) => m[1]!.split(/::|\.|\\/).pop()!).filter((w) => !/^(?:metaclass|object)$/.test(w)) : [];
+  switch (cls.language) {
+    case 'pascal': return names(/=\s*class\s*\(([^)]*)\)/i.exec(head)?.[1]);
+    case 'python': return names(/\bclass\s+\w+\s*\(([^)]*)\)/.exec(head)?.[1]?.replace(/\w+\s*=\s*[\w.]+/g, ''));
+    case 'ruby': return names(/\bclass\s+[\w:]+\s*<\s*([\w:]+)/.exec(head)?.[1]);
+    case 'php': case 'typescript': case 'tsx': case 'javascript': case 'jsx':
+      return names(/\bextends\s+([\w.\\]+)/.exec(head)?.[1]);
+    default: return [];
+  }
+}
+
+/** A method named `name` on a supertype of the given classes, nearest first. */
+function inheritedClassMethod(classes: Node[], name: string, context: ResolutionContext): Node | null {
+  if (classes.length === 0) return null;
+  let memo = INHERITED_METHODS.get(context);
+  if (!memo) INHERITED_METHODS.set(context, (memo = new Map()));
+  const key = `${classes.map((c) => c.id).join(',')}|${name}`;
+  if (memo.has(key)) return memo.get(key)!;
+  const found = findInheritedClassMethod(classes, name, context);
+  memo.set(key, found);
+  return found;
+}
+
+function findInheritedClassMethod(classes: Node[], name: string, context: ResolutionContext): Node | null {
+  const seen = new Set<string>(classes.map((c) => c.id));
+  let frontier = classes;
+  for (let depth = 0; depth < 5 && frontier.length > 0; depth++) {
+    const next: Node[] = [];
+    for (const cls of frontier) {
+      for (const sup of declaredSupertypes(cls, context)) {
+        for (const decl of context.getNodesByName(sup)) {
+          if (decl.language !== cls.language || !isMethodOwnerKind(decl) || seen.has(decl.id)) continue;
+          seen.add(decl.id);
+          const method = context.getNodesInFile(decl.filePath).find((n) => n.kind === 'method' && n.name === name &&
+            n.qualifiedName.slice(0, Math.max(0, n.qualifiedName.lastIndexOf('::'))).split(/::|\./).pop() === decl.name);
+          if (method) return method;
+          next.push(decl);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return null;
+}
+
+/** The simple names a Java / C# / Kotlin class declaration's head extends or implements. */
+function classHeadSupertypes(cls: Node, context: ResolutionContext): string[] {
+  const lines = context.getFileLines?.(cls.filePath) ?? context.readFile(cls.filePath)?.split(/\r?\n/) ?? [];
+  let depth = 0;
+  let head = '';
+  for (const ch of lines.slice(cls.startLine - 1, cls.startLine + 8).join(' ').replace(/\/\/[^\n]*|\/\*.*?\*\//g, ' ')) {
+    if (ch === '{' && depth === 0) break;
+    if (ch === '<' || ch === '(') depth++;
+    else if (ch === '>' || ch === ')') depth = Math.max(0, depth - 1);
+    else if (depth === 0) head += ch;
+  }
+  const clause = /\b(?:extends|implements)\b([\s\S]*)$/.exec(head)?.[1] ??
+    /\b(?:class|interface|struct|record|object)\s+\w+[^:]*:([\s\S]*)$/.exec(head)?.[1] ?? '';
+  return [...clause.replace(/\bwhere\b[\s\S]*$/, '').matchAll(/([A-Z]\w*)\s*(?=,|$|\bimplements\b)/g)].map((m) => m[1]!);
+}
+
+/**
+ * The type a class declares a member `name` with, read from the lines at its
+ * body's own brace depth (or its header, for a primary constructor's
+ * parameters) — deeper ones are method, accessor and indexer bodies or
+ * nested types.
+ */
+function classMemberType(cls: Node, name: string, context: ResolutionContext): string | null {
+  let memo = MEMBER_TYPE_MEMO.get(context);
+  if (!memo) {
+    memo = new Map();
+    MEMBER_TYPE_MEMO.set(context, memo);
+  }
+  const key = `${cls.id}|${name}`;
+  if (memo.has(key)) return memo.get(key)!;
+  const r = name.replace(/\$/g, '\\$');
+  const pattern = cls.language === 'kotlin' || cls.language === 'swift'
+    ? new RegExp(`\\b(?:val|var|let)\\s+${r}\\s*:\\s*([A-Z][\\w.]*)`)
+    : new RegExp(`(?:^|[\\s(,])([A-Za-z_][\\w.]*)\\s*${TYPE_ARGS}\\??\\s+${r}\\s*(?:[=;,)]|\\{)`);
+  let found: string | null = null;
+  for (const { text, depth } of classMemberLines(cls, context)) {
+    if (!text.includes(name)) continue;
+    const m = pattern.exec(text);
+    // Inside parentheses at member depth is a method's parameter list; only
+    // the header's (a primary constructor's) declares members.
+    const inParens = m !== null && depth === 1 &&
+      (text.slice(0, m.index).match(/\(/g)?.length ?? 0) > (text.slice(0, m.index).match(/\)/g)?.length ?? 0);
+    if (m && !inParens && !MEMBER_TYPE_NON_TYPES.has(m[1]!)) {
+      found = normalizeInferredTypeName(m[1]!);
+      break;
+    }
+  }
+  memo.set(key, found);
+  return found;
+}
+
+const MEMBER_LINES = new WeakMap<ResolutionContext, Map<string, Array<{ text: string; depth: number }>>>();
+
+/**
+ * A class's own member-declaration lines — those at its body's brace depth,
+ * or its header (a primary constructor's parameters) — with comments and
+ * string contents dropped; method, accessor and indexer bodies and nested
+ * types are deeper and left out. Read once per class.
+ */
+function classMemberLines(cls: Node, context: ResolutionContext): Array<{ text: string; depth: number }> {
+  let memo = MEMBER_LINES.get(context);
+  if (!memo) MEMBER_LINES.set(context, (memo = new Map()));
+  const hit = memo.get(cls.id);
+  if (hit) return hit;
+  const lines = context.getFileLines?.(cls.filePath) ?? context.readFile(cls.filePath)?.split(/\r?\n/) ?? [];
+  const out: Array<{ text: string; depth: number }> = [];
+  let depth = 0;
+  let inComment = false;
+  for (let line = cls.startLine; line <= cls.endLine; line++) {
+    let raw = lines[line - 1] ?? '';
+    if (inComment) {
+      const close = raw.indexOf('*/');
+      if (close < 0) continue;
+      raw = raw.slice(close + 2);
+      inComment = false;
+    }
+    let text = raw.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, '""').replace(/\/\*.*?\*\//g, ' ').replace(/\/\/.*$/, '');
+    const open = text.indexOf('/*');
+    if (open >= 0) {
+      text = text.slice(0, open);
+      inComment = true;
+    }
+    if (depth <= 1 && text.trim() !== '') out.push({ text, depth });
+    for (const ch of text) {
+      if (ch === '{') depth++;
+      else if (ch === '}') depth = Math.max(0, depth - 1);
+    }
+  }
+  memo.set(cls.id, out);
+  return out;
+}
+
+/**
+ * What a Java / C# / Kotlin type parameter of the class or method around a
+ * call is bounded by: `ExceptionContext` for `T` in `class Test<T extends
+ * ExceptionContext & Serializable>` / `where T : ExceptionContext` / `<T :
+ * ExceptionContext>`, null when it is a type parameter with no named bound,
+ * undefined when it is not a type parameter there at all.
+ */
+function typeParameterBound(typeName: string, ref: UnresolvedRef, context: ResolutionContext): string | null | undefined {
+  const around = context.getNodesInFile(ref.filePath).filter((n) => n.startLine <= ref.line && n.endLine >= ref.line &&
+    (MEMBER_CLASS_KINDS.has(n.kind) || n.kind === 'method' || n.kind === 'function'));
+  return typeParameterBoundIn(typeName, around, context);
+}
+
+/** {@link typeParameterBound}, over the heads of the given declarations. */
+function typeParameterBoundIn(typeName: string, decls: Node[], context: ResolutionContext): string | null | undefined {
+  if (!/^[A-Z]\w*$/.test(typeName)) return undefined;
+  const t = typeName;
+  let declared = false;
+  for (const n of decls) {
+    const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+    const head = lines.slice(n.startLine - 1, n.startLine + 5).join(' ').split('{')[0]!;
+    const bound = new RegExp(`[<,]\\s*(?:in\\s+|out\\s+|reified\\s+)?${t}\\s*(?:extends|:)\\s*([A-Z][\\w.]*)`).exec(head)?.[1] ??
+      new RegExp(`\\bwhere\\s+${t}\\s*:\\s*([A-Z][\\w.]*)`).exec(head)?.[1];
+    if (bound) return bound.split('.').pop()!;
+    if (new RegExp(`[<,]\\s*(?:in\\s+|out\\s+|reified\\s+)?${t}\\s*[,>]`).test(head)) declared = true;
+  }
+  return declared ? null : undefined;
+}
+
 /** 1-based start line of the tightest function/method enclosing the call. */
 function enclosingScopeStartLine(ref: UnresolvedRef, context: ResolutionContext): number {
   let start = 1;
@@ -2491,6 +10296,13 @@ function inferLocalReceiverType(
   receiverName: string,
   ref: UnresolvedRef,
   context: ResolutionContext,
+  /**
+   * Receives the found type as the declaration spells it, before the
+   * normalization the return value gets: Go's package qualifier (`pkg.Type`
+   * vs a bare `server`) says which package declares it. Set on the
+   * incremental-scan path only, the one every Go receiver takes.
+   */
+  decl?: { raw?: string },
 ): string | null {
   // CFML scope prefixes: `variables.svc` / `this.svc` name a COMPONENT-scoped
   // field whose assignment or `property` declaration usually lives outside the
@@ -2549,6 +10361,8 @@ function inferLocalReceiverType(
     ? 0
     : Math.max(0, enclosingScopeStartLine(ref, context) - 1);
 
+  // The raw capture behind matchLine's latest non-null answer (see `decl`).
+  let lastRaw: string | undefined;
   const matchLine = (i: number): string | null => {
     const line = lines[i];
     if (!line) return null;
@@ -2560,7 +10374,10 @@ function inferLocalReceiverType(
       const m = line.match(re);
       if (m && m[1]) {
         const type = normalizeInferredTypeName(m[1]);
-        if (type) return type;
+        if (type) {
+          lastRaw = m[1];
+          return type;
+        }
       }
     }
     return null;
@@ -2587,7 +10404,8 @@ function inferLocalReceiverType(
       for (let i = callIdx; i >= startIdx; i--) {
         const type = matchLine(i);
         if (type) {
-          states.set(key, { hi: callIdx, ansIdx: i, ansType: type });
+          states.set(key, { hi: callIdx, ansIdx: i, ansType: type, ansRaw: lastRaw });
+          if (decl) decl.raw = lastRaw;
           return type;
         }
       }
@@ -2600,15 +10418,21 @@ function inferLocalReceiverType(
         if (type) {
           state.ansIdx = i;
           state.ansType = type;
+          state.ansRaw = lastRaw;
           break;
         }
       }
       state.hi = callIdx;
-      return state.ansIdx >= startIdx ? state.ansType : null;
+      if (state.ansIdx < startIdx) return null;
+      if (decl) decl.raw = state.ansRaw;
+      return state.ansType;
     }
     for (let i = callIdx; i >= startIdx; i--) {
       const type = matchLine(i);
-      if (type) return type;
+      if (type) {
+        if (decl) decl.raw = lastRaw;
+        return type;
+      }
     }
     return null;
   }
@@ -2967,16 +10791,59 @@ export function matchMethodCall(
   // receiver type we can try to infer from its local declaration.
   const inferableReceiver = dotMatch || luaColonMatch || rDollarMatch;
 
+  // A Dart call through a type's name is to that type's own member, or to
+  // nothing in the project.
+  if (ref.language === 'dart' && dotMatch) {
+    const typeMember = nmTimedT('mc-darttype', ref, () => matchDartTypeMemberCall(objectOrClass!, methodName!, ref, context));
+    if (typeMember !== undefined) return typeMember;
+  }
+
   // Infer the receiver's type from its local declaration/initializer in the
   // enclosing scope, then resolve the method on that type (#1108). C++ keeps its
   // dedicated inferrer (header scan + `auto`); every other language uses the
   // shared source-based inferrer. resolveMethodOnType validates the method
   // exists on the inferred type, so a mis-inference produces no edge.
   if (inferableReceiver) {
+    // A VB.NET receiver's declared type decides the call, or that there is no
+    // project method to call: SCrawler's `ThumbnailFile.Delete(…)` on an
+    // external `SFile` went to a nested class's `Delete` by a shared word.
+    if (ref.language === 'vbnet' && dotMatch) {
+      const typed = nmTimedT('mc-vbtyped', ref, () =>
+        matchVbTypedCall(objectOrClass!, methodName!, ref, context, (name) => isStdMethodName('vbnet', name)));
+      if (typed !== undefined) return typed;
+    }
+    const decl: { raw?: string } = {};
+    const cppDecl: CppReceiverDeclaration = {};
     let inferredType = nmTimedT('mc-infer', ref, () =>
       ref.language === 'cpp'
-        ? inferCppReceiverType(objectOrClass!, ref, context)
-        : inferLocalReceiverType(objectOrClass!, ref, context));
+        ? inferCppReceiverType(objectOrClass!, ref, context, 0, cppDecl)
+        : inferLocalReceiverType(objectOrClass!, ref, context, decl));
+    // A pytest test's parameter is what its fixture returns: flaskbb's
+    // `cli_runner.invoke(…)` is click's `CliRunner`, not the project's one `invoke`.
+    if (!inferredType && ref.language === 'python' && dotMatch) inferredType = pythonFixtureReturnType(objectOrClass!, ref, context);
+    // A Go parameter named like an import is declared through a package as
+    // often as not (`logger logger.Interface`), which the patterns above
+    // don't read; the scope reader kept its type. Not a field's: in
+    // `metadata.Type.String()` that is the type of `metadata`.
+    if (!inferredType && ref.language === 'go' && dotMatch && !objectOrClass!.includes('.')) {
+      const declared = goRefQualification(ref, context).declaredType;
+      if (declared) {
+        inferredType = normalizeInferredTypeName(declared);
+        decl.raw = declared;
+      }
+    }
+    if (!inferredType && MEMBER_TYPED_LANGUAGES.has(ref.language) && dotMatch) {
+      inferredType = nmTimedT('mc-member', ref, () => inferMemberReceiverType(objectOrClass!, ref, context));
+      // A field of a built-in type (`string _name`, `int count`) has no project method.
+      if (inferredType && /^[a-z]/.test(inferredType)) return null;
+    }
+    // A type parameter is its bound; with none, only `Object`'s methods.
+    if (inferredType && MEMBER_TYPED_LANGUAGES.has(ref.language) &&
+        !context.getNodesByName(inferredType).some(isMethodOwnerKind)) {
+      const bound = typeParameterBound(inferredType, ref, context);
+      if (bound === null) return null;
+      if (bound !== undefined) inferredType = bound;
+    }
     const awaited = !inferredType && ESM_FAMILY.has(ref.language)
       ? inferEsmAwaitedCallType(objectOrClass!, ref, context) : null;
     if (awaited) {
@@ -2985,13 +10852,16 @@ export function matchMethodCall(
     }
     if (inferredType) {
       // Java/Kotlin: when two classes share the simple name, the file's import
-      // pins WHICH one (#314). Other languages disambiguate by call-site file.
+      // pins WHICH one (#314); Go: the package that declares the type (#2323).
+      // Other languages disambiguate by call-site file.
       const importedFqn =
         ref.language === 'java' || ref.language === 'kotlin'
           ? context
               .getImportMappings(ref.filePath, ref.language)
               .find((i) => i.localName === inferredType)?.source
-          : undefined;
+          : ref.language === 'go'
+            ? goDeclaredTypePackage(decl.raw, ref.filePath, context)
+            : undefined;
       const typedMatch = nmTimedT('mc-rmot', ref, () => resolveMethodOnType(
         inferredType,
         methodName!,
@@ -3001,6 +10871,11 @@ export function matchMethodCall(
         'instance-method',
         importedFqn,
       ));
+      if (typedMatch && ref.language === 'kotlin') {
+        // `medium and 0xff` on an Int: the standard library's member, not a project `Int.and(Long)`.
+        const target = context.getNodeById?.(typedMatch.targetNodeId);
+        if (target && isKotlinNumberBitwise(target, ref)) return null;
+      }
       if (typedMatch) {
         if (awaited) {
           const target = context.getNodeById?.(typedMatch.targetNodeId);
@@ -3023,6 +10898,42 @@ export function matchMethodCall(
       ) {
         return null;
       }
+      // The receiver's declared type is one the project doesn't declare —
+      // `List<Roshambo> list`, `String s`, `val sb = StringBuilder()` — so the
+      // method is that outside type's. gson's `list.add(…)` went to a project
+      // list wrapper's `add`, commons-lang's `s.length()` to a writer's.
+      // (Only a type name — `java.util.List`, not a call chain like Python's
+      // `Device.objects.create(…)` the initializer pattern also captures.)
+      if (isUndeclaredTypeName(inferredType.split('.').pop()!, ref, context)) return null;
+    }
+    if (cppDecl.aliased) {
+      // A C++ receiver the calling function or its class declares through an
+      // alias has the type the alias names. When that type and its
+      // supertypes lack the method (`files_.clear()` through `using Files =
+      // std::vector<int>;`), or the alias names a template parameter's type,
+      // a method picked by the receiver's name below would be some other
+      // type's.
+      if (!cppDecl.classTemplate && (cppDecl.pointer || isCppDotCall(objectOrClass!, ref, context))) return null;
+      // Not so for `it->m()` on an iterator or smart pointer, whose `->`
+      // reaches an element type the alias doesn't name, nor for one of the
+      // project's class templates, whose specializations may declare members
+      // the template itself doesn't (rocksdb's `omt_node_templated<T, true>`
+      // adds `get_marked`): that call goes on as it did before aliases were
+      // followed.
+      if (isUndeclaredTypeName(cppDecl.written!, ref, context)) return null;
+    }
+    // A C++ receiver the calling function or its class declares as a type
+    // from outside the project with a lowercase name calls that type's own
+    // member, through `.` or a raw pointer's `->`: leveldb's `std::string
+    // data_; data_.data()` went to `Slice::data`, protobuf's `std::string
+    // proto; proto.append(…)` to `LeftoverBuffer::append`. Not so for `->`
+    // on such a value — an iterator, smart pointer or optional hands the call
+    // to its element type — nor for a call that doesn't fit the declaration
+    // (`.` on a pointer), which then is another variable's.
+    if (ref.language === 'cpp' && cppDecl.callers && !cppDecl.aliased && !cppDecl.shadowed &&
+        cppMemberOperator(objectOrClass!, ref, context) === (cppDecl.pointer ? '->' : '.') &&
+        isCppLibraryType(cppDecl.raw!, context)) {
+      return null;
     }
   }
 
@@ -3108,26 +11019,17 @@ export function matchMethodCall(
   }
 
   // Object-literal namespace receiver (#1573): `api.call()` where `api` is a
-  // same-file `const api = { call() {…}, get: () => {…} }`. Its members are
-  // plain functions with bare names inside the constant's extent — no
-  // `Container::member` qualified name — so none of the class-shaped
-  // strategies below can see them (Strategy 3 only considers `method`
-  // kinds) and the call resolved to nothing at all. Same file only: a
-  // cross-file use reaches the same helper through the import path.
+  // `const api = { call() {…}, get: () => {…} }`. Its members are functions
+  // inside the constant's extent, found by containment — none of the
+  // class-shaped strategies below can see them (Strategy 3 only considers
+  // `method` kinds). The holder is the one the call can see: in its own file,
+  // the nearest enclosing declaration (an IIFE's `const App` before the file's);
+  // otherwise a global — `window.App = {…}`, or a classic script's top-level
+  // `App` — when the file doesn't import or bind the name itself (#2300). An
+  // imported holder reaches the same member through the import path.
   if (dotMatch && !objectOrClass!.includes('.') && OBJECT_LITERAL_LANGUAGES.has(ref.language)) {
-    const literalMatch = nmTimedT('mc-literal', ref, (): ResolvedRef | null => {
-      // Same-file holders only, so the call-site-first ordering is moot.
-      const holders = context.getNodesByName(objectOrClass!).filter(
-        (n) => (n.kind === 'constant' || n.kind === 'variable') && n.filePath === ref.filePath
-      );
-      for (const holder of holders) {
-        const hit =
-          resolveObjectLiteralMember(holder, methodName!, ref, context, 0.85, 'instance-method') ??
-          resolveObjectLiteralBinding(holder, methodName!, ref, context);
-        if (hit) return hit;
-      }
-      return null;
-    });
+    const literalMatch = nmTimedT('mc-literal', ref, (): ResolvedRef | null =>
+      resolveObjectPathMember(objectOrClass!, methodName!, ref, context, null) ?? null);
     if (literalMatch) return literalMatch;
   }
 
@@ -3137,10 +11039,21 @@ export function matchMethodCall(
   // own file first — otherwise the first-indexed class wins and a call in `b/`
   // resolves to `a/`'s method (#1079).
   const strat1 = nmTimedT('mc-class', ref, (): ResolvedRef | null => {
-    const classCandidates = preferCallSiteFile(
+    let classCandidates = preferCallSiteFile(
       context.getNodesByName(objectOrClass!).filter(isMethodOwnerKind),
       ref.filePath,
     );
+    // A C# class the call's namespaces can see before one they can't:
+    // serilog's `Some.InformationEvent()` in Serilog.Tests is its own
+    // Support namespace's `Some`, not the performance tests'.
+    if (ref.language === 'csharp' && classCandidates.length > 1) {
+      const typeRef = { ...ref, referenceName: objectOrClass! };
+      const visible = classCandidates.filter((c) => c.language !== 'csharp' || isCsharpTypeVisible(c, typeRef, context));
+      classCandidates = [...visible, ...classCandidates.filter((c) => !visible.includes(c))];
+    }
+    // A VB.NET type declared in two projects is the caller's own project's:
+    // staxrip's `FrameServerFactory.Create(…)` went to its AutoCrop tool's copy.
+    if (ref.language === 'vbnet') classCandidates = preferVbProject(classCandidates, ref, context);
 
     for (const classNode of classCandidates) {
       // Skip cross-language class matches
@@ -3163,6 +11076,10 @@ export function matchMethodCall(
         };
       }
     }
+    // A class method the named class inherits — Horse's `THorse.Get(…)` is
+    // THorseCore's, three `class(…)` heads up — before any guess by name.
+    const inherited = inheritedClassMethod(classCandidates.filter((c) => c.language === ref.language), methodName!, context);
+    if (inherited) return { original: ref, targetNodeId: inherited.id, confidence: 0.8, resolvedBy: 'qualified-name' };
     return null;
   });
   if (strat1) return strat1;
@@ -3175,6 +11092,46 @@ export function matchMethodCall(
       objectOrClass !== 'this' && objectOrClass !== 'super' &&
       JS_BUILTIN_METHODS.has(methodName!)) return null;
 
+  // A receiver the file imports is past guessing. A namespace import is the
+  // module object, whose members are its exports, never some class's method;
+  // a binding from a package outside the repository names nothing in it. The
+  // import resolver placed what it could, and a method picked by name alone is
+  // wrong: zod's `z.string()` (`import * as z from "zod/v4"`) bound 3,207 calls
+  // to a test helper's `string` getter, trpc's `z.record()` another class's.
+  if (ref.referenceKind === 'calls' && JS_FAMILY.has(ref.language) && isImportedModuleReceiver(objectOrClass!, ref, context)) {
+    return null;
+  }
+
+  // A receiver written as a type name the project doesn't declare
+  // (`Exception.Create(…)` in Delphi, `Collections.sort(…)`) is a type from
+  // outside it: a same-named method of some project type is a guess. horse's
+  // `Exception.Create` went to its own `EHorseException::Create` 44 times.
+  // A C# using alias names its type: `using Assert = Newtonsoft.Json.Tests.XUnitAssert;`.
+  const aliased = ref.language === 'csharp' ? csharpUsingAlias(objectOrClass!, ref, context) : null;
+  if (aliased) {
+    return resolveMethodOnType(aliased, methodName!, ref, context, 0.9, 'instance-method', undefined);
+  }
+
+  // In C# and Java a capitalized receiver the class around it doesn't declare
+  // is a type — a project property of that name elsewhere (a test object's
+  // `DateTime`) does not make `DateTime.Parse(…)` the project's.
+  const typesOnly = ref.language === 'csharp' || ref.language === 'java' || ref.language === 'rust';
+  if (namesExternalType(objectOrClass!, ref.language) &&
+      !context.getNodesByName(objectOrClass!).some((n) => sameLanguageFamily(n.language, ref.language) &&
+        (!typesOnly || isMethodOwnerKind(n) || n.kind === 'enum' || n.kind === 'namespace' || n.kind === 'module' ||
+          n.kind === 'trait' || n.kind === 'type_alias'))) {
+    return null;
+  }
+  // Rust `task::spawn(…)` / `io::stdout()`: a function through a module path —
+  // never a method some type of that name owns.
+  if (ref.language === 'rust' && match === colonMatch && /^[a-z_][\w]*(?:::[a-z_]\w*)*$/.test(objectOrClass!)) {
+    return null;
+  }
+  // `string.Equals(…)`, `object.ReferenceEquals(…)`: a C# keyword type.
+  if (ref.language === 'csharp' && /^(?:string|object|int|long|short|byte|bool|char|double|float|decimal|uint|ulong|ushort|sbyte)$/.test(objectOrClass!)) {
+    return null;
+  }
+
   // Strategy 2: Instance variable receiver - try capitalized form to find class
   // e.g., "permissionEngine" → look for classes containing "PermissionEngine"
   const capitalizedReceiver = objectOrClass!.charAt(0).toUpperCase() + objectOrClass!.slice(1);
@@ -3231,10 +11188,70 @@ export function matchMethodCall(
 
     // Filter to same-language candidates first
     const sameLanguageMethods = methods.filter(m => m.language === ref.language);
-    const targetMethods = sameLanguageMethods.length > 0 ? sameLanguageMethods : methods;
+    let targetMethods = sameLanguageMethods.length > 0 ? sameLanguageMethods : methods;
+    // A receiver the file imports is another module's value: never a method
+    // declared in the calling file. expo-camera's `CameraManager.isAvailableAsync()`
+    // (`import CameraManager from './ExpoCameraManager'`) went to `CameraView`'s
+    // own static `isAvailableAsync` — the method making the call.
+    // Ruling the caller's file out may reject a guess; it must never
+    // manufacture one — the one method left is then no likelier than before.
+    let narrowed = false;
+    if (JS_FAMILY.has(ref.language) && isImportBinding(objectOrClass!, ref, context)) {
+      const kept = targetMethods.filter((m) => m.filePath !== ref.filePath);
+      narrowed = kept.length !== targetMethods.length;
+      targetMethods = kept;
+    }
+    // Ruling these out must not leave a lone other `destroy` to guess at.
+    {
+      const kept = targetMethods.filter((m) => !(DISPATCHED_ACTIONS.has(m.name) &&
+        DISPATCHED_OWNER.test(m.qualifiedName.slice(0, Math.max(0, m.qualifiedName.lastIndexOf('::'))).split(/::|\./).pop()!)) &&
+        !isKotlinNumberBitwise(m, ref));
+      narrowed ||= kept.length !== targetMethods.length;
+      targetMethods = kept;
+    }
+    // Another library's unnamed Dart extension does not apply here: bloc's
+    // `tester.pumpApp(…)` is the imported `PumpApp`, not flutter_counter's
+    // `extension on WidgetTester`.
+    {
+      const kept = targetMethods.filter((m) => !isDartUnnamedExtensionMember(m, context) || inSameDartLibrary(ref.filePath, m.filePath, context));
+      narrowed ||= kept.length !== targetMethods.length;
+      targetMethods = kept;
+    }
+    // Production code never calls into a test suite: a guess from
+    // rest_framework/renderers.py's `view.reverse_action(…)` is not a test's
+    // `DummyView`. The test's methods were never in the running.
+    if (!isTestPath(ref.filePath)) targetMethods = targetMethods.filter((m) => !isTestPath(m.filePath));
+    // A Vue component's own method is reached as `this.m()` inside it —
+    // never as `e.preventDefault()` on an event, nor `this.editor.setValue()`
+    // on something the component holds. A template ref
+    // (`this.$refs.form.validate()`) names a child this cannot tell apart.
+    if (JS_FAMILY.has(ref.language)) {
+      const kept = targetMethods.filter((m) => !isVueComponentMethod(m) || (objectOrClass === 'this' && m.filePath === ref.filePath));
+      narrowed ||= kept.length !== targetMethods.length;
+      targetMethods = kept;
+    }
 
-    // If only one same-language method with this name exists, use it
-    if (targetMethods.length === 1 && targetMethods[0]!.language === ref.language) {
+    // If only one same-language method with this name exists, use it —
+    // except in Ruby, where nothing types a receiver: there the one method
+    // must also belong to something the receiver is named after
+    // (`web_push_request.legacy_encrypt` → WebPushRequest). rubocop's
+    // `node.loc` on a rubocop-ast node went to the one `loc` in the project
+    // 1,201 times; lobsters' `value.to_s` to a short-id class's.
+    if (targetMethods.length === 1 && !narrowed && targetMethods[0]!.language === ref.language &&
+        // A test double is only what a test names — as in the scoring below:
+        // allauth's `resp.json()` on a Django test response is not the one
+        // `json` of its `MockedResponse`.
+        !isUnnamedTestDouble(targetMethods[0]!, objectOrClass!, ref, context) &&
+        !((ref.language === 'lua' || ref.language === 'luau') && isLuaLibraryCall(objectOrClass!, methodName!, ref, targetMethods[0]!)) &&
+        // Rust / Go / Kotlin / C# / VB.NET: a standard-library method name on
+        // an untyped receiver (`sym.map(…)`, `w.Header().Get(…)`,
+        // `reader.Value.ToString()`) is the library type's.
+        !(isStdMethodName(ref.language, methodName!) &&
+          !/^(?:self|Self|this|base)$/.test(objectOrClass!) && !receiverNamesOwner(receiverLink(objectOrClass!), targetMethods[0]!, context)) &&
+        !(UNTYPED_RECEIVER_LANGUAGES.has(ref.language) && !/^(?:self|self\.class|this|super|weak_?self|strong_?self)$/i.test(objectOrClass!) &&
+          !sharesReceiverWord(objectOrClass!, targetMethods[0]!) &&
+          !(ref.language === 'objc' && objcReceiverReaches(objectOrClass!, targetMethods[0]!, context)) &&
+          !(ref.language === 'php' && phpReceiverReaches(objectOrClass!, targetMethods[0]!, context)))) {
       return {
         original: ref,
         targetNodeId: targetMethods[0]!.id,
@@ -3243,43 +11260,437 @@ export function matchMethodCall(
       };
     }
 
-    // Multiple methods: score by receiver name word overlap with class name
-    if (targetMethods.length > 1) {
-      const receiverWords = splitCamelCase(objectOrClass!);
-      let bestMatch: typeof targetMethods[0] | undefined;
-      let bestScore = 0;
+    // Multiple methods: score by receiver name word overlap with class name
+    if (targetMethods.length > 1) {
+      // What the receiver is named after is its last link: `builder.tokeniser`
+      // is a Tokeniser, `table.Columns` no kind of table.
+      const receiverWords = splitCamelCase(receiverLink(objectOrClass!));
+      const head = receiverWords[receiverWords.length - 1]?.toLowerCase();
+      let bestMatch: typeof targetMethods[0] | undefined;
+      let bestScore = 0;
+      let tied: typeof targetMethods = [];
+
+      // Same-file candidates first, so a score tie (`score > bestScore` keeps
+      // the first seen) resolves to the call site's own file rather than the
+      // first-indexed duplicate (#1079).
+      const std = isStdMethodName(ref.language, methodName!) && !/^(?:self|Self|this|base)$/.test(objectOrClass!);
+      for (const method of preferCallSiteFile(targetMethods, ref.filePath)) {
+        if (std && !receiverNamesOwner(receiverLink(objectOrClass!), method, context)) continue;
+        // The owner type's own name — not its namespace (`eShop.ClientApp…`
+        // shares `Client` with every `httpClient`) nor the method's.
+        const cut = method.qualifiedName.lastIndexOf('::');
+        const classWords = cut > 0 ? splitCamelCase(method.qualifiedName.slice(0, cut).split(/::|\./).pop()!) : [];
+        let score = receiverWords.filter(w =>
+          classWords.some(cw => cw.toLowerCase() === w.toLowerCase())
+        ).length;
+        // A test double is only what a test constructs or names — never a
+        // guess from `response.json()` (mealie's `_FakeHTTPResponse`) in a
+        // file that never mentions it.
+        if (TEST_DOUBLE_OWNER.test(classWords.join(' ')) && !receiverWords.some((w) => TEST_DOUBLE_OWNER.test(w)) &&
+            !(context.readFile(ref.filePath) ?? '').includes(method.qualifiedName.slice(0, cut).split(/::|\./).pop()!)) continue;
+        // The receiver's head noun naming the owner's: `bookPage` is a Page
+        // before it is anything of a Book's.
+        if (head !== undefined && head === classWords[classWords.length - 1]?.toLowerCase()) score += 1;
+        // Bonus for same language
+        if (method.language === ref.language) score += 1;
+        if (score > bestScore) {
+          bestScore = score;
+          bestMatch = method;
+          tied = [method];
+        } else if (score === bestScore) {
+          tied.push(method);
+        }
+      }
+      // VB.NET: between equally good guesses, the caller's own file, then its
+      // project, then the nearer directory — and no guess when none of them
+      // decides. staxrip's main app and its AutoCrop tool each declare a
+      // `ColorHSL`, and the first indexed took about 90 of the app's calls.
+      if (ref.language === 'vbnet' && tied.length > 1 && bestScore >= 2) bestMatch = breakVbTie(tied, ref, context) ?? undefined;
+
+      // A wrapper handing its call on — BookStack's `FileStorage::delete` doing
+      // `$storage->delete($path)`, `CommentRepo::delete` doing
+      // `$comment->delete()` — names the caller's own class only by a shared
+      // word. The guess is the caller itself, so there is no guess.
+      if (bestMatch && bestScore >= 2 && bestMatch.id !== ref.fromNodeId) {
+        return {
+          original: ref,
+          targetNodeId: bestMatch.id,
+          confidence: 0.65,
+          resolvedBy: 'instance-method',
+        };
+      }
+    }
+    return null;
+    });
+    if (strat3) return strat3;
+  }
+
+  return null;
+}
+
+/**
+ * Is a member call's receiver (`z` in `z.string`, `ns` in `ns.util.fn`) an
+ * import binding that is a module namespace, or one from outside the repo?
+ */
+function isImportedModuleReceiver(receiver: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const root = receiver.split('.')[0]!;
+  const binding = context.getImportMappings?.(ref.filePath, ref.language)?.find((m) => m.localName === root);
+  if (!binding) return false;
+  return binding.isNamespace || context.isOutOfRepoImport?.(binding.source, ref.filePath, ref.language) === true;
+}
+
+/** A method a Vue Options API component declares for itself (`index::handleLogin` in `index.vue`). */
+function isVueComponentMethod(n: Node): boolean {
+  return n.kind === 'method' && n.filePath.endsWith('.vue') && n.qualifiedName === `${path.posix.basename(n.filePath, '.vue')}::${n.name}`;
+}
+
+/** Is `ref` written as `this.<name>(` in the file that declares `n`? */
+function isThisCallInOwnFile(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (n.filePath !== ref.filePath) return false;
+  const line = (context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/))?.[ref.line - 1] ?? '';
+  return new RegExp(String.raw`\bthis\s*\??\.\s*${n.name.replace(/\$/g, '\\$')}\s*\(`).test(line);
+}
+
+/** Is the root of a member call's receiver (`CameraManager` in `CameraManager.x`) one of the file's imports? */
+function isImportBinding(receiver: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const root = receiver.split('.')[0]!;
+  return context.getImportMappings?.(ref.filePath, ref.language)?.some((m) => m.localName === root) === true;
+}
+
+/** Does the file bind `name` by importing it from outside the repository? */
+function isOutOfRepoBinding(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const binding = context.getImportMappings?.(ref.filePath, ref.language)?.find((m) => m.localName === name);
+  return !!binding && context.isOutOfRepoImport?.(binding.source, ref.filePath, ref.language) === true;
+}
+
+/** The directory of a Go file, which is its package: Go keeps one package per directory. */
+function goPackageDir(filePath: string): string {
+  return path.posix.dirname(filePath.replace(/\\/g, '/'));
+}
+
+/**
+ * The project directory of the package `filePath` imports as `qualifier`:
+ * undefined when the file has no such import, null when the import is not a
+ * package of one of the project's modules.
+ */
+function goImportPackageDir(qualifier: string, filePath: string, context: ResolutionContext): string | null | undefined {
+  const imp = context.getImportMappings(filePath, 'go').find((i) => i.localName === qualifier);
+  if (!imp) return undefined;
+  return context.getGoPackageDir?.(imp.source, filePath) ?? null;
+}
+
+/**
+ * The package directory that declares a Go type spelled `raw` in `filePath`:
+ * the file's own package for a bare name (`server`, `*Store`), the imported
+ * package for a qualified one (`store.Manager`) when it is a project package.
+ * Undefined when that can't be told, which leaves resolution as it was.
+ */
+function goDeclaredTypePackage(raw: string | undefined, filePath: string, context: ResolutionContext): string | undefined {
+  if (!raw) return undefined;
+  const name = raw.replace(/[*&\s]/g, '');
+  const dot = name.indexOf('.');
+  if (dot < 0) return goPackageDir(filePath);
+  return goImportPackageDir(name.slice(0, dot), filePath, context) ?? undefined;
+}
+
+/** The node kinds a Go `type` declaration produces. */
+export const GO_TYPE_KINDS: ReadonlySet<string> = new Set(['struct', 'interface', 'type_alias']);
+
+/**
+ * `methodName` on the Go type `typeName` that the package in directory
+ * `pkgDir` declares (#2323). Go type names are unique only within a package —
+ * each package may have its own `server`, `handler` or `DAO` — and a type's
+ * methods are always declared in its own package, so `matches` (every
+ * `<typeName>::<methodName>` in the project) counts only from `pkgDir`. A
+ * method the type doesn't declare is promoted from a type it embeds, which
+ * its declaration names (`BaseAPI`, `*cached.BaseManager`, `ReadView`); the
+ * name-based supertype walk would mix in every same-named type's embeddings.
+ * Undefined when the package declares no such type (a dot import, a file
+ * that isn't indexed): the caller then resolves by name as before.
+ */
+function resolveGoMethodInPackage(
+  typeName: string,
+  methodName: string,
+  pkgDir: string,
+  matches: Node[],
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  confidence: number,
+  resolvedBy: ResolvedRef['resolvedBy'],
+  depth: number,
+): ResolvedRef | null | undefined {
+  const own = matches.filter((m) => goPackageDir(m.filePath) === pkgDir);
+  if (own.length > 0) {
+    if (ref.referenceKind === 'function_ref' && own.length !== 1) return null;
+    return { original: ref, targetNodeId: preferCallSiteFile(own, ref.filePath)[0]!.id, confidence, resolvedBy };
+  }
+  const types = goPackageTypes(typeName, pkgDir, context);
+  if (types.length === 0) return undefined;
+  if (depth >= 4) return null;
+  let unplaced = 0;
+  for (const t of types) {
+    // An alias is the type it names, and has that type's methods.
+    const aliased = goAliasTarget(t, context);
+    if (aliased !== undefined) {
+      const via = aliased && resolveMethodOnType(
+        aliased.name, methodName, ref, context, confidence, resolvedBy, aliased.pkgDir, depth + 1,
+      );
+      if (via) return via;
+      if (!aliased) unplaced++;
+      continue;
+    }
+    for (const embedded of goEmbeddedTypes(t, context)) {
+      const via = resolveMethodOnType(
+        embedded.name, methodName, ref, context, confidence, resolvedBy, embedded.pkgDir, depth + 1,
+      );
+      if (via) return via;
+    }
+  }
+  // An alias of a type from outside the project (`type Ctx = context.Context`)
+  // or of no named type declares nothing here: the method is looked up by name,
+  // as it was before aliases had nodes.
+  return unplaced === types.length ? undefined : null;
+}
+
+const GO_ALIAS_TARGETS = new WeakMap<ResolutionContext, Map<string, { name: string; pkgDir: string } | null | undefined>>();
+
+/**
+ * The type a Go alias names, with the directory of the package that declares
+ * it — `mvccpb.Event` for `type Event = mvccpb.Event`, `Local` for `type Ptr
+ * = *Local`, `List` for `type Items[T any] = List[T]` — read from the
+ * declaration, as an embedding is. Null for an alias of anything else: a type
+ * from outside the project's packages, a predeclared one, a `func(…)` or
+ * `map[…]…`. Undefined when the node is no alias: a struct, an interface, or a
+ * defined type (`type Dur int`), which declares a type of its own.
+ */
+function goAliasTarget(typeNode: Node, context: ResolutionContext): { name: string; pkgDir: string } | null | undefined {
+  if (typeNode.kind !== 'type_alias') return undefined;
+  let memo = GO_ALIAS_TARGETS.get(context);
+  if (!memo) GO_ALIAS_TARGETS.set(context, (memo = new Map()));
+  if (memo.has(typeNode.id)) return memo.get(typeNode.id);
+  const lines = context.getFileLines?.(typeNode.filePath) ?? context.readFile(typeNode.filePath)?.split(/\r?\n/) ?? [];
+  // From the alias's name, where the node starts, to the end of its type.
+  const decl = lines
+    .slice(Math.max(0, typeNode.startLine - 1), typeNode.endLine ?? typeNode.startLine)
+    .map((l, i) => (i === 0 ? l.slice(typeNode.startColumn ?? 0) : l).replace(/\/\/.*$/, '').replace(/\/\*.*?\*\//g, ''))
+    .join(' ');
+  // `Name =` or `Name[T any] =`; a defined type has no `=` there.
+  const head = /^\s*[A-Za-z_]\w*\s*(?:\[[^\]]*\])?\s*=/.exec(decl);
+  // `T`, `*T`, `pkg.T`, each perhaps with type arguments.
+  const m = head && /^\s*(?:\*\s*)?([A-Za-z_]\w*)(?:\s*\.\s*([A-Za-z_]\w*))?\s*(?:\[.*\])?\s*;?\s*$/.exec(decl.slice(head[0].length));
+  let target: { name: string; pkgDir: string } | null | undefined;
+  if (m) {
+    const pkgDir = m[2] ? goImportPackageDir(m[1]!, typeNode.filePath, context) : goPackageDir(typeNode.filePath);
+    const name = m[2] ?? m[1]!;
+    target = pkgDir == null || (!m[2] && GO_BUILTIN_FIELD_TYPES.has(name)) ? null : { name, pkgDir };
+  } else {
+    target = head ? null : undefined;
+  }
+  memo.set(typeNode.id, target);
+  return target;
+}
+
+/** The declarations of Go type `typeName` in the package at directory `pkgDir`. */
+function goPackageTypes(typeName: string, pkgDir: string, context: ResolutionContext): Node[] {
+  return context.getNodesByName(typeName).filter(
+    (n) => n.language === 'go' && GO_TYPE_KINDS.has(n.kind) && goPackageDir(n.filePath) === pkgDir
+  );
+}
+
+const GO_EMBEDS = new WeakMap<ResolutionContext, Map<string, Array<{ name: string; pkgDir: string }>>>();
+
+/**
+ * The project types a Go struct or interface embeds, read from its own
+ * declaration — a member that is nothing but a type (`BaseAPI`,
+ * `*cached.BaseManager`, `ReadView`, optionally tagged), one per line or
+ * `;`-separated (`type EphemeralKV struct{ RemoteKV }`) — each with the
+ * directory of the package that declares it. An embedded type from outside
+ * the module (`suite.Suite`, `sync.Mutex`) has no project methods and is left
+ * out, as is anything whose package can't be told.
+ */
+function goEmbeddedTypes(typeNode: Node, context: ResolutionContext): Array<{ name: string; pkgDir: string }> {
+  let memo = GO_EMBEDS.get(context);
+  if (!memo) GO_EMBEDS.set(context, (memo = new Map()));
+  const hit = memo.get(typeNode.id);
+  if (hit) return hit;
+  const embedded: Array<{ name: string; pkgDir: string }> = [];
+  const lines = context.getFileLines?.(typeNode.filePath) ?? context.readFile(typeNode.filePath)?.split(/\r?\n/) ?? [];
+  const decl = lines
+    .slice(Math.max(0, typeNode.startLine - 1), typeNode.endLine ?? typeNode.startLine)
+    .map((l) => l.replace(/\/\/.*$/, '').replace(/\/\*.*?\*\//g, ''))
+    .join('\n');
+  const open = decl.indexOf('{');
+  const close = decl.lastIndexOf('}');
+  if (open >= 0 && close > open) {
+    let body = decl.slice(open + 1, close);
+    // Members of a nested anonymous struct are not this type's.
+    while (/\{[^{}]*\}/.test(body)) body = body.replace(/\{[^{}]*\}/g, '');
+    for (const member of body.split(/[\n;]/)) {
+      const m = /^\s*\*?\s*([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?\s*(?:\[[^\]]*\])?\s*(?:`[^`]*`|"[^"]*")?\s*$/.exec(member);
+      if (!m) continue;
+      const pkgDir = m[2] ? goImportPackageDir(m[1]!, typeNode.filePath, context) : goPackageDir(typeNode.filePath);
+      if (pkgDir == null) continue;
+      embedded.push({ name: m[2] ?? m[1]!, pkgDir });
+    }
+  }
+  memo.set(typeNode.id, embedded);
+  return embedded;
+}
+
+/**
+ * A Go call made through a type assertion — `srv.(KVServer).Range(ctx, in)`,
+ * `c.Reader.(*pipe).Close()`, `v.(storage.Store).Fetch(k)` — calls a method of
+ * the asserted type: its own, the one its interface declares, or one embedding
+ * promotes into it. The call reaches the resolver by its bare name, at the
+ * column where its receiver expression starts, and name matching took any
+ * method of that name: every gRPC handler etcd generates went to the
+ * `UnimplementedKVServer` stub beside the `KVServer` interface. The type is
+ * the one Go finds: in the call's own package or a package it dot-imports for
+ * a bare name, in the imported package for a qualified one, and an alias is
+ * the type it names. A type found in none — one from outside the project
+ * (`http.Flusher`), a predeclared one (`error`) — an alias of such a type, or
+ * a type literal (`interface{ Flush() }`) links nothing.
+ * Undefined when the call is not made through an assertion.
+ */
+export function matchGoAssertedCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null | undefined {
+  if (ref.language !== 'go' || ref.referenceKind !== 'calls' || !/^[A-Za-z_]\w*$/.test(ref.referenceName)) return undefined;
+  const asserted = goAssertedType(ref, context);
+  if (asserted === undefined) return undefined;
+  // `KVServer`, `*pipe`, `storage.Store`, `*List[int]`: anything else is a type literal.
+  const type = /^\*?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[\s\S]*\])?$/.exec(asserted);
+  if (!type) return null;
+  const [, qualifier, typeName] = type;
+  const declares = (dir: string | null | undefined): dir is string => !!dir && goPackageTypes(typeName!, dir, context).length > 0;
+  const dir = qualifier !== undefined
+    ? goImportPackageDir(qualifier, ref.filePath, context)
+    : [goPackageDir(ref.filePath), ...goDotImportDirs(ref.filePath, context)].find(declares);
+  if (!declares(dir)) return null;
+  // An alias of a type from outside the project (`type Ctx = context.Context`)
+  // has that type's methods, none the project declares.
+  if (goPackageTypes(typeName!, dir, context).every((t) => goAliasTarget(t, context) === null)) return null;
+  return resolveMethodOnType(typeName!, ref.referenceName, ref, context, 0.9, 'instance-method', dir);
+}
+
+/** How many lines past a Go call's first its chain is read on. */
+const GO_CHAIN_LINES = 30;
+
+/**
+ * The type a Go call's receiver is asserted to, as written (`KVServer`,
+ * `*pipe`, `storage.Store`). Every call of a chain records the chain's start,
+ * so the call is a `.name(…)` link of the chain read from there, and the link
+ * before it is the assertion. Two links of one name in a chain
+ * (`b.(*Builder).Add(1).Add(2)`) are told apart by nothing, and both are taken
+ * for the one made through the assertion: that call is there either way.
+ * Undefined when no link of the name follows an assertion, or no chain
+ * starts at the column.
+ */
+function goAssertedType(ref: UnresolvedRef, context: ResolutionContext): string | undefined {
+  const lines = context.getFileLines?.(ref.filePath) ?? context.readFile(ref.filePath)?.split(/\r?\n/);
+  const line = lines?.[ref.line - 1];
+  if (!lines || line === undefined || ref.column >= line.length) return undefined;
+  // Most calls through an expression assert nothing: no `.(` after the
+  // column, nor a chain that goes on past the line.
+  if (line.indexOf('.(', ref.column) < 0 && !/\.\s*$/.test(line)) return undefined;
+  const links = goChainLinks(lines.slice(ref.line - 1, ref.line + GO_CHAIN_LINES).join('\n'), ref.column);
+  for (let k = 1; k + 1 < links.length; k++) {
+    if (links[k - 1]!.kind === 'assert' && links[k]!.kind === 'select' && links[k]!.text === ref.referenceName &&
+        links[k + 1]!.kind === 'call') return links[k - 1]!.text;
+  }
+  return undefined;
+}
+
+interface GoChainLink {
+  kind: 'operand' | 'select' | 'assert' | 'call' | 'index';
+  /** An operand's or selector's name, an assertion's type. */
+  text: string;
+}
 
-      // Same-file candidates first, so a score tie (`score > bestScore` keeps
-      // the first seen) resolves to the call site's own file rather than the
-      // first-indexed duplicate (#1079).
-      for (const method of preferCallSiteFile(targetMethods, ref.filePath)) {
-        const classWords = splitCamelCase(method.qualifiedName);
-        let score = receiverWords.filter(w =>
-          classWords.some(cw => cw.toLowerCase() === w.toLowerCase())
-        ).length;
-        // Bonus for same language
-        if (method.language === ref.language) score += 1;
-        if (score > bestScore) {
-          bestScore = score;
-          bestMatch = method;
-        }
-      }
+/**
+ * The links of the Go expression that starts at `start`: its operand (a name
+ * or a parenthesized expression), then each selector, type assertion, call
+ * and index. A line break ends it, except right after a `.`, where Go
+ * inserts no semicolon.
+ */
+function goChainLinks(text: string, start: number): GoChainLink[] {
+  const links: GoChainLink[] = [];
+  const NAME = /[A-Za-z_]\w*/y;
+  let i = start;
+  const name = (): string | null => {
+    NAME.lastIndex = i;
+    const m = NAME.exec(text);
+    if (m) i += m[0].length;
+    return m ? m[0] : null;
+  };
+  const group = (): string | null => {
+    const close = goClosingBracket(text, i);
+    if (close < 0) return null;
+    const inner = text.slice(i + 1, close);
+    i = close + 1;
+    return inner;
+  };
+  const operand = text[i] === '(' ? group() : name();
+  if (operand === null) return links;
+  links.push({ kind: 'operand', text: operand });
+  for (;;) {
+    while (text[i] === ' ' || text[i] === '\t') i++;
+    if (text[i] === '.') {
+      i++;
+      while (i < text.length && WHITESPACE.test(text[i]!)) i++;
+      const type = text[i] === '(' ? group() : null;
+      const member = type === null ? name() : null;
+      if (type !== null) links.push({ kind: 'assert', text: type.trim() });
+      else if (member !== null) links.push({ kind: 'select', text: member });
+      else break;
+    } else if (text[i] === '(' || text[i] === '[') {
+      // A call whose arguments run past what was read is still a call.
+      links.push({ kind: text[i] === '(' ? 'call' : 'index', text: '' });
+      if (group() === null) break;
+    } else break;
+  }
+  return links;
+}
 
-      if (bestMatch && bestScore >= 2) {
-        return {
-          original: ref,
-          targetNodeId: bestMatch.id,
-          confidence: 0.65,
-          resolvedBy: 'instance-method',
-        };
-      }
-    }
-    return null;
-    });
-    if (strat3) return strat3;
+/** The bracket closing the one at `open`, past Go strings, runes and comments; -1 when it does not close. */
+function goClosingBracket(text: string, open: number): number {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    const c = text[i]!;
+    if (c === '"' || c === '\'') {
+      for (i++; i < text.length && text[i] !== c && text[i] !== '\n'; i++) if (text[i] === '\\') i++;
+    } else if (c === '`') {
+      i = text.indexOf('`', i + 1);
+      if (i < 0) return -1;
+    } else if (c === '/' && text[i + 1] === '/') {
+      i = text.indexOf('\n', i);
+      if (i < 0) return -1;
+    } else if (c === '/' && text[i + 1] === '*') {
+      i = text.indexOf('*/', i + 2);
+      if (i < 0) return -1;
+      i++;
+    } else if (c === '(' || c === '[' || c === '{') depth++;
+    else if ((c === ')' || c === ']' || c === '}') && --depth === 0) return i;
   }
+  return -1;
+}
 
-  return null;
+const GO_DOT_IMPORTS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/** The project packages a Go file dot-imports (`import . "example.com/app/storage"`), by directory: their names it reads bare. */
+function goDotImportDirs(filePath: string, context: ResolutionContext): string[] {
+  let memo = GO_DOT_IMPORTS.get(context);
+  if (!memo) GO_DOT_IMPORTS.set(context, (memo = new Map()));
+  let dirs = memo.get(filePath);
+  if (dirs) return dirs;
+  dirs = [];
+  for (const line of context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? []) {
+    // The imports come before any other declaration.
+    if (/^(?:func|type|var|const)\b/.test(line)) break;
+    const dot = /^\s*(?:import\s+)?\.\s+"([^"]+)"/.exec(line);
+    const dir = dot ? context.getGoPackageDir?.(dot[1]!, filePath) : null;
+    if (dir) dirs.push(dir);
+  }
+  memo.set(filePath, dirs);
+  return dirs;
 }
 
 /** Go builtin/primitive field types that can never carry a project method. */
@@ -3314,15 +11725,25 @@ function matchGoFieldChainCall(
   if (segs.length !== 2 || !segs[0] || !segs[1]) return null;
   const [base, field] = segs;
 
-  const baseType = inferLocalReceiverType(base!, ref, context);
+  const decl: { raw?: string } = {};
+  const baseType = inferLocalReceiverType(base!, ref, context, decl);
   if (!baseType) return null;
 
   const fieldEsc = field!.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const fieldTypeRe = new RegExp(`\\b${fieldEsc}\\s+\\*?\\[?\\]?([A-Za-z_][\\w.]*)`);
 
-  const structs = preferCallSiteFile(context.getNodesByName(baseType), ref.filePath).filter(
+  let structs = context.getNodesByName(baseType).filter(
     (n) => (n.kind === 'struct' || n.kind === 'class') && n.language === 'go'
   );
+  // The struct the declaring package has is the one the base's type means (a
+  // method receiver's type is always the call site's own package's): Go type
+  // names repeat across packages — harbor has a `daoTestSuite` in every DAO
+  // package — and another package's same-named struct with a same-named
+  // field is not this one (#2323).
+  const basePkg = goDeclaredTypePackage(decl.raw, ref.filePath, context);
+  const declared = structs.filter((n) => goPackageDir(n.filePath) === basePkg);
+  if (declared.length > 0) structs = declared;
+  structs = preferCallSiteFile(structs, ref.filePath);
   for (const s of structs) {
     const source = context.readFile(s.filePath);
     if (!source) continue;
@@ -3337,23 +11758,19 @@ function matchGoFieldChainCall(
       const m = line.match(fieldTypeRe);
       if (!m || !m[1]) continue;
       const rawType = m[1];
+      // The package that declares the field's type: the struct's own for a
+      // bare type name, the imported one for a package-qualified name.
+      let pkgDir = goPackageDir(s.filePath);
       // A package-qualified field type (`http.Handler`, `sql.DB`) is only
-      // followed when the package is IN-MODULE: stripping the qualifier and
-      // matching the bare name would conflate a stdlib/third-party type with
-      // any same-named project type — on chi, `handler http.Handler` bound
-      // to an example app's unrelated local `Handler`. That is the exact
-      // fabrication this matcher exists to prevent (#1276).
+      // followed when the package is one of the project's: stripping the
+      // qualifier and matching the bare name would conflate a stdlib or
+      // third-party type with any same-named project type — on chi, `handler
+      // http.Handler` bound to an example app's unrelated local `Handler`.
+      // That is the exact fabrication this matcher exists to prevent (#1276).
       if (rawType.includes('.')) {
-        const pkg = rawType.split('.')[0]!;
-        const mod = context.getGoModule?.();
-        const imp = context
-          .getImportMappings(s.filePath, 'go')
-          .find((i) => i.localName === pkg);
-        const inModule =
-          !!mod &&
-          !!imp &&
-          (imp.source === mod.modulePath || imp.source.startsWith(mod.modulePath + '/'));
-        if (!inModule) continue;
+        const imported = goImportPackageDir(rawType.split('.')[0]!, s.filePath, context);
+        if (imported == null) continue;
+        pkgDir = imported;
       }
       // Unexported (lowercase) types are idiomatic Go and stay eligible —
       // chi's `mx.tree.FindRoute()` chains through `tree *node`. A
@@ -3361,7 +11778,7 @@ function matchGoFieldChainCall(
       // validated `<type>::<method>` match.
       const fieldType = rawType.split('.').pop();
       if (!fieldType || !/^[A-Za-z_]/.test(fieldType) || GO_BUILTIN_FIELD_TYPES.has(fieldType)) continue;
-      const resolved = resolveMethodOnType(fieldType, methodName, ref, context, 0.85, 'instance-method');
+      const resolved = resolveMethodOnType(fieldType, methodName, ref, context, 0.85, 'instance-method', pkgDir);
       if (resolved) return resolved;
     }
   }
@@ -3717,8 +12134,11 @@ function matchTsThisFieldCall(
   context: ResolutionContext,
 ): ResolvedRef | null {
   if (!field || field.includes('.')) return null;
-  const caller = context.getNodeById?.(ref.fromNodeId);
-  if (!caller) return null;
+  const written = context.getNodeById?.(ref.fromNodeId);
+  if (!written) return null;
+  // An arrow member of an object literal written in a method has that
+  // method's `this` (#2300).
+  const caller = thisScopeCaller(written, context);
   const sep = caller.qualifiedName.lastIndexOf('::');
   if (sep <= 0) return null; // not inside a class
   const owner = caller.qualifiedName.slice(0, sep).split('::').pop();
@@ -3897,6 +12317,293 @@ function matchDestructuredStoreCall(ref: UnresolvedRef, context: ResolutionConte
   return null;
 }
 
+/**
+ * A bare call through a name destructured from a call's result — a composable
+ * or custom hook, `const { getDefaultActivityRoute } = useDefaultActivity()`
+ * (mealie), `const { login } = useAuth()` — is the function the callee returns
+ * under that key: one declared in the callee's own body, else a top-level one
+ * of the callee's module (returned as `{ getDefaultActivityRoute, … }`). The
+ * callee is resolved through the file's imports (or found in the same file),
+ * and its source must return the key; a later declaration of the name at the
+ * call's scope shadows the binding. The local binding otherwise ruled out
+ * every cross-file candidate, so the call resolved to nothing.
+ *
+ * The file is read once (#2334): stripping and scanning all the text above
+ * each call took time in the square of the file's size — seconds for each
+ * bundled library (pdf.js, d3) a project ships. The text above a call,
+ * blanked on its own, is the file's blanked code up to the call: blanking
+ * reads past a character only for a comment opener's second character (a
+ * call's name never starts with one) and for the `/` that closes a regex
+ * literal (calls inside one: matchDestructuredCallInLiteral). Its bindings
+ * are then the file's that end at or before the call: the pattern finds a
+ * statement the same way wherever the two texts agree up to its `(`, and
+ * one running past the call holds no `{` followed by a `(` to start another.
+ */
+function matchDestructuredCallResult(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const source = context.readFile(ref.filePath);
+  if (!source) return null;
+  const file = destructuredBindings(ref.filePath, source, context);
+  if (!file) return null;
+  const cut = destructuredCallOffset(file, source, ref);
+  if (cut < 0) return matchDestructuredCallAbove(ref, source, context);
+  const literal = regexLiteralAround(file.literals, cut);
+  if (literal >= 0) {
+    const depth = file.literalDepths[literal]!;
+    return depth < 0 ? matchDestructuredCallAbove(ref, source, context)
+      : matchDestructuredCallInLiteral(ref, file, file.literals[2 * literal]!, depth, cut, context);
+  }
+  const bindings = file.byName.get(ref.referenceName) ?? [];
+  // The nearest binding above the call whose block is still open at the call.
+  for (let i = bindings.length - 1; i >= 0; i--) {
+    const { binding, key } = bindings[i]!;
+    if (binding.end > cut || binding.scopeEnd < cut) continue;
+    return destructuredCallTarget(binding.callee, key, file.code.slice(binding.end, cut), ref, context);
+  }
+  return null;
+}
+
+/** A `const { … } = f(…)` statement. */
+interface DestructuredBinding {
+  /** Just past its `(`. */
+  end: number;
+  /** The function it calls. */
+  callee: string;
+  /** The `{` of the block it sits in: its place on the stack of open blocks (-1 at top level), and where its `}` is (Infinity if nowhere). */
+  depth: number;
+  scopeEnd: number;
+}
+
+/** What matchDestructuredCallResult needs of a file, read once. */
+interface DestructuredFile {
+  /** The file with comments and string contents blanked. */
+  code: string;
+  /** Where each line starts. */
+  lineStarts: number[];
+  /** Each name a binding introduces → those bindings, in file order, with the key it reads. */
+  byName: Map<string, Array<{ binding: DestructuredBinding; key: string }>>;
+  /** The opening and closing offset of each span the blanking read as a regex literal, in order. */
+  literals: number[];
+  /** Per literal: how many blocks are open at its `/`, or -1 when a binding statement could run across that `/`. */
+  literalDepths: number[];
+}
+
+const DESTRUCTURED_BINDING = /\b(?:const|let|var)\s*\{([^{}]*)\}\s*=\s*(?:await\s+)?([A-Za-z_$][\w$]*)\s*(?:<[^<>()]*>)?\s*\(/g;
+/** Per context: the files matchDestructuredCallResult read last (calls arrive file by file); null for one without destructuring. */
+const DESTRUCTURED_FILES = new WeakMap<ResolutionContext, Map<string, DestructuredFile | null>>();
+const DESTRUCTURED_FILES_KEEP = 16;
+
+function destructuredBindings(filePath: string, source: string, context: ResolutionContext): DestructuredFile | null {
+  let files = DESTRUCTURED_FILES.get(context);
+  if (!files) DESTRUCTURED_FILES.set(context, (files = new Map()));
+  let file = files.get(filePath);
+  if (file !== undefined) return file;
+  file = /\b(?:const|let|var)\s*\{/.test(source) ? readDestructuredBindings(source) : null;
+  if (files.size >= DESTRUCTURED_FILES_KEEP) files.delete(files.keys().next().value!);
+  files.set(filePath, file);
+  return file;
+}
+
+function readDestructuredBindings(source: string): DestructuredFile {
+  const literals: number[] = [];
+  const code = blankStringContents(stripCommentsForRegex(source, 'typescript'), literals);
+  const lineStarts = [0];
+  for (let at = source.indexOf('\n'); at !== -1; at = source.indexOf('\n', at + 1)) lineStarts.push(at + 1);
+  const found = Array.from(code.matchAll(DESTRUCTURED_BINDING), (m) => ({
+    index: m.index!,
+    binding: { end: m.index! + m[0].length, callee: m[2]!, depth: -1, scopeEnd: Infinity },
+    keys: destructuredKeys(m[1]!),
+  }));
+  // The `{` after every `const`, `let` and `var`: where a binding statement's pattern opens.
+  const patterns = new Set(Array.from(code.matchAll(/\b(?:const|let|var)\s*\{/g), (m) => m.index! + m[0].length - 1));
+  const literalDepths: number[] = [];
+  const stack: number[] = [];
+  const scoped = new Map<number, DestructuredBinding[]>();
+  let lastBrace = -1;
+  let lastBracket = -1; // the last `<`, `>`, `(` or `)`
+  for (let i = 0, next = 0, literal = 0; i < code.length; i++) {
+    if (found[next]?.index === i) {
+      const { binding } = found[next++]!;
+      // In scope until the `}` that closes the block it sits in.
+      binding.depth = stack.length - 1;
+      const open = stack[binding.depth];
+      if (open !== undefined) {
+        const list = scoped.get(open);
+        if (list) list.push(binding);
+        else scoped.set(open, [binding]);
+      }
+    }
+    if (literals[2 * literal] === i) {
+      // A binding statement holds a `/` only in its pattern `{ … }` or its type arguments `< … >`.
+      literalDepths.push(patterns.has(lastBrace) || code[lastBracket] === '<' ? -1 : stack.length);
+      literal++;
+    }
+    const c = code.charCodeAt(i);
+    if (c === 123 /* { */) {
+      stack.push(i);
+      lastBrace = i;
+    } else if (c === 125 /* } */) {
+      lastBrace = i;
+      const open = stack.pop();
+      for (const binding of (open !== undefined && scoped.get(open)) || []) binding.scopeEnd = i;
+    } else if (c === 60 /* < */ || c === 62 /* > */ || c === 40 /* ( */ || c === 41 /* ) */) {
+      lastBracket = i;
+    }
+  }
+  const byName = new Map<string, Array<{ binding: DestructuredBinding; key: string }>>();
+  for (const { binding, keys } of found) {
+    for (const [name, key] of keys) {
+      const list = byName.get(name);
+      if (list) list.push({ binding, key });
+      else byName.set(name, [{ binding, key }]);
+    }
+  }
+  return { code, lineStarts, byName, literals, literalDepths };
+}
+
+/** Each name a destructuring pattern binds → the key it reads (`{ a, b: c = 1 }`); a later entry for a name wins. */
+function destructuredKeys(pattern: string): Map<string, string> {
+  const keys = new Map<string, string>();
+  for (const part of pattern.split(',')) {
+    const [k, v] = part.split(':').map((x) => x.trim().replace(/\s*=.*$/, ''));
+    if (/^[A-Za-z_$][\w$]*$/.test(k ?? '')) keys.set(v ?? k!, k!);
+  }
+  return keys;
+}
+
+/**
+ * Where the text above a call ends in `source` (that text is
+ * `source.slice(0, cut)`), or -1 when the call's line or column lies outside
+ * the file, or that text ends in a `/` that opens a comment in the file.
+ */
+function destructuredCallOffset(file: DestructuredFile, source: string, ref: UnresolvedRef): number {
+  const { line, column } = ref;
+  const starts = file.lineStarts;
+  if (!Number.isInteger(line) || !Number.isInteger(column) || line < 1 || line > starts.length || column < 0) return -1;
+  const cut = Math.min(starts[line - 1]! + column, line < starts.length ? starts[line]! - 1 : source.length);
+  return source[cut - 1] === '/' && (source[cut] === '/' || source[cut] === '*') ? -1 : cut;
+}
+
+/** The regex literal (its index) that opens before `cut` and closes at or after it, or -1. */
+function regexLiteralAround(literals: number[], cut: number): number {
+  let lo = 0;
+  let hi = literals.length / 2;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (literals[2 * mid]! < cut) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo > 0 && literals[2 * lo - 1]! >= cut ? lo - 1 : -1;
+}
+
+/**
+ * matchDestructuredCallResult for a call inside what the file's blanking read
+ * as a regex literal opening at `start`. Blanked on its own, the text above
+ * the call reads that `/` as division: it is the file's code up to there,
+ * then `tail` — the rest, blanked as text of its own. No binding statement
+ * runs across the `/` (literalDepths), so the call sees the file's bindings
+ * that end before it, then any in `tail`; and of the `depth` blocks open at
+ * the `/`, those `tail` does not close.
+ */
+function matchDestructuredCallInLiteral(
+  ref: UnresolvedRef, file: DestructuredFile, start: number, depth: number, cut: number, context: ResolutionContext
+): ResolvedRef | null {
+  const tail = blankStringContents(file.code.slice(start, cut));
+  const atCall = blocksThrough(tail, depth);
+  for (const m of Array.from(tail.matchAll(DESTRUCTURED_BINDING)).reverse()) {
+    const key = destructuredKeys(m[1]!).get(ref.referenceName);
+    if (!key) continue;
+    const atBinding = blocksThrough(tail.slice(0, m.index), depth);
+    const block = atBinding.opened[atBinding.opened.length - 1];
+    if (block !== undefined ? !atCall.opened.includes(block) : atBinding.enclosing > atCall.enclosing) continue;
+    return destructuredCallTarget(m[2]!, key, tail.slice(m.index! + m[0].length), ref, context);
+  }
+  const bindings = file.byName.get(ref.referenceName) ?? [];
+  for (let i = bindings.length - 1; i >= 0; i--) {
+    const { binding, key } = bindings[i]!;
+    if (binding.end > start) continue;
+    if (binding.depth >= 0 && (binding.scopeEnd < start || binding.depth >= atCall.enclosing)) continue;
+    return destructuredCallTarget(binding.callee, key, file.code.slice(binding.end, start) + tail, ref, context);
+  }
+  return null;
+}
+
+/** After `text`'s braces: how many of the `enclosing` blocks open before it are still open, and which it opened are. */
+function blocksThrough(text: string, enclosing: number): { enclosing: number; opened: number[] } {
+  const opened: number[] = [];
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 123 /* { */) opened.push(i);
+    else if (c === 125 /* } */) {
+      if (opened.length > 0) opened.pop();
+      else if (enclosing > 0) enclosing--;
+    }
+  }
+  return { enclosing, opened };
+}
+
+/** matchDestructuredCallResult by scanning the text above the call, where the whole file's reading may not hold. */
+function matchDestructuredCallAbove(ref: UnresolvedRef, source: string, context: ResolutionContext): ResolvedRef | null {
+  const lines = source.split('\n');
+  const before = lines.slice(0, ref.line - 1).concat(lines[ref.line - 1]?.slice(0, ref.column) ?? '').join('\n');
+  const code = blankStringContents(stripCommentsForRegex(before, 'typescript'));
+  const stackAt = (end: number): number[] => {
+    const stack: number[] = [];
+    for (let i = 0; i < end; i++) {
+      if (code[i] === '{') stack.push(i);
+      else if (code[i] === '}') stack.pop();
+    }
+    return stack;
+  };
+  const callScope = stackAt(code.length);
+  for (const m of [...code.matchAll(DESTRUCTURED_BINDING)].reverse()) {
+    const key = destructuredKeys(m[1]!).get(ref.referenceName);
+    if (!key) continue;
+    if (!stackAt(m.index!).every((pos, i) => callScope[i] === pos)) continue;
+    return destructuredCallTarget(m[2]!, key, code.slice(m.index! + m[0].length), ref, context);
+  }
+  return null;
+}
+
+/**
+ * The function `calleeName` returns under `key`, unless a declaration in
+ * `rest` (the code between the binding and the call) shadows the binding.
+ * The callee is resolved first: most callees (`require`) return no such
+ * function, and then the shadowing scan is not needed.
+ */
+function destructuredCallTarget(calleeName: string, key: string, rest: string, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const target = destructuredKeyTarget(calleeName, key, ref, context);
+  if (!target) return null;
+  const name = ref.referenceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${name}\\b|\\{[^}]*\\b${name}\\b)`).test(rest) ? null : target;
+}
+
+/** The function `calleeName` returns under `key`: one declared in its body, else a top-level one of its module. */
+function destructuredKeyTarget(calleeName: string, key: string, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const imported = context.resolveImport?.({ ...ref, referenceName: calleeName, referenceKind: 'calls' });
+  // Through the import; else the same file's; else the one function of that
+  // name in the project (an alias the import resolver can't follow, like
+  // Nuxt's `~/composables/…`) — the returned key is checked below either way.
+  const holders = context.getNodesByName(calleeName).filter((n) =>
+    (n.kind === 'function' || n.kind === 'constant' || n.kind === 'variable') && sameLanguageFamily(n.language, ref.language));
+  const callee = (imported && context.getNodeById?.(imported.targetNodeId)) ??
+    holders.find((n) => n.filePath === ref.filePath) ??
+    (holders.length === 1 ? holders[0] : undefined);
+  if (!callee || !sameLanguageFamily(callee.language, ref.language)) return null;
+  const calleeText = (context.getFileLines?.(callee.filePath) ?? context.readFile(callee.filePath)?.split('\n') ?? [])
+    .slice(callee.startLine - 1, callee.endLine).join('\n');
+  if (!new RegExp(`\\breturn\\s*\\{[^]*?\\b${key}\\b`).test(calleeText)) return null;
+  const callable = (n: Node) => n.kind === 'function' || n.kind === 'method' || n.kind === 'constant' || n.kind === 'variable';
+  const inFile = context.getNodesInFile(callee.filePath);
+  const inner = inFile.filter((n) => n.name === key && callable(n) && n.id !== callee.id && rangeWithin(n, callee) &&
+    !inFile.some((f) => f.id !== callee.id && f.id !== n.id && (f.kind === 'function' || f.kind === 'method') &&
+      rangeWithin(f, callee) && rangeWithin(n, f) && !sameRange(f, n)));
+  const top = inner.length > 0 ? inner : inFile.filter((n) => n.name === key && callable(n) && !n.qualifiedName.includes('::') &&
+    !inFile.some((f) => (f.kind === 'function' || f.kind === 'method') && f.id !== n.id && rangeWithin(n, f) && !sameRange(f, n)));
+  const target = top.sort((a, b) => Number(b.kind === 'function') - Number(a.kind === 'function'))[0];
+  if (!target) return null;
+  return { original: ref, targetNodeId: target.id, confidence: 0.85, resolvedBy: 'instance-method' };
+}
+
 /** Bound action names need not have a same-named definition (selectors may
  * rename them). The resolver's symbol-existence prefilter must allow them. */
 export function matchJsStoreBindingCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
@@ -3905,9 +12612,11 @@ export function matchJsStoreBindingCall(ref: UnresolvedRef, context: ResolutionC
 }
 
 /** A qualified untyped chain is useful source evidence, not permission to
- * infer a property type. Framework resolution runs before this guard. */
+ * infer a property type. Framework resolution runs before this guard. Vue,
+ * Svelte and Astro files keep resolving them: there `api.groupReports.getAll()`
+ * reaches its API client class far more often than a wrong namesake. */
 export function isUnresolvedJsMemberCall(ref: UnresolvedRef): boolean {
-  return ref.referenceKind === 'calls' && JS_FAMILY.has(ref.language) &&
+  return ref.referenceKind === 'calls' && JS_TS.has(ref.language) &&
     !/^(?:this|window)\./.test(ref.referenceName) &&
     /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*){2,}$/.test(ref.referenceName);
 }
@@ -3973,7 +12682,8 @@ function importShadowedAt(name: string, ref: UnresolvedRef, context: ResolutionC
     return stack;
   };
   const scope = stackAt(code.length);
-  const declarations = new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${escaped}\\b|\\{[^}]*\\b${escaped}\\b)`, 'g');
+  // Not `\b`: there is no word boundary beside the `$` of `items$` or `$store`.
+  const declarations = new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${escaped}(?![\\w$])|\\{[^}]*(?<![\\w$])${escaped}(?![\\w$]))`, 'g');
   return [...code.matchAll(declarations)].some(m => stackAt(m.index!).every((p, i) => scope[i] === p));
 }
 
@@ -3981,8 +12691,8 @@ function importShadowedAt(name: string, ref: UnresolvedRef, context: ResolutionC
  * parentheses must not make the outer shadow invisible. Conservative when a
  * parameter's type mentions the same name: leave that call unresolved. */
 function hasParameterBinding(code: string, escapedName: string): boolean {
-  const name = new RegExp(`\\b${escapedName}\\b`);
-  if (new RegExp(`\\b${escapedName}\\s*=>`).test(code)) return true;
+  const name = new RegExp(`(?<![\\w$])${escapedName}(?![\\w$])`);
+  if (new RegExp(`(?<![\\w$])${escapedName}\\s*=>`).test(code)) return true;
   for (let i = 0; i < code.length; i++) {
     if (code[i] !== '(' || /\b(?:if|while|for|switch|with)\s*$/.test(code.slice(0, i))) continue;
     let depth = 1, j = i + 1;
@@ -3999,6 +12709,75 @@ function hasParameterBinding(code: string, escapedName: string): boolean {
 /**
  * Split a camelCase or PascalCase string into words.
  */
+/**
+ * Whether a receiver written as `Name` is a type in `language`'s conventions.
+ * Not in Go (an exported package variable is `FormPost`), nor C / C++ / Rust
+ * (their type paths use `::`); in Pascal every identifier is capitalized, so
+ * only Delphi's type prefixes (`TFoo`, `EFoo`, `IFoo`) and `Exception` count —
+ * `AWebRequest` / `LRequest` are a parameter and a local.
+ */
+function namesExternalType(receiver: string, language: string): boolean {
+  if (!/^[A-Z][A-Za-z0-9_]*$/.test(receiver)) return false;
+  if (language === 'pascal') return /^(?:[TEI][A-Z]\w*|Exception)$/.test(receiver);
+  // Rust: `Vec::new()`, `String::from(…)`, `Default::default()` — but `Self::` is the impl's own type,
+  // and a SCREAMING_CASE receiver (`REQ_ID.scope(…)`) a static.
+  if (language === 'rust') return receiver !== 'Self' && /[a-z]/.test(receiver);
+  return !['go', 'c', 'cpp', 'cuda', 'metal'].includes(language);
+}
+
+/**
+ * Languages whose receivers nothing types, where a unique method name alone
+ * is no evidence: CFML's `server.keyExists()` is the struct member function,
+ * not the one component method named `keyExists`; Objective-C's
+ * `image.respondsToSelector:` is NSObject's, not a proxy class's override;
+ * PHP's `$request->has()` is the framework request's, not a settings
+ * service's.
+ */
+const UNTYPED_RECEIVER_LANGUAGES: ReadonlySet<string> = new Set(['ruby', 'cfml', 'cfscript', 'objc', 'php']);
+
+/**
+ * Lua's standard and host libraries: a call through one of these tables is
+ * the library's, never the one project method that shares its name (busted's
+ * `assert.truthy` went to a condition helper 987 times, `string.find` to a
+ * picker's `find`, Neovim's `vim.split` to a build module's).
+ */
+const LUA_LIBRARY_TABLES: ReadonlySet<string> = new Set([
+  'string', 'table', 'math', 'io', 'os', 'coroutine', 'debug', 'utf8', 'package', 'bit', 'bit32', 'jit', 'ffi',
+  'vim', 'ngx', 'assert', 'spy', 'stub', 'mock', 'love',
+]);
+/** Lua string methods, reached with `s:find(…)` on any string. */
+const LUA_STRING_METHODS: ReadonlySet<string> = new Set([
+  'find', 'match', 'gmatch', 'gsub', 'sub', 'format', 'upper', 'lower', 'len', 'rep', 'byte', 'reverse',
+]);
+
+/**
+ * Whether a Lua call is a library's rather than `candidate`: through a library
+ * table the project doesn't patch itself (kong's globalpatches do define
+ * `ngx.sleep`), or a string method on a value.
+ */
+function isLuaLibraryCall(receiver: string, method: string, ref: UnresolvedRef, candidate: Node): boolean {
+  const root = receiver.split(/[.:]/)[0]!;
+  if (LUA_LIBRARY_TABLES.has(root)) return candidate.qualifiedName.split(/::|\./)[0] !== root;
+  return LUA_STRING_METHODS.has(method) && ref.referenceName.endsWith(`:${method}`);
+}
+
+/**
+ * Whether a receiver is named after the owner of `method`, case aside: the
+ * receiver's last segment is the owner's name (`cbsecurity` → CBSecurity), or
+ * they share a word of three letters or more (`web_push_request` →
+ * WebPushRequest, `executor1` → Executor, `decodedImage` → UIImage).
+ */
+function sharesReceiverWord(receiver: string, method: Node): boolean {
+  const cut = method.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return false;
+  const ownerQn = method.qualifiedName.slice(0, cut);
+  const flat = (w: string) => w.replace(/[^A-Za-z0-9]/g, '').replace(/\d+$/, '').toLowerCase();
+  if (flat(receiver.split('.').pop()!) === flat(ownerQn.split(/::|\./).pop()!)) return true;
+  // Two-letter words are class prefixes (`SD`, `NS`, `UI`), not names.
+  const owner = new Set(splitCamelCase(ownerQn).map(flat).filter((w) => w.length > 2));
+  return splitCamelCase(receiver).some((w) => owner.has(flat(w)));
+}
+
 function splitCamelCase(str: string): string[] {
   return str.replace(/([a-z])([A-Z])/g, '$1 $2')
     .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
@@ -4050,7 +12829,7 @@ function computePathProximity(filePath1: string, filePath2: string): number {
 function findBestMatch(
   ref: UnresolvedRef,
   candidates: Node[],
-  _context: ResolutionContext
+  context: ResolutionContext
 ): Node | null {
   // Prioritization rules:
   // 1. Same file > different file
@@ -4090,6 +12869,13 @@ function findBestMatch(
     // Directory proximity bonus — strongly prefer same module/package
     score += pathProximityFromDirs(refDirs, candidate.filePath);
 
+    // A VB.NET project compiles its own files: the caller's project weighs as
+    // much as the nearest a directory can be. staxrip's `New ColorHSL(…)` went
+    // to its AutoCrop tool's copy.
+    if (ref.language === 'vbnet' && candidate.language === 'vbnet' && sameVbProject(candidate.filePath, ref.filePath, context)) {
+      score += 80;
+    }
+
     // Language matching: strongly prefer same language, penalize cross-language
     if (candidate.language === ref.language) {
       score += 50;
@@ -4120,7 +12906,8 @@ function findBestMatch(
 
     // For decorator references (`@Foo`), prefer functions. Class
     // decorators (Python `@SomeClass`, Java annotation interfaces)
-    // also resolve here, hence the smaller class bonus.
+    // also resolve here, hence the smaller class bonus. (A Dart annotation,
+    // a constant or a constructor call, is matchDartAnnotation's.)
     if (ref.referenceKind === 'decorates') {
       if (candidate.kind === 'function' || candidate.kind === 'method') {
         score += 25;
@@ -4163,13 +12950,81 @@ export function matchFuzzy(
 
   // Filter to callable kinds only (function, method, class)
   const callableKinds = new Set(['function', 'method', 'class']);
-  const callableCandidates = candidates.filter((n) => callableKinds.has(n.kind))
+  const typeRef = isDotNetTypeRef(ref, context);
+  const rustBare = ref.language === 'rust' && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  const pythonShape = pythonCallShape(ref, context);
+  const javaBare = ref.language === 'java' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const dartBare = ref.language === 'dart' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName) && isReceiverLessDartCall(ref, context);
+  // A Dart type name — a declared type, a supertype, the `Color` of `Color.red` — is in scope as a call is, or through its import prefix.
+  const dartTypeRef = ref.language === 'dart' && (ref.referenceKind === 'references' || isInheritanceRef(ref)) && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const dartPrefix = dartTypeRef ? dartImportPrefixOf(ref, context) : null;
+  const kotlinCall = ref.language === 'kotlin' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const kotlinBare = kotlinCall && isReceiverLessKotlinCall(ref, context);
+  const rubyBare = ref.language === 'ruby' && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*[?!]?$/.test(ref.referenceName);
+  const cfmlBare = (ref.language === 'cfml' || ref.language === 'cfscript') && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  const vbReceiver = ref.language === 'vbnet' && (ref.referenceKind === 'calls' || ref.referenceKind === 'instantiates') && /^\w+$/.test(ref.referenceName)
+    ? vbReceiverOf(ref, context) : null;
+  const vbScoped = isVbScopedCall(ref, vbReceiver, context);
+  const vbUnqualified = isVbUnqualifiedName(ref, vbReceiver, context);
+  const objcShape = ref.language === 'objc' && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*:*(?:\w+:)*$/.test(ref.referenceName)
+    ? objcCallShape(ref, context) : null;
+  const csharpBare = ref.language === 'csharp' && (ref.referenceKind === 'calls' || ref.referenceKind === 'references') && /^[A-Za-z_]\w*$/.test(ref.referenceName);
+  const scalaBare = ref.language === 'scala' && ref.referenceKind === 'calls' && /^[A-Za-z_$][\w$]*$/.test(ref.referenceName);
+  const rustGoShape = (ref.language === 'rust' || ref.language === 'go') && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName)
+    ? rustGoCallShape(ref, context) : null;
+  const kotlinStdChain = ref.language === 'kotlin' && ref.referenceKind === 'calls' && KOTLIN_STD_METHODS.has(ref.referenceName)
+    ? kotlinChainReceiver(ref, context) : null;
+  const swiftShape = ref.language === 'swift' && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName)
+    ? swiftCallShape(ref, context) : null;
+  const phpSelf = phpSelfReceiver(ref, context);
+  // Names are case-sensitive in every language but a handful: Rust's
+  // `Bytes` is not the method `bytes`, Python's builtin `dir(…)` not a class
+  // `Dir`, halo's `type RsbuildConfig` not its local `rsbuildConfig`, a Java
+  // `Node` not a `node()`. Only PHP, Pascal/Delphi, CFML, COBOL and VB.NET
+  // resolve a name without regard to case, which is what this fallback's
+  // lowercase index is for.
+  const bareR = isBareRCall(ref, context);
+  const solidityBare = isReceiverLessSolidityCall(ref, context);
+  const callableCandidates = candidates.filter((n) => callableKinds.has(n.kind) && !(typeRef && !canNameInTypePosition(n)) &&
+    !(bareR && n.kind === 'method') &&
+    !(solidityBare && !isSolidityMemberInScope(n, ref, context)) &&
+    // `new …MockData()` makes an instance of a type; a method is never what it names.
+    !(ref.referenceKind === 'instantiates' && n.kind === 'method') &&
+    !(rustBare && !isRustNameInScope(n, ref, context)) &&
+    !(!CASE_INSENSITIVE_LANGUAGES.has(ref.language) && n.name !== ref.referenceName) &&
+    !(pythonShape && !fitsPythonCallShape(n, pythonShape, ref, context)) &&
+    !(javaBare && n.kind === 'method' && !isJavaMethodInScope(n, ref, context)) &&
+    !(dartBare && isDartMember(n) && !isDartMethodInScope(n, ref, context)) &&
+    !(ref.language === 'dart' && isDartConstructor(n, context)) &&
+    !((dartBare || dartTypeRef) && !isDartTopLevelVisible(n, ref, context, dartPrefix)) &&
+    // A Dart `extension on Color` is no `Color`, here as in exact matching:
+    // flutter_weather's `Color brighten(…)` in that extension names Flutter's.
+    dartExtensionDecl(n, context)?.named !== false &&
+    !(kotlinCall && !isKotlinTopLevelVisible(n, ref, context)) &&
+    !(kotlinBare && !isKotlinMemberReachable(n, ref, context)) &&
+    !isKotlinNumberBitwise(n, ref) &&
+    !(rubyBare && n.kind === 'method' && !isRubyMethodInScope(n, ref, context)) &&
+    !(cfmlBare && n.kind === 'method' && !isCfmlMethodInScope(n, ref, context)) &&
+    !(vbReceiver !== null && !isVbMemberReachable(n, vbReceiver)) &&
+    !(vbReceiver && !/^(?:me|mybase|myclass)$/i.test(vbReceiver) && !isVbTypeQualifiedBy(n, vbReceiver, ref.filePath, context)) &&
+    !(vbScoped && !isVbMemberInScope(n, ref, context)) &&
+    !(vbUnqualified && !isVbNestedTypeInScope(n, ref, context)) &&
+    !(objcShape === 'c-call' && OBJC_MEMBER_KINDS.has(n.kind)) &&
+    !(objcShape === 'self-send' && !isObjcSelfSendTarget(n, ref, context)) &&
+    !(objcShape === 'super-send' && !isObjcSelfSendTarget(n, ref, context, true)) &&
+    !(csharpBare && !isCsharpMemberInScope(n, ref, context)) &&
+    !(scalaBare && !isScalaMemberInScope(n, ref, context)) &&
+    !(rustGoShape && !isRustGoCallTarget(n, rustGoShape)) &&
+    !(kotlinStdChain !== null && !isKotlinStdChainTarget(n, kotlinStdChain)) &&
+    !(swiftShape && !isSwiftCallTarget(n, swiftShape, ref, context)) &&
+    !(phpSelf && (n.kind !== 'method' || !isPhpMethodInScope(n, ref, phpSelf, context))))
     .filter((n) => (ref.referenceKind !== 'references' && ref.referenceKind !== 'function_ref') ||
       sameLanguageFamily(n.language, ref.language));
 
   // Prefer same-language matches
   const sameLanguageCandidates = callableCandidates.filter(n => n.language === ref.language);
-  const finalCandidates = sameLanguageCandidates.length > 0 ? sameLanguageCandidates : callableCandidates;
+  const languageCandidates = sameLanguageCandidates.length > 0 ? sameLanguageCandidates : callableCandidates;
+  const finalCandidates = dartBare || (dartTypeRef && dartPrefix === null) ? preferOwnDartLibrary(languageCandidates, ref, context) : languageCandidates;
 
   // Both post-pipeline visibility guards (#1745 language-local + #1719 sealed
   // module). The sealed-module test rejects the survivor and never filters the
@@ -4191,8 +13046,9 @@ export function matchFuzzy(
     isVisibleAcrossFiles(finalCandidates[0]!, ref, context) &&
     isCrossFileReachable(finalCandidates[0]!, ref, context) &&
     !(isBareJsCall(ref, context) &&
-      (finalCandidates[0]!.kind === 'method' ||
+      (TYPE_MEMBER_KINDS.has(finalCandidates[0]!.kind) ||
         (finalCandidates[0]!.filePath !== ref.filePath && isLocallyBoundJsName(ref.referenceName, ref.filePath, context)))) &&
+    !(JS_FAMILY.has(ref.language) && isOutOfRepoBinding(ref.referenceName, ref, context)) &&
     !(finalCandidates[0]!.kind === 'method' && isBareGoCall(ref, context)) &&
     // A bare PHP call is a function call (case-insensitive, so fuzzy may find
     // one) — never the class `View` for `view(…)`, never a method.
@@ -4264,7 +13120,189 @@ export function matchReference(
   ref: UnresolvedRef,
   context: ResolutionContext
 ): ResolvedRef | null {
-  return gateLanguageMatch(matchReferenceInner(ref, context), ref, context);
+  const result = gateLanguageMatch(matchReferenceInner(ref, context), ref, context);
+  // `this.container.classList.toggle()` inside `toggle()`, `window.$events
+  // .listen()` inside `listen()`, Scala's `requestToArmeria(request).execute()`
+  // inside `execute()`: a member of what the receiver is, which is the calling
+  // method only through a TS/JS field of the caller's own type.
+  if (result && result.targetNodeId === ref.fromNodeId && isCollapsedNonRecursion(ref, context)) return null;
+  // A name the calling JS/TS function binds itself shadows the file's own:
+  // lodash's `mixin(object, …)` calling `object(this.__wrapped__)` is its
+  // parameter, whichever strategy (fuzzy included) found a `function object`.
+  if (result && JS_LOCAL_REF_KINDS.has(ref.referenceKind)) {
+    const target = context.getNodeById?.(result.targetNodeId);
+    // (A target of another name is what the local was followed to: `const
+    // selected = useStore(s => s.reset); selected()` is the store's `reset`.)
+    if (target && target.name === ref.referenceName && isOutsideJsLocal(target, ref, context)) return null;
+  }
+  // R looks a call's name up among FUNCTIONS only, skipping other bindings:
+  // ggplot2's tests' `c <- data_frame(b = 3)` is never what `c(1, 2)` calls —
+  // base R's `c` is. (A project binding made by a function factory, ggplot2's
+  // `geom_point <- make_constructor(…)`, is a function, and stays.)
+  if (result && ref.language === 'r' && ref.referenceKind === 'calls' && R_BASE_FUNCTIONS.has(ref.referenceName)) {
+    const target = context.getNodeById?.(result.targetNodeId);
+    if (target && (target.kind === 'variable' || target.kind === 'constant') && !isRFunctionValue(target, context)) return null;
+  }
+  // C has no methods, and C code cannot call a C++ one: hiredis' function
+  // pointer `c->funcs->read(c, buf, …)` is no Qt adapter's `read`.
+  if (result && ref.language === 'c' && ref.referenceKind === 'calls' &&
+      context.getNodeById?.(result.targetNodeId)?.kind === 'method') return null;
+  // A type never inherits from itself: cats' `trait BigDecimalInstances extends
+  // cats.kernel.instances.BigDecimalInstances` and `trait AllOps … with
+  // Bifoldable.AllOps` name another type of their own name.
+  if (result && result.targetNodeId === ref.fromNodeId && isInheritanceRef(ref)) return otherSupertypeNamed(ref, context);
+  // Nor does a value's initializer call the value: sttp's `val response =
+  // basicRequest.get(…).response(asStringAlways)` is a request's `response`.
+  if (result && result.targetNodeId === ref.fromNodeId && ref.referenceKind === 'calls' &&
+      VALUE_KINDS.has(context.getNodeById?.(ref.fromNodeId)?.kind ?? '')) return null;
+  return result ? retargetSelfOverload(result, ref, context) : result;
+}
+
+/**
+ * The supertype an inheritance ref names when the name is the declaring
+ * type's own: another type of that name — the one the written qualifier
+ * (`cats.kernel.instances.`, `Bifoldable.`) leads to, by its owner and its
+ * file's package. Null unless exactly one fits.
+ */
+function otherSupertypeNamed(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const name = ref.referenceName.split(/::|\./).pop()!;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1] ?? '';
+  const written = new RegExp(`^\\s*((?:[\\w$]+\\.)+)${name.replace(/\$/g, '\\$')}\\b`).exec(line.slice(Math.max(0, ref.column)));
+  const qualifier = written ? written[1]!.slice(0, -1) : '';
+  const candidates = context.getNodesByName(name).filter((n) =>
+    n.id !== ref.fromNodeId && isSupertypeTarget(n) && sameLanguageFamily(n.language, ref.language) &&
+    (qualifier === '' || ownerPathOf(n, context) === qualifier || ownerPathOf(n, context).endsWith(`.${qualifier}`)));
+  // Among several, the declaring file's own, then (for `implements`) a protocol / interface / trait:
+  // SDWebImage's `@interface SDWebImageCacheKeyFilter : NSObject <SDWebImageCacheKeyFilter>`.
+  let pool = candidates;
+  if (pool.length > 1) {
+    const sameFile = pool.filter((n) => n.filePath === ref.filePath);
+    if (sameFile.length > 0) pool = sameFile;
+  }
+  if (pool.length > 1 && ref.referenceKind === 'implements') {
+    const conformable = pool.filter((n) => n.kind === 'protocol' || n.kind === 'interface' || n.kind === 'trait');
+    if (conformable.length > 0) pool = conformable;
+  }
+  return pool.length === 1 ? { original: ref, targetNodeId: pool[0]!.id, confidence: 0.8, resolvedBy: 'qualified-name' } : null;
+}
+
+/** A declaration's dotted owner path — its file's package clauses, then its enclosing types (`cats.kernel.instances`, `cats.Bifoldable`). */
+function ownerPathOf(n: Node, context: ResolutionContext): string {
+  const text = context.readFile(n.filePath) ?? '';
+  const pkg = [...text.matchAll(/^\s*package\s+([\w.]+)\s*;?\s*$/gm)].map((m) => m[1]!).join('.');
+  const cut = n.qualifiedName.lastIndexOf('::');
+  const owners = cut > 0 ? n.qualifiedName.slice(0, cut).replace(/::/g, '.') : '';
+  return [pkg, owners].filter((p) => p !== '' && !(pkg !== '' && p === owners && owners.startsWith(pkg))).join('.');
+}
+
+/** Reference kinds a bare JS/TS local can be: a call, a value, a construction. */
+const JS_LOCAL_REF_KINDS: ReadonlySet<string> = new Set(['calls', 'references', 'function_ref', 'instantiates']);
+
+/** Base R functions whose names data often shadows (`c <- data_frame(…)`, `df <- …`, `t <- 1`). */
+const R_BASE_FUNCTIONS: ReadonlySet<string> = new Set([
+  'c', 't', 'q', 'df', 'dt', 'data', 'list', 'length', 'names', 'max', 'min', 'sum', 'mean', 'range', 'rev', 'sort',
+  'order', 'rep', 'seq', 'cat', 'print', 'paste', 'paste0', 'format', 'levels', 'factor', 'matrix', 'vector', 'table',
+  'scale', 'sample', 'exp', 'log', 'abs', 'all', 'any', 'which', 'nchar', 'summary', 'file', 'dir', 'identity', 'unique',
+  'nrow', 'ncol', 'rownames', 'colnames', 'array', 'character', 'numeric', 'integer', 'logical', 'mode', 'class', 'body',
+  'args', 'environment', 'search', 'diff', 'round', 'sign', 'trunc', 'var', 'sd', 'median', 'quantile', 'weights',
+]);
+
+/** Whether an R binding holds a function: `f <- function(…)`, `f = \\(x) …`, a `purrr::partial(…)` aside. */
+function isRFunctionValue(n: Node, context: ResolutionContext): boolean {
+  const line = (context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [])[n.startLine - 1] ?? '';
+  return /(?:<<?-|=)\s*(?:function\b|\\\s*\()/.test(line);
+}
+
+/** Node kinds that hold a value rather than run code. */
+const VALUE_KINDS: ReadonlySet<string> = new Set(['variable', 'constant', 'field', 'property']);
+
+/** Languages whose methods overload by arity. */
+const OVERLOADING_LANGUAGES: ReadonlySet<string> = new Set(['csharp', 'java', 'kotlin', 'swift', 'cpp', 'scala', 'dart', 'vbnet', 'solidity']);
+
+/**
+ * A call a method makes to its own name, with arguments its own parameters
+ * cannot take, is to another overload of it: Newtonsoft's
+ * `DeserializeXNode(value)` body `return DeserializeXNode(value, null);`
+ * bound to itself, so the two-argument overload never saw the one-argument
+ * one among its callers. The same-owner overload the argument count fits.
+ */
+type Arity = { min: number; max: number } | null;
+/** Per context: node id → its same-owner overloads with their arities (null: none). */
+const OVERLOAD_SETS = new WeakMap<ResolutionContext, Map<string, { name: string; own: Arity; siblings: Array<{ id: string; arity: Arity }> } | null>>();
+
+function retargetSelfOverload(result: ResolvedRef, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef {
+  if (ref.referenceKind !== 'calls' || !OVERLOADING_LANGUAGES.has(ref.language)) return result;
+  // C++ overload sets (templates, SFINAE tags, a `data()` on any container) are
+  // only trusted for a method's call to itself.
+  if (ref.language === 'cpp' && result.targetNodeId !== ref.fromNodeId) return result;
+  let memo = OVERLOAD_SETS.get(context);
+  if (!memo) OVERLOAD_SETS.set(context, (memo = new Map()));
+  let set = memo.get(result.targetNodeId);
+  if (set === undefined) {
+    set = overloadSetOf(result.targetNodeId, context);
+    memo.set(result.targetNodeId, set);
+  }
+  // Only an overload set has a sibling to move to.
+  if (!set || set.own === null) return result;
+  const args = cppParenListAfter(ref.filePath, ref.line, Math.max(0, ref.column), set.name, context);
+  if (args === null) return result;
+  // Swift overloads by argument label as much as by count: Alamofire's
+  // `self.tableView(tableView, numberOfRowsInSection: section)` inside
+  // `tableView(_:titleForHeaderInSection:)` is the other `tableView`.
+  if (ref.language === 'swift') {
+    const labels = args.trim() === '' ? [] : splitCppTopLevel(args).map((a) => /^\s*([A-Za-z_]\w*)\s*:(?!:)/.exec(a)?.[1] ?? '_');
+    const fitsLabels = (id: string): boolean | null => {
+      const decl = context.getNodeById?.(id);
+      const list = decl ? cppParenListAfter(decl.filePath, decl.startLine, 0, set!.name, context) : null;
+      return list === null ? null : swiftLabelsFit(labels, list);
+    };
+    if (fitsLabels(result.targetNodeId) !== false) return result;
+    const fit = set.siblings.filter((sib) => fitsLabels(sib.id) === true);
+    return fit.length === 1 ? { ...result, targetNodeId: fit[0]!.id } : result;
+  }
+  const argc = args.trim() === '' ? 0 : splitCppTopLevel(args).length;
+  if (argc >= set.own.min && argc <= set.own.max) return result;
+  const fits = set.siblings.filter((s) => s.arity !== null && argc >= s.arity.min && argc <= s.arity.max);
+  return fits.length === 1 ? { ...result, targetNodeId: fits[0]!.id } : result;
+}
+
+/**
+ * Whether a Swift call's argument labels (`_` for none) fit a declaration's
+ * parameter list: each parameter's external label in order, one with a
+ * default value or a variadic one free to be left out.
+ */
+function swiftLabelsFit(labels: string[], paramList: string): boolean {
+  const params = paramList.trim() === '' ? [] : splitCppTopLevel(paramList).map((p) => {
+    const head = /^\s*(?:@\w+(?:\([^)]*\))?\s+)*(?:inout\s+)?([A-Za-z_]\w*)(?:\s+([A-Za-z_]\w*))?\s*:/.exec(p);
+    return { label: head?.[1] ?? '_', optional: /=/.test(p) || /\.\.\./.test(p) };
+  });
+  let i = 0;
+  for (const param of params) {
+    if (i < labels.length && labels[i] === param.label) { i++; continue; }
+    if (!param.optional) return false;
+  }
+  return i === labels.length;
+}
+
+/** A method's same-owner overloads and every one's arity, read from its declaration. */
+function overloadSetOf(id: string, context: ResolutionContext): { name: string; own: Arity; siblings: Array<{ id: string; arity: Arity }> } | null {
+  const self = context.getNodeById?.(id);
+  if (!self || (self.kind !== 'method' && self.kind !== 'function')) return null;
+  const name = self.name;
+  const owner = self.qualifiedName.slice(0, Math.max(0, self.qualifiedName.lastIndexOf('::')));
+  const siblings = (context.getNodesInFileNamed?.(self.filePath, name) ?? context.getNodesInFile(self.filePath).filter((n) => n.name === name))
+    .filter((n) => n.id !== self.id && (n.kind === 'method' || n.kind === 'function') &&
+      n.qualifiedName.slice(0, Math.max(0, n.qualifiedName.lastIndexOf('::'))) === owner);
+  if (siblings.length === 0) return null;
+  const arity = (n: Node): Arity => {
+    const list = cppParenListAfter(n.filePath, n.startLine, 0, name, context);
+    if (list === null) return null;
+    const params = splitCppTopLevel(list).filter((p) => p !== '' && p !== 'void');
+    const pack = (p: string) => /\.\.\.|\bparams\s|\bvararg\s/.test(p.replace(/<[^<>]*>/g, ''));
+    const min = params.filter((p) => !/=/.test(p) && !pack(p)).length;
+    return { min, max: params.some(pack) ? Infinity : params.length };
+  };
+  return { name, own: arity(self), siblings: siblings.map((n) => ({ id: n.id, arity: arity(n) })) };
 }
 
 function matchReferenceInner(
@@ -4309,6 +13347,32 @@ function matchReferenceInner(
     };
   }
 
+  // `import java.lang.reflect.Field;` — the file's `Field` is the JDK's, never
+  // a project class of that name (gson's production code bound it to a test's
+  // nested `ParameterizedTypesTest.Field`).
+  if ((ref.language === 'java' || ref.language === 'kotlin') && ref.referenceKind !== 'imports' &&
+      isJavaOutsideImport(ref.referenceName.split('.')[0]!, ref, context)) {
+    return null;
+  }
+
+  // A symbolic name in a Scala type is a type (`F ~> G`) or a kind-projector
+  // placeholder (`Either[A, *]`) — never an operator method, by any strategy.
+  if (ref.language === 'scala' && ref.referenceKind === 'references' && /^[^\w\s]+$/.test(ref.referenceName)) {
+    const types = context.getNodesByName(ref.referenceName).filter((n) => n.language === 'scala' && (SCALA_TYPE_KINDS.has(n.kind) || n.kind === 'type_alias'));
+    const chosen = types.length > 1 ? preferCallSiteFile(types, ref.filePath) : types;
+    return chosen.length === 1 ? { original: ref, targetNodeId: chosen[0]!.id, confidence: 0.8, resolvedBy: 'exact-match' } : null;
+  }
+
+  // A bare Lua call through a `local` alias reaches what the alias names.
+  if ((ref.language === 'lua' || ref.language === 'luau') && ref.referenceKind === 'calls' && /^[A-Za-z_]\w*$/.test(ref.referenceName)) {
+    const aliased = luaAliasTarget(ref, context);
+    if (aliased !== undefined) return aliased;
+    // `ipairs(t)` is Lua's, unless the file defines its own: telescope's 122
+    // `for _, v in ipairs(…)` went to a linked list's `ipairs` method.
+    if (LUA_GLOBAL_FUNCTIONS.has(ref.referenceName) &&
+        !context.getNodesInFile(ref.filePath).some((n) => n.name === ref.referenceName && n.kind === 'function')) return null;
+  }
+
   // Erlang `-behaviour(m)` refs target a MODULE. Letting them fall through to
   // bare-name matching grabs any same-named symbol — on emqx,
   // `-behaviour(supervisor)` resolved to a `-define(supervisor, …)` macro
@@ -4363,6 +13427,19 @@ function matchReferenceInner(
         if (sameFile) {
           return { original: ref, targetNodeId: sameFile.id, confidence: 0.95, resolvedBy: 'exact-match' };
         }
+        // Another module's function is called bare only through `-import(Mod,
+        // [f/N])` (or from a `.hrl` a module includes): cowboy's
+        // `-import(req_SUITE, [do_get/3])` went to compress_SUITE's `do_get/3`.
+        const imported = erlangImportedModule(am[1]!, am[2]!, ref, context);
+        if (imported !== undefined) {
+          const chosen = candidates.find((n) => n.qualifiedName.startsWith(`${imported}::`));
+          return chosen ? { original: ref, targetNodeId: chosen.id, confidence: 0.9, resolvedBy: 'exact-match' } : null;
+        }
+        if (!/\.hrl$/.test(ref.filePath)) {
+          const included = candidates.filter((n) => /\.hrl$/.test(n.filePath));
+          if (included.length === 0) return null;
+          candidates.splice(0, candidates.length, ...included);
+        }
         if (candidates.length === 1) {
           return { original: ref, targetNodeId: candidates[0]!.id, confidence: 0.8, resolvedBy: 'exact-match' };
         }
@@ -4381,7 +13458,29 @@ function matchReferenceInner(
     }
   }
 
-  if (isUnresolvedJsMemberCall(ref)) return null;
+  // An identifier-rooted chain has no type to resolve through (#1566) — unless
+  // its receiver is a path an object literal was hung on (#2300).
+  if (isUnresolvedJsMemberCall(ref)) return matchObjectPathCall(ref, context);
+
+  // `window.App.init()` / a sibling's `this.init()`, recorded by the bare
+  // name: the object they are written on comes first (#2300).
+  const collapsed = matchCollapsedObjectCall(ref, context);
+  if (collapsed) return collapsed;
+
+  // A Swift call through a type path (`API.PackageController.GetRoute.query`)
+  // resolves on the type the path names, or not at all: the strategies below
+  // would bind it by the member's name alone.
+  if (ref.language === 'swift' && ref.referenceKind === 'calls' && SWIFT_TYPE_PATH_CALL.test(ref.referenceName)) {
+    return nmTimed('swiftTypePath', ref, () => resolveSwiftTypePathCall(ref, context));
+  }
+
+  // A Dart call through an import prefix (`http.get(…)`) is to what the
+  // prefixed import exports, or to nothing: the strategies below would take
+  // the prefix for a receiver and guess a method by its name.
+  if (ref.language === 'dart' && ref.referenceKind === 'calls') {
+    const prefixed = nmTimedT('dartPrefixed', ref, () => matchDartPrefixedCall(ref, context));
+    if (prefixed !== undefined) return prefixed;
+  }
 
   // Try strategies in order of confidence
   let result: ResolvedRef | null;
@@ -4458,5 +13557,304 @@ function matchReferenceInner(
   result = nmTimed('fuzzy', ref, () => matchFuzzy(ref, context));
   if (result) return result;
 
+  // 5. A C / C++ name qualified by a namespace the project opens with a macro
+  // (`fmt::format` — `FMT_BEGIN_NAMESPACE`), which the index cannot see.
+  if ((ref.language === 'cpp' || ref.language === 'c') && ref.referenceName.includes('::')) {
+    return matchCppMacroNamespaced(ref, context);
+  }
+
+  return null;
+}
+
+const SOLIDITY_SUPERS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+const SOLIDITY_HIERARCHIES = new WeakMap<ResolutionContext, WeakMap<UnresolvedRef, Set<string>>>();
+const SOLIDITY_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'interface', 'struct', 'module', 'trait']);
+
+/** What a Solidity contract, interface or library inherits: `contract Governor is Context, ERC165(…), IGovernor {`. */
+function soliditySupertypesOf(name: string, context: ResolutionContext): string[] {
+  let memo = SOLIDITY_SUPERS.get(context);
+  if (!memo) SOLIDITY_SUPERS.set(context, (memo = new Map()));
+  const hit = memo.get(name);
+  if (hit) return hit;
+  const supers: string[] = [];
+  for (const decl of context.getNodesByName(name)) {
+    if (decl.language !== 'solidity' || !SOLIDITY_TYPE_KINDS.has(decl.kind)) continue;
+    const lines = context.getFileLines?.(decl.filePath) ?? context.readFile(decl.filePath)?.split(/\r?\n/) ?? [];
+    let depth = 0;
+    let head = '';
+    for (const ch of lines.slice(decl.startLine - 1, decl.startLine + 10).join(' ').replace(/\/\/[^\n]*|\/\*.*?\*\//g, ' ')) {
+      if (ch === '{' && depth === 0) break;
+      if (ch === '(') depth++;
+      else if (ch === ')') depth = Math.max(0, depth - 1);
+      else if (depth === 0) head += ch;
+    }
+    const clause = /\bis\b([\s\S]*)$/.exec(head)?.[1] ?? '';
+    for (const m of clause.matchAll(/([A-Za-z_]\w*)\s*(?=,|$)/g)) supers.push(m[1]!);
+  }
+  memo.set(name, supers);
+  return supers;
+}
+
+/**
+ * Whether a bare Solidity call can reach method `n`: a function of the
+ * contract around the call or of one it inherits, or a free function.
+ * OpenZeppelin's `_msgSender()` in Governor (a Context) went to
+ * ERC2771Context's override 83 times.
+ */
+function isSolidityMemberInScope(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (n.kind !== 'method' || n.language !== 'solidity') return true;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut <= 0) return true;
+  const owner = n.qualifiedName.slice(0, cut).split('::').pop()!;
+  let memo = SOLIDITY_HIERARCHIES.get(context);
+  if (!memo) SOLIDITY_HIERARCHIES.set(context, (memo = new WeakMap()));
+  let names = memo.get(ref);
+  if (!names) {
+    names = new Set<string>();
+    const queue = context.getNodesInFile(ref.filePath)
+      .filter((c) => SOLIDITY_TYPE_KINDS.has(c.kind) && c.startLine <= ref.line && c.endLine >= ref.line)
+      .map((c) => c.name);
+    while (queue.length > 0 && names.size < 60) {
+      const name = queue.shift()!;
+      if (names.has(name)) continue;
+      names.add(name);
+      queue.push(...soliditySupertypesOf(name, context));
+    }
+    memo.set(ref, names);
+  }
+  return names.has(owner);
+}
+
+/** Whether a Solidity call is written with no receiver (`_msgSender()`, not `token._msgSender()`). */
+function isReceiverLessSolidityCall(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.language !== 'solidity' || ref.referenceKind !== 'calls' || !/^[A-Za-z_]\w*$/.test(ref.referenceName)) return false;
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+  if (!line) return false;
+  const m = new RegExp(`(?<![\\w$])${ref.referenceName}\\s*\\(`).exec(line);
+  return !!m && !/\.\s*$/.test(line.slice(0, m.index));
+}
+
+/** The module an Erlang file `-import`s `name/arity` from, or undefined. */
+function erlangImportedModule(name: string, arity: string, ref: UnresolvedRef, context: ResolutionContext): string | undefined {
+  const source = context.readFile(ref.filePath);
+  if (!source || !source.includes('-import')) return undefined;
+  const fn = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  for (const m of source.matchAll(/^-import\(\s*'?([A-Za-z_][\w@]*)'?\s*,\s*\[([^\]]*)\]\s*\)\s*\./gm)) {
+    if (new RegExp(`(?:^|[\\s,])'?${fn}'?\\s*/\\s*${arity}\\b`).test(m[2]!)) return m[1]!;
+  }
+  return undefined;
+}
+
+const CPP_NS_MACROS = new WeakMap<ResolutionContext, { openers: Map<string, string[]>; openerFns: Set<string>; closers: Map<string, number>; aliases: Map<string, string> }>();
+const CPP_NS_FRAMES = new WeakMap<ResolutionContext, Map<string, Array<{ start: number; end: number; path: string[] }>>>();
+/** A closing macro's body: `}` / `} }`, maybe beside a pragma macro (`PYBIND11_WARNING_POP }`). */
+const CPP_CLOSER_BODY = /^(?:[A-Za-z_]\w*\s+)*\}(?:\s*\})*\s*;?$/;
+const CPP_NS_ALIASES = new WeakMap<ResolutionContext, Map<string, string>>();
+
+/** The project's namespace aliases: `namespace py = pybind11;`. */
+export function cppNamespaceAliases(context: ResolutionContext): Map<string, string> {
+  const hit = CPP_NS_ALIASES.get(context);
+  if (hit) return hit;
+  const aliases = new Map<string, string>();
+  for (const file of context.getAllFiles()) {
+    if (!/\.(?:h|hh|hpp|hxx|inl|c|cc|cpp|cxx)$/i.test(file)) continue;
+    const source = context.readFile(file);
+    if (!source || !source.includes('namespace')) continue;
+    for (const m of source.matchAll(/^[ \t]*namespace[ \t]+([A-Za-z_]\w*)[ \t]*=[ \t]*(?:::)?([A-Za-z_][\w:]*)[ \t]*;/gm)) {
+      if (!aliases.has(m[1]!)) aliases.set(m[1]!, m[2]!);
+    }
+  }
+  CPP_NS_ALIASES.set(context, aliases);
+  return aliases;
+}
+
+/**
+ * The project's namespace-opening macros — `#define FMT_BEGIN_NAMESPACE
+ * namespace fmt { inline namespace v12 {`, `#define RAPIDJSON_NAMESPACE_BEGIN
+ * namespace RAPIDJSON_NAMESPACE {` (through `#define RAPIDJSON_NAMESPACE
+ * rapidjson`) — as the namespace path each opens (inline namespaces are
+ * transparent), and the closing macros as how many scopes each closes.
+ */
+function cppNamespaceMacros(context: ResolutionContext): { openers: Map<string, string[]>; openerFns: Set<string>; closers: Map<string, number>; aliases: Map<string, string> } {
+  const hit = CPP_NS_MACROS.get(context);
+  if (hit) return hit;
+  const openers = new Map<string, string[]>();
+  // `#define PYBIND11_NAMESPACE_BEGIN(name) namespace name {`, used as `PYBIND11_NAMESPACE_BEGIN(detail)`.
+  const openerFns = new Set<string>();
+  const closers = new Map<string, number>();
+  const aliases = new Map<string, string>();
+  const bodies: Array<[string, string]> = [];
+  for (const file of context.getAllFiles()) {
+    if (!/\.(?:h|hh|hpp|hxx|h\+\+|inl|ipp|tcc)$/i.test(file)) continue;
+    const raw = context.readFile(file);
+    if (!raw || !raw.includes('#') || !raw.includes('define')) continue;
+    const source = stripCommentsForRegex(raw.replace(/\\\r?\n/g, ' '), 'cpp');
+    for (const m of source.matchAll(/^[ \t]*#[ \t]*define[ \t]+([A-Za-z_]\w*)(\(\s*([A-Za-z_]\w*)?\s*\))?[ \t]+([^\n]*)$/gm)) {
+      const body = m[4]!.trim();
+      if (m[2] !== undefined) {
+        // (a trailing pragma macro — `PYBIND11_WARNING_PUSH` — rides along)
+        if (m[3] && new RegExp(`^namespace\\s+${m[3]}\\s*\\{[\\w\\s]*$`).test(body)) openerFns.add(m[1]!);
+        else if (CPP_CLOSER_BODY.test(body)) closers.set(m[1]!, (body.match(/\}/g) ?? []).length);
+        continue;
+      }
+      if (/^[A-Za-z_]\w*$/.test(body)) aliases.set(m[1]!, body);
+      else if (CPP_CLOSER_BODY.test(body)) closers.set(m[1]!, (body.match(/\}/g) ?? []).length);
+      // An inline namespace (transparent, and often named by a macro call) is skipped.
+      else if (/^(?:inline\s+namespace\s+[^{}]*\{\s*|namespace\s+[A-Za-z_]\w*\s*\{\s*)+[\w\s]*$/.test(body)) bodies.push([m[1]!, body]);
+    }
+  }
+  for (const [name, body] of bodies) {
+    if (openers.has(name)) continue;
+    const path = [...body.replace(/inline\s+namespace\s+[^{}]*\{/g, '').matchAll(/namespace\s+([A-Za-z_]\w*)/g)]
+      .map((m) => aliases.get(m[1]!) ?? m[1]!);
+    if (path.length > 0) openers.set(name, path);
+  }
+  const macros = { openers, openerFns, closers, aliases };
+  CPP_NS_MACROS.set(context, macros);
+  return macros;
+}
+
+/** The line ranges of a C / C++ file each namespace macro opens, with the namespace path it opens. */
+export function cppMacroNamespaceFrames(file: string, context: ResolutionContext): Array<{ start: number; end: number; path: string[] }> {
+  let memo = CPP_NS_FRAMES.get(context);
+  if (!memo) {
+    memo = new Map();
+    CPP_NS_FRAMES.set(context, memo);
+  }
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const frames: Array<{ start: number; end: number; path: string[] }> = [];
+  const { openers, openerFns, closers, aliases } = cppNamespaceMacros(context);
+  if (openers.size > 0 || openerFns.size > 0) {
+    const lines = context.getFileLines?.(file) ?? context.readFile(file)?.split(/\r?\n/) ?? [];
+    const open: Array<{ start: number; path: string[] }> = [];
+    lines.forEach((text, i) => {
+      const m = /^[ \t]*([A-Z_][A-Z0-9_]*)(?:\(\s*([A-Za-z_]\w*)?\s*\))?[ \t]*;?[ \t]*(?:\/\/.*|\/\*.*\*\/[ \t]*)?\r?$/.exec(text);
+      const token = m?.[1];
+      if (!token) return;
+      const arg = m[2];
+      const path = arg !== undefined && openerFns.has(token) ? [aliases.get(arg) ?? arg] : arg === undefined ? openers.get(token) : undefined;
+      if (path) open.push({ start: i + 1, path });
+      else if (closers.has(token) && open.length > 0) frames.push({ ...open.pop()!, end: i + 1 });
+    });
+    for (const frame of open) frames.push({ ...frame, end: lines.length });
+  }
+  memo.set(file, frames);
+  return frames;
+}
+
+/**
+ * Resolve `fmt::format` / `fmt::detail::to_unsigned` to the declaration a
+ * namespace macro puts there: a node named `format` (qualified `format` or
+ * `detail::to_unsigned` in the index, which cannot see the macro) inside a
+ * `FMT_BEGIN_NAMESPACE` … `FMT_END_NAMESPACE` range. On fmt, 1,728
+ * `fmt::format(…)` calls resolved to nothing.
+ */
+function matchCppMacroNamespaced(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  let target = ref.referenceName.replace(/^::/, '');
+  // `::memset` names no namespace for a macro or an alias to open.
+  if (!target.includes('::')) return null;
+  const head = target.slice(0, target.indexOf('::'));
+  const alias = cppNamespaceAliases(context).get(head);
+  // `py::str` under `namespace py = pybind11;` is `pybind11::str`.
+  if (alias) target = alias + target.slice(head.length);
+  const name = target.slice(target.lastIndexOf('::') + 2);
+  if (!/^[A-Za-z_~]\w*$/.test(name)) return null;
+  const matches: Node[] = [];
+  for (const n of context.getNodesByName(name)) {
+    if (n.language !== 'cpp' && n.language !== 'c') continue;
+    if (!['function', 'method', 'class', 'struct', 'enum', 'type_alias', 'union', 'variable', 'constant'].includes(n.kind)) continue;
+    const prefix = cppMacroNamespaceFrames(n.filePath, context)
+      .filter((f) => f.start <= n.startLine && f.end >= n.startLine)
+      .sort((a, b) => a.start - b.start)
+      .flatMap((f) => f.path);
+    const effective = prefix.length > 0 ? `${prefix.join('::')}::${n.qualifiedName}` : alias ? n.qualifiedName : '';
+    if (effective === target) matches.push(n);
+  }
+  // A declaration outside the tests over one in them; among an overload set,
+  // the one the call's arguments fit: `fmt::format("{}", v)` is format.h's
+  // `format(format_string, T&&...)`, not color.h's `format(const text_style&, …)`.
+  const args = matches.length > 1 && ref.referenceKind === 'calls' ? cppCallArguments(ref, name, context) : null;
+  let best: Node | null = null;
+  let bestScore = -Infinity;
+  for (const n of matches) {
+    const score = (isTestPath(n.filePath) ? -10 : 0) + (args ? cppOverloadFit(n, name, args, context) : 0);
+    if (score > bestScore) { best = n; bestScore = score; }
+  }
+  return best ? { original: ref, targetNodeId: best.id, confidence: 0.8, resolvedBy: 'qualified-name' } : null;
+}
+
+/** Split `a, f(b, c), d<e, f>` at its top-level commas. */
+function splitCppTopLevel(text: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let cur = '';
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    if (ch === '"' || ch === "'") {
+      let j = i + 1;
+      while (j < text.length && text[j] !== ch) j += text[j] === '\\' ? 2 : 1;
+      cur += text.slice(i, j + 1);
+      i = j;
+      continue;
+    }
+    if (ch === '(' || ch === '[' || ch === '{' || ch === '<') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}' || (ch === '>' && text[i - 1] !== '-')) depth = Math.max(0, depth - 1);
+    if (ch === ',' && depth === 0) { out.push(cur.trim()); cur = ''; continue; }
+    cur += ch;
+  }
+  if (cur.trim()) out.push(cur.trim());
+  return out;
+}
+
+/** The balanced `( … )` after `name` from `line`/`column` of `file` (up to a dozen lines), or null. */
+function cppParenListAfter(file: string, line: number, column: number, name: string, context: ResolutionContext): string | null {
+  const lines = context.getFileLines?.(file) ?? context.readFile(file)?.split(/\r?\n/) ?? [];
+  const text = lines.slice(line - 1, line + 11).join('\n');
+  const at = new RegExp(`\\b${name.replace(/[~]/g, '\\$&')}\\s*(?:<[^<>()]*>)?\\s*\\(`).exec(text.slice(column));
+  if (!at) return null;
+  const open = column + at.index + at[0].length - 1;
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === '(') depth++;
+    else if (text[i] === ')' && --depth === 0) return text.slice(open + 1, i);
+  }
   return null;
 }
+
+function cppCallArguments(ref: UnresolvedRef, name: string, context: ResolutionContext): string[] | null {
+  const list = cppParenListAfter(ref.filePath, ref.line, Math.max(0, ref.column), name, context);
+  return list === null ? null : splitCppTopLevel(list);
+}
+
+/** How well a call's arguments fit an overload's parameters: arity, and a string literal's first slot. */
+function cppOverloadFit(n: Node, name: string, args: string[], context: ResolutionContext): number {
+  if (n.kind !== 'function' && n.kind !== 'method') return -1;
+  const list = cppParenListAfter(n.filePath, n.startLine, 0, name, context);
+  if (list === null) return 0;
+  const params = splitCppTopLevel(list).filter((p) => p !== 'void');
+  // A pack is `T&&... args`, not the `...` inside `format_string<T...>`.
+  const isPack = (p: string): boolean => {
+    let flat = p;
+    for (let prev = ''; prev !== flat;) { prev = flat; flat = flat.replace(/<[^<>]*>/g, ''); }
+    return flat.includes('...');
+  };
+  const variadic = params.some(isPack);
+  const required = params.filter((p) => !isPack(p) && !/=/.test(p)).length;
+  let score = 0;
+  if (args.length < required || (!variadic && args.length > params.length)) score -= 3;
+  // Each string literal against its parameter: a string type by name over a
+  // template parameter that might be one (`const S&`), and a narrow literal
+  // never a wide parameter (`fmt::join(v, ", ")` is not xchar.h's `wstring_view`).
+  for (let i = 0; i < args.length && i < params.length; i++) {
+    const arg = args[i]!;
+    const param = params[i]!;
+    if (isPack(param)) break;
+    if (!/^(?:u8|u|U|L)?"|^FMT_STRING\s*\(/.test(arg)) continue;
+    const wideArg = /^L"/.test(arg);
+    const wideParam = /\bw(?:string|char_t|format|string_view)|wchar_t/.test(param);
+    if (wideArg !== wideParam && /string|char|Char|format/.test(param)) score -= 2;
+    else score += /string|char|Char|\bstr\b/.test(param) ? 3 : /^(?:const\s+)?[A-Z]\w{0,2}\s*[&*]{0,2}\s*\w*$/.test(param) ? 1 : -2;
+  }
+  return score;
+}
diff --git a/src/resolution/react-router-synthesizer.ts b/src/resolution/react-router-synthesizer.ts
index a0706219e7..ad8be602a7 100644
--- a/src/resolution/react-router-synthesizer.ts
+++ b/src/resolution/react-router-synthesizer.ts
@@ -6,6 +6,8 @@
  *   <Navigate to="/login" replace />
  *   <LinkContainer to="/payment">…</LinkContainer>   // react-router-bootstrap
  *   <Link to={{ pathname: '/shipping' }}>…</Link>    // v5's object form
+ *   <Redirect to="/login" />                          // v5
+ *   <HeaderLink to="/features">                        // HeaderLink = styled(Link)
  *
  * A JSX attribute is not a call, so the extractor records no reference for it
  * and the resolver in `frameworks/react-router.ts` — which binds
@@ -27,7 +29,7 @@
  * attribute (`to`, not `href`) and the other table.
  */
 
-import type { Edge } from '../types';
+import type { Edge, Language } from '../types';
 import type { ResolutionContext } from './types';
 import type { MaybeYield } from './cooperative-yield';
 import { stripCommentsForRegex } from './strip-comments';
@@ -36,15 +38,78 @@ import { parseHrefExpression, routesForFile, toHref, type HrefLiteral } from './
 import { matchBracket } from './frameworks/object-literal';
 import { destinationsForHref } from './frameworks/nextjs';
 import { reactRouterTable } from './frameworks/react-router';
+import { configHrefExpression } from './frameworks/react';
 import { enclosingFn, makeLineAt } from './synth-utils';
+import { resolveImportPath } from './import-resolver';
 
 const JSX_FILE = /\.(?:[cm]?[jt]sx?|mdx)$/;
 
-/** The tags that carry a route as a `to` attribute, the attribute anywhere in the tag. */
-const LINK_TAG = /<(Link|NavLink|Navigate|LinkContainer|IndexLinkContainer)\b([^>]*?)\bto\s*=\s*(?:"([^"]*)"|'([^']*)'|(?=\{))/g;
+/** The tags that carry a route as a `to` attribute. */
+const LINK_TAGS = ['Link', 'NavLink', 'Navigate', 'Redirect', 'LinkContainer', 'IndexLinkContainer'];
 
-/** A tag this pass could possibly match — the cheap prefilter before stripping comments. */
-const HAS_LINK_TAG = /<(?:Link|NavLink|Navigate|LinkContainer|IndexLinkContainer)\b/;
+/** `<Tag … to=…>` for any of `tags`, the attribute anywhere in the tag. */
+function linkTagPattern(tags: readonly string[]): RegExp {
+  // An attribute before `to` may hold an arrow (`onMouseEnter={() => …}`), whose `>` is not the tag's end.
+  return new RegExp(`<(${tags.map((t) => t.replace(/[$]/g, '\\$&')).join('|')})\\b((?:[^>]|=>)*?)\\bto\\s*=\\s*(?:"([^"]*)"|'([^']*)'|(?=\\{))`, 'g');
+}
+
+const LINK_TAG = linkTagPattern(LINK_TAGS);
+
+/** A file that imports React Router's own components. */
+const ROUTER_IMPORT = /\bfrom\s*['"]react-router(?:-dom)?['"]/;
+
+/** `const HeaderLink = styled(Link)` — a styled wrapper is the link it wraps. */
+const STYLED_LINK_CONST = /\b(?:export\s+)?(?:const|let)\s+([A-Z][\w$]*)\s*=\s*styled\s*\(\s*(?:Link|NavLink)\s*\)/g;
+const STYLED_LINK_DEFAULT = /\bexport\s+default\s+styled\s*\(\s*(?:Link|NavLink)\s*\)/;
+
+interface LinkWrappers {
+  /** File → the wrapper components it declares by name. */
+  named: Map<string, Set<string>>;
+  /** Files whose default export is a wrapper. */
+  defaults: Set<string>;
+}
+
+/**
+ * Every styled-components / emotion wrapper of `Link` or `NavLink` in the
+ * project — react-boilerplate's header links are `export default
+ * styled(Link)`…``, used as `<HeaderLink to="/features">` from another file.
+ */
+function linkWrappers(ctx: ResolutionContext): LinkWrappers {
+  const named = new Map<string, Set<string>>();
+  const defaults = new Set<string>();
+  for (const file of ctx.getAllFiles()) {
+    if (!JSX_FILE.test(file) || isTestPath(file)) continue;
+    if (ctx.fileContains && !ctx.fileContains(file, 'styled')) continue;
+    const source = ctx.readFile(file);
+    if (!source || !/\bstyled\s*\(\s*(?:Link|NavLink)\s*\)/.test(source) || !ROUTER_IMPORT.test(source)) continue;
+    if (STYLED_LINK_DEFAULT.test(source)) defaults.add(file);
+    STYLED_LINK_CONST.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = STYLED_LINK_CONST.exec(source)) !== null) {
+      let set = named.get(file);
+      if (!set) named.set(file, (set = new Set()));
+      set.add(m[1]!);
+    }
+  }
+  return { named, defaults };
+}
+
+/** The link tags `file` can write: React Router's own and the wrappers in scope there. */
+function linkTagsFor(file: string, wrappers: LinkWrappers, ctx: ResolutionContext): string[] {
+  const tags = [...LINK_TAGS, ...(wrappers.named.get(file) ?? [])];
+  if (wrappers.named.size > 0 || wrappers.defaults.size > 0) {
+    for (const m of ctx.getImportMappings(file, languageOf(file))) {
+      const target = resolveImportPath(m.source, file, languageOf(file), ctx);
+      if (!target) continue;
+      if ((m.isDefault && wrappers.defaults.has(target)) || wrappers.named.get(target)?.has(m.exportedName)) tags.push(m.localName);
+    }
+  }
+  return tags;
+}
+
+function languageOf(file: string): Language {
+  return /\.tsx$/.test(file) ? 'tsx' : /\.[cm]?ts$/.test(file) ? 'typescript' : /\.jsx$/.test(file) ? 'jsx' : 'javascript';
+}
 
 /** Links a single component may carry before it is a navigation menu, not a decision. */
 const MAX_LINKS_PER_COMPONENT = 24;
@@ -55,6 +120,7 @@ export async function reactRouterLinkEdges(ctx: ResolutionContext, onYield: Mayb
   const edges: Edge[] = [];
   const seen = new Set<string>();
   const perComponent = new Map<string, number>();
+  const wrappers = linkWrappers(ctx);
   let scanned = 0;
   for (const file of ctx.getAllFiles()) {
     if (!JSX_FILE.test(file) || isTestPath(file)) continue;
@@ -62,13 +128,16 @@ export async function reactRouterLinkEdges(ctx: ResolutionContext, onYield: Mayb
     if (!routes || routes.exact.size === 0) continue;
     if ((++scanned & 63) === 0) await onYield();
     const source = ctx.readFile(file);
-    if (!source || !HAS_LINK_TAG.test(source)) continue;
+    if (!source || !/\bto\s*=/.test(source)) continue;
+    const tags = linkTagsFor(file, wrappers, ctx);
+    const pattern = tags.length === LINK_TAGS.length ? LINK_TAG : linkTagPattern(tags);
+    if (!new RegExp(`<(?:${tags.join('|')})\\b`).test(source)) continue;
     const safe = stripCommentsForRegex(source, 'typescript');
     const nodes = ctx.getNodesInFile(file);
     const lineOf = makeLineAt(safe, 1);
-    LINK_TAG.lastIndex = 0;
+    pattern.lastIndex = 0;
     let m: RegExpExecArray | null;
-    while ((m = LINK_TAG.exec(safe)) !== null) {
+    while ((m = pattern.exec(safe)) !== null) {
       const tag = m[1]!;
       const quoted: string | null = m[3] ?? m[4] ?? null;
       let href: HrefLiteral | null;
@@ -83,7 +152,13 @@ export async function reactRouterLinkEdges(ctx: ResolutionContext, onYield: Mayb
         const at = m.index + m[0].length;
         const close = matchBracket(safe, at);
         if (close < 0) continue;
-        href = parseHrefExpression(safe.slice(at + 1, close));
+        const expr = safe.slice(at + 1, close);
+        href = parseHrefExpression(expr);
+        // `to={paths.app.discussion.getHref(id)}`: a route-config object's href.
+        if (!href) {
+          const configured = configHrefExpression(expr, file, ctx);
+          if (configured) href = parseHrefExpression(configured);
+        }
       }
       // A relative `to` is resolved against the route this markup renders
       // under — a nesting this scan does not read, so it is not a destination.
@@ -109,7 +184,7 @@ export async function reactRouterLinkEdges(ctx: ResolutionContext, onYield: Mayb
           metadata: {
             synthesizedBy: 'react-router-link',
             href: arm.display,
-            navMethod: tag === 'Navigate' ? 'navigate' : 'link',
+            navMethod: tag === 'Navigate' ? 'navigate' : tag === 'Redirect' ? 'redirect' : 'link',
             registeredAt: `${file}:${line}`,
           },
         });
diff --git a/src/resolution/resolver-pool.ts b/src/resolution/resolver-pool.ts
index 56b9785a66..457e1d0c0f 100644
--- a/src/resolution/resolver-pool.ts
+++ b/src/resolution/resolver-pool.ts
@@ -16,6 +16,7 @@ import * as os from 'os';
 import type { Edge, UnresolvedReference } from '../types';
 import type { ResolvedRef, UnresolvedRef } from './types';
 import { memoryBudgetBytes } from './memory-budget';
+import { terminateOnceStarted, workerStarted } from '../worker-teardown';
 
 /** One synthesis pass's output: its edge list + worker-measured wall clock. */
 export interface SynthPassResult {
@@ -34,9 +35,14 @@ export interface ChunkResult {
 interface PoolWorker {
   worker: Worker;
   ready: Promise<void>;
+  /** Settles on the worker's first message or its end — see worker-teardown.ts. */
+  started: Promise<void>;
   busy: number;
 }
 
+/** How long destroy() waits for a worker to exit on 'close' before terminating it. */
+const CLOSE_TIMEOUT_MS = 5000;
+
 const MIN_PARALLEL_BATCH = 1000;
 const CHUNK_SIZE = 500;
 
@@ -58,6 +64,23 @@ export function minRefsForPool(): number {
   return 150_000;
 }
 
+/**
+ * Fewest refs still to settle for the batch loop to boot the pool mid-run
+ * from its observed per-ref rate. Booting takes seconds (each worker opens the
+ * database and warms a resolver), only batches of MIN_PARALLEL_BATCH refs fan
+ * out, and synthesis waits for a booting pool. A rate measured on a busy
+ * machine inflates every projection, so with no floor a ten-file project booted
+ * the pool in half its runs under heavy load and paid seconds for nothing.
+ * Repos the adaptive bar is for (Rust-class per-ref cost) have tens of
+ * thousands of refs and still engage.
+ */
+export const ADAPTIVE_ENGAGE_MIN_REFS = 20_000;
+
+/** Whether the resolve loop should boot the pool mid-run (see ADAPTIVE_ENGAGE_MIN_REFS). */
+export function shouldEngageAdaptively(projectedMs: number, remainingRefs: number, barMs: number): boolean {
+  return remainingRefs >= ADAPTIVE_ENGAGE_MIN_REFS && projectedMs >= barMs;
+}
+
 export class ResolverPool {
   private workers: PoolWorker[] = [];
   private nextId = 0;
@@ -149,13 +172,14 @@ export class ResolverPool {
   private constructor(workerScript: string, dbPath: string, projectRoot: string, size: number) {
     for (let i = 0; i < size; i++) {
       const worker = new Worker(workerScript);
+      const started = workerStarted(worker);
       let readyResolve!: () => void;
       let readyReject!: (e: Error) => void;
       const ready = new Promise<void>((resolve, reject) => {
         readyResolve = resolve;
         readyReject = reject;
       });
-      const pw: PoolWorker = { worker, ready, busy: 0 };
+      const pw: PoolWorker = { worker, ready, started, busy: 0 };
       worker.on('message', (msg: { type: string; id?: number; message?: string; edges?: Edge[]; ms?: number } & Partial<ChunkResult>) => {
         if (msg.type === 'ready') {
           readyResolve();
@@ -324,14 +348,20 @@ export class ResolverPool {
     );
   }
 
-  async destroy(): Promise<void> {
+  /**
+   * Ask every worker to close; each collects garbage and exits by itself (see
+   * worker-teardown.ts). One that hasn't by `closeTimeoutMs` is terminated —
+   * but never while it is still starting up: a pool torn down soon after it
+   * booted, on a busy machine, can have a worker still loading its modules.
+   */
+  async destroy(closeTimeoutMs = CLOSE_TIMEOUT_MS): Promise<void> {
     await Promise.all(
       this.workers.map(
         (pw) =>
           new Promise<void>((resolve) => {
             const t = setTimeout(() => {
-              void pw.worker.terminate().then(() => resolve());
-            }, 5000);
+              void terminateOnceStarted(pw.worker, pw.started).then(() => resolve());
+            }, closeTimeoutMs);
             pw.worker.once('exit', () => {
               clearTimeout(t);
               resolve();
diff --git a/src/resolution/resolver-worker.ts b/src/resolution/resolver-worker.ts
index f1d3020128..6cc3ec71f7 100644
--- a/src/resolution/resolver-worker.ts
+++ b/src/resolution/resolver-worker.ts
@@ -26,6 +26,7 @@ import { QueryBuilder } from '../db/queries';
 import { ReferenceResolver } from './index';
 import { SYNTH_PASSES } from './callback-synthesizer';
 import { createYielder } from './cooperative-yield';
+import { collectBeforeExit } from '../worker-teardown';
 import type { UnresolvedReference } from '../types';
 
 if (!parentPort) {
@@ -126,6 +127,8 @@ port.on('message', (msg: InMessage) => {
         } catch {
           /* already closed */
         }
+        // No GC marking in flight when the thread ends (worker-teardown.ts).
+        collectBeforeExit();
         process.exit(0);
         break;
       }
diff --git a/src/resolution/resurrect-ref.ts b/src/resolution/resurrect-ref.ts
new file mode 100644
index 0000000000..52cb8bc4de
--- /dev/null
+++ b/src/resolution/resurrect-ref.ts
@@ -0,0 +1,38 @@
+/**
+ * The reference behind a resolution edge, for an edge whose target is going
+ * away — shared by every path that removes nodes other files point at.
+ */
+
+import type { Edge, Language, ReferenceKind, UnresolvedReference } from '../types';
+
+/**
+ * Resurrect a resolution edge that is about to be dropped (its target symbol
+ * was removed, renamed, or its whole file deleted) as the ORIGINAL unresolved
+ * reference that created it, read from the refName/refKind stamp
+ * `createEdges` writes into edge metadata. Inserted as status='pending', the
+ * ref is consumed by the same sync's resolution sweep: it rebinds to an
+ * alternative definition if one exists, or parks as status='failed' where the
+ * #1240 retry finds it if the symbol later reappears.
+ *
+ * Returns null — drop silently, the pre-#1240 behavior — for edges without a
+ * refName stamp (created before the stamp existed, or synthesized): rebuilding
+ * a ref from the target's plain node name would strip the receiver/qualifier
+ * context the original text carried (`h.greet` → `greet`) and could rebind
+ * somewhere a full re-index never would. Silent beats wrong.
+ */
+export function resurrectRefFromDroppedEdge(
+  e: Edge & { sourceFilePath: string; sourceLanguage: Language }
+): UnresolvedReference | null {
+  const refName = e.metadata?.refName;
+  if (typeof refName !== 'string' || refName.length === 0) return null;
+  const refKind = typeof e.metadata?.refKind === 'string' ? (e.metadata.refKind as ReferenceKind) : e.kind;
+  return {
+    fromNodeId: e.source,
+    referenceName: refName,
+    referenceKind: refKind,
+    line: e.line ?? 0,
+    column: e.column ?? 0,
+    filePath: e.sourceFilePath,
+    language: e.sourceLanguage,
+  };
+}
diff --git a/src/resolution/shopify-themes.ts b/src/resolution/shopify-themes.ts
new file mode 100644
index 0000000000..3c2f3c8b5c
--- /dev/null
+++ b/src/resolution/shopify-themes.ts
@@ -0,0 +1,39 @@
+/**
+ * A Shopify theme's section and snippet references → that theme's own files.
+ *
+ * `{% render 'price' %}` renders the `snippets/price.liquid` of the theme the
+ * file belongs to; `{% section 'header' %}` and a JSON template's section
+ * `"type"` name a file in that theme's `sections/`. Shopify never looks in
+ * another theme. The Liquid extractor records these as `snippets/<name>.liquid`
+ * and `sections/<name>.liquid`, and the path matcher took any file whose path
+ * ends with that, so in a repository holding several themes (a theme tool's
+ * examples, a store's seasonal themes) a theme missing a section linked to
+ * another theme's copy of it.
+ *
+ * From a file inside a theme (see `shopifyThemeRoot`), these references
+ * resolve to the theme's own file or to nothing, and never fall through to the
+ * generic name strategies. A reference from a file in no theme resolves as
+ * before.
+ */
+import { shopifyThemeRoot } from '../extraction/grammars';
+import type { ResolvedRef, ResolutionContext, UnresolvedRef } from './types';
+
+/**
+ * The file a section or snippet reference made inside a Shopify theme names:
+ * the theme's own `sections/<name>.liquid` or `snippets/<name>.liquid`.
+ * undefined means the reference is not one, or is made outside any theme;
+ * null means the theme has no such file, so no other strategy may guess one.
+ */
+export function matchShopifyThemeFile(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null | undefined {
+  if (ref.language !== 'liquid' || !/^(sections|snippets)\//.test(ref.referenceName)) return undefined;
+  const theme = shopifyThemeRoot(ref.filePath, (relativePath) => context.fileExists(relativePath));
+  if (theme === undefined) return undefined;
+  const target = theme === '' ? ref.referenceName : `${theme}/${ref.referenceName}`;
+  const file = context
+    .getNodesByName(target.slice(target.lastIndexOf('/') + 1))
+    .find((n) => n.kind === 'file' && n.filePath === target);
+  if (!file) return null;
+  // The confidence the path matcher gives the same link: an exact path for a
+  // theme at the project root, a path tail for one in a folder.
+  return { original: ref, targetNodeId: file.id, confidence: theme === '' ? 0.95 : 0.85, resolvedBy: 'file-path' };
+}
diff --git a/src/resolution/strip-comments.ts b/src/resolution/strip-comments.ts
index b728e3722d..341cf7032e 100644
--- a/src/resolution/strip-comments.ts
+++ b/src/resolution/strip-comments.ts
@@ -27,8 +27,10 @@
  * Blank string contents while preserving quotes and offsets. Template
  * interpolations are blanked too; callers checking executable expressions
  * must conservatively inspect those expressions in the original source.
+ * `regexLiterals`, when given, receives the offsets of the opening and
+ * closing `/` of every span read as a regex literal (left as is).
  */
-export function blankStringContents(text: string): string {
+export function blankStringContents(text: string, regexLiterals?: number[]): string {
   const out = text.split('');
   let i = 0;
   const n = text.length;
@@ -45,7 +47,11 @@ export function blankStringContents(text: string): string {
         if (text[end] === ']') inClass = false;
         if (text[end] === '/' && !inClass) break;
       }
-      if (end < n && text[end] === '/') { i = end + 1; continue; }
+      if (end < n && text[end] === '/') {
+        regexLiterals?.push(i, end);
+        i = end + 1;
+        continue;
+      }
     }
     if (c === '"' || c === "'" || c === '`') {
       const quote = c;
diff --git a/src/resolution/swift-type-visibility.ts b/src/resolution/swift-type-visibility.ts
index 9c6442ce68..0e1446c183 100644
--- a/src/resolution/swift-type-visibility.ts
+++ b/src/resolution/swift-type-visibility.ts
@@ -39,13 +39,14 @@ interface Memo {
   conformances: Map<string, string[]>;
   clauses: Map<string, string[]>;
   inherited: Map<string, ReadonlySet<string>>;
+  owners: Map<string, string | null>;
 }
 const memos = new WeakMap<ResolutionContext, Memo>();
 
 function memoFor(context: ResolutionContext): Memo {
   let memo = memos.get(context);
   if (!memo) {
-    memo = { extension: new Map(), declaration: new Map(), conformances: new Map(), clauses: new Map(), inherited: new Map() };
+    memo = { extension: new Map(), declaration: new Map(), conformances: new Map(), clauses: new Map(), inherited: new Map(), owners: new Map() };
     memos.set(context, memo);
   }
   return memo;
@@ -340,3 +341,120 @@ export function gateSwiftTypeTarget(result: ResolvedRef | null, ref: UnresolvedR
   if (!declared) return null;
   return declared.id === result.targetNodeId ? result : { ...result, targetNodeId: declared.id };
 }
+
+/**
+ * A call through a type path, `API.PackageController.GetRoute.query` — at
+ * least two capitalized segments before the member (the extractor keeps the
+ * path only for those; see SWIFT_TYPE_PATH_RECEIVER in tree-sitter.ts).
+ */
+export const SWIFT_TYPE_PATH_CALL = /^(?!Self\.)[A-Z]\w*(?:\.[A-Z]\w*)+\.[A-Za-z_]\w*$/;
+
+/** What a type-path call can name: a method, or a case with associated values (`Gitlab.Error.requestFailed(status:)`). */
+const PATH_MEMBER_KINDS: ReadonlySet<Node['kind']> = new Set<Node['kind']>(['method', 'function', 'enum_member']);
+
+/**
+ * `API.PackageController.GetRoute.query(on:)` lands on the `query` of the
+ * type the path names, and `API.PackageController.Model(name:)` on that
+ * nested type — never on the member's name alone: in a Vapor app every
+ * route's type has a `query`. A path the call's own namespace lets it
+ * shorten (`PackageController.GetRoute` inside `extension API`) or a module
+ * qualifier (`Vapor.HTTPStatus`) still fits. No type on the path, or two,
+ * leaves the call unresolved.
+ */
+export function resolveSwiftTypePathCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const name = ref.referenceName;
+  const dot = name.lastIndexOf('.');
+  const member = name.slice(dot + 1);
+  const path = name.slice(0, dot).split('.').join('::');
+  const onPath = (kinds: ReadonlySet<Node['kind']>): Node[] => {
+    const exact: Node[] = [];
+    const shortened: Node[] = [];
+    for (const n of context.getNodesByName(member)) {
+      if (n.language !== 'swift' || !kinds.has(n.kind)) continue;
+      if (TYPE_KINDS.has(n.kind) && isSwiftExtension(n, context)) continue;
+      const owner = ownerPath(n, context);
+      if (owner === null) continue;
+      if (owner === path) exact.push(n);
+      else if (owner.endsWith(`::${path}`) || moduleQualified(owner, path, context)) shortened.push(n);
+    }
+    return exact.length > 0 ? exact : shortened;
+  };
+  // `API.PackageController.Model(name:)` constructs a nested type.
+  let fit = /^[A-Z]/.test(member) ? onPath(TYPE_KINDS) : [];
+  if (fit.length === 0) fit = onPath(PATH_MEMBER_KINDS);
+  // The Composable Architecture's `@Reducer enum Path { case detail(Detail) }`
+  // generates `Path.State` and `Path.Action` with the same cases, so
+  // `Path.State.detail(…)` constructs the case written in `Path`.
+  if (fit.length === 0) {
+    const reducer = /^(.+)::(?:State|Action)$/.exec(path)?.[1];
+    if (reducer) {
+      fit = context.getNodesByName(member).filter((n) => {
+        if (n.language !== 'swift' || n.kind !== 'enum_member') return false;
+        const owner = ownerPath(n, context);
+        return owner !== null && (owner === reducer || owner.endsWith(`::${reducer}`)) && isReducerEnum(n, context);
+      });
+    }
+  }
+  if (fit.length === 0 || new Set(fit.map((n) => ownerPath(n, context))).size > 1) return null;
+  // Of one type's overloads, the first declared.
+  const target = fit.reduce((a, b) => (a.filePath < b.filePath || (a.filePath === b.filePath && a.startLine <= b.startLine) ? a : b));
+  return { original: ref, targetNodeId: target.id, confidence: 0.9, resolvedBy: 'qualified-name' };
+}
+
+/** Is this case declared in a `@Reducer enum`? */
+function isReducerEnum(member: Node, context: ResolutionContext): boolean {
+  const owner = context
+    .getNodesInFile(member.filePath)
+    .filter((t) => t.kind === 'enum' && t.startLine <= member.startLine && t.endLine >= member.endLine)
+    .reduce<Node | null>((inner, t) => (!inner || t.startLine >= inner.startLine ? t : inner), null);
+  if (!owner) return false;
+  const lines = linesOf(owner.filePath, context) ?? [];
+  // The node starts at its attributes; `@Reducer` may also sit on the line above.
+  return /@Reducer\b/.test(lines.slice(Math.max(0, owner.startLine - 2), owner.startLine + 1).join(' '));
+}
+
+/** `Vapor::HTTPStatus` for a type `HTTPStatus`: a qualifier that names no project type is a module. */
+function moduleQualified(owner: string, path: string, context: ResolutionContext): boolean {
+  if (!path.endsWith(`::${owner}`)) return false;
+  const head = path.slice(0, path.length - owner.length - 2);
+  return !head.includes('::') && !context.getNodesByName(head).some((n) => n.language === 'swift' && TYPE_KINDS.has(n.kind));
+}
+
+/**
+ * The full path of the type a member is declared on. Its qualified name
+ * starts at the outermost declaration in its file, and an extension is named
+ * by its last segment — the members of `extension API.PackageController {
+ * enum GetRoute { … } }` are `PackageController::GetRoute::…` — so the
+ * outermost extension's written path is read back from its line. Null for a
+ * top-level function.
+ */
+function ownerPath(member: Node, context: ResolutionContext): string | null {
+  const memo = memoFor(context).owners;
+  const hit = memo.get(member.id);
+  if (hit !== undefined) return hit;
+  const cut = member.qualifiedName.lastIndexOf('::');
+  let path: string | null = cut < 0 ? null : member.qualifiedName.slice(0, cut);
+  if (path !== null) {
+    const first = path.split('::')[0]!;
+    const outer = context
+      .getNodesInFile(member.filePath)
+      .filter((t) => t.name === first && TYPE_KINDS.has(t.kind) && t.startLine <= member.startLine && t.endLine >= member.endLine)
+      .reduce<Node | null>((out, t) => (!out || t.startLine < out.startLine ? t : out), null);
+    const extended = outer ? extendedPath(outer, context) : null;
+    if (extended) path = extended + path.slice(first.length);
+  }
+  memo.set(member.id, path);
+  return path;
+}
+
+/** `extension API.PackageController {` → `API::PackageController`; null for anything but an extension of a nested type. */
+function extendedPath(node: Node, context: ResolutionContext): string | null {
+  if (!isSwiftExtension(node, context)) return null;
+  const lines = linesOf(node.filePath, context);
+  if (!lines) return null;
+  const head = [(lines[node.startLine - 1] ?? '').slice(node.startColumn), ...lines.slice(node.startLine, node.startLine + 3)]
+    .join(' ')
+    .replace(/"(?:[^"\\\n]|\\.)*"/g, '""');
+  const written = /\bextension\s+((?:[A-Za-z_]\w*\s*\.\s*)+[A-Za-z_]\w*)/.exec(head)?.[1];
+  return written ? written.replace(/\s+/g, '').split('.').join('::') : null;
+}
diff --git a/src/resolution/type-parameters.ts b/src/resolution/type-parameters.ts
new file mode 100644
index 0000000000..d5c4a9ba10
--- /dev/null
+++ b/src/resolution/type-parameters.ts
@@ -0,0 +1,291 @@
+/**
+ * A name an enclosing declaration declares as a TYPE PARAMETER means that
+ * parameter, never a project symbol that happens to share it.
+ *
+ * `def zipWith[A, B, C](fa: ISeq[A], …)` in cats sent its `A` to an
+ * `implicit def A` elsewhere (4,916 dependents) and its `B` to a
+ * `case class B()` declared inside some test; getx's `T` landed on a constant
+ * named `T`. The index does not record type parameters, so they are read
+ * from the declaration heads around the reference: after the declared name
+ * (`class Foo<T>`, `fn f<T: Display>`, `func F[T any]`, `def f[F[_]: Monad, A]`,
+ * `struct Stack<Element>`), before it where the language puts them
+ * (Java's `<T extends X> T max(…)`, Kotlin's `fun <T> f()`), a C++
+ * `template <typename T>` line above it, and a Go method's receiver
+ * (`func (p *Pool[T]) Get() T`). Applied at resolveOne's seam, so every
+ * strategy's result obeys it.
+ */
+import type { Node } from '../types';
+import type { ResolutionContext, ResolvedRef, UnresolvedRef } from './types';
+
+const GENERIC_LANGUAGES: ReadonlySet<string> = new Set([
+  'scala', 'java', 'kotlin', 'csharp', 'typescript', 'tsx', 'swift', 'rust', 'dart', 'go', 'cpp', 'vbnet', 'arkts',
+]);
+
+/** Where a reference names a type. */
+const TYPE_REF_KINDS: ReadonlySet<string> = new Set(['references', 'type_of', 'returns', 'instantiates']);
+
+/** Declarations that can carry type parameters. */
+const DECLARATION_KINDS: ReadonlySet<string> = new Set([
+  'class', 'struct', 'interface', 'trait', 'protocol', 'enum', 'type_alias', 'function', 'method', 'union', 'module',
+]);
+
+/** How far past a declaration's first line its head can run: a parameter list may take a line per parameter. */
+const HEAD_LINES = 40;
+
+const memos = new WeakMap<ResolutionContext, Map<string, ReadonlySet<string>>>();
+
+/** Drop the memos (see ReferenceResolver.clearCaches). */
+export function clearTypeParameterMemos(context: ResolutionContext): void {
+  memos.delete(context);
+  valueMemos.delete(context);
+}
+
+/**
+ * The resolved reference, or null when a declaration around it declares its
+ * name: as a type parameter (a type reference), or — Scala — as a value
+ * parameter of the enclosing `def` (`f(a)` where `f: A => B` is the def's own
+ * argument; cats bound 846 such calls to a case class's `f` field).
+ */
+export function gateTypeParameter(resolved: ResolvedRef | null, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  if (!resolved) return resolved;
+  let result = resolved;
+  if (ref.language === 'scala' && (ref.referenceKind === 'calls' || ref.referenceKind === 'references') &&
+    /^[A-Za-z_]\w*$/.test(ref.referenceName)) {
+    for (const declaration of enclosingDeclarations(ref, context)) {
+      if ((declaration.kind === 'function' || declaration.kind === 'method') &&
+        declaredValueParameters(declaration, context).has(ref.referenceName)) return null;
+    }
+  }
+  if (ref.language === 'scala' && !scalaMemberInScope(result, ref, context)) {
+    // Out of scope: the type of that name that IS in scope — cats' own
+    // `trait FlatMap`, not `Eval`'s nested `FlatMap` case class — when one fits.
+    const target = context.getNodeById?.(result.targetNodeId);
+    if (!target || !SCALA_TYPE_KINDS.has(target.kind)) return null;
+    const inScope = context
+      .getNodesByName(ref.referenceName)
+      .filter((n) => n.id !== target.id && n.language === 'scala' && SCALA_TYPE_KINDS.has(n.kind))
+      .filter((n) => scalaMemberInScope({ ...result, targetNodeId: n.id }, ref, context));
+    const chosen = inScope.length === 1 ? inScope[0]! : inScope.find((n) => n.filePath === ref.filePath);
+    if (!chosen) return null;
+    result = { ...result, targetNodeId: chosen.id };
+  }
+  if (!GENERIC_LANGUAGES.has(ref.language) || !TYPE_REF_KINDS.has(ref.referenceKind)) return result;
+  const name = ref.referenceName;
+  if (!/^[A-Z][A-Za-z0-9_]*$/.test(name)) return result;
+  for (const declaration of enclosingDeclarations(ref, context)) {
+    if (declaredTypeParameters(declaration, context).has(name)) return null;
+  }
+  return result;
+}
+
+const SCALA_OWNER_KINDS: ReadonlySet<string> = new Set(['class', 'trait', 'module', 'interface', 'struct', 'enum']);
+const SCALA_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'trait', 'interface', 'struct', 'enum', 'type_alias']);
+
+/**
+ * A bare Scala name reaches a member of another type — `FreeT.FlatMapped`'s
+ * `type A`, a test suite's `val P` — only from inside that type, a type that
+ * extends it, or a file importing its members (`import Owner._`,
+ * `Owner.{A}`, `Owner.*`). cats' bare type parameters landed on such members
+ * across the library once the test-local classes stopped catching them.
+ */
+function scalaMemberInScope(result: ResolvedRef, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (!/^[A-Za-z_]\w*$/.test(ref.referenceName) || ref.referenceKind !== 'references') return true;
+  // Bare in the SOURCE: the index keeps `SttpClient.Service` by its last
+  // segment, and a qualified name reaches any member.
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1];
+  if (line === undefined || !line.startsWith(ref.referenceName, ref.column) || /\.\s*$/.test(line.slice(0, ref.column))) return true;
+  const target = context.getNodeById?.(result.targetNodeId);
+  if (!target || target.language !== 'scala') return true;
+  const cut = target.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const ownerQn = target.qualifiedName.slice(0, cut);
+  const containers = context
+    .getNodesByQualifiedName(ownerQn)
+    .filter((o) => o.filePath === target.filePath && o.startLine <= target.startLine && o.endLine >= target.endLine);
+  const inside = (o: Node): boolean => ref.filePath === o.filePath && ref.line >= o.startLine && ref.line <= o.endLine;
+  // A def's local (`case class B()` in a test method): only in there.
+  const def = containers.find((o) => o.kind === 'function' || o.kind === 'method');
+  if (def) return inside(def);
+  const owner = containers.find((o) => SCALA_OWNER_KINDS.has(o.kind));
+  if (!owner) return true; // a package member
+  if (inside(owner)) return true;
+  // Inherited: the reference sits in a type that extends the owner.
+  for (const around of enclosingDeclarations(ref, context)) {
+    if (!SCALA_OWNER_KINDS.has(around.kind)) continue;
+    if (around.name === owner.name) return true;
+    if (context.getSupertypes?.(around.name, 'scala').includes(owner.name)) return true;
+  }
+  // Imported: `import cats.data.FreeT.FlatMapped._`, `Owner.{A, B}`, `Owner.*`.
+  const text = context.readFile(ref.filePath) ?? '';
+  const imports = new RegExp(
+    String.raw`\bimport\s+[\w.]*\b${owner.name}\.(?:_|\*|given\b|\{[^}]*\b(?:_|\*|${target.name})\b[^}]*\}|${target.name}\b)`,
+  );
+  return /^[A-Za-z_]\w*$/.test(owner.name) && /^[A-Za-z_]\w*$/.test(target.name) ? imports.test(text) : true;
+}
+
+function enclosingDeclarations(ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  return context
+    .getNodesInFile(ref.filePath)
+    .filter((n) => DECLARATION_KINDS.has(n.kind) && n.startLine <= ref.line && n.endLine >= ref.line);
+}
+
+function declaredTypeParameters(node: Node, context: ResolutionContext): ReadonlySet<string> {
+  let memo = memos.get(context);
+  if (!memo) {
+    memo = new Map();
+    memos.set(context, memo);
+  }
+  const hit = memo.get(node.id);
+  if (hit) return hit;
+  const names = new Set<string>();
+  const lines = context.getFileLines?.(node.filePath) ?? context.readFile(node.filePath)?.split(/\r?\n/) ?? null;
+  if (lines) {
+    const head = lines.slice(node.startLine - 1, Math.min(node.endLine, node.startLine - 1 + HEAD_LINES)).join('\n');
+    const at = nameIndex(head, node.name);
+    if (at >= 0) {
+      // After the declared name: `Foo<T>`, `f[A]`.
+      let open = at + node.name.length;
+      while (open < head.length && /[ \t]/.test(head[open]!)) open++;
+      if (head[open] === '<' || head[open] === '[') collect(head, open, names);
+      // Before it, detached from any type name: `static <T> T max(`, `fun <T> f(`.
+      const before = head.slice(0, at);
+      for (let i = 0; i < before.length; i++) {
+        if (before[i] === '<' && (i === 0 || /[\s(,]/.test(before[i - 1]!))) collect(before, i, names);
+      }
+    }
+    // Go: a method of a generic type declares the type's parameters again in
+    // its receiver — `func (p *Pool[T]) Get() T`, `func (LazyLoader[K, V]) …`.
+    if (node.language === 'go' && node.kind === 'method') {
+      const receiver = /^\s*func\s*\(\s*(?:[A-Za-z_]\w*\s+)?\*?\s*[A-Za-z_]\w*\s*\[/.exec(head);
+      if (receiver) collect(head, receiver[0].length - 1, names);
+    }
+    // C++: `template <typename T, class U>` on the lines just above.
+    if (node.language === 'cpp') {
+      const above = lines.slice(Math.max(0, node.startLine - 3), node.startLine).join('\n');
+      const template = /\btemplate\s*</g;
+      for (let m = template.exec(above); m; m = template.exec(above)) collect(above, m.index + m[0].length - 1, names);
+    }
+  }
+  memo.set(node.id, names);
+  return names;
+}
+
+const valueMemos = new WeakMap<ResolutionContext, Map<string, ReadonlySet<string>>>();
+
+/**
+ * A Scala def's value parameters, every curried list: `def f[A](fa: F[A])(f:
+ * A => B)(implicit G: Applicative[G])` → fa, f, G.
+ */
+function declaredValueParameters(node: Node, context: ResolutionContext): ReadonlySet<string> {
+  let memo = valueMemos.get(context);
+  if (!memo) {
+    memo = new Map();
+    valueMemos.set(context, memo);
+  }
+  const hit = memo.get(node.id);
+  if (hit) return hit;
+  const names = new Set<string>();
+  const lines = context.getFileLines?.(node.filePath) ?? context.readFile(node.filePath)?.split(/\r?\n/) ?? null;
+  if (lines) {
+    const head = lines.slice(node.startLine - 1, Math.min(node.endLine, node.startLine - 1 + HEAD_LINES)).join('\n');
+    const at = nameIndex(head, node.name);
+    if (at >= 0) {
+      let i = at + node.name.length;
+      const skipSpace = (): void => {
+        while (i < head.length && /\s/.test(head[i]!)) i++;
+      };
+      skipSpace();
+      if (head[i] === '[') {
+        const close = matchingBracket(head, i);
+        i = close < 0 ? head.length : close + 1;
+      }
+      for (skipSpace(); head[i] === '('; skipSpace()) {
+        const close = matchingBracket(head, i);
+        if (close < 0) break;
+        for (const item of splitTopLevel(head.slice(i + 1, close), false)) {
+          const bare = item.replace(/^\s*(?:@[\w.]+(?:\([^()]*\))?\s*)+/, '');
+          const param = /^\s*(?:(?:implicit|using|val|var|override|private|protected|final|inline|erased)\s+)*([A-Za-z_]\w*)\s*:/.exec(bare)?.[1];
+          if (param) names.add(param);
+        }
+        i = close + 1;
+      }
+    }
+  }
+  memo.set(node.id, names);
+  return names;
+}
+
+/**
+ * The declared name's position in its head: the whole word, past attributes
+ * and modifiers. A plain search — a declared name can be an operator (Scala's
+ * `*`, `|+|`), which no pattern built from it could match safely.
+ */
+function nameIndex(head: string, name: string): number {
+  if (!name) return -1;
+  const word = /[\w$]/;
+  for (let at = head.indexOf(name); at >= 0; at = head.indexOf(name, at + 1)) {
+    const before = at > 0 ? head[at - 1]! : '';
+    const after = head[at + name.length] ?? '';
+    if (!word.test(before) && !word.test(after)) return at;
+  }
+  return -1;
+}
+
+/** Add the parameter names of the bracket group opening at `open`. */
+function collect(text: string, open: number, names: Set<string>): void {
+  const close = matchingBracket(text, open);
+  if (close < 0) return;
+  for (const item of splitTopLevel(text.slice(open + 1, close), text[open] === '<')) {
+    // Past annotations (`@sp(Int, Long) A`, `@NonNull T`), variance and keywords.
+    const bare = item.replace(/^\s*(?:@[\w.]+(?:\([^()]*\))?\s*)+/, '');
+    const param = /^\s*(?:(?:in|out|reified|const|typename|class|struct)\s+|[+\-']\s*)*([A-Za-z_]\w*)/.exec(bare)?.[1];
+    if (param && param !== 'typename' && param !== 'class') names.add(param);
+  }
+}
+
+/**
+ * The bracket closing the one at `open`. A `[…]` list counts only square
+ * brackets and parentheses — Scala's bounds `B >: A` and `A <: AnyRef` are not
+ * angle brackets — and a `<…>` list skips the `->` / `=>` inside its bounds.
+ */
+function matchingBracket(text: string, open: number): number {
+  const angle = text[open] === '<';
+  const closer = angle ? '>' : text[open] === '[' ? ']' : ')';
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    const c = text[i]!;
+    if (c === '{' || c === ';') return -1;
+    if (isOpener(c, angle)) depth++;
+    else if (isCloser(c, angle, text[i - 1])) {
+      depth--;
+      if (depth === 0) return c === closer ? i : -1;
+    }
+  }
+  return -1;
+}
+
+function splitTopLevel(inner: string, angle: boolean): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i]!;
+    if (isOpener(c, angle)) depth++;
+    else if (isCloser(c, angle, inner[i - 1])) depth--;
+    else if (c === ',' && depth === 0) {
+      out.push(inner.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(inner.slice(start));
+  return out;
+}
+
+function isOpener(c: string, angle: boolean): boolean {
+  return c === '[' || c === '(' || (angle && c === '<');
+}
+
+function isCloser(c: string, angle: boolean, previous: string | undefined): boolean {
+  if (c === ']' || c === ')') return true;
+  return angle && c === '>' && previous !== '-' && previous !== '=';
+}
diff --git a/src/resolution/types.ts b/src/resolution/types.ts
index f3ff14a075..52d62be2ac 100644
--- a/src/resolution/types.ts
+++ b/src/resolution/types.ts
@@ -29,6 +29,9 @@ export interface UnresolvedRef {
   /** `unresolved_refs.id` when loaded from the database — post-pass cleanup
    * targets exactly this row instead of every same-key sibling (#1269). */
   rowId?: number;
+  /** The tail a ref that failed to resolve is parked under, when it is not
+   * the one its name gives (see `importBindingTail`). */
+  nameTail?: string;
 }
 
 /**
@@ -166,6 +169,13 @@ export interface ResolutionContext {
    * importing the import resolver (which itself uses name-matching helpers).
    * Minimal contexts without import resolution may omit this capability. */
   resolveImport?(ref: UnresolvedRef): ResolvedRef | null;
+  /**
+   * Whether an import specifier, written in `fromFile`, names a module outside
+   * the repository: a package that is not a relative path, a tsconfig alias, a
+   * workspace member or the repository's own package name, and that resolves
+   * to no project file. Supplied by the coordinator, like `resolveImport`.
+   */
+  isOutOfRepoImport?(source: string, fromFile: string, language: Language): boolean;
   /**
    * Project import-path aliases (tsconfig/jsconfig `paths`). Returns
    * `null` when the project doesn't define any. Cached per resolver
@@ -175,13 +185,21 @@ export interface ResolutionContext {
    */
   getProjectAliases?(): import('./path-aliases').AliasMap | null;
   /**
-   * Go module info from `go.mod` at the project root. Returns `null`
-   * when the project has no `go.mod` (non-Go projects, pre-modules
-   * Go code, or projects whose modules live in subdirectories). Used
-   * by the Go branch of import resolution to distinguish in-module
-   * cross-package imports from third-party packages.
+   * The aliases of the tsconfig / jsconfig nearest `fromFile` below the
+   * project root that declares `paths` — a monorepo app's own `@/*` — or null.
+   */
+  getNearestAliases?(fromFile: string): import('./path-aliases').AliasMap | null;
+  /**
+   * The project-relative directory (`/`-separated, `.` for the root) of
+   * the Go package an import path names, when it is a package of one of the
+   * project's own modules — the `go.mod` at the root or any `go.mod` above
+   * an indexed `.go` file (#2322) — else `null` (the standard library,
+   * third-party modules, a project with no `go.mod`). `fromFile`, the
+   * importing file, breaks a tie between two modules declaring one path.
+   * Used by the Go branch of resolution to tell in-project cross-package
+   * imports from outside ones, and to find the package's files.
    */
-  getGoModule?(): import('./go-module').GoModule | null;
+  getGoPackageDir?(importPath: string, fromFile?: string): string | null;
   /**
    * Monorepo workspace member packages, keyed by declared package name.
    * Returns `null` for single-package repos (no `workspaces` field).
@@ -212,6 +230,13 @@ export interface ResolutionContext {
    * relative resolution fails. Optional so existing callers compile.
    */
   getCppIncludeDirs?(): string[];
+  /**
+   * The import node of every C / C++ `#include`, narrowed to the path it
+   * spells and where it is written: what ./cpp-includers builds the include
+   * graph from. Optional so minimal contexts compile; it falls back to
+   * reading the import nodes themselves.
+   */
+  getCppIncludeNodes?(): Array<Pick<Node, 'id' | 'name' | 'filePath' | 'language' | 'startLine' | 'startColumn'>>;
 }
 
 /**
@@ -224,14 +249,69 @@ export interface FrameworkExtractionResult {
   references: UnresolvedRef[];
 }
 
+/**
+ * Nodes a framework can name only from several files at once, with the
+ * references that bind each — and how to recognise the ones an earlier run
+ * produced, so a run can remove those it no longer wants.
+ */
+export interface CrossFileNodes extends FrameworkExtractionResult {
+  /** The kind every one of these nodes has. */
+  kind: Node['kind'];
+  /** True for a node this pass produces, and for no node extraction does. */
+  owns(node: Node): boolean;
+}
+
+/**
+ * The navigation calls a router binds to its routes — `navigate('/login')`,
+ * `router.push('/x')` — described so a sync can find the ones a changed route
+ * may answer (see `FrameworkResolver.navigation`).
+ */
+export interface NavigationCalls {
+  /**
+   * The name tails of the calls `claimsReference` accepts as navigation —
+   * `push` for `history.push` — which find them through the failed-tail
+   * index; `claimsReference` then decides on the whole name.
+   */
+  tails: readonly string[];
+  /**
+   * The files whose navigation calls can name `route`: the path prefixes of
+   * the apps whose table it is in (`''` for every file), or null when it is
+   * not one of this router's routes.
+   */
+  scope(route: Node, context: ResolutionContext): readonly string[] | null;
+}
+
 /**
  * Framework-specific resolver
  */
 export interface FrameworkResolver {
   /** Framework name */
   name: string;
-  /** Languages this framework applies to. If omitted, applies to all languages. */
+  /**
+   * Languages this framework applies to: `extract()` runs only on files in
+   * them, and `resolve()` sees only references written in them (unless
+   * `resolveLanguages` says otherwise). If omitted, applies to all languages.
+   */
   languages?: Language[];
+  /**
+   * The languages whose references `resolve()` sees, when they are not
+   * `languages`. For a resolver that reads references in languages it
+   * extracts nothing from: SvelteKit's `$lib/…` imports and Svelte 5 runes
+   * are written in `.ts` / `.js` modules too, but only a `.svelte` file holds
+   * a route. Widening `languages` instead would run `extract()` on those
+   * files.
+   */
+  resolveLanguages?: readonly Language[];
+  /**
+   * Packages an app declares when it is built on this framework. When set,
+   * `extract()` runs only on files of an app whose package.json — the file's
+   * own or an enclosing one — declares one of them: in a monorepo with an Expo
+   * app beside a Next.js app, Expo Router must not read the Next app's
+   * `app/layout.tsx` as a `/layout` screen. When no manifest in the project
+   * declares any, detection found the framework by other evidence and the
+   * extractor runs on every file, as before.
+   */
+  appDependencies?: readonly string[];
   /** Detect if project uses this framework (project-level, called once at startup) */
   detect(context: ResolutionContext): boolean;
   /** Resolve a reference using framework-specific patterns */
@@ -242,6 +322,7 @@ export interface FrameworkResolver {
    * an attribute/descriptor, not a declared symbol (e.g. Django's
    * `self._iterable_class(...)`, React effect callbacks). Returning true lets the
    * ref reach `resolve()` instead of being dropped for having no name match.
+   * Asked only about references written in the languages `resolve()` sees.
    */
   claimsReference?(name: string): boolean;
   /**
@@ -267,6 +348,29 @@ export interface FrameworkResolver {
    * second run can recover the original in-file form from `qualifiedName`.
    */
   postExtract?(context: ResolutionContext): Node[];
+  /**
+   * Nodes no single file's `extract()` can decide on — a React Router route
+   * table written in one file is a table of routes only because another
+   * file hands it to the router. Called after `postExtract` on every index
+   * and every sync, it returns the COMPLETE set the framework wants now. The
+   * orchestrator inserts the new ones (their references pending, for the
+   * resolution that follows), removes the ones an earlier run inserted that
+   * are no longer wanted, renames the ones whose name changed, and leaves
+   * the rest alone, so an unchanged node keeps its edges. A node lives in the
+   * file it is written in, so re-extracting that file drops it until the
+   * next run puts it back.
+   */
+  crossFileNodes?(context: ResolutionContext): CrossFileNodes;
+  /**
+   * Set by a router whose `resolve()` binds a navigation call to one of its
+   * route nodes. A call whose route did not exist yet was parked as failed, or
+   * bound to whatever answered it then (a catch-all, a parameter route), and
+   * the retry that matches a failed ref's name tail against the names a sync
+   * adds (#1240) never finds it: its name is the router's method, never the
+   * route's path. So a sync that adds, removes or renames a route puts the
+   * calls this describes back for its resolution sweep.
+   */
+  navigation?: NavigationCalls;
 }
 
 /**
@@ -306,6 +410,12 @@ export type ReExport =
       kind: 'wildcard';
       /** Module specifier of the upstream module. */
       source: string;
+    }
+  | {
+      /** `export * as ns from './other'`: only `ns` is exported, the module's members through it. */
+      kind: 'namespace';
+      exportedName: string;
+      source: string;
     };
 
 /**
diff --git a/src/resolution/vbnet-receivers.ts b/src/resolution/vbnet-receivers.ts
new file mode 100644
index 0000000000..b78704a85a
--- /dev/null
+++ b/src/resolution/vbnet-receivers.ts
@@ -0,0 +1,1655 @@
+/**
+ * VB.NET receivers, projects and receiver-less calls.
+ *
+ * The name matcher guesses a `receiver.Method()` call it cannot type by the
+ * method's name alone (matchMethodCall's Strategy 3: a unique name, or the
+ * receiver sharing words with the owner), and a receiver-less call by the
+ * nearest same-named member. VB.NET brought none of the evidence C# does to
+ * those guesses, so a call landed on whichever project method shared its
+ * name: SCrawler's `ThumbnailFile.Delete(…)` on an external `SFile` went to a
+ * nested `TempFileConversion.Delete`, staxrip's main app called its AutoCrop
+ * tool's copy of `ColorHSL`. What this module reads, from the source:
+ *
+ * 1. A receiver's declared type — `Dim x As T`, `ByVal x As T`, `x As New T`,
+ *    a type character (`Dim name$`), `Dim x = New T(…)`, a `For Each` over a
+ *    typed collection, a field or property of the class, of one it inherits
+ *    (with the type arguments the subclass gives) or of a `Module`, or what
+ *    `Dim x = obj.GetString(…)` returns. A typed receiver's call is the
+ *    type's own method or one it inherits, else an extension method declared
+ *    for the type, else nothing of the project's: a type the project does
+ *    not define (`SFile`, `String`, `List(Of T)`) has none of its methods. A
+ *    member read through it (`x.Normal`, `Me._h.Title`, a `With` block's
+ *    `.Value`) is the type's member in the same way, link by link.
+ * 2. Which type a name means where it is written: the namespaces around it,
+ *    outward, then its file's and project's `Imports` (aliases included),
+ *    then the project a file belongs to — the `.vbproj` above it, whose
+ *    `RootNamespace` its namespaces are inside. Between same-named types, and
+ *    between guesses nothing else tells apart, the caller's own project's
+ *    comes first; a written qualifier (`System.Drawing.Point`) must match.
+ * 3. A receiver-less call (or one on `Me` / `MyClass` / `MyBase`, which the
+ *    extractor drops) is a member of a type around it, of what those inherit,
+ *    or of a `Module`; a type nested in a class is named bare only inside it.
+ *
+ * VB.NET's keywords and names are matched without regard to case. Nothing
+ * here runs for another language.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import type { Node } from '../types';
+import type { ResolutionContext, ResolvedRef, UnresolvedRef } from './types';
+
+/** A VB.NET declared type: its simple name (no namespace, no type arguments) and whether it is an array. */
+interface VbType {
+  name: string;
+  array: boolean;
+  /** The namespaces or types written before the name (`API.Base` in `API.Base.UserDataBase`), lowercased. */
+  qualifier?: string[];
+  /** Where the name is written, which decides the namespaces it is looked up in. */
+  file?: string;
+  line?: number;
+  /** A supertype named in an `Implements` statement: its members are not the type's own. */
+  implemented?: boolean;
+  /** The type arguments written with it: `SiteSettings` in `Checker(Of SiteSettings)`. */
+  args?: VbType[];
+}
+
+/** What a statement says a local is: its type, the call whose result it holds, or a binding that names no type. */
+type VbBinding =
+  | { kind: 'type'; type: VbType }
+  | { kind: 'call'; receiver: string | null; member: string }
+  | { kind: 'each'; collection: string }
+  | { kind: 'unknown' };
+
+/** .NET's collections of one element type: `For Each x In list` over a `List(Of T)` binds a `T`. */
+const VB_ELEMENT_COLLECTIONS = /^(?:List|IList|IEnumerable|ICollection|IReadOnlyList|IReadOnlyCollection|HashSet|SortedSet|Queue|Stack|LinkedList|ObservableCollection|Collection|ReadOnlyCollection|BindingList|ConcurrentBag|ConcurrentQueue|ConcurrentStack|BlockingCollection)$/i;
+
+/** The type of what a `For Each` over a value of type `t` binds: an array's or a .NET collection's element type. */
+function elementType(t: VbType): VbType | null {
+  if (t.array) return { ...t, array: false };
+  return t.args?.length === 1 && VB_ELEMENT_COLLECTIONS.test(t.name) && t.args[0]!.name !== '?' ? t.args[0]! : null;
+}
+
+/** VB.NET's built-in types, by keyword and by .NET name, keyed to the keyword. */
+const VB_BUILTIN_TYPES: ReadonlyMap<string, string> = new Map([
+  ...['boolean', 'byte', 'char', 'date', 'decimal', 'double', 'integer', 'long', 'object', 'sbyte', 'short', 'single',
+    'string', 'uinteger', 'ulong', 'ushort'].map((k): [string, string] => [k, k]),
+  ['int16', 'short'], ['int32', 'integer'], ['int64', 'long'], ['uint16', 'ushort'], ['uint32', 'uinteger'],
+  ['uint64', 'ulong'], ['datetime', 'date'],
+]);
+
+/** The type a type character declares: `Dim aStr$`, `For i% = 0 …`. */
+const VB_TYPE_CHARS: Readonly<Record<string, string>> = {
+  $: 'String', '%': 'Integer', '&': 'Long', '!': 'Single', '#': 'Double', '@': 'Decimal',
+};
+
+/** VB.NET's conversion functions and the built-in type each returns. */
+const VB_CONVERSIONS: Readonly<Record<string, string>> = {
+  cbool: 'Boolean', cbyte: 'Byte', cchar: 'Char', cdate: 'Date', cdbl: 'Double', cdec: 'Decimal', cint: 'Integer',
+  clng: 'Long', cobj: 'Object', csbyte: 'SByte', cshort: 'Short', csng: 'Single', cstr: 'String', cuint: 'UInteger',
+  culng: 'ULong', cushort: 'UShort',
+};
+
+/** VB.NET type nodes a member can belong to (a `Module` is indexed as a class). */
+const VB_TYPE_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'interface']);
+const VB_VALUE_KINDS: ReadonlySet<string> = new Set(['field', 'property', 'constant', 'variable']);
+const VB_MEMBER_KINDS: ReadonlySet<string> = new Set(['method', 'property', 'field', 'enum_member', 'constant', 'variable']);
+
+/** A declaration keyword right before a name: the name is a member being declared, not a variable. */
+const VB_MEMBER_HEAD = /\b(?:Function|Sub|Property|Event|Operator|Declare|Delegate|Class|Structure|Module|Interface|Enum|Namespace)\s+$/i;
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** A type's key for comparing two of them: the built-in keyword or the lowercased name, `[]` for an array. */
+function typeKey(t: VbType): string {
+  const lower = t.name.toLowerCase();
+  return `${VB_BUILTIN_TYPES.get(lower) ?? lower}${t.array ? '[]' : ''}`;
+}
+
+function isBuiltin(t: VbType): boolean {
+  return !t.array && VB_BUILTIN_TYPES.has(t.name.toLowerCase());
+}
+
+/** The index of the `)` closing the `(` at `open`, or -1. */
+function closeParen(text: string, open: number): number {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === '(') depth++;
+    else if (text[i] === ')' && --depth === 0) return i;
+  }
+  return -1;
+}
+
+/** The top-level items of the parenthesized list opening at `open`, or null when it does not close. */
+function splitArgs(text: string, open: number): string[] | null {
+  const close = closeParen(text, open);
+  if (close < 0) return null;
+  const args: string[] = [];
+  let depth = 0;
+  let cur = '';
+  for (const ch of text.slice(open + 1, close)) {
+    if (ch === '(' || ch === '{') depth++;
+    else if (ch === ')' || ch === '}') depth--;
+    if (ch === ',' && depth === 0) {
+      args.push(cur);
+      cur = '';
+    } else cur += ch;
+  }
+  args.push(cur);
+  return args.map((a) => a.trim());
+}
+
+/**
+ * The type written at `text[at]` — `List(Of Foo)`, `String()`, `Integer?`,
+ * `Global.A.B` — by its last name; null when no type starts there.
+ */
+function readType(text: string, at: number): VbType | null {
+  const head = /^\s*([A-Za-z_][\w.]*)/.exec(text.slice(at));
+  if (!head) return null;
+  let i = at + head[0].length;
+  let args: VbType[] | undefined;
+  if (/^\s*\(\s*Of\b/i.test(text.slice(i))) {
+    const open = text.indexOf('(', i);
+    const close = closeParen(text, open);
+    if (close < 0) return null;
+    args = (splitArgs(text, open) ?? []).map((a) => readType(a.replace(/^Of\s+/i, ''), 0) ?? { name: '?', array: false });
+    i = close + 1;
+  }
+  const segments = head[1]!.split('.');
+  const name = segments.pop()!;
+  if (!/^[A-Za-z_]\w*$/.test(name) || /^(?:New|Of|As|In|Out|From|With)$/i.test(name)) return null;
+  const qualifier = segments.map((s) => s.toLowerCase()).filter((s, i) => !(i === 0 && s === 'global'));
+  return {
+    name,
+    array: /^\s*\??\s*\(\s*,*\s*\)/.test(text.slice(i)),
+    ...(qualifier.length > 0 ? { qualifier } : {}),
+    ...(args ? { args } : {}),
+  };
+}
+
+/** `t` — and the type arguments written inside it — written at `file:line`. */
+function sited(t: VbType | null, file: string, line: number): VbType | null {
+  return t ? { ...t, file, line, ...(t.args ? { args: t.args.map((a) => sited(a, file, line)!) } : {}) } : null;
+}
+
+/** A VB.NET line's code: its comment dropped and every string literal emptied to `""`. */
+function vbCode(line: string): string {
+  // Most lines have neither: the line itself, without a copy.
+  if (!/["'‘’\r]/.test(line)) return line;
+  let out = '';
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i]!;
+    if (ch === '"') {
+      let j = i + 1;
+      for (; j < line.length; j++) {
+        if (line[j] !== '"') continue;
+        if (line[j + 1] === '"') j++;
+        else break;
+      }
+      out += '""';
+      i = j;
+      continue;
+    }
+    if (ch === "'" || ch === '\u2018' || ch === '\u2019' || ch === '\r') break;
+    out += ch;
+  }
+  return out;
+}
+
+const VB_CODE_LINES = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/** A file's lines as code (see vbCode), read once per file. */
+function codeLines(file: string, context: ResolutionContext): string[] {
+  let memo = VB_CODE_LINES.get(context);
+  if (!memo) VB_CODE_LINES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const lines = (context.getFileLines?.(file) ?? context.readFile(file)?.split(/\r?\n/) ?? []).map(vbCode);
+  if (memo.size >= 1024) memo.delete(memo.keys().next().value!);
+  memo.set(file, lines);
+  return lines;
+}
+
+interface VbPatterns {
+  /** The name standing where a binding names it — not as `name.Member` nor `name(args)`, which only use it. */
+  declared: RegExp;
+  /** `name As T`, `name() As T`, `name As New T`: a variable, parameter, loop or catch variable. */
+  asClause: RegExp;
+  /** `Dim name, other As T`: a declarator sharing the next one's type. */
+  listed: RegExp;
+  /** `Dim name$`, `ByVal name%`, `For i% = …`. */
+  typeChar: RegExp;
+  /** `Dim name = …`: the value's type. */
+  inferred: RegExp;
+  /** `For Each name In …`: the collection's element type, when it says it. */
+  forEach: RegExp;
+  /** A binding that names no type: `For name = …`, `Function(name)`, `From name In`, `Catch name`. */
+  loose: RegExp;
+}
+
+const VB_PATTERNS = new Map<string, VbPatterns>();
+
+function patternsFor(name: string): VbPatterns {
+  const key = name.toLowerCase();
+  const hit = VB_PATTERNS.get(key);
+  if (hit) return hit;
+  const r = escapeRegex(key);
+  const patterns: VbPatterns = {
+    declared: new RegExp(`(?<![\\w.])${r}(?![\\w.]|\\s*\\.|\\s*\\((?![\\s\\d,]*\\)))`, 'i'),
+    asClause: new RegExp(`(?<![\\w.])${r}(\\s*\\([\\s\\d,]*\\))?\\s*\\??\\s+As\\s+(New\\s+)?`, 'gi'),
+    listed: new RegExp(`\\b(?:Dim|Static)\\s+(?:[A-Za-z_]\\w*\\s*,\\s*)*${r}\\s*,[\\w\\s,]*?\\bAs\\s+`, 'i'),
+    typeChar: new RegExp(
+      `(?:\\b(?:Dim|Static|Const|ByVal|ByRef|Optional|ParamArray|Each|For|Using|Private|Public|Friend|Protected|Shared|ReadOnly|WithEvents)\\s+|[,(]\\s*)` +
+      `${r}([$%&!#@])(\\s*\\([\\s\\d,]*\\))?(?![\\w$%&!#@])`,
+      'i',
+    ),
+    inferred: new RegExp(`\\b(?:Dim|Static|Const|Using)\\s+${r}\\s*=(?!=)`, 'i'),
+    forEach: new RegExp(`\\bFor\\s+Each\\s+${r}\\s+In\\s+(.+)$`, 'i'),
+    loose: new RegExp(
+      `\\bFor\\s+(?:Each\\s+)?${r}\\b|\\b(?:From|Aggregate)\\s+${r}\\s+In\\b|\\bLet\\s+${r}\\s*=|\\bCatch\\s+${r}\\b|` +
+      `\\b(?:Function|Sub)\\s*\\((?:[^()]*,)?\\s*(?:ByVal\\s+|ByRef\\s+)?${r}\\s*[,)]`,
+      'i',
+    ),
+  };
+  if (VB_PATTERNS.size >= 4096) VB_PATTERNS.delete(VB_PATTERNS.keys().next().value!);
+  VB_PATTERNS.set(key, patterns);
+  return patterns;
+}
+
+/**
+ * What every binding of a name has on its line: a declaring keyword, or a
+ * type character. Most lines naming a variable just use it (`sb.Append(…)`).
+ */
+const VB_MAY_BIND = /\b(?:As|Dim|Static|Const|For|Each|Function|Sub|Catch|Using|From|Let|Aggregate)\b|\w[$%&!#@]/i;
+
+/** What one line of code says `name` is, or undefined when it doesn't bind the name. */
+function bindingOn(code: string, name: string): VbBinding | undefined {
+  if (!VB_MAY_BIND.test(code)) return undefined;
+  const p = patternsFor(name);
+  if (!p.declared.test(code)) return undefined;
+  p.asClause.lastIndex = 0;
+  for (let m = p.asClause.exec(code); m; m = p.asClause.exec(code)) {
+    if (VB_MEMBER_HEAD.test(code.slice(0, m.index))) continue;
+    const type = readType(code, m.index + m[0].length);
+    if (!type) return { kind: 'unknown' };
+    // `As New T(…)`: the parentheses are the constructor's.
+    return { kind: 'type', type: m[2] ? { ...type, array: false } : { ...type, array: type.array || !!m[1] } };
+  }
+  const listed = p.listed.exec(code);
+  if (listed) {
+    const type = readType(code, listed.index + listed[0].length);
+    return type ? { kind: 'type', type } : { kind: 'unknown' };
+  }
+  const typeChar = p.typeChar.exec(code);
+  if (typeChar) return { kind: 'type', type: { name: VB_TYPE_CHARS[typeChar[1]!]!, array: !!typeChar[2] } };
+  // An assignment (`x = New Channel`) says nothing: the declared type
+  // (`Dim x As IYouTubeMediaContainer`) is what the call binds to.
+  const inferred = p.inferred.exec(code);
+  if (inferred) return valueBinding(code.slice(inferred.index + inferred[0].length));
+  // `For Each c In controls.OfType(Of ButtonLabel)`: the loop's elements are
+  // that type; `For Each user In users`: the elements of what `users` is.
+  const loop = p.forEach.exec(code);
+  if (loop) {
+    const collection = loop[1]!.trim();
+    const elements = /\.\s*(?:OfType|Cast)\s*\(\s*Of\s+/i.exec(collection);
+    const type = elements && /^[^()]*\)\s*(?:\(\s*\))?\s*$/.test(collection.slice(elements.index + elements[0].length))
+      ? readType(collection, elements.index + elements[0].length) : null;
+    if (type) return { kind: 'type', type };
+    return /^[A-Za-z_]\w*$/.test(collection) ? { kind: 'each', collection } : { kind: 'unknown' };
+  }
+  return p.loose.test(code) ? { kind: 'unknown' } : undefined;
+}
+
+/** What a local initialized with `expr` (`Dim x = expr`) is. */
+function valueBinding(expr: string): VbBinding {
+  const e = expr.split(/\s:(?!=)/)[0]!.trim();
+  const unknown: VbBinding = { kind: 'unknown' };
+  const created = /^New\s+/i.exec(e);
+  if (created) {
+    const type = readType(e, created[0].length);
+    return type ? { kind: 'type', type: { ...type, array: false } } : unknown;
+  }
+  const cast = /^(?:DirectCast|TryCast|CType)\s*\(/i.exec(e);
+  if (cast) {
+    const args = splitArgs(e, cast[0].length - 1);
+    const type = args?.length === 2 ? readType(args[1]!, 0) : null;
+    return type ? { kind: 'type', type } : unknown;
+  }
+  if (/^\$?""/.test(e)) return { kind: 'type', type: { name: 'String', array: false } };
+  const conversion = /^(C[A-Za-z]+)\s*\(/.exec(e);
+  const converted = conversion ? VB_CONVERSIONS[conversion[1]!.toLowerCase()] : undefined;
+  if (converted) return { kind: 'type', type: { name: converted, array: false } };
+  // `obj.Member(…)`, `Member(…)`, `Me.Member`: a call or a read as the whole value.
+  const call = /^(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*/.exec(e);
+  if (call) {
+    let rest = e.slice(call[0].length);
+    if (rest.startsWith('(')) {
+      const close = closeParen(rest, 0);
+      rest = close < 0 ? 'unclosed' : rest.slice(close + 1).trim();
+    }
+    if (rest === '') return { kind: 'call', receiver: call[1] ?? null, member: call[2]! };
+  }
+  return unknown;
+}
+
+/** The 0-based line a call's own declarations start on: its member's first line, which holds a method's parameters. */
+function scopeStartLine(ref: UnresolvedRef, context: ResolutionContext): number {
+  const from = context.getNodeById?.(ref.fromNodeId);
+  if (from && from.filePath === ref.filePath && from.startLine <= ref.line && from.endLine >= ref.line &&
+      (from.kind === 'method' || from.kind === 'function' || from.kind === 'property' || from.kind === 'field')) {
+    return from.startLine - 1;
+  }
+  let start = -1;
+  for (const n of context.getNodesInFile(ref.filePath)) {
+    if (n.kind !== 'method' && n.kind !== 'function' && n.kind !== 'property') continue;
+    if (n.startLine <= ref.line && n.endLine >= ref.line && n.startLine - 1 > start) start = n.startLine - 1;
+  }
+  return start < 0 ? ref.line - 1 : start;
+}
+
+const VB_WORD_LINES = new WeakMap<ResolutionContext, Map<string, Map<string, number[]>>>();
+
+/**
+ * The 0-based lines of a file's code each lowercased word appears on, in
+ * order: a call's receiver is looked for only on the lines that name it,
+ * not on every line back to its method's start (a long method's calls each
+ * rescanned it).
+ */
+function wordLines(file: string, context: ResolutionContext): Map<string, number[]> {
+  let memo = VB_WORD_LINES.get(context);
+  if (!memo) VB_WORD_LINES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const index = new Map<string, number[]>();
+  const words = /[A-Za-z_]\w*/g;
+  const lines = codeLines(file, context);
+  for (let i = 0; i < lines.length; i++) {
+    const code = lines[i]!.toLowerCase();
+    words.lastIndex = 0;
+    for (let m = words.exec(code); m; m = words.exec(code)) {
+      let at = index.get(m[0]);
+      if (!at) index.set(m[0], (at = []));
+      if (at[at.length - 1] !== i) at.push(i);
+    }
+  }
+  if (memo.size >= 256) memo.delete(memo.keys().next().value!);
+  memo.set(file, index);
+  return index;
+}
+
+const VB_BINDINGS = new WeakMap<ResolutionContext, Map<string, Array<{ line: number; binding: VbBinding }>>>();
+
+/**
+ * Every statement of a file that binds `name`, by 0-based line — read once:
+ * staxrip's `GetArgs` methods call `sb.Append(…)` on hundreds of lines, each
+ * of which would otherwise walk back over all the others to the `Dim sb`.
+ */
+function bindingsOf(name: string, file: string, context: ResolutionContext): Array<{ line: number; binding: VbBinding }> {
+  let memo = VB_BINDINGS.get(context);
+  if (!memo) VB_BINDINGS.set(context, (memo = new Map()));
+  const key = `${file}|${name.toLowerCase()}`;
+  const hit = memo.get(key);
+  if (hit) return hit;
+  const lines = codeLines(file, context);
+  const found: Array<{ line: number; binding: VbBinding }> = [];
+  for (const i of wordLines(file, context).get(name.toLowerCase()) ?? []) {
+    const binding = bindingOn(lines[i]!, name);
+    if (binding) found.push({ line: i, binding });
+  }
+  if (memo.size >= 65536) memo.delete(memo.keys().next().value!);
+  memo.set(key, found);
+  return found;
+}
+
+/** The nearest statement above a call (in its member) that binds `name`, and its 1-based line. */
+function localBinding(name: string, ref: UnresolvedRef, context: ResolutionContext): { binding: VbBinding; line: number } | undefined {
+  const found = bindingsOf(name, ref.filePath, context);
+  // The last binding at or above the call's line.
+  let lo = 0;
+  let hi = found.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    if (found[mid]!.line <= ref.line - 1) lo = mid + 1;
+    else hi = mid;
+  }
+  const nearest = found[lo - 1];
+  return nearest && nearest.line >= scopeStartLine(ref, context) ? { binding: nearest.binding, line: nearest.line + 1 } : undefined;
+}
+
+const VB_FILE_TYPES = new WeakMap<ResolutionContext, Map<string, Node[]>>();
+
+/** The VB.NET types a line is written inside, innermost first. */
+function typesAround(file: string, line: number, context: ResolutionContext): Node[] {
+  let memo = VB_FILE_TYPES.get(context);
+  if (!memo) VB_FILE_TYPES.set(context, (memo = new Map()));
+  let types = memo.get(file);
+  if (!types) {
+    types = context.getNodesInFile(file)
+      .filter((n) => n.language === 'vbnet' && VB_TYPE_KINDS.has(n.kind))
+      .sort((a, b) => b.startLine - a.startLine);
+    if (memo.size >= 1024) memo.delete(memo.keys().next().value!);
+    memo.set(file, types);
+  }
+  return types.filter((n) => n.startLine <= line && n.endLine >= line);
+}
+
+/** The project's VB.NET types (classes, modules, structures, interfaces — or `kinds`) named `name`, case aside. */
+function projectTypesNamed(name: string, context: ResolutionContext, kinds: ReadonlySet<string> = VB_TYPE_KINDS): Node[] {
+  return context.getNodesByLowerName(name.toLowerCase()).filter((n) => n.language === 'vbnet' && kinds.has(n.kind));
+}
+
+const VB_FILE_QNS = new WeakMap<ResolutionContext, Map<string, Map<string, Node[]>>>();
+
+/** A file's VB.NET nodes by lowercased qualified name, indexed once. */
+function nodesByQualifiedName(file: string, context: ResolutionContext): Map<string, Node[]> {
+  let memo = VB_FILE_QNS.get(context);
+  if (!memo) VB_FILE_QNS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const index = new Map<string, Node[]>();
+  for (const n of context.getNodesInFile(file)) {
+    if (n.language !== 'vbnet') continue;
+    const key = n.qualifiedName.toLowerCase();
+    const list = index.get(key);
+    if (list) list.push(n);
+    else index.set(key, [n]);
+  }
+  if (memo.size >= 1024) memo.delete(memo.keys().next().value!);
+  memo.set(file, index);
+  return index;
+}
+
+const VB_MEMBERS = new WeakMap<ResolutionContext, Map<string, Node[]>>();
+
+/**
+ * Members named `name` declared directly in `type` (any partial part of it),
+ * case aside. A member is declared inside a part of its type, so it is looked
+ * up in those parts' files: one lookup per type name, not one per member name.
+ */
+function membersNamed(type: Node, name: string, context: ResolutionContext): Node[] {
+  let memo = VB_MEMBERS.get(context);
+  if (!memo) VB_MEMBERS.set(context, (memo = new Map()));
+  const qn = `${type.qualifiedName}::${name}`.toLowerCase();
+  const hit = memo.get(qn);
+  if (hit) return hit;
+  const own = type.qualifiedName.toLowerCase();
+  const files = new Set([type.filePath]);
+  for (const part of context.getNodesByLowerName(type.name.toLowerCase())) {
+    if (part.language === 'vbnet' && part.qualifiedName.toLowerCase() === own) files.add(part.filePath);
+  }
+  const members = [...files].flatMap((file) => nodesByQualifiedName(file, context).get(qn) ?? []);
+  if (memo.size >= 65536) memo.delete(memo.keys().next().value!);
+  memo.set(qn, members);
+  return members;
+}
+
+const VB_MODULES = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** Whether a VB.NET owner (by qualified name) is a `Module`, whose members are reached without a qualifier. */
+function isModule(ownerQn: string, context: ResolutionContext): boolean {
+  let memo = VB_MODULES.get(context);
+  if (!memo) VB_MODULES.set(context, (memo = new Map()));
+  const hit = memo.get(ownerQn);
+  if (hit !== undefined) return hit;
+  // Its own head line or the two after it (attributes may come first); the raw
+  // lines, as the whole file need not be read as code for this.
+  const module = context.getNodesByQualifiedName(ownerQn).some((n) => n.language === 'vbnet' && n.kind === 'class' &&
+    (context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? []).slice(n.startLine - 1, n.startLine + 2)
+      .some((l) => /^\s*(?:<[^>]*>\s*)*(?:(?:Public|Friend|Private|Partial)\s+)*Module\s/i.test(l)));
+  memo.set(ownerQn, module);
+  return module;
+}
+
+/** The members named `name` of the project's Modules, which code reaches without a qualifier — the caller's project's first. */
+function moduleMembersNamed(name: string, ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  const members = context.getNodesByLowerName(name.toLowerCase()).filter((n) => {
+    const cut = n.qualifiedName.lastIndexOf('::');
+    return n.language === 'vbnet' && cut > 0 && isModule(n.qualifiedName.slice(0, cut), context);
+  });
+  return preferVbProject(members, ref, context);
+}
+
+const VB_SUPERS = new WeakMap<ResolutionContext, Map<string, VbType[]>>();
+
+/**
+ * The types a VB.NET type's declarations (every `Partial` part) inherit or
+ * implement: the `Inherits` / `Implements` statements that open its body,
+ * including the `Class X : Inherits Y` form.
+ */
+function supertypesOf(type: Node, context: ResolutionContext): VbType[] {
+  let memo = VB_SUPERS.get(context);
+  if (!memo) VB_SUPERS.set(context, (memo = new Map()));
+  const key = type.qualifiedName.toLowerCase();
+  const hit = memo.get(key);
+  if (hit) return hit;
+  const supers: VbType[] = [];
+  const parts = context.getNodesByQualifiedName(type.qualifiedName).filter((n) => n.language === 'vbnet' && VB_TYPE_KINDS.has(n.kind));
+  for (const part of parts.length > 0 ? parts : [type]) {
+    const lines = codeLines(part.filePath, context);
+    scan: for (let i = part.startLine - 1; i < Math.min(lines.length, part.startLine + 12, part.endLine); i++) {
+      for (const statement of lines[i]!.split(/:(?!=)/)) {
+        const s = statement.trim();
+        // Blank, an attribute, a directive, or the declaration's own head.
+        if (s === '' || /^<.*>$/.test(s) || s.startsWith('#') || /\b(?:Class|Structure|Interface|Module)\s+[A-Za-z_]/i.test(s) && !/^(?:Inherits|Implements)\b/i.test(s)) continue;
+        const clause = /^(Inherits|Implements)\s+(.+)$/i.exec(s);
+        if (!clause) break scan;
+        for (const sup of splitArgs(`(${clause[2]})`, 0) ?? []) {
+          const t = sited(readType(sup, 0), part.filePath, part.startLine);
+          if (t) supers.push(/^Implements$/i.test(clause[1]!) ? { ...t, implemented: true } : t);
+        }
+      }
+    }
+  }
+  memo.set(key, supers);
+  return supers;
+}
+
+/** A type a VB.NET type inherits, with what its type parameters stand for there (`T` → `SiteSettings`). */
+interface VbAncestor {
+  node: Node;
+  args: Map<string, VbType>;
+}
+
+const VB_ANCESTRIES = new WeakMap<ResolutionContext, Map<string, VbAncestor[]>>();
+
+/** `t` with a type parameter replaced by what `args` says it stands for. */
+function substitute(t: VbType, args: ReadonlyMap<string, VbType>): VbType {
+  return (!t.qualifier && !t.array && args.get(t.name.toLowerCase())) || t;
+}
+
+/**
+ * A VB.NET type and the project types it inherits, nearest first: a class's
+ * base classes, an interface's base interfaces — whose members are the
+ * type's own. Each carries the type arguments `Inherits Checker(Of
+ * SiteSettings)` gives its parameters. An interface a class implements lends
+ * it no members: they are reached through the class's own `… Implements
+ * IFoo.Bar` ones.
+ */
+function ancestry(type: Node, context: ResolutionContext): VbAncestor[] {
+  let memo = VB_ANCESTRIES.get(context);
+  if (!memo) VB_ANCESTRIES.set(context, (memo = new Map()));
+  const hit = memo.get(type.id);
+  if (hit) return hit;
+  const out: VbAncestor[] = [];
+  const seen = new Set<string>();
+  const queue: VbAncestor[] = [{ node: type, args: new Map() }];
+  while (queue.length > 0 && out.length < 16) {
+    const current = queue.shift()!;
+    const key = current.node.qualifiedName.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(current);
+    for (const sup of supertypesOf(current.node, context)) {
+      if (sup.implemented) continue;
+      const found = typesNamedAt(sup, context);
+      if (found.ambiguous) continue;
+      const given = (sup.args ?? []).map((a) => substitute(a, current.args));
+      for (const base of found.owners) {
+        const params = [...typeParametersOf(base, context).keys()];
+        queue.push({ node: base, args: new Map(params.flatMap((p, i): Array<[string, VbType]> => (given[i] ? [[p, given[i]!]] : []))) });
+      }
+    }
+  }
+  memo.set(type.id, out);
+  return out;
+}
+
+/** A VB.NET type and the project types it inherits, nearest first (see ancestry). */
+function hierarchy(type: Node, context: ResolutionContext): Node[] {
+  return ancestry(type, context).map((a) => a.node);
+}
+
+const VB_PROJECTS = new WeakMap<ResolutionContext, Map<string, string | null>>();
+
+/** The directory of the nearest `.vbproj` at or above `dir` (`''` for the root), or null outside any project. */
+function projectOfDir(dir: string, context: ResolutionContext, memo: Map<string, string | null>): string | null {
+  const hit = memo.get(dir);
+  if (hit !== undefined) return hit;
+  let found: string | null = null;
+  try {
+    if (fs.readdirSync(path.join(context.getProjectRoot(), dir)).some((e) => /\.vbproj$/i.test(e))) found = dir;
+  } catch {
+    // Unreadable: no project file here.
+  }
+  if (found === null && dir !== '') {
+    const cut = dir.lastIndexOf('/');
+    found = projectOfDir(cut < 0 ? '' : dir.slice(0, cut), context, memo);
+  }
+  memo.set(dir, found);
+  return found;
+}
+
+/** The project (the directory of the nearest `.vbproj` above it) a file belongs to, or null. */
+function projectOf(file: string, context: ResolutionContext): string | null {
+  let memo = VB_PROJECTS.get(context);
+  if (!memo) VB_PROJECTS.set(context, (memo = new Map()));
+  const cut = file.lastIndexOf('/');
+  return projectOfDir(cut < 0 ? '' : file.slice(0, cut), context, memo);
+}
+
+/** Whether two files are in the same VB.NET project — false when either is in none. */
+export function sameVbProject(a: string, b: string, context: ResolutionContext): boolean {
+  const project = projectOf(a, context);
+  return project !== null && project === projectOf(b, context);
+}
+
+interface VbProjectInfo {
+  /** The root namespace every file of the project declares its namespaces inside, as segments. */
+  root: string[];
+  /** The namespaces the project imports into every file (`<Import Include="…" />`). */
+  imports: string[];
+}
+
+const VB_PROJECT_INFO = new WeakMap<ResolutionContext, Map<string, VbProjectInfo>>();
+
+/** A file's project's root namespace (`<RootNamespace>`, else the project's name) and project-wide imports, lowercased. */
+function projectInfo(file: string, context: ResolutionContext): VbProjectInfo {
+  const dir = projectOf(file, context);
+  if (dir === null) return { root: [], imports: [] };
+  let memo = VB_PROJECT_INFO.get(context);
+  if (!memo) VB_PROJECT_INFO.set(context, (memo = new Map()));
+  const hit = memo.get(dir);
+  if (hit) return hit;
+  const info: VbProjectInfo = { root: [], imports: [] };
+  try {
+    const abs = path.join(context.getProjectRoot(), dir);
+    const project = fs.readdirSync(abs).find((e) => /\.vbproj$/i.test(e));
+    if (project) {
+      const text = fs.readFileSync(path.join(abs, project), 'utf8');
+      const root = /<RootNamespace>\s*([\w.]*)\s*<\/RootNamespace>/i.exec(text)?.[1] ?? project.replace(/\.vbproj$/i, '');
+      info.root = root.toLowerCase().split('.').filter((s) => s !== '');
+      for (const m of text.matchAll(/<Import\s+Include\s*=\s*"([\w.]+)"/gi)) info.imports.push(m[1]!.toLowerCase());
+    }
+  } catch {
+    // Unreadable project file: no root namespace, no project imports.
+  }
+  memo.set(dir, info);
+  return info;
+}
+
+/** A node's full qualified name as segments: its project's root namespace, then its namespaces and types. */
+function fullSegments(n: Node, context: ResolutionContext): string[] {
+  return [...projectInfo(n.filePath, context).root, ...n.qualifiedName.toLowerCase().split('::').flatMap((s) => s.split('.'))];
+}
+
+/** A file's lines before its first declaration: where its `Option` and `Imports` statements are. */
+function headerLines(file: string, context: ResolutionContext): string[] {
+  const lines = codeLines(file, context);
+  const end = lines.findIndex((l) =>
+    /^\s*(?:Namespace|Module|Class|Structure|Interface|Enum|Delegate|Public|Friend|Private|Protected|Partial|NotInheritable|MustInherit)\b/i.test(l));
+  return end < 0 ? lines : lines.slice(0, end);
+}
+
+const VB_FILE_IMPORTS = new WeakMap<ResolutionContext, Map<string, string[]>>();
+
+/** The namespaces a file imports — its own `Imports` and its project's — lowercased. */
+function importedNamespaces(file: string, context: ResolutionContext): string[] {
+  let memo = VB_FILE_IMPORTS.get(context);
+  if (!memo) VB_FILE_IMPORTS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const imports = [...projectInfo(file, context).imports];
+  for (const line of headerLines(file, context)) {
+    const m = /^\s*Imports\s+([\w.]+)\s*$/i.exec(line);
+    if (m) imports.push(m[1]!.toLowerCase().replace(/^global\./, ''));
+  }
+  memo.set(file, imports);
+  return imports;
+}
+
+const VB_ALIASES = new WeakMap<ResolutionContext, Map<string, Map<string, VbType>>>();
+
+/** A file's import aliases: `Imports TDJob = SCrawler.DownloadObjects.TDownloader.Job`, by lowercased alias. */
+function importAliases(file: string, context: ResolutionContext): Map<string, VbType> {
+  let memo = VB_ALIASES.get(context);
+  if (!memo) VB_ALIASES.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const aliases = new Map<string, VbType>();
+  for (const line of headerLines(file, context)) {
+    const m = /^\s*Imports\s+([A-Za-z_]\w*)\s*=\s*(.+)$/i.exec(line);
+    const target = m ? readType(m[2]!, 0) : null;
+    if (target) aliases.set(m![1]!.toLowerCase(), target);
+  }
+  memo.set(file, aliases);
+  return aliases;
+}
+
+/** `t` with an import alias it is written with — as itself or as its first qualifier — spelled out. */
+function unalias(t: VbType, file: string, context: ResolutionContext): VbType {
+  const aliases = importAliases(file, context);
+  if (aliases.size === 0) return t;
+  if (!t.qualifier) {
+    const target = aliases.get(t.name.toLowerCase());
+    return target ? { ...t, name: target.name, ...(target.qualifier ? { qualifier: target.qualifier } : {}) } : t;
+  }
+  const target = aliases.get(t.qualifier[0]!);
+  return target ? { ...t, qualifier: [...(target.qualifier ?? []), target.name.toLowerCase(), ...t.qualifier.slice(1)] } : t;
+}
+
+/** Whether `tail` is the end of `full`. */
+function endsWith(full: string[], tail: string[]): boolean {
+  return tail.length <= full.length && tail.every((s, i) => full[full.length - tail.length + i] === s);
+}
+
+const VB_TYPE_LIKE_KINDS: ReadonlySet<string> = new Set(['class', 'struct', 'interface', 'enum', 'type_alias']);
+
+/** The class, structure or interface (not a `Module`) a VB.NET type is nested in, or null. */
+function enclosingType(n: Node, context: ResolutionContext): Node | null {
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return null;
+  const parentQn = n.qualifiedName.slice(0, cut);
+  const parent = context.getNodesByQualifiedName(parentQn).find((p) => p.language === 'vbnet' && VB_TYPE_KINDS.has(p.kind));
+  return parent && !isModule(parentQn, context) ? parent : null;
+}
+
+function isNestedInType(n: Node, context: ResolutionContext): boolean {
+  return enclosingType(n, context) !== null;
+}
+
+const VB_BASE_NAMES = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/**
+ * The lowercased names of the types around a line and of the classes they
+ * inherit, walked by name (a few levels): the types whose nested types code
+ * there names bare — `Dim ret As New MenuList` in a `VideoEncoder` subclass.
+ */
+function baseTypeNamesAround(file: string, line: number, context: ResolutionContext): Set<string> {
+  const around = typesAround(file, line, context);
+  let memo = VB_BASE_NAMES.get(context);
+  if (!memo) VB_BASE_NAMES.set(context, (memo = new Map()));
+  const key = around.map((t) => t.id).join('|');
+  const hit = memo.get(key);
+  if (hit) return hit;
+  const names = new Set<string>();
+  let frontier = around;
+  for (let depth = 0; depth < 5 && frontier.length > 0; depth++) {
+    const next: Node[] = [];
+    for (const t of frontier) {
+      if (names.has(t.name.toLowerCase())) continue;
+      names.add(t.name.toLowerCase());
+      for (const sup of supertypesOf(t, context)) if (!sup.implemented) next.push(...projectTypesNamed(sup.name, context));
+    }
+    frontier = next;
+  }
+  memo.set(key, names);
+  return names;
+}
+
+/**
+ * Whether a type is one a name written with this qualifier can mean: its
+ * namespaces and outer types end with what is written before the name.
+ * Designer code's `New System.Drawing.Point(3, 3)` is not staxrip's nested
+ * `ButtonEx.SymbolDrawer.Point`; `New API.Base.UserDataBase(…)` is that one.
+ */
+export function isVbTypeQualifiedBy(n: Node, qualifier: string, file: string, context: ResolutionContext): boolean {
+  if (n.language !== 'vbnet' || !VB_TYPE_LIKE_KINDS.has(n.kind)) return true;
+  const written = readType(`${qualifier}.${n.name}`, 0);
+  if (!written?.qualifier) return true;
+  const t = unalias(written, file, context);
+  return !t.qualifier || endsWith(fullSegments(n, context).slice(0, -1), t.qualifier);
+}
+
+/**
+ * The project types a type name written at a site means, as VB.NET looks it
+ * up: one its written qualifier names, nested in or declared in the namespace
+ * of a type around the site — the nearest first — else nested in a class
+ * those inherit, else in a namespace the file or project imports, else in
+ * the site's own project (a class's nested type only where it is in scope).
+ * SCrawler declares
+ * a `SiteSettings` in each site's namespace (`API.Pinterest`, `API.Bluesky`,
+ * …); a member typed `SiteSettings` in `API.Pinterest.UserData` is
+ * Pinterest's. `ambiguous` when what is left are different types. `kinds`
+ * widens the types looked for (an `Enum` a value is read through).
+ */
+function typesNamedAt(
+  written: VbType,
+  context: ResolutionContext,
+  kinds: ReadonlySet<string> = VB_TYPE_KINDS,
+): { owners: Node[]; ambiguous: boolean } {
+  const t = written.file ? unalias(written, written.file, context) : written;
+  let candidates = projectTypesNamed(t.name, context, kinds);
+  // `System.Drawing.Color` is not the project's `Color`; `API.Base.UserDataBase` is that one.
+  if (t.qualifier) candidates = candidates.filter((c) => endsWith(fullSegments(c, context).slice(0, -1), t.qualifier!));
+  if (candidates.length === 0 || !t.file) return { owners: candidates, ambiguous: false };
+  const file = t.file;
+  const site = typesAround(file, t.line ?? 0, context)[0];
+  const sitePath = site ? fullSegments(site, context) : projectInfo(file, context).root;
+  let tier: Node[] = [];
+  let best = -1;
+  for (const c of candidates) {
+    const container = fullSegments(c, context).slice(0, -1);
+    if (container.length > sitePath.length || container.some((s, i) => s !== sitePath[i])) continue;
+    if (container.length > best) {
+      best = container.length;
+      tier = [c];
+    } else if (container.length === best) tier.push(c);
+  }
+  // A type nested in a class the site's types inherit.
+  if (tier.length === 0 && !t.qualifier) {
+    const bases = baseTypeNamesAround(file, t.line ?? 0, context);
+    tier = candidates.filter((c) => bases.has(enclosingType(c, context)?.name.toLowerCase() ?? ''));
+  }
+  if (tier.length === 0) {
+    const imports = importedNamespaces(file, context);
+    tier = candidates.filter((c) => imports.includes(fullSegments(c, context).slice(0, -1).join('.')));
+  }
+  // Else any the project declares in a namespace (the root namespaces and
+  // project imports this cannot see) — but not a class's nested type, which
+  // is named bare only inside it or a class deriving from it.
+  if (tier.length === 0) tier = t.qualifier ? candidates : candidates.filter((c) => !isNestedInType(c, context));
+  // A project's own declaration over another project's of the same name
+  // (staxrip's main app and its AutoCrop tool each declare a `ColorHSL`).
+  const own = tier.filter((c) => sameVbProject(c.filePath, file, context));
+  if (own.length > 0) tier = own;
+  // One type's partial parts are one type.
+  const distinct = new Set(tier.map((c) => `${projectOf(c.filePath, context)}|${c.qualifiedName.toLowerCase()}`));
+  return { owners: [...tier.filter((c) => c.filePath === file), ...tier.filter((c) => c.filePath !== file)], ambiguous: distinct.size > 1 };
+}
+
+/** The call site's own file first, then its project's, the rest after, each in its given order. */
+export function preferVbProject(nodes: Node[], ref: UnresolvedRef, context: ResolutionContext): Node[] {
+  if (nodes.length < 2) return nodes;
+  const file: Node[] = [];
+  const project: Node[] = [];
+  const rest: Node[] = [];
+  for (const n of nodes) {
+    if (n.filePath === ref.filePath) file.push(n);
+    else if (sameVbProject(n.filePath, ref.filePath, context)) project.push(n);
+    else rest.push(n);
+  }
+  return [...file, ...project, ...rest];
+}
+
+/** How many leading directories two files share. */
+function sharedDirs(a: string, b: string): number {
+  const da = a.split('/').slice(0, -1);
+  const db = b.split('/').slice(0, -1);
+  let i = 0;
+  while (i < da.length && i < db.length && da[i] === db[i]) i++;
+  return i;
+}
+
+/**
+ * The one of several equally good guesses a call means: the one in its own
+ * file, else in its own project, else in the nearest directory — or null
+ * when none of these tells them apart.
+ */
+export function breakVbTie(tied: Node[], ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  // One type's overloads (and partial parts) are one guess, not a tie: the first stands for them.
+  const seen = new Set<string>();
+  const distinct = tied.filter((n) => {
+    const key = `${projectOf(n.filePath, context)}|${n.qualifiedName.toLowerCase()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  if (distinct.length === 1) return distinct[0]!;
+  let pool = distinct.filter((n) => n.filePath === ref.filePath);
+  if (pool.length === 0) {
+    const own = distinct.filter((n) => sameVbProject(n.filePath, ref.filePath, context));
+    pool = own.length > 0 ? own : distinct;
+  }
+  if (pool.length === 1) return pool[0]!;
+  let best = -1;
+  let winners: Node[] = [];
+  for (const n of pool) {
+    const shared = sharedDirs(ref.filePath, n.filePath);
+    if (shared > best) {
+      best = shared;
+      winners = [n];
+    } else if (shared === best) winners.push(n);
+  }
+  return winners.length === 1 ? winners[0]! : null;
+}
+
+/** The type a field or property declares itself with, read from its declaration. */
+function memberDeclaredType(member: Node, context: ResolutionContext): VbType | null {
+  const code = codeLines(member.filePath, context).slice(member.startLine - 1, member.startLine + 2).join(' ');
+  const r = escapeRegex(member.name);
+  const property = new RegExp(`\\bProperty\\s+${r}\\b\\s*`, 'i').exec(code);
+  if (property) {
+    let at = property.index + property[0].length;
+    if (code[at] === '(') {
+      const close = closeParen(code, at);
+      if (close < 0) return null;
+      at = close + 1;
+    }
+    const as = /^\s*As\s+(New\s+)?/i.exec(code.slice(at));
+    const type = as ? readType(code, at + as[0].length) : null;
+    return type && as?.[1] ? { ...type, array: false } : type;
+  }
+  const binding = bindingOn(code, member.name);
+  if (binding?.kind === 'type') return binding.type;
+  // `Private x = New Foo()`: a field's initializer is what it holds.
+  const init = new RegExp(`(?<![\\w.])${r}\\s*=(?!=)`, 'i').exec(code);
+  const value = init ? valueBinding(code.slice(init.index + init[0].length)) : null;
+  return value?.kind === 'type' ? value.type : null;
+}
+
+/**
+ * The type a value member — a field, a property, or a function read without
+ * parentheses — has, as written at it; a type parameter of its class is what
+ * `args` gives it where it is reached from.
+ */
+function valueMemberType(member: Node, context: ResolutionContext, args: ReadonlyMap<string, VbType> = new Map()): VbType | null {
+  const type = sited(member.kind === 'method' ? declaredReturnType(member, context) : memberDeclaredType(member, context),
+    member.filePath, member.startLine);
+  const given = type ? substitute(type, args) : null;
+  return given !== type ? given : resolveTypeParameter(type, member, context);
+}
+
+/**
+ * The type of what a receiver-less `name` reads where a call is: a member of
+ * a class around the call or of one it inherits, else of a `Module`. Null when
+ * it declares no type the source shows, undefined when nothing has the name.
+ */
+function memberType(name: string, ref: UnresolvedRef, context: ResolutionContext): VbType | null | undefined {
+  const fits = (n: Node) => VB_VALUE_KINDS.has(n.kind) || n.kind === 'method';
+  for (const around of typesAround(ref.filePath, ref.line, context)) {
+    for (const { node, args } of ancestry(around, context)) {
+      const member = membersNamed(node, name, context).find(fits);
+      if (member) return valueMemberType(member, context, args);
+    }
+  }
+  const global = moduleMembersNamed(name, ref, context).find(fits);
+  return global ? valueMemberType(global, context) : undefined;
+}
+
+/** The type a method, function or property returns, read from its declaration; null for a `Sub` or none written. */
+function declaredReturnType(n: Node, context: ResolutionContext): VbType | null {
+  const code = codeLines(n.filePath, context).slice(n.startLine - 1, n.startLine + 6).join(' ');
+  const head = new RegExp(`\\b(Function|Property|Sub)\\s+${escapeRegex(n.name)}\\b`, 'i').exec(code);
+  if (!head || /^Sub$/i.test(head[1]!)) return null;
+  let at = head.index + head[0].length;
+  // `(Of T)`, then the parameter list.
+  for (let group = 0; group < 2; group++) {
+    const open = /^\s*\(/.exec(code.slice(at));
+    if (!open) break;
+    const close = closeParen(code, at + open[0].length - 1);
+    if (close < 0) return null;
+    at = close + 1;
+  }
+  const as = /^\s*As\s+/i.exec(code.slice(at));
+  return as ? readType(code, at + as[0].length) : null;
+}
+
+const VB_TYPE_PARAMS = new WeakMap<ResolutionContext, Map<string, Map<string, VbType | null>>>();
+
+/** The type parameters a declaration's head names (`Class Repo(Of T As Entity)`), each with its constraint or null. */
+function typeParametersOf(n: Node, context: ResolutionContext): Map<string, VbType | null> {
+  let memo = VB_TYPE_PARAMS.get(context);
+  if (!memo) VB_TYPE_PARAMS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit) return hit;
+  const params = readTypeParameters(n, context);
+  memo.set(n.id, params);
+  return params;
+}
+
+function readTypeParameters(n: Node, context: ResolutionContext): Map<string, VbType | null> {
+  const params = new Map<string, VbType | null>();
+  const code = codeLines(n.filePath, context).slice(n.startLine - 1, n.startLine + 2).join(' ');
+  const head = new RegExp(`\\b(?:Class|Structure|Interface|Module|Function|Sub)\\s+${escapeRegex(n.name)}\\s*(?=\\(\\s*Of\\b)`, 'i').exec(code);
+  if (!head) return params;
+  for (const p of splitArgs(code, head.index + head[0].length) ?? []) {
+    const m = /^(?:Of\s+)?(?:In\s+|Out\s+)?([A-Za-z_]\w*)(?:\s+As\s+(.+))?$/i.exec(p);
+    if (!m) continue;
+    const constraints = (m[2] ?? '').replace(/^\{|\}$/g, '').split(',').map((c) => c.trim())
+      .filter((c) => c !== '' && !/^(?:New|Class|Structure)$/i.test(c));
+    params.set(m[1]!.toLowerCase(), constraints.length > 0 ? sited(readType(constraints[0]!, 0), n.filePath, n.startLine) : null);
+  }
+  return params;
+}
+
+/**
+ * What a type means where it is written: a type parameter of the method
+ * (`owner`) or of a type around it stands for its constraint — null when it
+ * has none, as its value's type is then unknown — and any other name for itself.
+ */
+function resolveTypeParameter(t: VbType | null, owner: Node | null, context: ResolutionContext): VbType | null {
+  if (!t || t.array || isBuiltin(t) || t.qualifier || !t.file) return t;
+  const key = t.name.toLowerCase();
+  for (const decl of [...(owner && owner.kind === 'method' ? [owner] : []), ...typesAround(t.file, t.line ?? 0, context)]) {
+    const params = typeParametersOf(decl, context);
+    if (params.has(key)) return params.get(key) ?? null;
+  }
+  return t;
+}
+
+/**
+ * The project types `t` names where it is written, null when the name leaves
+ * different types (a guess between them would be no better than none), or
+ * none for an array or a built-in type.
+ */
+function ownersOf(t: VbType, context: ResolutionContext): Node[] | null {
+  if (t.array || isBuiltin(t)) return [];
+  const found = typesNamedAt(t, context);
+  return found.ambiguous ? null : found.owners;
+}
+
+/**
+ * A method — or, `withValues`, a field or property; or what `fits` — named
+ * `name` on one of `owners` (the type `typed` names) or a project type they
+ * inherit, with what the type parameters of the type declaring it stand for.
+ */
+function memberOn(
+  owners: Node[],
+  name: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  withValues: boolean,
+  typed?: VbType,
+  fits: (n: Node) => boolean = (n) => n.kind === 'method' || (withValues && VB_VALUE_KINDS.has(n.kind)),
+): { node: Node; args: Map<string, VbType> } | null {
+  for (const level of [0, 1]) {
+    for (const owner of preferVbProject(owners, ref, context)) {
+      // What the owner's own parameters are, as the receiver's type writes them (`Repo(Of Foo)`).
+      const given = new Map([...typeParametersOf(owner, context).keys()].flatMap((p, i): Array<[string, VbType]> =>
+        (typed?.args?.[i] ? [[p, typed.args[i]!]] : [])));
+      const ancestors = ancestry(owner, context);
+      for (const { node, args } of level === 0 ? ancestors.slice(0, 1) : ancestors.slice(1)) {
+        const found = preferVbProject(membersNamed(node, name, context).filter(fits), ref, context)[0];
+        if (found) return { node: found, args: level === 0 ? given : new Map([...args].map(([p, t]) => [p, substitute(t, given)])) };
+      }
+    }
+  }
+  return null;
+}
+
+/** The type of the value `Member(…)` / `obj.Member(…)` gives, from the member's declaration. */
+function callResultType(
+  call: { receiver: string | null; member: string },
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  depth: number,
+): VbType | null {
+  let member: { node: Node; args: Map<string, VbType> } | null = null;
+  if (call.receiver === null || /^(?:Me|MyClass|MyBase)$/i.test(call.receiver)) {
+    const owners = typesAround(ref.filePath, ref.line, context).slice(0, 1);
+    member = owners.length > 0 ? memberOn(owners, call.member, ref, context, true) : null;
+    if (!member && call.receiver === null) {
+      const global = moduleMembersNamed(call.member, ref, context).find((n) => n.kind === 'method' || VB_VALUE_KINDS.has(n.kind));
+      member = global ? { node: global, args: new Map() } : null;
+    }
+  } else {
+    const type = receiverType(call.receiver, ref, context, depth + 1);
+    // Not a variable: a type or module named for a shared call (`ObjectStorage.Load()`).
+    const owners = type === undefined ? ownersOf({ name: call.receiver, array: false, file: ref.filePath, line: ref.line }, context)
+      : type ? ownersOf(type, context) : null;
+    member = owners && owners.length > 0 ? memberOn(owners, call.member, ref, context, true, type ?? undefined) : null;
+  }
+  return member ? valueMemberType(member.node, context, member.args) : null;
+}
+
+/**
+ * What a receiver named `name` is declared as where the call is: a local or
+ * parameter of its member, else a field or property of its class, of one the
+ * class inherits, or of a `Module`. Null when the receiver is bound but its
+ * type isn't known; undefined when nothing binds the name (a type or module).
+ */
+function receiverType(name: string, ref: UnresolvedRef, context: ResolutionContext, depth: number): VbType | null | undefined {
+  if (depth > 2) return null;
+  const local = localBinding(name, ref, context);
+  if (local) {
+    const { binding, line } = local;
+    const owner = context.getNodeById?.(ref.fromNodeId) ?? null;
+    if (binding.kind === 'type') return resolveTypeParameter(sited(binding.type, ref.filePath, line), owner, context);
+    if (binding.kind === 'call') return callResultType(binding, { ...ref, line }, context, depth);
+    if (binding.kind === 'each') {
+      const collection = receiverType(binding.collection, { ...ref, line }, context, depth + 1);
+      return collection ? elementType(collection) : null;
+    }
+    return null;
+  }
+  return memberType(name, ref, context);
+}
+
+interface VbExtension {
+  node: Node;
+  /** The type it extends; null when that is one of its own type parameters (it extends anything). */
+  param: VbType | null;
+}
+
+const VB_EXTENSIONS = new WeakMap<ResolutionContext, Map<string, VbExtension | null>>();
+
+/** A method's extension-method declaration (`<Extension> Function F(s As String, …)`), or null when it isn't one. */
+function extensionOf(n: Node, context: ResolutionContext): VbExtension | null {
+  if (n.kind !== 'method' || n.language !== 'vbnet') return null;
+  let memo = VB_EXTENSIONS.get(context);
+  if (!memo) VB_EXTENSIONS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  const extension = readExtension(n, context);
+  memo.set(n.id, extension);
+  return extension;
+}
+
+function readExtension(n: Node, context: ResolutionContext): VbExtension | null {
+  const code = codeLines(n.filePath, context).slice(Math.max(0, n.startLine - 2), n.startLine + 6).join(' ');
+  const decl = new RegExp(`\\b(?:Function|Sub)\\s+${escapeRegex(n.name)}\\b`, 'i').exec(code);
+  if (!decl) return null;
+  const attributes = /((?:<[^<>]*>\s*)+)(?:(?:Public|Friend|Private|Protected|Shared|Overloads|Async|Iterator)\s+)*$/i
+    .exec(code.slice(0, decl.index))?.[1];
+  if (!attributes || !/\bExtension(?:Attribute)?\b/i.test(attributes)) return null;
+  let at = decl.index + decl[0].length;
+  const typeParams = new Set<string>();
+  if (/^\s*\(\s*Of\b/i.test(code.slice(at))) {
+    const open = code.indexOf('(', at);
+    for (const p of splitArgs(code, open) ?? []) {
+      const tp = /^(?:Of\s+)?(?:In\s+|Out\s+)?([A-Za-z_]\w*)/i.exec(p);
+      if (tp) typeParams.add(tp[1]!.toLowerCase());
+    }
+    const close = closeParen(code, open);
+    if (close < 0) return null;
+    at = close + 1;
+  }
+  const open = /^\s*\(/.exec(code.slice(at));
+  const first = open ? splitArgs(code, at + open[0].length - 1)?.[0]?.replace(/<[^<>]*>/g, '') : undefined;
+  const as = first ? /\bAs\s+/i.exec(first) : null;
+  const type = as ? readType(first!, as.index + as[0].length) : null;
+  if (!type) return null;
+  return { node: n, param: typeParams.has(type.name.toLowerCase()) && !type.array ? null : type };
+}
+
+/** `Object`'s instance methods, which every type has. */
+const OBJECT_METHODS = ['tostring', 'equals', 'gethashcode', 'gettype'];
+
+/**
+ * The instance methods of .NET's everyday types: a call one of them answers
+ * is the type's own, whatever extension of that name the project declares
+ * (`list.Sort()` on a `List(Of T)`), and a name one of them lacks is no
+ * instance method there (`list.Join(", ")` is an extension's).
+ */
+const BCL_INSTANCE_METHODS: ReadonlyMap<string, ReadonlySet<string>> = new Map(Object.entries({
+  string: ['clone', 'compareto', 'contains', 'copyto', 'endswith', 'getenumerator', 'gettypecode', 'indexof', 'indexofany',
+    'insert', 'isnormalized', 'lastindexof', 'lastindexofany', 'normalize', 'padleft', 'padright', 'remove', 'replace', 'split',
+    'startswith', 'substring', 'tochararray', 'tolower', 'tolowerinvariant', 'toupper', 'toupperinvariant', 'trim', 'trimend',
+    'trimstart'],
+  stringbuilder: ['append', 'appendformat', 'appendjoin', 'appendline', 'clear', 'copyto', 'ensurecapacity', 'getchunks', 'insert',
+    'remove', 'replace'],
+  list: ['add', 'addrange', 'asreadonly', 'binarysearch', 'clear', 'contains', 'convertall', 'copyto', 'exists', 'find', 'findall',
+    'findindex', 'findlast', 'findlastindex', 'foreach', 'getenumerator', 'getrange', 'indexof', 'insert', 'insertrange',
+    'lastindexof', 'remove', 'removeall', 'removeat', 'removerange', 'reverse', 'sort', 'toarray', 'trimexcess', 'trueforall'],
+  dictionary: ['add', 'clear', 'containskey', 'containsvalue', 'ensurecapacity', 'getenumerator', 'remove', 'trimexcess', 'tryadd',
+    'trygetvalue'],
+  hashset: ['add', 'clear', 'contains', 'copyto', 'exceptwith', 'getenumerator', 'intersectwith', 'ispropersubsetof',
+    'ispropersupersetof', 'issubsetof', 'issupersetof', 'overlaps', 'remove', 'removewhere', 'setequals', 'symmetricexceptwith',
+    'trimexcess', 'trygetvalue', 'unionwith'],
+  '[]': ['clone', 'copyto', 'getenumerator', 'getlength', 'getlonglength', 'getlowerbound', 'getupperbound', 'getvalue',
+    'initialize', 'setvalue'],
+}).map(([type, methods]) => [type, new Set([...methods, ...OBJECT_METHODS])]));
+
+/** The instance methods of a .NET type the table above knows; undefined for any other. */
+function bclInstanceMethods(t: VbType): ReadonlySet<string> | undefined {
+  return BCL_INSTANCE_METHODS.get(t.array ? '[]' : typeKey(t));
+}
+
+/**
+ * Whether a value of type `t` might reach an extension declared for `param`
+ * through a conversion nothing here can check: `Object`, an array's
+ * collection interfaces, an interface a built-in type implements, or any
+ * type an outside base type may lead to.
+ */
+function mayExtend(t: VbType, open: boolean, param: VbType): boolean {
+  if (typeKey(param) === 'object') return true;
+  if (param.array !== t.array) {
+    return t.array && /^(?:IEnumerable|IList|ICollection|IReadOnlyList|IReadOnlyCollection|Array)$/i.test(param.name);
+  }
+  if (isBuiltin(param)) return false;
+  if (isBuiltin(t)) return /^I[A-Z]/.test(param.name);
+  return open;
+}
+
+/**
+ * The extension method a call on a value of type `t` reaches: one declared
+ * for `t` or for a type it inherits — else, when exactly one other extension
+ * of that name could apply and the name is no instance method of `t`'s
+ * (one of .NET's own names, for a type nothing here describes), that one.
+ */
+function extensionFor(
+  t: VbType,
+  owners: Node[],
+  method: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  isStdMethod: (name: string) => boolean,
+): ResolvedRef | null {
+  const instanceMethods = owners.length === 0 ? bclInstanceMethods(t) : undefined;
+  if (instanceMethods?.has(method.toLowerCase())) return null;
+  const extensions = context.getNodesByLowerName(method.toLowerCase())
+    .map((n) => extensionOf(n, context))
+    .filter((e): e is VbExtension => e !== null);
+  if (extensions.length === 0) return null;
+  // Every name the type goes by — its own, its base types', the interfaces
+  // they implement — and whether one of them is an outside type, whose own
+  // ancestry nothing here shows.
+  const names = new Set<string>([typeKey({ name: t.name, array: false })]);
+  let open = owners.length === 0 && !isBuiltin(t) && !t.array;
+  for (const owner of owners) {
+    for (const type of hierarchy(owner, context)) {
+      names.add(type.name.toLowerCase());
+      for (const sup of supertypesOf(type, context)) {
+        names.add(typeKey(sup));
+        const found = typesNamedAt(sup, context).owners;
+        if (found.length === 0) open = true;
+        else if (sup.implemented) for (const i of found) for (const h of hierarchy(i, context)) names.add(h.name.toLowerCase());
+      }
+    }
+  }
+  const exact = extensions.filter((e) => e.param !== null &&
+    (typeKey(e.param) === typeKey(t) || (!t.array && !e.param.array && names.has(typeKey(e.param)))));
+  if (exact.length > 0) {
+    const target = preferVbProject(exact.map((e) => e.node), ref, context)[0]!;
+    return { original: ref, targetNodeId: target.id, confidence: 0.85, resolvedBy: 'instance-method' };
+  }
+  const loose = extensions.filter((e) => e.param === null || mayExtend(t, open, e.param));
+  if (loose.length === 1 && (instanceMethods !== undefined || !isStdMethod(method))) {
+    return { original: ref, targetNodeId: loose[0]!.node.id, confidence: 0.7, resolvedBy: 'instance-method' };
+  }
+  return null;
+}
+
+/**
+ * Resolve `receiver.method()` through the receiver's declared type: the
+ * type's own method or one it inherits, else an extension method for it,
+ * else null — a typed receiver is never a guess. A receiver naming one of the
+ * project's types or modules is a shared call on it. Undefined when the type
+ * isn't known, or is `Object` (a late-bound call), for the name strategies.
+ */
+export function matchVbTypedCall(
+  receiver: string,
+  method: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  isStdMethod: (name: string) => boolean,
+): ResolvedRef | null | undefined {
+  if (!/^[A-Za-z_]\w*$/.test(receiver)) return undefined;
+  const type = receiverType(receiver, ref, context, 0);
+  if (type === undefined) {
+    // A type or module named for a shared call — `M3U8.Download(…)` in SCrawler's
+    // `API.Reddit.UserData` is `API.Reddit.M3U8`'s, not another site's: its own
+    // member or one it inherits.
+    const named = typesNamedAt({ name: receiver, array: false, file: ref.filePath, line: ref.line }, context);
+    if (named.owners.length === 0) return undefined;
+    if (named.ambiguous) return null;
+    const shared = memberOn(named.owners, method, ref, context, false);
+    if (shared) return { original: ref, targetNodeId: shared.node.id, confidence: 0.85, resolvedBy: 'qualified-name' };
+    // `AppSession.Items(0)`: an index into a shared field or property, which
+    // VB.NET writes as a call — a read of the member and of its type (#2305).
+    const indexed = memberOn(named.owners, method, ref, context, true);
+    return indexed ? readThrough(indexed.node, named.owners, ref, context, { edgeKind: 'references' }) : null;
+  }
+  if (!type || typeKey(type) === 'object') return undefined;
+  const owners = ownersOf(type, context);
+  // A type name that leaves two of the project's types: no guess between them.
+  if (owners === null) return null;
+  return callOnValue(type, owners, method, ref, context, isStdMethod);
+}
+
+/**
+ * A call of `method` on a value of type `type` (`owners`, the project type
+ * it names; none for an outside type): the type's own method or one it
+ * inherits; an index into its field or property (`x.Items(0)`), which VB.NET
+ * writes as a call, reads the member; else an extension method for the type.
+ */
+function callOnValue(
+  type: VbType,
+  owners: Node[],
+  method: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  isStdMethod: (name: string) => boolean,
+): ResolvedRef | null {
+  if (owners.length > 0) {
+    const own = memberOn(owners, method, ref, context, false, type);
+    if (own) return { original: ref, targetNodeId: own.node.id, confidence: 0.9, resolvedBy: 'instance-method' };
+    const indexed = memberOn(owners, method, ref, context, true, type);
+    if (indexed) {
+      return indexed.node.id === ref.fromNodeId ? null
+        : { original: ref, targetNodeId: indexed.node.id, confidence: 0.9, resolvedBy: 'instance-method', edgeKind: 'references' };
+    }
+  }
+  return extensionFor(type, owners, method, ref, context, isStdMethod);
+}
+
+/** The types a value is read through: those a shared call is made on, and an `Enum`. */
+const VB_READ_TYPE_KINDS: ReadonlySet<string> = new Set([...VB_TYPE_KINDS, 'enum']);
+
+/**
+ * What a read through a type names: a value it holds or gives (a field, a
+ * property, a constant, an `Enum` case, an event), a method — which VB.NET
+ * runs when it is named without parentheses — or a type nested in it.
+ */
+const VB_READ_KINDS: ReadonlySet<string> = new Set([...VB_VALUE_KINDS, 'enum_member', 'method', ...VB_TYPE_LIKE_KINDS]);
+
+/** What a read through a value names: a field, property, constant or event of its type, or a method it runs. */
+const VB_INSTANCE_READ_KINDS: ReadonlySet<string> = new Set([...VB_VALUE_KINDS, 'method']);
+
+/** Members that belong to a type, not an instance, besides those declared `Shared`: a constant, an `Enum` case, a nested type. */
+const VB_SHARED_READ_KINDS: ReadonlySet<string> = new Set(['constant', 'enum_member', ...VB_TYPE_LIKE_KINDS]);
+
+/**
+ * Whether a member belongs to its type rather than to an instance: `Shared`,
+ * an `Enum` case, a nested type, or a `Const` — Shared without saying so,
+ * which a VB.NET field's node doesn't record, so its declaration is read.
+ */
+function isSharedMember(n: Node, context: ResolutionContext): boolean {
+  if (n.isStatic || VB_SHARED_READ_KINDS.has(n.kind)) return true;
+  if (n.kind !== 'field') return false;
+  const code = codeLines(n.filePath, context).slice(n.startLine - 1, n.startLine + 2).join(' ');
+  return new RegExp(`\\bConst\\s+(?:[^=]*,\\s*)?${escapeRegex(n.name)}(?![\\w$%&!#@])`, 'i').test(code);
+}
+
+/**
+ * A member read (or a `With` block's call) as the extractor sends it
+ * (extractVbMemberRead): the receiver — a name, `Me` / `MyClass` / `MyBase`,
+ * or `{T}` for a value of a type the code writes — then each member read
+ * through it, the last the one used: `AppSession.SessionId`, `x.Normal`,
+ * `Me._h.Title`, `{BoolParam}.Switch`.
+ */
+const VB_MEMBER_PATH = /^(\{[^{}]+\}|\[?[A-Za-z_]\w*\]?)((?:\.\[?[A-Za-z_]\w*\]?)*)\.(\[?[A-Za-z_]\w*\]?)$/;
+
+/** Whether a reference is a VB.NET member read through a receiver, which matchVbMemberRead alone resolves. */
+export function isVbMemberRead(ref: UnresolvedRef): boolean {
+  return ref.language === 'vbnet' && ref.referenceKind === 'references' && VB_MEMBER_PATH.test(ref.referenceName);
+}
+
+/**
+ * Whether a reference is a VB.NET call through a receiver path, which only a
+ * `With` block sends (`.Run()` in `With Me._h`, `With DirectCast(o, T)`) and
+ * matchVbPathCall alone resolves. A call through a name (`x.Run`) is the
+ * name matcher's, which types it with matchVbTypedCall.
+ */
+export function isVbPathCall(ref: UnresolvedRef): boolean {
+  if (ref.language !== 'vbnet' || ref.referenceKind !== 'calls') return false;
+  const m = VB_MEMBER_PATH.exec(ref.referenceName);
+  return m !== null && (m[2] !== '' || m[1]!.startsWith('{') || /^(?:Me|MyClass|MyBase)$/i.test(m[1]!));
+}
+
+/** What a receiver path reaches: the project type whose members are read through it, and how. */
+interface VbReceiver {
+  /** The parts of the project type the receiver names or holds a value of; none for an outside type. */
+  owners: Node[];
+  /** The type a value is declared as, with the type arguments it gives; absent through a type's name. */
+  typed?: VbType;
+  /** The receiver names a type (`AppSession`, `Outer.Mode`), whose own members are read, not a value. */
+  throughType: boolean;
+  /** The name is a value whose type has the same name (`theme As Theme`): VB.NET's "Color Color" rule. */
+  colorColor?: boolean;
+}
+
+/** `Name` for an escaped `[Name]`. */
+function unescaped(name: string): string {
+  return name.replace(/^\[(.*)\]$/, '$1');
+}
+
+/** A receiver holding a value of type `t`; null when that type isn't known, is `Object` (late-bound), or names two types. */
+function valueReceiver(t: VbType | null | undefined, context: ResolutionContext): VbReceiver | null {
+  if (!t || typeKey(t) === 'object') return null;
+  const owners = ownersOf(t, context);
+  return owners ? { owners, typed: t, throughType: false } : null;
+}
+
+/**
+ * What a receiver path's first link is where a member is read through it:
+ * `Me` / `MyClass` the type around the read, `MyBase` the class that type
+ * inherits, `{T}` a value of `T`. A name holds a value of its declared type
+ * when it is a local, a parameter, or a member of a type around the read or
+ * of a Module; any other name means the class, module, structure, interface
+ * or enum it names there. A value whose type has its name (`Public Property
+ * Settings As Settings`, `theme As Theme`) may mean either, by VB.NET's
+ * "Color Color" rule: the member read through it decides (matchVbMemberRead).
+ */
+function receiverAt(head: string, ref: UnresolvedRef, context: ResolutionContext): VbReceiver | null {
+  if (head.startsWith('{')) {
+    const owner = context.getNodeById?.(ref.fromNodeId) ?? null;
+    return valueReceiver(resolveTypeParameter(sited(readType(head.slice(1, -1), 0), ref.filePath, ref.line), owner, context), context);
+  }
+  if (/^(?:Me|MyClass|MyBase)$/i.test(head)) {
+    const own = typesAround(ref.filePath, ref.line, context)[0];
+    if (!own) return null;
+    if (/^MyBase$/i.test(head)) return valueReceiver(supertypesOf(own, context).find((s) => !s.implemented), context);
+    return { owners: [own], typed: { name: own.name, array: false }, throughType: false };
+  }
+  const name = unescaped(head);
+  const bound = receiverType(name, ref, context, 0);
+  const written: VbType | null = bound === undefined ? { name, array: false, file: ref.filePath, line: ref.line }
+    : bound && !bound.array && bound.name.toLowerCase() === name.toLowerCase() ? bound : null;
+  if (!written) return valueReceiver(bound, context);
+  const found = typesNamedAt(written, context, VB_READ_TYPE_KINDS);
+  return found.ambiguous || found.owners.length === 0 ? null
+    : { owners: found.owners, throughType: true, ...(bound ? { colorColor: true } : {}) };
+}
+
+/**
+ * What `name`, read through `at`, is as a receiver in turn: a value of the
+ * type a field, property or function declares, or a type nested in a type
+ * named for it (`Outer.Mode`). Null where the member, or its type, is not
+ * known here.
+ */
+function memberAt(at: VbReceiver, name: string, ref: UnresolvedRef, context: ResolutionContext): VbReceiver | null {
+  if (at.owners.length === 0) return null;
+  const fits = (n: Node) => VB_INSTANCE_READ_KINDS.has(n.kind) || (at.throughType && VB_READ_TYPE_KINDS.has(n.kind));
+  const found = memberOn(at.owners, name, ref, context, true, at.typed, fits) ??
+    memberOn(at.owners, `[${name}]`, ref, context, true, at.typed, fits);
+  if (!found) return null;
+  if (VB_READ_TYPE_KINDS.has(found.node.kind)) return { owners: [found.node], throughType: true };
+  return valueReceiver(valueMemberType(found.node, context, found.args), context);
+}
+
+/** What the receiver path `head.links…` reaches (see receiverAt and memberAt), or null where a link has no type here. */
+function pathReceiver(head: string, links: string[], ref: UnresolvedRef, context: ResolutionContext): VbReceiver | null {
+  let at = receiverAt(head, ref, context);
+  for (const link of links) {
+    if (!at) return null;
+    at = memberAt(at, unescaped(link), ref, context);
+  }
+  return at;
+}
+
+/**
+ * A read of `member` through one of `owners` (the parts of the type its
+ * receiver names): the member, and the type as a second target — unless the
+ * read is written inside that type, which doesn't depend on itself.
+ */
+function readThrough(
+  member: Node,
+  owners: Node[],
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  extra: Partial<ResolvedRef> = {},
+): ResolvedRef | null {
+  if (member.id === ref.fromNodeId) return null;
+  const owner = owners.find((o) => o.filePath === member.filePath) ?? owners[0]!;
+  const from = context.getNodeById?.(ref.fromNodeId)?.qualifiedName.toLowerCase();
+  const own = owner.qualifiedName.toLowerCase();
+  const inside = owner.id === ref.fromNodeId || (from !== undefined && (from === own || from.startsWith(`${own}::`)));
+  return {
+    original: ref,
+    targetNodeId: member.id,
+    confidence: 0.85,
+    resolvedBy: 'qualified-name',
+    ...extra,
+    ...(inside ? {} : { alsoTargets: [{ targetNodeId: owner.id }] }),
+  };
+}
+
+/** Whether a method is named at a reference without being run: `AddressOf Type.Method`, `NameOf(Type.Method)`. */
+function namesWithoutRunning(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1] ?? '';
+  return /\b(?:AddressOf\s+|NameOf\s*\(\s*)$/i.test(line.slice(0, Math.max(0, ref.column)));
+}
+
+/**
+ * Resolve a VB.NET member read or write to the member the receiver's type
+ * declares or inherits. Through a type's name (#2305) — `AppSession.SessionId`,
+ * `AppSession.CurrentUser = "demo"`, `Logger.Level`, `Mode.Fast` — the read
+ * links the type as well, and a `Shared` member before a same-named instance
+ * one. Through a value — `x.Normal = 3` on a parameter `x As Holder`,
+ * `Me._h.Title`, a `With` block's `.Value`, an initializer's `.Switch` — it
+ * links the member of the type the value is declared as, whatever that
+ * type's name; never a member of the type the receiver's own name would
+ * mean. A value named like its type (`theme As Theme`) reads an instance
+ * member as a value does and a Shared one as the type does, by VB.NET's
+ * "Color Color" rule. A method named either way is called, as without
+ * parentheses VB.NET runs it, unless `AddressOf` or `NameOf` only names it.
+ * Null when a link of the path is not typed here (an outside type:
+ * `Color.Red`, `str.Length`), is late-bound (`Object`), or names two of the
+ * project's types.
+ */
+export function matchVbMemberRead(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const m = VB_MEMBER_PATH.exec(ref.referenceName);
+  if (!m) return null;
+  const links = m[2] ? m[2].slice(1).split('.') : [];
+  const at = pathReceiver(m[1]!, links, ref, context);
+  if (!at || at.owners.length === 0) return null;
+  // `MySettings.Default` reads the property declared `[Default]`, and back.
+  const name = unescaped(m[3]!);
+  const calls = (member: Node) => member.kind === 'method' && !namesWithoutRunning(ref, context);
+  const throughValue = (member: Node): ResolvedRef => ({
+    original: ref,
+    targetNodeId: member.id,
+    confidence: 0.9,
+    resolvedBy: 'instance-method',
+    ...(calls(member) ? { edgeKind: 'calls' as const } : {}),
+  });
+  if (!at.throughType) {
+    // The member the name means: the nearest the type declares or inherits.
+    // The read's own member (`Return Me.Count` in `Count`) runs itself.
+    const fits = (n: Node) => VB_INSTANCE_READ_KINDS.has(n.kind);
+    const member = (memberOn(at.owners, name, ref, context, true, at.typed, fits) ??
+      memberOn(at.owners, `[${name}]`, ref, context, true, at.typed, fits))?.node;
+    return member && member.id !== ref.fromNodeId ? throughValue(member) : null;
+  }
+  // Not the member the read is written in: staxrip's `Overrides ReadOnly
+  // Property Package` returns the class's `Shared ReadOnly Property Package`.
+  const fits = (n: Node) => VB_READ_KINDS.has(n.kind) && n.id !== ref.fromNodeId;
+  let member = (memberOn(at.owners, name, ref, context, true, undefined, fits) ??
+    memberOn(at.owners, `[${name}]`, ref, context, true, undefined, fits))?.node;
+  if (!member) return null;
+  // Of a `Shared` member and an instance one of the same name, a type's name reads the `Shared` one.
+  if (!member.isStatic) {
+    const found = member;
+    member = context.getNodesByQualifiedName(found.qualifiedName).find((n) => n.isStatic && n.filePath === found.filePath && fits(n)) ?? found;
+  }
+  // "Color Color": a value named like its type (`theme As Theme`) reads an
+  // instance member through itself, and only a Shared one through the type.
+  if (at.colorColor && !isSharedMember(member, context)) return throughValue(member);
+  if (member.kind === 'method') {
+    return {
+      original: ref,
+      targetNodeId: member.id,
+      confidence: 0.85,
+      resolvedBy: 'qualified-name',
+      ...(calls(member) ? { edgeKind: 'calls' as const } : {}),
+    };
+  }
+  // A type named through another (`Outer.Mode.Fast`) is linked by the read
+  // that names it (`Outer.Mode`), so only a type named itself is linked here.
+  return links.length === 0 ? readThrough(member, at.owners, ref, context, { confidence: 0.9 })
+    : { original: ref, targetNodeId: member.id, confidence: 0.9, resolvedBy: 'qualified-name' };
+}
+
+/**
+ * Resolve a VB.NET call through a receiver path, which a `With` block sends
+ * for its `.Run()` (`With Me._h`, `With user.Settings`, `With
+ * DirectCast(o, T)`), as matchVbTypedCall resolves one through a typed name:
+ * the method the path's type has or inherits, a read of a field or property
+ * it indexes, or an extension method for the type. Null — never a guess by
+ * the method's name — when a link of the path is not typed here.
+ */
+export function matchVbPathCall(
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  isStdMethod: (name: string) => boolean,
+): ResolvedRef | null {
+  const m = VB_MEMBER_PATH.exec(ref.referenceName);
+  if (!m) return null;
+  const at = pathReceiver(m[1]!, m[2] ? m[2].slice(1).split('.') : [], ref, context);
+  return at?.typed && !at.throughType ? callOnValue(at.typed, at.owners, unescaped(m[3]!), ref, context, isStdMethod) : null;
+}
+
+const VB_TYPE_IMPORTS = new WeakMap<ResolutionContext, Map<string, Set<string>>>();
+
+/** The last names of a file's `Imports` (a type imported this way lends its shared members; an alias lends none). */
+function importedNames(file: string, context: ResolutionContext): Set<string> {
+  let memo = VB_TYPE_IMPORTS.get(context);
+  if (!memo) VB_TYPE_IMPORTS.set(context, (memo = new Map()));
+  const hit = memo.get(file);
+  if (hit) return hit;
+  const names = new Set<string>();
+  for (const line of headerLines(file, context)) {
+    const m = /^\s*Imports\s+([\w.]+)\s*$/i.exec(line);
+    if (m) names.add(m[1]!.split('.').pop()!.toLowerCase());
+  }
+  memo.set(file, names);
+  return names;
+}
+
+const VB_SCOPES = new WeakMap<ResolutionContext, WeakMap<UnresolvedRef, Set<string> | null>>();
+
+/** The lowercased names of the types around a call and of the project types they inherit; null outside any type. */
+function scopeOwners(ref: UnresolvedRef, context: ResolutionContext): Set<string> | null {
+  let memo = VB_SCOPES.get(context);
+  if (!memo) VB_SCOPES.set(context, (memo = new WeakMap()));
+  const hit = memo.get(ref);
+  if (hit !== undefined) return hit;
+  const around = typesAround(ref.filePath, ref.line, context);
+  const owners = around.length === 0 ? null
+    : new Set(around.flatMap((t) => hierarchy(t, context)).map((t) => t.name.toLowerCase()));
+  memo.set(ref, owners);
+  return owners;
+}
+
+/**
+ * Whether an unqualified VB.NET type name can mean `n`: a type nested in a
+ * class, structure or interface is named bare only inside it or a type
+ * deriving from it — designer code's `New Point(4, 285)` is not staxrip's
+ * nested `ButtonEx.SymbolDrawer.Point`. A `Module`'s types belong to its
+ * namespace; a file can import the outer type, or alias the nested one
+ * (`Imports UserMediaD = SCrawler.DownloadObjects.TDownloader.UserMediaD`).
+ * Not judged when no type is around the name.
+ */
+export function isVbNestedTypeInScope(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (n.language !== 'vbnet' || !VB_TYPE_LIKE_KINDS.has(n.kind)) return true;
+  const parent = enclosingType(n, context);
+  if (!parent) return true;
+  const owners = scopeOwners(ref, context);
+  if (owners === null || owners.has(parent.name.toLowerCase())) return true;
+  const alias = importAliases(ref.filePath, context).get(ref.referenceName.toLowerCase());
+  if (alias && alias.name.toLowerCase() === n.name.toLowerCase() &&
+      (!alias.qualifier || endsWith(fullSegments(n, context).slice(0, -1), alias.qualifier))) return true;
+  return importedNames(ref.filePath, context).has(parent.name.toLowerCase());
+}
+
+/**
+ * Whether a receiver-less VB.NET call (or one through `Me` / `MyClass` /
+ * `MyBase`) can mean member `n`: one of a type around the call or of a type
+ * those inherit, of a `Module`, or of a type the file imports. Not judged
+ * when no type is around the call, or `n` is not a member of a type.
+ */
+export function isVbMemberInScope(n: Node, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (n.language !== 'vbnet' || !VB_MEMBER_KINDS.has(n.kind)) return true;
+  const cut = n.qualifiedName.lastIndexOf('::');
+  if (cut < 0) return true;
+  const owners = scopeOwners(ref, context);
+  if (owners === null) return true;
+  const ownerQn = n.qualifiedName.slice(0, cut);
+  const owner = ownerQn.split(/::|\./).pop()!.toLowerCase();
+  return owners.has(owner) || isModule(ownerQn, context) || importedNames(ref.filePath, context).has(owner);
+}
+
+/**
+ * Drop this module's per-context memos — file lines and what was read from
+ * them — with the resolver's own caches (ReferenceResolver.clearCaches), so a
+ * sync never reads a changed file's old declarations.
+ */
+export function clearVbnetReceiverMemos(context: ResolutionContext): void {
+  for (const memo of [VB_CODE_LINES, VB_WORD_LINES, VB_BINDINGS, VB_FILE_TYPES, VB_FILE_QNS, VB_MEMBERS, VB_MODULES, VB_SUPERS, VB_ANCESTRIES,
+    VB_PROJECTS, VB_PROJECT_INFO, VB_FILE_IMPORTS, VB_ALIASES, VB_BASE_NAMES, VB_TYPE_PARAMS, VB_EXTENSIONS, VB_TYPE_IMPORTS,
+    VB_SCOPES] as Array<WeakMap<ResolutionContext, unknown>>) {
+    memo.delete(context);
+  }
+}
diff --git a/src/search/query-utils.ts b/src/search/query-utils.ts
index 03817b8c5f..e51cbe5d46 100644
--- a/src/search/query-utils.ts
+++ b/src/search/query-utils.ts
@@ -317,8 +317,10 @@ export function isTestPath(filePath: string): boolean {
   if (
     lowerName.startsWith('test_') ||                              // python: test_foo.py
     lowerName.startsWith('test.') ||
-    // separator-delimited: foo_test.go, foo.test.ts, foo-spec.rb, bar_spec.py
-    /[._-](test|tests|spec|specs)\.[a-z0-9]+$/.test(lowerName) ||
+    // separator-delimited: foo_test.go, foo.test.ts, foo-spec.rb, bar_spec.py,
+    // and Google's C++ foo_unittest.cc (protobuf, Chromium). A bare
+    // `unittest.go` is no test: promtool's is the code that runs rule tests.
+    /[._-](test|tests|unittest|unittests|spec|specs)\.[a-z0-9]+$/.test(lowerName) ||
     // CamelCase suffix (Java/Kotlin/Swift/C#/Scala): FooTest.kt, BarTests.swift,
     // BazSpec.scala, QuxTestCase.java. Capital-led so "latest.kt"/"manifest.kt"
     // (lowercase "test") are NOT matched.
diff --git a/src/sync/watcher.ts b/src/sync/watcher.ts
index 17722a8fbd..3742a98429 100644
--- a/src/sync/watcher.ts
+++ b/src/sync/watcher.ts
@@ -650,7 +650,7 @@ export class FileWatcher {
       this.refreshScope(rel);
       return;
     }
-    if (!isSourceFile(rel, loadExtensionOverrides(this.projectRoot))) {
+    if (!isSourceFile(rel, loadExtensionOverrides(this.projectRoot), this.projectRoot)) {
       this.maybeScheduleForRemovedDir(rel);
       return;
     }
diff --git a/src/sync/worktree.ts b/src/sync/worktree.ts
index 1f9bfba7ec..a648b9333a 100644
--- a/src/sync/worktree.ts
+++ b/src/sync/worktree.ts
@@ -122,6 +122,66 @@ export function detectWorktreeIndexMismatch(
   return { worktreeRoot, indexRoot: resolvedIndexRoot };
 }
 
+/** A git repository of its own nested below an index root. */
+export interface NestedRepository {
+  /** The nested repository's working-tree root. */
+  root: string;
+  /** `root` relative to the index root, POSIX — the prefix its files carry in that index. */
+  relPath: string;
+}
+
+/**
+ * The repository `startPath` belongs to when it is a DIFFERENT git repository
+ * nested strictly below `indexRoot` — an embedded clone, a submodule, a
+ * gitignored checkout. The up-walk to the nearest `.codegraph/` crosses its
+ * boundary without noticing, and the ancestor's index may or may not hold its
+ * files, so the caller has to ask that index before answering for it (#2110).
+ *
+ * Returns null — nothing to check — when:
+ *   - `startPath` isn't in a git repo (or git is unavailable),
+ *   - its repository root is the index root or above it (an ordinary
+ *     subdirectory; a monorepo sub-project with its own index), or
+ *   - it is a linked worktree of the index root's OWN repository (same git
+ *     common dir): the #155 borrowed-worktree case, warned about, not refused.
+ */
+export function nestedRepositoryBelow(startPath: string, indexRoot: string): NestedRepository | null {
+  // git needs an existing directory to run in: a file, or a sub-path that does
+  // not exist yet, belongs to the repository of its nearest existing directory.
+  let dir = path.resolve(startPath);
+  while (!isDirectory(dir)) {
+    const up = path.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+  const repoRoot = gitWorktreeRoot(dir);
+  if (!repoRoot) return null;
+
+  // The on-disk spelling of both ends (`realpathSync.native` normalizes case on
+  // macOS and Windows), so `relPath` matches the paths the index stored.
+  const rel = path.relative(nativeRealpath(indexRoot), nativeRealpath(repoRoot));
+  if (!rel || rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) return null;
+
+  const repoCommon = gitCommonDir(repoRoot);
+  if (!repoCommon || repoCommon === gitCommonDir(realpath(indexRoot))) return null;
+  return { root: repoRoot, relPath: rel.split(path.sep).join('/') };
+}
+
+function isDirectory(p: string): boolean {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function nativeRealpath(p: string): string {
+  try {
+    return fs.realpathSync.native(path.resolve(p));
+  } catch {
+    return realpath(p);
+  }
+}
+
 /** One-line-per-fact warning describing a detected mismatch. */
 export function worktreeMismatchWarning(m: WorktreeIndexMismatch): string {
   return (
diff --git a/src/telemetry/index.ts b/src/telemetry/index.ts
index a10ad945c9..04a89317e1 100644
--- a/src/telemetry/index.ts
+++ b/src/telemetry/index.ts
@@ -121,6 +121,52 @@ interface EventLine {
 }
 type BufferLine = CountLine | EventLine;
 
+const countKey = (l: CountLine): string => [l.d, l.k, l.n, l.cn ?? '', l.cv ?? ''].join('\u0000');
+
+/**
+ * One count line per (day, kind, name, client), calls and errors summed; lifecycle
+ * events pass through in order. Each process aggregates in memory but appends its
+ * own lines on exit, so without this a machine running a short-lived `codegraph`
+ * process a thousand times a day queued — and uploaded — a thousand `count: 1`
+ * lines for the one counter the server wanted.
+ */
+function coalesceLines(lines: BufferLine[]): BufferLine[] {
+  const counts = new Map<string, CountLine>();
+  const out: BufferLine[] = [];
+  for (const line of lines) {
+    if ('ev' in line) {
+      out.push(line);
+      continue;
+    }
+    const key = countKey(line);
+    const seen = counts.get(key);
+    if (seen) {
+      seen.c += line.c;
+      seen.e += line.e;
+    } else {
+      const copy = { ...line };
+      counts.set(key, copy);
+      out.push(copy);
+    }
+  }
+  return out;
+}
+
+/** Parses JSONL buffer text, skipping blank, corrupt and other-schema lines. */
+function parseLines(text: string): BufferLine[] {
+  const lines: BufferLine[] = [];
+  for (const raw of text.split('\n')) {
+    if (!raw.trim()) continue;
+    try {
+      const parsed = JSON.parse(raw) as BufferLine;
+      if (parsed && typeof parsed === 'object' && parsed.v === SCHEMA_VERSION) lines.push(parsed);
+    } catch {
+      /* skip corrupt line */
+    }
+  }
+  return lines;
+}
+
 export interface TelemetryOptions {
   /** Global state dir; defaults to ~/.codegraph. Tests inject a temp dir. */
   dir?: string;
@@ -246,18 +292,17 @@ export class Telemetry {
   /** Recheck shared consent, then increment in memory; no network or writes. */
   recordUsage(kind: UsageKind, name: string, ok: boolean, client?: ClientInfo): void {
     if (!this.isEnabled()) return;
-    const day = this.utcDay();
+    const fresh: CountLine = { v: SCHEMA_VERSION, d: this.utcDay(), k: kind, n: name.slice(0, 64), c: 1, e: ok ? 0 : 1 };
     const cn = client?.name?.slice(0, 64);
     const cv = client?.version?.slice(0, 32);
-    const key = [day, kind, name, cn ?? '', cv ?? ''].join('\u0000');
+    if (cn) fresh.cn = cn;
+    if (cv) fresh.cv = cv;
+    const key = countKey(fresh);
     const line = this.counts.get(key);
     if (line) {
       line.c += 1;
       if (!ok) line.e += 1;
     } else {
-      const fresh: CountLine = { v: SCHEMA_VERSION, d: day, k: kind, n: name.slice(0, 64), c: 1, e: ok ? 0 : 1 };
-      if (cn) fresh.cn = cn;
-      if (cv) fresh.cv = cv;
       this.counts.set(key, fresh);
     }
     this.ensureExitHook();
@@ -293,7 +338,9 @@ export class Telemetry {
       let identity = this.getStatus().machineId;
       const claim = this.claimQueue();
       if (!claim) return;
-      const { claimPath, lines } = claim;
+      const { claimPath } = claim;
+      // A queue written by an older version can hold many lines per counter.
+      const lines = coalesceLines(claim.lines);
       const today = this.utcDay();
       const sendable: BufferLine[] = [];
       const keep: BufferLine[] = [];
@@ -434,12 +481,14 @@ export class Telemetry {
     if (!this.canUseIdentity(identity)) return;
     try {
       fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-      const payload = lines.map((l) => JSON.stringify(l)).join('\n') + '\n';
-      // Cap the buffer: drop oldest lines first (telemetry is best-effort —
-      // bounded disk use beats completeness).
+      // Merge into what is already queued rather than appending beside it, so the
+      // queue holds one line per counter however many processes wrote to it.
       let existing = '';
       try { existing = fs.readFileSync(this.queuePath, 'utf8'); } catch { /* no queue yet */ }
-      let combined = existing + payload;
+      const merged = coalesceLines([...parseLines(existing), ...lines]);
+      // Cap the buffer: drop oldest lines first (telemetry is best-effort —
+      // bounded disk use beats completeness).
+      let combined = merged.map((l) => JSON.stringify(l)).join('\n') + '\n';
       if (combined.length > MAX_BUFFER_BYTES) {
         combined = combined.slice(combined.length - MAX_BUFFER_BYTES);
         combined = combined.slice(combined.indexOf('\n') + 1); // drop the partial first line
@@ -462,17 +511,9 @@ export class Telemetry {
     } catch {
       return null; // no queue, or another process just claimed it
     }
-    const lines: BufferLine[] = [];
+    let lines: BufferLine[] = [];
     try {
-      for (const raw of fs.readFileSync(claimPath, 'utf8').split('\n')) {
-        if (!raw.trim()) continue;
-        try {
-          const parsed = JSON.parse(raw) as BufferLine;
-          if (parsed && typeof parsed === 'object' && parsed.v === SCHEMA_VERSION) lines.push(parsed);
-        } catch {
-          /* skip corrupt line */
-        }
-      }
+      lines = parseLines(fs.readFileSync(claimPath, 'utf8'));
     } catch {
       /* unreadable claim — treat as empty; file removed by caller */
     }
@@ -491,7 +532,10 @@ export class Telemetry {
           if (fs.statSync(full).mtimeMs < cutoff) {
             const content = fs.readFileSync(full, 'utf8');
             fs.rmSync(full, { force: true });
-            if (content.trim() && this.canUseIdentity(identity)) fs.appendFileSync(this.queuePath, content.endsWith('\n') ? content : content + '\n');
+            // Through appendLines, so recovered lines are merged and capped like any
+            // other write — a raw append here once let the queue grow without bound.
+            const recovered = parseLines(content);
+            if (recovered.length > 0) this.appendLines(recovered, identity);
           }
         } catch {
           /* fail silent */
diff --git a/src/types.ts b/src/types.ts
index 44ffaf4e43..f30080002f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -265,6 +265,24 @@ export interface FileRecord {
   generated?: boolean;
 }
 
+/**
+ * Indexed files whose symbols are missing even though their content hash is
+ * current — what a hash comparison alone calls "up to date" (#2336). Paths are
+ * project-relative and sorted.
+ */
+export interface IndexHealth {
+  /**
+   * Files `sync` re-indexes: stored while their grammar could not load (#2335)
+   * or stored with no nodes and no recorded reason (#1541).
+   */
+  needsReindex: string[];
+  /**
+   * Files with a recorded parse error and no symbols from it. Deterministic:
+   * they stay this way until the file (or the parser) changes.
+   */
+  parseErrors: string[];
+}
+
 // =============================================================================
 // Extraction Types
 // =============================================================================
diff --git a/src/ui-server/api/deadcode.ts b/src/ui-server/api/deadcode.ts
index b099debaf2..fb31e2ea82 100644
--- a/src/ui-server/api/deadcode.ts
+++ b/src/ui-server/api/deadcode.ts
@@ -95,11 +95,12 @@ export interface WireDeadCode {
 const EXCLUSION_LABELS: Record<keyof DeadCodeExclusions, string> = {
   tests: 'in test files',
   generated: 'in generated files',
-  exported: 'exported, or declared in a header',
+  exported: 'exported, declared in a header, or merged into a library or global type',
   exportsUnknown: 'in languages this index records no exports for',
   declarations: 'abstract, or declared on an interface',
   decorated: 'carrying a decorator, so a framework registers them',
   overriding: 'overriding a member declared further up',
+  hooks: 'framework hooks, called by name on classes that skip the interface',
   implicit: 'named something the language calls by itself',
   vendored: 'in vendored directories',
   testScope: 'inside a test module',
diff --git a/src/ui-server/api/entrypoints.ts b/src/ui-server/api/entrypoints.ts
index 2ac64f6470..81372cf399 100644
--- a/src/ui-server/api/entrypoints.ts
+++ b/src/ui-server/api/entrypoints.ts
@@ -396,15 +396,18 @@ function testFiles(cg: CodeGraph, limit: number): WireList<WireEntryTest> {
   return wireList(items, Math.max(ranked.length, items.length));
 }
 
-/** The most depended-on symbols, tests and non-navigable kinds removed. */
+/** The most depended-on symbols, tests, generated files and non-navigable kinds removed. */
 function hubs(cg: CodeGraph, limit: number): WireList<WireEntryHub> {
-  const ranked = cg.getTopDependedOn(SCAN_ROWS);
+  const ranked = cg
+    .getTopDependedOn(SCAN_ROWS)
+    .map((row) => ({ row, node: cg.getNode(row.nodeId) }));
+  // A vendored bundle's one-letter functions are depended on by the bundle alone.
+  const generated = cg.generatedFilePredicate(ranked.flatMap(({ node }) => (node ? [node.filePath] : [])));
 
   const items: WireEntryHub[] = [];
   let eligible = 0;
-  for (const row of ranked) {
-    const node = cg.getNode(row.nodeId);
-    if (!node || NON_HUB_KINDS.has(node.kind) || isTestFile(node.filePath)) continue;
+  for (const { row, node } of ranked) {
+    if (!node || NON_HUB_KINDS.has(node.kind) || isTestFile(node.filePath) || generated(node.filePath)) continue;
     eligible += 1;
     if (items.length >= limit) continue;
     items.push({ ...toNodeRef(node), dependents: row.dependents });
diff --git a/src/ui-server/api/map.ts b/src/ui-server/api/map.ts
index f58f892322..b63ebf0b08 100644
--- a/src/ui-server/api/map.ts
+++ b/src/ui-server/api/map.ts
@@ -351,11 +351,13 @@ export function pickDefaultRoot(
   let total = 0;
   for (const file of files) {
     if (file.test) continue;
+    // A file loose in the repository root is program too: git's hundreds of
+    // top-level `.c` files made `builtin/` look like the majority of the code.
+    total += file.symbols;
     const slash = file.path.indexOf('/');
     if (slash <= 0) continue;
     const dir = file.path.slice(0, slash);
     byDir.set(dir, (byDir.get(dir) ?? 0) + file.symbols);
-    total += file.symbols;
   }
   if (total === 0) return '';
   let best = '';
@@ -478,6 +480,26 @@ export function pickDefaultDepth(
   return fallback;
 }
 
+/**
+ * The root and depth the map opens on when the reader named neither.
+ *
+ * A source directory whose files all sit in one folder — Express's `lib/`, an
+ * R package's `R/`, an Erlang app's `src/`, fmt's `include/fmt/` — draws as one
+ * box at any depth, and a map whose subject is one box has said nothing. The
+ * repository around it (that folder beside a CLI, a `src/`, the examples) is
+ * then the picture worth opening on, when it draws more than one box.
+ */
+export function pickDefaultView(
+  files: ReadonlyArray<{ path: string; symbols: number; test: boolean }>,
+  passThrough?: ReadonlySet<string>
+): { root: string; depth: number } {
+  const root = pickDefaultRoot(files);
+  const depth = pickDefaultDepth(files, root, passThrough);
+  if (root === '' || tallyModules(files, root, depth, passThrough).count > 1) return { root, depth };
+  const wholeDepth = pickDefaultDepth(files, '', passThrough);
+  return tallyModules(files, '', wholeDepth, passThrough).count > 1 ? { root: '', depth: wholeDepth } : { root, depth };
+}
+
 // =============================================================================
 // Cache
 // =============================================================================
@@ -579,12 +601,13 @@ export function buildMap(cg: CodeGraph, projectRoot: string, query: URLSearchPar
     };
   });
 
-  const root = requestedRoot ?? pickDefaultRoot(fileRecords);
   const passThrough = passThroughDirs(fileRecords.map((f) => f.path));
   // Root first, then depth against THAT root: how finely to cut depends on
   // what is being cut. Choosing `src` and then asking for one level under it
   // is the same question as choosing the whole project and asking for two.
-  const depth = requestedDepth ?? pickDefaultDepth(fileRecords, root, passThrough);
+  const view = requestedRoot === null ? pickDefaultView(fileRecords, passThrough) : null;
+  const root = view?.root ?? requestedRoot ?? '';
+  const depth = requestedDepth ?? view?.depth ?? pickDefaultDepth(fileRecords, root, passThrough);
   const stats = cg.getStats();
   const key = [
     projectRoot,
diff --git a/src/ui-server/api/node.ts b/src/ui-server/api/node.ts
index bc7d6b4a66..c5431a0d3c 100644
--- a/src/ui-server/api/node.ts
+++ b/src/ui-server/api/node.ts
@@ -244,10 +244,17 @@ function buildMembers(
   endpoints: Map<string, Node>,
   overrides?: Map<string, WireOverride>
 ): { items: WireMember[]; total: number } {
+  // Each member once, and never the symbol itself or a file: a component in a
+  // Vue / Svelte / Astro file was recorded as containing its script's file node
+  // and every symbol in it, so the walk one level down met those symbols
+  // again — and a member listed twice is a repeated key the viewer cannot draw.
+  const seen = new Set<string>([focal.id]);
+  const admit = (child: Node | undefined): child is Node =>
+    !!child && child.kind !== 'file' && !seen.has(child.id) && !!seen.add(child.id);
   const direct: Array<{ node: Node; parentId: string; depth: number }> = [];
   for (const edge of containsOut) {
     const child = endpoints.get(edge.target);
-    if (child) direct.push({ node: child, parentId: focal.id, depth: 1 });
+    if (admit(child)) direct.push({ node: child, parentId: focal.id, depth: 1 });
   }
 
   const containerIds = direct
@@ -260,7 +267,7 @@ function buildMembers(
     const grandNodes = cg.getNodesByIds(grandEdges.map((e) => e.target));
     for (const edge of grandEdges) {
       const child = grandNodes.get(edge.target);
-      if (child) nested.push({ node: child, parentId: edge.source, depth: 2 });
+      if (admit(child)) nested.push({ node: child, parentId: edge.source, depth: 2 });
     }
   }
 
diff --git a/src/ui-server/api/route-roots.ts b/src/ui-server/api/route-roots.ts
index 78412b8497..f9ab4c1296 100644
--- a/src/ui-server/api/route-roots.ts
+++ b/src/ui-server/api/route-roots.ts
@@ -52,6 +52,23 @@ export function looksLikeComponent(node: Node): boolean {
   return JS_FAMILY.has(node.language) && /^[A-Z]/.test(node.name);
 }
 
+/**
+ * Route id → the layouts it renders inside, outermost first: an Angular
+ * parent route's component around its `<router-outlet>`. What happens in a
+ * layout — its tabs, its buttons — happens on every screen nested in it.
+ */
+export function routeLayouts(cg: CodeGraph, routes: readonly Node[]): Map<string, string[]> {
+  const out = new Map<string, string[]>();
+  if (routes.length === 0) return out;
+  for (const e of cg.getOutgoingEdgesFrom(routes.map((r) => r.id), ['references'])) {
+    if ((e.metadata as Record<string, unknown> | undefined)?.layout !== true) continue;
+    const list = out.get(e.source) ?? [];
+    if (!list.includes(e.target)) list.push(e.target);
+    out.set(e.source, list);
+  }
+  return out;
+}
+
 /** Route id → where its code starts, for every route that has an answer. */
 export function routeRoots(cg: CodeGraph, routes: readonly Node[]): Map<string, RouteRoot> {
   const out = new Map<string, RouteRoot>();
@@ -70,9 +87,10 @@ export function routeRoots(cg: CodeGraph, routes: readonly Node[]): Map<string,
   for (const route of routes) {
     const list = byRoute.get(route.id);
     if (!list || list.length === 0) continue;
-    // 1. The handler the resolver named.
+    // 1. The handler the resolver named. A layout the screen renders inside
+    // (an Angular parent route's component) is not the screen's own.
     const named = list
-      .filter((e) => e.kind === 'references')
+      .filter((e) => e.kind === 'references' && (e.metadata as Record<string, unknown> | undefined)?.layout !== true)
       .map((e) => targets.get(e.target))
       .filter((n): n is Node => !!n && HANDLER_KINDS.has(n.kind) && n.id !== route.id)
       .sort((a, b) => rank(a) - rank(b) || a.startLine - b.startLine);
diff --git a/src/ui-server/api/routes.ts b/src/ui-server/api/routes.ts
index 44429b6b59..ca20c9a745 100644
--- a/src/ui-server/api/routes.ts
+++ b/src/ui-server/api/routes.ts
@@ -23,6 +23,8 @@
 import type { CodeGraph } from '../../index';
 import { intParam } from './respond';
 import { toPosixPath } from './wire';
+import { routeRoots } from './route-roots';
+import { isTestFile } from '../../search/query-utils';
 
 /**
  * HTTP verbs a route name may lead with, plus the two stand-ins the resolvers
@@ -56,6 +58,8 @@ export interface WireRoute {
   routeFile: string;
   routeLine: number;
   routeId: string;
+  /** The handler is written inline at the registration: the route stands in for it. */
+  inline: boolean;
 }
 
 export interface WireRoutes {
@@ -86,11 +90,62 @@ export function splitRouteName(url: string): { method: string | null; path: stri
  */
 const MIN_LIMIT = 3;
 
+/** Manifest rows fetched per route shown, so folding repeats still fills the page. */
+const ROWS_PER_ROUTE = 4;
+
+type ManifestRow = NonNullable<ReturnType<CodeGraph['getRoutingManifest']>>['entries'][number];
+
+/**
+ * The manifest's rows folded to one per route, in its order: the row naming
+ * the route's root (the handler a resolver bound, or the component a screen
+ * renders), else the route's first row. A route whose root is its own inline
+ * body is that route, labelled as an inline handler — not whichever call in
+ * the body sorted first — and is left out when it is written in a test, as
+ * the manifest leaves out test handlers.
+ */
+function oneRowPerRoute(cg: CodeGraph, entries: readonly ManifestRow[]): Array<ManifestRow & { inline: boolean }> {
+  const byRoute = new Map<string, ManifestRow[]>();
+  for (const entry of entries) {
+    const list = byRoute.get(entry.routeId);
+    if (list) list.push(entry);
+    else byRoute.set(entry.routeId, [entry]);
+  }
+  const routes = [...cg.getNodesByIds([...byRoute.keys()]).values()];
+  const roots = routeRoots(cg, routes);
+  const out: Array<ManifestRow & { inline: boolean }> = [];
+  for (const [routeId, list] of byRoute) {
+    const root = roots.get(routeId);
+    if (root?.inline) {
+      const first = list[0]!;
+      if (isTestFile(first.routeFile)) continue;
+      out.push({
+        ...first,
+        handler: 'inline handler',
+        handlerKind: 'route',
+        handlerFile: first.routeFile,
+        handlerLine: first.routeLine,
+        inline: true,
+      });
+      continue;
+    }
+    const named = root
+      ? list.find((e) => e.handlerFile === root.node.filePath && e.handlerLine === root.node.startLine && e.handler === root.node.name)
+      : undefined;
+    out.push({ ...(named ?? list[0]!), inline: false });
+  }
+  return out;
+}
+
 export function buildRoutes(cg: CodeGraph, query: URLSearchParams): WireRoutes {
   const limit = intParam(query, 'limit', { min: MIN_LIMIT, max: 500, default: 200 });
 
-  // One row over the limit, purely to learn whether there were more.
-  const manifest = cg.getRoutingManifest(limit + 1);
+  // The engine's manifest is a row per (route, edge): a route bound to two
+  // symbols, or an inline handler whose every call reads as a "handler"
+  // (hono's `GET /stream/text` came back three times, as `streamText`,
+  // `writeln` and `sleep`), repeats. A route has ONE answer to "what serves
+  // this" — route-roots.ts's — so rows are over-fetched and folded onto it.
+  const fetched = limit * ROWS_PER_ROUTE + 1;
+  const manifest = cg.getRoutingManifest(fetched);
   const routeCount = cg.getStats().nodesByKind.route ?? 0;
 
   if (!manifest) {
@@ -105,8 +160,9 @@ export function buildRoutes(cg: CodeGraph, query: URLSearchParams): WireRoutes {
     };
   }
 
-  const truncated = manifest.entries.length > limit;
-  const rows = manifest.entries.slice(0, limit);
+  const folded = oneRowPerRoute(cg, manifest.entries);
+  const truncated = folded.length > limit || manifest.entries.length >= fetched;
+  const rows = folded.slice(0, limit);
 
   // Every row's handler file in one batched query, so a project that scatters
   // handlers across hundreds of files still costs one query per chunk, and no
@@ -127,11 +183,13 @@ export function buildRoutes(cg: CodeGraph, query: URLSearchParams): WireRoutes {
     handlerKind: entry.handlerKind,
     file: toPosixPath(entry.handlerFile),
     line: entry.handlerLine,
-    handlerId:
-      byFileLineName.get(`${entry.handlerFile} ${entry.handlerLine} ${entry.handler}`) ?? null,
+    handlerId: entry.inline
+      ? entry.routeId
+      : byFileLineName.get(`${entry.handlerFile} ${entry.handlerLine} ${entry.handler}`) ?? null,
     routeFile: toPosixPath(entry.routeFile),
     routeLine: entry.routeLine,
     routeId: entry.routeId,
+    inline: entry.inline,
   }));
 
   return {
diff --git a/src/ui-server/api/screens.ts b/src/ui-server/api/screens.ts
index 7e11ca9f70..a8b6ec73f6 100644
--- a/src/ui-server/api/screens.ts
+++ b/src/ui-server/api/screens.ts
@@ -30,7 +30,7 @@
 import * as fs from 'fs';
 import type CodeGraph from '../../index';
 import type { Edge, Node } from '../../types';
-import { routeRoots } from './route-roots';
+import { routeLayouts, routeRoots } from './route-roots';
 import { resolveProjectFile } from '../security';
 import { findIndexedFile, hasDriftedOnDisk } from './source';
 import { createWhenReader } from './when';
@@ -195,6 +195,9 @@ const SHARED_CHROME_MIN = 3;
 
 /** True when the edge's destination is written at the line the edge points to. */
 function writtenHere(edge: Edge, holder: Node): boolean {
+  // An Angular template names its destination where it is written — in a
+  // file of its own, beside the component the edge leaves from.
+  if ((edge.metadata as Record<string, unknown> | undefined)?.template === true) return true;
   const at = (edge.metadata as Record<string, unknown> | undefined)?.registeredAt;
   if (typeof at !== 'string') return edge.provenance !== 'heuristic';
   return at === `${holder.filePath}:${edge.line}`;
@@ -216,7 +219,7 @@ function writtenHere(edge: Edge, holder: Node): boolean {
  * Entry points, which is the list of what a request or a user can arrive at.
  */
 function isScreenRoute(route: Node): boolean {
-  return route.name.startsWith('/') && !route.filePath.includes('/server/api/');
+  return route.name.startsWith('/') && !`/${route.filePath}`.includes('/server/api/');
 }
 
 export async function buildScreens(cg: CodeGraph, projectRoot: string, query = new URLSearchParams()): Promise<WireScreensPayload> {
@@ -279,6 +282,15 @@ export async function buildScreens(cg: CodeGraph, projectRoot: string, query = n
     if (serves) serves.push(routeId);
     else screenOfComponent.set(root.node.id, [routeId]);
   }
+  // A layout serves every screen nested in it: ProfileComponent's tabs are on
+  // both `/profile/:username` and `/profile/:username/favorites`.
+  for (const [routeId, layouts] of routeLayouts(cg, routes)) {
+    for (const layout of layouts) {
+      const serves = screenOfComponent.get(layout);
+      if (!serves) screenOfComponent.set(layout, [routeId]);
+      else if (!serves.includes(routeId)) serves.push(routeId);
+    }
+  }
   const nodesById = cg.getNodesByIds([...componentOf.values()].map((n) => n.id).concat(navEdges.map((e) => e.source)));
 
   const readWhen = createWhenReader(cg, projectRoot, MAX_WHEN_SITES);
diff --git a/src/ui-server/api/steps.ts b/src/ui-server/api/steps.ts
index d9da63aab7..b6c85c3062 100644
--- a/src/ui-server/api/steps.ts
+++ b/src/ui-server/api/steps.ts
@@ -395,6 +395,13 @@ interface StepRecord extends WireStep {
   root: Node | null;
 }
 
+/** A trigger an edge carries in its metadata (a template binding), when it has one. */
+function siteTriggerOf(meta: Record<string, unknown>): SiteTrigger | null {
+  const t = meta.trigger as Partial<SiteTrigger> | undefined;
+  if (!t || typeof t !== 'object' || t.kind !== 'prop' || typeof t.name !== 'string') return null;
+  return { kind: 'prop', name: t.name, of: typeof t.of === 'string' ? t.of : null };
+}
+
 /**
  * The string a Java / Kotlin return expression builds, when it starts with a
  * literal: `"owners/ownerDetails"`, `"redirect:/owners/" + owner.getId()` →
@@ -1297,7 +1304,10 @@ export async function buildSteps(cg: CodeGraph, projectRoot: string, query: URLS
           // every call-shaped hop, so a store action or an effect fired by
           // a tap says so on its link too.
           const isCall = e.kind === 'calls' || e.kind === 'instantiates' || (e.kind === 'references' && meta.fnRef === true);
-          const trigger = isCall ? await triggerAt(fold.node, { line: e.line, column: e.column }) : null;
+          // An Angular template's `(click)` binding rides on its edge: the
+          // template is a file of its own, not the source at `e.line`.
+          const carried = siteTriggerOf(meta);
+          const trigger = carried ? { ...carried, in: fold.node.name } : isCall ? await triggerAt(fold.node, { line: e.line, column: e.column }) : null;
 
           // A server action, by its directive: a function in a `'use server'`
           // file (or opening with the directive) called from a file that is
diff --git a/src/ui-server/highlight/bounded-tokenize.ts b/src/ui-server/highlight/bounded-tokenize.ts
new file mode 100644
index 0000000000..9147538f37
--- /dev/null
+++ b/src/ui-server/highlight/bounded-tokenize.ts
@@ -0,0 +1,112 @@
+/**
+ * Highlighting that cannot take the server down.
+ *
+ * The viewer's server answers every request on one thread, and a slice is
+ * classified by handing it to a tree-sitter grammar — which can loop forever on
+ * a fragment it was never written for: cobolcraft's free-format COBOL, cut to a
+ * Flow card's window, kept the fixed-format grammar's scanner spinning inside
+ * WebAssembly, and every request after it — the page's own `/api/stats`
+ * included — waited behind it for good. A parse inside WebAssembly cannot be
+ * interrupted from JavaScript, so the slice is classified in a worker the
+ * server can terminate: past the deadline the worker is ended, the slice is
+ * served plain, and the next slice gets a fresh worker.
+ */
+
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { Worker } from 'worker_threads';
+import { tokenizeSource, type TokenizeResult } from '../../extraction/syntax-tokens';
+import type { Language } from '../../types';
+
+/** Longest a slice may take to classify — far past any file the grammars can parse at all. */
+export const TOKENIZE_DEADLINE_MS = 2000;
+
+/** What a bounded classification came to: the result, or that it ran out of time. */
+export type BoundedTokenize = { result: TokenizeResult | null } | { timedOut: true };
+
+interface Pending {
+  resolve: (outcome: BoundedTokenize) => void;
+  timer: NodeJS.Timeout;
+}
+
+let worker: Worker | null = null;
+let nextId = 1;
+const pending = new Map<number, Pending>();
+
+/**
+ * The compiled worker beside us; Vitest loads `src/` but builds `dist/` before
+ * the tests, so it uses that copy. Null when neither exists.
+ */
+function workerFile(): string | null {
+  const sibling = path.join(__dirname, 'tokenize-worker.js');
+  if (existsSync(sibling)) return sibling;
+  const built = path.resolve(__dirname, '../../../dist/ui-server/highlight/tokenize-worker.js');
+  return existsSync(built) ? built : null;
+}
+
+/** Settle everything waiting on the current worker and forget it. */
+function retire(outcome: BoundedTokenize): void {
+  const dead = worker;
+  worker = null;
+  for (const [id, p] of pending) {
+    clearTimeout(p.timer);
+    pending.delete(id);
+    p.resolve(outcome);
+  }
+  if (dead) void dead.terminate().catch(() => {});
+}
+
+function ensureWorker(file: string): Worker {
+  if (worker) return worker;
+  const w = new Worker(file);
+  w.unref();
+  w.on('message', (msg: { id: number; result: TokenizeResult | null }) => {
+    const p = pending.get(msg.id);
+    if (!p) return;
+    clearTimeout(p.timer);
+    pending.delete(msg.id);
+    p.resolve({ result: msg.result });
+  });
+  w.on('error', () => {
+    if (worker === w) retire({ result: null });
+  });
+  w.on('exit', () => {
+    if (worker === w) retire({ result: null });
+  });
+  worker = w;
+  return w;
+}
+
+/** Classify `text` in the highlight worker, giving up after {@link TOKENIZE_DEADLINE_MS}. */
+export async function tokenizeBounded(
+  text: string,
+  language: Language,
+  deadlineMs = TOKENIZE_DEADLINE_MS
+): Promise<BoundedTokenize> {
+  const file = workerFile();
+  // No compiled worker (a source checkout that was never built): classify
+  // in-process, as before.
+  if (!file) return { result: await tokenizeSource(text, language) };
+  let w: Worker;
+  try {
+    w = ensureWorker(file);
+  } catch {
+    return { result: await tokenizeSource(text, language) };
+  }
+  const id = nextId++;
+  return new Promise<BoundedTokenize>((resolve) => {
+    const timer = setTimeout(() => {
+      // Everything queued behind the slice that hung waits on the same
+      // worker: end it, serve them all plain, and start over next time.
+      if (worker === w) retire({ timedOut: true });
+    }, deadlineMs);
+    timer.unref();
+    pending.set(id, { resolve, timer });
+    w.postMessage({ id, text, language });
+  });
+}
+
+/** End the highlight worker — for tests, and for a server that is shutting down. */
+export function stopHighlightWorker(): void {
+  retire({ result: null });
+}
diff --git a/src/ui-server/highlight/index.ts b/src/ui-server/highlight/index.ts
index 11e69861e0..3e3b5a9cc9 100644
--- a/src/ui-server/highlight/index.ts
+++ b/src/ui-server/highlight/index.ts
@@ -42,7 +42,8 @@
  * whole-file view pages the same file repeatedly.
  */
 
-import { SYNTAX_TOKEN_CLASSES, tokenizeSource, type SyntaxTokenClass } from '../../extraction/syntax-tokens';
+import { SYNTAX_TOKEN_CLASSES, type SyntaxTokenClass } from '../../extraction/syntax-tokens';
+import { tokenizeBounded } from './bounded-tokenize';
 import type { Language } from '../../types';
 import { grammarFor } from './languages';
 
@@ -208,7 +209,11 @@ async function highlightUncached(
     return plain(lines, grammar, 'Too much text on too few lines to highlight (minified?).');
   }
 
-  const tokenized = await tokenizeSource(text, language as Language);
+  const bounded = await tokenizeBounded(text, language as Language);
+  if ('timedOut' in bounded) {
+    return plain(lines, grammar, `The ${grammar} grammar took too long on this slice, so it is shown unhighlighted.`);
+  }
+  const tokenized = bounded.result;
   if (!tokenized || tokenized.spans.length === 0) {
     return plain(lines, grammar, `The ${grammar} grammar is not available in this build.`);
   }
diff --git a/src/ui-server/highlight/tokenize-worker.ts b/src/ui-server/highlight/tokenize-worker.ts
new file mode 100644
index 0000000000..6c25fe6e12
--- /dev/null
+++ b/src/ui-server/highlight/tokenize-worker.ts
@@ -0,0 +1,25 @@
+/**
+ * The worker side of bounded highlighting (`bounded-tokenize.ts`): classifies
+ * one slice per message with the engine's own grammars, off the server's
+ * thread, so a grammar that never finishes a slice can be terminated.
+ */
+
+import { parentPort } from 'worker_threads';
+import { tokenizeSource } from '../../extraction/syntax-tokens';
+import type { Language } from '../../types';
+
+interface TokenizeRequest {
+  id: number;
+  text: string;
+  language: Language;
+}
+
+parentPort?.on('message', async (msg: TokenizeRequest) => {
+  let result: Awaited<ReturnType<typeof tokenizeSource>> = null;
+  try {
+    result = await tokenizeSource(msg.text, msg.language);
+  } catch {
+    result = null;
+  }
+  parentPort?.postMessage({ id: msg.id, result });
+});
diff --git a/src/ui-server/index.ts b/src/ui-server/index.ts
index 40c170f703..e5d0cced8a 100644
--- a/src/ui-server/index.ts
+++ b/src/ui-server/index.ts
@@ -397,9 +397,10 @@ function safeDecode(value: string): string {
 /**
  * Bind the first free port at or after `port`, on loopback only.
  *
- * Only `EADDRINUSE` advances to the next port — a permission failure or a bad
- * address will not get better one port over, and retrying twenty times would
- * only bury the real error.
+ * Only a port that is taken advances to the next one (see
+ * {@link shouldTryNextPort}) — a permission failure every port shares, or a
+ * bad address, will not get better one port over, and retrying twenty times
+ * would only bury the real error.
  */
 async function listenWithFallback(
   server: http.Server,
@@ -407,6 +408,9 @@ async function listenWithFallback(
 ): Promise<number> {
   // Port 0 means "any free port", so there is nothing to fall back from.
   const attempts = opts.port === 0 || !opts.fallback ? 1 : Math.max(1, opts.attempts);
+  const platform = process.platform;
+  // Whether any port was refused rather than in use — the message says so.
+  let refused = false;
 
   for (let i = 0; i < attempts; i++) {
     const candidate = opts.port === 0 ? 0 : opts.port + i;
@@ -419,8 +423,9 @@ async function listenWithFallback(
       return address.port;
     } catch (err) {
       const code = (err as NodeJS.ErrnoException).code;
-      if (code !== 'EADDRINUSE' || i === attempts - 1) {
-        throw describeBindFailure(err, candidate, opts);
+      if (code === 'EACCES') refused = true;
+      if (!shouldTryNextPort(code, candidate, platform) || i === attempts - 1) {
+        throw describeBindFailure(err, candidate, opts, platform, refused);
       }
     }
   }
@@ -434,7 +439,8 @@ async function listenWithFallback(
  * The same `http.Server` is reused across attempts: a `listen()` that failed
  * with EADDRINUSE never took a handle, so it can be listened on again directly
  * (verified on Node 20 and 22 — `server.listening` is still `false` afterwards,
- * and `close()` on a never-listening server would itself throw).
+ * and `close()` on a never-listening server would itself throw). The same goes
+ * for a port Windows refused with EACCES (checked on Node 22 and 24).
  */
 function listenOnce(server: http.Server, port: number): Promise<void> {
   return new Promise<void>((resolve, reject) => {
@@ -452,22 +458,78 @@ function listenOnce(server: http.Server, port: number): Promise<void> {
   });
 }
 
-/** Turn a bind failure into something a user can act on. */
-function describeBindFailure(
+/**
+ * Whether a `listen()` on `port` that failed with `code` leaves the next port
+ * worth trying.
+ *
+ * `EADDRINUSE` does, and so does `EACCES` on Windows: a port another program
+ * holds exclusively (`SO_EXCLUSIVEADDRUSE`), or one inside a range the system
+ * reserves (Hyper-V and WinNAT reserve whole blocks of them), fails there with
+ * EACCES rather than EADDRINUSE. Elsewhere, EACCES below 1024 is the
+ * privileged-port rule, which the next port is under too, so walking on would
+ * only bury it. From 1024 up it is something refusing that one port — a
+ * security policy, say — and the next one may be allowed.
+ */
+export function shouldTryNextPort(
+  code: string | undefined,
+  port: number,
+  platform: NodeJS.Platform = process.platform
+): boolean {
+  if (code === 'EADDRINUSE') return true;
+  return code === 'EACCES' && !isPrivilegedPort(port, platform);
+}
+
+/**
+ * Whether `port` is one only an administrator may bind: below 1024, on every
+ * platform but Windows, which has no such rule.
+ */
+function isPrivilegedPort(port: number, platform: NodeJS.Platform): boolean {
+  return platform !== 'win32' && port > 0 && port < 1024;
+}
+
+/** The command that lists the port ranges Windows reserves. */
+const LIST_RESERVED_PORTS = '`netsh int ipv4 show excludedportrange protocol=tcp`';
+
+/**
+ * Turn a bind failure into something a user can act on, and that is true where
+ * it is read: Windows refuses ports for reasons POSIX doesn't have, and has no
+ * privileged ports.
+ *
+ * `refused` says whether any port a fallback walk tried was refused (EACCES)
+ * rather than in use; it only changes the message for a walk that ran out.
+ */
+export function describeBindFailure(
   err: unknown,
   port: number,
-  opts: { port: number; fallback: boolean; attempts: number }
+  opts: { port: number; fallback: boolean },
+  platform: NodeJS.Platform = process.platform,
+  refused = false
 ): Error {
   const code = (err as NodeJS.ErrnoException).code;
+  const windows = platform === 'win32';
+  if (opts.fallback && shouldTryNextPort(code, port, platform)) {
+    // A failure that moves on only ends the walk when there is nowhere left.
+    const taken =
+      !refused && code === 'EADDRINUSE'
+        ? 'in use'
+        : windows
+          ? `in use or reserved (${LIST_RESERVED_PORTS} lists the reserved ranges)`
+          : 'in use or not allowed';
+    return new Error(`Ports ${opts.port}–${port} are all ${taken}. Free one, or pick another with --port.`);
+  }
   if (code === 'EADDRINUSE') {
-    return opts.fallback
-      ? new Error(
-          `Ports ${opts.port}–${port} are all in use. Free one, or pick another with --port.`
-        )
-      : new Error(`Port ${port} is already in use. Pick another with --port, or omit --port to let CodeGraph find a free one.`);
+    return new Error(`Port ${port} is already in use. Pick another with --port, or omit --port to let CodeGraph find a free one.`);
   }
   if (code === 'EACCES') {
-    return new Error(`Not allowed to listen on port ${port}. Ports below 1024 usually need elevated privileges — pick a higher one with --port.`);
+    if (isPrivilegedPort(port, platform)) {
+      return new Error(`Not allowed to listen on port ${port}. Ports below 1024 usually need elevated privileges — pick a higher one with --port.`);
+    }
+    return new Error(
+      (windows
+        ? `Windows refused port ${port}: another program holds it, or it is in a reserved range (${LIST_RESERVED_PORTS} lists them).`
+        : `Not allowed to listen on port ${port}: the system refused permission.`) +
+        ' Pick another with --port, or omit --port to let CodeGraph find a free one.'
+    );
   }
   return err instanceof Error ? err : new Error(String(err));
 }
diff --git a/src/ui-server/workspace/config.ts b/src/ui-server/workspace/config.ts
index be72ebd942..479bb92cd9 100644
--- a/src/ui-server/workspace/config.ts
+++ b/src/ui-server/workspace/config.ts
@@ -15,7 +15,13 @@ function resolveOfflinePath(absolute: string): string {
     try {
       if (fs.lstatSync(absolute).isSymbolicLink()) return resolveOfflinePath(path.resolve(path.dirname(absolute), fs.readlinkSync(absolute)));
     } catch (statError) { if ((statError as NodeJS.ErrnoException).code !== 'ENOENT') throw statError; }
-    return path.join(resolveOfflinePath(path.dirname(absolute)), path.basename(absolute));
+    const parent = resolveOfflinePath(path.dirname(absolute));
+    // Windows can report ENOENT, not ENOTDIR, for a child of an ordinary
+    // file. A real ancestor must still be a directory before it can host
+    // offline descendants; do not hide malformed project paths as offline.
+    const parentStat = statIfPresent(parent);
+    if (parentStat && !parentStat.isDirectory()) throw new Error(`项目路径的祖先不是目录：${parent}`);
+    return path.join(parent, path.basename(absolute));
   }
 }
 
diff --git a/src/upgrade/index.ts b/src/upgrade/index.ts
index 625e45b831..0e088e9982 100644
--- a/src/upgrade/index.ts
+++ b/src/upgrade/index.ts
@@ -17,11 +17,12 @@
  * vendored `node` binary and a `bin/codegraph` launcher next to its `lib/`, so
  * we can recognize it from the running file's path without a marker file.
  *
- * Windows wrinkle: a running `node.exe` is locked and can't be deleted, so the
- * bundle's `current\` dir can't be overwritten in place by the process doing
- * the upgrade. We therefore spawn a DETACHED helper that waits for this
- * process to exit (releasing the lock), then runs `install.ps1`. This is the
- * conventional Windows self-update dance (rustup/nvm-windows do the same).
+ * Windows wrinkle: a running `node.exe` and a loaded `.node` addon are locked —
+ * they can't be overwritten or deleted, by this process or by the MCP servers
+ * of open agent sessions. They CAN be renamed, so the Windows upgrade unpacks
+ * the new bundle next to `current\` and swaps it in file by file, renaming each
+ * replaced file aside and rolling every step back on failure (see
+ * `WINDOWS_SWAP_FUNCTION`, shared verbatim with `install.ps1`).
  */
 
 import * as fs from 'fs';
@@ -34,6 +35,7 @@ export const REPO = 'colbymchenry/codegraph';
 export const NPM_PACKAGE = '@colbymchenry/codegraph';
 const RAW_BASE = `https://raw.githubusercontent.com/${REPO}/main`;
 export const INSTALL_SH_URL = `${RAW_BASE}/install.sh`;
+export const INSTALL_PS1_URL = `${RAW_BASE}/install.ps1`;
 
 // ---------------------------------------------------------------------------
 // Install-method detection (pure — fully unit-testable via injected probes)
@@ -297,6 +299,15 @@ export interface UpgradeDeps {
   warn: (msg: string) => void;
   error: (msg: string) => void;
   platform: NodeJS.Platform;
+  /**
+   * Wire Claude Code's front-load prompt hook into the GLOBAL Claude profile
+   * when that profile already has CodeGraph configured; resolves true when it
+   * changed the settings file. That file is the user's real
+   * `~/.claude/settings.json`, so the writer is injected like every other side
+   * effect here — the CLI passes {@link defaultWirePromptHook}, unit tests a
+   * recorder (#2275: tests that reached the real one rewrote the developer's).
+   */
+  wirePromptHook: () => Promise<boolean>;
   /**
    * Offer the one-time CodeGraph Pro beta opt-in after a successful update
    * (see installer/beta-signup — self-gating: TTY only, and silent forever
@@ -528,10 +539,7 @@ function selfHealInstalledSurfaces(deps: UpgradeDeps): void {
  */
 async function selfHealPromptHook(deps: UpgradeDeps): Promise<void> {
   if (process.env.CODEGRAPH_NO_PROMPT_HOOK === '1' || process.env.CODEGRAPH_PROMPT_HOOK === '0') return;
-  const { claudeTarget, writePromptHookEntry } = await import('../installer/targets/claude');
-  if (!claudeTarget.detect('global').alreadyConfigured) return;
-  const res = writePromptHookEntry('global');
-  if (res.action === 'created' || res.action === 'updated') {
+  if (await deps.wirePromptHook()) {
     deps.log(
       c.dim('Enabled the CodeGraph front-load hook for Claude Code (structural prompts). Disable any time: CODEGRAPH_NO_PROMPT_HOOK=1'),
     );
@@ -572,36 +580,140 @@ function upgradeUnixBundle(
   return 0;
 }
 
+/**
+ * The PowerShell function that moves an unpacked Windows bundle into the
+ * install's `current\` dir. Shared VERBATIM with `install.ps1` (a test pins the
+ * two copies equal), so a first install, a re-run of the installer, and
+ * `codegraph upgrade` all replace files the same way.
+ *
+ * Why file-by-file renames (#2185): every open agent session runs a CodeGraph
+ * MCP server from `current\`, which keeps `node.exe` and the native kernel
+ * (`lib\kernel\codegraph-kernel.node`) locked. Windows refuses to overwrite or
+ * delete a running exe or a loaded DLL but does let it be renamed. The old
+ * upgrade renamed only `node.exe` and then `Copy-Item`ed over the rest, so the
+ * locked kernel failed the copy halfway — leaving no `node.exe` and a mix of
+ * versions, which no `codegraph` command could repair. Now each file being
+ * replaced (or dropped by the new version) is renamed aside to
+ * `<name>.old-<token>` before the staged file is moved in; any failure undoes
+ * every step, and the renamed-aside files are deleted on the next successful
+ * run once nothing holds them.
+ */
+export const WINDOWS_SWAP_FUNCTION = String.raw`function Install-CodeGraphFiles([string]$Stage, [string]$Dest) {
+  # Move an unpacked bundle into $Dest. Windows can't overwrite or delete a
+  # running node.exe or a loaded .node addon, but it can rename one, so every
+  # file being replaced (or dropped by the new version) is first renamed aside
+  # to <name>.old-<token>. Any failure puts every file back, so the install is
+  # never left half-replaced or without its node.exe.
+  $ErrorActionPreference = 'Stop'
+  $stageDir = (Resolve-Path -LiteralPath $Stage).ProviderPath.TrimEnd('\')
+  foreach ($need in 'node.exe', 'bin\codegraph.cmd') {
+    if (-not (Test-Path -LiteralPath (Join-Path $stageDir $need))) { throw "The CodeGraph download is incomplete (no $need); nothing was changed." }
+  }
+  $token = [guid]::NewGuid().ToString('N').Substring(0, 8)
+  $asideName = '\.old-[0-9a-f]{8,32}$'
+  $files = @{}; $dirs = @{}
+  foreach ($i in @(Get-ChildItem -LiteralPath $stageDir -Recurse -Force)) {
+    $rel = $i.FullName.Substring($stageDir.Length)
+    if ($i.PSIsContainer) { $dirs[$rel] = $true } else { $files[$rel] = $true }
+  }
+  $undo = New-Object System.Collections.ArrayList
+  function Move-Logged([string]$From, [string]$To) { [IO.File]::Move($From, $To); [void]$undo.Add(@($From, $To)) }
+  function Undo-Logged {
+    $lost = 0
+    for ($n = $undo.Count - 1; $n -ge 0; $n--) {
+      $u = $undo[$n]
+      try { if ($u.Count -eq 2) { [IO.File]::Move($u[1], $u[0]) } else { [IO.Directory]::Delete($u[0]) } } catch { if ($u.Count -eq 2) { $lost++ } }
+    }
+    $undo.Clear()
+    $lost
+  }
+  $done = $false; $at = $Dest
+  try {
+    if (-not (Test-Path -LiteralPath $Dest)) { [void][IO.Directory]::CreateDirectory($Dest); [void]$undo.Add(@($Dest)) }
+    $destDir = (Resolve-Path -LiteralPath $Dest).ProviderPath.TrimEnd('\')
+    foreach ($f in @(Get-ChildItem -LiteralPath $destDir -Recurse -Force -File)) {
+      if (-not $files.ContainsKey($f.FullName.Substring($destDir.Length)) -and $f.Name -notmatch $asideName) {
+        $at = $f.FullName; Move-Logged $at "$at.old-$token"
+      }
+    }
+    foreach ($rel in @($dirs.Keys | Sort-Object Length)) {
+      $at = $destDir + $rel
+      if (-not [IO.Directory]::Exists($at)) { [void][IO.Directory]::CreateDirectory($at); [void]$undo.Add(@($at)) }
+    }
+    foreach ($rel in @($files.Keys)) {
+      $at = $destDir + $rel
+      if ([IO.File]::Exists($at)) { Move-Logged $at "$at.old-$token" }
+      Move-Logged ($stageDir + $rel) $at
+    }
+    $done = $true
+  } catch {
+    $x = $_.Exception; while ($x.InnerException) { $x = $x.InnerException }
+    $lost = Undo-Logged
+    $msg = "Could not replace $at ($($x.Message))."
+    if ($lost) {
+      $msg += " $lost file(s) could not be put back, so the install may not start. Close your agent sessions and any running codegraph commands, then reinstall: irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex"
+    } else {
+      $msg += " Nothing was changed: the existing install still works. If another program has CodeGraph's files open, close your agent sessions (they run the CodeGraph MCP server) and any running codegraph commands, then try again."
+    }
+    $e = New-Object System.Exception($msg); $e.Data['codegraphDamaged'] = [bool]$lost; throw $e
+  } finally {
+    # Interrupted (Ctrl+C) without reaching catch: still put everything back.
+    if (-not $done) { [void](Undo-Logged) }
+  }
+  # Delete what this run and earlier ones renamed aside. A file a running
+  # process still holds can't be deleted yet; the next install retries it.
+  foreach ($f in @(Get-ChildItem -LiteralPath $destDir -Recurse -Force -File -ErrorAction SilentlyContinue)) {
+    if ($f.Name -match $asideName) { try { [IO.File]::Delete($f.FullName) } catch {} }
+  }
+  foreach ($d in @(Get-ChildItem -LiteralPath $destDir -Recurse -Force -Directory -ErrorAction SilentlyContinue | Sort-Object { $_.FullName.Length } -Descending)) {
+    if (-not $dirs.ContainsKey($d.FullName.Substring($destDir.Length))) { try { [IO.Directory]::Delete($d.FullName) } catch {} }
+  }
+}
+`;
+
+/** Single-quote a value for PowerShell (a `'` inside is doubled). */
+function psQuote(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+/** Exit code of the upgrade script when files could not all be put back. */
+export const WINDOWS_UPGRADE_DAMAGED = 2;
+
 /** Build the in-place Windows upgrade script (exported for unit-testing). */
 export function buildWindowsUpgradeScript(bundleRoot: string, version: string, arch: string): string {
   const target = `win32-${arch}`;
   const url = `https://github.com/${REPO}/releases/download/${version}/codegraph-${target}.zip`;
-  // Windows can't DELETE a running exe but CAN rename it, so we upgrade IN
-  // PLACE: download → rename the locked node.exe aside → extract the new bundle
-  // over current\. Synchronous, no detached helper (which dies under SSH/job
-  // objects and has worse UX). The running process keeps its renamed node.exe
-  // mapped; the NEXT `codegraph` invocation uses the new one. We can't reuse
-  // install.ps1 here — it `Remove-Item`s current\, which fails on the locked exe.
+  // Synchronous, no detached helper (which dies under SSH/job objects and has
+  // worse UX). The bundle is unpacked into a sibling of current\ — the same
+  // volume, so the swap is renames, never a half-finished copy — and nothing
+  // in current\ changes until it is fully unpacked. The running process keeps
+  // its renamed node.exe mapped; the NEXT `codegraph` invocation uses the new
+  // one. Exit codes: 0 installed, 1 failed with the install unchanged,
+  // WINDOWS_UPGRADE_DAMAGED when the rollback could not restore every file.
   return [
     `$ErrorActionPreference='Stop'`,
-    `$dest='${bundleRoot}'`,
-    `$url='${url}'`,
-    `Write-Host "Downloading $url"`,
+    WINDOWS_SWAP_FUNCTION,
+    `$dest=${psQuote(bundleRoot)}`,
+    `$url=${psQuote(url)}`,
     `$tmp=Join-Path $env:TEMP ('cg-up-'+[guid]::NewGuid().ToString('N'))`,
-    `New-Item -ItemType Directory -Force -Path $tmp | Out-Null`,
-    `$zip=Join-Path $tmp 'cg.zip'`,
-    `Invoke-WebRequest -Uri $url -OutFile $zip`,
-    `$stage=Join-Path $tmp 'stage'`,
-    `Expand-Archive -Path $zip -DestinationPath $stage -Force`,
-    `$inner=Join-Path $stage 'codegraph-${target}'`,
-    `$src=if(Test-Path $inner){$inner}else{$stage}`,
-    `$node=Join-Path $dest 'node.exe'`,
-    `if(Test-Path $node){Rename-Item -Path $node -NewName ('node.exe.old-'+[guid]::NewGuid().ToString('N')) -Force}`,
-    `Copy-Item -Path (Join-Path $src '*') -Destination $dest -Recurse -Force`,
-    `Get-ChildItem -Path $dest -Filter 'node.exe.old-*' -ErrorAction SilentlyContinue | ForEach-Object { try { Remove-Item $_.FullName -Force -ErrorAction Stop } catch {} }`,
-    `Remove-Item -Recurse -Force $tmp -ErrorAction SilentlyContinue`,
-    `Write-Host "Installed CodeGraph ${version} to $dest"`,
-  ].join(';');
+    `$stage=Join-Path (Split-Path -Parent $dest) ('.staging-'+[guid]::NewGuid().ToString('N').Substring(0,8))`,
+    `$code=0`,
+    `try {`,
+    `  Write-Host "Downloading $url"`,
+    `  New-Item -ItemType Directory -Force -Path $tmp | Out-Null`,
+    `  $zip=Join-Path $tmp 'cg.zip'`,
+    `  Invoke-WebRequest -Uri $url -OutFile $zip`,
+    `  Expand-Archive -Path $zip -DestinationPath $stage -Force`,
+    `  $inner=Join-Path $stage 'codegraph-${target}'`,
+    `  Install-CodeGraphFiles $(if(Test-Path $inner){$inner}else{$stage}) $dest`,
+    `  Write-Host "Installed CodeGraph ${version} to $dest"`,
+    `} catch {`,
+    `  [Console]::Error.WriteLine($_.Exception.Message)`,
+    `  $code=if($_.Exception.Data['codegraphDamaged']){${WINDOWS_UPGRADE_DAMAGED}}else{1}`,
+    `}`,
+    `Remove-Item -LiteralPath $stage,$tmp -Recurse -Force -ErrorAction SilentlyContinue`,
+    `exit $code`,
+  ].join('\n');
 }
 
 function upgradeWindowsBundle(
@@ -618,7 +730,15 @@ function upgradeWindowsBundle(
   deps.log(c.dim(`Downloading and installing ${latest}…`));
   const code = deps.run('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded]);
   if (code !== 0) {
-    deps.error(`Installer exited with code ${code}.`);
+    // The script has already printed what went wrong and what to do.
+    if (code === WINDOWS_UPGRADE_DAMAGED) {
+      deps.error('The upgrade failed and some files could not be put back.');
+      deps.log(c.dim(`Close your agent sessions and any running codegraph commands, then reinstall:  irm ${INSTALL_PS1_URL} | iex`));
+    } else if (code === 1) {
+      deps.error(`The upgrade to ${latest} did not complete; your existing install was left as it was.`);
+    } else {
+      deps.error(`Installer exited with code ${code}.`);
+    }
     return 1;
   }
   deps.log('');
@@ -714,3 +834,15 @@ export function defaultCapture(cmd: string, args: string[]): { code: number; std
   if (r.error) return null;
   return { code: r.status ?? -1, stdout: r.stdout ?? '' };
 }
+
+/**
+ * The production `UpgradeDeps.wirePromptHook`: writes the hook only when the
+ * global Claude profile already carries CodeGraph's MCP entry, and leaves the
+ * file byte-for-byte alone once the hook is there.
+ */
+export async function defaultWirePromptHook(): Promise<boolean> {
+  const { claudeTarget, writePromptHookEntry } = await import('../installer/targets/claude');
+  if (!claudeTarget.detect('global').alreadyConfigured) return false;
+  const res = writePromptHookEntry('global');
+  return res.action === 'created' || res.action === 'updated';
+}
diff --git a/src/worker-teardown.ts b/src/worker-teardown.ts
new file mode 100644
index 0000000000..fa5d08e34a
--- /dev/null
+++ b/src/worker-teardown.ts
@@ -0,0 +1,100 @@
+/**
+ * Ending a worker thread without taking the process down.
+ *
+ * On Windows, a worker thread that ends — terminated, by its own
+ * `process.exit()`, or with the process — while V8's concurrent marker is
+ * still marking its heap can crash the whole process with an access violation
+ * (exit 3221225477 / 0xC0000005), with no error and no dump. Bisected on a
+ * Windows 11 ARM64 VM (Node 24): `--no-concurrent-marking` alone stops it, and
+ * no other concurrency flag does — but that flag makes indexing about a third
+ * slower, so CodeGraph avoids the dangerous moments instead.
+ *
+ * Measured there, 480 child processes per row, four workers each:
+ *
+ *   ended while still loading CodeGraph's modules      18 crashed
+ *   loaded and allocating, terminated by the owner       4 crashed
+ *   loaded and allocating, exiting by itself             1 crashed
+ *   loaded and allocating, full collection, then exit    0 crashed
+ *
+ * So an owner never ends a worker that is still starting (it waits for the
+ * worker's first message, which is posted only after its modules load), and a
+ * worker that is about to exit collects garbage first — a full collection
+ * finishes any marking in flight.
+ */
+
+import type { Worker } from 'worker_threads';
+
+/**
+ * Longest an owner waits for a worker to finish starting before terminating
+ * it anyway. A start takes about a second normally and a few under heavy
+ * load; the cap only bounds a start that is wedged.
+ */
+export const WORKER_START_SETTLE_MS = 15_000;
+
+/**
+ * Settles once `worker` has started — its first message — or has gone away.
+ * Call it right after creating the worker, before it can post anything.
+ */
+export function workerStarted(worker: Worker): Promise<void> {
+  return new Promise<void>((resolve) => {
+    worker.once('message', () => resolve());
+    worker.once('error', () => resolve());
+    worker.once('exit', () => resolve());
+  });
+}
+
+/**
+ * Terminate `worker`, but not while it is still starting: wait for `started`
+ * (from {@link workerStarted}) first, up to `capMs`. Never rejects.
+ */
+export async function terminateOnceStarted(
+  worker: Pick<Worker, 'terminate'>,
+  started: Promise<void>,
+  capMs = WORKER_START_SETTLE_MS
+): Promise<void> {
+  let cap: NodeJS.Timeout | undefined;
+  await Promise.race([
+    started,
+    new Promise<void>((resolve) => {
+      cap = setTimeout(resolve, capMs);
+      cap.unref?.();
+    }),
+  ]);
+  clearTimeout(cap);
+  try {
+    await worker.terminate();
+  } catch {
+    // already gone
+  }
+}
+
+let collect: (() => void) | null | undefined;
+
+/**
+ * In a worker that is about to exit: run a full garbage collection, so no
+ * marking is in flight when the thread ends. Returns whether one ran. The
+ * collector is reached at runtime (no `--expose-gc` on the command line) and
+ * is never exposed as a global.
+ */
+export function collectBeforeExit(): boolean {
+  if (collect === undefined) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      (require('v8') as typeof import('v8')).setFlagsFromString('--expose-gc');
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      collect = (require('vm') as typeof import('vm')).runInNewContext('gc') as () => void;
+      // Only the context made above needed it; workers created later don't get a global gc.
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      (require('v8') as typeof import('v8')).setFlagsFromString('--no-expose-gc');
+    } catch {
+      collect = null;
+    }
+  }
+  if (!collect) return false;
+  try {
+    collect();
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/telemetry-dashboard/README.md b/telemetry-dashboard/README.md
index 83d673e7c5..10c1fb3fc2 100644
--- a/telemetry-dashboard/README.md
+++ b/telemetry-dashboard/README.md
@@ -40,19 +40,26 @@ renders. Bad input is a `400` with a message, never a guess. Chart data carries
 
 | Endpoint | Answers |
 |---|---|
-| `/api/meta` | The days data actually exists for. The picker anchors its presets on `latest_day` so no chart ends on a day the nightly rollup has not written yet. |
+| `/api/meta` | How current the data is: `today`, the rollup's last day (`latest_rollup_day`), the last day ingest stored anything (`latest_ingest_day` — a lifecycle event or a usage counter), machines active yesterday, and two flags — `ingest_stalled` and `rollup_behind` — that put a warning above the panels when either writer stops. Cached 60 s. |
 | `/api/summary` | Big numbers: production users, active machines, new machines, installs, uninstalls, indexing runs, tool calls. |
-| `/api/timeseries?metric=` | `installs_uninstalls`, `new_installs`, `production_users`, `indexing_activity`, `tool_calls`, `duration_buckets`. One dense point per day — a day with nothing is a zero, not a gap. |
+| `/api/timeseries?metric=` | `installs_uninstalls`, `new_installs`, `production_users`, `indexing_activity`, `tool_calls`, `duration_buckets`. One dense point per day — a day with nothing is a zero, not a gap. Days after the rollup's last day are `null` ("not counted yet") and `covered_through` says where that is; `new_installs` is written live and runs through today. |
 | `/api/breakdown?dim=` | `os`, `arch`, `codegraph_version`, `node_major`, `language`, `file_count_bucket`, `duration_bucket`, `target`, `scope`, `kind`, `name`, `client_name`, `name_error`. Optional `&event=`, `&metric=count\|machines`, `&limit=`. |
 | `/api/activation?window=7` | Install → first index funnel, plus the daily rate. |
 | `/api/retention` | Day 0–14 cohort curve for machines first seen in the range. |
 | `/api/health` | Liveness plus the latest event/rollup day. Uncached. |
 
-Everything reads the `daily_*` rollups and `machine_days`, which are kept forever, so a
-chart stays correct for days whose raw events have been purged. `/api/activation` is the
-one exception — "did this machine ever run an index" is not a daily aggregate — so it
-reads raw `events` and is bounded by the ingest worker's retention window. It reports
-`raw_events_from` for that reason.
+Everything reads the `daily_*` rollups, `machine_days` and `machine_first_seen`, which are
+kept forever, so a chart stays correct for days whose raw events have been purged. **No
+panel reads raw `events`.** D1 runs one query at a time per database: the activation funnel
+used to join every cohort machine against `events`, which took ~55 s for one week of
+cohorts in production and failed every panel queued behind it. It now reads
+`machine_first_seen.first_index_day`, which the ingest worker lowers as each index event is
+stored and the nightly rollup re-derives from raw events.
+
+The presets end on **today** (UTC — every event and rollup is keyed on the UTC day). Live
+numbers — production users, new machines, retention — run through today; rolled-up ones
+stop at the rollup's last day, normally yesterday, and the filter row says which day that
+is.
 
 ### Two numbers that are easy to misread
 
@@ -104,6 +111,12 @@ npm run deploy
 Both secrets are required — the worker refuses every request if either is missing, so a
 half-configured deployment fails closed rather than becoming an open dashboard.
 
+The activation panels read `machine_first_seen.first_index_day`, which arrives with
+`telemetry-worker/migrations/0002_first_index_day.sql`. Apply the ingest worker's
+migrations and deploy it **before** this worker, or those two panels fail with a query
+error (the rest of the page is unaffected) — see "Backfilling first_index_day" in
+`telemetry-worker/README.md`.
+
 Rotating either one is a `wrangler secret put` away. Rotating `SESSION_SECRET` invalidates
 outstanding cookies too, and is the right move if you think one leaked.
 
@@ -126,6 +139,10 @@ npm run smoke:render             # the panels, in a browser (79 assertions)
 Each suite starts its own throwaway `wrangler dev` on its own port and cleans up after
 itself, so they can be run in any order (`DASH_PORT` overrides the port).
 
+The repo's own test suite also runs `src/api.ts`, with the ingest worker feeding it, against
+the writer's migrations in an in-memory SQLite database — no wrangler needed. From the repo
+root (it is part of `npm test` there): `npx vitest run __tests__/telemetry-services.test.ts`.
+
 **`smoke-auth.sh`** is the regression net for the gate: unauthenticated requests reach
 nothing (pages, API *and* static assets), the cookie is persistent and correctly flagged,
 flipped/truncated/forged cookies are all rejected, brute force is capped, and rotating the
diff --git a/telemetry-dashboard/public/app.js b/telemetry-dashboard/public/app.js
index 2c7f3a5f0e..abb2f46efa 100644
--- a/telemetry-dashboard/public/app.js
+++ b/telemetry-dashboard/public/app.js
@@ -32,14 +32,30 @@ const DAY_MS = 86_400_000;
 
 const Chart = window.Chart;
 
+/** Pause before the one retry a failed panel gets. */
+const RETRY_DELAY_MS = 800;
+
 /** Every fetch goes through here so an expired session lands on /login instead
- *  of failing silently mid-render. */
-export async function api(path) {
-  const response = await fetch(path, { headers: { accept: 'application/json' } });
+ *  of failing silently mid-render. A 5xx or a dropped connection gets exactly one
+ *  retry: D1 sheds queued queries under load and the second ask usually lands,
+ *  while a real failure still reaches the panel a moment later. */
+export async function api(path, { retry = true } = {}) {
+  let response;
+  try {
+    response = await fetch(path, { headers: { accept: 'application/json' } });
+  } catch (err) {
+    if (!retry) throw err;
+    await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+    return api(path, { retry: false });
+  }
   if (response.status === 401) {
     window.location.href = `/login?next=${encodeURIComponent(window.location.pathname)}`;
     throw new Error('session expired');
   }
+  if (response.status >= 500 && retry) {
+    await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+    return api(path, { retry: false });
+  }
   if (!response.ok) {
     const detail = await response.json().catch(() => null);
     throw new Error(detail?.error ?? `responded ${response.status}`);
@@ -61,8 +77,15 @@ const isDay = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(da
 // ---------------------------------------------------------------------------
 
 const state = {
-  /** Latest day the nightly rollup has written; every preset ends here. */
+  /**
+   * Today, as a UTC day — every preset ends here. Days are UTC because that is
+   * what every event and rollup is keyed on. Rolled-up numbers stop at the last
+   * day the nightly rollup has written; the API returns those later days as null,
+   * so a chart ending today shows a gap there rather than a zero.
+   */
   anchor: utcDay(Date.now()),
+  /** /api/meta, once it has answered: what each kind of number is current through. */
+  meta: null,
   earliest: null,
   preset: DEFAULT_PRESET,
   custom: { from: null, to: null },
@@ -341,16 +364,70 @@ async function drawPanel(panel, request, token) {
 // ---------------------------------------------------------------------------
 
 async function refreshMeta() {
+  // Re-read on every refresh, so a page left open overnight moves on to the new day.
+  state.anchor = utcDay(Date.now());
   try {
     const meta = await api('/api/meta');
-    if (meta.latest_day) state.anchor = meta.latest_day;
+    state.meta = meta;
+    if (meta.today) state.anchor = meta.today;
     state.earliest = meta.earliest_day ?? null;
-    syncFilters();
   } catch {
-    // A meta failure is not fatal: the picker falls back to today's date and
-    // every panel still answers. The banner is what says so.
-    document.getElementById('data-through').textContent = 'Could not read the data range.';
+    // A meta failure is not fatal: the presets still end today and every panel
+    // still answers. The status line is what says so.
+    state.meta = null;
+  }
+  for (const input of document.querySelectorAll('.custom-range input')) input.max = state.anchor;
+  syncFilters();
+  drawDataWarning();
+}
+
+const plural = (n, one, many) => `${n.toLocaleString('en-US')} ${n === 1 ? one : many}`;
+
+/** What each kind of number is current through, as one line of fact. */
+function dataThroughText() {
+  const meta = state.meta;
+  if (!meta) return 'Could not read how current the data is.';
+  const parts = [
+    meta.latest_rollup_day ? `Event counts through ${shortDay(meta.latest_rollup_day)}` : 'No event counts rolled up yet',
+  ];
+  // The one number that shows an ingest collapse at a glance: production runs at
+  // thousands a day, so a handful here means events are not being stored.
+  parts.push(`${plural(meta.machines_yesterday ?? 0, 'machine', 'machines')} active yesterday`);
+  return parts.join(' · ');
+}
+
+/**
+ * The stale-data warning. Silent when both writers are keeping up; otherwise says
+ * which one stopped, since when, and what that leaves the page unable to show.
+ */
+function drawDataWarning() {
+  const host = document.getElementById('data-warning');
+  host.replaceChildren();
+  const meta = state.meta;
+  const lines = [];
+
+  if (meta?.ingest_stalled) {
+    lines.push([
+      // The last day anything was stored, lifecycle event or usage counter.
+      `No new events since ${shortDay(meta.latest_ingest_day ?? meta.latest_raw_day)}.`,
+      ' The ingest worker at telemetry.getcodegraph.com is not storing anything; its logs and the D1 database are where to look.',
+    ]);
+  }
+  if (meta?.rollup_behind) {
+    lines.push([
+      meta.latest_rollup_day
+        ? `The nightly rollup has not run since ${shortDay(meta.latest_rollup_day)}.`
+        : 'The nightly rollup has never run.',
+      ' Installs, indexing runs, tool calls and every breakdown stop there. Machine counts, new installs and retention are live.',
+    ]);
+  }
+
+  for (const [lead, rest] of lines) {
+    const p = el('p');
+    p.append(el('strong', null, lead), document.createTextNode(rest));
+    host.append(p);
   }
+  host.hidden = lines.length === 0;
 }
 
 async function render() {
@@ -358,8 +435,8 @@ async function render() {
   const { from, to } = currentRange();
   const query = `from=${from}&to=${to}`;
 
-  setRangeSummary(`${shortDay(from)} – ${shortDay(to)}, ${to.slice(0, 4)}`);
-  document.getElementById('data-through').textContent = `Data through ${shortDay(state.anchor)}`;
+  setRangeSummary(`${shortDay(from)} – ${shortDay(to)}, ${to.slice(0, 4)} (UTC)`);
+  document.getElementById('data-through').textContent = dataThroughText();
 
   // Deduplicate identical URLs within THIS render only — the four stat tiles
   // share one /api/summary. Discarded when the render ends, so refresh refetches.
diff --git a/telemetry-dashboard/public/index.html b/telemetry-dashboard/public/index.html
index c573420735..6263b1afbd 100644
--- a/telemetry-dashboard/public/index.html
+++ b/telemetry-dashboard/public/index.html
@@ -44,6 +44,12 @@ <h1>codegraph telemetry</h1>
       </p>
     </section>
 
+    <!-- Filled from /api/meta when a writer has stopped: the ingest worker (no new
+         events) or the nightly rollup (numbers stuck on an old day). Both have
+         failed silently before, so the page says so instead of drawing old data
+         as if it were current. -->
+    <section class="data-warning" id="data-warning" role="status" hidden></section>
+
     <main class="grid" id="grid"></main>
 
     <script src="/vendor/chart.umd.js"></script>
diff --git a/telemetry-dashboard/public/styles.css b/telemetry-dashboard/public/styles.css
index 73ec9751c1..e2dc7f88c7 100644
--- a/telemetry-dashboard/public/styles.css
+++ b/telemetry-dashboard/public/styles.css
@@ -107,6 +107,28 @@ button:focus-visible {
   padding: 0 4px;
 }
 
+/* --- stale-data warning ------------------------------------------------- */
+
+.data-warning {
+  margin-top: 16px;
+  padding: 12px 16px;
+  background: var(--surface);
+  border: 1px solid var(--oxblood);
+}
+
+.data-warning p {
+  margin: 0;
+}
+
+.data-warning p + p {
+  margin-top: 6px;
+}
+
+.data-warning strong {
+  color: var(--oxblood);
+  font-weight: 600;
+}
+
 /* --- buttons ------------------------------------------------------------ */
 
 button {
diff --git a/telemetry-dashboard/scripts/fixture.sql b/telemetry-dashboard/scripts/fixture.sql
index 108df44365..e9ca7c151d 100644
--- a/telemetry-dashboard/scripts/fixture.sql
+++ b/telemetry-dashboard/scripts/fixture.sql
@@ -36,6 +36,7 @@ DELETE FROM daily_machines;
 DELETE FROM machine_days;
 DELETE FROM machine_first_seen;
 DELETE FROM events;
+DELETE FROM usage_daily;
 
 -- ---------------------------------------------------------------------------
 -- install — 12, one per machine on its first day
@@ -117,6 +118,12 @@ SELECT machine_id, min(day) FROM events GROUP BY machine_id;
 INSERT INTO daily_machines (day, machines, prod_machines)
 SELECT day, count(*), coalesce(sum(prod), 0) FROM machine_days GROUP BY day;
 
+-- The activation funnel's input: each machine's earliest index day (FIRST_INDEX_DAY).
+-- m04 and m06 never index, so theirs stays NULL.
+UPDATE machine_first_seen
+   SET first_index_day = (SELECT min(day) FROM events e
+                           WHERE e.machine_id = machine_first_seen.machine_id AND e.event = 'index');
+
 INSERT INTO daily_event_counts (day, event, count, machines)
 SELECT day, event,
        CASE WHEN event = 'usage_rollup'
diff --git a/telemetry-dashboard/scripts/render-check.mjs b/telemetry-dashboard/scripts/render-check.mjs
index 9411bec541..fd1a740fbd 100644
--- a/telemetry-dashboard/scripts/render-check.mjs
+++ b/telemetry-dashboard/scripts/render-check.mjs
@@ -176,8 +176,12 @@ const PROBE = `(() => {
       tableHidden: section.querySelector('[data-role="table"]').hidden,
     };
   });
+  const warning = document.getElementById('data-warning');
   return {
     ready: document.body.dataset.ready === 'true',
+    warning: warning.hidden ? null : warning.textContent,
+    customFrom: document.querySelector('[data-role="custom-from"]').value,
+    customTo: document.querySelector('[data-role="custom-to"]').value,
     range: document.getElementById('range-summary').textContent,
     dataThrough: document.getElementById('data-through').textContent,
     refreshed: document.getElementById('refreshed-at').textContent,
@@ -299,17 +303,32 @@ async function main() {
   // The very same registry the page just rendered from, imported here so the
   // expectations cannot drift from the panels under test.
   const { PANELS } = await import(pathToFileURL(join(root, 'public', 'panels.js')).href);
+  const { shortDay } = await import(pathToFileURL(join(root, 'public', 'theme.js')).href);
+  const utcDay = (ms) => new Date(ms).toISOString().slice(0, 10);
+  const today = utcDay(Date.now());
   check(`all ${PANELS.length} panels are on the page`, view.panels.length === PANELS.length, `got ${view.panels.length}`);
-  const broken = view.panels.filter((p) => p.state !== 'ready');
+  // The fixture lives in July, so a range ending today has nothing in it: every
+  // panel should say so plainly, and none should error.
+  const broken = view.panels.filter((p) => p.state !== 'ready' && p.state !== 'empty');
   check(
-    'every panel reached its ready state',
+    'every panel settled without an error',
     broken.length === 0,
     broken.map((p) => `${p.id}: ${p.state} ${p.message}`).join(' | '),
   );
   check('the default range is the 30-day preset', view.selectedPreset === 'Last 30 days', view.selectedPreset);
-  check('the range is stated in the filter row', /Jun|Jul/.test(view.range), view.range);
-  check('the data horizon is stated', view.dataThrough.includes('Jul 10'), view.dataThrough);
+  same('…ending today, not on the last rolled-up day', today, view.customTo);
+  same('…and starting 29 days before', utcDay(Date.now() - 29 * 864e5), view.customFrom);
+  check('the range is stated in the filter row', view.range.includes(shortDay(today)), view.range);
+  check('the rollup horizon is stated', view.dataThrough.includes('Event counts through Jul 10'), view.dataThrough);
+  check('…with yesterday\'s activity beside it', view.dataThrough.includes('0 machines active yesterday'), view.dataThrough);
   check('the refresh time is stated', view.refreshed.startsWith('Last refreshed'), view.refreshed);
+  // Nothing has arrived since the fixture's last day: the page must say so rather
+  // than present July as current.
+  check(
+    'a stalled ingest is called out above the panels',
+    view.warning?.includes('No new events since Jul 10.') === true,
+    String(view.warning),
+  );
 
   // A CSP violation surfaces here as a `security` log entry, which is the point
   // of the check: the page must work under `script-src 'self'` with no inline
@@ -339,10 +358,10 @@ async function main() {
     (await cdp.evaluate(sessionId, 'document.body.dataset.ready === "true"')) === true,
   );
   view = await cdp.evaluate(sessionId, PROBE);
-  const weekly = view.panels.find((p) => p.id === 'daily-production-users');
-  check('a daily line now holds 7 points', weekly.chart?.labels.length === 7, `${weekly.chart?.labels.length}`);
+  same('the range now starts 6 days back', utcDay(Date.now() - 6 * 864e5), view.customFrom);
+  check('…and still ends today', view.customTo === today, view.customTo);
   check('the 7-day preset is marked selected', view.selectedPreset === 'Last 7 days', view.selectedPreset);
-  check('every panel re-rendered cleanly', view.panels.every((p) => p.state === 'ready'));
+  check('every panel re-rendered cleanly', view.panels.every((p) => p.state === 'ready' || p.state === 'empty'));
 
   console.log('\nA custom range works the same way');
   await cdp.evaluate(
@@ -358,6 +377,12 @@ async function main() {
   view = await cdp.evaluate(sessionId, PROBE);
   check('the fixture window is 10 days', view.panels.find((p) => p.id === 'daily-production-users').chart?.labels.length === 10);
   check('no preset stays highlighted', view.selectedPreset === null, view.selectedPreset);
+  const notReady = view.panels.filter((p) => p.state !== 'ready');
+  check(
+    'every panel reached its ready state',
+    notReady.length === 0,
+    notReady.map((p) => `${p.id}: ${p.state} ${p.message}`).join(' | '),
+  );
 
   // -- every panel plots what the API returned ------------------------------
   console.log('\nEvery panel plots the API’s own numbers');
@@ -428,6 +453,29 @@ async function main() {
   same('languages lead with typescript', 'typescript', byId.languages.chart.labels[0]);
   check('retention starts at 100%', byId.retention.chart.datasets[0].data[0] === 100);
 
+  console.log('\nPast the rollup\'s last day, lines stop instead of dropping to zero');
+  await cdp.evaluate(
+    sessionId,
+    `document.body.dataset.ready = "";
+     document.querySelector('[data-role="custom-from"]').value = "2026-07-05";
+     document.querySelector('[data-role="custom-to"]').value = "2026-07-14";
+     document.querySelector('[data-role="custom-apply"]').click();`,
+  );
+  await waitFor('the over-the-edge render', async () =>
+    (await cdp.evaluate(sessionId, 'document.body.dataset.ready === "true"')) === true,
+  );
+  const edge = Object.fromEntries((await cdp.evaluate(sessionId, PROBE)).panels.map((p) => [p.id, p]));
+  same(
+    'daily production users ends in gaps after Jul 10',
+    [[2, 3, 2, 1, 1, 1, null, null, null, null]],
+    edge['daily-production-users'].chart?.datasets.map((d) => d.data),
+  );
+  same(
+    'new installs are live, so they stay zero rather than gap',
+    [[2, 0, 0, 1, 2, 0, 0, 0, 0, 0]],
+    edge['new-installs'].chart?.datasets.map((d) => d.data),
+  );
+
   // Colour, spacing and label collisions are not things an assertion catches.
   // RENDER_SHOT=/tmp/dash.png npm run smoke:render → look at it.
   if (process.env.RENDER_SHOT) {
diff --git a/telemetry-dashboard/scripts/seed-fixture.sh b/telemetry-dashboard/scripts/seed-fixture.sh
index 88c8b1e271..3f4eb66085 100755
--- a/telemetry-dashboard/scripts/seed-fixture.sh
+++ b/telemetry-dashboard/scripts/seed-fixture.sh
@@ -11,17 +11,20 @@ set -uo pipefail
 cd "$(dirname "$0")/.."
 
 DB=codegraph-telemetry
-MIGRATION=../telemetry-worker/migrations/0001_init.sql
+MIGRATIONS=../telemetry-worker/migrations
 
-if [[ ! -f "$MIGRATION" ]]; then
-  echo "seed: cannot find $MIGRATION — run this from a full checkout" >&2
+if [[ ! -f "$MIGRATIONS/0001_init.sql" ]]; then
+  echo "seed: cannot find $MIGRATIONS — run this from a full checkout" >&2
   exit 1
 fi
 
-# The migration is plain CREATE TABLE, so a second run fails on "table already
-# exists". That is the expected steady state here, hence the swallowed output —
-# the fixture load below is the step whose failure actually matters.
-npx wrangler d1 execute "$DB" --local --file="$MIGRATION" >/dev/null 2>&1
+# Applied in order, each as a plain file. A second run fails every one of them
+# ("table already exists", "duplicate column") — the expected steady state here,
+# hence the swallowed output. The fixture load below is the step whose failure
+# actually matters, and it fails loudly if a migration is missing.
+for migration in "$MIGRATIONS"/*.sql; do
+  npx wrangler d1 execute "$DB" --local --file="$migration" >/dev/null 2>&1
+done
 
 if ! npx wrangler d1 execute "$DB" --local --file=scripts/fixture.sql >/dev/null; then
   echo "seed: loading scripts/fixture.sql failed" >&2
diff --git a/telemetry-dashboard/scripts/smoke-api.sh b/telemetry-dashboard/scripts/smoke-api.sh
index 964c1b6819..8dda68403b 100755
--- a/telemetry-dashboard/scripts/smoke-api.sh
+++ b/telemetry-dashboard/scripts/smoke-api.sh
@@ -92,12 +92,22 @@ check "health stays uncached" "no-store" \
   "$(curl -sD - -o /dev/null -b "$JAR" "$BASE/api/health" | grep -i '^cache-control:' | cut -d' ' -f2- | tr -d '\r')"
 
 echo
-echo "/api/meta — what the range picker anchors on"
+echo "/api/meta — how current each kind of number is"
+TODAY="$(node -e 'console.log(new Date().toISOString().slice(0, 10))')"
+YESTERDAY="$(node -e 'console.log(new Date(Date.now() - 864e5).toISOString().slice(0, 10))')"
 META="$(get "/api/meta")"
-field "latest day"        latest_day       2026-07-10 "$META"
-field "earliest day"      earliest_day     2026-07-01 "$META"
-field "raw events start"  earliest_raw_day 2026-07-01 "$META"
-field "retention window"  retention_days   14         "$META"
+field "today, as a UTC day"  today            "$TODAY"   "$META"
+field "latest rollup day"    latest_rollup_day 2026-07-10 "$META"
+field "…kept as latest_day"  latest_day       2026-07-10 "$META"
+field "earliest day"         earliest_day     2026-07-01 "$META"
+field "raw events start"     earliest_raw_day 2026-07-01 "$META"
+field "retention window"     retention_days   14         "$META"
+# The fixture stops on 07-10, months ago: nothing has arrived since, but the
+# rollup did cover every day that saw activity, so it is not behind.
+field "ingest stalled (no events since 07-10)" ingest_stalled true "$META"
+field "…named by the last day anything was stored" latest_ingest_day 2026-07-10 "$META"
+field "rollup not behind (it covered every active day)" rollup_behind false "$META"
+field "nobody active yesterday" machines_yesterday 0 "$META"
 
 echo
 echo "/api/summary — the big numbers (12 machines, one of them CI)"
@@ -134,6 +144,7 @@ field "calls per day"     datasets.0.data '[0,40,28,0,0,12,0,0,0,5]' "$TS"
 field "machines per day"  datasets.1.data '[0,1,2,0,0,1,0,0,0,1]'    "$TS"
 
 TS="$(get "/api/timeseries?metric=duration_buckets&$RANGE")"
+field "coverage reported"         covered_through  2026-07-10              "$TS"
 field "bucket order is the scale" datasets.0.label '<10s'                  "$TS"
 field "…and ends at the longest"  datasets.3.label '5m+'                   "$TS"
 field "<10s over time"            datasets.0.data  '[2,0,1,1,0,0,0,1,0,0]' "$TS"
@@ -141,6 +152,22 @@ field "10-60s over time"          datasets.1.data  '[0,2,0,0,0,0,1,0,0,1]' "$TS"
 field "1-5m over time"            datasets.2.data  '[0,0,0,0,1,1,0,0,0,0]' "$TS"
 field "5m+ over time"             datasets.3.data  '[0,0,1,0,0,0,0,0,1,0]' "$TS"
 
+echo
+echo "Past the rollup's last day: not counted yet, so null — never a zero"
+# The fixture is rolled up through 07-10; 07-11 and 07-12 have not been.
+LATE="from=2026-07-09&to=2026-07-12"
+TS="$(get "/api/timeseries?metric=installs_uninstalls&$LATE")"
+field "installs stop at the rollup"   datasets.0.data '[2,0,null,null]' "$TS"
+field "…and say where"                covered_through 2026-07-10        "$TS"
+field "the table twin keeps the gap"  rows.2.Installs  null             "$TS"
+TS="$(get "/api/timeseries?metric=production_users&$LATE")"
+field "daily production users too"    datasets.0.data '[1,1,null,null]' "$TS"
+TS="$(get "/api/timeseries?metric=duration_buckets&$LATE")"
+field "run length over time too"      datasets.0.data '[0,0,null,null]' "$TS"
+TS="$(get "/api/timeseries?metric=new_installs&$LATE")"
+field "new installs are live: zeros, not gaps" datasets.0.data '[2,0,0,0]' "$TS"
+field "…and claim no rollup coverage"          covered_through null        "$TS"
+
 echo
 echo "/api/breakdown — bars and pies"
 # machine-days, taking the largest per-event count per day so one machine's
@@ -209,6 +236,7 @@ field "…so two dropped"                    dropped    2 "$ACT"
 field "window"                             window_days 7 "$ACT"
 field "daily rate, null where no cohort"   datasets.0.data '[75,50,100,null,100,null,null,100,100,null]' "$ACT"
 field "recent cohorts flagged incomplete"  incomplete_from 2026-07-04 "$ACT"
+field "cohorts counted through the rollup" covered_through 2026-07-10 "$ACT"
 field "…and the completed ones are not"    rows.2.complete true "$ACT"
 field "…while the last week is"            rows.8.complete false "$ACT"
 
@@ -217,6 +245,14 @@ field "…while the last week is"            rows.8.complete false "$ACT"
 ACT="$(get "/api/activation?window=1&$RANGE")"
 field "a 1-day window converts fewer" activated 9 "$ACT"
 
+# m11 (indexed 07-10) and m12 (indexed 07-09) arrived on 07-09. 07-11 onward has
+# not been rolled up, so those cohorts are gaps and stay out of the totals.
+ACT="$(get "/api/activation?from=2026-07-09&to=2026-07-12")"
+field "uncounted cohorts stay out of the totals" installs 2 "$ACT"
+field "…both counted ones converted"             activated 2 "$ACT"
+field "…and draw as gaps, not 0%"                datasets.0.data '[100,null,null,null]' "$ACT"
+field "…with no conversions claimed"             rows.2.activated null "$ACT"
+
 echo
 echo "/api/retention — day 0–14, denominator per day"
 RET="$(get "/api/retention?$RANGE")"
@@ -259,6 +295,32 @@ field "no bars"         labels '[]' "$EMPTY"
 EMPTY="$(get "/api/timeseries?metric=production_users&from=2025-01-01&to=2025-01-03")"
 field "still a dense axis" datasets.0.data '[0,0,0]' "$EMPTY"
 
+echo
+echo "A rollup that stops is called out"
+# One machine active yesterday that no rollup has covered — what a failed nightly
+# run (or a database refusing writes) leaves behind. Removed again straight after.
+STALE_ID=00000000-0000-4000-8000-0000000000ff
+npx wrangler d1 execute codegraph-telemetry --local \
+  --command "INSERT INTO machine_days (machine_id, day, prod) VALUES ('$STALE_ID', '$YESTERDAY', 1)" >/dev/null 2>&1
+META="$(get "/api/meta")"
+field "rollup behind once a day goes un-rolled" rollup_behind true "$META"
+field "…and yesterday's machine is counted"     machines_yesterday 1 "$META"
+npx wrangler d1 execute codegraph-telemetry --local \
+  --command "DELETE FROM machine_days WHERE machine_id = '$STALE_ID'" >/dev/null 2>&1
+
+echo
+echo "Usage counters alone are not a stalled ingest"
+# Usage lands in usage_daily, not events, so a day of tool calls with no install or
+# index run must not read as "not storing anything". Removed again straight after.
+npx wrangler d1 execute codegraph-telemetry --local \
+  --command "INSERT INTO usage_daily (day, machine_id, kind, name, count) VALUES ('$YESTERDAY', '$STALE_ID', 'mcp_tool', 'codegraph_explore', 3)" >/dev/null 2>&1
+META="$(get "/api/meta")"
+field "not stalled while usage arrives"           ingest_stalled    false        "$META"
+field "…the usage day is the last day stored"     latest_ingest_day "$YESTERDAY" "$META"
+field "…though the last lifecycle event is 07-10" latest_raw_day    2026-07-10   "$META"
+npx wrangler d1 execute codegraph-telemetry --local \
+  --command "DELETE FROM usage_daily WHERE machine_id = '$STALE_ID'" >/dev/null 2>&1
+
 echo
 printf '%d passed, %d failed\n' "$PASS" "$FAIL"
 [[ "$FAIL" -eq 0 ]]
diff --git a/telemetry-dashboard/scripts/smoke-auth.sh b/telemetry-dashboard/scripts/smoke-auth.sh
index 3fe357baec..73777cadb4 100755
--- a/telemetry-dashboard/scripts/smoke-auth.sh
+++ b/telemetry-dashboard/scripts/smoke-auth.sh
@@ -64,9 +64,10 @@ lacks() { # lacks <description> <needle> <haystack>
   fi
 }
 
-echo "Seeding local D1 from the ingest worker's migration…"
-npx wrangler d1 execute codegraph-telemetry --local \
-  --file=../telemetry-worker/migrations/0001_init.sql >/dev/null 2>&1
+echo "Seeding local D1 from the ingest worker's migrations…"
+for migration in ../telemetry-worker/migrations/*.sql; do
+  npx wrangler d1 execute codegraph-telemetry --local --file="$migration" >/dev/null 2>&1
+done
 
 echo "Starting wrangler dev on :${DASH_PORT}…"
 npx wrangler dev --port "$DASH_PORT" --ip 127.0.0.1 >"$LOG" 2>&1 &
diff --git a/telemetry-dashboard/src/api.ts b/telemetry-dashboard/src/api.ts
index 5b5fac3760..24deb33522 100644
--- a/telemetry-dashboard/src/api.ts
+++ b/telemetry-dashboard/src/api.ts
@@ -3,10 +3,14 @@
  * scoped by the same `?from=&to=` range the picker drives.
  *
  * Rules this file keeps:
- * - **Rollups first.** Every panel is answered from `daily_*` / `machine_days`,
- *   which are kept forever. Only the activation funnel touches raw `events`,
- *   because "did this machine ever run an index" is not a daily aggregate — and
- *   that is also the only endpoint with a horizon (the retention window).
+ * - **Rollups only.** Every panel is answered from `daily_*`, `machine_days` and
+ *   `machine_first_seen`, which are kept forever. No panel reads raw `events`:
+ *   D1 runs one query at a time per database, so one slow scan there fails every
+ *   panel queued behind it. (/api/meta reads the table's first and last day, and
+ *   `usage_daily`'s last, one indexed lookup each.)
+ * - **Today is in range; uncounted days are not zeros.** Rolled-up numbers stop
+ *   at the nightly rollup's last day and come back null after it, so a chart
+ *   ending today draws a gap where the count has not happened yet, not a cliff.
  * - **Parameterized, always.** No value from the query string is ever
  *   concatenated into SQL. Dimensions and metrics are looked up in the tables
  *   below and rejected with a 400 if they are not there, so even the column
@@ -88,9 +92,7 @@ export interface Range {
 
 /**
  * The range every endpoint shares. Absent params default to the last 30 days
- * ending today so a bare `curl /api/summary` still answers something sensible;
- * the dashboard itself always sends both, anchored on /api/meta's latest day so
- * no chart ends on a day the nightly rollup has not written yet.
+ * ending today, which is also what the dashboard's presets send.
  */
 function parseRange(url: URL): Range | ApiResult {
   const rawTo = url.searchParams.get('to');
@@ -212,43 +214,110 @@ interface MetaRow {
   earliest_active_day: string | null;
   earliest_raw_day: string | null;
   latest_raw_day: string | null;
+  latest_usage_day: string | null;
+  machines_yesterday: number | null;
 }
 
 /**
- * What the picker anchors on. The dashboard asks for this first and ends every
- * default range on `latest_day`, because the nightly cron has not rolled up
- * today yet — anchoring on the wall clock would put a phantom zero on the right
- * edge of every line chart.
+ * How fresh the data is, and whether either writer has stopped.
+ *
+ * The page's ranges end on today; this is what tells it how much of that range
+ * each kind of number actually covers. Machine counts (`machine_days`,
+ * `machine_first_seen`) are written by the ingest worker as events arrive, so they
+ * run through today. Everything rolled up by the nightly cron runs through
+ * `latest_rollup_day` — normally yesterday.
+ *
+ * Every lookup here is a single min() or max() per subquery, on purpose: SQLite only
+ * answers those from an index when the aggregate stands alone, and
+ * `SELECT min(day), max(day) FROM events` is a full scan of the biggest table.
+ *
+ * The two flags exist because both writers have failed silently before: from
+ * 2026-08-11 almost no event was stored and no rollup ran, nothing errored where
+ * anyone would see it, and the dashboard kept presenting Aug 9 as "the latest day"
+ * for seven weeks. Each flag is a fact the page states, not a tuned threshold.
  */
 async function meta(env: Env): Promise<ApiResult> {
+  const now = Date.now();
+  const today = utcDay(now);
+  const yesterday = utcDay(now - DAY_MS);
   const row = await env.DB.prepare(
     `SELECT (SELECT max(day) FROM daily_event_counts) AS latest_rollup_day,
             (SELECT min(day) FROM daily_event_counts) AS earliest_rollup_day,
             (SELECT max(day) FROM machine_days)       AS latest_active_day,
             (SELECT min(day) FROM machine_days)       AS earliest_active_day,
             (SELECT min(day) FROM events)             AS earliest_raw_day,
-            (SELECT max(day) FROM events)             AS latest_raw_day`,
-  ).first<MetaRow>();
+            (SELECT max(day) FROM events)             AS latest_raw_day,
+            (SELECT max(day) FROM usage_daily)        AS latest_usage_day,
+            (SELECT count(*) FROM machine_days WHERE day = ?) AS machines_yesterday`,
+  )
+    .bind(yesterday)
+    .first<MetaRow>();
+
+  const latestRollup = row?.latest_rollup_day ?? null;
+  const latestRaw = row?.latest_raw_day ?? null;
+  const latestUsage = row?.latest_usage_day ?? null;
+  const latestActive = row?.latest_active_day ?? null;
+  // Ingest stores lifecycle events in `events` and usage counters in `usage_daily`, so
+  // either one arriving means it is working — a day of usage and no installs or index
+  // runs is quiet, not stalled.
+  const latestIngest =
+    latestUsage !== null && (latestRaw === null || latestUsage > latestRaw) ? latestUsage : latestRaw;
+
+  // Stalled: nothing stored since before yesterday. (Client clocks may run a few
+  // minutes ahead, so the latest day can be tomorrow — that is fresh, not stale.) Usage
+  // counters get a day more, because a client uploads a day's counters only once that
+  // day is over: just after midnight UTC the newest one can be the day before yesterday.
+  const ingestStalled =
+    latestIngest !== null &&
+    (latestRaw === null || latestRaw < yesterday) &&
+    (latestUsage === null || latestUsage < addDays(today, -2));
+  // The 00:30 UTC run rolls up yesterday, so the day before that must always be in
+  // by now. Only "behind" if there was activity after the last rolled-up day — a day
+  // nobody used codegraph would be a silent rollup, not a missed one.
+  const rollupBehind =
+    latestActive !== null &&
+    (latestRollup === null || (latestRollup < addDays(today, -2) && latestActive > latestRollup));
 
-  const latest = row?.latest_rollup_day ?? row?.latest_active_day ?? null;
-  const earliest = row?.earliest_rollup_day ?? row?.earliest_active_day ?? null;
   return {
     body: {
-      latest_day: latest,
-      earliest_day: earliest,
-      latest_rollup_day: row?.latest_rollup_day ?? null,
-      latest_active_day: row?.latest_active_day ?? null,
-      /** Below this day the activation funnel is blind — raw events are purged. */
+      today,
+      /** The last day the nightly rollup covers. Kept under its old name for callers. */
+      latest_day: latestRollup ?? latestActive,
+      earliest_day: row?.earliest_rollup_day ?? row?.earliest_active_day ?? null,
+      latest_rollup_day: latestRollup,
+      latest_active_day: latestActive,
       earliest_raw_day: row?.earliest_raw_day ?? null,
-      latest_raw_day: row?.latest_raw_day ?? null,
+      /** The last day of a stored lifecycle event (install, index, uninstall). */
+      latest_raw_day: latestRaw,
+      /** The last day of a stored usage counter. */
+      latest_usage_day: latestUsage,
+      /** The later of the two: the last day ingest stored anything, which the stall banner names. */
+      latest_ingest_day: latestIngest,
+      machines_yesterday: row?.machines_yesterday ?? 0,
+      rollup_behind: rollupBehind,
+      ingest_stalled: ingestStalled,
       max_range_days: MAX_RANGE_DAYS,
       retention_days: RETENTION_DAYS,
-      generated_at: new Date().toISOString(),
+      generated_at: new Date(now).toISOString(),
     },
-    cacheControl: CACHE_CONTROL,
+    // Short: this is the staleness check, and it is one indexed lookup per field.
+    cacheControl: 'private, max-age=60',
   };
 }
 
+/**
+ * The last day the nightly rollup has written. Rolled-up series stop here and go
+ * null after it — "not counted yet", which a chart draws as a gap, rather than a zero
+ * it would draw as a cliff. `daily_event_counts` is keyed (day, event), so this is
+ * one step down its primary key.
+ */
+const COVERAGE_SQL = 'SELECT max(day) AS day FROM daily_event_counts';
+
+/** Like densify(), but days past `coveredThrough` are null: not counted yet, not zero. */
+function densifyCovered(labels: string[], byDay: Map<string, number>, coveredThrough: string | null): (number | null)[] {
+  return labels.map((day) => (coveredThrough === null || day > coveredThrough ? null : (byDay.get(day) ?? 0)));
+}
+
 // ---------------------------------------------------------------------------
 // /api/summary — the big numbers
 // ---------------------------------------------------------------------------
@@ -314,12 +383,19 @@ interface SeriesSpec {
   labels: [string] | [string, string];
   sql: string;
   binds: (range: Range) => (string | number)[];
+  /**
+   * Written by the ingest worker as events arrive rather than by the nightly
+   * rollup, so it runs through today instead of stopping at the rollup's last day.
+   */
+  live?: boolean;
 }
 
 /**
- * Every metric here reads a rollup table, so a line stays correct for days whose
- * raw events are long gone. Each query returns (day, a[, b]) and is densified
- * against the full day list, because a day with no rows means zero, not a gap.
+ * Every metric here reads a rollup table (or, if `live`, a table the ingest path
+ * keeps), so a line stays correct for days whose raw events are long gone. Each
+ * query returns (day, a[, b]) and is densified against the full day list, because
+ * a covered day with no rows means zero, not a gap. Days the rollup has not
+ * reached yet are the gap.
  */
 const SERIES: Record<string, SeriesSpec> = {
   installs_uninstalls: {
@@ -341,6 +417,7 @@ const SERIES: Record<string, SeriesSpec> = {
            WHERE first_day BETWEEN ? AND ?
            GROUP BY first_day`,
     binds: (r) => [r.from, r.to],
+    live: true,
   },
   production_users: {
     title: 'Daily production users',
@@ -379,9 +456,12 @@ async function timeseries(env: Env, url: URL, range: Range): Promise<ApiResult>
     return fail(`unknown metric — one of: ${[...Object.keys(SERIES), 'duration_buckets'].join(', ')}`);
   }
 
-  const { results } = await env.DB.prepare(spec.sql)
-    .bind(...spec.binds(range))
-    .all<DayValueRow>();
+  const batch = await env.DB.batch([
+    env.DB.prepare(spec.sql).bind(...spec.binds(range)),
+    env.DB.prepare(COVERAGE_SQL),
+  ]);
+  const results = rowsOf<DayValueRow>(batch[0]);
+  const coveredThrough = spec.live ? null : (firstOf<{ day: string | null }>(batch[1])?.day ?? null);
 
   const labels = dayList(range);
   const a = new Map<string, number>();
@@ -391,19 +471,23 @@ async function timeseries(env: Env, url: URL, range: Range): Promise<ApiResult>
     b.set(row.day, row.b ?? 0);
   }
 
-  const datasets = [{ label: spec.labels[0], data: densify(labels, a) }];
-  if (spec.labels.length === 2) datasets.push({ label: spec.labels[1], data: densify(labels, b) });
+  const fill = (byDay: Map<string, number>): (number | null)[] =>
+    spec.live ? densify(labels, byDay) : densifyCovered(labels, byDay, coveredThrough);
+  const datasets = [{ label: spec.labels[0], data: fill(a) }];
+  if (spec.labels.length === 2) datasets.push({ label: spec.labels[1], data: fill(b) });
 
   return {
     body: {
       range,
       metric,
       title: spec.title,
+      /** Last day with real numbers; null for a live series, which runs through today. */
+      covered_through: spec.live ? null : coveredThrough,
       labels,
       datasets,
       rows: labels.map((day, i) => ({
         day,
-        ...Object.fromEntries(datasets.map((d) => [d.label, d.data[i] ?? 0])),
+        ...Object.fromEntries(datasets.map((d) => [d.label, d.data[i] ?? null])),
       })),
     },
     cacheControl: CACHE_CONTROL,
@@ -412,14 +496,17 @@ async function timeseries(env: Env, url: URL, range: Range): Promise<ApiResult>
 
 /** "Session run length over time": one series per duration bucket, bucket-ordered. */
 async function durationBucketSeries(env: Env, range: Range): Promise<ApiResult> {
-  const { results } = await env.DB.prepare(
-    `SELECT day, value, sum(count) AS n
-       FROM daily_dim_counts
-      WHERE dim = 'duration_bucket' AND event = 'index' AND day BETWEEN ? AND ?
-      GROUP BY day, value`,
-  )
-    .bind(range.from, range.to)
-    .all<{ day: string; value: string; n: number }>();
+  const batch = await env.DB.batch([
+    env.DB.prepare(
+      `SELECT day, value, sum(count) AS n
+         FROM daily_dim_counts
+        WHERE dim = 'duration_bucket' AND event = 'index' AND day BETWEEN ? AND ?
+        GROUP BY day, value`,
+    ).bind(range.from, range.to),
+    env.DB.prepare(COVERAGE_SQL),
+  ]);
+  const results = rowsOf<{ day: string; value: string; n: number }>(batch[0]);
+  const coveredThrough = firstOf<{ day: string | null }>(batch[1])?.day ?? null;
 
   const labels = dayList(range);
   const perBucket = new Map<string, Map<string, number>>();
@@ -437,7 +524,7 @@ async function durationBucketSeries(env: Env, range: Range): Promise<ApiResult>
 
   const datasets = order.map((bucket) => ({
     label: bucket,
-    data: densify(labels, perBucket.get(bucket) ?? new Map()),
+    data: densifyCovered(labels, perBucket.get(bucket) ?? new Map(), coveredThrough),
   }));
 
   return {
@@ -445,11 +532,12 @@ async function durationBucketSeries(env: Env, range: Range): Promise<ApiResult>
       range,
       metric: 'duration_buckets',
       title: 'Indexing run length over time',
+      covered_through: coveredThrough,
       labels,
       datasets,
       rows: labels.map((day, i) => ({
         day,
-        ...Object.fromEntries(datasets.map((d) => [d.label, d.data[i] ?? 0])),
+        ...Object.fromEntries(datasets.map((d) => [d.label, d.data[i] ?? null])),
       })),
     },
     cacheControl: CACHE_CONTROL,
@@ -600,11 +688,18 @@ interface ActivationRow {
  * reinstalls does not re-enter the funnel, which is what makes this a
  * conversion rate rather than an install-event ratio.
  *
- * The LEFT JOIN rides events_machine_day (machine_id, day) and `count(DISTINCT)`
- * absorbs the fan-out from a machine that indexed many times. This is the one
- * endpoint that reads raw `events`, so it is bounded by the retention window —
- * `raw_events_from` tells the caller where the data actually starts, and the UI
- * says so rather than drawing a cliff and calling it a drop in conversion.
+ * "Ran an index" is `machine_first_seen.first_index_day`, the earliest day each
+ * machine indexed. The ingest worker lowers it as each index event is stored — so a
+ * run that uploads days late still counts — and the nightly rollup re-derives it from
+ * raw events. That makes this a range read over one small table. It used to be a
+ * join against raw `events` — on production volume ~55 s per week of cohorts, which
+ * held D1's single query lane long enough to fail every other panel waiting behind
+ * it. A first index day is never before the first day (the ingest path keeps
+ * first_day at the machine's earliest event), so "within the window" is just
+ * `first_index_day <= first_day + window`.
+ *
+ * Cohorts after the rollup's last day are left out of the totals and drawn as gaps,
+ * like every other rolled-up number on the page.
  */
 async function activation(env: Env, url: URL, range: Range): Promise<ApiResult> {
   const rawWindow = url.searchParams.get('window');
@@ -615,41 +710,40 @@ async function activation(env: Env, url: URL, range: Range): Promise<ApiResult>
 
   const batch = await env.DB.batch([
     env.DB.prepare(
-      `SELECT f.first_day AS day,
-              count(DISTINCT f.machine_id) AS installs,
-              count(DISTINCT CASE WHEN e.machine_id IS NOT NULL THEN f.machine_id END) AS activated
-         FROM machine_first_seen f
-         LEFT JOIN events e
-                ON e.machine_id = f.machine_id
-               AND e.event = 'index'
-               AND e.day >= f.first_day
-               AND e.day <= date(f.first_day, ?)
-        WHERE f.first_day BETWEEN ? AND ?
-        GROUP BY f.first_day`,
+      `SELECT first_day AS day,
+              count(*) AS installs,
+              count(CASE WHEN first_index_day <= date(first_day, ?) THEN 1 END) AS activated
+         FROM machine_first_seen
+        WHERE first_day BETWEEN ? AND ?
+        GROUP BY first_day`,
       // A bound modifier string, built from an integer this function validated —
       // date() takes the modifier as data, so nothing is concatenated into SQL.
     ).bind(`+${window} days`, range.from, range.to),
-    env.DB.prepare(`SELECT min(day) AS raw_from, max(day) AS raw_to FROM events`),
+    env.DB.prepare(COVERAGE_SQL),
   ]);
 
   const rows = rowsOf<ActivationRow>(batch[0]);
   const byDay = new Map(rows.map((r) => [r.day, r]));
   const labels = dayList(range);
 
-  const installs = rows.reduce((n, r) => n + (r.installs ?? 0), 0);
-  const activated = rows.reduce((n, r) => n + (r.activated ?? 0), 0);
-
   // Cohorts younger than the window have not finished converting yet, so their
   // rate is a floor, not a result. Marked rather than dropped: hiding the last
   // week of a conversion chart is its own kind of lie.
-  const boundsRow = firstOf<{ raw_from: string | null; raw_to: string | null }>(batch[1]);
-  const latestRaw = boundsRow?.raw_to ?? utcDay(Date.now());
-  const incompleteFrom = addDays(latestRaw, -(window - 1));
+  const coveredThrough = firstOf<{ day: string | null }>(batch[1])?.day ?? null;
+  const incompleteFrom = addDays(coveredThrough ?? utcDay(Date.now()), -(window - 1));
+  const counted = (day: string): boolean => coveredThrough !== null && day <= coveredThrough;
 
+  let installs = 0;
+  let activated = 0;
   const detail = labels.map((day) => {
     const row = byDay.get(day);
     const dayInstalls = row?.installs ?? 0;
+    if (!counted(day)) {
+      return { day, installs: dayInstalls, activated: null, rate: null, complete: false };
+    }
     const dayActivated = row?.activated ?? 0;
+    installs += dayInstalls;
+    activated += dayActivated;
     return {
       day,
       installs: dayInstalls,
@@ -669,8 +763,8 @@ async function activation(env: Env, url: URL, range: Range): Promise<ApiResult>
       rate: installs > 0 ? activated / installs : null,
       /** Cohorts from this day on have not had the full window to convert. */
       incomplete_from: incompleteFrom,
-      /** Raw events start here; a range reaching further back under-counts. */
-      raw_events_from: boundsRow?.raw_from ?? null,
+      /** The last cohort day in the totals: later cohorts have no conversions counted yet. */
+      covered_through: coveredThrough,
       labels,
       datasets: [
         {
diff --git a/telemetry-worker/README.md b/telemetry-worker/README.md
index 204074c914..077d0812f0 100644
--- a/telemetry-worker/README.md
+++ b/telemetry-worker/README.md
@@ -31,15 +31,19 @@ Telemetry is stored in the `codegraph-telemetry` D1 database on the same account
 events are written in a single `batch()` (one implicit transaction) under `ctx.waitUntil`,
 so the write is off the response path. It is deliberately **fail-silent**: a D1 error is
 logged to Workers Logs (counts only, never the payload) and the client still gets its `204`,
-because clients never retry — losing a datapoint beats losing availability. Alongside the
-raw rows, the worker upserts `machine_days` and `machine_first_seen`; when a batch is emptied
-by the allowlist, nothing at all is written, so those tables only ever describe stored events.
-
-The complete schema is [`migrations/0001_init.sql`](migrations/0001_init.sql) —
+because clients never retry — losing a datapoint beats losing availability. Lifecycle events
+(`install`, `index`, `uninstall`) are one `events` row each. `usage_rollup` counters are
+**added** into `usage_daily`, one row per machine × day × tool: clients upload a counter per
+process rather than per day, and storing a row per upload is what filled the database in
+August 2026. Alongside those, the worker upserts `machine_days` and `machine_first_seen`; when
+a batch is emptied by the allowlist, nothing at all is written, so those tables only ever
+describe stored events.
+
+The complete schema is [`migrations/`](migrations/) (applied in order) —
 checked in for the same reason this worker's source is public: it is the entire list of what
 gets kept, with a comment on every column and on which dashboard chart each rollup table
-serves. Shape: raw sanitized `events`, `daily_*` rollups recomputed nightly, and
-`machine_days` / `machine_first_seen` for retention cohorts. The dashboard reads rollups; raw
+serves. Shape: raw sanitized `events`, `usage_daily` counters, `daily_*` rollups recomputed
+nightly, and `machine_days` / `machine_first_seen` for retention cohorts. The dashboard reads rollups; raw
 events exist for drill-down and are purged past the retention window.
 
 ```bash
@@ -56,29 +60,55 @@ edit to a migration that has been applied.
 Volume, at ~97k accepted POSTs/day: ≈30M D1 row writes/month against the 50M included on
 Workers Paid, plus roughly as much again once the purge reaches steady state — a delete bills
 like an insert, and at steady state every row written is eventually deleted, so budget ≈48M.
-D1 bills a row write per index touched on top of the table row, which is why `events` carries
-only two indexes; dropping `events_machine_day` is the first lever if that gets tight. Storage
-is the other constraint, and it is what sets the window: raw events grow ≈74 MB/day, so 90 days
-lands at ≈6.7 GB against D1's 10 GB per-database cap, while 180 days would exceed it. Full
+D1 bills a row write per index touched on top of the table row, which is why `events` now
+carries one index (`events_machine_day` is dropped by `0004`, once the legacy usage rows are
+folded out — on the full table the drop runs past D1's per-query limit). Storage is the other
+constraint, and it is what sets the window: the estimate here was ≈74 MB/day of raw events
+(≈6.7 GB at 90 days against D1's 10 GB per-database cap), but it assumed one usage row per
+machine × day × tool. Clients actually sent one per process — ≈3.8M rows a day by early
+August — and the database hit the cap on 2026-08-11. `usage_daily` bounds that by
+construction; re-measure with `npx wrangler d1 info codegraph-telemetry` before widening the
+window. Full
 arithmetic and the remaining levers are in the migration's footer comment.
 
-## Rollups & retention (nightly cron)
+**A full database fails quietly.** D1 caps a database at 10 GB on Workers Paid (500 MB on
+Free), and upgrading cannot raise it. Once full, nearly every write fails with
+`D1_ERROR: Exceeded maximum DB size`: ingest stops storing events (the client never retries,
+so they are lost) and the nightly rollup stops too, while deletes and reads still work, so
+nothing looks broken from the outside. That ran from 2026-08-11 to October 2026.
+`npx wrangler d1 info codegraph-telemetry` shows the current size.
 
-`src/rollup.ts` runs on a Cron Trigger at **00:30 UTC** and does two things.
+## Rollups & retention (nightly cron)
 
-**Rolls up** the day that just ended into `daily_machines`, `daily_event_counts` and
-`daily_dim_counts`, then re-runs the two days before it — offline clients ship completed-day
-rollups late, so a day keeps growing after it ends. The aggregation is one
+`src/rollup.ts` runs on a Cron Trigger at **00:30 UTC** and does two things, the purge
+first.
+
+**Rolls up** the day that just ended into `daily_machines`, `daily_event_counts`,
+`daily_dim_counts` and `machine_first_seen.first_index_day`, then re-runs the two days before
+it — offline clients ship completed-day rollups late, so a day keeps growing after it ends.
+It then **catches up** on any earlier day that saw activity but never got a rollup (a
+`machine_days` day with no `daily_machines` row — a night the run failed or the database
+refused writes), newest first, up to 31 a night. An outage heals on the first good night
+instead of leaving a hole someone has to notice. Cloudflare ends a Cron Trigger after 15
+minutes of wall-clock time, and a day that still holds millions of legacy usage rows (below)
+takes minutes, so the run starts no new day and no new fold chunk once 10 minutes have
+passed (`NIGHTLY_BUDGET_MS`). A day it stops partway gets no rollup at all, so it is still a
+missed day the next night, which carries on from the last folded chunk; the summary line
+counts those days as `deferred`. The aggregation is one
 `INSERT … SELECT … ON CONFLICT DO UPDATE` per table or dimension, so it happens inside D1 and
 no event row crosses the wire. Every write overwrites the recomputed value rather than adding
 to it: **re-running a day is a no-op, never a double count.** Two things the SQL is careful
-about — a `usage_rollup` row is a counter the client pre-aggregated, so its `count` prop is
-summed rather than the rows counted; and `index.languages` / `install.targets` are unnested
-with `json_each`, one row per element. Adding a breakdown is a line in `ROLLUP_STATEMENTS`,
+about — usage figures are sums of `usage_daily.count` (calls), not row counts; and
+`index.languages` / `install.targets` are unnested with `json_each`, one row per element.
+Before rolling up a day it folds any legacy `usage_rollup` rows still in `events` (how usage
+was stored before `0003`) into `usage_daily`, 50k rows per transaction, so re-running the
+rollup over old days is the whole migration. Adding a breakdown is a line in `ROLLUP_STATEMENTS`,
 never a migration — that is what the generic `(dim, value)` shape buys.
 
-**Purges** raw `events` older than `RETENTION_DAYS` (90, a var in `wrangler.jsonc`) in bounded
-`DELETE` batches, and logs one line of counts. `machine_days` and `machine_first_seen` are
+**Purges** raw `events` and `usage_daily` rows older than `RETENTION_DAYS` (90, a var in
+`wrangler.jsonc`) in bounded `DELETE` batches, before any rollup: behind a long catch-up it
+would be the part the 15-minute limit cuts off, night after night, while the database
+grows. The run ends with one line of counts. `machine_days` and `machine_first_seen` are
 never purged — retention cohorts need the full history and they are two orders of magnitude
 smaller. Rollups are kept forever, so shortening the window costs ad-hoc drill-back, never a
 chart.
@@ -98,6 +128,40 @@ retention window, where it would delete rows and then find no events to rebuild
 the response says which days it refused. Keep manual ranges to a few days at production volume;
 each day is a full scan of that day's events, and the request has a wall-clock budget.
 
+### Backfilling first_index_day
+
+`first_index_day` (migration `0002`) is what the dashboard's activation funnel reads. The
+ingest worker lowers it as each index event is stored, so an index run that uploads days late
+still counts, and the rollup re-derives it from the raw events of every day it rolls up. Days
+rolled up before the migration left it NULL, an index event stored before the ingest worker
+began setting it (#2333) counts only once its day is rolled up again, and days stored before
+`0003` still hold their usage as one `events` row per upload. Re-running the rollup over every
+day that still has raw events fixes all three — it folds that day's legacy usage rows into
+`usage_daily`, sets `first_index_day`, and recomputes the day's rollups. It is idempotent, so
+overlapping or repeating a range is harmless. A day with millions of legacy rows takes several
+minutes, so go a day at a time:
+
+```bash
+# One day per call, from the earliest raw event (2026-07-04) through yesterday.
+for day in $(node -e 'for (let t = Date.parse("2026-07-04"); t < Date.now() - 864e5; t += 864e5)
+                        console.log(new Date(t).toISOString().slice(0, 10))'); do
+  curl -sS -X POST -H "x-admin-token: $ADMIN_TOKEN" \
+    "https://telemetry.getcodegraph.com/admin/rollup?day=$day"; echo
+done
+```
+
+Move the start to the earliest day `events` still holds (`/api/meta` on the dashboard
+reports it as `earliest_raw_day`). A machine whose index events were purged before the backfill stays NULL
+and counts as not activated — so run it before the retention window passes those days.
+
+### When the dashboard says ingest stalled or the rollup is behind
+
+Both banners mean a writer stopped. In order: `npx wrangler tail codegraph-telemetry` (look
+for `d1 write failed` / `rollup day failed` and the error text), then
+`npx wrangler d1 info codegraph-telemetry` against the plan's database cap (see Storage
+above). Once writes succeed again the next nightly run catches the rollup up on its own; the
+events that arrived while writes were failing are gone.
+
 ## Deploy
 
 Prereqs: the `getcodegraph.com` zone on the deploying Cloudflare account (the custom
@@ -247,6 +311,15 @@ To drive the cron body by hand, run `wrangler dev --test-scheduled` and hit
 `.dev.vars.example` to `.dev.vars` — without an `ADMIN_TOKEN` the route 404s, exactly as a
 deploy that never set the secret does.
 
+The repo's own test suite also covers this worker and the dashboard API without wrangler:
+it runs their source against these migrations in an in-memory SQLite database, including
+late uploads and a nightly run whose catch-up outlasts the cron's time limit. From the repo
+root (it is part of `npm test` there):
+
+```bash
+npx vitest run __tests__/telemetry-services.test.ts
+```
+
 ## Changing the schema
 
 The allowlist in `src/index.ts` mirrors `docs/design/telemetry.md` (and the user-facing
diff --git a/telemetry-worker/migrations/0002_first_index_day.sql b/telemetry-worker/migrations/0002_first_index_day.sql
new file mode 100644
index 0000000000..37b2910a1f
--- /dev/null
+++ b/telemetry-worker/migrations/0002_first_index_day.sql
@@ -0,0 +1,19 @@
+-- codegraph telemetry — the first day each machine ran an index.
+--
+-- Serves the install → first-index activation funnel. Until this column, the
+-- dashboard answered that funnel by joining every cohort machine against raw
+-- `events`, which on production volume took ~55 s for ONE week of cohorts — long
+-- enough to stall D1 (one query at a time per database) and fail every other
+-- panel queued behind it. With the first index day stored next to the first-seen
+-- day, the funnel is a range read over `machine_first_seen` alone.
+--
+-- It is also what lets the funnel outlive the raw-event retention purge, like
+-- every other panel: the nightly cron fills it from `events` while they exist.
+--
+-- Written by the nightly rollup (telemetry-worker/src/rollup.ts), never by the
+-- ingest path, and only ever lowered: NULL means "has not indexed (yet)".
+-- Existing rows start NULL — backfill them by re-running the rollup over the
+-- retained days (see "Backfilling first_index_day" in telemetry-worker/README.md).
+--
+-- ADD COLUMN with no default is a schema-only change in SQLite: no row is rewritten.
+ALTER TABLE machine_first_seen ADD COLUMN first_index_day TEXT;
diff --git a/telemetry-worker/migrations/0003_usage_daily.sql b/telemetry-worker/migrations/0003_usage_daily.sql
new file mode 100644
index 0000000000..3cfaa07357
--- /dev/null
+++ b/telemetry-worker/migrations/0003_usage_daily.sql
@@ -0,0 +1,35 @@
+-- codegraph telemetry — usage counters, one row per machine × day × tool.
+--
+-- `usage_rollup` events were stored one row per event in `events`. The client was
+-- meant to send one pre-aggregated counter per machine × day × tool, but it only
+-- aggregates within a single process: every short-lived codegraph process (each
+-- `serve` launch, CLI command or prompt hook) uploads its own `count: 1` line. By
+-- 2026-08-10 that was ~3.8M rows a day, 98% of the database, and the database hit
+-- D1's 10 GB cap — from 2026-08-11 nearly every write failed and was lost.
+--
+-- This table makes storage independent of how a client batches: the ingest worker
+-- ADDS each counter into the row for its key instead of inserting a new row, so a
+-- machine that uploads the same counter 80,000 times still owns one row. Same
+-- fields as the `usage_rollup` props plus the envelope the rollup breaks down by;
+-- nothing new is collected.
+--
+-- Every key column is NOT NULL with '' for "absent": a primary key treats NULLs as
+-- distinct, which would quietly turn the upsert back into an insert. The envelope
+-- columns are in the key so a machine that upgrades mid-day keeps exact per-version
+-- counts. Purged at the same retention window as `events`.
+CREATE TABLE usage_daily (
+  day               TEXT    NOT NULL,          -- UTC YYYY-MM-DD the counts belong to
+  machine_id        TEXT    NOT NULL,          -- random UUIDv4, client-minted
+  kind              TEXT    NOT NULL,          -- mcp_tool | cli_command
+  name              TEXT    NOT NULL,          -- tool or command name
+  client_name       TEXT    NOT NULL DEFAULT '',
+  client_version    TEXT    NOT NULL DEFAULT '',
+  codegraph_version TEXT    NOT NULL DEFAULT '',
+  os                TEXT    NOT NULL DEFAULT '',
+  arch              TEXT    NOT NULL DEFAULT '',
+  node_major        TEXT    NOT NULL DEFAULT '',
+  count             INTEGER NOT NULL DEFAULT 0,   -- calls
+  error_count       INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (day, machine_id, kind, name, client_name, client_version,
+               codegraph_version, os, arch, node_major)
+) WITHOUT ROWID;
diff --git a/telemetry-worker/migrations/0004_drop_events_machine_day.sql b/telemetry-worker/migrations/0004_drop_events_machine_day.sql
new file mode 100644
index 0000000000..3a637e8523
--- /dev/null
+++ b/telemetry-worker/migrations/0004_drop_events_machine_day.sql
@@ -0,0 +1,11 @@
+-- codegraph telemetry — drop the per-machine index on `events`.
+--
+-- Its only query reader was the dashboard's old activation join, which now reads
+-- machine_first_seen.first_index_day. Dropping it saves a row write per stored event,
+-- and it was the first storage lever the 0001 footer names.
+--
+-- A separate migration, applied AFTER the legacy usage rows are folded out of
+-- `events` (see "Backfilling first_index_day" in README.md): with ~30M rows in the
+-- table, dropping the index ran past D1's per-query time limit and was rolled back.
+-- On the folded table it is quick.
+DROP INDEX IF EXISTS events_machine_day;
diff --git a/telemetry-worker/scripts/backfill-rollup.sh b/telemetry-worker/scripts/backfill-rollup.sh
new file mode 100755
index 0000000000..4f9e24bfbe
--- /dev/null
+++ b/telemetry-worker/scripts/backfill-rollup.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Re-runs the nightly rollup over a range of days against the DEPLOYED ingest worker,
+# one day per request. Each day: legacy usage rows still in `events` are folded into
+# `usage_daily`, `first_index_day` is set, and the day's rollups are recomputed. All of
+# it is idempotent, so a range can be repeated or overlapped safely.
+#
+#   ./scripts/backfill-rollup.sh 2026-07-04 2026-10-02 [token-file]
+#
+# The admin token comes from the token file when one is given, else from $ADMIN_TOKEN.
+# Stops at the first day that does not answer 200, so a rerun can start from there.
+set -euo pipefail
+
+FROM=${1:?usage: backfill-rollup.sh FROM_DAY TO_DAY [TOKEN_FILE]}
+TO=${2:?usage: backfill-rollup.sh FROM_DAY TO_DAY [TOKEN_FILE]}
+if [ -n "${3:-}" ]; then ADMIN_TOKEN=$(tr -d '\n' < "$3"); fi
+: "${ADMIN_TOKEN:?set ADMIN_TOKEN or pass a token file}"
+BASE="${ROLLUP_BASE:-https://telemetry.getcodegraph.com}"
+
+days=$(node -e '
+const [from, to] = process.argv.slice(1);
+for (let t = Date.parse(`${from}T00:00:00Z`); t <= Date.parse(`${to}T00:00:00Z`); t += 864e5)
+  console.log(new Date(t).toISOString().slice(0, 10));' "$FROM" "$TO")
+
+for day in $days; do
+  started=$(date +%s)
+  # A day with millions of legacy rows takes minutes; never let one hang forever.
+  response=$(curl -sS --max-time 1800 -X POST -H "x-admin-token: $ADMIN_TOKEN" \
+    -w $'\n%{http_code}' "$BASE/admin/rollup?day=$day") || { echo "$day request failed"; exit 1; }
+  code=${response##*$'\n'}
+  body=${response%$'\n'*}
+  printf '%s %s %ss %s\n' "$day" "$code" "$(( $(date +%s) - started ))" "$body"
+  [ "$code" = 200 ] || { echo "stopping at $day"; exit 1; }
+done
diff --git a/telemetry-worker/scripts/smoke-cutover.sh b/telemetry-worker/scripts/smoke-cutover.sh
index 47aed75370..6d55f8c79a 100755
--- a/telemetry-worker/scripts/smoke-cutover.sh
+++ b/telemetry-worker/scripts/smoke-cutover.sh
@@ -233,11 +233,16 @@ ts "indexing activity"       indexing_activity   '[3]' '[3]'
 ts "tool calls (sums the prop)" tool_calls       '[20]' '[2]'
 
 MET=$(api "meta")
-is "meta anchors on the rolled-up day" "$DAY" "$(jget "$MET" latest_day)"
+is "meta reports the rolled-up day"     "$DAY" "$(jget "$MET" latest_day)"
 is "meta reports the rollup ran"       "$DAY" "$(jget "$MET" latest_rollup_day)"
+# Usage lands in usage_daily rather than events; the stalled-ingest check reads both.
+is "meta reports the last day ingest stored" "$DAY" "$(jget "$MET" latest_ingest_day)"
 
-# The funnel is the one panel that reads RAW events rather than a rollup, so it is
-# also the one the retention purge can blind — worth pinning that it works today.
+# The funnel reads machine_first_seen.first_index_day. The ingest worker sets it as
+# each index event is stored, and the nightly rollup re-derives it from raw `index`
+# events (smoke-rollup.sh pins that half, on events it seeds past the ingest path).
+# This is the seam: ingest writes the column, the dashboard reads it. If neither
+# writer set it, "activated" here would read 0.
 #
 # Its denominator is FIRST-SEEN MACHINES, not `install` events (api.ts: "a machine
 # that reinstalls does not re-enter the funnel"). m3 is the discriminator: it never
@@ -247,7 +252,7 @@ ACT=$(api "activation?$RANGE&window=1")
 is "funnel counts new machines, not install events" 3 "$(jget "$ACT" installs)"
 is "all three indexed within the window"            3 "$(jget "$ACT" activated)"
 is "nobody dropped out"                             0 "$(jget "$ACT" dropped)"
-is "raw-event floor is reported to the caller" "$DAY" "$(jget "$ACT" raw_events_from)"
+is "cohorts are counted through the rolled-up day" "$DAY" "$(jget "$ACT" covered_through)"
 
 is "retention endpoint answers" 200 \
    "$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" "$DASH/api/retention?$RANGE")"
diff --git a/telemetry-worker/scripts/smoke-ingest.sh b/telemetry-worker/scripts/smoke-ingest.sh
index f9dd4795be..9fd2b87fe4 100755
--- a/telemetry-worker/scripts/smoke-ingest.sh
+++ b/telemetry-worker/scripts/smoke-ingest.sh
@@ -37,6 +37,9 @@ q() {
 # ---------------------------------------------------------------------------
 # Boot
 # ---------------------------------------------------------------------------
+echo "applying migrations to local D1"
+npx wrangler d1 migrations apply "$DB" --local >/dev/null 2>&1
+
 echo "booting wrangler dev on :$PORT"
 npx wrangler dev --port "$PORT" >/tmp/cg-smoke-ingest.log 2>&1 &
 DEV_PID=$!
@@ -83,26 +86,31 @@ is "oversized body → 413" 413 "$(post "$BIG")"
 echo
 echo "ingest"
 
-M_OK=$(uuid); M_DROP=$(uuid); M_CI=$(uuid); M_BACK=$(uuid)
+M_OK=$(uuid); M_DROP=$(uuid); M_CI=$(uuid); M_BACK=$(uuid); M_USE=$(uuid)
 TODAY=$(date -u +%F)
+# Client timestamps older than 30 days are rejected at ingest, so the dated events
+# here are relative to today — fixed dates rot into "too old" a month after writing.
+day_ago() { node -e 'console.log(new Date(Date.now()-process.argv[1]*864e5).toISOString().slice(0,10))' "$1"; }
+RECENT_DAY=$(day_ago 2)
+BACK_DAY=$(day_ago 9)
 
 # Three valid events + one unknown event + unknown/malformed props that must be stripped.
 is "valid batch → 204" 204 "$(post "$(node -e '
-const [m] = process.argv.slice(1);
+const [m, day] = process.argv.slice(1);
 process.stdout.write(JSON.stringify({
   machine_id: m, codegraph_version: "1.5.0", os: "darwin", arch: "arm64",
   node_major: 22, ci: false, schema_version: 1, secret_field: "must not be stored",
   events: [
-    { event: "install", ts: "2026-07-27T10:00:00Z",
+    { event: "install", ts: `${day}T10:00:00Z`,
       props: { scope: "local", kind: "fresh", targets: ["claude", "cursor"], nope: "strip me" } },
-    { event: "index", ts: "2026-07-27T10:01:00Z",
+    { event: "index", ts: `${day}T10:01:00Z`,
       props: { languages: ["typescript"], file_count_bucket: "100-1k",
                duration_bucket: "bogus-bucket", repo_path: "/Users/someone/secret" } },
     { event: "usage_rollup",
       props: { kind: "mcp_tool", name: "codegraph_explore", count: 12, client_name: "Claude Code" } },
     { event: "not_an_event", props: { count: 1 } },
   ],
-}));' "$M_OK")")"
+}));' "$M_OK" "$RECENT_DAY")")"
 
 # Nothing survives the allowlist: unknown event + usage_rollup missing required props.
 is "all-dropped batch → 204" 204 "$(post "$(node -e '
@@ -113,6 +121,26 @@ process.stdout.write(JSON.stringify({ machine_id: m, os: "linux", events: [
   { event: "install", props: { scope: "local" } },
 ]}));' "$M_DROP")")"
 
+# Usage counters ADD into one row per machine × day × tool — what old clients send
+# is the same `count: 1` line once per process, many times over. Two batches: the
+# first repeats one counter three times (one of them an error) beside a second tool,
+# the second sends the first counter again.
+USAGE_A=$(node -e '
+const [m] = process.argv.slice(1);
+const explore = (errors) => ({ event: "usage_rollup",
+  props: { kind: "mcp_tool", name: "codegraph_explore", count: 1, error_count: errors, client_name: "Claude Code" } });
+process.stdout.write(JSON.stringify({ machine_id: m, os: "darwin", events: [
+  explore(0), explore(1), explore(0),
+  { event: "usage_rollup", props: { kind: "cli_command", name: "index", count: 2, error_count: 0 } },
+]}));' "$M_USE")
+USAGE_B=$(node -e '
+const [m] = process.argv.slice(1);
+process.stdout.write(JSON.stringify({ machine_id: m, os: "darwin", events: [
+  { event: "usage_rollup", props: { kind: "mcp_tool", name: "codegraph_explore", count: 1, error_count: 0, client_name: "Claude Code" } },
+]}));' "$M_USE")
+is "usage batch → 204" 204 "$(post "$USAGE_A")"
+is "the same counter again → 204" 204 "$(post "$USAGE_B")"
+
 # NOTE: build every body into a variable first. Escaped quotes nested inside
 # "$(post "…\"…\"…")" break out of the quoting context and get brace-expanded.
 index_batch() {  # <machine_id> [ci] [ts]
@@ -130,8 +158,8 @@ is "ci batch → 204" 204 "$(post "$CI_ON")"
 is "same machine, non-ci → 204" 204 "$(post "$CI_OFF")"
 
 # A late offline buffer arriving second must move first_day EARLIER, never later.
-RECENT=$(index_batch "$M_BACK" "" 2026-07-27T09:00:00Z)
-BACKDATED=$(index_batch "$M_BACK" "" 2026-07-20T09:00:00Z)
+RECENT=$(index_batch "$M_BACK" "" "${RECENT_DAY}T09:00:00Z")
+BACKDATED=$(index_batch "$M_BACK" "" "${BACK_DAY}T09:00:00Z")
 is "recent batch → 204" 204 "$(post "$RECENT")"
 is "backdated batch → 204" 204 "$(post "$BACKDATED")"
 
@@ -145,17 +173,22 @@ sleep 1          # and let miniflare release the local sqlite file
 echo
 echo "stored rows"
 
-is "3 of 4 events stored (unknown dropped)" 3 "$(q "select count(*) from events where machine_id='$M_OK'")"
+is "lifecycle events land in events (usage and the unknown event do not)" 2 \
+   "$(q "select count(*) from events where machine_id='$M_OK'")"
+is "the usage counter lands in usage_daily" "codegraph_explore|mcp_tool|12|0|Claude Code" \
+   "$(q "select name||'|'||kind||'|'||count||'|'||error_count||'|'||client_name from usage_daily where machine_id='$M_OK'")"
+is "…carrying the batch's envelope" "1.5.0|darwin|arm64|22" \
+   "$(q "select codegraph_version||'|'||os||'|'||arch||'|'||node_major from usage_daily where machine_id='$M_OK'")"
 is "all-dropped batch stored nothing" 0 "$(q "select count(*) from events where machine_id='$M_DROP'")"
 is "…and no machine_days row for it" 0 "$(q "select count(*) from machine_days where machine_id='$M_DROP'")"
 is "envelope columns land in their own columns" "darwin|arm64|22|0|1.5.0" \
    "$(q "select os||'|'||arch||'|'||node_major||'|'||ci||'|'||codegraph_version from events where machine_id='$M_OK' limit 1")"
-is "day derived from the client ts" "2026-07-27" \
+is "day derived from the client ts" "$RECENT_DAY" \
    "$(q "select day from events where machine_id='$M_OK' and event='install'")"
 is "day falls back to received_at when ts is absent" "$TODAY" \
-   "$(q "select day from events where machine_id='$M_OK' and event='usage_rollup'")"
+   "$(q "select day from usage_daily where machine_id='$M_OK'")"
 is "ts is NULL when the client sent none" 1 \
-   "$(q "select ts is null from events where machine_id='$M_OK' and event='usage_rollup'")"
+   "$(q "select ts is null from events where machine_id='$M_CI' limit 1")"
 is "allowlisted props stored" "local|fresh|2" \
    "$(q "select json_extract(props,'\$.scope')||'|'||json_extract(props,'\$.kind')||'|'||json_array_length(props,'\$.targets') from events where machine_id='$M_OK' and event='install'")"
 is "unknown prop stripped" 0 \
@@ -167,7 +200,7 @@ is "path-shaped prop stripped" 0 \
 is "unknown envelope field stored nowhere" 0 \
    "$(q "select count(*) from events where props like '%must not be stored%'")"
 
-# The valid batch mixes ts-dated events (2026-07-27) with an undated rollup (today),
+# The valid batch mixes ts-dated events ($RECENT_DAY) with an undated rollup (today),
 # so it legitimately spans two days and must produce a machine_days row for each.
 is "machine_days: one row per distinct day in the batch" 2 \
    "$(q "select count(*) from machine_days where machine_id='$M_OK'")"
@@ -175,12 +208,31 @@ is "machine_days: non-ci machine is production" 1 \
    "$(q "select min(prod) from machine_days where machine_id='$M_OK'")"
 is "machine_days: a later non-ci batch flips the day to production" 1 \
    "$(q "select prod from machine_days where machine_id='$M_CI'")"
-is "machine_days: each backdated batch gets its own day" "2026-07-20,2026-07-27" \
+is "machine_days: each backdated batch gets its own day" "$BACK_DAY,$RECENT_DAY" \
    "$(q "select group_concat(day) from (select day from machine_days where machine_id='$M_BACK' order by day)")"
 
-is "machine_first_seen recorded" "2026-07-27" "$(q "select first_day from machine_first_seen where machine_id='$M_OK'")"
-is "machine_first_seen only moves earlier" "2026-07-20" \
+is "machine_first_seen recorded" "$RECENT_DAY" "$(q "select first_day from machine_first_seen where machine_id='$M_OK'")"
+is "machine_first_seen only moves earlier" "$BACK_DAY" \
    "$(q "select first_day from machine_first_seen where machine_id='$M_BACK'")"
+# The activation funnel's input is kept here too, not only by the nightly rollup: an
+# index run that uploads after the cron stopped re-rolling its day must still count.
+is "first_index_day recorded as the index run is stored" "$RECENT_DAY" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='$M_OK'")"
+is "first_index_day only moves earlier, like first_day" "$BACK_DAY" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='$M_BACK'")"
+is "a machine that never sent an index run has none" "null" \
+   "$(q "select coalesce(first_index_day, 'null') from machine_first_seen where machine_id='$M_USE'")"
+
+echo
+echo "usage counters add up instead of piling up"
+is "no usage row ever lands in events" 0 "$(q "select count(*) from events where event='usage_rollup' and machine_id='$M_USE'")"
+is "one row per tool, however many uploads" 2 "$(q "select count(*) from usage_daily where machine_id='$M_USE'")"
+is "repeats within a batch and across batches are summed" "4/1" \
+   "$(q "select count||'/'||error_count from usage_daily where machine_id='$M_USE' and name='codegraph_explore'")"
+is "…and a different tool keeps its own count" "2/0" \
+   "$(q "select count||'/'||error_count from usage_daily where machine_id='$M_USE' and name='index'")"
+is "an absent client name is stored as empty, not NULL (it is part of the key)" "" \
+   "$(q "select client_name from usage_daily where machine_id='$M_USE' and name='index'")"
 
 echo
 echo "$pass passed, $fail failed"
diff --git a/telemetry-worker/scripts/smoke-rollup.sh b/telemetry-worker/scripts/smoke-rollup.sh
index c0bfbef0b5..2befab4eb8 100755
--- a/telemetry-worker/scripts/smoke-rollup.sh
+++ b/telemetry-worker/scripts/smoke-rollup.sh
@@ -15,6 +15,11 @@
 #     raw events are already purged
 #   * the purge deletes only rows past the window, and leaves machine_days /
 #     machine_first_seen alone
+#   * each machine's first_index_day is its earliest index, and survives the purge
+#   * the cron catches up on a day that saw activity but was never rolled up, and
+#     logs its one summary line
+#   * usage comes from usage_daily; a legacy usage row still in `events` is folded
+#     into it (counts added, row deleted) before the day is rolled up
 #   * /admin/rollup does not exist without ADMIN_TOKEN, and rejects a wrong one
 #
 # Re-runnable: it wipes its own synthetic days first, and they are chosen to sit
@@ -39,10 +44,13 @@ is()   { [ "$2" = "$3" ] && ok "$1" || bad "$1" "$2" "$3"; }
 day_ago() { node -e 'console.log(new Date(Date.now()-process.argv[1]*864e5).toISOString().slice(0,10))' "$1"; }
 
 # Synthetic days. MAIN/RESET sit inside the 90-day retention window but outside the
-# cron's 3-day lookback; OLD sits past the window so the purge takes it.
+# cron's 3-day lookback; OLD sits past the window so the purge takes it. MISSED is
+# never rolled up by hand — the cron has to find it on its own.
 DAY_MAIN=$(day_ago 40)
 DAY_RESET=$(day_ago 41)
+DAY_MISSED=$(day_ago 30)
 DAY_OLD=$(day_ago 200)
+DAY_ANCIENT=$(day_ago 199)   # a usage counter past the window, for the usage purge
 CUTOFF=$(day_ago 90)
 
 # First column of the first row of a query against the LOCAL D1 state.
@@ -91,18 +99,18 @@ shutdown() {
 echo "applying migrations to local D1"
 npx wrangler d1 migrations apply "$DB" --local >/dev/null 2>&1
 
-echo "seeding $DAY_MAIN / $DAY_RESET / $DAY_OLD"
+echo "seeding $DAY_MAIN / $DAY_RESET / $DAY_MISSED / $DAY_OLD"
 node -e '
-const [main, reset, old, seedFile] = process.argv.slice(1);
+const [main, reset, old, missed, ancient, seedFile] = process.argv.slice(1);
 const sq = (v) => `'"'"'${String(v).replace(/'"'"'/g, "'"'"''"'"'")}'"'"'`;
 const M = ["11111111-1111-4111-8111-111111111111", "22222222-2222-4222-8222-222222222222",
            "33333333-3333-4333-8333-333333333333", "44444444-4444-4444-8444-444444444444",
-           "99999999-9999-4999-8999-999999999999"];
+           "99999999-9999-4999-8999-999999999999", "55555555-5555-4555-8555-555555555555"];
 const out = [];
 
 // Re-runnable: every table this script touches, scoped to its own synthetic days.
-for (const t of ["events", "daily_event_counts", "daily_dim_counts", "daily_machines", "machine_days"]) {
-  out.push(`DELETE FROM ${t} WHERE day IN (${[main, reset, old].map(sq).join(", ")});`);
+for (const t of ["events", "daily_event_counts", "daily_dim_counts", "daily_machines", "machine_days", "usage_daily"]) {
+  out.push(`DELETE FROM ${t} WHERE day IN (${[main, reset, old, missed, ancient].map(sq).join(", ")});`);
 }
 out.push(`DELETE FROM machine_first_seen WHERE machine_id IN (${M.map(sq).join(", ")});`);
 
@@ -110,7 +118,6 @@ out.push(`DELETE FROM machine_first_seen WHERE machine_id IN (${M.map(sq).join("
 const rows = [
   [main, M[0], "install",      "darwin", "arm64", "1.5.0", 22, 0, {targets:["claude","cursor"], scope:"local", kind:"fresh"}],
   [main, M[0], "index",        "darwin", "arm64", "1.5.0", 22, 0, {languages:["typescript","go"], file_count_bucket:"100-1k", duration_bucket:"10-60s"}],
-  [main, M[0], "usage_rollup", "darwin", "arm64", "1.5.0", 22, 0, {kind:"mcp_tool", name:"codegraph_explore", count:10, error_count:2, client_name:"Claude Code"}],
   [main, M[1], "index",        "darwin", "x64",   "1.5.0", 20, 0, {languages:["typescript"], file_count_bucket:"1k-10k", duration_bucket:"10-60s"}],
   [main, M[1], "usage_rollup", "darwin", "x64",   "1.5.0", 20, 0, {kind:"mcp_tool", name:"codegraph_explore", count:5, error_count:0, client_name:"Cursor"}],
   [main, M[2], "install",      "linux",  "x64",   "1.4.1", 22, 1, {targets:["claude"], scope:"global", kind:"upgrade"}],
@@ -118,6 +125,8 @@ const rows = [
   [reset, M[3], "index",       "darwin", "arm64", "1.5.0", 22, 0, {languages:["python"], file_count_bucket:"<100", duration_bucket:"<10s"}],
   [old,  M[4], "install",      "linux",  "x64",   "1.0.0", 20, 0, {targets:["codex"], scope:"local", kind:"fresh"}],
   [old,  M[4], "index",        "linux",  "x64",   "1.0.0", 20, 0, {languages:["rust"], file_count_bucket:"<100", duration_bucket:"<10s"}],
+  [missed, M[5], "install",    "win32",  "x64",   "1.5.0", 22, 0, {targets:["claude"], scope:"local", kind:"fresh"}],
+  [missed, M[5], "index",      "win32",  "x64",   "1.5.0", 22, 0, {languages:["go"], file_count_bucket:"<100", duration_bucket:"<10s"}],
 ];
 for (const [day, m, event, os, arch, version, node, ci, props] of rows) {
   out.push(`INSERT INTO events (received_at, ts, day, event, machine_id, codegraph_version, os, arch, node_major, ci, schema_version, props)
@@ -125,8 +134,19 @@ for (const [day, m, event, os, arch, version, node, ci, props] of rows) {
             ${sq(version)}, ${sq(os)}, ${sq(arch)}, ${node}, ${ci}, 1, ${sq(JSON.stringify(props))});`);
 }
 
+// Usage for M[0] arrives the way the ingest path writes it now: added into usage_daily.
+// Usage for M[1] (in the rows above) is a LEGACY row in `events`, as stored before
+// migrations/0003 — the rollup has to fold it in before counting.
+out.push(`INSERT INTO usage_daily (day, machine_id, kind, name, client_name, client_version,
+            codegraph_version, os, arch, node_major, count, error_count)
+          VALUES (${[main, M[0], "mcp_tool", "codegraph_explore", "Claude Code", "",
+                     "1.5.0", "darwin", "arm64", "22"].map(sq).join(", ")}, 10, 2);`);
+// A usage counter past the retention window: the purge must take it.
+out.push(`INSERT INTO usage_daily (day, machine_id, kind, name, count, error_count)
+          VALUES (${[ancient, M[4], "cli_command", "index"].map(sq).join(", ")}, 3, 0);`);
+
 // What the ingest path would have written alongside those events.
-for (const [m, day, prod] of [[M[0], main, 1], [M[1], main, 1], [M[2], main, 0], [M[3], reset, 1], [M[4], old, 1]]) {
+for (const [m, day, prod] of [[M[0], main, 1], [M[1], main, 1], [M[2], main, 0], [M[3], reset, 1], [M[4], old, 1], [M[5], missed, 1]]) {
   out.push(`INSERT INTO machine_days (machine_id, day, prod) VALUES (${sq(m)}, ${sq(day)}, ${prod});`);
   out.push(`INSERT INTO machine_first_seen (machine_id, first_day) VALUES (${sq(m)}, ${sq(day)})
               ON CONFLICT (machine_id) DO UPDATE SET first_day = min(machine_first_seen.first_day, excluded.first_day);`);
@@ -137,7 +157,7 @@ out.push(`INSERT INTO daily_dim_counts (day, event, dim, value, count, machines)
             VALUES (${sq(reset)}, ${sq("index")}, ${sq("obsolete_dim")}, ${sq("stale")}, 99, 99);`);
 
 require("fs").writeFileSync(seedFile, out.join("\n"));
-' "$DAY_MAIN" "$DAY_RESET" "$DAY_OLD" "$SEED_SQL"
+' "$DAY_MAIN" "$DAY_RESET" "$DAY_OLD" "$DAY_MISSED" "$DAY_ANCIENT" "$SEED_SQL"
 npx wrangler d1 execute "$DB" --local --file "$SEED_SQL" >/dev/null
 
 # ---------------------------------------------------------------------------
@@ -173,9 +193,16 @@ is "rollup $DAY_MAIN again → 200" 200 "$(roll "day=$DAY_MAIN")"
 is "rollup $DAY_OLD, whose events are still there → 200" 200 "$(roll "day=$DAY_OLD")"
 is "rollup $DAY_RESET with reset → 200" 200 "$(roll "day=$DAY_RESET&reset=1")"
 
-# The cron body: rolls up the last three days and purges everything past the window.
+# The cron body: rolls up the last three days, catches up $DAY_MISSED (active, never
+# rolled up), and purges everything past the window.
 is "cron trigger → 200" 200 "$(curl -s -o /dev/null -w '%{http_code}' "$BASE/__scheduled?cron=30+0+*+*+*")"
 sleep 2
+# Its one summary line: written once the purge and every rollup are done, and with
+# nothing this small left for the next night by the time budget.
+is "the cron logs its summary, nothing failed or deferred" "0/0" \
+   "$(grep -ao '{"msg":"nightly rollup".*}' "$LOG" | tail -1 |
+      node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{
+        const r=JSON.parse(s||"{}");console.log(`${r.failed}/${r.deferred}`);})')"
 
 # Rolling a purged day with reset=1 must NOT blank the rollups it already has: past
 # the window the reset is ignored, so the delete-then-rebuild can't find zero events.
@@ -184,6 +211,12 @@ is "…and reports the reset it refused to run" "[\"$DAY_OLD\"]" \
    "$(curl -s -X POST -H "x-admin-token: $TOKEN" "$BASE/admin/rollup?day=$DAY_OLD&reset=1" |
       node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>console.log(JSON.stringify(JSON.parse(s).reset_ignored)))')"
 
+# first_index_day only ever moves earlier. Give M[1] an index day before $DAY_MAIN,
+# then re-roll $DAY_MAIN (where it indexed again): the earlier day must stand.
+q "update machine_first_seen set first_index_day='$DAY_RESET'
+     where machine_id='22222222-2222-4222-8222-222222222222'" >/dev/null
+is "re-roll $DAY_MAIN over an earlier first index day → 200" 200 "$(roll "day=$DAY_MAIN")"
+
 shutdown
 
 # ---------------------------------------------------------------------------
@@ -239,10 +272,19 @@ echo "cross-check against the raw events"
 is "machines matches count(distinct machine_id)" \
    "$(q "select count(distinct machine_id) from events where day='$DAY_MAIN' and event='index'")" \
    "$(q "select machines from daily_event_counts where day='$DAY_MAIN' and event='index'")"
-is "usage count matches sum(props.count)" \
-   "$(q "select sum(json_extract(props,'\$.count')) from events where day='$DAY_MAIN' and event='usage_rollup'")" \
+is "usage count matches sum(usage_daily.count)" \
+   "$(q "select sum(count) from usage_daily where day='$DAY_MAIN'")" \
    "$(q "select count from daily_event_counts where day='$DAY_MAIN' and event='usage_rollup'")"
 
+echo
+echo "legacy usage rows"
+is "folded out of events" 0 "$(q "select count(*) from events where day='$DAY_MAIN' and event='usage_rollup'")"
+is "…into usage_daily, counts and client intact" "5|0|Cursor|darwin|x64|20" \
+   "$(q "select count||'|'||error_count||'|'||client_name||'|'||os||'|'||arch||'|'||node_major from usage_daily
+          where day='$DAY_MAIN' and machine_id='22222222-2222-4222-8222-222222222222'")"
+is "…and re-rolling the day adds nothing (no double count)" 15 \
+   "$(q "select sum(count) from usage_daily where day='$DAY_MAIN'")"
+
 echo
 echo "reset"
 is "?reset=1 drops a rollup row whose dimension no longer exists" 0 \
@@ -255,12 +297,38 @@ echo
 echo "retention purge"
 is "raw events past the window are gone" 0 "$(q "select count(*) from events where day='$DAY_OLD'")"
 is "nothing older than the cutoff survives" 0 "$(q "select count(*) from events where day<'$CUTOFF'")"
-is "events inside the window are untouched" 7 "$(q "select count(*) from events where day='$DAY_MAIN'")"
+# 6 seeded, minus the legacy usage row the rollup folded into usage_daily.
+is "events inside the window are untouched" 5 "$(q "select count(*) from events where day='$DAY_MAIN'")"
+is "usage counters past the window are purged" 0 "$(q "select count(*) from usage_daily where day='$DAY_ANCIENT'")"
+is "…and inside it they stay" 2 "$(q "select count(*) from usage_daily where day='$DAY_MAIN'")"
 is "machine_days is NOT purged (retention cohorts need it)" 1 \
    "$(q "select count(*) from machine_days where day='$DAY_OLD'")"
 is "machine_first_seen is NOT purged" "$DAY_OLD" \
    "$(q "select first_day from machine_first_seen where machine_id='99999999-9999-4999-8999-999999999999'")"
 
+echo
+echo "first_index_day — the activation funnel's input"
+is "machines that indexed get that day" "$DAY_MAIN" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='11111111-1111-4111-8111-111111111111'")"
+is "a machine that never indexed stays NULL" "null" \
+   "$(q "select coalesce(first_index_day, 'null') from machine_first_seen where machine_id='33333333-3333-4333-8333-333333333333'")"
+is "set on a reset run too" "$DAY_RESET" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='44444444-4444-4444-8444-444444444444'")"
+is "outlives the purge of the events it came from" "$DAY_OLD" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='99999999-9999-4999-8999-999999999999'")"
+is "only ever lowered: re-rolling a later index day leaves an earlier one" "$DAY_RESET" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='22222222-2222-4222-8222-222222222222'")"
+
+echo
+echo "the cron catches up on a day nobody rolled up"
+is "$DAY_MISSED got its daily_machines row" "1/1" \
+   "$(q "select machines||'/'||prod_machines from daily_machines where day='$DAY_MISSED'")"
+is "…and its event counts" "1/1" \
+   "$(q "select count||'/'||machines from daily_event_counts where day='$DAY_MISSED' and event='index'")"
+is "…and its breakdowns" "1/1" "$(dim "$DAY_MISSED" index language go)"
+is "…and its first index day" "$DAY_MISSED" \
+   "$(q "select first_index_day from machine_first_seen where machine_id='55555555-5555-4555-8555-555555555555'")"
+
 echo
 echo "rollups outlive the events they came from"
 is "daily_event_counts survives the purge" "1/1" \
diff --git a/telemetry-worker/src/index.ts b/telemetry-worker/src/index.ts
index 801d9a783e..3c4ac7cde3 100644
--- a/telemetry-worker/src/index.ts
+++ b/telemetry-worker/src/index.ts
@@ -4,7 +4,7 @@
  * This file is public on purpose: it is the exact code that receives codegraph's
  * anonymous usage telemetry, so anyone can audit what is (and is not) stored.
  * The schema contract lives in docs/design/telemetry.md; the storage schema — the
- * complete list of what is kept — is migrations/0001_init.sql.
+ * complete list of what is kept — is migrations/.
  *
  * Guarantees enforced here:
  * - strict allowlist: unknown events are dropped, unknown properties are stripped
@@ -39,7 +39,7 @@ sent; the client IP is never read or stored; the machine ID is a random UUID the
 client mints locally and can delete at any time. Accepted events are stored in our
 own database on Cloudflare (D1) and are never forwarded to any third-party analytics
 vendor. The stored schema is the complete list of what is kept:
-https://github.com/colbymchenry/codegraph/blob/main/telemetry-worker/migrations/0001_init.sql
+https://github.com/colbymchenry/codegraph/tree/main/telemetry-worker/migrations
 
 Individual events are deleted after ${keepDays} days. What outlives them: anonymous
 daily totals (counts per day of things like operating system, version and language),
@@ -200,14 +200,67 @@ const INSERT_EVENT = `INSERT INTO events (
 const UPSERT_MACHINE_DAY = `INSERT INTO machine_days (machine_id, day, prod) VALUES (?, ?, ?)
   ON CONFLICT (machine_id, day) DO UPDATE SET prod = max(machine_days.prod, excluded.prod)`;
 
-// A late-arriving offline buffer can move a machine's first day earlier, never later.
-const UPSERT_FIRST_SEEN = `INSERT INTO machine_first_seen (machine_id, first_day) VALUES (?, ?)
-  ON CONFLICT (machine_id) DO UPDATE SET first_day = min(machine_first_seen.first_day, excluded.first_day)`;
+// A late-arriving offline buffer can move a machine's first day earlier, never later —
+// and its first index day (the activation funnel's input) the same way. That one is set
+// here as well as by the nightly rollup because the rollup only re-rolls the last three
+// days, while this path accepts events up to 30 days old: an index run that uploads a
+// week late would otherwise never count. SQLite's multi-argument min() is NULL when
+// either side is, hence the coalesce: a batch with no index run leaves the stored day
+// alone, and the first index run on record sets it.
+const UPSERT_FIRST_SEEN = `INSERT INTO machine_first_seen (machine_id, first_day, first_index_day) VALUES (?, ?, ?)
+  ON CONFLICT (machine_id) DO UPDATE SET
+    first_day = min(machine_first_seen.first_day, excluded.first_day),
+    first_index_day = coalesce(min(machine_first_seen.first_index_day, excluded.first_index_day),
+                               machine_first_seen.first_index_day, excluded.first_index_day)`;
+
+// usage_rollup counters ADD into one row per machine × day × tool (migrations/0003):
+// clients upload the same counter many times over — once per process — so storing
+// a row per upload grew without bound.
+const UPSERT_USAGE = `INSERT INTO usage_daily (
+  day, machine_id, kind, name, client_name, client_version,
+  codegraph_version, os, arch, node_major, count, error_count
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT (day, machine_id, kind, name, client_name, client_version, codegraph_version, os, arch, node_major)
+  DO UPDATE SET count = usage_daily.count + excluded.count,
+                error_count = usage_daily.error_count + excluded.error_count`;
+
+interface UsageCounter {
+  day: string;
+  kind: string;
+  name: string;
+  clientName: string;
+  clientVersion: string;
+  count: number;
+  errors: number;
+}
 
 /**
- * Persist a sanitized batch: one `events` row per event, plus the machine×day and
- * first-seen bookkeeping the dashboard's retention/activation panels need. One D1
- * `batch()` = one implicit transaction = one round trip.
+ * Folds a batch's usage_rollup events into one counter per day × tool × client.
+ * Old clients send up to 100 copies of the same `count: 1` line per request; this
+ * turns them into one upsert instead of a hundred.
+ */
+function foldUsage(events: StoredEvent[], receivedAt: string): UsageCounter[] {
+  const byKey = new Map<string, UsageCounter>();
+  for (const e of events) {
+    const day = (e.ts ?? receivedAt).slice(0, 10);
+    const kind = String(e.props.kind);
+    const name = String(e.props.name);
+    const clientName = typeof e.props.client_name === 'string' ? e.props.client_name : '';
+    const clientVersion = typeof e.props.client_version === 'string' ? e.props.client_version : '';
+    const key = [day, kind, name, clientName, clientVersion].join('\u0000');
+    const counter = byKey.get(key) ?? { day, kind, name, clientName, clientVersion, count: 0, errors: 0 };
+    counter.count += typeof e.props.count === 'number' ? e.props.count : 0;
+    counter.errors += typeof e.props.error_count === 'number' ? e.props.error_count : 0;
+    byKey.set(key, counter);
+  }
+  return [...byKey.values()];
+}
+
+/**
+ * Persist a sanitized batch: one `events` row per lifecycle event, usage counters
+ * added into `usage_daily`, plus the machine×day and first-seen bookkeeping the
+ * dashboard's retention/activation panels need. One D1 `batch()` = one implicit
+ * transaction = one round trip.
  *
  * Fail-silent by design: the client treats every response as final and never retries,
  * so a failed write loses a datapoint rather than costing availability. The error is
@@ -236,9 +289,38 @@ async function writeToD1(
     // machine_days gets one row per distinct day rather than one per batch.
     const days = new Set<string>();
 
+    const usage = batch.filter((e) => e.event === 'usage_rollup');
+    if (usage.length > 0) {
+      const upsertUsage = env.DB.prepare(UPSERT_USAGE);
+      const [version, os, arch, nodeMajor] = envelopeCols;
+      for (const u of foldUsage(usage, receivedAt)) {
+        days.add(u.day);
+        stmts.push(
+          upsertUsage.bind(
+            u.day,
+            machineId,
+            u.kind,
+            u.name,
+            u.clientName,
+            u.clientVersion,
+            version ?? '',
+            os ?? '',
+            arch ?? '',
+            nodeMajor === null ? '' : String(nodeMajor),
+            u.count,
+            u.errors,
+          ),
+        );
+      }
+    }
+
+    // The earliest day this batch indexed on, if it did — see UPSERT_FIRST_SEEN.
+    let firstIndexDay: string | null = null;
     for (const e of batch) {
+      if (e.event === 'usage_rollup') continue;
       const day = (e.ts ?? receivedAt).slice(0, 10);
       days.add(day);
+      if (e.event === 'index' && (firstIndexDay === null || day < firstIndexDay)) firstIndexDay = day;
       stmts.push(
         insertEvent.bind(
           receivedAt,
@@ -258,7 +340,7 @@ async function writeToD1(
 
     const firstDay = [...days].sort()[0];
     if (firstDay !== undefined) {
-      stmts.push(env.DB.prepare(UPSERT_FIRST_SEEN).bind(machineId, firstDay));
+      stmts.push(env.DB.prepare(UPSERT_FIRST_SEEN).bind(machineId, firstDay, firstIndexDay));
     }
 
     await env.DB.batch(stmts);
diff --git a/telemetry-worker/src/rollup.ts b/telemetry-worker/src/rollup.ts
index abd1671c98..9502210984 100644
--- a/telemetry-worker/src/rollup.ts
+++ b/telemetry-worker/src/rollup.ts
@@ -6,13 +6,16 @@
  *
  * Two jobs, both driven by the cron trigger in wrangler.jsonc (00:30 UTC daily):
  *
- * 1. ROLL UP the just-completed UTC day into `daily_machines`, `daily_event_counts`
- *    and `daily_dim_counts` — plus the two days before it, because clients buffer
- *    offline and ship completed-day rollups late, so a day keeps growing after it
- *    ends. Every write is an upsert that OVERWRITES the recomputed value rather than
- *    adding to it, so re-running a day is a no-op and never double-counts.
+ * 1. ROLL UP the just-completed UTC day into `daily_machines`, `daily_event_counts`,
+ *    `daily_dim_counts` and `machine_first_seen.first_index_day` — plus the two days
+ *    before it, because clients buffer offline and ship completed-day rollups late, so
+ *    a day keeps growing after it ends, plus any earlier day a failed run missed, as
+ *    many as fit in the run's time budget. Every write is an upsert that OVERWRITES
+ *    the recomputed value rather than adding to it (or, for first_index_day, only ever
+ *    lowers it), so re-running a day is a no-op and never double-counts.
  *
- * 2. PURGE raw `events` past the retention window, in bounded batches. Rollups are
+ * 2. PURGE raw `events` past the retention window, in bounded batches — first, so a
+ *    long catch-up can never push it past the cron's wall-clock limit. Rollups are
  *    kept forever, so only ad-hoc drill-down has a horizon; `machine_days` and
  *    `machine_first_seen` are never purged, because retention cohorts need the full
  *    history and they are two orders of magnitude smaller than the raw rows.
@@ -28,6 +31,17 @@ export const DEFAULT_RETENTION_DAYS = 90;
 export const ROLLUP_LOOKBACK_DAYS = 3;
 /** Widest range one manual /admin/rollup call will attempt. */
 export const MAX_MANUAL_DAYS = 31;
+/** Most missed days one nightly run catches up on, newest first; the next night takes the rest. */
+export const MAX_CATCHUP_DAYS = 31;
+/**
+ * How long into a nightly run it still starts rollup work. Cloudflare ends a Cron
+ * Trigger after 15 minutes of wall-clock time, and catching up a day that still holds
+ * millions of legacy usage rows takes minutes, so a backlog can run straight into that
+ * limit. Past this point the run starts no new day and no new fold chunk; the 5
+ * minutes left cover the one statement already in flight and the summary line. What
+ * did not fit stays a missed day, so the next night carries on from there.
+ */
+export const NIGHTLY_BUDGET_MS = 10 * 60_000;
 
 /** Rows per purge DELETE — bounded so one statement stays well inside D1's limits. */
 const PURGE_BATCH_ROWS = 5_000;
@@ -66,18 +80,17 @@ export function retentionCutoff(atMs: number, keepDays: number): string {
 // aggregation happens inside D1, so a day rolls up in one round trip and no event
 // row ever crosses the wire. Each takes exactly one bound parameter — the day.
 //
+// Lifecycle events (install / index / uninstall) are one `events` row each, so their
+// volume is count(*). Usage is NOT in `events`: the ingest worker adds every
+// usage_rollup counter into `usage_daily` (one row per machine × day × tool), so the
+// usage figures are sums over that table — its `count` is calls, and counting its
+// rows would report "machines that used the tool" instead.
+//
 // Adding a breakdown is a line in ROLLUP_STATEMENTS, never a migration — that is
 // what the generic (dim, value) shape of daily_dim_counts buys.
 
-/**
- * A group's event volume. For install/index/uninstall one row is one event, but a
- * usage_rollup row is a counter the client pre-aggregated (one per machine × day ×
- * tool), so its `count` prop is what has to be summed — counting rows there would
- * silently report "machines that used the tool" and undercount by an order of magnitude.
- */
-const COUNT = `CASE WHEN e.event = 'usage_rollup'
-           THEN sum(coalesce(json_extract(e.props, '$.count'), 0))
-           ELSE count(*) END`;
+/** Lifecycle events only; usage comes from `usage_daily`. */
+const LIFECYCLE = ` AND e.event <> 'usage_rollup'`;
 
 const DIM_CONFLICT = `ON CONFLICT (day, event, dim, value) DO UPDATE
      SET count = excluded.count, machines = excluded.machines`;
@@ -87,15 +100,29 @@ const quoted = (values: readonly string[]): string => values.map((v) => `'${v}'`
 const onlyEvents = (...events: readonly string[]): string => ` AND e.event IN (${quoted(events)})`;
 
 /** One dimension whose value is a scalar column or a scalar prop. */
-function dimStatement(dim: string, value: string, where = ''): string {
+function dimStatement(dim: string, value: string, where = LIFECYCLE): string {
   return `INSERT INTO daily_dim_counts (day, event, dim, value, count, machines)
-   SELECT e.day, e.event, '${dim}', CAST(${value} AS TEXT), ${COUNT}, count(DISTINCT e.machine_id)
+   SELECT e.day, e.event, '${dim}', CAST(${value} AS TEXT), count(*), count(DISTINCT e.machine_id)
      FROM events e
     WHERE e.day = ? AND ${value} IS NOT NULL AND ${value} <> ''${where}
     GROUP BY e.day, e.event, ${value}
    ${DIM_CONFLICT}`;
 }
 
+/**
+ * One usage dimension, from a `usage_daily` column. Absent values are stored as ''
+ * (they are part of the primary key), so '' is what gets skipped. `where` narrows
+ * the rows further — name_error keeps only counters that saw an error.
+ */
+function usageDimStatement(dim: string, column: string, total = 'count', where = ''): string {
+  return `INSERT INTO daily_dim_counts (day, event, dim, value, count, machines)
+   SELECT day, 'usage_rollup', '${dim}', ${column}, sum(${total}), count(DISTINCT machine_id)
+     FROM usage_daily
+    WHERE day = ? AND ${column} <> ''${where}
+    GROUP BY day, ${column}
+   ${DIM_CONFLICT}`;
+}
+
 /**
  * One dimension unnested from a JSON array prop — one row per element, so an index
  * of a TypeScript+Go repo counts once under each language. `json_each` over a path
@@ -125,22 +152,52 @@ const DAILY_MACHINES = `INSERT INTO daily_machines (day, machines, prod_machines
    ON CONFLICT (day) DO UPDATE
      SET machines = excluded.machines, prod_machines = excluded.prod_machines`;
 
+/**
+ * The activation funnel's input: each machine's first index day, lowered to this day
+ * if the machine indexed on it and has no earlier index on record. The dashboard reads
+ * it straight off `machine_first_seen`, which keeps the funnel off raw `events` (a
+ * cohort join there took most of a minute per week of cohorts) and past the purge.
+ *
+ * The ingest path lowers it the same way as each index event is stored (src/index.ts),
+ * because a run that uploads late lands on a day this cron has stopped re-rolling. This
+ * statement is what fills it for events stored before that, and what a backfill re-runs.
+ *
+ * Only rows that actually move are written, so re-running a day is free. `?1` is the
+ * day — still the one bound parameter, used three times.
+ */
+const FIRST_INDEX_DAY = `UPDATE machine_first_seen
+   SET first_index_day = ?1
+ WHERE (first_index_day IS NULL OR first_index_day > ?1)
+   AND machine_id IN (SELECT machine_id FROM events WHERE day = ?1 AND event = 'index')`;
+
 const ROLLUP_STATEMENTS: readonly string[] = [
   DAILY_MACHINES,
+  FIRST_INDEX_DAY,
 
   `INSERT INTO daily_event_counts (day, event, count, machines)
-   SELECT e.day, e.event, ${COUNT}, count(DISTINCT e.machine_id)
+   SELECT e.day, e.event, count(*), count(DISTINCT e.machine_id)
      FROM events e
-    WHERE e.day = ?
+    WHERE e.day = ?${LIFECYCLE}
     GROUP BY e.day, e.event
    ON CONFLICT (day, event) DO UPDATE
      SET count = excluded.count, machines = excluded.machines`,
+  `INSERT INTO daily_event_counts (day, event, count, machines)
+   SELECT day, 'usage_rollup', sum(count), count(DISTINCT machine_id)
+     FROM usage_daily
+    WHERE day = ?
+    GROUP BY day
+   ON CONFLICT (day, event) DO UPDATE
+     SET count = excluded.count, machines = excluded.machines`,
 
   // Envelope dimensions — every event type carries them.
   dimStatement('os', 'e.os'),
   dimStatement('arch', 'e.arch'),
   dimStatement('codegraph_version', 'e.codegraph_version'),
   dimStatement('node_major', 'e.node_major'),
+  usageDimStatement('os', 'os'),
+  usageDimStatement('arch', 'arch'),
+  usageDimStatement('codegraph_version', 'codegraph_version'),
+  usageDimStatement('node_major', 'node_major'),
 
   // Event-specific scalar props.
   dimStatement('file_count_bucket', prop('file_count_bucket'), onlyEvents('index')),
@@ -148,9 +205,10 @@ const ROLLUP_STATEMENTS: readonly string[] = [
   dimStatement('scope', prop('scope'), onlyEvents('install')),
   // `kind` is fresh/upgrade/reinstall on install and mcp_tool/cli_command on
   // usage_rollup; `event` is part of the primary key, so both live here without colliding.
-  dimStatement('kind', prop('kind'), onlyEvents('install', 'usage_rollup')),
-  dimStatement('name', prop('name'), onlyEvents('usage_rollup')),
-  dimStatement('client_name', prop('client_name'), onlyEvents('usage_rollup')),
+  dimStatement('kind', prop('kind'), onlyEvents('install')),
+  usageDimStatement('kind', 'kind'),
+  usageDimStatement('name', 'name'),
+  usageDimStatement('client_name', 'client_name'),
 
   // Array props.
   arrayDimStatement('language', '$.languages', ['index']),
@@ -158,20 +216,13 @@ const ROLLUP_STATEMENTS: readonly string[] = [
 
   // Errors per tool/command. Not in the migration's documented dim list because dims
   // are a cron concern rather than a schema one, but rolled up because it is the one
-  // usage number that is gone for good after the purge. Only groups with at least one
-  // error are stored, so `count` is errors and `machines` is the machines that saw one
+  // usage number that is gone for good after the purge. Only counters with at least
+  // one error count, so `count` is errors and `machines` is the machines that saw one
   // — NOT the machines that ran the tool (that is the `name` dim).
-  `INSERT INTO daily_dim_counts (day, event, dim, value, count, machines)
-   SELECT e.day, e.event, 'name_error', CAST(${prop('name')} AS TEXT),
-          sum(${prop('error_count')}), count(DISTINCT e.machine_id)
-     FROM events e
-    WHERE e.day = ? AND e.event = 'usage_rollup'
-      AND ${prop('name')} IS NOT NULL AND coalesce(${prop('error_count')}, 0) > 0
-    GROUP BY e.day, e.event, ${prop('name')}
-   ${DIM_CONFLICT}`,
+  usageDimStatement('name_error', 'name', 'error_count', ' AND error_count > 0'),
 ];
 
-/** Rollup tables derived from raw `events` — the ones `reset` wipes before recomputing. */
+/** Rollup tables derived from raw `events` / `usage_daily` — the ones `reset` wipes before recomputing. */
 const EVENT_DERIVED_TABLES = ['daily_event_counts', 'daily_dim_counts'] as const;
 
 // ---------------------------------------------------------------------------
@@ -184,6 +235,11 @@ export interface DayResult {
   rows: number;
   /** Day is past the retention window — a `reset` on it is ignored (see below). */
   pastRetention: boolean;
+  /**
+   * The deadline passed before the day's legacy usage rows were all folded, so nothing
+   * was rolled up: the next run finishes the fold and rolls the day up then.
+   */
+  deferred: boolean;
 }
 
 /**
@@ -199,13 +255,20 @@ export interface DayResult {
  * exists would otherwise linger. It is IGNORED past the retention window, where it
  * would delete rows and then find no events to rebuild them from: silently blanking a
  * real day is the one irreversible thing this file could do.
+ *
+ * `deadline` (epoch ms) bounds the legacy fold that runs first. If it stops the fold
+ * partway, the day is not rolled up at all — usage counted from a half-folded day would
+ * be short, and its `daily_machines` row would stop the nightly run from ever coming
+ * back to it. The chunks already folded are committed, so the next call carries on.
  */
 export async function rollupDay(
   env: Env,
   day: string,
-  opts: { cutoff: string; reset?: boolean },
+  opts: { cutoff: string; reset?: boolean; deadline?: number },
 ): Promise<DayResult> {
   const pastRetention = day < opts.cutoff;
+  const fold = await foldLegacyUsage(env, day, opts.deadline);
+  if (!fold.complete) return { day, rows: 0, pastRetention, deferred: true };
   const statements: D1PreparedStatement[] = [];
 
   if (opts.reset && !pastRetention) {
@@ -219,79 +282,246 @@ export async function rollupDay(
 
   const results = await env.DB.batch(statements);
   const rows = results.reduce((total, r) => total + (r.meta?.changes ?? 0), 0);
-  return { day, rows, pastRetention };
+  return { day, rows, pastRetention, deferred: false };
+}
+
+// ---------------------------------------------------------------------------
+// Legacy usage rows
+// ---------------------------------------------------------------------------
+// Before migrations/0003, every usage_rollup event was its own `events` row — about
+// 3.8M a day by August 2026, because clients upload a counter per process rather
+// than per day, and enough to fill the database. These statements fold one day's
+// worth of those rows into `usage_daily`, adding counts the same way the ingest path
+// does, and delete them in the same transaction, so a count is never in both places
+// and never in neither. rollupDay runs it first, which makes re-running the rollup
+// over old days the whole migration; once a day has no legacy rows left it costs
+// one indexed probe.
+
+/** Rows folded per transaction — bounded so one GROUP BY + DELETE stays well inside D1's limits. */
+const LEGACY_CHUNK_ROWS = 50_000;
+/** Ceiling per day (the worst day on record had ~3.9M rows). */
+const LEGACY_MAX_CHUNKS = 200;
+
+const LEGACY_FOLD = `INSERT INTO usage_daily (
+    day, machine_id, kind, name, client_name, client_version,
+    codegraph_version, os, arch, node_major, count, error_count)
+  SELECT day, machine_id,
+         coalesce(json_extract(props, '$.kind'), ''),
+         coalesce(json_extract(props, '$.name'), ''),
+         coalesce(json_extract(props, '$.client_name'), ''),
+         coalesce(json_extract(props, '$.client_version'), ''),
+         coalesce(codegraph_version, ''), coalesce(os, ''), coalesce(arch, ''),
+         coalesce(CAST(node_major AS TEXT), ''),
+         sum(coalesce(json_extract(props, '$.count'), 0)),
+         sum(coalesce(json_extract(props, '$.error_count'), 0))
+    FROM events
+   WHERE day = ?1 AND event = 'usage_rollup' AND id < ?2
+   GROUP BY 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+  ON CONFLICT (day, machine_id, kind, name, client_name, client_version, codegraph_version, os, arch, node_major)
+  DO UPDATE SET count = usage_daily.count + excluded.count,
+                error_count = usage_daily.error_count + excluded.error_count`;
+
+const LEGACY_DELETE = `DELETE FROM events WHERE day = ?1 AND event = 'usage_rollup' AND id < ?2`;
+
+export interface FoldResult {
+  /** Legacy rows moved into usage_daily by this call. */
+  moved: number;
+  /** False when the deadline stopped it with rows still to fold; the next call carries on. */
+  complete: boolean;
+}
+
+/**
+ * Folds any legacy usage rows for `day` into usage_daily, a chunk per transaction.
+ * With a `deadline` (epoch ms) it starts no chunk once that has passed: each chunk
+ * commits on its own and always takes the oldest rows left, so stopping between two
+ * loses nothing and the next call simply continues.
+ */
+export async function foldLegacyUsage(
+  env: Env,
+  day: string,
+  deadline = Number.POSITIVE_INFINITY,
+): Promise<FoldResult> {
+  const any = await env.DB.prepare(`SELECT 1 AS hit FROM events WHERE day = ? AND event = 'usage_rollup' LIMIT 1`)
+    .bind(day)
+    .first<{ hit: number }>();
+  if (!any) return { moved: 0, complete: true };
+
+  let moved = 0;
+  for (let chunk = 0; chunk < LEGACY_MAX_CHUNKS; chunk++) {
+    if (Date.now() >= deadline) return { moved, complete: false };
+    // Always the oldest remaining rows: everything below the next chunk's first id.
+    // Rows folded by earlier chunks are gone, so there is no cursor to carry.
+    const next = await env.DB.prepare(
+      `SELECT id FROM events WHERE day = ? AND event = 'usage_rollup' ORDER BY id LIMIT 1 OFFSET ${LEGACY_CHUNK_ROWS}`,
+    )
+      .bind(day)
+      .first<{ id: number }>();
+    const below = next?.id ?? Number.MAX_SAFE_INTEGER;
+    const [, deleted] = await env.DB.batch([
+      env.DB.prepare(LEGACY_FOLD).bind(day, below),
+      env.DB.prepare(LEGACY_DELETE).bind(day, below),
+    ]);
+    moved += deleted?.meta?.changes ?? 0;
+    if (!next) return { moved, complete: true };
+  }
+  throw new Error(`legacy usage fold for ${day} did not finish within ${LEGACY_MAX_CHUNKS} chunks`);
 }
 
 export interface PurgeResult {
   /** Everything strictly before this day was deleted. */
   cutoff: string;
   deleted: number;
+  /** usage_daily rows past the window — per-machine counters, so they expire with the events. */
+  usageDeleted: number;
   batches: number;
   /** Hit the per-run batch ceiling — more rows are still due, next run takes them. */
   capped: boolean;
 }
 
 /**
- * Delete raw events older than the window, oldest first, in bounded batches.
- * `id` is a rowid alias and the purge only ever removes the oldest rows, so the
- * keyset subquery stays a cheap index range scan on (day, event).
+ * Delete raw events older than the window, oldest first, in bounded batches, then
+ * the usage counters older than it, a day per statement (`usage_daily` is keyed by
+ * day first, so each is one primary-key range). `id` is a rowid alias and the purge
+ * only ever removes the oldest rows, so the keyset subquery stays a cheap index range
+ * scan on (day, event).
  */
 export async function purgeOldEvents(env: Env, cutoff: string): Promise<PurgeResult> {
   const del = env.DB.prepare(
     `DELETE FROM events WHERE id IN (SELECT id FROM events WHERE day < ? LIMIT ${PURGE_BATCH_ROWS})`,
   );
   let deleted = 0;
-  for (let batch = 1; batch <= PURGE_MAX_BATCHES; batch++) {
+  let batches = 0;
+  let capped = true;
+  while (batches < PURGE_MAX_BATCHES) {
+    batches++;
     const { meta } = await del.bind(cutoff).run();
     const removed = meta?.changes ?? 0;
     deleted += removed;
-    if (removed < PURGE_BATCH_ROWS) return { cutoff, deleted, batches: batch, capped: false };
+    if (removed < PURGE_BATCH_ROWS) {
+      capped = false;
+      break;
+    }
+  }
+
+  const delUsageDay = env.DB.prepare(
+    `DELETE FROM usage_daily WHERE day = (SELECT min(day) FROM usage_daily WHERE day < ?)`,
+  );
+  let usageDeleted = 0;
+  for (let day = 0; day < PURGE_MAX_BATCHES; day++) {
+    const { meta } = await delUsageDay.bind(cutoff).run();
+    const removed = meta?.changes ?? 0;
+    if (removed === 0) break;
+    usageDeleted += removed;
   }
-  return { cutoff, deleted, batches: PURGE_MAX_BATCHES, capped: true };
+  return { cutoff, deleted, usageDeleted, batches, capped };
+}
+
+/**
+ * Days that saw activity but never got a rollup: the nights a run failed, or the
+ * database refused writes. Every active day has `machine_days` rows and every
+ * rolled-up day has a `daily_machines` row, so the difference is exactly the missed
+ * days — a day nobody was active on is in neither, and needs nothing.
+ *
+ * Without this, the cron only ever looks three days back, so one bad week leaves a
+ * permanent hole that someone has to notice and backfill by hand. Bounded below by
+ * the retention cutoff, past which the raw events are gone and there is nothing left
+ * to roll up.
+ */
+async function missedDays(env: Env, cutoff: string, before: string): Promise<string[]> {
+  const { results } = await env.DB.prepare(
+    `SELECT DISTINCT day FROM machine_days
+      WHERE day >= ? AND day < ?
+        AND day NOT IN (SELECT day FROM daily_machines)
+      ORDER BY day DESC
+      LIMIT ${MAX_CATCHUP_DAYS}`,
+  )
+    .bind(cutoff, before)
+    .all<{ day: string }>();
+  return results.map((r) => r.day);
 }
 
 /**
- * The cron body: roll up the completed day and the two before it, then purge.
+ * The cron body: purge, roll up the completed day and the two before it, then catch
+ * up any earlier day a past run missed, for as long as the time budget lasts.
+ *
+ * The purge goes first. It is bounded, it deletes only days past the window (which
+ * nothing below reads), and it is the job that must not slip: a database that stops
+ * purging grows until D1's size cap refuses every write. Run last, it was what
+ * Cloudflare's 15-minute limit cut off whenever a catch-up ran long, night after night.
+ *
+ * Rollups then start until NIGHTLY_BUDGET_MS has passed. A day the budget stops —
+ * before it starts, or partway through its legacy fold — gets no rollup at all, so it
+ * is still a missed day tomorrow and picks up where it stopped (each fold chunk is
+ * already committed).
  *
  * Logs one line of counts — never a day's contents, never a machine id. Throws if
  * anything failed so the invocation is marked failed (and retried) rather than
- * quietly skipping a day; every write here is idempotent, so a retry is safe.
+ * quietly skipping a day; every write here is idempotent, so a retry is safe. A day
+ * left for tomorrow is not a failure.
  */
 export async function runNightly(env: Env, atMs: number): Promise<void> {
   const started = Date.now();
+  const deadline = started + NIGHTLY_BUDGET_MS;
   const keepDays = retentionDays(env);
   const cutoff = retentionCutoff(atMs, keepDays);
 
+  let purge: PurgeResult | null = null;
+  try {
+    purge = await purgeOldEvents(env, cutoff);
+  } catch (err) {
+    console.error(JSON.stringify({ msg: 'purge failed', cutoff, err: String(err) }));
+  }
+
+  const regular: string[] = [];
+  for (let back = 1; back <= ROLLUP_LOOKBACK_DAYS; back++) regular.push(utcDay(atMs - back * DAY_MS));
+
+  // A failure to find the missed days must not cost tonight's regular rollup.
+  let missed: string[] = [];
+  try {
+    missed = await missedDays(env, cutoff, regular[regular.length - 1] ?? utcDay(atMs));
+  } catch (err) {
+    console.error(JSON.stringify({ msg: 'missed-day scan failed', err: String(err) }));
+  }
+
   const rolled: string[] = [];
   const failed: string[] = [];
+  const deferred: string[] = [];
+  let caughtUp = 0;
   let rows = 0;
-  for (let back = 1; back <= ROLLUP_LOOKBACK_DAYS; back++) {
-    const day = utcDay(atMs - back * DAY_MS);
+  for (const day of [...regular, ...missed]) {
+    if (Date.now() >= deadline) {
+      deferred.push(day);
+      continue;
+    }
     try {
-      rows += (await rollupDay(env, day, { cutoff })).rows;
+      const result = await rollupDay(env, day, { cutoff, deadline });
+      if (result.deferred) {
+        deferred.push(day);
+        continue;
+      }
+      rows += result.rows;
       rolled.push(day);
+      if (!regular.includes(day)) caughtUp++;
     } catch (err) {
       failed.push(day);
       console.error(JSON.stringify({ msg: 'rollup day failed', day, err: String(err) }));
     }
   }
 
-  let purge: PurgeResult | null = null;
-  try {
-    purge = await purgeOldEvents(env, cutoff);
-  } catch (err) {
-    console.error(JSON.stringify({ msg: 'purge failed', cutoff, err: String(err) }));
-  }
-
   console.log(
     JSON.stringify({
       msg: 'nightly rollup',
       days: rolled,
+      /** Missed days rolled up tonight. */
+      caught_up: caughtUp,
+      /** Days the time budget left for the next run. */
+      deferred: deferred.length,
       rows,
       failed: failed.length,
       retention_days: keepDays,
       purged_before: cutoff,
       purged: purge?.deleted ?? null,
+      usage_purged: purge?.usageDeleted ?? null,
       purge_batches: purge?.batches ?? null,
       purge_capped: purge?.capped ?? null,
       ms: Date.now() - started,
diff --git a/ui/package.json b/ui/package.json
index 4c01a250f0..1d641cc165 100644
--- a/ui/package.json
+++ b/ui/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@colbymchenry/codegraph-ui",
   "private": true,
-  "version": "1.6.1",
+  "version": "1.6.2",
   "type": "module",
   "description": "The CodeGraph reader as Svelte components: Symbol view, Flow strip and architecture Map behind one data adapter.",
   "keywords": [
diff --git a/ui/src/lib/entry-model.ts b/ui/src/lib/entry-model.ts
index 854d2cbfd1..ef7061b374 100644
--- a/ui/src/lib/entry-model.ts
+++ b/ui/src/lib/entry-model.ts
@@ -140,7 +140,8 @@ export function routeRow(route: WireEntryRoute): EntryRow {
     target: route.handlerId
       ? { type: 'symbol', id: route.handlerId, name: route.handler, kind: route.handlerKind }
       : null,
-    flowFrom: route.handlerId ? route.handler : null,
+    // An inline handler has no name of its own to draw a Flow from.
+    flowFrom: route.handlerId && !route.inline ? route.handler : null,
     title: `${route.url} → ${route.handler} (${route.file}:${route.line}), registered at ${route.routeFile}:${route.routeLine}`,
   };
 }
diff --git a/ui/src/lib/i18n.svelte.ts b/ui/src/lib/i18n.svelte.ts
index d209e6d0c2..93d32fbc59 100644
--- a/ui/src/lib/i18n.svelte.ts
+++ b/ui/src/lib/i18n.svelte.ts
@@ -83,6 +83,7 @@ const visibleCopy: Record<string, string> = {
   'Walking from the anchor…': '正在从锚点追踪…',
   'This has no body to read in order': '这里没有可按顺序阅读的主体',
   'What it sets in motion →': '它会启动什么 →',
+  'Its callers and callees →': '它的调用方与被调用方 →',
   'Start here →': '从这里开始 →',
   'Open as a flow →': '以调用流打开 →',
   'Arrives from': '到达自',
diff --git a/ui/src/lib/program-model.ts b/ui/src/lib/program-model.ts
index 8d38559ac7..bbcbe48dc9 100644
--- a/ui/src/lib/program-model.ts
+++ b/ui/src/lib/program-model.ts
@@ -174,12 +174,12 @@ export function orderGraph(program: NonNullable<WireStepsPayload['program']>, an
           // An arm that answers, returns or throws does not rejoin — nothing
           // leaves the last box in it, which is what says so on a canvas.
           const armTails = flow(arm.body, entry, []);
-          if (arm.ends === null) out.push(...armTails);
+          if (arm.ends === null) for (const t of armTails) out.push(t);
         }
         // An `if` with no `else` runs on either way; a fork with both sides
         // covered runs on only through the arms that did not end.
-        if (item.arms.length < 2) out.push(...tails.map((t) => ({ ...t, runs: [...t.runs, ...runs] })));
-        tails = out;
+        if (item.arms.length < 2) for (const t of tails) out.push({ ...t, runs: [...t.runs, ...runs] });
+        tails = mergeTails(out);
       } else if (item.kind === 'block') {
         const label = runWords(item);
         const inner = flow(item.body, tails, [...runs, label]);
@@ -206,6 +206,26 @@ export function orderGraph(program: NonNullable<WireStepsPayload['program']>, an
   return { edges, depth: rows(anchor, ids, edges), forks };
 }
 
+/**
+ * Ways on that wait at the same place are one place to go on from. Without
+ * this, an `if` with no `else` — or a fork whose arms draw nothing — doubles
+ * every way it crosses (once under its condition, once without), and a body
+ * with eighty such checks (jsoup's `parse`) never finished: the page died
+ * overflowing the stack. The merged way keeps what every way to it had to
+ * hold; a condition only some of them needed is dropped, so the line
+ * under-claims rather than claims a side it does not have.
+ */
+function mergeTails(tails: readonly Tail[]): Tail[] {
+  const byPlace = new Map<string, Tail>();
+  for (const t of tails) {
+    const key = `${t.id}\0${t.arm ?? ''}\0${t.runs.join('\0')}`;
+    const found = byPlace.get(key);
+    if (found) found.when = found.when.filter((w) => t.when.includes(w));
+    else byPlace.set(key, { ...t, when: [...t.when], runs: [...t.runs] });
+  }
+  return [...byPlace.values()];
+}
+
 /** Whether anything in this block draws a box — a fork with one drawn arm is a guard clause, not a point. */
 function hasStep(block: WireBlock): boolean {
   return block.some((item) =>
diff --git a/ui/src/lib/wire.ts b/ui/src/lib/wire.ts
index ff866c23c9..a6d369a191 100644
--- a/ui/src/lib/wire.ts
+++ b/ui/src/lib/wire.ts
@@ -377,6 +377,8 @@ export interface WireRoute {
   routeFile: string;
   routeLine: number;
   routeId: string;
+  /** The handler is written inline at the registration: the route stands in for it. */
+  inline: boolean;
 }
 
 export interface WireRoutes {
@@ -410,6 +412,8 @@ export interface WireEntryRoute {
   routeFile: string;
   routeLine: number;
   routeId: string;
+  /** The handler is written inline at the registration: the route stands in for it. */
+  inline: boolean;
 }
 
 export interface WireEntryFile extends WireNodeRef {
diff --git a/ui/src/views/StepsView.svelte b/ui/src/views/StepsView.svelte
index f9e3e878df..e3faa33bd4 100644
--- a/ui/src/views/StepsView.svelte
+++ b/ui/src/views/StepsView.svelte
@@ -766,6 +766,15 @@
             {/if}
           {/each}
         </p>
+        {#if payload.steps.length === 1 && payload.truncated.steps === 0 && payload.truncated.hubs === 0}
+          <!-- A lone anchor is an answer, not an empty canvas: say what the walk looked for. -->
+          <p>
+            Nothing this sets in motion is a step the picture draws — no reply, database, queue, network or
+            other {kindWord('screen', payload.project)} within {payload.depth} calls. Calls between plain functions
+            fold into the lines between steps, so a helper that only computes is drawn alone.
+            {#if payload.anchor}<a href={symbolHref(payload.anchor.id)}>Its callers and callees →</a>{/if}
+          </p>
+        {/if}
         {#if readAs === 'order'}
           <p class="dim">
             <span class="mark">●</span> The anchor is at the top, and each row down is what happens next: a line
diff --git a/vitest.config.mts b/vitest.config.mts
index ae02ba84c6..96fb2573a6 100644
--- a/vitest.config.mts
+++ b/vitest.config.mts
@@ -14,6 +14,9 @@ export default defineConfig({
     include: ['__tests__/**/*.test.ts'],
     // Suites that spawn the built CLI need a current dist/ (#1879).
     globalSetup: ['./__tests__/global-setup-dist.ts'],
+    // A throwaway home dir (and git global config) per test file, so nothing
+    // the suite runs can write to the developer's real one (#2275).
+    setupFiles: ['./__tests__/setup-home-sandbox.ts'],
     /**
      * Several MCP integration tests (mcp-daemon, mcp-initialize, mcp-ppid-watchdog,
      * mcp-roots) spawn `dist/bin/codegraph.js serve --mcp` with `process.execPath`
diff --git a/vitest.workspace.mts b/vitest.workspace.mts
index de9d3e8b14..2dd4b9eaf5 100644
--- a/vitest.workspace.mts
+++ b/vitest.workspace.mts
@@ -20,9 +20,9 @@ import { defineWorkspace } from 'vitest/config';
  * browser builds of `web-tree-sitter` and friends, and the failures that
  * causes look nothing like their cause.
  *
- * The engine project `extends` the shared base, so the env vars and Node guard
- * in `vitest.config.mts` still apply to every engine test. The ui project does
- * not — see the note on it.
+ * The engine project `extends` the shared base, so the env vars, Node guard and
+ * home-dir sandbox in `vitest.config.mts` still apply to every engine test. The
+ * ui project does not — see the note on it.
  */
 export default defineWorkspace([
   {