diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8a861a68e..c9f22f046 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -534,6 +534,18 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - 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.
+
+- The call paths `codegraph context` prints now say what bridges each dynamic-dispatch hop, in the same words `codegraph_explore` uses: a call through an interface reads `interface → impl`, and a C++ override, a Redux thunk or a Gin middleware chain is named as one. Before, every hop of a kind it didn't know was labeled an "event", so a call through an interface looked like an event being emitted.
+
+- In C++, a call on a range-based `for` loop's variable, like `suite->SetVerbose(verbose)` inside `for (ConformanceTestSuite *suite : suites)`, now links to the method of the type the loop declares. Before, the loop's declaration was never read, so the call was matched by the variable's name alone: in RocksDB, `log->file()` on a `log::Writer` went to `BlobLogWriter::file`, and a loop variable named like a member of its class was taken for that member. The variable counts only inside its loop, and loops over `auto` elements resolve as before. Re-index C++ projects after upgrading.
+
+- In C++, a call made with `->` on a variable, parameter or member declared as a `std::unique_ptr`, `std::shared_ptr` or `std::optional`, like `iter->Valid()` on a `std::unique_ptr<Iterator> iter`, now links to that method of the type it holds, or of a class that type inherits from, with the type looked up the way C++ does it, so a class of the same name nested elsewhere is not mistaken for it. Before, the call went to whichever project method shared its name: in facebook/rocksdb, `iter->Valid()` reached `ArenaWrappedDBIter::Valid` and `fs->GetFileSize(…)` on a `std::shared_ptr<FileSystem>` reached a test's stand-in file system, and calls like `it->Next()` were often not linked at all. When what it holds is a template parameter or a standard-library type, like `std::unique_ptr<std::deque<…>>`, the call no longer links to a project method. Re-index C++ projects after upgrading.
+
+- `codegraph sync` and the file watcher now move a React Router route to its page when the router file loads that page lazily into a value of its own, like `const Docs = lazy(() => import('./pages/Docs'))` rendered by `<Route path="/docs" element={<Docs />} />`, and the page's file is added after the router was indexed, comes back after being deleted, or gets or changes its default export in a later edit. Before, the route kept pointing at the `Docs` declaration, or at the page's old component, until the router file itself changed or the project was re-indexed, unless the page's component happened to share the declaration's name. The same now holds for a `lazy: () => import('./pages/Docs')` route whose page switches its default export to another component. Re-index React projects after upgrading to correct routes an earlier version left behind.
+
+- `codegraph sync` and the file watcher now link a component to the JSX that renders it, like `<Team />`, when the component is added in a file with no JSX of its own, as in `export default function Team() { return null; }`. Before, the link waited for an unrelated change to a file with JSX, or for a re-index, so the new component looked unused.
+
+- In JavaScript and TypeScript, a default import now links to what the module's `export default` statement exports, wherever the statement sits in the file. Before, a module that declares its default, like `export default function Vans() {…}` or `export default class Store {…}`, had its default import linked to the first function it exports instead: in a React Router data-router app, where a page exports its `loader` or `action` above the page component, `import Vans, { loader as vansLoader } from './pages/Vans'` made the route `/vans` and every use of `Vans` lead to the loader. A component file that also exports a styled or memoized component no longer hands its default import to that component, and an anonymous default, like `export default function () {…}` or `export default () => …`, is no longer linked to a function exported beside it or nested inside it. Re-index JavaScript and TypeScript projects after upgrading.
 #### MCP / indexing
 
 - Full indexes of large projects no longer sometimes run two to three times slower than usual. A timing clash between two background database maintenance steps could switch reference resolution from several threads to one partway through.
