@remnic/coding-graph 9.6.22 → 9.6.24

package/src/heuristic-resolution.test.ts

@@ -0,0 +1,596 @@
+/**
+ * Phase A heuristic edge resolution tests (issue #1891).
+ *
+ * deriveHeuristicEdges: pure function FileIR[] → per-file EdgeIR[] + stats.
+ * The store's pass-2 (batch map + full-DB dst fallback, conservative
+ * ambiguity drops) does final id resolution; this module only decides
+ * WHICH (srcQualifiedName → dstQualifiedName, CALLS) assertions a fresh
+ * parse supports, so every emitted edge must be derivable from the IR
+ * alone.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  deriveHeuristicEdges,
+  HEURISTIC_CONFIDENCE_SAME_FILE,
+  HEURISTIC_CONFIDENCE_IMPORT_BOUND,
+} from "./heuristic-resolution.js";
+import type { EdgeIR, FileIR } from "./graph-store.js";
+
+function firstFile(result: { files: readonly { edges: readonly EdgeIR[] }[] }): { edges: readonly EdgeIR[] } {
+  const file = result.files[0];
+  assert.ok(file, "expected at least one file in the result");
+  return file;
+}
+
+function fileIR(overrides: Partial<FileIR> & { path: string }): FileIR {
+  return {
+    language: "typescript",
+    contentHash: `h-${overrides.path}`,
+    symbols: [],
+    imports: [],
+    exports: [],
+    callSites: [],
+    routes: [],
+    ...overrides,
+  } as FileIR;
+}
+
+const span = (startByte: number, endByte: number) => ({ startByte, endByte });
+
+test("same-file call resolves to a CALLS edge with heuristic provenance", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "greet", qualifiedName: "greet", span: span(0, 70) },
+      { kind: "function", name: "format", qualifiedName: "format", span: span(71, 132) },
+    ],
+    callSites: [{ calleeNameCandidates: ["format"], span: span(40, 46) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.equal(result.files.length, 1);
+  assert.deepEqual(firstFile(result).edges, [
+    {
+      srcQualifiedName: "greet",
+      dstQualifiedName: "format",
+      type: "CALLS",
+      confidence: HEURISTIC_CONFIDENCE_SAME_FILE,
+      provenance: "heuristic",
+    },
+  ]);
+  assert.equal(stats.callSites, 1);
+  assert.equal(stats.resolved, 1);
+});
+
+test("import-bound cross-file call emits an edge for the store to resolve", () => {
+  const ir = fileIR({
+    path: "util.ts",
+    symbols: [
+      { kind: "function", name: "shout", qualifiedName: "shout", span: span(30, 110) },
+    ],
+    imports: [{ module: "./main", importedNames: ["greet"], span: span(0, 29) }],
+    callSites: [{ calleeNameCandidates: ["greet"], span: span(60, 67) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(firstFile(result).edges, [
+    {
+      srcQualifiedName: "shout",
+      dstQualifiedName: "greet",
+      type: "CALLS",
+      confidence: HEURISTIC_CONFIDENCE_IMPORT_BOUND,
+      provenance: "heuristic",
+      dstPathHint: "main",
+      dstImporterLanguage: "typescript",
+    },
+  ]);
+});
+
+test("unresolvable bare names are skipped and counted, never emitted", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "greet", qualifiedName: "greet", span: span(0, 70) },
+    ],
+    callSites: [{ calleeNameCandidates: ["log"], span: span(20, 25) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, []);
+  assert.equal(stats.skippedUnresolved, 1);
+  assert.equal(stats.resolved, 0);
+});
+
+test("call site outside any symbol span is skipped and counted", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "format", qualifiedName: "format", span: span(50, 100) },
+    ],
+    // Top-level call before the first symbol.
+    callSites: [{ calleeNameCandidates: ["format"], span: span(0, 8) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, []);
+  assert.equal(stats.skippedNoEnclosingSymbol, 1);
+});
+
+test("innermost enclosing symbol wins as src (nested spans)", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "class", name: "Outer", qualifiedName: "Outer", span: span(0, 200) },
+      { kind: "method", name: "run", qualifiedName: "Outer.run", span: span(20, 120) },
+      { kind: "function", name: "helper", qualifiedName: "helper", span: span(210, 260) },
+    ],
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(60, 68) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.equal(firstFile(result).edges.length, 1);
+  assert.equal(firstFile(result).edges[0]?.srcQualifiedName, "Outer.run");
+});
+
+test("ambiguous same-file name is skipped conservatively and counted", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "run", qualifiedName: "run", span: span(0, 50) },
+      // Same bare name at a different span (e.g. overload-style duplicate).
+      { kind: "function", name: "format", qualifiedName: "a.format", span: span(60, 100) },
+      { kind: "function", name: "format", qualifiedName: "b.format", span: span(110, 150) },
+    ],
+    callSites: [{ calleeNameCandidates: ["format"], span: span(20, 28) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, []);
+  assert.equal(stats.skippedAmbiguous, 1);
+});
+
+test("second callee candidate is tried when the first cannot resolve", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "run", qualifiedName: "run", span: span(0, 50) },
+      { kind: "function", name: "fallback", qualifiedName: "fallback", span: span(60, 100) },
+    ],
+    callSites: [{ calleeNameCandidates: ["missing", "fallback"], span: span(10, 20) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.equal(firstFile(result).edges.length, 1);
+  assert.equal(firstFile(result).edges[0]?.dstQualifiedName, "fallback");
+  assert.equal(stats.resolved, 1);
+});
+
+test("recursive self-call emits a self edge", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "walk", qualifiedName: "walk", span: span(0, 90) },
+    ],
+    callSites: [{ calleeNameCandidates: ["walk"], span: span(40, 46) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(firstFile(result).edges.map((e: EdgeIR) => [e.srcQualifiedName, e.dstQualifiedName]), [
+    ["walk", "walk"],
+  ]);
+});
+
+test("duplicate src→dst call sites are deduped to one edge", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "greet", qualifiedName: "greet", span: span(0, 90) },
+      { kind: "function", name: "format", qualifiedName: "format", span: span(100, 150) },
+    ],
+    callSites: [
+      { calleeNameCandidates: ["format"], span: span(20, 26) },
+      { calleeNameCandidates: ["format"], span: span(50, 56) },
+    ],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.equal(firstFile(result).edges.length, 1);
+  assert.equal(stats.callSites, 2);
+  assert.equal(stats.resolved, 2);
+});
+
+test("files with no call sites assert an explicit empty edge set", () => {
+  const ir = fileIR({
+    path: "empty.ts",
+    symbols: [
+      { kind: "function", name: "solo", qualifiedName: "solo", span: span(0, 20) },
+    ],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  // Empty ARRAY (not undefined): the fresh parse asserts "no heuristic
+  // edges", so stale heuristic edges from a prior version are cleaned up.
+  assert.deepEqual(firstFile(result).edges, []);
+});
+
+test("output is deterministic and byte-stable across runs (rule 38)", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "a", qualifiedName: "a", span: span(0, 40) },
+      { kind: "function", name: "b", qualifiedName: "b", span: span(50, 90) },
+      { kind: "function", name: "c", qualifiedName: "c", span: span(100, 140) },
+    ],
+    callSites: [
+      { calleeNameCandidates: ["c"], span: span(10, 12) },
+      { calleeNameCandidates: ["b"], span: span(20, 22) },
+    ],
+  });
+  const one = JSON.stringify(deriveHeuristicEdges([ir]));
+  const two = JSON.stringify(deriveHeuristicEdges([ir]));
+  assert.equal(one, two);
+});
+
+test("a nested symbol under a different parent is NOT visible to a sibling caller", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "outer", qualifiedName: "outer", span: span(0, 100) },
+      { kind: "function", name: "helper", qualifiedName: "outer.helper", span: span(10, 60) },
+      { kind: "function", name: "run", qualifiedName: "run", span: span(110, 180) },
+    ],
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(130, 138) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, [], "outer.helper is not in run's lexical scope");
+  assert.equal(stats.skippedUnresolved, 1);
+});
+
+test("shadowing: the innermost visible declaration wins over a top-level one", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "greet", qualifiedName: "greet", span: span(0, 100) },
+      { kind: "function", name: "format", qualifiedName: "greet.format", span: span(10, 50) },
+      { kind: "function", name: "format", qualifiedName: "format", span: span(110, 160) },
+    ],
+    callSites: [{ calleeNameCandidates: ["format"], span: span(60, 68) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.equal(firstFile(result).edges.length, 1);
+  assert.equal(
+    firstFile(result).edges[0]?.dstQualifiedName,
+    "greet.format",
+    "the nested declaration shadows the top-level one for calls inside greet",
+  );
+});
+
+test("a caller's own nested declaration is visible to it", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "outer", qualifiedName: "outer", span: span(0, 100) },
+      { kind: "function", name: "helper", qualifiedName: "outer.helper", span: span(10, 40) },
+    ],
+    // Call inside outer but outside helper.
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(60, 68) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(
+    firstFile(result).edges.map((e: EdgeIR) => [e.srcQualifiedName, e.dstQualifiedName]),
+    [["outer", "outer.helper"]],
+  );
+});
+
+test("external-package imports never bind bare names (no false in-repo edges)", () => {
+  const ir = fileIR({
+    path: "util.ts",
+    symbols: [
+      { kind: "function", name: "shout", qualifiedName: "shout", span: span(30, 110) },
+    ],
+    imports: [{ module: "lodash", importedNames: ["map"], span: span(0, 29) }],
+    callSites: [{ calleeNameCandidates: ["map"], span: span(60, 65) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, [], "lodash's map must not bind an in-repo symbol");
+  assert.equal(stats.skippedUnresolved, 1);
+});
+
+test("relative-module imports bind with a normalized in-repo hint", () => {
+  const ir = fileIR({
+    path: "src/util.ts",
+    symbols: [
+      { kind: "function", name: "shout", qualifiedName: "shout", span: span(30, 110) },
+    ],
+    imports: [{ module: "../lib/main.js", importedNames: ["greet"], span: span(0, 29) }],
+    callSites: [{ calleeNameCandidates: ["greet"], span: span(60, 67) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.equal(firstFile(result).edges.length, 1);
+  assert.equal(firstFile(result).edges[0]?.confidence, HEURISTIC_CONFIDENCE_IMPORT_BOUND);
+  assert.equal(firstFile(result).edges[0]?.dstPathHint, "lib/main");
+});
+
+test("an import escaping the repo root never binds (cursor review)", () => {
+  const ir = fileIR({
+    path: "util.ts",
+    symbols: [
+      { kind: "function", name: "shout", qualifiedName: "shout", span: span(30, 110) },
+    ],
+    // dirname("util.ts") = "." so ../lib escapes the repo root — files.path
+    // is canonical and can never match a "../" hint.
+    imports: [{ module: "../lib/main.js", importedNames: ["greet"], span: span(0, 29) }],
+    callSites: [{ calleeNameCandidates: ["greet"], span: span(60, 67) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, []);
+  assert.equal(stats.skippedUnresolved, 1);
+});
+
+test("member-access call sites never bind bare names (codex review)", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "function", name: "run", qualifiedName: "run", span: span(0, 90) },
+      { kind: "function", name: "connect", qualifiedName: "connect", span: span(100, 150) },
+    ],
+    // client.connect() — the property name matches a visible bare symbol
+    // but the receiver decides the target; Phase A must skip it.
+    callSites: [{ calleeNameCandidates: ["connect"], memberAccess: true, span: span(30, 40) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, []);
+  assert.equal(stats.skippedMemberAccess, 1);
+});
+
+test("aliased imports bind by local name and emit the exported dst (codex review)", () => {
+  const ir = fileIR({
+    path: "util.ts",
+    symbols: [
+      { kind: "function", name: "shout", qualifiedName: "shout", span: span(30, 110) },
+    ],
+    imports: [
+      {
+        module: "./main",
+        importedNames: ["greet"],
+        bindings: [{ exported: "greet", local: "salute" }],
+        span: span(0, 29),
+      },
+    ],
+    // Call site uses the LOCAL alias...
+    callSites: [{ calleeNameCandidates: ["salute"], span: span(60, 68) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.equal(firstFile(result).edges.length, 1);
+  // ...but the edge's dst is the EXPORTED name in the target file.
+  assert.equal(firstFile(result).edges[0]?.dstQualifiedName, "greet");
+  assert.equal(firstFile(result).edges[0]?.dstPathHint, "main");
+});
+
+test("an ambiguous first candidate does not block a later candidate's import binding (cursor review)", () => {
+  const ir = fileIR({
+    path: "util.ts",
+    symbols: [
+      { kind: "function", name: "shout", qualifiedName: "shout", span: span(40, 120) },
+      { kind: "function", name: "dup", qualifiedName: "a.dup", span: span(130, 160) },
+      { kind: "function", name: "dup", qualifiedName: "b.dup", span: span(170, 200) },
+    ],
+    imports: [{ module: "./main", importedNames: ["greet"], span: span(0, 29) }],
+    callSites: [{ calleeNameCandidates: ["dup", "greet"], span: span(60, 70) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.equal(firstFile(result).edges.length, 1);
+  assert.equal(firstFile(result).edges[0]?.dstQualifiedName, "greet");
+  assert.equal(firstFile(result).edges[0]?.dstPathHint, "main");
+});
+
+test("python dot-style relative imports bind with package-path hints (cursor review)", () => {
+  const ir = fileIR({
+    path: "pkg/app/views.py",
+    language: "python",
+    symbols: [
+      { kind: "function", name: "render", qualifiedName: "render", span: span(30, 110) },
+    ],
+    imports: [
+      { module: ".models", importedNames: ["User"], span: span(0, 25) },
+      { module: "..lib.utils", importedNames: ["helper"], span: span(26, 55) },
+    ],
+    callSites: [
+      { calleeNameCandidates: ["User"], span: span(60, 64) },
+      { calleeNameCandidates: ["helper"], span: span(70, 76) },
+    ],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const hints = firstFile(result).edges.map((e: EdgeIR) => [e.dstQualifiedName, e.dstPathHint]);
+  assert.deepEqual(hints, [
+    ["User", "pkg/app/models"],
+    ["helper", "pkg/lib/utils"],
+  ]);
+});
+
+test("python dot-style import escaping the root never binds", () => {
+  const ir = fileIR({
+    path: "views.py",
+    language: "python",
+    symbols: [
+      { kind: "function", name: "render", qualifiedName: "render", span: span(30, 110) },
+    ],
+    imports: [{ module: "..outside", importedNames: ["thing"], span: span(0, 25) }],
+    callSites: [{ calleeNameCandidates: ["thing"], span: span(60, 65) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(firstFile(result).edges, []);
+});
+
+test("same exported name from two modules yields two hinted edges (codex review)", () => {
+  const ir = fileIR({
+    path: "util.ts",
+    symbols: [
+      { kind: "function", name: "run", qualifiedName: "run", span: span(60, 160) },
+    ],
+    imports: [
+      { module: "./a", importedNames: ["foo"], bindings: [{ exported: "foo", local: "fooA" }], span: span(0, 28) },
+      { module: "./b", importedNames: ["foo"], bindings: [{ exported: "foo", local: "fooB" }], span: span(29, 57) },
+    ],
+    callSites: [
+      { calleeNameCandidates: ["fooA"], span: span(80, 86) },
+      { calleeNameCandidates: ["fooB"], span: span(100, 106) },
+    ],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(
+    firstFile(result).edges.map((e: EdgeIR) => [e.dstQualifiedName, e.dstPathHint]),
+    [
+      ["foo", "a"],
+      ["foo", "b"],
+    ],
+  );
+});
+
+test("a bare call inside a method never binds a sibling method (codex review round 8)", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "class", name: "C", qualifiedName: "C", span: span(0, 200) },
+      { kind: "method", name: "run", qualifiedName: "C.run", span: span(10, 100) },
+      { kind: "method", name: "helper", qualifiedName: "C.helper", span: span(110, 190) },
+      { kind: "function", name: "helper", qualifiedName: "helper", span: span(210, 260) },
+    ],
+    // bare helper() inside C.run — this.helper() would be memberAccess.
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(40, 48) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(
+    firstFile(result).edges.map((e: EdgeIR) => [e.srcQualifiedName, e.dstQualifiedName]),
+    [["C.run", "helper"]],
+    "binds the file-level function, never the sibling method C.helper",
+  );
+});
+
+test("with only a sibling method available, a bare call stays unresolved", () => {
+  const ir = fileIR({
+    path: "main.ts",
+    symbols: [
+      { kind: "class", name: "C", qualifiedName: "C", span: span(0, 200) },
+      { kind: "method", name: "run", qualifiedName: "C.run", span: span(10, 100) },
+      { kind: "method", name: "helper", qualifiedName: "C.helper", span: span(110, 190) },
+    ],
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(40, 48) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(firstFile(result).edges, []);
+  assert.equal(stats.skippedUnresolved, 1);
+});
+
+test("absent bindings falls back to importedNames; explicit [] binds nothing (rounds 9 + 12)", () => {
+  const base = {
+    path: "util.ts",
+    symbols: [
+      { kind: "function" as const, name: "shout", qualifiedName: "shout", span: span(30, 110) },
+    ],
+    callSites: [{ calleeNameCandidates: ["greet"], span: span(60, 67) }],
+  };
+  // Absent field (pre-bindings emitter / hand-built IR) -> fallback binds.
+  const absent = deriveHeuristicEdges([
+    fileIR({ ...base, imports: [{ module: "./main", importedNames: ["greet"], span: span(0, 29) }] }),
+  ]);
+  assert.equal(firstFile(absent).edges.length, 1);
+  // Explicit [] (default/namespace import: exported symbol unknowable) ->
+  // never re-bound through the fallback.
+  const explicit = deriveHeuristicEdges([
+    fileIR({
+      ...base,
+      imports: [{ module: "./main", importedNames: ["greet"], bindings: [], span: span(0, 29) }],
+    }),
+  ]);
+  assert.deepEqual(firstFile(explicit).edges, []);
+});
+
+test("pure parent-package python imports hint the package directory (codex review round 10)", () => {
+  const ir = fileIR({
+    path: "pkg/app/views.py",
+    language: "python",
+    symbols: [
+      { kind: "function", name: "render", qualifiedName: "render", span: span(30, 110) },
+    ],
+    imports: [
+      { module: ".", importedNames: ["sibling"], span: span(0, 20) },
+      { module: "..", importedNames: ["helper"], span: span(21, 45) },
+    ],
+    callSites: [
+      { calleeNameCandidates: ["sibling"], span: span(60, 67) },
+      { calleeNameCandidates: ["helper"], span: span(70, 76) },
+    ],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(
+    firstFile(result).edges.map((e: EdgeIR) => [e.dstQualifiedName, e.dstPathHint]),
+    [
+      ["sibling", "pkg/app"],
+      ["helper", "pkg"],
+    ],
+  );
+});
+
+test("implicit-this languages bind sibling methods on bare calls (codex review round 11)", () => {
+  const ir = fileIR({
+    path: "C.java",
+    language: "java",
+    symbols: [
+      { kind: "class", name: "C", qualifiedName: "C", span: span(0, 200) },
+      { kind: "method", name: "run", qualifiedName: "C.run", span: span(10, 100) },
+      { kind: "method", name: "helper", qualifiedName: "C.helper", span: span(110, 190) },
+    ],
+    // Java: helper() inside run() legally targets the sibling method.
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(40, 48) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(
+    firstFile(result).edges.map((e: EdgeIR) => [e.srcQualifiedName, e.dstQualifiedName]),
+    [["C.run", "C.helper"]],
+  );
+});
+
+test("php bare calls inside methods never bind sibling methods (codex review round 12)", () => {
+  const ir = fileIR({
+    path: "C.php",
+    language: "php",
+    symbols: [
+      { kind: "class", name: "C", qualifiedName: "C", span: span(0, 200) },
+      { kind: "method", name: "run", qualifiedName: "C.run", span: span(10, 100) },
+      { kind: "method", name: "helper", qualifiedName: "C.helper", span: span(110, 190) },
+    ],
+    callSites: [{ calleeNameCandidates: ["helper"], span: span(40, 48) }],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  assert.deepEqual(firstFile(result).edges, []);
+});
+
+test("function-local imports bind only within their enclosing symbol (codex review round 12)", () => {
+  const ir = fileIR({
+    path: "app.py",
+    language: "python",
+    symbols: [
+      { kind: "function", name: "setup", qualifiedName: "setup", span: span(0, 100) },
+      { kind: "function", name: "run", qualifiedName: "run", span: span(110, 200) },
+    ],
+    // from .dep import helper INSIDE setup's span.
+    imports: [{ module: ".dep", importedNames: ["helper"], span: span(10, 40) }],
+    callSites: [
+      // Inside setup: binds.
+      { calleeNameCandidates: ["helper"], span: span(60, 66) },
+      // Inside sibling run: must NOT bind.
+      { calleeNameCandidates: ["helper"], span: span(140, 146) },
+    ],
+  });
+  const result = deriveHeuristicEdges([ir]);
+  const { stats } = result;
+  assert.deepEqual(
+    firstFile(result).edges.map((e: EdgeIR) => e.srcQualifiedName),
+    ["setup"],
+  );
+  assert.equal(stats.skippedUnresolved, 1);
+});