diff --git a/README.md b/README.md
index a6011a56a..128ddb1ee 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,7 @@ Follow [@getcodegraph](https://x.com/getcodegraph) on X for updates.
 
 ## About this fork
 
-This is **bompus/codegraph**, a fork of [colbymchenry/codegraph](https://github.com/colbymchenry/codegraph). Its default branch, `fork/consolidated`, contains upstream `main` through [`b635dd46`](https://github.com/colbymchenry/codegraph/commit/b635dd467f0578926a9c01a37b9d28d2b26689f1) (after v1.6.2) plus the fork's own work, and it takes upstream changes as they land. Changes that suit upstream are also offered there as pull requests.
+This is **bompus/codegraph**, a fork of [colbymchenry/codegraph](https://github.com/colbymchenry/codegraph). Its default branch, `fork/consolidated`, contains upstream `main` through [`c0f45c7d`](https://github.com/colbymchenry/codegraph/commit/c0f45c7d) (after v1.6.2) plus the fork's own work, and it takes upstream changes as they land. Changes that suit upstream are also offered there as pull requests.
 
 The fork publishes no releases. The install scripts, npm package, badges and `codegraph upgrade` further down this page install **upstream's** releases. To run the fork, build it from source (below).
 
@@ -80,7 +80,7 @@ Session search uses `.codegraph/sessions-v2.db`. The first session search import
 
 ### What the fork adds
 
-Compared with upstream `main` at `b635dd46` (after v1.6.2). Each item here and in the dispatch and framework lists below was checked against upstream's tree at that commit.
+Compared with upstream `main` at `c0f45c7d` (after v1.6.2). Each item here and in the dispatch and framework lists below was checked against upstream's tree at that commit.
 
 | Feature | Upstream | Fork | What it does |
 |---|:-:|:-:|---|
@@ -150,6 +150,7 @@ Call resolution the fork adds:
 - Kotlin chains on instance and extension receivers use the declared return type, including nested and multiline calls; upstream covers class and companion-factory chains. An imported return-type guess for an unknown receiver keeps confidence at most 0.7, and so does a Rust chain match without a proved receiver type.
 - Kotlin multi-dollar strings keep their interpolation threshold.
 - C++ typedef and using aliases follow their declaration scope, including nested owners and inherited aliases. Pointer, array and function members are not supertypes. Visible class-scoped aliases and declared complex receivers keep their method owners; unsubstituted template parameters and ambiguous owners stay unresolved.
+- C++ `->` calls on a `std::unique_ptr`, `std::shared_ptr` or `std::optional` reach the type it holds, looked up through the caller's enclosing classes and their bases, its namespaces, `using` directives and aliases. A held type the project does not declare leaves the call unresolved, as a plain pointer to one does; upstream guesses a callee from the receiver's name there. A partial class template specialization is indexed as an anonymous class, so a call to a member only it declares stays unresolved.
 - C++ namespace aliases and declarations in macro-opened namespaces are looked up only in the caller's include closure; upstream pools them across all files.
 - C# namespace `using` directives and `using` aliases apply only inside their enclosing namespace, not to sibling namespaces in the same file (`using static` is still file-wide, as upstream).
 - A Java field declared with a qualified type (`outside.Repository`) keeps its qualifier, so calls through it never resolve to an unrelated project class with the same simple name.
diff --git a/__tests__/cpp-range-for-receiver.test.ts b/__tests__/cpp-range-for-receiver.test.ts
new file mode 100644
index 000000000..67da5c2f9
--- /dev/null
+++ b/__tests__/cpp-range-for-receiver.test.ts
@@ -0,0 +1,446 @@
+/**
+ * A C++ range-based for loop declares the receiver its body calls through.
+ *
+ * protocolbuffers/protobuf's conformance runner loops `for
+ * (ConformanceTestSuite *suite : suites)` and calls `suite->SetVerbose(…)`,
+ * `suite->RunSuite(…)` and `suite->GetFailureListFlagName()` in the body.
+ * Receiver inference reads a declaration only when the declared name is
+ * followed by `;`, `=`, `,`, `)`, `[`, `{` or `(`, so it never read a loop's
+ * `Type name :` and the calls fell through to a guess by the receiver's name.
+ * A guess can still land on the right method by a shared word, so these tests
+ * check how the edge was made (the typed path's confidence), not only where
+ * it goes.
+ *
+ * The loop's variable is in scope in the loop's body only: after the loop, or
+ * in another function, a receiver of the same name is some other variable.
+ * A `for` in a comment or a string literal declares nothing, and a colon
+ * outside a loop's header never ends a declaration: not a bit-field's
+ * (`unsigned car : 1;`), nor the scope operator's (`void parts::Install()`).
+ */
+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-range-for-'));
+  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 @confidence`, one per call site. */
+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.edge.metadata as { confidence?: number } | undefined)?.confidence}`)
+    .sort();
+}
+
+/** protocolbuffers/protobuf's conformance runner, trimmed; `FlagParser` is a decoy `SetVerbose`. */
+const CONFORMANCE = {
+  'conformance/suite.h': [
+    '#include <string>',
+    'namespace google {',
+    'namespace protobuf {',
+    'class ConformanceTestRunner {',
+    ' public:',
+    '  virtual ~ConformanceTestRunner() = default;',
+    '};',
+    'class ConformanceTestSuite {',
+    ' public:',
+    '  void SetVerbose(bool verbose) { verbose_ = verbose; }',
+    '  std::string GetFailureListFlagName() { return failure_list_flag_name_; }',
+    '  bool RunSuite(ConformanceTestRunner* runner, std::string* output,',
+    '                const std::string& filename);',
+    ' private:',
+    '  bool verbose_ = false;',
+    '  std::string failure_list_flag_name_;',
+    '};',
+    'class FlagParser {',
+    ' public:',
+    '  void SetVerbose(bool verbose) {}',
+    '};',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  'conformance/suite.cc': [
+    '#include "conformance/suite.h"',
+    'namespace google {',
+    'namespace protobuf {',
+    'bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner, std::string* output,',
+    '                                    const std::string& filename) {',
+    '  return true;',
+    '}',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+  'conformance/runner.cc': [
+    '#include <cstring>',
+    '#include <vector>',
+    '#include "conformance/suite.h"',
+    'namespace google {',
+    'namespace protobuf {',
+    'int ForkPipeRunnerMain(int argc, char* argv[], const std::vector<ConformanceTestSuite*>& suites) {',
+    '  bool verbose = false;',
+    '  for (ConformanceTestSuite *suite : suites) {',
+    '    std::string failure_list_filename;',
+    '    for (int arg = 1; arg < argc; ++arg) {',
+    '      if (strcmp(argv[arg], suite->GetFailureListFlagName().c_str()) == 0) {',
+    '        failure_list_filename = argv[arg];',
+    '      }',
+    '    }',
+    '    suite->SetVerbose(verbose);',
+    '    std::string output;',
+    '    ConformanceTestRunner* runner = nullptr;',
+    '    verbose = verbose && suite->RunSuite(runner, &output,',
+    '                                         failure_list_filename);',
+    '  }',
+    '  return 0;',
+    '}',
+    '}  // namespace protobuf',
+    '}  // namespace google',
+    '',
+  ].join('\n'),
+};
+
+/** Two `Start`s no receiver name below points at, and a class whose member is named like a loop variable. */
+const GARAGE = {
+  'garage/vehicle.h': [
+    '#include <vector>',
+    'namespace garage {',
+    'class Engine {',
+    ' public:',
+    '  void Start();',
+    '  int Torque() const;',
+    '};',
+    'class Car {',
+    ' public:',
+    '  void Start();',
+    '};',
+    'namespace parts {',
+    'class Part {',
+    ' public:',
+    '  void Fit();',
+    '};',
+    'void Install();',
+    '}  // namespace parts',
+    '}  // namespace garage',
+    '',
+  ].join('\n'),
+  'garage/vehicle.cc': [
+    '#include "garage/vehicle.h"',
+    'namespace garage {',
+    'void Engine::Start() {}',
+    'int Engine::Torque() const { return 0; }',
+    'void Car::Start() {}',
+    'void parts::Part::Fit() {}',
+    '}  // namespace garage',
+    '',
+  ].join('\n'),
+  'garage/garage.h': [
+    '#include "garage/vehicle.h"',
+    'namespace garage {',
+    'class Garage {',
+    ' public:',
+    '  void Inspect(const std::vector<Engine*>& engines);',
+    '  void Service();',
+    ' private:',
+    '  Car* car;',
+    '};',
+    '}  // namespace garage',
+    '',
+  ].join('\n'),
+  'garage/garage.cc': [
+    '#include "garage/garage.h"',
+    'namespace garage {',
+    'void Garage::Inspect(const std::vector<Engine*>& engines) {',
+    '  for (Engine* car : engines) car->Start();',
+    '}',
+    'void Garage::Service() {',
+    '  car->Start();',
+    '}',
+    '}  // namespace garage',
+    '',
+  ].join('\n'),
+};
+
+describe('a C++ range-based for declares its loop variable', () => {
+  it('reproduction: protobuf\'s conformance runner calls the suite\'s methods through the typed path', async () => {
+    const cg = await indexed(CONFORMANCE);
+    try {
+      // The guess by the receiver's name lands on the same methods (0.65 /
+      // 0.7); the loop's declared type makes them certain.
+      expect(calls(cg, 'google::protobuf::ForkPipeRunnerMain')).toEqual([
+        'google::protobuf::ConformanceTestSuite::GetFailureListFlagName @0.9',
+        'google::protobuf::ConformanceTestSuite::RunSuite @0.9',
+        'google::protobuf::ConformanceTestSuite::SetVerbose @0.9',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a loop variable that hides a member is the element, not the member', async () => {
+    const cg = await indexed(GARAGE);
+    try {
+      // Reading on past the loop reached the member `Car* car;` in the header.
+      expect(calls(cg, 'garage::Garage::Inspect')).toEqual(['garage::Engine::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('after the loop, and in another function, a same-named receiver is not the loop\'s variable', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/fleet.cc': [
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'void Drive(Car* engine, const std::vector<Engine*>& engines) {',
+        '  for (Engine* engine : engines) {',
+        '    engine->Start();',
+        '  }',
+        '  engine->Start();',
+        '}',
+        'void Wash(Car* engine, const std::vector<Engine*>& engines) {',
+        '  for (Engine* engine : engines) engine->Start();',
+        '  engine->Start();',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'garage::Drive')).toEqual(['garage::Car::Start @0.9', 'garage::Engine::Start @0.9']);
+      // A loop without braces ends with its one statement.
+      expect(calls(cg, 'garage::Wash')).toEqual(['garage::Car::Start @0.9', 'garage::Engine::Start @0.9']);
+      // Garage::Service's `car` is the member, though Inspect's loop above it names one `car`.
+      expect(calls(cg, 'garage::Garage::Service')).toEqual(['garage::Car::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('reads references, pointers, qualified and global-scope types, and a header split over lines', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/shop.cc': [
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'void ByReference(std::vector<Engine>& engines) {',
+        '  for (Engine& e : engines) e.Start();',
+        '}',
+        'void ByConstReference(const std::vector<Engine>& engines) {',
+        '  for (const Engine& e : engines) {',
+        '    if (e.Torque() > 0) {}',
+        '  }',
+        '}',
+        'void StarOnName(const std::vector<Engine*>& engines) {',
+        '  for (Engine *e : engines)',
+        '    e->Start();',
+        '}',
+        'void Qualified(const std::vector<parts::Part*>& list) {',
+        '  for (::garage::parts::Part* p : list) p->Fit();',
+        '}',
+        'void SplitHeader(const std::vector<Engine*>& engines) {',
+        '  for (Engine* first_engine_in_the_list :',
+        '       engines) {',
+        '    first_engine_in_the_list->Start();',
+        '  }',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'garage::ByReference')).toEqual(['garage::Engine::Start @0.9']);
+      expect(calls(cg, 'garage::ByConstReference')).toEqual(['garage::Engine::Torque @0.9']);
+      expect(calls(cg, 'garage::StarOnName')).toEqual(['garage::Engine::Start @0.9']);
+      expect(calls(cg, 'garage::Qualified')).toEqual(['garage::parts::Part::Fit @0.9']);
+      expect(calls(cg, 'garage::SplitHeader')).toEqual(['garage::Engine::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a brace in a comment or a string literal does not end the loop', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/braces.cc': [
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'void Braces(const std::vector<Engine*>& engines) {',
+        '  for (Engine* e : engines) {',
+        '    // A comment\'s } is not the loop\'s.',
+        '    const char* close = "}";',
+        '    /* nor is } this one',
+        '       } or this */',
+        '    char brace = \'}\';',
+        '    e->Start();',
+        '  }',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'garage::Braces')).toEqual(['garage::Engine::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a nested loop\'s call is inside the outer loop\'s body', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/nested.cc': [
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'void Nested(const std::vector<parts::Part*>& list) {',
+        '  for (parts::Part* p : list) {',
+        '    for (int i = 0; i < 2; ++i) {',
+        '      if (i) { p->Fit(); }',
+        '    }',
+        '  }',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'garage::Nested')).toEqual(['garage::parts::Part::Fit @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('what declares no loop variable', () => {
+  it('a `for` in a comment or a string literal', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/notes.cc': [
+        '#include <string>',
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'void Commented(Car* car) {',
+        '  // for (Engine* car : engines) {',
+        '  car->Start();',
+        '}',
+        'void Inline(Car* car) {',
+        '  /* for (Engine* car : engines) { */ car->Start();',
+        '}',
+        'std::string Template(Car* car) {',
+        '  std::string code = "for (Engine* car : engines) {";',
+        '  car->Start();',
+        '  return code + "}";',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      expect(calls(cg, 'garage::Commented')).toEqual(['garage::Car::Start @0.9']);
+      expect(calls(cg, 'garage::Inline')).toEqual(['garage::Car::Start @0.9']);
+      expect(calls(cg, 'garage::Template')).toEqual(['garage::Car::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a bit-field', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/lot.h': [
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'struct Slot {',
+        '  unsigned car : 1;',
+        '};',
+        'class Lot {',
+        ' public:',
+        '  void Park();',
+        ' private:',
+        '  Car* car;',
+        '};',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+      'garage/lot.cc': [
+        '#include "garage/lot.h"',
+        'namespace garage {',
+        'void Lot::Park() {',
+        '  car->Start();',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      // The member `Car* car;`, not Slot's `unsigned car : 1;` above it.
+      expect(calls(cg, 'garage::Lot::Park')).toEqual(['garage::Car::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a name followed by the scope operator', async () => {
+    const cg = await indexed({
+      ...GARAGE,
+      'garage/bay.h': [
+        '#include "garage/vehicle.h"',
+        'namespace garage {',
+        'class Bay {',
+        ' public:',
+        '  void Open();',
+        '  void Fit(const std::vector<parts::Part*>& list);',
+        ' private:',
+        '  Car* parts;',
+        '};',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+      'garage/bay.cc': [
+        '#include "garage/bay.h"',
+        'namespace garage {',
+        'void parts::Install() {}',
+        'void Bay::Open() {',
+        '  parts->Start();',
+        '}',
+        'void Bay::Fit(const std::vector<parts::Part*>& list) {',
+        '  for (parts::Part* part : list) parts->Start();',
+        '}',
+        '}  // namespace garage',
+        '',
+      ].join('\n'),
+    });
+    try {
+      // `void parts::Install()` declares no `parts`; the member does.
+      expect(calls(cg, 'garage::Bay::Open')).toEqual(['garage::Car::Start @0.9']);
+      // `parts::Part` declares the loop's `part`; the receiver `parts` is still the member.
+      expect(calls(cg, 'garage::Bay::Fit')).toEqual(['garage::Car::Start @0.9']);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/cpp-smart-pointer-receiver.test.ts b/__tests__/cpp-smart-pointer-receiver.test.ts
new file mode 100644
index 000000000..fddbf8370
--- /dev/null
+++ b/__tests__/cpp-smart-pointer-receiver.test.ts
@@ -0,0 +1,457 @@
+/**
+ * A C++ `->` call on a receiver declared as a standard smart pointer or
+ * optional — `std::unique_ptr<Iterator> iter; iter->Valid()` — calls a member
+ * of the type it holds.
+ *
+ * facebook/rocksdb has about 14,000 of these calls on a declaration in the
+ * calling function or its class. Receiver inference read the declared type as
+ * `unique_ptr`, which has no project methods, so the call fell through to a
+ * guess by the method's name and the receiver's words: `iter->Valid()` went
+ * to `ArenaWrappedDBIter::Valid`, `db_copy->Get()` to a test's `Get`.
+ *
+ * The held type is looked up as C++ looks a name up where the call is
+ * written — the scopes around the call, the file's `using`s, aliases
+ * followed — and the method is taken from that class or the classes it
+ * derives from. Its last name alone is not enough: rocksdb's `Iterator` is
+ * also the name of `MemTableRep::Iterator` and other nested classes, while the
+ * `Iterator` the call means inherits `Valid` from `IteratorBase`. A template
+ * parameter, a library type and an alias of a type outside the project hold
+ * no project class, so those calls get no edge; neither does a call the held
+ * class has no method for (unless a class template's specialization may
+ * declare it). A held type the project doesn't declare — a generated message
+ * — leaves the call as it was.
+ */
+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-held-'));
+  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');
+
+/** rocksdb's iterator family, trimmed: the public Iterator, a nested namesake, and an implementation a guess reaches. */
+const ROCKSDB = {
+  'include/rocksdb/iterator_base.h': lines(
+    'namespace rocksdb {',
+    'class IteratorBase {',
+    ' public:',
+    '  virtual ~IteratorBase() {}',
+    '  virtual bool Valid() const = 0;',
+    '  virtual void Next() = 0;',
+    '};',
+    '}  // namespace rocksdb',
+  ),
+  'include/rocksdb/iterator.h': lines(
+    '#include "include/rocksdb/iterator_base.h"',
+    'namespace rocksdb {',
+    'class Iterator : public IteratorBase {',
+    ' public:',
+    '  virtual int value() const = 0;',
+    '};',
+    '}  // namespace rocksdb',
+  ),
+  'include/rocksdb/memtablerep.h': lines(
+    'namespace rocksdb {',
+    'class MemTableRep {',
+    ' public:',
+    '  class Iterator {',
+    '   public:',
+    '    virtual bool Valid() const = 0;',
+    '    virtual void Next() = 0;',
+    '  };',
+    '};',
+    '}  // namespace rocksdb',
+  ),
+  'db/arena_wrapped_db_iter.h': lines(
+    '#include "include/rocksdb/iterator.h"',
+    'namespace rocksdb {',
+    'class ArenaWrappedDBIter : public Iterator {',
+    ' public:',
+    '  bool Valid() const override { return true; }',
+    '  void Next() override {}',
+    '  int value() const override { return 0; }',
+    '};',
+    '}  // namespace rocksdb',
+  ),
+  'include/rocksdb/db.h': lines(
+    '#include "include/rocksdb/iterator.h"',
+    'namespace rocksdb {',
+    'class DB {',
+    ' public:',
+    '  virtual int Get(int key) = 0;',
+    '  virtual Iterator* NewIterator() = 0;',
+    '};',
+    'class DBGetBatch {',
+    ' public:',
+    '  int Get(int key) { return key; }',
+    '};',
+    '}  // namespace rocksdb',
+  ),
+};
+
+describe('a `->` call on a standard smart pointer or optional reaches the type it holds', () => {
+  it('reproduction: `std::unique_ptr<Iterator> iter; iter->Valid()` is the Iterator the scope sees, not a namesake', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      'db/db_impl.cc': lines(
+        '#include <memory>',
+        '#include "include/rocksdb/db.h"',
+        '#include "db/arena_wrapped_db_iter.h"',
+        'namespace rocksdb {',
+        'int CountKeys(DB* db) {',
+        '  std::unique_ptr<Iterator> iter(db->NewIterator());',
+        '  int n = 0;',
+        '  for (; iter->Valid(); iter->Next()) n += iter->value();',
+        '  return n;',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      // `Valid` and `Next` are IteratorBase's, which Iterator derives from.
+      expect(calls(cg, 'rocksdb::CountKeys')).toEqual([
+        'rocksdb::DB::NewIterator',
+        'rocksdb::Iterator::value',
+        'rocksdb::IteratorBase::Next',
+        'rocksdb::IteratorBase::Valid',
+      ]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('`std::shared_ptr`, `std::optional`, a parameter, and a member the class declares in its header', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      // Classes the receivers' names point a guess at.
+      'table/table_db.h': lines(
+        'namespace rocksdb {',
+        'class TableDB {',
+        ' public:',
+        '  int Get(int key) { return key; }',
+        '};',
+        'class CuckooTableDB {',
+        ' public:',
+        '  int Get(int key) { return key; }',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+      'db/db_impl.h': lines(
+        '#include <memory>',
+        '#include "include/rocksdb/db.h"',
+        'namespace rocksdb {',
+        'class DBImpl {',
+        ' public:',
+        '  int Lookup(int key);',
+        ' private:',
+        '  std::shared_ptr<DB> table_db_;',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+      'db/db_impl.cc': lines(
+        '#include <optional>',
+        '#include "db/db_impl.h"',
+        '#include "table/table_db.h"',
+        'namespace rocksdb {',
+        'int DBImpl::Lookup(int key) {',
+        '  return table_db_->Get(key);',
+        '}',
+        'int Probe(const std::shared_ptr<DB>& cuckoo_db) {',
+        '  std::optional<DBGetBatch> batch;',
+        '  return cuckoo_db->Get(1) + batch->Get(2);',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::DBImpl::Lookup')).toEqual(['rocksdb::DB::Get']);
+      expect(calls(cg, 'rocksdb::Probe')).toEqual(['rocksdb::DB::Get', 'rocksdb::DBGetBatch::Get']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a nested class is found first from inside the class that declares it', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      'memtable/skiplistrep.cc': lines(
+        '#include <memory>',
+        '#include "include/rocksdb/iterator.h"',
+        '#include "include/rocksdb/memtablerep.h"',
+        'namespace rocksdb {',
+        'class SkipListRep : public MemTableRep {',
+        ' public:',
+        '  bool Check();',
+        ' private:',
+        '  std::unique_ptr<Iterator> iter_;',
+        '};',
+        'bool SkipListRep::Check() { return iter_->Valid(); }',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      // MemTableRep's own `Iterator`, which SkipListRep inherits, hides rocksdb::Iterator.
+      expect(calls(cg, 'rocksdb::SkipListRep::Check')).toEqual(['rocksdb::MemTableRep::Iterator::Valid']);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a held type named through an alias, a `using namespace`, and a class local to the function', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      'table/internal_iterator.h': lines(
+        'namespace rocksdb {',
+        'template <class TValue>',
+        'class InternalIteratorBase {',
+        ' public:',
+        '  virtual void SeekToFirst() = 0;',
+        '};',
+        'using InternalIterator = InternalIteratorBase<int>;',
+        'class MergingIterator : public InternalIterator {',
+        ' public:',
+        '  void SeekToFirst() override {}',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+      'table/scan.cc': lines(
+        '#include <memory>',
+        '#include "table/internal_iterator.h"',
+        'namespace rocksdb {',
+        'void ScanTable(InternalIterator* raw) {',
+        '  std::unique_ptr<InternalIterator> it(raw);',
+        '  it->SeekToFirst();',
+        '}',
+        'class EventListener {',
+        ' public:',
+        '  void OnFlushCompleted() {}',
+        '};',
+        'void Notify() {',
+        '  class FlushListener {',
+        '   public:',
+        '    void OnFlushCompleted() {}',
+        '  };',
+        '  std::shared_ptr<FlushListener> listener;',
+        '  listener->OnFlushCompleted();',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+      'tools/dump.cc': lines(
+        '#include <memory>',
+        '#include "include/rocksdb/db.h"',
+        '#include "include/rocksdb/memtablerep.h"',
+        'using namespace rocksdb;',
+        'int Dump(DB* db) {',
+        '  std::unique_ptr<Iterator> it(db->NewIterator());',
+        '  return it->Valid() ? 1 : 0;',
+        '}',
+      ),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::ScanTable')).toEqual(['rocksdb::InternalIteratorBase::SeekToFirst']);
+      expect(calls(cg, 'rocksdb::Notify')).toEqual(['rocksdb::Notify::FlushListener::OnFlushCompleted']);
+      expect(calls(cg, 'Dump')).toEqual(['rocksdb::DB::NewIterator', 'rocksdb::IteratorBase::Valid']);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('a held type that is no class of the project\'s gets no guess', () => {
+  it('a template parameter, a library type, and an alias of one', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      'table/block.h': lines(
+        'namespace rocksdb {',
+        'class Block {',
+        ' public:',
+        '  unsigned size() const { return 0; }',
+        '  int front() const { return 0; }',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+      'db_stress_tool/stress.cc': lines(
+        '#include <deque>',
+        '#include <memory>',
+        '#include <vector>',
+        '#include "db/arena_wrapped_db_iter.h"',
+        '#include "table/block.h"',
+        'namespace rocksdb {',
+        'template <class IterType>',
+        'void TestIterate(IterType* raw) {',
+        '  std::unique_ptr<IterType> iter(raw);',
+        '  iter->Next();',
+        '}',
+        'using BlockList = std::vector<int>;',
+        'class BlockBasedTableIterator {',
+        ' public:',
+        '  int First();',
+        ' private:',
+        '  std::unique_ptr<std::deque<int>> block_handles_;',
+        '  std::shared_ptr<BlockList> block_list_;',
+        '};',
+        'int BlockBasedTableIterator::First() {',
+        '  return block_handles_->front() + static_cast<int>(block_list_->size());',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      // Not ArenaWrappedDBIter::Next, Block::front or Block::size.
+      expect(calls(cg, 'rocksdb::TestIterate')).toEqual([]);
+      expect(calls(cg, 'rocksdb::BlockBasedTableIterator::First')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('a class that has no such method, nor does any class it derives from', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      'db/compaction.cc': lines(
+        '#include <memory>',
+        '#include "include/rocksdb/db.h"',
+        '#include "db/arena_wrapped_db_iter.h"',
+        'namespace rocksdb {',
+        'class CompactionIterator {',
+        ' public:',
+        '  void Release() {}',
+        '};',
+        'void Compact(DB* raw) {',
+        '  std::unique_ptr<DB> db(raw);',
+        '  db->Release();',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::Compact')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
+
+describe('what keeps the call as it was', () => {
+  it('a type the project does not declare, such as a generated message, and a class template\'s specialization', async () => {
+    // protocolbuffers/protobuf's tests hold generated messages, which derive
+    // from Message; facebook/rocksdb's order-maintenance tree has members only
+    // a specialization declares.
+    const cg = await indexed({
+      'src/google/protobuf/message.h': lines(
+        'namespace google {',
+        'namespace protobuf {',
+        'class Message {',
+        ' public:',
+        '  unsigned SpaceUsedLong() const { return 0; }',
+        '};',
+        '}  // namespace protobuf',
+        '}  // namespace google',
+      ),
+      'src/google/protobuf/extension_set_unittest.cc': lines(
+        '#include <memory>',
+        '#include "src/google/protobuf/message.h"',
+        'namespace google {',
+        'namespace protobuf {',
+        'unsigned SpaceUsed() {',
+        '  std::unique_ptr<unittest::TestAllExtensions> message;',
+        '  return message->SpaceUsedLong();',
+        '}',
+        '}  // namespace protobuf',
+        '}  // namespace google',
+      ),
+      'util/omt.h': lines(
+        '#include <memory>',
+        'namespace toku {',
+        'template <typename omtdata_t, bool marks>',
+        'class omt_node {',
+        ' public:',
+        '  void clear_stolen_bits() {}',
+        '};',
+        'template <typename omtdata_t>',
+        'class omt_node<omtdata_t, true> {',
+        ' public:',
+        '  bool get_marked() const { return false; }',
+        '};',
+        'bool HasMarks() {',
+        '  std::unique_ptr<omt_node<int, true>> node;',
+        '  return node->get_marked();',
+        '}',
+        '}  // namespace toku',
+      ),
+    });
+    try {
+      // The fork's resolver guesses no callee by the receiver's name when the
+      // receiver's declared type is one the project doesn't declare (a plain
+      // `unittest::TestAllExtensions* message` gets none either), so the held
+      // type's call stays as unresolved as the pointer's.
+      expect(calls(cg, 'google::protobuf::SpaceUsed')).toEqual([]);
+      // A partial specialization is extracted as an anonymous class here, so its
+      // `get_marked` is not a member of `omt_node` and the call stays unresolved;
+      // what matters is that it does not reach `omt_node`'s other methods.
+      expect(cg.getCallees(callable(cg, 'toku::HasMarks').id).filter((r) => r.edge.kind === 'calls').map((r) => r.node.name)).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('`->` through a raw pointer to a smart pointer is the smart pointer\'s own member', async () => {
+    const cg = await indexed({
+      ...ROCKSDB,
+      'cache/cache.h': lines(
+        'namespace rocksdb {',
+        'class Cache {',
+        ' public:',
+        '  void reset() {}',
+        '};',
+        '}  // namespace rocksdb',
+      ),
+      'db/version_set.cc': lines(
+        '#include <memory>',
+        '#include "include/rocksdb/iterator.h"',
+        '#include "cache/cache.h"',
+        'namespace rocksdb {',
+        'void Drop(std::unique_ptr<Iterator>* iter_cache) {',
+        '  iter_cache->reset();',
+        '}',
+        '}  // namespace rocksdb',
+      ),
+    });
+    try {
+      expect(calls(cg, 'rocksdb::Drop')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  });
+});
diff --git a/__tests__/default-export-declaration.test.ts b/__tests__/default-export-declaration.test.ts
new file mode 100644
index 000000000..ab39db1c2
--- /dev/null
+++ b/__tests__/default-export-declaration.test.ts
@@ -0,0 +1,274 @@
+/**
+ * A default import is the declaration the module's `export default` statement
+ * names, wherever it sits in the file — not the first exported function.
+ *
+ * A React Router 6.4+ data-router page exports its loader or action above the
+ * page component (`export function loader() {…}` then `export default function
+ * Vans() {…}`), and `import Vans, { loader as vansLoader } from './Vans'` bound
+ * `Vans` to `loader`: the route `/vans` rendered the loader, and every call
+ * through the default import went there too. A component file that exports a
+ * styled or memo component lost its default function or binding to that
+ * component, and an anonymous default (`export default function () {…}`,
+ * `export default () => …`) took whatever exported function came first — even
+ * one nested inside the default itself.
+ */
+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;
+
+const files: Record<string, string> = {
+  'package.json': JSON.stringify({ name: 'vanlife', private: true, dependencies: { react: '^18', 'react-router-dom': '^6.4' } }),
+  'src/index.jsx': `import { RouterProvider, createBrowserRouter, createRoutesFromElements, Route } from "react-router-dom"
+import Vans, { loader as vansLoader } from "./pages/Vans/Vans"
+import HostVans, { loader as hostVansLoader } from "./pages/Host/HostVans"
+import Login, { action as loginAction } from "./pages/Login"
+
+const router = createBrowserRouter(createRoutesFromElements(
+  <Route path="/">
+    <Route path="login" element={<Login />} action={loginAction} />
+    <Route path="vans" element={<Vans />} loader={vansLoader} />
+    <Route path="host/vans" element={<HostVans />} loader={hostVansLoader} />
+  </Route>
+))
+
+export default function App() {
+  return <RouterProvider router={router} />
+}
+`,
+  'src/api.js': `export function getVans() {
+  return fetch("/api/vans")
+}
+`,
+  'src/pages/Vans/Vans.jsx': `import { useLoaderData, defer } from "react-router-dom"
+import { getVans } from "../../api"
+
+export function loader() {
+  return defer({ vans: getVans() })
+}
+
+export default function Vans() {
+  const dataPromise = useLoaderData()
+  function renderVanElements(vans) {
+    return vans.map((van) => <h3 key={van.id}>{van.name}</h3>)
+  }
+  return <div>{renderVanElements(dataPromise.vans)}</div>
+}
+`,
+  'src/pages/Host/HostVans.jsx': `import { useLoaderData } from "react-router-dom"
+import { getVans } from "../../api"
+
+export const loader = async () => getVans()
+
+export default function HostVans() {
+  return <ul>{useLoaderData().length}</ul>
+}
+`,
+  'src/pages/Login.jsx': `import { useActionData } from "react-router-dom"
+
+export async function action({ request }) {
+  return request.formData()
+}
+
+export default function Login() {
+  const data = useActionData()
+  return <form>{data}</form>
+}
+`,
+  // A Next.js API route: a helper exported above the default handler.
+  'src/api/vans.ts': `export function listVans() {
+  return []
+}
+
+export default async function handler(req: unknown, res: { json(v: unknown): void }) {
+  res.json(listVans())
+}
+`,
+  'src/store.ts': `export function createStore() {
+  return {}
+}
+
+export default class Store {
+  read() {
+    return 1
+  }
+}
+`,
+  // A regex with a backtick inside a template literal's interpolation
+  // (outline's headingToSlug): a string masker loses step there and blanked
+  // the statement below it.
+  'src/slug.ts': `export function escapeHtml(text: string) {
+  return text
+}
+
+function safeSlugify(text: string) {
+  return \`h-\${escapeHtml(text).replace(/[\`]/g, "")}\`
+}
+
+export default function headingToSlug(text: string, index = 0) {
+  return index === 0 ? safeSlugify(text) : \`\${safeSlugify(text)}-\${index}\`
+}
+`,
+  // A line break between the statement and the declaration it writes.
+  'src/stream.js': `export function emit() {
+  return 1
+}
+
+export default
+function* stream() {
+  yield emit()
+}
+`,
+  // An exported styled component above the default function, or the binding.
+  'src/components/Title.tsx': `import styled from "styled-components"
+
+export const Heading = styled.h1\`
+  font-size: 2rem;
+\`
+
+export default function Title() {
+  return <Heading>Vans</Heading>
+}
+`,
+  'src/components/Banner.tsx': `import styled from "styled-components"
+
+export const Strip = styled.div\`
+  display: flex;
+\`
+
+const Banner = () => <Strip />
+
+export default Banner
+`,
+  // Anonymous defaults name no declaration of their own.
+  'src/anonymous.js': `export function helper() {
+  return 1
+}
+
+export default function () {
+  function inner() {
+    return helper()
+  }
+  return inner()
+}
+`,
+  'src/arrow.jsx': `export function useThing() {
+  return 1
+}
+
+export default () => {
+  const handle = () => useThing()
+  return <button onClick={handle} />
+}
+`,
+  // An expression default keeps the class it instantiates.
+  'src/service.ts': `export class Service {
+  run() {
+    return 1
+  }
+}
+
+export default new Service()
+`,
+  'src/use.tsx': `import handler from "./api/vans"
+import Store from "./store"
+import headingToSlug from "./slug"
+import stream from "./stream"
+import Title from "./components/Title"
+import Banner from "./components/Banner"
+import runAnonymous from "./anonymous"
+import Arrow from "./arrow"
+import service from "./service"
+
+export function consume() {
+  handler({}, { json() {} })
+  new Store().read()
+  headingToSlug("Vans")
+  stream()
+  Title()
+  Banner()
+  runAnonymous()
+  Arrow()
+  service.run()
+}
+`,
+};
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-default-export-'));
+  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:name` of every node `consume` calls or instantiates. */
+function consumed(): string[] {
+  const consume = cg.getNodesInFile('src/use.tsx').find((n) => n.name === 'consume')!;
+  return cg
+    .getOutgoingEdges(consume.id)
+    .filter((e) => e.kind === 'calls' || e.kind === 'instantiates')
+    .map((e) => cg.getNode(e.target)!)
+    .map((n) => `${n.filePath}:${n.name}`)
+    .sort();
+}
+
+describe('a default import of a module that exports something above its default', () => {
+  it('binds each data-router route to the page component, not its loader or action', () => {
+    const bindings = cg
+      .getNodesByKind('route')
+      .flatMap((r) =>
+        cg
+          .getOutgoingEdges(r.id)
+          .filter((e) => e.kind === 'references')
+          .map((e) => `${r.name} -> ${cg.getNode(e.target)!.filePath}:${cg.getNode(e.target)!.name}`)
+      )
+      .sort();
+    expect(bindings).toEqual([
+      '/host/vans -> src/pages/Host/HostVans.jsx:HostVans',
+      '/login -> src/pages/Login.jsx:Login',
+      '/vans -> src/pages/Vans/Vans.jsx:Vans',
+    ]);
+  });
+
+  it('calls the default-exported function or class the statement declares', () => {
+    const targets = consumed();
+    expect(targets).toContain('src/api/vans.ts:handler');
+    expect(targets).toContain('src/store.ts:Store');
+    expect(targets).toContain('src/slug.ts:headingToSlug');
+    expect(targets).toContain('src/stream.js:stream');
+    expect(targets).not.toContain('src/api/vans.ts:listVans');
+    expect(targets).not.toContain('src/store.ts:createStore');
+    expect(targets).not.toContain('src/slug.ts:escapeHtml');
+    expect(targets).not.toContain('src/stream.js:emit');
+  });
+
+  it('prefers what the statement exports to an exported component above it', () => {
+    const targets = consumed();
+    expect(targets).toContain('src/components/Title.tsx:Title');
+    expect(targets).toContain('src/components/Banner.tsx:Banner');
+    expect(targets).not.toContain('src/components/Title.tsx:Heading');
+    expect(targets).not.toContain('src/components/Banner.tsx:Strip');
+  });
+
+  it('binds an anonymous default to nothing, not to an exported function beside or inside it', () => {
+    const targets = consumed();
+    for (const wrong of ['src/anonymous.js:helper', 'src/anonymous.js:inner', 'src/arrow.jsx:useThing', 'src/arrow.jsx:handle']) {
+      expect(targets).not.toContain(wrong);
+    }
+  });
+
+  it('still finds the class behind an expression default', () => {
+    expect(consumed()).toContain('src/service.ts:run');
+  });
+});
diff --git a/__tests__/sync-lazy-route-value.test.ts b/__tests__/sync-lazy-route-value.test.ts
new file mode 100644
index 000000000..1bf620473
--- /dev/null
+++ b/__tests__/sync-lazy-route-value.test.ts
@@ -0,0 +1,347 @@
+/**
+ * A sync redraws what a route renders when the module behind it changes.
+ *
+ * A route that renders a value its own file declares —
+ * `const Docs = lazy(() => import('./pages/Docs'))` and `<Route path="/docs"
+ * element={<Docs />} />` — binds to the component that module exports, and to
+ * the declaration while the module is missing or exports none (#2400). The
+ * reference resolved either way, so nothing parked it for the failed-ref
+ * retry, and the rebind of the names a sync adds (CG-33) only reaches it when
+ * the module's component is named like the declaration. So a module added,
+ * given its default export, or switched to another component after the router
+ * was indexed left the route on its old answer until the router file changed.
+ *
+ * The other half is the JSX a component renders: `<Team />` links to the
+ * `Team` a sync adds only if the sync redraws the synthesized edges, and the
+ * file a component is added in decided that alone, by its own markup. A
+ * component without any (`return null`, a wrapper) passed none of those
+ * checks.
+ *
+ * Every case compares the synced graph with a fresh index of the same files
+ * in a folder of its own: indexing again over an existing index skips its
+ * unchanged files, so it is no stand-in for one.
+ */
+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 { ReferenceResolver } from '../src/resolution';
+
+type Files = Record<string, string | null>;
+
+const pkg = JSON.stringify({ name: 'app', dependencies: { react: '^18', 'react-router-dom': '^6' } });
+const page = (name: string, exported = 'export default') => `${exported} function ${name}() { return null; }\n`;
+
+/** The router of the report: two pages it loads lazily into values of its own. */
+const APP = `import { lazy } from 'react';
+import { BrowserRouter, Routes, Route } from 'react-router-dom';
+const Team = lazy(() => import('./pages/Team'));
+const Docs = lazy(() => import('./pages/Docs'));
+export function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/team" element={<Team />} />
+        <Route path="/docs" element={<Docs />} />
+      </Routes>
+    </BrowserRouter>
+  );
+}
+`;
+
+let root: string | undefined;
+let cg: CodeGraph | undefined;
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  cg?.close();
+  cg = 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)) {
+    const full = path.join(dir, file);
+    if (text === null) {
+      fs.rmSync(full, { force: true });
+      continue;
+    }
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, text);
+  }
+}
+
+/** Every node and edge by natural key, edge metadata included, so two indexes of the same files compare directly. */
+function graphOf(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)
+  );
+  const edges = graph.getOutgoingEdgesFrom([...keys.keys()]).map((e) =>
+    `${keys.get(e.source)} -${e.kind}-> ${keys.get(e.target) ?? e.target} ${JSON.stringify(e.metadata ?? null)} @${e.line ?? ''}:${e.column ?? ''}`);
+  return [...[...keys.values()].map((k) => `node ${k}`), ...edges].sort();
+}
+
+/** What each route renders: `<target file>::<target name>`, a layout marked. */
+function routeLinks(graph: CodeGraph): Record<string, string[]> {
+  const links: Record<string, string[]> = {};
+  for (const route of graph.getNodesByKind('route')) {
+    links[route.name] = [
+      ...(links[route.name] ?? []),
+      ...graph.getOutgoingEdges(route.id)
+        .filter((e) => e.kind !== 'contains')
+        .map((e) => {
+          const target = graph.getNode(e.target);
+          return `${e.metadata?.layout ? 'layout ' : ''}${target?.filePath}::${target?.name}`;
+        }),
+    ].sort();
+  }
+  return links;
+}
+
+/** `<parent> -> <child>` for every JSX render edge. */
+function renders(graph: CodeGraph): string[] {
+  const out: string[] = [];
+  for (const file of graph.getFiles()) {
+    for (const node of graph.getNodesInFile(file.path)) {
+      for (const e of graph.getOutgoingEdges(node.id)) {
+        if (e.metadata?.synthesizedBy !== 'jsx-render') continue;
+        const child = graph.getNode(e.target);
+        out.push(`${node.name} -> ${child?.filePath}::${child?.name}`);
+      }
+    }
+  }
+  return out.sort();
+}
+
+/** The graph of a fresh index of `files`, in a folder of its own. */
+async function freshGraph(files: Files): Promise<string[]> {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-lazy-route-fresh-'));
+  try {
+    write(dir, Object.fromEntries(Object.entries(files).filter(([, text]) => text !== null)));
+    const fresh = await CodeGraph.init(dir, { index: true });
+    try {
+      return graphOf(fresh);
+    } finally {
+      fresh.close();
+    }
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Index `initial`, then write each step and sync after it — with `scoped`, a
+ * sync of only the step's files, as the file watcher runs it. Returns the
+ * final files.
+ */
+async function indexThenSync(initial: Files, ...steps: Files[]): Promise<Files> {
+  return indexThenSyncWith({ scoped: false }, initial, ...steps);
+}
+
+async function indexThenSyncWith(opts: { scoped: boolean }, initial: Files, ...steps: Files[]): Promise<Files> {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-lazy-route-'));
+  write(root, initial);
+  cg = await CodeGraph.init(root, { index: true });
+  const files = { ...initial };
+  for (const step of steps) {
+    write(root, step);
+    Object.assign(files, step);
+    await cg.sync(opts.scoped ? { paths: Object.keys(step) } : {});
+  }
+  return files;
+}
+
+describe('sync redraws a route that renders a same-file lazy value when its module changes', () => {
+  it.each([false, true])('when the modules are added after the router (scoped=%s)', async (scoped) => {
+    const files = await indexThenSyncWith(
+      { scoped },
+      { 'package.json': pkg, 'src/App.tsx': APP },
+      { 'src/pages/Team.tsx': page('Team'), 'src/pages/Docs.tsx': page('DocsPage') }
+    );
+    expect(routeLinks(cg!)).toEqual({
+      '/team': ['src/pages/Team.tsx::Team'],
+      // The page's component is named unlike the declaration, so only the
+      // module it loads leads to it.
+      '/docs': ['src/pages/Docs.tsx::DocsPage'],
+    });
+    expect(renders(cg!)).toEqual(['App -> src/pages/Team.tsx::Team']);
+    expect(cg!.getPendingReferenceCount()).toBe(0);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('when an edit gives the module its default export', async () => {
+    const files = await indexThenSync(
+      { 'package.json': pkg, 'src/App.tsx': APP, 'src/pages/Team.tsx': page('Team'), 'src/pages/Docs.tsx': page('DocsPage', 'export') },
+      // No name appears or goes: only the export changes.
+      { 'src/pages/Docs.tsx': `${page('DocsPage', 'export')}export default DocsPage;\n` }
+    );
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs.tsx::DocsPage']);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('when the module’s default export moves to another component', async () => {
+    const files = await indexThenSync(
+      { 'package.json': pkg, 'src/App.tsx': APP, 'src/pages/Team.tsx': page('Team'), 'src/pages/Docs.tsx': page('DocsPage') },
+      // The old component stays, so the route's edge follows it through the re-index.
+      { 'src/pages/Docs.tsx': `${page('DocsPage', 'export')}${page('Documentation')}` }
+    );
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs.tsx::Documentation']);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('when deleted modules come back', async () => {
+    const pages = { 'src/pages/Team.tsx': page('Team'), 'src/pages/Docs.tsx': page('DocsPage') };
+    const files = await indexThenSync(
+      { 'package.json': pkg, 'src/App.tsx': APP, ...pages },
+      { 'src/pages/Team.tsx': null, 'src/pages/Docs.tsx': null }
+    );
+    // While they are gone, each route is the declaration it renders.
+    expect(routeLinks(cg!)).toEqual({ '/team': ['src/App.tsx::Team'], '/docs': ['src/App.tsx::Docs'] });
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+
+    write(root!, pages);
+    await cg!.sync();
+    expect(routeLinks(cg!)).toEqual({ '/team': ['src/pages/Team.tsx::Team'], '/docs': ['src/pages/Docs.tsx::DocsPage'] });
+    expect(graphOf(cg!)).toEqual(await freshGraph({ ...files, ...pages }));
+  }, 60_000);
+
+  it('when the barrel itself is edited to forward another page', async () => {
+    const files = await indexThenSync(
+      {
+        'package.json': pkg,
+        'src/App.tsx': APP,
+        'src/pages/Team.tsx': page('Team'),
+        'src/pages/Docs/index.ts': "export { default } from './DocsPage';\n",
+        'src/pages/Docs/DocsPage.tsx': page('DocsPage'),
+      },
+      { 'src/pages/Docs/Other.tsx': page('OtherPage') }
+    );
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs/DocsPage.tsx::DocsPage']);
+    const edit = { 'src/pages/Docs/index.ts': "export { default } from './Other';\n" };
+    write(root!, edit);
+    await cg!.sync();
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs/Other.tsx::OtherPage']);
+    expect(graphOf(cg!)).toEqual(await freshGraph({ ...files, ...edit }));
+  }, 60_000);
+
+  it('when the page behind a barrel is added, then switches its default export', async () => {
+    const files = await indexThenSync(
+      {
+        'package.json': pkg,
+        'src/App.tsx': APP,
+        'src/pages/Team.tsx': page('Team'),
+        // `./pages/Docs` is a barrel; the page it forwards comes later.
+        'src/pages/Docs/index.ts': "export { default } from './DocsPage';\n",
+      },
+      { 'src/pages/Docs/DocsPage.tsx': page('DocsPage') }
+    );
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs/DocsPage.tsx::DocsPage']);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+
+    // The barrel is unchanged; only the page behind it moves its default export.
+    const edit = { 'src/pages/Docs/DocsPage.tsx': `${page('DocsPage', 'export')}${page('Documentation')}` };
+    write(root!, edit);
+    await cg!.sync();
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs/DocsPage.tsx::Documentation']);
+    expect(graphOf(cg!)).toEqual(await freshGraph({ ...files, ...edit }));
+  }, 60_000);
+
+  it('in a route table another file hands the router (codedthemes’ admin templates)', async () => {
+    const files = await indexThenSync(
+      {
+        'package.json': JSON.stringify({ name: 'berry', dependencies: { react: '^18', 'react-router-dom': '^7' } }),
+        'src/routes/index.jsx': "import { createBrowserRouter } from 'react-router-dom';\nimport MainRoutes from './MainRoutes';\n\nconst router = createBrowserRouter([MainRoutes]);\n\nexport default router;\n",
+        '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/dashboard/Default')));
+
+const MainRoutes = {
+  path: '/',
+  element: <MainLayout />,
+  children: [{ path: 'dashboard/default', element: <DashboardDefault /> }]
+};
+
+export default MainRoutes;
+`,
+        'src/layout/MainLayout.jsx': 'export default function MainLayout() {\n  return <main />;\n}\n',
+        'src/ui-component/Loadable.jsx': 'export default function Loadable(Component) {\n  return (props) => <Component {...props} />;\n}\n',
+      },
+      { 'src/views/dashboard/Default.jsx': page('DashboardDefaultPage') }
+    );
+    expect(routeLinks(cg!)['/dashboard/default']).toEqual([
+      'layout src/layout/MainLayout.jsx::MainLayout',
+      'src/views/dashboard/Default.jsx::DashboardDefaultPage',
+    ]);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('for a data router’s lazy route whose module switches its default export', async () => {
+    const files = await indexThenSync(
+      {
+        'package.json': pkg,
+        'src/router.tsx': "import { createBrowserRouter } from 'react-router-dom';\nexport const router = createBrowserRouter([{ path: '/docs', lazy: () => import('./pages/Docs') }]);\n",
+        'src/pages/Docs.tsx': page('DocsPage'),
+      },
+      { 'src/pages/Docs.tsx': `${page('DocsPage', 'export')}${page('Documentation')}` }
+    );
+    expect(routeLinks(cg!)['/docs']).toEqual(['src/pages/Docs.tsx::Documentation']);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('and re-opens nothing for a module no route loads', async () => {
+    await indexThenSync({ 'package.json': pkg, 'src/App.tsx': APP, 'src/pages/Team.tsx': page('Team'), 'src/pages/Docs.tsx': page('DocsPage') });
+    const reopen = vi.spyOn(ReferenceResolver.prototype, 'reopenRouteModuleReaders');
+    write(root!, { 'src/util.ts': 'export function slug(s: string) { return s.toLowerCase(); }\n' });
+    await cg!.sync();
+    expect(reopen).toHaveBeenCalledTimes(1);
+    expect(reopen.mock.results[0]!.value).toBe(0);
+
+    // The router's own edit resolves its references itself.
+    write(root!, { 'src/App.tsx': APP.replace('/docs', '/documentation'), 'src/pages/Docs.tsx': page('Documentation') });
+    await cg!.sync();
+    expect(reopen.mock.results[1]!.value).toBe(0);
+    expect(routeLinks(cg!)['/documentation']).toEqual(['src/pages/Docs.tsx::Documentation']);
+  }, 60_000);
+});
+
+describe('sync draws the JSX edges to a component it adds', () => {
+  it('when another file imports and renders it', async () => {
+    const files = await indexThenSync(
+      { 'package.json': pkg, 'src/Shell.tsx': "import Team from './Team';\nexport function Shell() {\n  return <main><Team /></main>;\n}\n" },
+      // A component without markup of its own.
+      { 'src/Team.tsx': page('Team') }
+    );
+    expect(renders(cg!)).toEqual(['Shell -> src/Team.tsx::Team']);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('when another file renders it by name alone', async () => {
+    const files = await indexThenSync(
+      { 'package.json': pkg, 'src/Shell.tsx': 'export function Shell() {\n  return <main><Badge /></main>;\n}\n' },
+      { 'src/Badge.tsx': 'export const Badge = () => null;\n' }
+    );
+    expect(renders(cg!)).toEqual(['Shell -> src/Badge.tsx::Badge']);
+    expect(graphOf(cg!)).toEqual(await freshGraph(files));
+  }, 60_000);
+
+  it('but leaves them alone for a new name no tag can render', async () => {
+    await indexThenSync({
+      'package.json': pkg,
+      'src/Shell.tsx': "import Team from './Team';\nexport function Shell() {\n  return <main><Team /></main>;\n}\n",
+      'src/Team.tsx': page('Team'),
+      'src/limits.ts': 'export function clamp(n: number) { return Math.min(n, 3); }\n',
+    });
+    // A value and a lowercase function: neither is a component. (The fork
+    // refreshes synthesis on every sync that changes files, so no gate skips
+    // the linking phase here; the edges must come back as they were.)
+    write(root!, { 'src/limits.ts': 'export const Limits = { max: 3 };\nexport function clamp(n: number) { return Math.min(n, Limits.max); }\nexport function floor(n: number) { return n; }\n' });
+    await cg!.sync();
+    expect(renders(cg!)).toEqual(['Shell -> src/Team.tsx::Team']);
+  }, 60_000);
+});
diff --git a/__tests__/synthesized-hop.test.ts b/__tests__/synthesized-hop.test.ts
new file mode 100644
index 000000000..22a17ed8b
--- /dev/null
+++ b/__tests__/synthesized-hop.test.ts
@@ -0,0 +1,119 @@
+/**
+ * One wording for a synthesized (dynamic-dispatch) hop, on both surfaces that
+ * print one: codegraph_explore's Flow and the codegraph_node trail
+ * (`dynamic: …`), and ContextBuilder's "## Call paths" (`→[…]`, what
+ * `buildContext` and `codegraph context` print). The call paths used to keep
+ * their own list, and every synthesizer missing from it — interface dispatch,
+ * a C++ override, a redux thunk — read as an "event".
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import CodeGraph from '../src/index';
+import { ToolHandler } from '../src/mcp/tools';
+import { describeSynthesizedHop } from '../src/graph/synthesized-hop';
+import type { Edge } from '../src/types';
+
+describe('an interface-impl hop on both surfaces', () => {
+  const query = 'runExport exportReport renderPdf';
+  let dir: string;
+  let cg: CodeGraph;
+  // Assertions read RAW codegraph_explore output; managed offload would replace it.
+  let prevOffloadDisable: string | undefined;
+
+  beforeAll(async () => {
+    prevOffloadDisable = process.env.CODEGRAPH_OFFLOAD_DISABLE;
+    process.env.CODEGRAPH_OFFLOAD_DISABLE = '1';
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-synth-hop-'));
+    // One file each: ContextBuilder keeps only a few nodes per file, and with
+    // everything in one file the interface method is the node it drops.
+    const files: Record<string, string> = {
+      'src/exporter.ts': `export interface Exporter {
+  exportReport(data: string): string;
+}
+`,
+      'src/pdf-exporter.ts': `import type { Exporter } from './exporter';
+import { renderPdf } from './render';
+
+export class PdfExporter implements Exporter {
+  exportReport(data: string): string {
+    return renderPdf(data);
+  }
+}
+`,
+      'src/render.ts': `export function renderPdf(data: string): string {
+  return '%PDF ' + data;
+}
+`,
+      'src/run.ts': `import type { Exporter } from './exporter';
+
+export function runExport(exporter: Exporter): string {
+  return exporter.exportReport('q3');
+}
+`,
+    };
+    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 = CodeGraph.initSync(dir);
+    await cg.indexAll();
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (dir) fs.rmSync(dir, { recursive: true, force: true });
+    if (prevOffloadDisable === undefined) delete process.env.CODEGRAPH_OFFLOAD_DISABLE;
+    else process.env.CODEGRAPH_OFFLOAD_DISABLE = prevOffloadDisable;
+  });
+
+  it('ContextBuilder call paths label it interface dispatch, not "event"', async () => {
+    // Precondition: the hop is a real synthesized edge, not a static call.
+    const [iface] = cg.getNodesByName('exportReport').filter((n) => n.qualifiedName === 'Exporter::exportReport');
+    expect(cg.getOutgoingEdges(iface!.id).map((e) => e.metadata?.synthesizedBy)).toContain('interface-impl');
+
+    const md = String(await cg.buildContext(query, { format: 'markdown' }));
+    expect(md).toContain('## Call paths');
+    const callPaths = md.slice(md.indexOf('## Call paths'));
+    expect(callPaths).toContain(
+      '- runExport → exportReport →[interface → impl @src/pdf-exporter.ts:5] exportReport → renderPdf'
+    );
+    expect(callPaths).not.toContain('→[event');
+  });
+
+  it('codegraph_explore tags the same hop with the same words', async () => {
+    const res = await new ToolHandler(cg).execute('codegraph_explore', { query });
+    expect(res.content?.[0]?.text).toContain('↓ dynamic: interface → impl @src/pdf-exporter.ts:5');
+  });
+});
+
+describe('describeSynthesizedHop', () => {
+  const at = 'src/wire.ts:7';
+  const edge = (metadata: Record<string, unknown>): Edge =>
+    ({ source: 'a', target: 'b', kind: 'calls', provenance: 'heuristic', metadata: { registeredAt: at, ...metadata } });
+
+  it.each([
+    // Synthesizers the call paths used to call an "event".
+    [{ synthesizedBy: 'interface-impl', via: 'handle' }, 'interface → impl', ''],
+    [{ synthesizedBy: 'interface-impl', via: 'Report', promotedInto: 'scrapeLoop' }, 'interface → method promoted into scrapeLoop', ''],
+    [{ synthesizedBy: 'closure-collection', field: 'validators' }, 'runs `validators` handlers', ''],
+    [{ synthesizedBy: 'cpp-override', via: 'Run' }, 'cpp override', ''],
+    [{ synthesizedBy: 'redux-thunk', via: 'fetchUser' }, 'redux thunk', ''],
+    [{ synthesizedBy: 'gin-middleware-chain', via: 'Auth' }, 'gin middleware chain', ''],
+    [{ synthesizedBy: 'event-bus', channel: 'event', event: 'user.created' }, 'bus event `user.created`', ''],
+    // The detail only the call paths print.
+    [{ synthesizedBy: 'queue-job', event: 'send-email', queue: 'emails' }, 'queue job `send-email`', ' on `emails`'],
+    [{ synthesizedBy: 'event-bus', channel: 'socket', event: 'chat', tier: 'client→server' }, 'socket message `chat`', ' → server'],
+    [{ synthesizedBy: 'http-client', method: 'POST', href: '/api/users' }, 'HTTP POST /api/users', " — the client's call onto its own route"],
+  ])('%o reads "%s"', (metadata, summary, detail) => {
+    expect(describeSynthesizedHop(edge(metadata))).toEqual({ summary, detail, registeredAt: at });
+  });
+
+  it('is null for a static edge and for a heuristic edge no synthesizer made', () => {
+    expect(describeSynthesizedHop({ source: 'a', target: 'b', kind: 'calls', provenance: 'tree-sitter' })).toBeNull();
+    expect(describeSynthesizedHop({ ...edge({ synthesizedBy: 'callback', via: 'on' }), provenance: undefined })).toBeNull();
+    expect(describeSynthesizedHop(edge({ confidence: 0.5 }))).toBeNull();
+    expect(describeSynthesizedHop(null)).toBeNull();
+  });
+});
diff --git a/codegraph-kernel/src/resolve/cpp_receivers.rs b/codegraph-kernel/src/resolve/cpp_receivers.rs
index f2fa65625..8b9f8b6f9 100644
--- a/codegraph-kernel/src/resolve/cpp_receivers.rs
+++ b/codegraph-kernel/src/resolve/cpp_receivers.rs
@@ -59,18 +59,71 @@ impl KernelResolver {
         let ty = match operator.trim() {
             "." if pointers == 0 => raw.trim_end_matches('&').trim().to_string(),
             "->" if pointers == 1 && !raw.contains('<') => raw.replace(['*', '&'], "").trim().to_string(),
+            // A standard smart pointer or optional: `->` reaches a member of the type it holds.
             "->" if pointers == 0 => {
-                let Some(hit) = re!(r"^std::(?:unique_ptr|shared_ptr)\s*<\s*([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)\s*>\s*&?$").captures(&raw) else { return Ok(Some(None)) };
-                hit[1].to_string()
+                let Some(hit) = re!(r"^(?:const\s+)?(?:::)?std::(?:unique_ptr|shared_ptr|optional)\s*<(.*)>\s*&?$").captures(&raw) else { return Ok(Some(None)) };
+                let Some(held) = cpp_held_type(&hit[1]) else { return Ok(None) };
+                if held.trim_start_matches("::").starts_with("std::") { return Ok(Some(None)); }
+                held
             }
             _ => return Ok(Some(None)),
         };
         let primary = ty.split('<').next().unwrap_or(&ty).trim();
         if let Some(caller) = self.node_by_id(&r.from_node_id)? { if self.cpp_template_parameter(&caller, primary, r)? { return Ok(Some(None)); } }
         if self.cpp_alias_expansion(primary, r, 0, &included)?.is_some_and(|alias| alias.pointer) { return Ok(None); }
-        let Some(owner) = self.cpp_type_owner(primary, r, 0, false)? else { return Ok(None) };
+        let held = operator.trim() == "->" && pointers == 0;
+        let mut owner = if held { self.cpp_class_scope_type(primary, r)? } else { None };
+        if owner.is_none() { owner = self.cpp_type_owner(primary, r, 0, false)?; }
+        if owner.is_none() && held {
+            if let Some(parts) = super::cpp_aliases::type_segments(primary) {
+                // A class template and its specializations share a qualified name, and so their members.
+                let family = self.cpp_scoped_types(primary, &parts.join("::"), r, &included)?;
+                if let Some(first) = family.first().filter(|f| family.len() > 1 && family.iter().all(|n| n.qualified_name == f.qualified_name && matches!(n.kind.as_str(), "class" | "struct"))) { owner = Some(first.clone()); }
+                if owner.is_none() { owner = self.cpp_type_via_using(primary, &parts, r, &included)?; }
+            }
+        }
+        let Some(owner) = owner else {
+            // A held type that is an alias of a library type holds no project class.
+            let aliased_library = held && self.cpp_alias_expansion(primary, r, 0, &included)?
+                .is_some_and(|alias| alias.raw.as_deref().is_some_and(|ty| ty.trim_start_matches("::").starts_with("std::")));
+            return Ok(aliased_library.then_some(None));
+        };
         // Preserve the existing guarded alias and specialization fallback on a miss.
-        Ok(self.match_bound_type_member(&owner.qualified_name, method, r)?.map(Some))
+        let member = self.match_bound_type_member(&owner.qualified_name, method, r)?;
+        // A class that lacks the method, and whose bases lack it too, is called nothing
+        // (but a class template's specialization may declare it).
+        if member.is_none() && held && self.supertypes_complete && !self.cpp_alias_template_owner(&owner, r)? { return Ok(Some(None)); }
+        Ok(member.map(Some))
+    }
+
+    /// A class `ty` names from inside a class that declares or inherits it, which
+    /// C++ looks up before the namespaces around: the scopes of the caller, innermost
+    /// first, each with the classes it derives from.
+    fn cpp_class_scope_type(&mut self, ty: &str, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if ty.contains("::") { return Ok(None); }
+        let Some(caller) = self.node_by_id(&r.from_node_id)? else { return Ok(None) };
+        let scopes: Vec<_> = caller.qualified_name.split("::").map(str::to_string).collect();
+        let included = self.namespace_visible_files(&r.file_path, "cpp")?;
+        let is_class = |n: &&Arc<KNode>| matches!(n.language.as_str(), "c" | "cpp") && matches!(n.kind.as_str(), "class" | "struct" | "union") && included.contains(&n.file_path);
+        for i in (1..=scopes.len()).rev() {
+            let enclosing = self.nodes_by_qualified_name(&scopes[..i].join("::"))?;
+            let classes: Vec<_> = enclosing.iter().filter(is_class).cloned().collect();
+            let [class] = classes.as_slice() else { continue };
+            let mut frontier = vec![class.clone()];
+            let mut seen = HashSet::new();
+            for _ in 0..4 {
+                let mut next = Vec::new();
+                for c in frontier {
+                    if !seen.insert(c.id.clone()) { continue; }
+                    let nested = self.nodes_by_qualified_name(&format!("{}::{ty}", c.qualified_name))?;
+                    if let [only] = nested.iter().filter(is_class).cloned().collect::<Vec<_>>().as_slice() { return Ok(Some(only.clone())); }
+                    if self.supertypes_complete { next.extend(self.supertype_nodes(&c.id)?.into_iter().filter(|n| matches!(n.kind.as_str(), "class" | "struct" | "union"))); }
+                }
+                if next.is_empty() { break; }
+                frontier = next;
+            }
+        }
+        Ok(None)
     }
 
     pub(super) fn cpp_complex_call(&mut self, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
@@ -261,6 +314,28 @@ impl KernelResolver {
     }
 }
 
+/// The first template argument of a standard smart pointer or optional, or None when it
+/// is a pointer: `Foo`, `ns::Foo<int, true>`, `const Foo` for `Foo, Deleter`.
+fn cpp_held_type(arguments: &str) -> Option<String> {
+    let mut depth = 0usize;
+    let mut end = arguments.len();
+    for (i, ch) in arguments.char_indices() {
+        match ch {
+            '<' | '(' => depth += 1,
+            '>' | ')' => depth = depth.saturating_sub(1),
+            ',' if depth == 0 => { end = i; break; }
+            _ => (),
+        }
+    }
+    let held = arguments[..end].trim();
+    let held = held.strip_prefix("const ").unwrap_or(held).trim();
+    let mut depth = 0usize;
+    for ch in held.chars() {
+        match ch { '<' => depth += 1, '>' => depth = depth.saturating_sub(1), '*' if depth == 0 => return None, _ => () }
+    }
+    (!held.is_empty()).then(|| held.to_string())
+}
+
 fn cpp_declarator_name<'a>(mut node: tree_sitter::Node, source: &'a SourceFile) -> &'a str {
     while matches!(node.kind(), "reference_declarator" | "pointer_declarator" | "parenthesized_declarator" | "init_declarator") {
         let Some(inner) = node.child_by_field_name("declarator").or_else(|| node.named_child(0)) else { return "" }; node = inner;
diff --git a/codegraph-kernel/src/resolve/cpp_types.rs b/codegraph-kernel/src/resolve/cpp_types.rs
index 63c9980c5..04d53a849 100644
--- a/codegraph-kernel/src/resolve/cpp_types.rs
+++ b/codegraph-kernel/src/resolve/cpp_types.rs
@@ -28,43 +28,7 @@ impl KernelResolver {
         let visible: HashSet<_> = files.iter().filter(|file| **file == r.file_path
             || !re!(r"(?i)\.(?:c|cc|cpp|cxx|c\+\+|cu|metal)$").is_match(file)).cloned().collect();
         let mut target = self.cpp_type_owner_visible(&written, r, 0, false, &visible)?;
-        if target.is_none() {
-            if let Some(lines) = self.read_file(&r.file_path) {
-                let mut directives = Vec::new();
-                if let Some(tree) = self.parsed_tree(&lines, r) {
-                    let mut site = super::iteration::descendant_for_position(tree.root_node(), lines.text(),
-                        ((r.line - 1).max(0) as usize, r.column.max(0) as usize + 1));
-                    let before = site.start_byte();
-                    loop {
-                        if matches!(site.kind(), "translation_unit" | "declaration_list" | "field_declaration_list" | "compound_statement") {
-                            let mut cursor = site.walk();
-                            let mut local: Vec<_> = site.named_children(&mut cursor)
-                                .filter(|n| n.end_byte() <= before && matches!(n.kind(), "using_declaration" | "namespace_alias_definition"))
-                                .map(|n| lines.text()[n.byte_range()].to_string()).collect();
-                            local.reverse();
-                            directives.extend(local);
-                        }
-                        let Some(parent) = site.parent() else { break; };
-                        site = parent;
-                    }
-                }
-                for line in &directives {
-                    let spelled = if let Some(hit) = re!(r"\bnamespace\s+([A-Za-z_]\w*)\s*=\s*((?:::)?[\w:]+)\s*;").captures(line) {
-                        (hit[1] == parts[0]).then(|| format!("{}{}", &hit[2], written.trim_start_matches("::").strip_prefix(&parts[0]).unwrap_or("")))
-                    } else if !written.starts_with("::") {
-                        if let Some(hit) = re!(r"\busing\s+namespace\s+((?:::)?[\w:]+)\s*;").captures(line) {
-                            Some(format!("{}::{written}", &hit[1]))
-                        } else if let Some(hit) = re!(r"\busing\s+((?:::)?[\w:]+)::([A-Za-z_]\w*)\s*;").captures(line) {
-                            (hit[2] == parts[0]).then(|| format!("{}::{written}", &hit[1]))
-                        } else { None }
-                    } else { None };
-                    if let Some(spelled) = spelled {
-                        target = self.cpp_type_owner_visible(&spelled, r, 0, false, &visible)?;
-                        if target.is_some() { break; }
-                    }
-                }
-            }
-        }
+        if target.is_none() { target = self.cpp_type_via_using(&written, &parts, r, &visible)?; }
         let mut confidence = 0.9;
         let mut resolved_by = "qualified-name";
         if target.is_none() {
@@ -83,28 +47,55 @@ impl KernelResolver {
         }
     }
 
-    pub(super) fn cpp_type_owner(&mut self, raw: &str, r: &ResolveRefIn, depth: u32, constructor: bool) -> Res<Option<Arc<KNode>>> {
-        let included = self.namespace_visible_files(&r.file_path, "cpp")?;
-        self.cpp_type_owner_visible(raw, r, depth, constructor, &included)
+    /// The type `written` names through a `using namespace`, `using ns::Name` or
+    /// namespace alias that precedes `r` in an enclosing scope, innermost first.
+    pub(super) fn cpp_type_via_using(&mut self, written: &str, parts: &[String], r: &ResolveRefIn, visible: &HashSet<String>) -> Res<Option<Arc<KNode>>> {
+        let Some(lines) = self.read_file(&r.file_path) else { return Ok(None) };
+        let mut directives = Vec::new();
+        if let Some(tree) = self.parsed_tree(&lines, r) {
+            let mut site = super::iteration::descendant_for_position(tree.root_node(), lines.text(),
+                ((r.line - 1).max(0) as usize, r.column.max(0) as usize + 1));
+            let before = site.start_byte();
+            loop {
+                if matches!(site.kind(), "translation_unit" | "declaration_list" | "field_declaration_list" | "compound_statement") {
+                    let mut cursor = site.walk();
+                    let mut local: Vec<_> = site.named_children(&mut cursor)
+                        .filter(|n| n.end_byte() <= before && matches!(n.kind(), "using_declaration" | "namespace_alias_definition"))
+                        .map(|n| lines.text()[n.byte_range()].to_string()).collect();
+                    local.reverse();
+                    directives.extend(local);
+                }
+                let Some(parent) = site.parent() else { break; };
+                site = parent;
+            }
+        }
+        for line in &directives {
+            let spelled = if let Some(hit) = re!(r"\bnamespace\s+([A-Za-z_]\w*)\s*=\s*((?:::)?[\w:]+)\s*;").captures(line) {
+                (hit[1] == parts[0]).then(|| format!("{}{}", &hit[2], written.trim_start_matches("::").strip_prefix(&parts[0]).unwrap_or("")))
+            } else if !written.starts_with("::") {
+                if let Some(hit) = re!(r"\busing\s+namespace\s+((?:::)?[\w:]+)\s*;").captures(line) {
+                    Some(format!("{}::{written}", &hit[1]))
+                } else if let Some(hit) = re!(r"\busing\s+((?:::)?[\w:]+)::([A-Za-z_]\w*)\s*;").captures(line) {
+                    (hit[2] == parts[0]).then(|| format!("{}::{written}", &hit[1]))
+                } else { None }
+            } else { None };
+            if let Some(spelled) = spelled {
+                let target = self.cpp_type_owner_visible(&spelled, r, 0, false, visible)?;
+                if target.is_some() { return Ok(target); }
+            }
+        }
+        Ok(None)
     }
 
-    pub(super) fn cpp_type_owner_visible(&mut self, raw: &str, r: &ResolveRefIn, depth: u32, constructor: bool, included: &HashSet<String>) -> Res<Option<Arc<KNode>>> {
-        if depth > 4 { return Ok(None); }
-        if let Some(alias) = self.cpp_alias_expansion(raw, r, depth, included)? {
-            if constructor && (alias.pointer || alias.reference) { return Ok(None); }
-            let target = match alias.raw { Some(raw) => self.cpp_type_owner_visible(&raw, &alias.site, depth + 1, constructor, included)?, None => None };
-            if target.is_some() || !is_inheritance_ref(&r.reference_kind) { return Ok(target); }
-            return Ok(self.node_by_id(&alias.site.from_node_id)?.filter(|n| n.kind == "type_alias"));
-        }
-        let normalized = super::cpp_aliases::type_segments(raw).map(|p| p.join("::")).unwrap_or_else(|| raw.to_string());
-        let ty = normalized.trim();
+    /// The visible types `ty` names, found in the scopes around the caller, innermost
+    /// first; the first scope that has any answers, preferring those in the caller's file.
+    pub(super) fn cpp_scoped_types(&mut self, raw: &str, ty: &str, r: &ResolveRefIn, included: &HashSet<String>) -> Res<Vec<Arc<KNode>>> {
         let mut scopes = if raw.starts_with("::") { Vec::new() } else {
             self.node_by_id(&r.from_node_id)?.map(|n| n.qualified_name.split("::").map(str::to_string).collect::<Vec<_>>()).unwrap_or_default()
         };
         if is_inheritance_ref(&r.reference_kind) { scopes.pop(); }
         let mut names: Vec<_> = (1..=scopes.len()).rev().map(|i| format!("{}::{ty}", scopes[..i].join("::"))).collect();
         names.push(ty.to_string());
-        let simple = ty.rsplit("::").next().unwrap_or(ty);
         for name in names {
             let named = self.nodes_by_qualified_name(&name)?;
             let mut visible = Vec::new();
@@ -113,7 +104,29 @@ impl KernelResolver {
             }
             if visible.is_empty() { continue; }
             let local: Vec<_> = visible.iter().filter(|n| n.file_path == r.file_path).cloned().collect();
-            if !local.is_empty() { visible = local; }
+            return Ok(if local.is_empty() { visible } else { local });
+        }
+        Ok(Vec::new())
+    }
+
+    pub(super) fn cpp_type_owner(&mut self, raw: &str, r: &ResolveRefIn, depth: u32, constructor: bool) -> Res<Option<Arc<KNode>>> {
+        let included = self.namespace_visible_files(&r.file_path, "cpp")?;
+        self.cpp_type_owner_visible(raw, r, depth, constructor, &included)
+    }
+
+    pub(super) fn cpp_type_owner_visible(&mut self, raw: &str, r: &ResolveRefIn, depth: u32, constructor: bool, included: &HashSet<String>) -> Res<Option<Arc<KNode>>> {
+        if depth > 4 { return Ok(None); }
+        if let Some(alias) = self.cpp_alias_expansion(raw, r, depth, included)? {
+            if constructor && (alias.pointer || alias.reference) { return Ok(None); }
+            let target = match alias.raw { Some(raw) => self.cpp_type_owner_visible(&raw, &alias.site, depth + 1, constructor, included)?, None => None };
+            if target.is_some() || !is_inheritance_ref(&r.reference_kind) { return Ok(target); }
+            return Ok(self.node_by_id(&alias.site.from_node_id)?.filter(|n| n.kind == "type_alias"));
+        }
+        let normalized = super::cpp_aliases::type_segments(raw).map(|p| p.join("::")).unwrap_or_else(|| raw.to_string());
+        let ty = normalized.trim();
+        let simple = ty.rsplit("::").next().unwrap_or(ty);
+        let visible = self.cpp_scoped_types(raw, ty, r, included)?;
+        if !visible.is_empty() {
             let [owner] = visible.as_slice() else { return Ok(None) };
             return self.cpp_expand_owner(owner, r, depth, constructor, included);
         }
diff --git a/docs/design/framework-coverage.md b/docs/design/framework-coverage.md
index be0c04c27..46526f960 100644
--- a/docs/design/framework-coverage.md
+++ b/docs/design/framework-coverage.md
@@ -462,6 +462,20 @@ Each of these cost real debugging time; they are not hypothetical.
    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.
+17. **A sync revisits a resolved route only by the names it carries.** A route
+   that renders a same-file `const Docs = lazy(() => import('./pages/Docs'))`
+   binds to the component that module exports, and to the declaration while
+   the module is missing or exports none (`declaredComponent`). The reference
+   resolved, so the failed-ref retry never sees it, and the rebind of the
+   names a sync defines (CG-33) reaches it only when the module's component
+   is named like the declaration: on minimal-ui-kit/material-kit-react,
+   `/user` stayed on its `UserPage` declaration after `src/pages/user.tsx`
+   (`Page`) came back. A router whose `resolve()` reads modules' content to
+   answer a route says which ones (`FrameworkResolver.lazyModules`), barrels it
+   follows included, and a sync that adds or edits one of them puts the
+   route's reference back for its resolution sweep. The same holds for the
+   JSX a component renders: a sync that adds a component redraws the
+   `jsx-render` edges, since a tag in a file it never touched may name it.
 
 ---
 
diff --git a/src/codegraph.ts b/src/codegraph.ts
index 824426f78..4dda427a8 100644
--- a/src/codegraph.ts
+++ b/src/codegraph.ts
@@ -1160,6 +1160,18 @@ export class CodeGraph {
           }
         }
 
+        // The same for a route whose answer is read from a module: one that
+        // renders `const Docs = lazy(() => import('./pages/Docs'))` binds to
+        // the component the module exports, so it moves when the module is
+        // added or edited, though no name it carries changes.
+        if (filesChanged && result.changedFilePaths) {
+          const tModules = Date.now();
+          const reopened = this.resolver.reopenRouteModuleReaders(result.changedFilePaths);
+          if (process.env.CODEGRAPH_SYNTH_TIMINGS) {
+            console.error(`[phase-timing] sync-route-modules: ${Date.now() - tModules}ms (${reopened} refs re-opened)`);
+          }
+        }
+
         // Orphan sweep (#1187). A resolution pass that dies mid-run — the #850
         // daemon liveness watchdog's SIGKILL (#1122), Ctrl-C, a crash — leaves
         // the refs it never reached in unresolved_refs, and the git-scoped fast
diff --git a/src/context/index.ts b/src/context/index.ts
index 4263b1abc..332c258d7 100644
--- a/src/context/index.ts
+++ b/src/context/index.ts
@@ -28,6 +28,7 @@ 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';
+import { describeSynthesizedHop } from '../graph/synthesized-hop';
 
 /**
  * Most top-level declarations of one copybook that become entry points — its
@@ -411,31 +412,17 @@ export class ContextBuilder {
     const name = (id: string): string => subgraph.nodes.get(id)?.name ?? id;
 
     // Synthesized (dynamic-dispatch) hops are real `calls` edges but invisible to
-    // static parsing — mark them inline so the agent sees WHERE the callback was
-    // wired up (`registered @file:line`) instead of grepping for it. Keyed by
-    // "source>target".
+    // static parsing — mark them inline so the agent sees WHAT bridged the hop
+    // and WHERE it was wired up (`@file:line`) instead of grepping for it. The
+    // wording is `graph/synthesized-hop.ts`'s, the same explore's Flow uses, plus
+    // the detail this roomier line has space for. Keyed by "source>target".
     const synthByPair = new Map<string, string>();
     for (const e of subgraph.edges) {
-      if (e.kind !== 'calls' || e.provenance !== 'heuristic') continue;
-      const m = e.metadata as Record<string, unknown> | undefined;
-      if (!m?.synthesizedBy) continue;
-      const at = typeof m.registeredAt === 'string' ? ` @${m.registeredAt}` : '';
-      const label = m.synthesizedBy === 'callback'
-        ? `callback via ${m.via ? `\`${String(m.via)}\`` : 'registrar'}${at}`
-        : m.synthesizedBy === 'react-render'
-        ? `React re-render via setState${at}`
-        : m.synthesizedBy === 'jsx-render'
-        ? `renders <${String(m.via || 'child')}>`
-        : m.synthesizedBy === 'vue-handler'
-        ? `Vue @${String(m.event || 'event')} handler`
-        : m.synthesizedBy === 'http-client'
-        ? `HTTP ${String(m.method || 'GET')} ${String(m.href || '')} — the client's call onto its own route${at}`
-        : m.synthesizedBy === 'queue-job'
-        ? `queue job ${m.event ? `\`${String(m.event)}\`` : ''}${m.queue ? ` on \`${String(m.queue)}\`` : ''}${at}`
-        : m.synthesizedBy === 'event-bus' && m.channel === 'socket'
-        ? `socket message ${m.event ? `\`${String(m.event)}\`` : ''}${m.tier === 'client→server' ? ' → server' : m.tier === 'server→client' ? ' → client' : ''}${at}`
-        : `event ${m.event ? `\`${String(m.event)}\`` : ''}${at}`;
-      synthByPair.set(`${e.source}>${e.target}`, label);
+      if (e.kind !== 'calls') continue;
+      const hop = describeSynthesizedHop(e);
+      if (!hop) continue;
+      const at = hop.registeredAt ? ` @${hop.registeredAt}` : '';
+      synthByPair.set(`${e.source}>${e.target}`, `${hop.summary}${hop.detail}${at}`);
     }
     const renderChain = (c: string[]): string => {
       let s = name(c[0]!);
@@ -455,7 +442,7 @@ export class ContextBuilder {
       ...kept.map((c) => `- ${renderChain(c)}`),
       '',
       hasSynth
-        ? '_Hops marked `[callback/event …]` are dynamic dispatch bridged by codegraph (with the registration site); the rest are direct calls. codegraph_node any symbol for its body._'
+        ? '_Hops marked `[…]` are dynamic dispatch bridged by codegraph (with the registration site); the rest are direct calls. codegraph_node any symbol for its body._'
         : '_codegraph_node any symbol above for its source + its own callers/callees._',
     ];
     return '\n' + lines.join('\n') + '\n';
diff --git a/src/db/queries.ts b/src/db/queries.ts
index 2c1104659..f138a4212 100644
--- a/src/db/queries.ts
+++ b/src/db/queries.ts
@@ -4310,6 +4310,46 @@ export class QueryBuilder {
     return out;
   }
 
+  /**
+   * The resolution edges out of route nodes in files other than `filePaths`,
+   * which a change to `filePaths` can move: a route rendering
+   * `const Docs = lazy(() => import('./pages/Docs'))` binds to a value beside
+   * it while that module is missing, to its component once it exists, and to
+   * another component when a barrel the module forwards through is edited, so
+   * the edge's target file says nothing about which change moves it. The
+   * framework's `lazyModules` decides which of them read a changed file. Returned with the route's file and language, which a
+   * resurrection needs, in the order they were written, so references put
+   * back resolve in that order again. Synthesized edges carry no reference to
+   * resurrect and are left out.
+   */
+  getRouteEdgesMovedBy(filePaths: readonly string[]): Array<Edge & {
+    edgeId: number;
+    sourceFilePath: string;
+    sourceLanguage: Language;
+  }> {
+    if (filePaths.length === 0) return [];
+    const files = JSON.stringify(filePaths);
+    const rows = this.db
+      .prepare(
+        `SELECT e.*, src.file_path AS source_file_path, src.language AS source_language
+           FROM nodes src
+           JOIN edges e ON e.source = src.id
+           JOIN nodes tgt ON tgt.id = e.target
+          WHERE src.kind = 'route'
+            AND e.kind != 'contains'
+            AND (e.provenance IS NULL OR e.provenance != 'heuristic')
+            AND src.file_path NOT IN (SELECT value FROM json_each(?))
+          ORDER BY e.id`
+      )
+      .all(files) 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,
+    }));
+  }
+
   /** Delete edges by primary key — the rebind pass's half of a re-resolution. */
   deleteEdgesByIds(edgeIds: number[]): number {
     if (edgeIds.length === 0) return 0;
diff --git a/src/graph/synthesized-hop.ts b/src/graph/synthesized-hop.ts
new file mode 100644
index 000000000..741749c7a
--- /dev/null
+++ b/src/graph/synthesized-hop.ts
@@ -0,0 +1,82 @@
+/**
+ * How a synthesized hop reads — what bridged the call, and where it was wired.
+ *
+ * Static parsing cannot see a handler registered in one place and run in
+ * another, so the resolver synthesizes the `calls` edge across it
+ * (`provenance: 'heuristic'`, `metadata.synthesizedBy`, and usually a
+ * `metadata.registeredAt` wiring site). Whatever prints that hop has to say what
+ * bridged it, or the hop reads as a direct call — or as the wrong mechanism.
+ *
+ * Two surfaces print one. `codegraph_explore` (its Flow section and its
+ * dynamic-dispatch links) and the `codegraph_node` trail tag the hop
+ * `dynamic: callback via \`subscribe\` @src/store.ts:4`; ContextBuilder's
+ * "## Call paths" (`buildContext`, `codegraph context`) writes it inside the
+ * arrow, `→[callback via \`subscribe\` @src/store.ts:4]`. Each used to keep its
+ * own list, and the shorter one called every synthesizer it did not know —
+ * interface dispatch, a C++ override, a redux thunk — an "event". So the
+ * wording lives here once, and each surface renders it.
+ */
+
+import type { Edge } from '../types';
+
+export interface SynthesizedHop {
+  /** What bridged the hop: "callback via `subscribe`", "interface → impl", "redux thunk". */
+  summary: string;
+  /**
+   * What the call-paths rendering adds after the summary — the queue a job runs
+   * on, a socket message's direction, what an HTTP hop is; '' when nothing.
+   */
+  detail: string;
+  /** Where the hop was wired up (`file:line`), when the synthesizer recorded it. */
+  registeredAt?: string;
+}
+
+/**
+ * Describe a synthesized (dynamic-dispatch) edge; null for an ordinary static
+ * one. A synthesizer not named below still reads as dynamic dispatch, by its own
+ * name and with its wiring site — never as a bare call or a borrowed label.
+ */
+export function describeSynthesizedHop(edge: Edge | null | undefined): SynthesizedHop | null {
+  const m = edge?.provenance === 'heuristic' ? (edge.metadata as Record<string, unknown> | undefined) : undefined;
+  const by = m?.synthesizedBy;
+  if (!m || typeof by !== 'string') return null;
+  const registeredAt = typeof m.registeredAt === 'string' ? m.registeredAt : undefined;
+  const hop = (summary: string, detail = ''): SynthesizedHop => ({ summary, detail, registeredAt });
+  const quoted = (value: unknown, otherwise: string): string => (value ? `\`${String(value)}\`` : otherwise);
+  switch (by) {
+    case 'callback':
+      return hop(`callback via ${quoted(m.via, 'a registrar')}`);
+    case 'http-client': {
+      const request = `${String(m.method ?? 'GET')} ${String(m.href ?? '')}`.trim();
+      return hop(`HTTP ${request}`, " — the client's call onto its own route");
+    }
+    case 'queue-job':
+      return hop(`queue job ${quoted(m.event, 'a job')}`, m.queue ? ` on \`${String(m.queue)}\`` : '');
+    case 'event-bus': {
+      const what = m.channel === 'socket' ? 'socket message' : 'bus event';
+      const direction = m.tier === 'client→server' ? ' → server' : m.tier === 'server→client' ? ' → client' : '';
+      return hop(`${what} ${quoted(m.event, 'an event')}`, direction);
+    }
+    case 'event-emitter':
+      return hop(`event ${quoted(m.event, 'an event')}`);
+    case 'react-render':
+      return hop('React re-render via setState');
+    case 'jsx-render':
+      return hop(`renders ${m.via ? `<${String(m.via)}>` : 'a child component'}`);
+    case 'vue-handler':
+      return hop(`Vue ${m.event ? `@${String(m.event)}` : 'a template event'} handler`);
+    case 'interface-impl':
+      // Go: the implementing struct gets the method from a type it embeds.
+      if (typeof m.promotedInto === 'string') return hop(`interface → method promoted into ${m.promotedInto}`);
+      return hop('interface → impl');
+    case 'closure-collection':
+      return hop(`runs ${quoted(m.field, 'a collection')} handlers`);
+    case 'fn-pointer-dispatch':
+      return hop(`fn-pointer ${m.via ? String(m.via) : ''}`);
+    case 'goframe-route':
+      return hop(`GoFrame route ${m.route ? String(m.route) : ''}`);
+    default:
+      // redux-thunk, cpp-override, gin-middleware-chain, flutter-build, …
+      return hop(by.replace(/-/g, ' '));
+  }
+}
diff --git a/src/mcp/tools.ts b/src/mcp/tools.ts
index 99ab9517e..ede3f66d5 100644
--- a/src/mcp/tools.ts
+++ b/src/mcp/tools.ts
@@ -59,6 +59,7 @@ import { findDynamicBoundaries, type BoundarySite } from '../graph/dynamic-bound
 import { countImplementers } from '../graph/type-hierarchy';
 import { isNameGuess } from '../graph/edge-trust';
 import { isDocumentationNode } from '../graph/traversal';
+import { describeSynthesizedHop } from '../graph/synthesized-hop';
 import { isCopybookInclude, MAX_COPYBOOK_INCLUDES, type NamedCopybook } from '../graph/cobol-copybooks';
 import {
   findAllSymbols,
@@ -3639,12 +3640,6 @@ export class ToolHandler {
     return this.answerResult(cg, this.truncateOutput(sections.join('\n') + filterNote), answerPaths);
   }
 
-  /**
-   * Describe a synthesized (dynamic-dispatch) edge for human output: how the
-   * callback was wired up — the bridge static parsing can't see. Returns null
-   * for ordinary static edges. Used by trace + the node trail so a synthesized
-   * hop reads as "registered via onUpdate at App.tsx:3148", not a bare arrow.
-   */
   /**
    * The branch conditions a flow hop's call site runs under, read from the
    * caller's source now (`graph/branch-guards.ts`); '' when unconditional,
@@ -3668,133 +3663,17 @@ export class ToolHandler {
     }
   }
 
-  private synthEdgeNote(edge: Edge | null): { label: string; compact: string; registeredAt?: string } | null {
-    if (!edge || edge.provenance !== 'heuristic') return null;
-    const m = edge.metadata as Record<string, unknown> | undefined;
-    const registeredAt = typeof m?.registeredAt === 'string' ? m.registeredAt : undefined;
-    const at = registeredAt ? ` @${registeredAt}` : '';
-    if (m?.synthesizedBy === 'callback') {
-      const via = m.via ? `\`${String(m.via)}\`` : 'a registrar';
-      const field = m.field ? ` on .${String(m.field)}` : '';
-      return {
-        label: `callback — registered via ${via}${field} (dynamic dispatch)`,
-        compact: `dynamic: callback via ${via}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'http-client') {
-      const req = `${String(m.method ?? 'GET')} ${String(m.href ?? '')}`.trim();
-      return {
-        label: `HTTP request \`${req}\` — the client's call onto its own route (cross-tier)`,
-        compact: `dynamic: HTTP ${req}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'queue-job') {
-      const job = m.event ? `\`${String(m.event)}\`` : 'a job';
-      const queue = m.queue ? ` on queue \`${String(m.queue)}\`` : '';
-      return {
-        label: `queue job ${job}${queue} — producer → consumer (cross-tier)`,
-        compact: `dynamic: queue job ${job}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'event-bus') {
-      const ev = m.event ? `\`${String(m.event)}\`` : 'an event';
-      const what = m.channel === 'socket' ? 'socket message' : 'bus event';
-      const dir = m.tier === 'client→server' ? ', client → server' : m.tier === 'server→client' ? ', server → client' : '';
-      return {
-        label: `${what} ${ev} — emit → handler${dir} (dynamic dispatch)`,
-        compact: `dynamic: ${what} ${ev}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'event-emitter') {
-      const ev = m.event ? `\`${String(m.event)}\`` : 'an event';
-      return {
-        label: `event ${ev} — emit → handler (dynamic dispatch)`,
-        compact: `dynamic: event ${ev}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'window-message') {
-      const ev = m.event ? `\`${String(m.event)}\`` : 'a message';
-      return {
-        label: `window message ${ev} — postMessage → listener (dynamic dispatch)`,
-        compact: `dynamic: window message ${ev}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'react-render') {
-      return {
-        label: `React re-render — \`setState\` re-runs render() (dynamic dispatch)`,
-        compact: `dynamic: React re-render via setState${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'jsx-render') {
-      const child = m.via ? `<${String(m.via)}>` : 'a child component';
-      return {
-        label: `renders ${child} (JSX child — dynamic dispatch)`,
-        compact: `dynamic: renders ${child}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'vue-handler') {
-      const ev = m.event ? `@${String(m.event)}` : 'a template event';
-      return {
-        label: `Vue template handler — bound to ${ev} (dynamic dispatch)`,
-        compact: `dynamic: Vue ${ev} handler`,
-        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)`,
-        compact: `dynamic: interface → impl${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'closure-collection') {
-      const field = m.field ? `\`${String(m.field)}\`` : 'a collection';
-      return {
-        label: `closure collection — runs handlers appended to ${field} (dynamic dispatch)`,
-        compact: `dynamic: runs ${field} handlers${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'fn-pointer-dispatch') {
-      const via = m.via ? `\`${String(m.via)}\`` : 'a function pointer';
-      return {
-        label: `function-pointer dispatch via ${via} (dynamic dispatch)`,
-        compact: `dynamic: fn-pointer ${m.via ? String(m.via) : ''}${at}`,
-        registeredAt,
-      };
-    }
-    if (m?.synthesizedBy === 'goframe-route') {
-      const route = m.route ? `\`${String(m.route)}\`` : 'a route';
-      return {
-        label: `GoFrame route ${route} — reflective Bind → controller method (dynamic dispatch)`,
-        compact: `dynamic: GoFrame route ${m.route ? String(m.route) : ''}${at}`,
-        registeredAt,
-      };
-    }
-    // Generic fallback for any other synthesizer (redux-thunk, gin-middleware-chain,
-    // flutter-build, …): a synthesized hop must never read as a bare static `calls`.
-    // It's a dynamic-dispatch bridge — label it as one and keep its wiring site.
-    if (typeof m?.synthesizedBy === 'string') {
-      const kind = m.synthesizedBy.replace(/-/g, ' ');
-      return { label: `${kind} (dynamic dispatch)`, compact: `dynamic: ${kind}${at}`, registeredAt };
-    }
-    return null;
+  /**
+   * The tag a synthesized (dynamic-dispatch) hop carries in explore's Flow and
+   * dynamic-dispatch links and in the codegraph_node trail, so it reads as
+   * "dynamic: callback via `onUpdate` @App.tsx:3148", not a bare arrow. Null
+   * for an ordinary static edge. The wording is `graph/synthesized-hop.ts`'s,
+   * shared with ContextBuilder's call paths.
+   */
+  private synthEdgeNote(edge: Edge | null): string | null {
+    const hop = describeSynthesizedHop(edge);
+    if (!hop) return null;
+    return `dynamic: ${hop.summary}${hop.registeredAt ? ` @${hop.registeredAt}` : ''}`;
   }
 
   /**
@@ -3849,8 +3728,7 @@ export class ToolHandler {
             const key = `${src.name}>${tgt.name}`;
             if (synthSeen.has(key)) continue;
             synthSeen.add(key);
-            const note = this.synthEdgeNote(edge);
-            synthLines.push(`- ${src.name} → ${tgt.name}   [${note ? note.compact : edge.kind}]`);
+            synthLines.push(`- ${src.name} → ${tgt.name}   [${this.synthEdgeNote(edge) ?? edge.kind}]`);
           }
         }
         return synthLines;
@@ -3985,10 +3863,10 @@ export class ToolHandler {
         for (let i = 0; i < best!.length; i++) {
           const step = best![i]!;
           if (step.edge) {
-            const sy = this.synthEdgeNote(step.edge);
             const when = i > 0 ? this.whenLabel(cg, best![i - 1]!.node, step.edge) : '';
+            const sy = this.synthEdgeNote(step.edge);
             const guess = !sy && isNameGuess(step.edge) ? ' — matched by name only, unverified' : '';
-            out.push(`   ↓ ${sy ? sy.compact : step.edge.kind}${guess}${when ? ` (when ${when})` : ''}`);
+            out.push(`   ↓ ${sy ?? step.edge.kind}${guess}${when ? ` (when ${when})` : ''}`);
           }
           out.push(`${i + 1}. ${step.node.name} (${step.node.filePath}:${step.node.startLine})`);
         }
@@ -9314,7 +9192,7 @@ export class ToolHandler {
     const fmt = (e: { node: Node; edge: Edge }) => {
       const base = `${e.node.name} (${e.node.filePath}:${e.node.startLine})`;
       const synth = this.synthEdgeNote(e.edge);
-      if (synth) return `${base} [${synth.compact}]`;
+      if (synth) return `${base} [${synth}]`;
       return isNameGuess(e.edge) ? `${base} [name match, unverified]` : base;
     };
     const collect = (edges: Array<{ node: Node; edge: Edge }>): Array<{ node: Node; edge: Edge }> => {
diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts
index 3ca90fd1d..eebcee7da 100644
--- a/src/resolution/callback-synthesizer.ts
+++ b/src/resolution/callback-synthesizer.ts
@@ -2014,6 +2014,18 @@ const JSX_CHILD_KINDS = new Set<NodeKind>(['component', 'function', 'class']);
  */
 const JSX_CHILD_LANGUAGES = [...JS_FAMILY, 'vue', 'svelte'];
 
+/**
+ * Whether a JSX tag can render `node` (`jsxChild`): a script's component,
+ * function or class named with a tag's capital, or any component, which a
+ * default import names under a name of its own. A tag in a file a sync never
+ * touched may name one the sync adds, so adding one redraws the JSX edges.
+ * (A `.vue` or `.svelte` file redraws them on any change.)
+ */
+export function isJsxChildCandidate(node: Pick<Node, 'kind' | 'name' | 'language'>): boolean {
+  return JSX_CHILD_KINDS.has(node.kind) && JS_FAMILY.includes(node.language) &&
+    (node.kind === 'component' || /^[A-Z]/.test(node.name));
+}
+
 function languageForJsxFile(file: string): Language {
   if (file.endsWith('.tsx')) return 'tsx';
   if (/\.[cm]?ts$/.test(file)) return 'typescript';
diff --git a/src/resolution/frameworks/react.ts b/src/resolution/frameworks/react.ts
index c8b9dcc97..f3e3fc564 100644
--- a/src/resolution/frameworks/react.ts
+++ b/src/resolution/frameworks/react.ts
@@ -211,6 +211,22 @@ export const reactResolver: FrameworkResolver = {
   crossFileNodes(context: ResolutionContext) {
     return { kind: 'route', owns: isTableRoute, ...tableRoutes(context) };
   },
+
+  /**
+   * The modules a route's answer is read from: a lazily loaded page or layout
+   * (`lazy-import:` references), or the one a same-file lazy value the route
+   * renders loads — the references Pattern 1 asks `declaredComponent` about —
+   * with the modules a barrel there forwards the lookup to.
+   */
+  lazyModules(ref: UnresolvedRef, context: ResolutionContext): readonly string[] {
+    const name = ref.referenceName;
+    let spec: string | null | undefined;
+    if (name.startsWith(LAZY_ROUTE_PREFIX)) spec = name.slice(LAZY_ROUTE_PREFIX.length);
+    else if (name.startsWith(LAYOUT_PREFIX + LAZY_ROUTE_PREFIX)) spec = name.slice(LAYOUT_PREFIX.length + LAZY_ROUTE_PREFIX.length);
+    else if ((ref.language === 'tsx' || ref.language === 'jsx') && isPascalCase(name) && !isBuiltInType(name) &&
+      ref.fromNodeId.startsWith(`route:${ref.filePath}:`)) spec = declaredLoader(name, ref.filePath, context);
+    return spec ? lazyRouteFiles(spec, ref.filePath, context) : [];
+  },
 };
 
 const LAZY_ROUTE_PREFIX = 'lazy-import:';
@@ -431,11 +447,24 @@ function readObjectPath(text: string, at: number, keys: string[]): string | null
   return null;
 }
 
+/** The file a route's lazily loaded module is, from the file that loads it. */
+function lazyModuleFile(spec: string, fromFile: string, context: ResolutionContext): string | null {
+  return resolveImportPath(spec, fromFile, 'typescript', context);
+}
+
 /** 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);
+function lazyRouteComponent(spec: string, fromFile: string, context: ResolutionContext, reads?: Set<string>): string | null {
+  const file = lazyModuleFile(spec, fromFile, context);
   if (!file) return null;
-  return exportedComponent(file, 'default', context) ?? exportedComponent(file, 'Component', context);
+  return exportedComponent(file, 'default', context, new Set(), reads) ??
+    exportedComponent(file, 'Component', context, new Set(), reads);
+}
+
+/** The files `lazyRouteComponent` reads: the module, and the ones a barrel forwards it to. */
+function lazyRouteFiles(spec: string, fromFile: string, context: ResolutionContext): string[] {
+  const reads = new Set<string>();
+  lazyRouteComponent(spec, fromFile, context, reads);
+  return [...reads];
 }
 
 /** What a module can export as a component: a declaration, or a value holding one. */
@@ -452,10 +481,17 @@ const MAX_REEXPORT_HOPS = 4;
  * './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.
+ * exported by neither. `reads` collects every file the lookup reads.
  */
-function exportedComponent(file: string, name: string, context: ResolutionContext, visited: ReadonlySet<string> = new Set()): string | null {
+function exportedComponent(
+  file: string,
+  name: string,
+  context: ResolutionContext,
+  visited: ReadonlySet<string> = new Set(),
+  reads?: Set<string>
+): string | null {
   if (visited.has(file) || visited.size > MAX_REEXPORT_HOPS) return null;
+  reads?.add(file);
   const bindings = context.getBindings?.(file) ?? [];
   const local = bindings.find((b) => b.kind !== 'reexport' && b.exportedAs === name)?.name
     ?? ownExport(stripCommentsForRegex(context.readFile(file) ?? '', 'typescript'), name);
@@ -465,7 +501,7 @@ function exportedComponent(file: string, name: string, context: ResolutionContex
   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;
+    return target ? exportedComponent(target, exported, context, through, reads) : null;
   };
   for (const re of reExports) {
     if (re.name !== '*' && re.exportedAs === name) return forwarded(re.targetSpec!, re.targetName ?? re.name);
@@ -505,13 +541,23 @@ function ownExport(source: string, name: string): string | null {
  * usual way).
  */
 function declaredComponent(name: string, filePath: string, context: ResolutionContext): string | null | undefined {
+  const spec = declaredLoader(name, filePath, context);
+  if (spec === undefined) return undefined;
+  return spec ? lazyRouteComponent(spec, filePath, context) : null;
+}
+
+/**
+ * The module a value `filePath` declares as `name` loads lazily — the
+ * `'./x'` of `const X = lazy(() => import('./x'))`, wrapped or not — null
+ * for a value that loads none, undefined when the file declares no such value.
+ */
+function declaredLoader(name: string, filePath: string, context: ResolutionContext): string | null | undefined {
   const own = context.getNodesByName(name)
     .find((n) => n.filePath === filePath && (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;
+  return /=>\s*import\s*\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? null;
 }
 
 /**
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index 76e7edf62..942eace22 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -315,6 +315,42 @@ export class ReferenceResolver {
     return changed;
   }
 
+  /**
+   * Put back in the pending set the route references whose answer reads a
+   * module in `changedFilePaths` (`FrameworkResolver.lazyModules`), for a
+   * sync's resolution sweep. Returns the number put back.
+   *
+   * A route that renders a same-file `const Docs = lazy(() =>
+   * import('./pages/Docs'))` binds to the declaration while the module is
+   * missing, and nothing revisited it once the module was added: the
+   * reference had resolved, so it was never parked for the failed-ref retry,
+   * and the rebind of the names a sync defines (CG-33) reaches it only when
+   * the module's component is named like the declaration. An edit that gives
+   * the module its default export, or moves it to another component, changes
+   * the answer the same way: a route's edge follows its old target through
+   * the module's re-index. So does a page behind a barrel the module
+   * forwards. References written in a changed file were resolved against the
+   * new files already.
+   */
+  reopenRouteModuleReaders(changedFilePaths: readonly string[]): number {
+    const readers = this.frameworks.filter((f) => f.lazyModules);
+    if (readers.length === 0 || changedFilePaths.length === 0) return 0;
+    const changed = new Set(changedFilePaths);
+    const edgeIds: number[] = [];
+    const refs: UnresolvedReference[] = [];
+    for (const edge of this.queries.getRouteEdgesMovedBy(changedFilePaths)) {
+      const ref = resurrectRefFromDroppedEdge(edge);
+      if (!ref) continue;
+      const asked: UnresolvedRef = { ...ref, filePath: edge.sourceFilePath, language: edge.sourceLanguage };
+      const reads = readers.some((f) => f.lazyModules!(asked, this.context).some((file) => changed.has(file)));
+      if (!reads) continue;
+      edgeIds.push(edge.edgeId);
+      refs.push(ref);
+    }
+    if (refs.length > 0) this.queries.replaceResolutionEdgesWithUnresolvedRefs(edgeIds, refs);
+    return refs.length;
+  }
+
   /**
    * Pre-build lightweight caches for resolution.
    * Node lookups are now handled by indexed SQLite queries instead of
diff --git a/src/resolution/types.ts b/src/resolution/types.ts
index 83ea1b01e..743136acc 100644
--- a/src/resolution/types.ts
+++ b/src/resolution/types.ts
@@ -362,6 +362,16 @@ export interface FrameworkResolver {
    * calls this describes back for its resolution sweep.
    */
   navigation?: NavigationCalls;
+  /**
+   * The modules whose content `resolve()` reads to answer `ref`, a route
+   * node's reference — none for most. A React route that renders a same-file
+   * `const Docs = lazy(() => import('./pages/Docs'))` binds to the component
+   * that module exports, through any barrel that forwards it, and to the
+   * declaration while the module is missing or exports none: the answer
+   * changes with those files although no name the reference carries does, so
+   * a sync that adds or changes one of them resolves the reference again.
+   */
+  lazyModules?(ref: UnresolvedRef, context: ResolutionContext): readonly string[];
 }
 
 /**