diff --git a/__tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json b/__tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json
new file mode 100644
index 0000000000..4ad5ed553f
--- /dev/null
+++ b/__tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json
@@ -0,0 +1,60 @@
+{
+  "timestamp": "2026-10-29T14:52:50.836Z",
+  "corpus": "flask",
+  "repo": "https://github.com/pallets/flask.git",
+  "commit": "d73fa1c",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 0,
+    "absentHeld": 0,
+    "presentCases": 2,
+    "presentHeld": 2,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 2474,
+    "import": 1180,
+    "instance-method": 730,
+    "exact-match": 633,
+    "function-ref": 191
+  },
+  "edges": 5208,
+  "results": [
+    {
+      "caseId": "flask-package-reexport-receiver",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "file:examples/tutorial/flaskr/auth.py",
+          "to": "method:31833b8026746e7977b4c2736d71c63e",
+          "resolvedBy": "instance-method"
+        },
+        {
+          "from": "file:examples/tutorial/flaskr/auth.py",
+          "to": "method:31833b8026746e7977b4c2736d71c63e",
+          "resolvedBy": "instance-method"
+        },
+        {
+          "from": "file:examples/tutorial/flaskr/auth.py",
+          "to": "method:31833b8026746e7977b4c2736d71c63e",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "flask-control-relative-from-import",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "file:src/flask/app.py",
+          "to": "function:00d6010e49ed947bc5858174234b23e4",
+          "resolvedBy": "import"
+        }
+      ],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json b/__tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json
new file mode 100644
index 0000000000..ca540a12dc
--- /dev/null
+++ b/__tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json
@@ -0,0 +1,200 @@
+{
+  "timestamp": "2026-10-29T14:52:49.255Z",
+  "corpus": "json",
+  "repo": "https://github.com/nlohmann/json.git",
+  "commit": "aa391dc",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 11,
+    "absentHeld": 11,
+    "presentCases": 7,
+    "presentHeld": 7,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 13070,
+    "instance-method": 6643,
+    "qualified-name": 3946,
+    "exact-match": 2641,
+    "file-path": 1742,
+    "import": 670,
+    "function-ref": 49,
+    "field-call": 1
+  },
+  "edges": 28762,
+  "results": [
+    {
+      "caseId": "json-value-not-internal-serializer",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-fuzzer-contains-word",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:511ae2bab26a12794fe5b8e38095ef6f",
+          "to": "method:c7bd7bd104f933f1ecf2fcd44528462f",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-fuzzer-end-calls-begin",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:a583c5de8fb77fcf2e47f72d5f052f20",
+          "to": "method:c7bd7bd104f933f1ecf2fcd44528462f",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-front-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:8654732301dd561330bd7d76aaaac333",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-rend-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:0dda1746e6adfea526da71f9367b169b",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-subscript-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:77ad649124c3bf33008dde65773f52e6",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-emplace-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:c3902fb60811ce9452300172d8c55ee0",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-cross-test-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-eigen-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-udt-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-fifo-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-array-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-ordered-map-this",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-adl-to-helper",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-using-std-to-proxy",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-doctest-to-dictionary",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-abi-adl-to-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-items-calls-proxy-ctor",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:43fd87584a379054069e29e9f2000a50",
+          "to": "method:2c30311abef74670c4da1607ca5259fb",
+          "resolvedBy": "import"
+        },
+        {
+          "from": "method:b768fbb5951dfeae8fcc4e6af4e53c84",
+          "to": "method:2c30311abef74670c4da1607ca5259fb",
+          "resolvedBy": "import"
+        }
+      ],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json b/__tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json
new file mode 100644
index 0000000000..35dc6c9a68
--- /dev/null
+++ b/__tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json
@@ -0,0 +1,35 @@
+{
+  "timestamp": "2026-10-29T14:53:04.397Z",
+  "corpus": "svelte",
+  "repo": "https://github.com/sveltejs/svelte.git",
+  "commit": "5895c63",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 1,
+    "absentHeld": 1,
+    "presentCases": 0,
+    "presentHeld": 0,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 30920,
+    "import": 22673,
+    "exact-match": 9040,
+    "qualified-name": 1874,
+    "instance-method": 390,
+    "framework": 220,
+    "function-ref": 196,
+    "file-path": 58,
+    "fuzzy": 13
+  },
+  "edges": 65384,
+  "results": [
+    {
+      "caseId": "svelte-bare-import-bundle",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/evaluation/results/precision-vite-8492422-0ae0b138.json b/__tests__/evaluation/results/precision-vite-8492422-0ae0b138.json
new file mode 100644
index 0000000000..49808c5554
--- /dev/null
+++ b/__tests__/evaluation/results/precision-vite-8492422-0ae0b138.json
@@ -0,0 +1,95 @@
+{
+  "timestamp": "2026-10-29T14:52:56.623Z",
+  "corpus": "vite",
+  "repo": "https://github.com/vitejs/vite.git",
+  "commit": "8492422",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 6,
+    "absentHeld": 6,
+    "presentCases": 2,
+    "presentHeld": 2,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 13392,
+    "import": 11144,
+    "exact-match": 3389,
+    "qualified-name": 1009,
+    "instance-method": 457,
+    "file-path": 197,
+    "function-ref": 163,
+    "framework": 1
+  },
+  "edges": 29752,
+  "results": [
+    {
+      "caseId": "vite-factory-receiver-control",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "function:d321dd128d90578bc69867835ec73ef8",
+          "to": "method:db73e5f5d9c7af61d0f22c5b9971ced3",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-external-receiver-not-project-method",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-bare-import-self-edge",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-bare-import-getEnv",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-fuzzy-nested-resolveConfig-getEnv",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-fuzzy-nested-build-scan",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-sealed-module-defineConfig",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-control-relative-import",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "file:packages/vite/src/node/config.ts",
+          "to": "function:0c2f36c32c5742aee412978220fd5b23",
+          "resolvedBy": "import"
+        }
+      ],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/fixtures/golden/payroll-go.dump b/__tests__/fixtures/golden/payroll-go.dump
index 968514cc3c..7012d043da 100644
--- a/__tests__/fixtures/golden/payroll-go.dump
+++ b/__tests__/fixtures/golden/payroll-go.dump
@@ -572,8 +572,8 @@
 {"source":"function:0ae098aebe4dbe9d71e324db178702ba","target":"struct:19321b921e8669d1052268136951cb96","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayrollCycleRow\"}","line":52,"col":100,"provenance":null}
 {"source":"function:0ae098aebe4dbe9d71e324db178702ba","target":"struct:a7849e2411e6cccc2a1da578922c7004","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayrollCycleUpdateRequest\"}","line":52,"col":72,"provenance":null}
 {"source":"function:0e6d6dd34d39c0ac54c9a7084b8d8ca8","target":"struct:44ba5408fc435805ad63b792fae78895","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"EmployeeRow\"}","line":84,"col":33,"provenance":null}
-{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"instantiates","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":19,"col":43,"provenance":null}
-{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":19,"col":27,"provenance":null}
+{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":19,"col":43,"provenance":null}
+{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":19,"col":27,"provenance":null}
 {"source":"function:13c7c9632913a7b5c4cb3853ae46f74a","target":"function:d82ab6b26c7b41b587b8d940d1c57034","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"scanPayslip\"}","line":71,"col":8,"provenance":null}
 {"source":"function:13c7c9632913a7b5c4cb3853ae46f74a","target":"struct:6c93a0c367bc4b0f4392bc71266af6f6","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipUpdateRequest\"}","line":65,"col":67,"provenance":null}
 {"source":"function:13c7c9632913a7b5c4cb3853ae46f74a","target":"struct:eed7116b6261c410c79b06f6b3a3aebe","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipRow\"}","line":65,"col":90,"provenance":null}
@@ -635,8 +635,8 @@
 {"source":"function:97d5bc1460c9dc0379c4c2016964d601","target":"struct:141301eeb403e252d3f06decd0665c41","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"TimesheetRow\"}","line":71,"col":34,"provenance":null}
 {"source":"function:9a1275209a1a60e56b21de5aba04f222","target":"function:d82ab6b26c7b41b587b8d940d1c57034","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"scanPayslip\"}","line":61,"col":8,"provenance":null}
 {"source":"function:9a1275209a1a60e56b21de5aba04f222","target":"struct:eed7116b6261c410c79b06f6b3a3aebe","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipRow\"}","line":59,"col":61,"provenance":null}
-{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"instantiates","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":23,"col":9,"provenance":null}
-{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":22,"col":12,"provenance":null}
+{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":23,"col":9,"provenance":null}
+{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":22,"col":12,"provenance":null}
 {"source":"function:b11ab260a99f087321b978dfbbcbccbb","target":"function:680f46cf762a57779b8a8dbe6de8c989","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"scanContract\"}","line":49,"col":8,"provenance":null}
 {"source":"function:b11ab260a99f087321b978dfbbcbccbb","target":"struct:8ae9f91523a30c90667e8f5ba09c3fc1","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"ContractRow\"}","line":47,"col":62,"provenance":null}
 {"source":"function:b3b725a56ce5377ac34ef157db4d1170","target":"struct:416d70a4ba3bd67a9d4b7114f2abd3a6","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipDTO\"}","line":40,"col":8,"provenance":null}
@@ -690,7 +690,7 @@
 {"source":"method:18a9696cad4179d634834650c0684f0c","target":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleResponse\"}","line":37,"col":123,"provenance":null}
 {"source":"method:24e3292f2546abebcb9d371572f38e20","target":"struct:f1c05936f2b11591d1f90efa9d981fa7","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Payslip\"}","line":50,"col":76,"provenance":null}
 {"source":"method:2eb01c123ced28db3096d2168949061f","target":"method:412163f69abf5ae22adf9b9141ba79e2","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"mustEmbedUnimplementedPayrollServiceServer\",\"registeredAt\":\"internal/gen/payrollpb/payroll_grpc.pb.go:87\"}","line":69,"col":null,"provenance":"heuristic"}
-{"source":"method:3367319bda79cdcf1fefc366ce7322ac","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"instantiates","metadata":"{\"framework\":\"go\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Payslip\"}","line":102,"col":41,"provenance":null}
+{"source":"method:3367319bda79cdcf1fefc366ce7322ac","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\"}","line":102,"col":41,"provenance":null}
 {"source":"method:3708105303f9a5feb2601fa8f3fe731e","target":"function:5e2796c1fbc4081e6b6f6a4307fe4bc0","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"key\"}","line":45,"col":12,"provenance":null}
 {"source":"method:3708105303f9a5feb2601fa8f3fe731e","target":"struct:f1c05936f2b11591d1f90efa9d981fa7","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Payslip\"}","line":36,"col":57,"provenance":null}
 {"source":"method:3af34007f72fd40aebe0e4504e8228ae","target":"method:24e3292f2546abebcb9d371572f38e20","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"instance-method\",\"refName\":\"s.store.ListByCycle\"}","line":206,"col":15,"provenance":null}
@@ -724,7 +724,7 @@
 {"source":"method:4df364d0c37da3d10e39207b87a94ca8","target":"method:b90cd7088a55c9068e12a8120b256e13","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"RunPayrollCycle\",\"registeredAt\":\"internal/gen/payrollpb/payroll_grpc.pb.go:75\"}","line":66,"col":null,"provenance":"heuristic"}
 {"source":"method:4df364d0c37da3d10e39207b87a94ca8","target":"struct:4325013490f7f7a77604146f5e38c292","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleRequest\"}","line":66,"col":35,"provenance":null}
 {"source":"method:4df364d0c37da3d10e39207b87a94ca8","target":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleResponse\"}","line":66,"col":61,"provenance":null}
-{"source":"method:4f0ac2154c360ad1c55284c03d1f0c73","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":85,"col":49,"provenance":null}
+{"source":"method:4f0ac2154c360ad1c55284c03d1f0c73","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":85,"col":49,"provenance":null}
 {"source":"method:4f57884a5e57e13884848a959e466e9d","target":"function:63f3bd99966467470cbabcb097ad36dd","kind":"calls","metadata":"{\"confidence\":0.7,\"resolvedBy\":\"exact-match\",\"refName\":\"ListPayslipsByCycle\"}","line":66,"col":8,"provenance":null}
 {"source":"method:4f57884a5e57e13884848a959e466e9d","target":"struct:eed7116b6261c410c79b06f6b3a3aebe","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipRow\"}","line":65,"col":76,"provenance":null}
 {"source":"method:578c07e761ce9e31fb80ec2ae5ee7713","target":"struct:4325013490f7f7a77604146f5e38c292","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleRequest\"}","line":47,"col":56,"provenance":null}
@@ -824,7 +824,7 @@
 {"source":"method:e5d8405d7063593214cc4d16d2bbec81","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"payroll.Cycle\"}","line":67,"col":9,"provenance":null}
 {"source":"method:e5d8405d7063593214cc4d16d2bbec81","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"payroll.Cycle\"}","line":73,"col":9,"provenance":null}
 {"source":"method:e5d8405d7063593214cc4d16d2bbec81","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Cycle\"}","line":65,"col":68,"provenance":null}
-{"source":"method:eba91430ad280a0c070af5c64e79d2d0","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Payslip\"}","line":62,"col":51,"provenance":null}
+{"source":"method:eba91430ad280a0c070af5c64e79d2d0","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\"}","line":62,"col":51,"provenance":null}
 {"source":"method:ed702f7226c3efff6b07f6f5afd73bf8","target":"method:59c25996edd43745355454c918ca737d","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"instance-method\",\"refName\":\"s.store.SaveCycle\"}","line":196,"col":8,"provenance":null}
 {"source":"method:ed702f7226c3efff6b07f6f5afd73bf8","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Cycle\"}","line":193,"col":64,"provenance":null}
 {"source":"method:ee60f0f8c18e9fd703205c637e5b5f8d","target":"function:c68d01c236174f79631f8e8222523fa4","kind":"calls","metadata":"{\"confidence\":0.7,\"resolvedBy\":\"exact-match\",\"refName\":\"ListPayrollCycles\"}","line":81,"col":8,"provenance":null}
@@ -962,7 +962,7 @@
 {"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"method:2f3ad781c22d07dedb06b0a2f536ba18","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"method:3f9811f3a17dc661bfba3de069234279","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"method:eba91430ad280a0c070af5c64e79d2d0","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Payslip\"}","line":57,"col":15,"provenance":null}
+{"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\"}","line":57,"col":15,"provenance":null}
 {"source":"struct:f1c05936f2b11591d1f90efa9d981fa7","target":"struct:51160f165aa24865c9ffd701638e08de","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Line\"}","line":53,"col":18,"provenance":null}
 {"source":"struct:f221a626c8918bb65aeb52f4f2641203","target":"method:dd6580e3209a7f4efedb099a9bd5576d","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"variable:02a9b4868be4f999189e4d930af29b95","target":"interface:9382b4b7c3b120f81bd0566fb2d74864","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayrollServiceServer\",\"refKind\":\"calls\"}","line":97,"col":14,"provenance":null}
diff --git a/__tests__/fixtures/golden/tail-langs.dump b/__tests__/fixtures/golden/tail-langs.dump
index 0aa85d6783..14f19a41aa 100644
--- a/__tests__/fixtures/golden/tail-langs.dump
+++ b/__tests__/fixtures/golden/tail-langs.dump
@@ -263,7 +263,7 @@
 {"source":"method:3e8f1a96504ba0922e3ea15fd67c3af7","target":"method:834675ad82e7c76b57d6b7dbd9c4d007","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"_upper\"}","line":14,"col":68,"provenance":null}
 {"source":"method:6371e3682b7f64f04708b1f642de336e","target":"method:1b92f98530b02ea1c9bfb4530bca5eb7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"capitalize\"}","line":8,"col":48,"provenance":null}
 {"source":"method:6371e3682b7f64f04708b1f642de336e","target":"method:88abbd176ab3dd1c582009f2f0c8c792","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"logIt\"}","line":9,"col":8,"provenance":null}
-{"source":"method:bab15b615c718a99979e32483e78a2bd","target":"class:8f245e11bfe6a3d101a39ded206566ec","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Greeter\"}","line":14,"col":39,"provenance":null}
+{"source":"method:bab15b615c718a99979e32483e78a2bd","target":"class:8f245e11bfe6a3d101a39ded206566ec","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Greeter\"}","line":14,"col":39,"provenance":null}
 {"source":"method:bab15b615c718a99979e32483e78a2bd","target":"method:8c9db773f13cb8c0e5a0498432ebc819","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"initWithName:\"}","line":14,"col":37,"provenance":null}
 {"source":"method:bce8c6cce85fec8bd2df9223eaf629de","target":"method:7021a8a0ecfa8d21106abcf10c74a4d3","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"onlyOwner\"}","line":7,"col":52,"provenance":null}
 {"source":"method:c43ae451b29e35763223fd3a5fd1ae22","target":"class:5ed1a9fbfc5fad495850f0cc6ac2970c","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Greeter\"}","line":23,"col":19,"provenance":null}
diff --git a/__tests__/fixtures/golden/torture-multilang.dump b/__tests__/fixtures/golden/torture-multilang.dump
index af86bd28e8..53b8bf0081 100644
--- a/__tests__/fixtures/golden/torture-multilang.dump
+++ b/__tests__/fixtures/golden/torture-multilang.dump
@@ -2040,7 +2040,7 @@
 {"source":"class:129f932b07791059905bc786775e5dff","target":"method:846b59388a77b469427475c32a0d11a3","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:12b0fc1a5b8916f4876df49d6cd78ad7","target":"method:2482c6a39c7a71c514ac4eda10980efa","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:12b8092ee33506020a2ef69ffb0c942f","target":"method:f93cac5b4e9fd958cce4400d8a1fb21a","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:184d52a70ca25ab02246ba53448afd84","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":88,"col":21,"provenance":null}
+{"source":"class:184d52a70ca25ab02246ba53448afd84","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":88,"col":21,"provenance":null}
 {"source":"class:185f6260a8d5b738c53be0accb2a4e19","target":"method:2ea1f4137a11a0863dc001320a6553d4","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:185f6260a8d5b738c53be0accb2a4e19","target":"method:56abbc29e06f18840ab8e081a5955345","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:185f6260a8d5b738c53be0accb2a4e19","target":"method:7e714128b5b3c81a4e4f571a142197ba","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2127,7 +2127,7 @@
 {"source":"class:326854f65c2a15980f69f2865639f179","target":"variable:6adfcec1106f14a610956b32cf60e621","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:339d61243e19865bc9a1abb1bf086ced","target":"class:51e8dab5c341254b6e69fea52526cec0","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"SealedOp\"}","line":121,"col":33,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"class:02b8749f9f3f54ac2e63b9af5107cd67","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"OpenBase\"}","line":103,"col":21,"provenance":null}
-{"source":"class:341082c7a6943c8178f54be340ac5776","target":"interface:c81d5cab63db22eb6f15b7c2253d937e","kind":"implements","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\",\"refKind\":\"extends\"}","line":103,"col":34,"provenance":null}
+{"source":"class:341082c7a6943c8178f54be340ac5776","target":"interface:c81d5cab63db22eb6f15b7c2253d937e","kind":"implements","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\",\"refKind\":\"extends\"}","line":103,"col":34,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"method:45a51bb86d639c728b97972d1987b72b","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"method:6f5a2fd43f38fbf52acfdb0b84cb3b93","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"method:d0c57c6f9abd19cc5263f4b1c36ba5c9","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2165,7 +2165,7 @@
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"constant:b3b1efa0122809a96522516575f0cccb","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"field:32f596742e8806ab7d3138e43bb9b86b","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"field:530469f189a3fea0785da07779d01767","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:5eb14184151e0e35d5705df793db77a4","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"isReady\"}","line":14,"col":23,"provenance":null}
+{"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:5eb14184151e0e35d5705df793db77a4","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"isReady\"}","line":14,"col":23,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:5eb14184151e0e35d5705df793db77a4","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:73b61c8d80bf0af73a67434ab7f4be86","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:fa3938cdf0d608dc9a8646d21c39961c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2195,7 +2195,7 @@
 {"source":"class:54c0d1e485f298b4f9827706f928657f","target":"method:77e06442f583b8a728ecb572f6730060","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:54c0d1e485f298b4f9827706f928657f","target":"method:a7b6861e2ff780d68310f545ca791d3c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:54c0d1e485f298b4f9827706f928657f","target":"method:f11a1632c933108942e00d3b2c940adc","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:54c0d1e485f298b4f9827706f928657f","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":42,"col":86,"provenance":null}
+{"source":"class:54c0d1e485f298b4f9827706f928657f","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":42,"col":86,"provenance":null}
 {"source":"class:5502ac035e1ca2d56c14e093db0d8cec","target":"constant:918bdd1cc2ff2b2cd79d7560e2a8d3e4","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:5545c7494bbd6c81f0a1d85a3cf99570","target":"class:0939ad4dcc3f8b9686a6f2915ddc27f6","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Base\"}","line":73,"col":23,"provenance":null}
 {"source":"class:5545c7494bbd6c81f0a1d85a3cf99570","target":"class:25244cbdbe3e9bc720df9fc4d54fac0a","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"app::Config\"}","line":73,"col":42,"provenance":null}
@@ -2230,7 +2230,7 @@
 {"source":"class:63dc577067a8afeda1988d7d6845f698","target":"method:4a64a3754cd246ad0a17464408bb4625","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:63dc577067a8afeda1988d7d6845f698","target":"method:ec47a62d06708c1f02fc28a967649234","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:65d5c81c60b7d34bc7538930f2e979ac","target":"method:3d1787adb831782b4a90413dd941412b","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:65d5c81c60b7d34bc7538930f2e979ac","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":92,"col":41,"provenance":null}
+{"source":"class:65d5c81c60b7d34bc7538930f2e979ac","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":92,"col":41,"provenance":null}
 {"source":"class:669ed683926cda236e997600e8333886","target":"field:f42ef23569cac66be69e4d9154772969","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:679670ecd455feab2a3da4e81ddddb92","target":"class:ca530cf4e2520283a176c1937131d988","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"ProviderT\"}","line":53,"col":24,"provenance":null}
 {"source":"class:679670ecd455feab2a3da4e81ddddb92","target":"method:7f480d6918f98c10a04c91362d661b3e","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2484,7 +2484,7 @@
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"field:00576f3dd90e6114937e113163da4652","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"field:14b603226804f3f428d49d2f565924f2","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"field:44640a600955ccc0d98ee903194917f8","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:c70093f83659a119eaf917e29e426544","target":"interface:de46be0e109ecba28258bf5ab5ad85c2","kind":"implements","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":7,"col":64,"provenance":null}
+{"source":"class:c70093f83659a119eaf917e29e426544","target":"interface:de46be0e109ecba28258bf5ab5ad85c2","kind":"implements","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":7,"col":64,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"method:2026cf93a3b05afc33179fdef3bd9a2e","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"method:208640df2853621ea9e882dbb7a52d5a","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"method:5a848545dc28c551fa3193ddb28d9b17","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -3929,7 +3929,7 @@
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"class:508cb01a02b2ec3d871fa137a11a8863","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Holder\"}","line":15,"col":14,"provenance":null}
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:1932b46aef9b5a9c946962703eaf2c1c","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localWithNew\"}","line":18,"col":14,"provenance":null}
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:1932b46aef9b5a9c946962703eaf2c1c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:21ca45d9f9601839f9b8698f898ae7d9","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":13,"col":9,"provenance":null}
+{"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:21ca45d9f9601839f9b8698f898ae7d9","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":13,"col":9,"provenance":null}
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:21ca45d9f9601839f9b8698f898ae7d9","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1710f4f05ce5bdd8e1b2662e40746d82","target":"constant:9330a6b515f190e755baa3a37e0d04ba","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
 {"source":"function:1932b46aef9b5a9c946962703eaf2c1c","target":"class:508cb01a02b2ec3d871fa137a11a8863","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Holder\"}","line":15,"col":14,"provenance":null}
@@ -3955,15 +3955,15 @@
 {"source":"function:1c731d01deb9c8e7eb2881eaebba9e58","target":"function:9880cd7d8361fedda327ff0eb3eb37df","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"legacyHelper\"}","line":123,"col":11,"provenance":null}
 {"source":"function:1c731d01deb9c8e7eb2881eaebba9e58","target":"function:f54946f3687d20f9751ad94e97e271d7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"arrow\"}","line":124,"col":17,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:2160a464a79ffdc55d54ec63926e795a","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetK\",\"refKind\":\"calls\"}","line":183,"col":12,"provenance":null}
-{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:58dfebdea413c36d40db63cf5abbf568","kind":"references","metadata":"{\"framework\":\"spring\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Registry\"}","line":188,"col":4,"provenance":null}
+{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:58dfebdea413c36d40db63cf5abbf568","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":188,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:f9fa34d7af7ef38aa701ed9a4fde753e","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"enum:1cf855fc73c828cc6a9624095f50c676","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Color\"}","line":189,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:02ea7e14e3e28772587e5187d6cbde25","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":225,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:02ea7e14e3e28772587e5187d6cbde25","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:195bf407247f64b7e9a36cd403bed18e","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"run\"}","line":205,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:1cb7a6623f4a42c3a29a0ebe06f99a20","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":220,"col":16,"provenance":null}
-{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":223,"col":22,"provenance":null}
+{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":220,"col":16,"provenance":null}
+{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":223,"col":22,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:a835a780a7ca146cededcd8053765be7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"`weird name`\"}","line":237,"col":19,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:c062ca02de706ffe85e7dfb2f9586331","kind":"references","metadata":"{\"confidence\":0.95,\"resolvedBy\":\"function-ref\",\"refName\":\"topLevel\",\"refKind\":\"function_ref\",\"fnRef\":true}","line":209,"col":15,"provenance":null}
@@ -4000,7 +4000,7 @@
 {"source":"function:26ac3e78238b037efdce6f5fac049878","target":"class:ca1f1b5975a06b517d843fd576230997","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Report\"}","line":122,"col":25,"provenance":null}
 {"source":"function:26ac3e78238b037efdce6f5fac049878","target":"class:ca1f1b5975a06b517d843fd576230997","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Report\"}","line":124,"col":29,"provenance":null}
 {"source":"function:2cc9a67de84931c83b539237a3d695b9","target":"class:0ea6b25874f3f2740efdf3fe3093b554","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"FieldDelegator\"}","line":255,"col":84,"provenance":null}
-{"source":"function:2f5b0cdb31144b6c7277428960de2a32","target":"function:2dbfb7bd9188675ef862d45c0d8fd93c","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":192,"col":7,"provenance":null}
+{"source":"function:2f5b0cdb31144b6c7277428960de2a32","target":"function:2dbfb7bd9188675ef862d45c0d8fd93c","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":192,"col":7,"provenance":null}
 {"source":"function:2f5b0cdb31144b6c7277428960de2a32","target":"function:2dbfb7bd9188675ef862d45c0d8fd93c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:31667d19df8f0e5cd5dfb03fb205a8d7","target":"function:077abb142cd38f50fd7aeb4958ac54b7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"register\"}","line":76,"col":10,"provenance":null}
 {"source":"function:31667d19df8f0e5cd5dfb03fb205a8d7","target":"function:112bb390a54043c8ee6b3ee94ba6c956","kind":"references","metadata":"{\"confidence\":0.95,\"resolvedBy\":\"function-ref\",\"refName\":\"hostFn\",\"refKind\":\"function_ref\",\"fnRef\":true}","line":78,"col":28,"provenance":null}
@@ -4108,7 +4108,7 @@
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"class:fa355652331eee519e97b9ef15a61b2d","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetT\"}","line":94,"col":14,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:ba9868d0ac07f6aadd40bfb18b1f232e","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"helper\"}","line":67,"col":8,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:ba9868d0ac07f6aadd40bfb18b1f232e","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"helper\"}","line":83,"col":10,"provenance":null}
-{"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:de3e7760a8bf304d54651b74e6589aa3","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":89,"col":9,"provenance":null}
+{"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:de3e7760a8bf304d54651b74e6589aa3","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":89,"col":9,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:de3e7760a8bf304d54651b74e6589aa3","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"method:2ec7b72739446515eb6fa0e9a847d996","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"qualified-name\",\"refName\":\"WidgetT.named\"}","line":79,"col":15,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"method:8073f837979c32f4ea834666de93ff0e","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"qualified-name\",\"refName\":\"ConfigT.load\"}","line":70,"col":14,"provenance":null}
@@ -4154,7 +4154,7 @@
 {"source":"function:c2971e4b1912de92c9c1e02416630c6b","target":"class:185f6260a8d5b738c53be0accb2a4e19","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Widget\"}","line":59,"col":2,"provenance":null}
 {"source":"function:c2971e4b1912de92c9c1e02416630c6b","target":"method:7e714128b5b3c81a4e4f571a142197ba","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Widget::Widget/0\"}","line":59,"col":2,"provenance":null}
 {"source":"function:ca2a58bf9e2fe349053607e85964f54f","target":"class:fa355652331eee519e97b9ef15a61b2d","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetT\"}","line":56,"col":34,"provenance":null}
-{"source":"function:d06c2607f3378f3f3037272d30c5d24b","target":"function:dd3ddcfaee0976e540855839ddc8e1b0","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":174,"col":7,"provenance":null}
+{"source":"function:d06c2607f3378f3f3037272d30c5d24b","target":"function:dd3ddcfaee0976e540855839ddc8e1b0","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":174,"col":7,"provenance":null}
 {"source":"function:d06c2607f3378f3f3037272d30c5d24b","target":"function:dd3ddcfaee0976e540855839ddc8e1b0","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:d1b22ce81e4dcd9f8f6bd5f508ed2535","target":"class:54c0d1e485f298b4f9827706f928657f","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":26,"col":15,"provenance":null}
 {"source":"function:d7da4b402ad97a64a1766fcf09e392e0","target":"constant:84e8ca2c7ea91f1d3a3ed700ab7c9298","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
@@ -4168,7 +4168,7 @@
 {"source":"function:e611a10f53cb2352067120211e7632b2","target":"class:54c0d1e485f298b4f9827706f928657f","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":10,"col":22,"provenance":null}
 {"source":"function:f11355267c15b025e65a025974c2a4d1","target":"constant:4d2266cb0f452fd0233976ec146c28eb","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
 {"source":"function:f11355267c15b025e65a025974c2a4d1","target":"constant:7af11b36e8d4ddbbdc72a75e5d163a1f","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
-{"source":"function:f42d18d9932ecf98835384d2a581205f","target":"function:e611a10f53cb2352067120211e7632b2","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"topLevel\"}","line":30,"col":26,"provenance":null}
+{"source":"function:f42d18d9932ecf98835384d2a581205f","target":"function:e611a10f53cb2352067120211e7632b2","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"topLevel\"}","line":30,"col":26,"provenance":null}
 {"source":"function:f54946f3687d20f9751ad94e97e271d7","target":"function:9880cd7d8361fedda327ff0eb3eb37df","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"legacyHelper\"}","line":13,"col":21,"provenance":null}
 {"source":"function:fa31a4bba4af75d85403a627a9e62897","target":"module:3e98a45ef089de69c402c540a05c492e","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":108,"col":17,"provenance":null}
 {"source":"function:fa31a4bba4af75d85403a627a9e62897","target":"module:3e98a45ef089de69c402c540a05c492e","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":108,"col":29,"provenance":null}
@@ -4215,7 +4215,7 @@
 {"source":"method:1edca63b63663ee826e2349f6d040e1c","target":"method:fc93d61b2caa73e9feea003464e6332d","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"render\",\"registeredAt\":\"torture.rs:57\"}","line":42,"col":null,"provenance":"heuristic"}
 {"source":"method:212bbb3d2db529e2eb6e8fdd590a7e89","target":"method:d85e75675c9c25670ba7f631481482f8","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"render\"}","line":59,"col":27,"provenance":null}
 {"source":"method:255fc37070ede2ebf60c5b5f53829c63","target":"method:d0c57c6f9abd19cc5263f4b1c36ba5c9","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"draw\",\"registeredAt\":\"torture.kt:106\"}","line":114,"col":null,"provenance":"heuristic"}
-{"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"enum:2301fa8d1a0b010b91450d59386b4020","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Http\"}","line":166,"col":13,"provenance":null}
+{"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"enum:2301fa8d1a0b010b91450d59386b4020","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Http\"}","line":166,"col":13,"provenance":null}
 {"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"module:bc14df23aa624c6e9abad13ed495709a","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":165,"col":13,"provenance":null}
 {"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"module:bc14df23aa624c6e9abad13ed495709a","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":168,"col":4,"provenance":null}
 {"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"module:bc14df23aa624c6e9abad13ed495709a","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":169,"col":12,"provenance":null}
@@ -4296,7 +4296,7 @@
 {"source":"method:62962794279c3c99426ab6031814cfb6","target":"method:df9319e9e35228fc08a4c26bb7cac4dc","kind":"references","metadata":"{\"confidence\":0.95,\"resolvedBy\":\"function-ref\",\"refName\":\"items\",\"refKind\":\"function_ref\",\"fnRef\":true}","line":47,"col":12,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:35d9285764fa4fb28ea1d16db47145a1","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Pair\"}","line":43,"col":24,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:afd19409ef5bc781bca7198f0f8f0f88","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:afd19409ef5bc781bca7198f0f8f0f88","kind":"instantiates","metadata":"{\"framework\":\"spring\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Local\"}","line":45,"col":18,"provenance":null}
+{"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:afd19409ef5bc781bca7198f0f8f0f88","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Local\"}","line":45,"col":18,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:c70093f83659a119eaf917e29e426544","kind":"references","metadata":"{\"framework\":\"spring\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Point\"}","line":43,"col":15,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"constant:f5723290218cacb63dda24a45134f84d","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"method:1d91cdf995f81588bef6345d2c41cab8","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"instance-method\",\"refName\":\"pr.left\"}","line":47,"col":39,"provenance":null}
@@ -4367,7 +4367,7 @@
 {"source":"method:a7103764da0854afee05bc7d100478a4","target":"method:8cc04f699d9a44f457ad849e48334cf2","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"qualified-name\",\"refName\":\"ProviderT.value\"}","line":47,"col":16,"provenance":null}
 {"source":"method:a7b6861e2ff780d68310f545ca791d3c","target":"module:3e98a45ef089de69c402c540a05c492e","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":58,"col":20,"provenance":null}
 {"source":"method:a83a51eab57270a522b9a2b7133e3e55","target":"constant:f3f2f36c072cdfa3d41c0be651e605ce","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
-{"source":"method:a83a51eab57270a522b9a2b7133e3e55","target":"module:7b0b21e64c28c40d1a3a9a73109bc603","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Config\"}","line":12,"col":16,"provenance":null}
+{"source":"method:a83a51eab57270a522b9a2b7133e3e55","target":"module:7b0b21e64c28c40d1a3a9a73109bc603","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Config\"}","line":12,"col":16,"provenance":null}
 {"source":"method:a935b33c83e72d78f5aba957dc6b5362","target":"function:ba9868d0ac07f6aadd40bfb18b1f232e","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"helper\"}","line":55,"col":27,"provenance":null}
 {"source":"method:ac9d754fee3741f21584a0086c577453","target":"struct:0c309a8ed6f33456724d94ba73599e04","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Widget\"}","line":87,"col":8,"provenance":null}
 {"source":"method:ac9d754fee3741f21584a0086c577453","target":"struct:0c309a8ed6f33456724d94ba73599e04","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Self\"}","line":85,"col":28,"provenance":null}
@@ -4474,7 +4474,7 @@
 {"source":"module:3e98a45ef089de69c402c540a05c492e","target":"method:90c2e7d9608647c254c97e9a9cfea8f0","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:3e98a45ef089de69c402c540a05c492e","target":"method:f141417138453a1e069cb41778364534","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:50656f4b2dd953684ccf0569354e5f6a","target":"constant:afa8c28eaee270ee74f5cac2a4bac4f9","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"module:62d09c593067cc591a381d4b61d3c7cc","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":87,"col":22,"provenance":null}
+{"source":"module:62d09c593067cc591a381d4b61d3c7cc","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":87,"col":22,"provenance":null}
 {"source":"module:6e9593e56da8abba78b4de05c2093067","target":"method:1dd50f72d18602fd517764d7d7f38d07","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:6e9593e56da8abba78b4de05c2093067","target":"method:21bccd402845e4d14582f7b3f06c7f98","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:6e9593e56da8abba78b4de05c2093067","target":"method:6d9dc963c222f94eab797e7bbd0151d3","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
diff --git a/__tests__/function-ref-project-imports.test.ts b/__tests__/function-ref-project-imports.test.ts
index 866280dea2..7b32d8839e 100644
--- a/__tests__/function-ref-project-imports.test.ts
+++ b/__tests__/function-ref-project-imports.test.ts
@@ -222,4 +222,19 @@ export function list(present: (fn: unknown) => void): void {
       cg.close();
     }
   }, 60_000);
+
+  it('leaves a name the module does not export unresolved instead of taking an unexported namesake', async () => {
+    const cg = await indexProject({
+      'package.json': PACKAGE_JSON,
+      'tsconfig.json': TSCONFIG,
+      'src/empty.ts': 'export const anchor = 1;\n',
+      'src/other.ts': 'function secret() { return 1; }\nexport const keep = secret;\n',
+      'src/consumer.ts': "import { secret } from './empty';\nfunction register(cb: () => number) { return cb(); }\nregister(secret);\n",
+    });
+    try {
+      expect(fnRefsFrom(cg, 'src/consumer.ts')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  }, 60_000);
 });
diff --git a/__tests__/operator-method-names.test.ts b/__tests__/operator-method-names.test.ts
index b4ffae8fe4..d73cbbd148 100644
--- a/__tests__/operator-method-names.test.ts
+++ b/__tests__/operator-method-names.test.ts
@@ -282,4 +282,26 @@ describe('a method whose name is not a plain word', () => {
     expect(callsFrom(cg, 'src/Vec.scala', lineOf(scala, 'def twice'))).toEqual([`Vec::++@Vec.scala:${lineOf(scala, 'def ++(n: Int, m: Int)')}`]);
     expect(callsFrom(cg, 'src/Weird.kt', lineOf(kotlin, 'fun use()'))).toEqual([`Weird::\`reads (a value\`@Weird.kt:${lineOf(kotlin, 'x: Int, y: Int')}`]);
   }, 120_000);
+
+  it('C++: a comment between the dot and the operator name still reads the arguments', async () => {
+    const hppText = lines(
+      'struct Total {',
+      '  int value = 0;',
+      '  Total& operator+=(int n) { value += n; return *this; }',
+      '  Total& operator+=(const Total& other) { value += other.value; return *this; }',
+      '};',
+    );
+    const cppText = lines(
+      '#include "total.hpp"',
+      'int addUp() {',
+      '  Total a;',
+      '  Total b;',
+      '  b./* note */operator+=(a);',
+      '  return b.value;',
+      '}',
+    );
+    const cg = await index(project({ 'src/total.hpp': hppText, 'src/total.cpp': cppText }));
+    expect(callsFrom(cg, 'src/total.cpp', lineOf(cppText, 'int addUp()')))
+      .toEqual([`Total::operator+=@total.hpp:${lineOf(hppText, 'Total& operator+=(const Total& other)')}`]);
+  }, 120_000);
 });
diff --git a/__tests__/python-typed-builtin-method-calls.test.ts b/__tests__/python-typed-builtin-method-calls.test.ts
index 8f826a33a0..323b10ed02 100644
--- a/__tests__/python-typed-builtin-method-calls.test.ts
+++ b/__tests__/python-typed-builtin-method-calls.test.ts
@@ -281,6 +281,29 @@ def make():
 
 reg = {}
 reg.get("k")
+`,
+  'future_local.py': `class Store:
+    def get(self):
+        return 1
+
+def direct():
+    result = store.get()
+    store = Store()
+    return result
+`,
+  'branches_two.py': `class A:
+    def get(self):
+        return 'A'
+class B:
+    def get(self):
+        return 'B'
+
+def choose(flag):
+    if flag:
+        store = A()
+    else:
+        store = B()
+    return store.get()
 `,
   'outside_base.py': `from somepkg import BaseStore
 
@@ -420,6 +443,14 @@ describe('Python builtin-named methods through typed locals and parameters (#258
   it('links nothing for a method a base from outside the project could hold', () => {
     expect(callsFrom('outside_base.py', 'use_child')).toEqual([]);
   });
+
+  it('links nothing for a local read before its only assignment in the same def', () => {
+    expect(callsFrom('future_local.py', 'direct')).toEqual([]);
+  });
+
+  it('links nothing when branches bind the local to different classes', () => {
+    expect(callsFrom('branches_two.py', 'choose')).toEqual([]);
+  });
 });
 
 describe('sync after an edit to the file a typed local reads (#2583)', () => {
diff --git a/__tests__/ts-export-type-star.test.ts b/__tests__/ts-export-type-star.test.ts
index 4c43299bba..69c9e4407d 100644
--- a/__tests__/ts-export-type-star.test.ts
+++ b/__tests__/ts-export-type-star.test.ts
@@ -159,12 +159,19 @@ describe('a type-only star re-export parses in both engines', () => {
     }
   }
 
-  it.runIf(kernelAvailable)('keeps a re-export as written in a file the kernel hands to the wasm parser', () => {
-    // `export const = ;` is an error, so the kernel defers the whole file.
+  it.runIf(kernelAvailable)('keeps a re-export as written in a file with parse errors', () => {
+    // `export const = ;` is an error. Upstream's kernel defers such a file to
+    // the wasm parser; the fork's extracts the recovered native tree and flags
+    // it not-parsed-clean, so this path asserts the signature survives instead
+    // of the defer.
     const source = 'export type * from "./types.js";\nexport const = ;\n';
     delete process.env.CODEGRAPH_KERNEL;
     process.env.CODEGRAPH_KERNEL_LANGS = 'all';
-    expect(tryKernelExtract('src/broken.ts', source, 'typescript')).toBeNull();
+    const kernelResult = tryKernelExtract('src/broken.ts', source, 'typescript');
+    expect(kernelResult).not.toBeNull();
+    expect(kernelResult?.nodes.filter((n) => n.kind === 'import').map((n) => n.signature)).toEqual([
+      'export type * from "./types.js";',
+    ]);
     const result = extractFromSource('src/broken.ts', source, 'typescript');
     expect(result.nodes.filter((n) => n.kind === 'import').map((n) => n.signature)).toEqual([
       'export type * from "./types.js";',
diff --git a/__tests__/vue-tsx-script.test.ts b/__tests__/vue-tsx-script.test.ts
index d20d1ccae0..c84ab98a22 100644
--- a/__tests__/vue-tsx-script.test.ts
+++ b/__tests__/vue-tsx-script.test.ts
@@ -19,7 +19,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import CodeGraph from '../src/index';
-import { readGrammarWasmBytes } from '../src/extraction/grammars';
+import { hasTreeSitterGrammar } from '../src/extraction/grammars';
 import { syntaxRegionsFor } from '../src/extraction/syntax-tokens';
 import type { Node } from '../src/types';
 
@@ -128,9 +128,15 @@ describe('Vue <script lang="tsx">', () => {
     expect(named(graph.getNodesInFile('src/Legacy.vue'), 'function', 'sum')).toBeDefined();
   });
 
-  it('loads the TSX grammar for a Vue project, and not for a Svelte one', async () => {
-    expect(Object.keys(await readGrammarWasmBytes(['vue'])).sort()).toEqual(['javascript', 'tsx', 'typescript']);
-    expect(Object.keys(await readGrammarWasmBytes(['svelte'])).sort()).toEqual(['javascript', 'typescript']);
+  it('reads a Vue tsx block with the TSX grammar, which the kernel always carries', async () => {
+    // Upstream preloads wasm grammars per project and had to add TSX to Vue's
+    // set; the fork's kernel compiles every grammar in, so the contract is
+    // that TSX parses — the indexing tests above then prove a .vue project's
+    // tsx block never lacks a grammar.
+    expect(hasTreeSitterGrammar('tsx')).toBe(true);
+    const graph = await indexProject();
+    expect(errorsOf(graph, 'src/Title.vue')).toEqual([]);
+    expect(errorsOf(graph, 'src/Card.vue')).toEqual([]);
   });
 
   it('is highlighted in the viewer with the grammar it was indexed with', () => {
diff --git a/codegraph-kernel/src/resolve/call_shape.rs b/codegraph-kernel/src/resolve/call_shape.rs
index cda904aea8..bfab5c5008 100644
--- a/codegraph-kernel/src/resolve/call_shape.rs
+++ b/codegraph-kernel/src/resolve/call_shape.rs
@@ -419,7 +419,17 @@ impl KernelResolver {
                 if facts.infix_site == Some(true) && !is_std_method("kotlin",&r.reference_name) {return Ok(true);}
                 if facts.receiver_type.is_none() { facts.receiver_type = Some(self.kotlin_call_receiver_type(r)?); }
                 if let Some(receiver) = facts.receiver_type.as_ref().and_then(Option::as_ref) {
-                    return self.kotlin_receiver_accepts(n, receiver, r);
+                    if self.resolve_bound_type(&receiver.ty, &receiver.site, 0)?.is_some() {
+                        return self.kotlin_receiver_accepts(n, receiver, r);
+                    }
+                    // The receiver's type is no type the project declares
+                    // (`text(): StringBuilder` — the JDK's): only a
+                    // standard-library name constrains it, as upstream's
+                    // kotlinStdChain does; any other name match stands
+                    // unvetoed (#2822).
+                    return Ok(!is_std_method("kotlin", &r.reference_name)
+                        || site.receiver == "this"
+                        || (!site.receiver.is_empty() && shares_receiver_word(&site.receiver, n)));
                 }
                 Ok(!matches!(n.kind.as_str(), "method" | "function") || site.receiver == "this"
                     || (is_std_method("kotlin",&r.reference_name) && !site.receiver.is_empty() && shares_receiver_word(&site.receiver, n))
diff --git a/codegraph-kernel/src/resolve/cpp_overloads.rs b/codegraph-kernel/src/resolve/cpp_overloads.rs
index 07f7eae086..47c5e775d9 100644
--- a/codegraph-kernel/src/resolve/cpp_overloads.rs
+++ b/codegraph-kernel/src/resolve/cpp_overloads.rs
@@ -44,6 +44,9 @@ const CHAR_TYPES: &[&str] = &["char", "wchar_t", "char8_t", "char16_t", "char32_
 const NUMBER_TYPES: &[&str] = &[
     "int", "unsigned", "signed", "short", "long", "float", "double", "size_t", "ssize_t", "ptrdiff_t",
     "int8_t", "int16_t", "int32_t", "int64_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t", "intptr_t", "uintptr_t",
+    // A container's own integer aliases, by convention: nlohmann/json's `operator[](size_type idx)`
+    // takes a `0` over its `T* key` overload.
+    "size_type", "difference_type",
 ];
 const STRING_TYPES: &[&str] = &["string", "wstring", "string_view", "wstring_view", "basic_string", "basic_string_view"];
 
@@ -390,7 +393,10 @@ impl KernelResolver {
         let callee = shared_regex(&format!(r"(?:^|[.:>])\s*{}(?:\s*<[\s\S]*>)?\s*$", regex::escape(name)))?;
         let mut call = descendant_for_position(tree.root_node(), source.text(), ((r.line - 1).max(0) as usize, r.column.max(0) as usize));
         loop {
-            if call.kind() == "call_expression" && call.child_by_field_name("function").is_some_and(|f| callee.is_match(&source.text()[f.byte_range()])) { break; }
+            if call.kind() == "call_expression"
+                && (call.child_by_field_name("function").is_some_and(|f| callee.is_match(&source.text()[f.byte_range()]))
+                    || cpp_call_has_operator_error(call, source.text(), name))
+            { break; }
             let Some(parent) = call.parent() else { return Ok(None) };
             call = parent;
         }
@@ -520,6 +526,41 @@ fn opening_paren(text: &str, close: usize) -> Option<usize> {
     None
 }
 
+/// Whether `call` is an explicit operator call tree-sitter-cpp could not finish reading: it parses
+/// `b.operator+=(a)` and `s.operator()(4)` as a call on the receiver alone, with the operator's
+/// name stranded in an `ERROR` sibling (`function: (identifier) (ERROR (operator_name))
+/// arguments: …`), so the `function` field never spells the callee. The argument list is still the
+/// call's own; only the name has to come from the error.
+fn cpp_call_has_operator_error(call: tree_sitter::Node, text: &str, name: &str) -> bool {
+    let plain = |spelling: &str| -> String { spelling.chars().filter(|c| !c.is_whitespace()).collect() };
+    let name = plain(name);
+    let mut cursor = call.walk();
+    let mut found = false;
+    for child in call.children(&mut cursor) {
+        if !child.is_error() { continue; }
+        // The grammar still reads the operator's own name when a comment sits
+        // inside the access (`b./* note */operator+=(a)`); the error's raw text
+        // then carries the comment, so compare the name node where there is one.
+        if let Some(operator) = cpp_operator_name_in(child, text) {
+            if plain(operator) == name { found = true; break; }
+            continue;
+        }
+        // No name node: the error starts at the member access, so the text is
+        // `".operator+="` (or the same behind `->`).
+        let spelled = plain(&text[child.byte_range()]);
+        if spelled.trim_start_matches(['.', '-', '>']) == name { found = true; break; }
+    }
+    found
+}
+
+/// The `operator_name` a tree-sitter-cpp error holds, if it read one.
+fn cpp_operator_name_in<'t>(node: tree_sitter::Node, text: &'t str) -> Option<&'t str> {
+    if node.kind() == "operator_name" { return Some(&text[node.byte_range()]); }
+    let mut cursor = node.walk();
+    let children: Vec<_> = node.children(&mut cursor).collect();
+    children.into_iter().find_map(|child| cpp_operator_name_in(child, text))
+}
+
 /// The expanded definition a C++ method that a macro defines carries as its signature
 /// (cpp-macro-methods.ts), `inline const FileDescriptor* Descriptor::file() const` for protobuf's
 /// `PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)`: its source is the
diff --git a/codegraph-kernel/src/resolve/esm_scope.rs b/codegraph-kernel/src/resolve/esm_scope.rs
index ee92edd0c8..f73e1b06a0 100644
--- a/codegraph-kernel/src/resolve/esm_scope.rs
+++ b/codegraph-kernel/src/resolve/esm_scope.rs
@@ -26,6 +26,11 @@ impl KernelResolver {
                 for m in re!(r"(?m)^[ \t]*export\s+(?:default|=)\s+([A-Za-z_$][\w$]*)\s*;?\s*$").captures_iter(&code) {
                     names.insert(m[1].to_string());
                 }
+                // `export default function Disclosure() {}` exports the
+                // declaration's own name to a default import.
+                for m in re!(r"(?m)^[ \t]*export\s+default\s+(?:async\s+)?(?:function|class)\s+([A-Za-z_$][\w$]*)").captures_iter(&code) {
+                    names.insert(m[1].to_string());
+                }
                 for m in re!(r"(?m)^[ \t]*export\s+default\s*\{([^}]*)\}|(?-u:\b)return\s*\{([^{}]*)\}").captures_iter(&code) {
                     for item in m.get(1).or_else(|| m.get(2)).unwrap().as_str().split(',') {
                         let value = item.rsplit(':').next().unwrap_or("").trim();
diff --git a/codegraph-kernel/src/resolve/fields.rs b/codegraph-kernel/src/resolve/fields.rs
index b6bf6326a4..15763e31af 100644
--- a/codegraph-kernel/src/resolve/fields.rs
+++ b/codegraph-kernel/src/resolve/fields.rs
@@ -60,7 +60,10 @@ impl KernelResolver {
                     continue;
                 };
                 // The package directory that declares the field's type: the
-                // imported package for `pkg.Type`, else the struct's own.
+                // imported package for `pkg.Type`; for a bare name the
+                // struct's own package or one its file dot-imports — none of
+                // the project's for a name only an outside package can give
+                // the file.
                 let pkg_dir = if raw_type.contains('.') {
                     let pkg = raw_type.split('.').next().unwrap_or("");
                     match self.go_imported_package_dir(&s.file_path, pkg)? {
@@ -68,7 +71,10 @@ impl KernelResolver {
                         None => continue,
                     }
                 } else {
-                    pos_dirname(&s.file_path).to_string()
+                    match self.go_bare_type_dir(&raw_type, &s.file_path)? {
+                        Some(dir) => dir,
+                        None => continue,
+                    }
                 };
                 let Some(field_type) = raw_type.split('.').next_back() else {
                     continue;
@@ -81,6 +87,14 @@ impl KernelResolver {
                 {
                     continue;
                 }
+                // Nor is an alias of an outside type (`ctx Ctx` with
+                // `type Ctx = context.Context`): read in the struct's file.
+                if matches!(
+                    self.go_written_type(&raw_type, &r.clone().at(&s))?,
+                    Some(super::go_asserted::GoAsserted::Outside)
+                ) {
+                    continue;
+                }
                 if let Some(c) = self.go_method_in_package(field_type, method, &pkg_dir, r)? {
                     return Ok(Some(c));
                 }
@@ -89,6 +103,154 @@ impl KernelResolver {
         Ok(None)
     }
 
+    /// goDotImports (name-matcher.ts): the project package directories
+    /// `file_path` dot-imports (`import . "…"`), whether a dot import lies
+    /// outside the project's modules, and — only when an outside one does —
+    /// the names the file's own `type` declarations use.
+    pub(super) fn go_dot_imports(&mut self, file_path: &str) -> Res<GoDotImports> {
+        if let Some(hit) = self.go_dot_imports_memo.get(file_path) {
+            return Ok(hit.clone());
+        }
+        let mut found = GoDotImports::default();
+        for import in self.import_mappings(file_path)?.iter().filter(|i| i.local_name == ".") {
+            if let Some(dir) = self.go_package_dir(&import.source, file_path) {
+                found.dirs.push(dir);
+            } else if !import.source.starts_with('.') && !import.source.contains("/internal/") {
+                found.outside = true;
+            }
+        }
+        if found.outside {
+            let mut types = HashSet::new();
+            if let Some(lines) = self.read_file(file_path) {
+                for line in lines.iter() {
+                    for m in re!(r"(?:^|[^\w.])type\s+([A-Za-z_]\w*)").captures_iter(&strip_line_comments(line)) {
+                        types.insert(m[1].to_string());
+                    }
+                }
+            }
+            found.types = types;
+        }
+        self.go_dot_imports_memo.insert(file_path.to_string(), found.clone());
+        Ok(found)
+    }
+
+    /// goPackageTypes (name-matcher.ts): the Go type declarations named
+    /// `name` in the package at `dir`.
+    pub(super) fn go_package_types(&mut self, name: &str, dir: &str) -> Res<Vec<Arc<KNode>>> {
+        Ok(self.nodes_by_name(name)?.iter()
+            .filter(|n| n.language == "go"
+                && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
+                && pos_dirname(&n.file_path) == dir)
+            .cloned().collect())
+    }
+
+    /// goBareTypeDir (name-matcher.ts): the package directory Go reads a
+    /// bare type name from — the file's own package, else a package of the
+    /// project the file dot-imports that declares it. `None` for an
+    /// exported name only a package from outside the project can give the
+    /// file (`. "github.com/onsi/gomega"`): no type of the project's. The
+    /// file's own package when no package declares the name — a type the
+    /// index doesn't hold, like one a function declares.
+    pub(super) fn go_bare_type_dir(&mut self, name: &str, file_path: &str) -> Res<Option<String>> {
+        let own = pos_dirname(file_path).to_string();
+        let dots = self.go_dot_imports(file_path)?;
+        if (dots.dirs.is_empty() && !dots.outside) || !self.go_package_types(name, &own)?.is_empty() {
+            return Ok(Some(own));
+        }
+        for dir in &dots.dirs {
+            if !self.go_package_types(name, dir)?.is_empty() {
+                return Ok(Some(dir.clone()));
+            }
+        }
+        if !dots.outside || !re!(r"^[A-Z]\w*$").is_match(name) {
+            return Ok(Some(own));
+        }
+        Ok(dots.types.contains(name).then_some(own))
+    }
+
+    /// goAliasTarget (name-matcher.ts): the project type a `type X = T`
+    /// declaration names — `Null` when X is no project type's (a builtin or
+    /// a type from outside the modules), `Unknown` when the node is no alias
+    /// or its target can't be read.
+    pub(super) fn go_alias_target(&mut self, type_node: &KNode) -> Res<GoAliasTarget> {
+        if type_node.kind != "type_alias" {
+            return Ok(GoAliasTarget::Unknown);
+        }
+        if let Some(hit) = self.go_alias_target_memo.get(&type_node.id) {
+            return Ok(hit.clone());
+        }
+        let Some(lines) = self.read_file(&type_node.file_path) else {
+            return Ok(GoAliasTarget::Unknown);
+        };
+        // From the alias's name, where the node starts, to the end of its type.
+        let decl = lines.iter()
+            .skip((type_node.start_line - 1).max(0) as usize)
+            .take((type_node.end_line - type_node.start_line + 1).max(0) as usize)
+            .enumerate()
+            .map(|(i, l)| {
+                let s = if i == 0 { &l[type_node.start_column.max(0) as usize..] } else { l.as_str() };
+                strip_line_comments(s).to_string()
+            })
+            .collect::<Vec<_>>()
+            .join(" ");
+        let decl = re!(r"/\*.*?\*/").replace_all(&decl, "");
+        // `Name =` or `Name[T any] =`; a defined type has no `=` there.
+        let head = re!(r"^\s*[A-Za-z_]\w*\s*(?:\[[^\]]*\])?\s*=").captures(&decl);
+        let target = match head {
+            None => GoAliasTarget::Unknown,
+            Some(head) => {
+                let m = re!(r"^\s*(?:\*\s*)?([A-Za-z_]\w*)(?:\s*\.\s*([A-Za-z_]\w*))?\s*(?:\[.*\])?\s*;?\s*$")
+                    .captures(&decl[head.get(0).unwrap().end()..]);
+                match m {
+                    None => GoAliasTarget::Null,
+                    Some(m) => {
+                        let (bare, name) = match m.get(2) {
+                            Some(second) => (false, second.as_str().to_string()),
+                            None => (true, m[1].to_string()),
+                        };
+                        let pkg_dir = if bare {
+                            self.go_bare_type_dir(&name, &type_node.file_path)?
+                        } else {
+                            self.go_imported_package_dir(&type_node.file_path, &m[1])?
+                        };
+                        match pkg_dir {
+                            Some(dir) if !bare || !GO_BUILTIN_FIELD_TYPES.contains(name.as_str()) => {
+                                GoAliasTarget::Target(name, dir)
+                            }
+                            _ => GoAliasTarget::Null,
+                        }
+                    }
+                }
+            }
+        };
+        self.go_alias_target_memo.insert(type_node.id.clone(), target.clone());
+        Ok(target)
+    }
+
+    /// goDotImportedSupertype (name-matcher.ts): what a Go embedding written
+    /// bare (`*Manager`) names — the type of the package the file
+    /// dot-imports that declares it, not another package's namesake, and
+    /// nothing for a name only a package from outside the project can give
+    /// the file. `None` vetoes the pick; `Some` gives the node to use,
+    /// which may be `cand` unchanged.
+    pub(super) fn go_dot_imported_supertype(&mut self, cand: &Arc<KNode>, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if !re!(r"^[A-Za-z_]\w*$").is_match(&r.reference_name) {
+            return Ok(Some(cand.clone()));
+        }
+        let own = pos_dirname(&r.file_path).to_string();
+        let Some(dir) = self.go_bare_type_dir(&r.reference_name, &r.file_path)? else {
+            return Ok(None);
+        };
+        if dir == own || self.go_written_qualifier(r)?.is_some() {
+            return Ok(Some(cand.clone()));
+        }
+        if pos_dirname(&cand.file_path) == dir {
+            return Ok(Some(cand.clone()));
+        }
+        let types = self.go_package_types(&r.reference_name, &dir)?;
+        Ok(prefer_call_site_file(types, &r.file_path).into_iter().next().or_else(|| Some(cand.clone())))
+    }
+
     /// The module directory of the package `file_path` imports as `pkg`:
     /// `None` when `pkg` is no import there or names a package outside the
     /// module.
@@ -140,7 +302,14 @@ impl KernelResolver {
             .collect();
         let in_pkg: Vec<Arc<KNode>> =
             named.into_iter().filter(|m| pos_dirname(&m.file_path) == pkg_dir).collect();
-        if in_pkg.is_empty() { return self.go_promoted_method(type_name, method, pkg_dir, r); }
+        if in_pkg.is_empty() {
+            // A file of the package the index couldn't read may declare the
+            // method — the graph's gap is not a promoted method's place.
+            if self.go_unread_file_declares(type_name, method, pkg_dir)? {
+                return Ok(None);
+            }
+            return self.go_promoted_method(type_name, method, pkg_dir, r);
+        }
         if r.reference_kind == "function_ref" && in_pkg.len() != 1 { return Ok(None); }
         let ordered = prefer_call_site_file(in_pkg, &r.file_path);
         Ok(Some(KCand { node: ordered[0].clone(), confidence: 0.85, resolved_by: "instance-method" }))
@@ -161,7 +330,9 @@ impl KernelResolver {
             return Ok(self.go_imported_package_dir(file, pkg)?
                 .map(|dir| (name.to_string(), dir)));
         }
-        Ok(Some((named.to_string(), pos_dirname(file).to_string())))
+        // A bare type name reads from the file's own package or one it
+        // dot-imports (goBareTypeDir): `None` when it can't be told.
+        Ok(self.go_bare_type_dir(named, file)?.map(|dir| (named.to_string(), dir)))
     }
 
     /// A named term in an interface is a supertype only if its declaration
@@ -418,6 +589,7 @@ impl KernelResolver {
                 }
                 let rest = &line[at + field.len() + caps.get(0).map_or(0, |m| m.end())..];
                 return Ok(Some(TsFieldDecl {
+                    element: ts_field_element(&caps[1], rest, &source, line_no),
                     ty: caps[1].to_string(),
                     value_type: false,
                     typed_collection: guard1_tail_re().is_match(rest),
@@ -444,7 +616,9 @@ impl KernelResolver {
                         continue;
                     }
                     let rest = &line[m.end..];
+                    let element = if *value_type { None } else { ts_field_element(&line[gs..ge], rest, &source, line_no) };
                     return Ok(Some(TsFieldDecl {
+                        element,
                         ty: line[gs..ge].to_string(),
                         value_type: *value_type,
                         typed_collection: guard1_tail_re().is_match(rest),
@@ -467,6 +641,7 @@ impl KernelResolver {
                 if declares && self.ts_init_is_read(owner, &source, start + i, &init)? {
                     let rest = &line[init.end..];
                     return Ok(Some(TsFieldDecl {
+                        element: None,
                         ty: init.ty,
                         value_type: false,
                         typed_collection: guard1_tail_re().is_match(rest),
@@ -1096,15 +1271,39 @@ impl KernelResolver {
         self.resolve_rust_module_file(&segs[..segs.len() - 1], &owner.file_path)
     }
 
+    /// `this.<field>[k].<method>()` calls the element's type: what the field's
+    /// declaration writes for it, or nothing. A type parameter of the
+    /// declaring class names no type (`class Store<Item> { items: Item[] }`),
+    /// whatever project class shares its name.
+    fn ts_field_held(&mut self, decl: TsFieldDecl, cls: &KNode, element: bool) -> Res<Option<TsFieldDecl>> {
+        if !element {
+            return Ok(Some(decl));
+        }
+        let Some(element_ty) = decl.element.clone() else { return Ok(None) };
+        if decl.value_type || self.ts_class_type_parameter(cls, &element_ty) {
+            return Ok(None);
+        }
+        Ok(Some(TsFieldDecl {
+            element: None,
+            ty: element_ty,
+            value_type: false,
+            typed_collection: false,
+            array: false,
+            nullable: false,
+        }))
+    }
+
     /// matchTsThisFieldCall — the `this.field.method` entry point of
     /// matchMethodCall's requireReceiverEvidence=false arm. The owner is the
     /// enclosing class written on the calling method's qualified name, so it
     /// is not a guess — same exclusive discipline as the go/rust field arms.
+    /// `element` selects the field's element type (`this.<field>[].<method>`).
     pub(super) fn match_ts_this_field_call(
         &mut self,
         field: &str,
         method: &str,
         r: &ResolveRefIn,
+        element: bool,
     ) -> Res<Option<KCand>> {
         if field.is_empty() || field.contains('.') {
             return Ok(None);
@@ -1126,7 +1325,7 @@ impl KernelResolver {
         if owner.is_empty() {
             return Ok(None);
         }
-        self.match_ts_field_call_free(owner, field, method, r)
+        self.match_ts_field_call_free(owner, field, method, r, element)
     }
 
     /// matchTsFieldCall without boundOwner — the unbound variant used by the
@@ -1141,6 +1340,7 @@ impl KernelResolver {
         field: &str,
         method: &str,
         r: &ResolveRefIn,
+        element: bool,
     ) -> Res<Option<KCand>> {
         let owners = prefer_call_site_file(
             self.nodes_by_name(owner)?
@@ -1159,14 +1359,17 @@ impl KernelResolver {
         // nothing about this one's field.
         let mut found: Vec<(TsFieldDecl, Arc<KNode>)> = Vec::new();
         for cls in owners.iter().filter(|c| c.file_path == r.file_path) {
-            if let Some(hit) = self.ts_field_through_bases(cls, field, r, 0)? {
-                found.push(hit);
+            if let Some((decl, cls)) = self.ts_field_through_bases(cls, field, r, 0)? {
+                if let Some(decl) = self.ts_field_held(decl, &cls, element)? {
+                    found.push((decl, cls));
+                }
                 break;
             }
         }
         if found.is_empty() {
             for cls in owners.iter().filter(|c| c.file_path != r.file_path) {
-                let Some(decl) = self.ts_field_decl(cls, field)? else { continue };
+                let Some(read) = self.ts_field_decl(cls, field)? else { continue };
+                let Some(decl) = self.ts_field_held(read, cls, element)? else { continue };
                 if self.ts_type_visible_in(&decl.ty, r)? {
                     // The type is the class the call's file names.
                     let mut at = (**cls).clone();
@@ -1524,6 +1727,28 @@ fn ts_array_suffix_re() -> Rc<Regex> {
     re!(r"^\s*(?:<[^;=(){}<>]*(?:<[^;=(){}<>]*>[^;=(){}<>]*)*>)?\s*\[\s*\]")
 }
 
+/// goDotImports' answer (name-matcher.ts).
+#[derive(Clone, Default)]
+pub(super) struct GoDotImports {
+    pub(super) dirs: Vec<String>,
+    pub(super) outside: bool,
+    pub(super) types: HashSet<String>,
+}
+
+/// goAliasTarget's answer (name-matcher.ts).
+#[derive(Clone)]
+pub(super) enum GoAliasTarget {
+    /// A project type the alias names (`name`, package `dir`). Carried for
+    /// the callers that follow an alias to its type (the unread-file and
+    /// indexed-receiver Go ports); the alias-outside check only reads Null.
+    #[allow(dead_code)]
+    Target(String, String),
+    /// No project type — a builtin or a type from outside the modules.
+    Null,
+    /// Not a type alias, or its target can't be read.
+    Unknown,
+}
+
 /// A TypeScript class-field declaration found by `ts_field_decl`.
 pub(super) struct TsFieldDecl {
     /// The declared type text (`Mailer`, `ns.Mailer`, the `typeof` operand).
@@ -1536,6 +1761,103 @@ pub(super) struct TsFieldDecl {
     pub(super) array: bool,
     /// The only union members after the type are `undefined`/`null`.
     pub(super) nullable: bool,
+    /// What one of the field's elements holds: `Item` of `Item[]`, `Array<Item>` or `Record<string, Item>`.
+    pub(super) element: Option<String>,
+}
+
+/// Whether what follows a field's type joins it with another type: `| Other[]`,
+/// `& Extra`. `| null` and `| undefined` do not.
+fn ts_joins_another_type(tail: &str) -> bool {
+    let mut rest = tail.trim_start();
+    while let Some(t) = rest.strip_prefix('|') {
+        let t = t.trim_start();
+        if let Some(t) = t.strip_prefix("null").or_else(|| t.strip_prefix("undefined")) {
+            let mut b = t.as_bytes().iter();
+            if matches!(b.next(), None | Some(b' ' | b'\t' | b'|' | b'&' | b';' | b'=' | b')' | b',' | b'<' | b'{' | b'[' | b'/' | b'\n' | b'\r')) {
+                rest = t.trim_start();
+                continue;
+            }
+        }
+        break;
+    }
+    rest.starts_with('|') || rest.starts_with('&')
+}
+
+/// Container types whose element type is one of their type arguments, and which.
+fn ts_element_container(ty: &str) -> Option<(usize, usize)> {
+    match ty {
+        "Array" | "ReadonlyArray" => Some((1, 0)),
+        "Record" => Some((2, 1)),
+        _ => None,
+    }
+}
+
+/// The type an element of a field holds, from the field's written type (`ty`)
+/// and what follows it on the line (`rest`): `Item` of `Item[]`, `Array<Item>`
+/// and `Record<string, Item>`. None for any other type, an array of arrays, an
+/// element that is not a plain type name (a union, a generic), or a field
+/// typed as a union with another type (`Item[] | Other[]`); `| null` and
+/// `| undefined` leave the element as it is.
+fn ts_field_element_type(ty: &str, rest: &str) -> Option<String> {
+    let plain = |t: &str| -> Option<String> {
+        let ok = !t.is_empty()
+            && t.bytes().next().is_some_and(|b| b.is_ascii_alphabetic() || b == b'_' || b == b'$')
+            && t.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'$' || b == b'.');
+        ok.then(|| t.to_string())
+    };
+    let trimmed = rest.trim_start();
+    if let Some(tail) = trimmed.strip_prefix("[]") {
+        return (!tail.trim_start().starts_with('[') && !ts_joins_another_type(tail)).then(|| ty.to_string());
+    }
+    let (args_n, at) = ts_element_container(ty)?;
+    if !trimmed.starts_with('<') {
+        return None;
+    }
+    let mut depth = 0i32;
+    let mut from = rest.len() - trimmed.len() + 1;
+    let mut args: Vec<String> = Vec::new();
+    let bytes = rest.as_bytes();
+    let mut i = from;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'<' | b'(' | b'[' | b'{' => depth += 1,
+            b'>' | b')' | b']' | b'}' if depth > 0 => depth -= 1,
+            b',' if depth == 0 => {
+                args.push(rest[from..i].trim().to_string());
+                from = i + 1;
+            }
+            b'>' if depth == 0 => {
+                args.push(rest[from..i].trim().to_string());
+                let tail = &rest[i + 1..];
+                if tail.trim_start().starts_with('[') || ts_joins_another_type(tail) {
+                    return None;
+                }
+                return (args.len() == args_n).then(|| args.get(at)).flatten().and_then(|a| plain(a));
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+
+/// The field's element type, with the multi-line guard of tsFieldRead: a type
+/// that goes on below with `| Other[]` holds no one element type.
+fn ts_field_element(ty: &str, rest: &str, source: &SourceFile, line_no: i64) -> Option<String> {
+    let element = ts_field_element_type(ty, rest)?;
+    let mut below = String::new();
+    let mut r = line_no as usize;
+    while let Some(raw) = source.get(r) {
+        let line = strip_line_comments(raw);
+        let t = line.trim_start();
+        if !t.starts_with('|') && !t.starts_with('&') {
+            break;
+        }
+        below.push(' ');
+        below.push_str(t);
+        r += 1;
+    }
+    (!ts_joins_another_type(&below)).then_some(element)
 }
 
 /// Whether the class's constructor passes `field` as an argument of `super(...)`,
diff --git a/codegraph-kernel/src/resolve/go_asserted.rs b/codegraph-kernel/src/resolve/go_asserted.rs
index 2641b80f5d..e30c9ba06a 100644
--- a/codegraph-kernel/src/resolve/go_asserted.rs
+++ b/codegraph-kernel/src/resolve/go_asserted.rs
@@ -13,6 +13,7 @@
 //! name some other way and is left to the other receiver inference.
 
 use super::*;
+use super::fields::GoAliasTarget;
 use tree_sitter::Node as TsNode;
 
 /// What a Go type written at a call site names.
@@ -30,7 +31,7 @@ enum Declared {
     Other,
 }
 
-fn text_of<'a>(node: TsNode, text: &'a str) -> &'a str {
+pub(super) fn text_of<'a>(node: TsNode, text: &'a str) -> &'a str {
     &text[node.start_byte()..node.end_byte()]
 }
 
@@ -50,10 +51,10 @@ fn declared_by(names: &[TsNode], values: Option<TsNode>, typed: bool, name: &str
     Some(asserted.map_or(Declared::Other, Declared::Asserted))
 }
 
-fn identifiers<'t>(list: TsNode<'t>) -> Vec<TsNode<'t>> {
-    if list.kind() == "identifier" { return vec![list]; }
+pub(super) fn identifiers<'t>(list: TsNode<'t>) -> Vec<TsNode<'t>> {
+    if matches!(list.kind(), "identifier" | "blank_identifier") { return vec![list]; }
     let mut cursor = list.walk();
-    list.named_children(&mut cursor).filter(|n| n.kind() == "identifier").collect()
+    list.named_children(&mut cursor).filter(|n| matches!(n.kind(), "identifier" | "blank_identifier")).collect()
 }
 
 /// `name`'s declaration among one statement, if the statement declares it.
@@ -170,7 +171,14 @@ impl KernelResolver {
     /// the index cannot tell (a type literal, a type declared inside a
     /// function, a type parameter): the call goes to the other strategies.
     pub(super) fn go_written_type(&mut self, written: &str, r: &ResolveRefIn) -> Res<Option<GoAsserted>> {
-        let Some(hit) = re!(r"^\*?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[\s\S]*\])?$").captures(written.trim()) else { return Ok(None); };
+        let w = written.trim();
+        // A type the source spells without a named holder — `func() T`,
+        // `struct{…}`, `[]T`, `map[K]V`, `chan T`, `interface{…}` — is no
+        // project type's: terminal, not a name-match cue.
+        if re!(r"^\*?\s*(func\b|struct\b|interface\b|map\s*\[|chan\b|<-|\[)").is_match(w) {
+            return Ok(Some(GoAsserted::Outside));
+        }
+        let Some(hit) = re!(r"^\*?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[\s\S]*\])?$").captures(w) else { return Ok(None); };
         let qualifier = hit.get(1).map(|m| m.as_str().to_string());
         let name = hit[2].to_string();
         let declared = self.nodes_by_name(&name)?.iter()
@@ -183,15 +191,30 @@ impl KernelResolver {
                 Some(_) => return Ok(None),
             }
         } else {
-            let mut dirs = vec![pos_dirname(&r.file_path).to_string()];
-            for import in self.import_mappings(&r.file_path)?.iter().filter(|i| i.local_name == ".") {
-                if let Some(dir) = self.go_package_dir(&import.source, &r.file_path) { dirs.push(dir); }
-            }
-            match dirs.into_iter().find(|d| declared.contains(d)) {
-                Some(dir) => dir,
-                None => return Ok(GO_BUILTIN_FIELD_TYPES.contains(name.as_str()).then_some(GoAsserted::Outside)),
+            let Some(dir) = self.go_bare_type_dir(&name, &r.file_path)? else {
+                return Ok(Some(GoAsserted::Outside));
+            };
+            if !declared.contains(&dir) {
+                return Ok(GO_BUILTIN_FIELD_TYPES.contains(name.as_str()).then_some(GoAsserted::Outside));
             }
+            dir
         };
+        // An alias of a type from outside the project (`type Ctx =
+        // context.Context`) has that type's methods, none the project
+        // declares. Every declaration an outside alias means none here.
+        let types = self.go_package_types(&name, &dir)?;
+        if !types.is_empty() {
+            let mut all_outside_alias = true;
+            for t in &types {
+                if !matches!(self.go_alias_target(t)?, GoAliasTarget::Null) {
+                    all_outside_alias = false;
+                    break;
+                }
+            }
+            if all_outside_alias {
+                return Ok(Some(GoAsserted::Outside));
+            }
+        }
         Ok(Some(GoAsserted::Project { name, dir }))
     }
 
@@ -203,32 +226,81 @@ impl KernelResolver {
     }
 
     /// The verdict for `receiver.method` when the receiver is an asserted
-    /// local: the method the asserted type has, or nothing. `None`: not an
-    /// asserted local; the other strategies decide.
+    /// local: the method the asserted type has, or nothing — a miss and a
+    /// type the index cannot read are both terminal; the fork never guesses
+    /// a callee for an asserted receiver by name. `None`: not an asserted
+    /// local; the other strategies decide.
     pub(super) fn go_asserted_member(&mut self, receiver: &str, method: &str, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
-        Ok(match self.go_asserted_local(receiver, r)? {
-            None => None,
-            Some(GoAsserted::Outside) => Some(None),
-            Some(GoAsserted::Project { name, dir }) => Some(self.go_method_in_package(&name, method, &dir, r)?),
-        })
+        let Some(written) = self.go_asserted_local_type(receiver, r) else { return Ok(None); };
+        Ok(Some(match self.go_written_type(&written, r)? {
+            Some(GoAsserted::Outside) => None,
+            Some(GoAsserted::Project { name, dir }) => self.go_method_in_package(&name, method, &dir, r)?,
+            None => {
+                // An exported type the file declares — `type T interface`
+                // inside the function — is no index node; its call goes to
+                // the name strategies, as before. A literal, an unexported
+                // or an unknown name stays refused: the fork never guesses
+                // a callee for an asserted receiver it cannot type.
+                let bare = written.trim_start_matches('*').rsplit('.').next().unwrap_or("");
+                let local = Self::go_named_type(&written).is_some()
+                    && bare.chars().next().is_some_and(|c| c.is_uppercase())
+                    && self.go_bare_type_dir(bare, &r.file_path)?.is_some();
+                if local { self.go_mc_untyped_local = true; return Ok(None); }
+                None
+            }
+        }))
     }
 }
 
 /// An actual lexical declaration, including the name's position for reading
 /// its initializer. Used by func-field synthesis through the native bridge.
-fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
-    fn names<'a>(decl: TsNode<'a>, name: &str, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
-        let mut cursor = decl.walk();
-        let target = decl.children_by_field_name("name", &mut cursor).find(|n| text_of(*n, text) == name)?;
-        Some((target, decl.child_by_field_name("type").map(|t| text_of(t, text).to_string())))
+pub(super) fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
+    /// `x := &pkg.T{…}`, `x := T{…}`, `x := new(T)` and `var x = &T{…}`
+    /// write their type in the value; other right-hand sides say nothing.
+    /// `k` is the name's place among the declaration's names — the value
+    /// list's same place is its initializer.
+    fn value_type<'a>(value: Option<TsNode<'a>>, k: usize, text: &'a str) -> Option<String> {
+        let mut v = value?;
+        if v.kind() == "expression_list" {
+            v = if v.named_child_count() > k { v.named_child(k)? } else { v.named_child(v.named_child_count() - 1)? };
+        }
+        while v.kind() == "parenthesized_expression" {
+            v = v.named_child(0)?;
+        }
+        if v.kind() == "unary_expression" {
+            if text.get(v.start_byte()..v.start_byte() + 1)? != "&" { return None; }
+            v = v.named_child(0)?;
+        }
+        match v.kind() {
+            "composite_literal" => v.child_by_field_name("type").map(|t| text_of(t, text).to_string()),
+            // A type switch's `x := v.(type)` binds a per-clause type the
+            // declaration does not spell: unreadable, never a project type.
+            "type_assertion_expression" => Some(match v.child_by_field_name("type") {
+                Some(t) if text_of(t, text) != "type" => text_of(t, text).to_string(),
+                _ => "<type>".to_string(),
+            }),
+            "call_expression" => {
+                let function = v.child_by_field_name("function")?;
+                if function.kind() != "identifier" || !matches!(text_of(function, text), "new" | "make") { return None; }
+                v.child_by_field_name("arguments")?.named_child(0).map(|t| text_of(t, text).to_string())
+            }
+            _ => None,
+        }
     }
     fn statement<'a>(stmt: TsNode<'a>, name: &str, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
         match stmt.kind() {
             "short_var_declaration" | "range_clause" => {
-                let target = identifiers(stmt.child_by_field_name("left")?).into_iter().find(|n| text_of(*n, text) == name)?;
-                Some((target, None))
+                let names = identifiers(stmt.child_by_field_name("left")?);
+                let (k, target) = names.iter().enumerate().find(|(_, n)| text_of(**n, text) == name).map(|(k, n)| (k, *n))?;
+                Some((target, value_type(stmt.child_by_field_name("right"), k, text)))
+            }
+            "var_spec" | "const_spec" | "parameter_declaration" | "variadic_parameter_declaration" => {
+                let mut c = stmt.walk();
+                let names: Vec<_> = stmt.children_by_field_name("name", &mut c).collect();
+                let (k, target) = names.iter().enumerate().find(|(_, n)| text_of(**n, text) == name).map(|(k, n)| (k, *n))?;
+                let declared = stmt.child_by_field_name("type").map(|t| text_of(t, text).to_string());
+                Some((target, declared.or_else(|| value_type(stmt.child_by_field_name("value"), k, text))))
             }
-            "var_spec" | "const_spec" | "parameter_declaration" | "variadic_parameter_declaration" => names(stmt, name, text),
             "var_declaration" | "const_declaration" | "var_spec_list" | "parameter_list" => {
                 let mut c = stmt.walk();
                 stmt.named_children(&mut c).filter_map(|s| statement(s, name, text)).last()
@@ -243,7 +315,17 @@ fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &s
         }
         "if_statement" | "expression_switch_statement" | "type_switch_statement" | "for_statement" => {
             if let Some(alias) = scope.child_by_field_name("alias").filter(|n| n.end_byte() <= site) {
-                if let Some(target) = identifiers(alias).into_iter().find(|n| text_of(*n, text) == name) { return Some((target,None)); }
+                let decl = if alias.kind() == "short_var_declaration" { Some(alias) } else {
+                    let mut c = alias.walk();
+                    let mut it = alias.named_children(&mut c);
+                    it.find(|n| n.kind() == "short_var_declaration")
+                };
+                if let Some(d) = decl {
+                    let names = identifiers(d.child_by_field_name("left")?);
+                    if let Some((k, target)) = names.iter().enumerate().find(|(_, n)| text_of(**n, text) == name).map(|(k, n)| (k, *n)) {
+                        return Some((target, value_type(d.child_by_field_name("right"), k, text)));
+                    }
+                }
             }
             let mut c=scope.walk();
             for child in scope.named_children(&mut c).filter(|n| n.end_byte() <= site) {
diff --git a/codegraph-kernel/src/resolve/go_build.rs b/codegraph-kernel/src/resolve/go_build.rs
new file mode 100644
index 0000000000..46fe3d300e
--- /dev/null
+++ b/codegraph-kernel/src/resolve/go_build.rs
@@ -0,0 +1,457 @@
+//! preferGoBuildTwin and goFileConstraint (name-matcher.ts, #2581): a name a
+//! Go package defines once per build target resolves to the definition that
+//! builds for the most typical target the reference's own file builds for.
+
+use super::*;
+
+/// The operating systems and architectures go/build reads from a file name
+/// (its syslist).
+const GO_KNOWN_OS: &[&str] = &[
+    "aix", "android", "darwin", "dragonfly", "freebsd", "hurd", "illumos", "ios", "js", "linux",
+    "nacl", "netbsd", "openbsd", "plan9", "solaris", "wasip1", "windows", "zos",
+];
+const GO_KNOWN_ARCH: &[&str] = &[
+    "386", "amd64", "amd64p32", "arm", "armbe", "arm64", "arm64be", "loong64", "mips", "mipsle",
+    "mips64", "mips64le", "mips64p32", "mips64p32le", "ppc", "ppc64", "ppc64le", "riscv", "riscv64",
+    "s390", "s390x", "sparc", "sparc64", "wasm",
+];
+/// The systems the `unix` build tag holds for.
+const GO_UNIX_OS: &[&str] = &[
+    "aix", "android", "darwin", "dragonfly", "freebsd", "hurd", "illumos", "ios", "linux", "netbsd",
+    "openbsd", "solaris",
+];
+
+#[derive(Clone, Copy)]
+pub(super) struct GoTarget {
+    goos: &'static str,
+    goarch: &'static str,
+}
+
+/// GO_BUILD_TARGETS: the targets a Go name with build-constrained twins is
+/// read for, the most typical first: a Linux server, a Mac, Windows, then
+/// every other system on its usual architecture and Linux on every other
+/// architecture.
+fn go_build_targets() -> &'static [GoTarget] {
+    static TARGETS: std::sync::OnceLock<Vec<GoTarget>> = std::sync::OnceLock::new();
+    TARGETS.get_or_init(|| {
+        let usual = |goos: &str| match goos {
+            "js" | "wasip1" => "wasm",
+            "ios" | "android" => "arm64",
+            "aix" => "ppc64",
+            "zos" => "s390x",
+            "hurd" => "386",
+            _ => "amd64",
+        };
+        let mut targets = vec![
+            GoTarget { goos: "linux", goarch: "amd64" },
+            GoTarget { goos: "darwin", goarch: "arm64" },
+            GoTarget { goos: "windows", goarch: "amd64" },
+            GoTarget { goos: "linux", goarch: "arm64" },
+            GoTarget { goos: "darwin", goarch: "amd64" },
+            GoTarget { goos: "freebsd", goarch: "amd64" },
+        ];
+        for goos in GO_KNOWN_OS {
+            let goarch = usual(goos);
+            if !targets.iter().any(|t| t.goos == *goos && t.goarch == goarch) {
+                targets.push(GoTarget { goos, goarch });
+            }
+        }
+        for goarch in GO_KNOWN_ARCH {
+            if !targets.iter().any(|t| t.goos == "linux" && t.goarch == *goarch) {
+                targets.push(GoTarget { goos: "linux", goarch });
+            }
+        }
+        targets
+    })
+}
+
+/// goBuildTagHolds: whether a build tag holds for a target, as the go command
+/// sets them by default: the system and architecture (`android` is also
+/// `linux`, `ios` `darwin`, `illumos` `solaris`), `unix` on a Unix system, the
+/// `gc` compiler, cgo, and every `go1.N` release. Any other tag is unset.
+fn go_tag_holds(tag: &str, t: &GoTarget) -> bool {
+    if tag == t.goos || tag == t.goarch {
+        return true;
+    }
+    match tag {
+        "unix" => GO_UNIX_OS.contains(&t.goos),
+        "linux" => t.goos == "android",
+        "darwin" => t.goos == "ios",
+        "solaris" => t.goos == "illumos",
+        "gc" => true,
+        "cgo" => t.goos != "js" && t.goos != "wasip1",
+        _ => tag
+            .strip_prefix("go1.")
+            .is_some_and(|v| !v.is_empty() && v.bytes().all(|b| b.is_ascii_digit())),
+    }
+}
+
+/// A parsed build expression: a `//go:build` line, a `// +build` line, or a
+/// file-name suffix as a test of a target.
+enum BuildExpr {
+    Tag(String),
+    Not(Box<BuildExpr>),
+    And(Box<BuildExpr>, Box<BuildExpr>),
+    Or(Box<BuildExpr>, Box<BuildExpr>),
+}
+
+impl BuildExpr {
+    fn holds(&self, t: &GoTarget) -> bool {
+        match self {
+            Self::Tag(s) => go_tag_holds(s, t),
+            Self::Not(e) => !e.holds(t),
+            Self::And(a, b) => a.holds(t) && b.holds(t),
+            Self::Or(a, b) => a.holds(t) || b.holds(t),
+        }
+    }
+}
+
+fn build_tokens(text: &str) -> Vec<String> {
+    let b = text.as_bytes();
+    let mut out = Vec::new();
+    let mut i = 0;
+    while i < b.len() {
+        if b[i].is_ascii_whitespace() {
+            i += 1;
+            continue;
+        }
+        if b[i..].starts_with(b"&&") || b[i..].starts_with(b"||") {
+            out.push(text[i..i + 2].to_string());
+            i += 2;
+            continue;
+        }
+        if matches!(b[i], b'(' | b')' | b'!') {
+            out.push(text[i..i + 1].to_string());
+            i += 1;
+            continue;
+        }
+        let start = i;
+        while i < b.len() && (b[i].is_ascii_alphanumeric() || b[i] == b'_' || b[i] == b'.') {
+            i += 1;
+        }
+        if i > start {
+            out.push(text[start..i].to_string());
+            continue;
+        }
+        // The upstream `\S` catch-all: a stray token the parser then rejects.
+        out.push(text[i..i + 1].to_string());
+        i += 1;
+    }
+    out
+}
+
+fn parse_or(toks: &[String], i: &mut usize) -> Option<BuildExpr> {
+    let mut left = parse_and(toks, i)?;
+    while toks.get(*i).is_some_and(|t| t == "||") {
+        *i += 1;
+        left = BuildExpr::Or(Box::new(left), Box::new(parse_and(toks, i)?));
+    }
+    Some(left)
+}
+
+fn parse_and(toks: &[String], i: &mut usize) -> Option<BuildExpr> {
+    let mut left = parse_not(toks, i)?;
+    while toks.get(*i).is_some_and(|t| t == "&&") {
+        *i += 1;
+        left = BuildExpr::And(Box::new(left), Box::new(parse_not(toks, i)?));
+    }
+    Some(left)
+}
+
+fn parse_not(toks: &[String], i: &mut usize) -> Option<BuildExpr> {
+    let tok = toks.get(*i)?;
+    *i += 1;
+    match tok.as_str() {
+        "!" => Some(BuildExpr::Not(Box::new(parse_not(toks, i)?))),
+        "(" => {
+            let inner = parse_or(toks, i)?;
+            if toks.get(*i).is_some_and(|t| t == ")") {
+                *i += 1;
+                Some(inner)
+            } else {
+                None
+            }
+        }
+        w if !w.is_empty() && w.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.') => {
+            Some(BuildExpr::Tag(w.to_string()))
+        }
+        _ => None,
+    }
+}
+
+/// goParseBuildExpr: a `//go:build` expression (`unix && !(linux || darwin)`)
+/// as a test of a target, or None when it can't be read.
+fn go_parse_build_expr(text: &str) -> Option<BuildExpr> {
+    let toks = build_tokens(text);
+    let mut i = 0;
+    let expr = parse_or(&toks, &mut i)?;
+    (i == toks.len()).then_some(expr)
+}
+
+/// goParsePlusBuild: a legacy `// +build` line's options (`linux,amd64
+/// darwin`, `!plan9`) as a test of a target, or None when it can't be read.
+fn go_parse_plus_build(text: &str) -> Option<BuildExpr> {
+    let options: Option<Vec<Vec<(bool, String)>>> = text
+        .split_whitespace()
+        .map(|option| {
+            option
+                .split(',')
+                .map(|term| {
+                    let (neg, tag) = term
+                        .strip_prefix('!')
+                        .map_or((false, term), |t| (true, t));
+                    (!tag.is_empty()
+                        && tag.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.'))
+                    .then(|| (neg, tag.to_string()))
+                })
+                .collect()
+        })
+        .collect();
+    let mut options = options?.into_iter();
+    let first = options.next()?;
+    let mut acc = plus_option(first);
+    for option in options {
+        acc = BuildExpr::Or(Box::new(acc), Box::new(plus_option(option)));
+    }
+    Some(acc)
+}
+
+fn plus_option(terms: Vec<(bool, String)>) -> BuildExpr {
+    let mut terms = terms.into_iter().map(|(neg, tag)| {
+        let e = BuildExpr::Tag(tag);
+        if neg {
+            BuildExpr::Not(Box::new(e))
+        } else {
+            e
+        }
+    });
+    let mut acc = terms.next().unwrap();
+    for term in terms {
+        acc = BuildExpr::And(Box::new(acc), Box::new(term));
+    }
+    acc
+}
+
+/// goFileConstraint's answer: every part must hold for the file to build.
+pub(super) struct GoFileConstraint {
+    parts: Vec<BuildExpr>,
+}
+
+impl GoFileConstraint {
+    pub(super) fn holds(&self, t: &GoTarget) -> bool {
+        self.parts.iter().all(|p| p.holds(t))
+    }
+}
+
+impl KernelResolver {
+    /// goFileConstraint: the targets a Go file builds for, as go/build reads
+    /// them: a `_linux`, `_amd64` or `_windows_arm64` suffix on its name
+    /// (before `_test`), and the `//go:build` line above its package clause,
+    /// or the legacy `// +build` lines when it has none. None for a file that
+    /// builds everywhere, or whose constraint can't be read.
+    pub(super) fn go_file_constraint(&mut self, file: &str) -> Option<Rc<GoFileConstraint>> {
+        if let Some(hit) = self.go_build_constraint_memo.get(file) {
+            return hit.clone();
+        }
+        let mut parts: Vec<BuildExpr> = Vec::new();
+        // go/build ignores what comes before the name's first `_`, so
+        // `linux.go` names no system.
+        let base = file
+            .rsplit('/')
+            .next()
+            .unwrap_or(file)
+            .split('.')
+            .next()
+            .unwrap_or("");
+        if let Some(u) = base.find('_') {
+            let mut suffix: Vec<&str> = base[u + 1..].split('_').collect();
+            if suffix.last() == Some(&"test") {
+                suffix.pop();
+            }
+            let last = suffix.last().copied();
+            let prev = suffix.len().checked_sub(2).map(|i| suffix[i]);
+            if let (Some(p), Some(l)) = (prev, last) {
+                if GO_KNOWN_OS.contains(&p) && GO_KNOWN_ARCH.contains(&l) {
+                    parts.push(BuildExpr::And(
+                        Box::new(BuildExpr::Tag(p.to_string())),
+                        Box::new(BuildExpr::Tag(l.to_string())),
+                    ));
+                } else if GO_KNOWN_OS.contains(&l) || GO_KNOWN_ARCH.contains(&l) {
+                    parts.push(BuildExpr::Tag(l.to_string()));
+                }
+            } else if let Some(l) = last {
+                if GO_KNOWN_OS.contains(&l) || GO_KNOWN_ARCH.contains(&l) {
+                    parts.push(BuildExpr::Tag(l.to_string()));
+                }
+            }
+        }
+        // The constraint comes before the package clause, after only blank
+        // lines and line comments.
+        let mut go_build: Option<String> = None;
+        let mut plus_build: Vec<String> = Vec::new();
+        if let Some(lines) = self.read_file(file) {
+            for line in lines.iter().take(200) {
+                let text = line
+                    .as_str()
+                    .strip_prefix('\u{feff}')
+                    .unwrap_or(line.as_str())
+                    .trim();
+                if text.is_empty() {
+                    continue;
+                }
+                if !text.starts_with("//") {
+                    break;
+                }
+                if go_build.is_none() {
+                    if let Some(c) = re!(r"^//go:build\s+(.*)$").captures(text) {
+                        go_build = Some(c[1].to_string());
+                    }
+                }
+                if let Some(c) = re!(r"^//\s*\+build\s+(.*)$").captures(text) {
+                    plus_build.push(c[1].to_string());
+                }
+            }
+        }
+        let mut readable = true;
+        if let Some(g) = go_build {
+            match go_parse_build_expr(&g) {
+                Some(e) => parts.push(e),
+                None => readable = false,
+            }
+        } else {
+            for p in &plus_build {
+                match go_parse_plus_build(p) {
+                    Some(e) => parts.push(e),
+                    None => readable = false,
+                }
+            }
+        }
+        let constraint = if !readable || parts.is_empty() {
+            None
+        } else {
+            Some(Rc::new(GoFileConstraint { parts }))
+        };
+        self.go_build_constraint_memo.insert(file.to_string(), constraint.clone());
+        constraint
+    }
+
+    /// The twins of `target`: same name, kind and qualified name in the same
+    /// package (directory and clause), defined in different build files.
+    fn go_build_twins(&mut self, target: &KNode) -> Res<Rc<Vec<Arc<KNode>>>> {
+        if let Some(hit) = self.go_build_twins_memo.get(&target.id) {
+            return Ok(hit.clone());
+        }
+        let dir = pos_dirname(&target.file_path);
+        let clause = self.go_package_clause(&target.file_path);
+        let list = self.nodes_by_name(&target.name)?;
+        let mut twins = Vec::new();
+        for n in list.iter() {
+            if n.language == "go"
+                && n.kind == target.kind
+                && n.qualified_name == target.qualified_name
+                && pos_dirname(&n.file_path) == dir
+                && self.go_package_clause(&n.file_path) == clause
+            {
+                twins.push(n.clone());
+            }
+        }
+        let twins = Rc::new(twins);
+        self.go_build_twins_memo.insert(target.id.clone(), twins.clone());
+        Ok(twins)
+    }
+
+    /// The twin the reference's file builds with, among candidates no
+    /// resolution arm could collapse to one: same walk preferGoBuildTwin
+    /// runs — the most typical target the reference's file builds for whose
+    /// build admits exactly one. None when no target singles one out.
+    pub(super) fn go_pick_twin(
+        &mut self,
+        cands: &[Arc<KNode>],
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let own = self.go_file_constraint(&r.file_path);
+        for t in go_build_targets() {
+            if let Some(c) = &own {
+                if !c.holds(t) {
+                    continue;
+                }
+            }
+            let mut built: Vec<Arc<KNode>> = Vec::new();
+            for n in cands {
+                if self
+                    .go_file_constraint(&n.file_path)
+                    .map(|c| c.holds(t))
+                    .unwrap_or(true)
+                {
+                    built.push(n.clone());
+                }
+            }
+            if built.len() == 1 {
+                return Ok(Some(built.remove(0)));
+            }
+            if built.len() > 1 {
+                return Ok(None);
+            }
+        }
+        Ok(None)
+    }
+
+    /// preferGoBuildTwin: the definition Go builds, of a name its package
+    /// defines more than once for different targets — `sep` in `sep_unix.go`
+    /// (`//go:build unix`) and `sep_other.go` (`//go:build !unix`). The
+    /// definition kept is the one that builds for the most typical target the
+    /// reference's own file builds for: Linux on amd64 first, then a Mac,
+    /// then Windows and the rest (GO_BUILD_TARGETS), so a file that only
+    /// builds for Windows reaches the Windows definition. The result stands
+    /// when no twin builds for those targets, or two do (#2581).
+    pub(super) fn prefer_go_build_twin(
+        &mut self,
+        mut outcome: ResolveOutcome,
+        r: &ResolveRefIn,
+    ) -> Res<ResolveOutcome> {
+        if r.language != "go" || outcome.status != "resolved" {
+            return Ok(outcome);
+        }
+        let Some(tid) = outcome.target_node_id.clone() else {
+            return Ok(outcome);
+        };
+        let Some(target) = self.node_by_id(&tid)? else {
+            return Ok(outcome);
+        };
+        // A file that builds everywhere can have no twin: the package would
+        // declare the name twice.
+        if target.language != "go" || self.go_file_constraint(&target.file_path).is_none() {
+            return Ok(outcome);
+        }
+        let twins = self.go_build_twins(&target)?;
+        if twins.len() < 2 {
+            return Ok(outcome);
+        }
+        let own = self.go_file_constraint(&r.file_path);
+        for t in go_build_targets() {
+            if let Some(c) = &own {
+                if !c.holds(t) {
+                    continue;
+                }
+            }
+            let mut built: Vec<Arc<KNode>> = Vec::new();
+            for n in twins.iter() {
+                if self
+                    .go_file_constraint(&n.file_path)
+                    .map(|c| c.holds(t))
+                    .unwrap_or(true)
+                {
+                    built.push(n.clone());
+                }
+            }
+            if built.len() == 1 {
+                outcome.target_node_id = Some(built[0].id.clone());
+                return Ok(outcome);
+            }
+            if built.len() > 1 {
+                return Ok(outcome);
+            }
+        }
+        Ok(outcome)
+    }
+}
diff --git a/codegraph-kernel/src/resolve/go_value.rs b/codegraph-kernel/src/resolve/go_value.rs
new file mode 100644
index 0000000000..814c31abfa
--- /dev/null
+++ b/codegraph-kernel/src/resolve/go_value.rs
@@ -0,0 +1,1015 @@
+//! Go package-value typing and expression-typed call arms — the tree-native
+//! ports of name-matcher.ts `matchGoPackageValueCall`, `matchGoIndexedCall`
+//! and `matchGoChainedCall` (`goPackageValueType`/`goValueType`/
+//! `goNamedType`/`goReceiverChainType` semantics).
+
+use super::go_asserted::GoAsserted;
+use super::*;
+use tree_sitter::Node as TsNode;
+
+/// What a package-level var/const's declaration says its type is
+/// (`goPackageValueType`): `Written` the spec spells or its value reads,
+/// `Outside` one an outside package hands out, `Unknown` nothing readable.
+enum GoPkgValue {
+    Written(String),
+    Outside,
+    Unknown,
+}
+
+impl KernelResolver {
+    /// goNamedType — `*?ident(.ident)?[type-args]?` reduced to `ident` or
+    /// `pkg.ident`; anything else (a literal like `[]T`, `map[K]V`) is no
+    /// named type.
+    pub(super) fn go_named_type(written: &str) -> Option<String> {
+        static NAMED: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"^\*?\s*([A-Za-z_]\w*)\s*(?:\.\s*([A-Za-z_]\w*))?\s*(?:\[[\s\S]*\])?$").unwrap()
+        });
+        let cap = NAMED.captures(written.trim())?;
+        Some(match cap.get(2) {
+            Some(second) => format!("{}.{}", &cap[1], second.as_str()),
+            None => cap[1].to_string(),
+        })
+    }
+
+    /// isGoOutsidePackage — `pkg` names an import of `file` whose package is
+    /// no project directory.
+    pub(super) fn go_is_outside_package(&mut self, pkg: &str, file: &str) -> Res<bool> {
+        Ok(self.import_mappings(file)?.iter().any(|i| i.local_name == pkg)
+            && self.go_imported_package_dir(file, pkg)?.is_none())
+    }
+
+    /// goPackageValueType — the type a package-level `var`/`const` node's
+    /// spec writes: an explicit `var x T`, the spec a `const` group member
+    /// repeats, or the type a composite literal / conversion value gives.
+    fn go_package_value_type(&mut self, n: &KNode) -> Res<GoPkgValue> {
+        let Some(file) = self.read_file(&n.file_path) else { return Ok(GoPkgValue::Unknown); };
+        static SPEC: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"^\s*(?:(?:var|const)\s*(?:\(\s*)?)?([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)(.*)$").unwrap()
+        });
+        let start = (n.start_line - 1).max(0) as usize;
+        let mut i = start as i64;
+        while i >= 0 && start as i64 - i < 200 {
+            let raw = file.text().lines().nth(i as usize).unwrap_or("").to_string();
+            i -= 1;
+            let line = strip_line_comments(&raw);
+            let own = i as usize + 1 == start;
+            if !own && (line.trim().is_empty() || line.trim_start().starts_with("/*") || line.trim_start().starts_with('*')) {
+                continue;
+            }
+            let Some(cap) = SPEC.captures(&line) else { return Ok(GoPkgValue::Unknown); };
+            if own && !cap[1].split(',').map(str::trim).any(|x| x == n.name) {
+                return Ok(GoPkgValue::Unknown);
+            }
+            let rest = cap[2].trim();
+            if rest.is_empty() {
+                // A constant alone in its group repeats the spec above it.
+                if n.kind != "constant" || line.trim_start().starts_with("var") || line.trim_start().starts_with("const") {
+                    return Ok(GoPkgValue::Unknown);
+                }
+                continue;
+            }
+            let eq = rest.find('=').filter(|&p| !rest[p + 1..].starts_with('='));
+            let written = match eq {
+                Some(p) => rest[..p].trim(),
+                None => rest,
+            };
+            if written.chars().any(|c| matches!(c, ':' | '"' | '\'' | '`')) {
+                return Ok(GoPkgValue::Unknown);
+            }
+            if !written.is_empty() {
+                return Ok(GoPkgValue::Written(written.to_string()));
+            }
+            let Some(p) = eq else { return Ok(GoPkgValue::Unknown); };
+            return self.go_value_type(&rest[p + 1..], &n.file_path);
+        }
+        Ok(GoPkgValue::Unknown)
+    }
+
+    /// goValueType — the type a declaration value gives: a composite
+    /// literal's (`&Registry{}`, `pkg.T{…}`) or a conversion's (`Role("x")`,
+    /// `pkg.T(x)`). Outside for what an outside package hands out.
+    fn go_value_type(&mut self, value: &str, file: &str) -> Res<GoPkgValue> {
+        // A composite literal's own type is its first token: `[]T{…}`,
+        // `map[K]V{…}`, `&pkg.T{…}`.
+        let lead = value.trim_start_matches('&').trim_start();
+        if lead.starts_with('[') || lead.starts_with("map[") {
+            let token: String = lead.chars().take_while(|c| !matches!(c, '{' | '(' | ' ' | '\t')).collect();
+            return Ok(if token.is_empty() { GoPkgValue::Unknown } else { GoPkgValue::Written(token) });
+        }
+        static VAL: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"^\s*&?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[^\]\n]*\]\s*)?([({])").unwrap()
+        });
+        let Some(cap) = VAL.captures(value) else { return Ok(GoPkgValue::Unknown); };
+        let qualifier = cap.get(1).map(|m| m.as_str());
+        let name = cap[2].to_string();
+        let open = cap[3].to_string();
+        if let Some(q) = qualifier {
+            if self.go_is_outside_package(q, file)? {
+                return Ok(GoPkgValue::Outside);
+            }
+        }
+        let written = match qualifier {
+            Some(q) => format!("{q}.{name}"),
+            None => name.clone(),
+        };
+        if open == "{" {
+            return Ok(if GO_BUILTIN_FIELD_TYPES.contains(name.as_str()) || matches!(name.as_str(), "any" | "error") {
+                GoPkgValue::Outside
+            } else {
+                GoPkgValue::Written(written)
+            });
+        }
+        // A call is a conversion when it names a type of its package.
+        let dir = match qualifier {
+            Some(q) => self.go_imported_package_dir(file, q)?,
+            None => self.go_bare_type_dir(&name, file)?,
+        };
+        Ok(match dir {
+            Some(dir) if !self.go_package_types(&name, &dir)?.is_empty() => GoPkgValue::Written(written),
+            _ => GoPkgValue::Unknown,
+        })
+    }
+
+    /// matchGoPackageValueCall — `receiver.method` on a package-level
+    /// var/const whose declaration says its type (`var level = Level(2)`).
+    /// `Some(verdict)` claims the ref; `verdict=None` is a terminal miss on
+    /// an outside type. `None` leaves the other strategies to decide.
+    pub(super) fn match_go_package_value_call(
+        &mut self,
+        receiver: &str,
+        method: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Option<KCand>>> {
+        let dir = pos_dirname(&r.file_path);
+        let decls: Vec<Arc<KNode>> = self
+            .nodes_by_name(receiver)?
+            .iter()
+            .filter(|n| {
+                n.language == "go"
+                    && matches!(n.kind.as_str(), "variable" | "constant")
+                    && pos_dirname(&n.file_path) == dir
+            })
+            .cloned()
+            .collect();
+        if decls.is_empty() {
+            return Ok(None);
+        }
+        if self.import_mappings(&r.file_path)?.iter().any(|i| i.local_name == receiver) {
+            return Ok(None);
+        }
+        if self
+            .go_local_declaration_at(receiver.to_string(), r.file_path.clone(), r.line, r.column)?
+            .is_some()
+        {
+            return Ok(None);
+        }
+        let pkg = self.go_package_clause(&r.file_path);
+        let mut agreed: Option<String> = None;
+        for d in &decls {
+            if self.go_package_clause(&d.file_path) != pkg {
+                continue;
+            }
+            let written = match self.go_package_value_type(d)? {
+                GoPkgValue::Outside => return Ok(Some(None)),
+                GoPkgValue::Unknown => return Ok(None),
+                GoPkgValue::Written(w) => w.replace(char::is_whitespace, ""),
+            };
+            // Files for other build targets may declare it differently.
+            if agreed.as_deref().is_some_and(|seen| seen != written) {
+                return Ok(None);
+            }
+            agreed = Some(written);
+        }
+        let Some(written) = agreed else { return Ok(None); };
+        let Some(named) = Self::go_named_type(&written) else { return Ok(Some(None)); };
+        let mut site = r.clone();
+        site.file_path = decls[0].file_path.clone();
+        if matches!(self.go_written_type(&written, &site)?, Some(GoAsserted::Outside)) {
+            return Ok(Some(None));
+        }
+        let dot = named.find('.');
+        let name = match dot {
+            Some(p) => named[p + 1..].to_string(),
+            None => named.clone(),
+        };
+        if dot.is_none() && GO_BUILTIN_FIELD_TYPES.contains(name.as_str()) {
+            return Ok(Some(None));
+        }
+        let pkg_dir = match dot {
+            Some(p) => self.go_imported_package_dir(&site.file_path, &named[..p])?,
+            None => self.go_bare_type_dir(&name, &site.file_path)?,
+        };
+        if pkg_dir.is_none() && dot.is_none() {
+            return Ok(Some(None));
+        }
+        let Some(pkg_dir) = pkg_dir else { return Ok(None); };
+        if self.go_package_types(&name, &pkg_dir)?.is_empty() {
+            return Ok(None);
+        }
+        // Upstream resolves the package-value arm at the typed-receiver
+        // confidence, 0.9.
+        Ok(Some(self.go_method_in_package(&name, method, &pkg_dir, r)?.map(|mut c| {
+            c.confidence = 0.9;
+            c
+        })))
+    }
+
+    /// The text after the name in a Go type declaration's node span —
+    /// `[]Item` of `type Items []Item`, `B` of `type A = B`.
+    fn go_type_decl_rhs(&mut self, node: &KNode) -> Option<String> {
+        let lines = self.read_file(&node.file_path)?;
+        let decl = lines.iter()
+            .skip((node.start_line - 1).max(0) as usize)
+            .take((node.end_line - node.start_line + 1).max(0) as usize)
+            .enumerate()
+            .map(|(i, l)| {
+                let s = if i == 0 { &l[node.start_column.max(0) as usize..] } else { l.as_str() };
+                strip_line_comments(s).to_string()
+            })
+            .collect::<Vec<_>>()
+            .join(" ");
+        let decl = re!(r"/\*.*?\*/").replace_all(&decl, "");
+        // The name's own `[…]` is generics (`Pair[K,V]` — never empty); a
+        // `[]`/`[N]` prefix is the declared type's own (`Items []Item`).
+        let m = re!(r"^\s*[A-Za-z_]\w*(?:\[[A-Za-z_~][^\]]*\])?\s*(?:=\s*)?(\S[\s\S]*)$").captures(&decl)?;
+        Some(m[1].trim().trim_end_matches(';').trim().to_string()).filter(|s| !s.is_empty())
+    }
+
+    /// goElementOf (name-matcher.ts): the element one `x[i]` on a value of
+    /// type `written` gives — `T` of `[]T`/`[N]T`, `V` of `map[K]V`, and of
+    /// a named type what its declaration's element gives. Returns the
+    /// element's written text and the file it is read in.
+    fn go_element_of(&mut self, written: &str, file: &str, depth: u8) -> Res<Option<(String, String)>> {
+        if depth > 4 {
+            return Ok(None);
+        }
+        let text = written.trim().trim_start_matches('*').trim_start().to_string();
+        if let Some(rest) = text.strip_prefix("map[") {
+            return Ok(rest.find(']').map(|p| (rest[p + 1..].trim().to_string(), file.to_string())));
+        }
+        if text.starts_with('[') {
+            return Ok(text.find(']').map(|p| (text[p + 1..].trim().to_string(), file.to_string())));
+        }
+        let Some(named) = Self::go_named_type(&text) else { return Ok(None) };
+        let (name, dir) = match named.find('.') {
+            Some(p) => match self.go_imported_package_dir(file, &named[..p])? {
+                Some(d) => (named[p + 1..].to_string(), d),
+                None => {
+                    // `pkg.T` whose `pkg` is an import of no project package:
+                    // an outside element — go_written_type vetoes it.
+                    return Ok(if self.import_mappings(file)?.iter().any(|i| i.local_name == named[..p]) {
+                        Some((named.clone(), file.to_string()))
+                    } else {
+                        None
+                    });
+                }
+            },
+            None => {
+                // A builtin element (`error`) is no project type's either.
+                if GO_BUILTIN_FIELD_TYPES.contains(named.as_str()) {
+                    return Ok(Some((named.clone(), file.to_string())));
+                }
+                match self.go_bare_type_dir(&named, file)? {
+                    Some(d) => (named.clone(), d),
+                    None => return Ok(Some((named.clone(), file.to_string()))),
+                }
+            }
+        };
+        for decl in self.go_package_types(&name, &dir)? {
+            if let Some(rhs) = self.go_type_decl_rhs(&decl) {
+                if rhs != text
+                    && (rhs.starts_with('[')
+                        || rhs.starts_with("map[")
+                        || rhs.starts_with('*')
+                        || Self::go_named_type(&rhs).is_some())
+                {
+                    return self.go_element_of(&rhs, &decl.file_path, depth + 1);
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// goFieldTypeOf (name-matcher.ts): the type `field` of the Go struct
+    /// `type_name` in `dir` is declared with — the written text, read in the
+    /// struct's own file.
+    fn go_field_type(&mut self, type_name: &str, field: &str, dir: &str) -> Res<Option<(String, String)>> {
+        static FIELD_OF: LazyLock<Affix> = LazyLock::new(|| {
+            Affix::new("", r"\s+(\S+)", true, false, false)
+        });
+        for s in self.go_package_types(type_name, dir)?.iter().filter(|n| n.kind == "struct") {
+            let Some(source) = self.read_file(&s.file_path) else { continue };
+            let start = (s.start_line - 1).max(0) as usize;
+            let end = (s.end_line as usize).min(source.len());
+            for raw in source.get(start..end).unwrap_or_default() {
+                let line = strip_line_comments(raw);
+                if let Some(t) = FIELD_OF.capture(&line, field) {
+                    return Ok(Some((t.trim().to_string(), s.file_path.clone())));
+                }
+                // An embedded field spells only its type — `KV` of `struct
+                // { KV; name string }` answers `KV` for the field `KV`.
+                let toks = line.split_whitespace().collect::<Vec<_>>();
+                if let [only, ..] = toks.as_slice() {
+                    if only.trim_start_matches('*').rsplit('.').next() == Some(field) {
+                        return Ok(Some((only.to_string(), s.file_path.clone())));
+                    }
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// The `index`th result of a Go call's callee — `*Session` of `func
+    /// New() (*Session, error)` at 0, `*Txn` of `func Begin() (int, *Txn)`
+    /// at 1. A result that names the callee's own type parameter reduces to
+    /// its constraint (`func Pick[V Validator](vs []V) V` → `Validator`);
+    /// `any`/an interface literal leaves no named type.
+    pub(super) fn go_call_result_at(&mut self, callee: &KNode, index: usize) -> Option<String> {
+        // `() (int, *Txn)` — the results follow the params' closing `)`.
+        let sig_tail = |c: &KNode| -> Option<String> {
+            let s = c.signature.as_deref()?;
+            let mut depth = 0usize;
+            for (i, ch) in s.char_indices() {
+                match ch {
+                    '(' | '[' | '{' => depth += 1,
+                    ')' | ']' | '}' => {
+                        depth = depth.saturating_sub(1);
+                        if depth == 0 {
+                            return Some(s[i + 1..].trim().trim_end_matches('{').trim().to_string());
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            None
+        };
+        let raw = if index == 0 {
+            callee.return_type.clone().or_else(|| sig_tail(callee))?
+        } else {
+            // `return_type` keeps only the first result.
+            sig_tail(callee).or(callee.return_type.clone())?
+        };
+        let raw = raw.trim();
+        if raw.is_empty() || raw == "error" {
+            return None;
+        }
+        // `(T, error)` and `[]T`/`T` alike reduce to the named result.
+        let inner = raw.strip_prefix('(').and_then(|s| s.strip_suffix(')')).unwrap_or(raw);
+        let mut depth = 0usize;
+        let mut starts = vec![0usize];
+        let mut commas: Vec<usize> = Vec::new();
+        for (i, c) in inner.char_indices() {
+            match c {
+                '[' | '(' | '{' => depth += 1,
+                ']' | ')' | '}' => depth = depth.saturating_sub(1),
+                ',' if depth == 0 => { commas.push(i); starts.push(i + 1); }
+                _ => {}
+            }
+        }
+        if index >= starts.len() {
+            return None;
+        }
+        let end = commas.get(index).copied().unwrap_or(inner.len());
+        let nth = inner[starts[index]..end].trim();
+        let nth = nth.rsplit(' ').next().unwrap_or(nth).trim();
+        if nth.is_empty() || nth == "error" {
+            return None;
+        }
+        // The result a type parameter spells is its constraint: `V` of
+        // `F[V Validator]` carries Validator's methods, `T` of `F[T any]`
+        // none. The stored signature drops `[…]`, so the declaration line
+        // is read for it.
+        if let Some(source) = self.read_file(&callee.file_path) {
+            if let Some(line) = source.get((callee.start_line - 1).max(0) as usize) {
+                if let Some(tps) = re!(r"func\s+(?:\([^)]*\)\s*)?[A-Za-z_]\w*\s*\[([^\]]+)\]")
+                    .captures(line).map(|m| m[1].to_string())
+                {
+                    // `T1, T2 C` names share C; `K comparable, V any` pairs.
+                    let mut pending: Vec<String> = Vec::new();
+                    for chunk in tps.split(',') {
+                        let toks: Vec<&str> = chunk.split_whitespace().collect();
+                        match toks.as_slice() {
+                            [name] => pending.push(name.to_string()),
+                            [rest @ .., constraint] => {
+                                for n in rest.iter().map(|s| s.trim_end_matches(',')).chain(pending.iter().map(|s| s.as_str())) {
+                                    if n == nth {
+                                        return Some(constraint.to_string());
+                                    }
+                                }
+                                pending.clear();
+                            }
+                            [] => {}
+                        }
+                    }
+                }
+            }
+        }
+        Some(nth.to_string())
+    }
+
+    /// The initializer `names = values` gives the name `name_node`
+    /// declares — its place among the names picks the value among the
+    /// expression list (`in, out := &in.Items, &out.Items`).
+    fn decl_rhs_node<'a>(name_node: TsNode<'a>, name: &str, text: &'a str) -> Option<(TsNode<'a>, usize, bool)> {
+        use super::go_asserted::{identifiers, text_of};
+        let mut owner = name_node.parent()?;
+        if owner.kind() == "expression_list" {
+            owner = owner.parent()?;
+        }
+        let (names, value, range) = match owner.kind() {
+            "short_var_declaration" => {
+                (identifiers(owner.child_by_field_name("left")?), owner.child_by_field_name("right")?, false)
+            }
+            // `for k, v := range coll` — the name's position means key/index
+            // vs element, not a multi-result index.
+            "range_clause" => {
+                (identifiers(owner.child_by_field_name("left")?), owner.child_by_field_name("right")?, true)
+            }
+            "var_spec" | "const_spec" => {
+                let mut c = owner.walk();
+                (
+                    owner.children_by_field_name("name", &mut c).collect::<Vec<_>>(),
+                    owner.child_by_field_name("value")?,
+                    false,
+                )
+            }
+            _ => return None,
+        };
+        let k = names.iter().position(|n| text_of(*n, text) == name)?;
+        if value.kind() == "expression_list" {
+            if value.named_child_count() > k {
+                return Some((value.named_child(k)?, 0, range));
+            }
+            // `a, b := f()` — the call's kth result types b.
+            return Some((value.named_child(value.named_child_count() - 1)?, k, range));
+        }
+        Some((value, k, range))
+    }
+
+    /// The type `for k, v := range coll` binds `k`/`v` at — name position
+    /// 0 takes the index (`int` for a slice, array or `string`) or key
+    /// (`K` of `map[K]V`); position 1 takes the element/value. A `chan`
+    /// range binds only its received value.
+    fn go_range_pick(written: &str, pos: usize) -> String {
+        let w = written.trim().trim_start_matches('*').trim();
+        if let Some(rest) = w.strip_prefix("map[") {
+            if let Some(end) = rest.find(']') {
+                return (if pos == 0 { &rest[..end] } else { rest[end + 1..].trim() }).to_string();
+            }
+        }
+        for p in ["chan ", "<-chan ", "chan<- "] {
+            if let Some(rest) = w.strip_prefix(p) {
+                return rest.trim().to_string();
+            }
+        }
+        if pos == 0 {
+            "int".to_string()
+        } else if w.starts_with('[') {
+            w.find(']').map(|e| w[e + 1..].trim().to_string()).unwrap_or_else(|| w.to_string())
+        } else if w == "string" {
+            "rune".to_string()
+        } else {
+            w.to_string()
+        }
+    }
+
+    /// The type parameter `name`'s constraint in the function enclosing the
+    /// ref — `model.Validator` of `F[T model.Validator]`, the interface
+    /// literal of `F[T interface{ … }]`. `None` when `name` is no type
+    /// parameter of an enclosing declaration.
+    fn go_type_param_constraint(&mut self, name: &str, r: &ResolveRefIn) -> Res<Option<String>> {
+        use super::go_asserted::text_of;
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None) };
+        let mut scope = super::iteration::descendant_for_position(
+            tree.root_node(),
+            file.text(),
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        loop {
+            if matches!(scope.kind(), "function_declaration" | "method_declaration" | "func_literal") {
+                let Some(tps) = scope.child_by_field_name("type_parameters") else { return Ok(None) };
+                let mut c = tps.walk();
+                for decl in tps.named_children(&mut c) {
+                    if decl.kind() != "type_parameter_declaration" {
+                        continue;
+                    }
+                    let mut nc = decl.walk();
+                    let names: Vec<_> = decl.children_by_field_name("name", &mut nc).collect();
+                    if names.iter().any(|n| text_of(*n, file.text()) == name) {
+                        return Ok(decl.child_by_field_name("type").map(|t| text_of(t, file.text()).to_string()));
+                    }
+                }
+                return Ok(None);
+            }
+            let Some(parent) = scope.parent() else { return Ok(None) };
+            scope = parent;
+        }
+    }
+
+    /// The written type a Go local `name` carries at `anchor`'s site —
+    /// declared type, asserted type, its `:=`/`var` initializer's type, or
+    /// a package-level value's. `None` when nothing types it.
+    fn go_named_local_written(
+        &mut self,
+        name: &str,
+        anchor: TsNode,
+        file_text: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<(String, String)>> {
+        use super::go_asserted::local_declaration_in;
+        let file = r.file_path.clone();
+        let mut scope = anchor;
+        let found = loop {
+            if let Some(hit) = local_declaration_in(scope, name, anchor.start_byte(), file_text) {
+                break Some(hit);
+            }
+            match scope.parent() {
+                Some(p) => scope = p,
+                None => break None,
+            }
+        };
+        if let Some((target, declared)) = found {
+            if let Some(t) = declared {
+                return Ok(Some((t, file)));
+            }
+            if let Some(w) = self.go_asserted_local_type(name, r) {
+                return Ok(Some((w, file)));
+            }
+            // An untyped `:=`/`var` — read the initializer itself:
+            // `&m.F`, `f()`, `x[i]`, `[]T(v)` all carry a type.
+            if let Some((rhs, pos, range)) = Self::decl_rhs_node(target, name, file_text) {
+                let w = self.go_expr_written_at(rhs, if range { 0 } else { pos }, file_text, r)?
+                    .map(|(t, f)| if range { (Self::go_range_pick(&t, pos), f) } else { (t, f) });
+                if let Some(t) = w {
+                    return Ok(Some(t));
+                }
+            }
+            if let Some(t) = self.infer_local_receiver_type(name, r, true)? {
+                return Ok(Some((t, file)));
+            }
+            return Ok(None);
+        }
+        // A parameter or `:=` local the declaration reader missed —
+        // the bound-receiver inference still types it.
+        if let Some(t) = self.infer_local_receiver_type(name, r, true)? {
+            return Ok(Some((t, file)));
+        }
+        for n in self.nodes_by_name(name)?.iter().filter(|n| {
+            n.language == "go"
+                && matches!(n.kind.as_str(), "variable" | "constant")
+                && pos_dirname(&n.file_path) == pos_dirname(&file)
+        }) {
+            if let GoPkgValue::Written(w) = self.go_package_value_type(n)? {
+                return Ok(Some((w, n.file_path.clone())));
+            }
+        }
+        Ok(None)
+    }
+
+    /// A Go receiver named `name` at `r`'s call site, typed through the
+    /// same scoped local machinery `x[i].M` uses — the line-regex
+    /// infer_local_receiver_type can't see `x := pkg.F().Field` or a
+    /// shadowed name's outer binding.
+    pub(super) fn go_local_receiver_written(&mut self, name: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None) };
+        let anchor = super::iteration::descendant_for_position(
+            tree.root_node(),
+            file.text(),
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let w = self.go_named_local_written(name, anchor, file.text(), r)?;
+        Ok(w)
+    }
+
+    /// The type an expression's source text spells (`goReceiverChainType`,
+    /// tree-native): `(written, file)`. `None` is unreadable — the other
+    /// strategies decide.
+    fn go_expr_written(&mut self, expr: TsNode, file_text: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
+        self.go_expr_written_at(expr, 0, file_text, r)
+    }
+
+    /// `go_expr_written` whose top-level call takes its `result_idx`th
+    /// result — `_, txn := store.Begin()` types `txn` by the second.
+    fn go_expr_written_at(&mut self, expr: TsNode, result_idx: usize, file_text: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
+        let file = r.file_path.clone();
+        match expr.kind() {
+            "parenthesized_expression" => match expr.named_child(0) {
+                Some(inner) => self.go_expr_written(inner, file_text, r),
+                None => Ok(None),
+            },
+            "identifier" => {
+                let name = file_text[expr.byte_range()].to_string();
+                self.go_named_local_written(&name, expr, file_text, r)
+            }
+            "index_expression" => {
+                let Some(operand) = expr.child_by_field_name("operand") else { return Ok(None); };
+                let Some((text, at)) = self.go_expr_written(operand, file_text, r)? else {
+                    return Ok(None);
+                };
+                self.go_element_of(&text, &at, 0)
+            }
+            "slice_expression" => {
+                // `x[a:b]` keeps the slice's own type — `[]T` stays `[]T`, a
+                // named `Items` stays `Items`; `[N]T` cuts to `[]T`.
+                let Some(operand) = expr.child_by_field_name("operand") else { return Ok(None); };
+                let Some((text, at)) = self.go_expr_written(operand, file_text, r)? else {
+                    return Ok(None);
+                };
+                let trimmed = text.trim_start_matches('*').trim_start();
+                Ok(Some(if trimmed.starts_with('[') && trimmed[1..].chars().next().is_some_and(|c| c.is_ascii_digit()) {
+                    let p = trimmed.find(']').unwrap_or(1);
+                    (format!("[]{}", trimmed[p + 1..].trim()), at)
+                } else {
+                    (trimmed.to_string(), at)
+                }))
+            }
+            "selector_expression" => {
+                let (Some(op), Some(field)) =
+                    (expr.child_by_field_name("operand"), expr.child_by_field_name("field"))
+                else {
+                    return Ok(None);
+                };
+                let field = file_text[field.byte_range()].to_string();
+                if op.kind() == "identifier" {
+                    let base = file_text[op.byte_range()].to_string();
+                    // `pkg.Name` — a qualified type, not a field read.
+                    if self.go_imported_package_dir(&file, &base)?.is_some() {
+                        return Ok(Some((format!("{base}.{field}"), file)));
+                    }
+                    let Some((base_ty, base_at)) = self.go_expr_written(op, file_text, r)? else {
+                        return Ok(None);
+                    };
+                    // A literal type's package can't be named — the text
+                    // itself settles the read (Outside), never a name cue.
+                    let Some((tn, dir)) = self.go_type_package(&base_ty, &base_at)? else {
+                        return Ok(Some((base_ty, base_at)));
+                    };
+                    return self.go_field_type(&tn, &field, &dir);
+                }
+                // `f().F`, `x[0].F`, `(a).F` — the field the operand's type
+                // declares.
+                let Some((w, at)) = self.go_expr_written(op, file_text, r)? else {
+                    return Ok(None);
+                };
+                let Some((tn, dir)) = self.go_type_package(&w, &at)? else {
+                    return Ok(Some((w, at)));
+                };
+                self.go_field_type(&tn, &field, &dir)
+            }
+            "type_assertion_expression" => Ok(expr
+                .child_by_field_name("type")
+                .map(|t| (file_text[t.byte_range()].trim().to_string(), file))),
+            "type_conversion_expression" => {
+                let Some(t) = expr.child_by_field_name("type") else { return Ok(None) };
+                let text = file_text[t.byte_range()].trim().to_string();
+                // `F[T](x)` parses as a conversion; when its type names a
+                // function rather than a declared type it is a generic call
+                // — the callee's result types it, not the "converted" name.
+                if let Some(named) = Self::go_named_type(&text) {
+                    let (q, name) = named.split_once('.')
+                        .map(|(a, b)| (Some(a.to_string()), b.to_string()))
+                        .unwrap_or((None, named));
+                    let dir = match &q {
+                        Some(q) => self.go_imported_package_dir(&file, q)?,
+                        None => Some(pos_dirname(&file).to_string()),
+                    };
+                    if let Some(d) = dir {
+                        if self.go_package_types(&name, &d)?.is_empty() {
+                            for f in self.nodes_by_name(&name)?.iter().filter(|n| {
+                                n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
+                            }) {
+                                if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                    return Ok(Some((t, f.file_path.clone())));
+                                }
+                            }
+                        }
+                    }
+                }
+                Ok(Some((text, file)))
+            }
+            "composite_literal" => Ok(expr
+                .child_by_field_name("type")
+                .map(|t| (file_text[t.byte_range()].trim().to_string(), file))),
+            "unary_expression" => {
+                let op = expr.child(0).map(|n| &file_text[n.byte_range()]).unwrap_or("");
+                let Some(inner) = expr.named_child(0) else { return Ok(None); };
+                let Some((t, at)) = self.go_expr_written(inner, file_text, r)? else { return Ok(None); };
+                Ok(match op {
+                    "*" => t.strip_prefix('*').map(|s| (s.trim().to_string(), at)),
+                    "&" => Some((format!("*{t}"), at)),
+                    _ => None,
+                })
+            }
+            "call_expression" => {
+                let Some(function) = expr.child_by_field_name("function") else { return Ok(None); };
+                // `F[T](x)` — the callee sits under the instantiation as a
+                // qualified_type/type_identifier, not the expression
+                // grammar's selector/identifier shapes.
+                let function = if function.kind() == "type_instantiation_expression" {
+                    function.child_by_field_name("type").unwrap_or(function)
+                } else {
+                    function
+                };
+                if function.kind() == "qualified_type" {
+                    let q = function.child_by_field_name("package").map(|n| file_text[n.byte_range()].to_string());
+                    let callee = function.child_by_field_name("name").map(|n| file_text[n.byte_range()].to_string());
+                    if let (Some(q), Some(callee)) = (q, callee) {
+                        if self.go_is_outside_package(&q, &file)? {
+                            return Ok(None);
+                        }
+                        if let Some(d) = self.go_imported_package_dir(&file, &q)? {
+                            if !self.go_package_types(&callee, &d)?.is_empty() {
+                                return Ok(Some((format!("{q}.{callee}"), file)));
+                            }
+                            for f in self.nodes_by_name(&callee)?.iter().filter(|n| {
+                                n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
+                            }) {
+                                if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                    return Ok(Some((t, f.file_path.clone())));
+                                }
+                            }
+                        }
+                        return Ok(None);
+                    }
+                }
+                if function.kind() == "type_identifier" {
+                    let callee = &file_text[function.byte_range()];
+                    let own = pos_dirname(&file);
+                    for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                        n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == own
+                    }) {
+                        if let Some(t) = self.go_call_result_at(f, result_idx) {
+                            return Ok(Some((t, f.file_path.clone())));
+                        }
+                    }
+                    return Ok(None);
+                }
+                // A conversion spells its result type where a call spells a
+                // name: `[]T(x)`, `Pair[A,B](x)`, `map[K]V(x)`, `(*T)(x)`.
+                if matches!(
+                    function.kind(),
+                    "slice_type" | "map_type" | "pointer_type" | "generic_type" | "array_type"
+                ) {
+                    return Ok(Some((file_text[function.byte_range()].trim().to_string(), file)));
+                }
+                if function.kind() == "parenthesized_expression" {
+                    return Ok(function.named_child(0).map(|t| (file_text[t.byte_range()].trim().to_string(), file)));
+                }
+                if function.kind() == "identifier" {
+                    let callee = &file_text[function.byte_range()];
+                    if matches!(callee, "new" | "make") {
+                        return Ok(expr
+                            .child_by_field_name("arguments")
+                            .and_then(|a| a.named_child(0))
+                            .map(|t| (file_text[t.byte_range()].trim().to_string(), file)));
+                    }
+                    // A conversion names a type of its package.
+                    let dir = self.go_bare_type_dir(callee, &file)?;
+                    if dir.is_some_and(|d| !self.go_package_types(callee, &d).unwrap_or_default().is_empty()) {
+                        return Ok(Some((callee.to_string(), file)));
+                    }
+                }
+                if function.kind() == "selector_expression" {
+                    if let (Some(operand), Some(field)) =
+                        (function.child_by_field_name("operand"), function.child_by_field_name("field"))
+                    {
+                        if operand.kind() == "identifier" {
+                            let q = &file_text[operand.byte_range()];
+                            let callee = &file_text[field.byte_range()];
+                            if self.go_is_outside_package(q, &file)? {
+                                return Ok(None);
+                            }
+                            if let Some(d) = self.go_imported_package_dir(&file, q)? {
+                                if !self.go_package_types(callee, &d)?.is_empty() {
+                                    return Ok(Some((format!("{q}.{callee}"), file)));
+                                }
+                                // `pkg.F(…)` — F's result.
+                                for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                                    n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
+                                }) {
+                                    if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                        return Ok(Some((t, f.file_path.clone())));
+                                    }
+                                }
+                                return Ok(None);
+                            }
+                            // `m.F(…)` — F's first result, on m's type.
+                            let Some((base_ty, base_at)) = self.go_expr_written(operand, file_text, r)? else {
+                                return Ok(None);
+                            };
+                            let Some((tn, dir)) = self.go_type_package(&base_ty, &base_at)? else {
+                                return Ok(Some((base_ty, base_at)));
+                            };
+                            let want = format!("{tn}::{callee}");
+                            let suffix = format!("::{want}");
+                            for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                                n.language == "go"
+                                    && n.kind == "method"
+                                    && pos_dirname(&n.file_path) == dir
+                                    && (n.qualified_name == want
+                                        || n.qualified_name.ends_with(&suffix))
+                            }) {
+                                if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                    return Ok(Some((t, f.file_path.clone())));
+                                }
+                            }
+                            // `h.get()` — a field of func type called as a
+                            // callee: its type is no named method holder's.
+                            if let Some((ft, at)) = self.go_field_type(&tn, callee, &dir)? {
+                                return Ok(Some((ft, at)));
+                            }
+                            return Ok(None);
+                        }
+                        // `f().G(…)`, `x[0].G(…)` — the method's first
+                        // result on the operand's type.
+                        let callee = file_text[field.byte_range()].to_string();
+                        let Some((w, at)) = self.go_expr_written(operand, file_text, r)? else {
+                            return Ok(None);
+                        };
+                        let Some((tn, dir)) = self.go_type_package(&w, &at)? else {
+                            return Ok(Some((w, at)));
+                        };
+                        let want = format!("{tn}::{callee}");
+                        let suffix = format!("::{want}");
+                        for f in self.nodes_by_name(&callee)?.iter().filter(|n| {
+                            n.language == "go"
+                                && n.kind == "method"
+                                && pos_dirname(&n.file_path) == dir
+                                && (n.qualified_name == want
+                                    || n.qualified_name.ends_with(&suffix))
+                        }) {
+                            if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                return Ok(Some((t, f.file_path.clone())));
+                            }
+                        }
+                        return Ok(None);
+                    }
+                }
+                // `f(…)` on a project function — its result.
+                if function.kind() == "identifier" {
+                    let callee = &file_text[function.byte_range()];
+                    let own = pos_dirname(&file);
+                    for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                        n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == own
+                    }) {
+                        if let Some(t) = self.go_call_result_at(f, result_idx) {
+                            return Ok(Some((t, f.file_path.clone())));
+                        }
+                    }
+                }
+                Ok(None)
+            }
+            _ => Ok(None),
+        }
+    }
+
+    /// Whether a `.go` file of package `dir` that the index read nothing
+    /// from declares `type::method` — or itself can't be read (its methods
+    /// are then unknowable): kubernetes' oversized generated.pb.go. The
+    /// method the graph is missing is not the one an embedded type has.
+    pub(super) fn go_unread_file_declares(&mut self, type_name: &str, method: &str, dir: &str) -> Res<bool> {
+        let files = self.sorted_files().unwrap_or_default();
+        let mut unread: Vec<String> = files
+            .iter()
+            .filter(|f| {
+                f.ends_with(".go") && !f.ends_with("_test.go") && pos_dirname(f) == dir && self.known_file(f)
+            })
+            .filter(|f| self.nodes_in_file(f).map(|l| l.is_empty()).unwrap_or(true))
+            .cloned()
+            .collect();
+        // A path the index never recorded still sits on disk.
+        if let Ok(rd) = std::fs::read_dir(pos_resolve(&self.root_abs, dir)) {
+            for e in rd.flatten() {
+                let name = e.file_name().to_string_lossy().to_string();
+                if !name.ends_with(".go") || name.ends_with("_test.go") {
+                    continue;
+                }
+                let f = if dir.is_empty() { name.clone() } else { format!("{dir}/{name}") };
+                if !unread.contains(&f) && self.nodes_in_file(&f).map(|l| l.is_empty()).unwrap_or(true) {
+                    unread.push(f);
+                }
+            }
+        }
+        for f in unread {
+            let ms = self.go_unread_file_methods(&f)?;
+            match ms {
+                None => return Ok(true),
+                Some(ms) if ms.contains(&format!("{type_name}::{method}")) => return Ok(true),
+                _ => {}
+            }
+        }
+        Ok(false)
+    }
+
+    /// `Type::Method` names a file the index couldn't read declares, from
+    /// its text (`goUnreadFileMethods`). `None` when the file can't be read.
+    fn go_unread_file_methods(&mut self, f: &str) -> Res<Option<std::collections::HashSet<String>>> {
+        if let Some(hit) = self.go_unread_methods_memo.get(f) {
+            return Ok(hit.clone());
+        }
+        // GO_UNREAD_SCAN_BYTES — the sweep reads far past the indexer's 1
+        // MB cap, which is exactly why these files are unread.
+        const GO_UNREAD_SCAN_BYTES: u64 = 32 * 1024 * 1024;
+        let path = pos_resolve(&self.root_abs, f);
+        let methods = (|| {
+            let meta = std::fs::metadata(&path).ok()?;
+            if !meta.is_file() || meta.len() > GO_UNREAD_SCAN_BYTES {
+                return None;
+            }
+            let raw = std::fs::read(&path).ok()?;
+            let text = String::from_utf8(raw).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
+            let mut set = std::collections::HashSet::new();
+            let re = re!(r"(?m)^func\s*\(\s*(?:[A-Za-z_]\w*\s+)?\*?\s*([A-Za-z_]\w*)\s*(?:\[[^\]\n]*\])?\s*\)\s*([A-Za-z_]\w*)\s*[\[(]");
+            for m in re.captures_iter(&text) {
+                set.insert(format!("{}::{}", &m[1], &m[2]));
+            }
+            Some(set)
+        })();
+        self.go_unread_methods_memo.insert(f.to_string(), methods.clone());
+        Ok(methods)
+    }
+
+    /// The settled type of `expr` where `r` is read: a project type with its
+    /// package, `Outside`, or `None` (unreadable — name matching decides).
+    fn go_expr_type(&mut self, expr: TsNode, file_text: &str, r: &ResolveRefIn) -> Res<Option<GoAsserted>> {
+        let Some((written, at)) = self.go_expr_written(expr, file_text, r)? else { return Ok(None); };
+        // A type parameter is its constraint, never the package's namesake
+        // type: `F[T interface{…}]` → literal (nothing to read), `F[T
+        // model.Validator]` → the constraint's type.
+        if let Some(named) = Self::go_named_type(&written) {
+            if !named.contains('.') {
+                if let Some(constraint) = self.go_type_param_constraint(&named, r)? {
+                    return match Self::go_named_type(&constraint) {
+                        Some(_) => self.go_written_type(&constraint, r),
+                        None => Ok(Some(GoAsserted::Outside)),
+                    };
+                }
+            }
+        }
+        let mut site = r.clone();
+        site.file_path = at;
+        self.go_written_type(&written, &site)
+    }
+
+    /// matchGoIndexedCall + matchGoChainedCall — a bare `calls` name whose
+    /// enclosing call selects the method on an index, call, assertion,
+    /// composite or selector receiver: `gs[0].Expect`, `f().M`, `v.(T).M`,
+    /// `x.f.M`. The receiver's type owns the ref: a project type names the
+    /// method (or nothing — terminal), an outside type refuses it, and an
+    /// unreadable one leaves name matching to decide.
+    pub(super) fn match_go_expr_call(&mut self, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
+        if r.language != "go" || r.reference_kind != "calls" || r.reference_name.contains('.') {
+            return Ok(None);
+        }
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None); };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None); };
+        let mut node = super::iteration::descendant_for_position(
+            tree.root_node(),
+            file.text(),
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let mut selector = None;
+        loop {
+            if node.kind() == "call_expression" {
+                if let Some(function) = node.child_by_field_name("function") {
+                    if function.kind() == "selector_expression" {
+                        if let Some(field) = function.child_by_field_name("field") {
+                            if file.text()[field.byte_range()] == r.reference_name {
+                                selector = Some(function);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            let Some(parent) = node.parent() else { break };
+            if matches!(parent.kind(), "argument_list" | "block" | "source_file") {
+                break;
+            }
+            node = parent;
+        }
+        let Some(selector) = selector else { return Ok(None); };
+        let Some(operand) = selector.child_by_field_name("operand") else { return Ok(None); };
+        let mut operand = operand;
+        while operand.kind() == "parenthesized_expression" {
+            let Some(inner) = operand.named_child(0) else { return Ok(None); };
+            operand = inner;
+        }
+        match operand.kind() {
+            // `x.M` arrives as a dotted ref, never a bare name.
+            "identifier" => Ok(None),
+            _ => {
+                let ty = self.go_expr_type(operand, file.text(), r)?;
+                Ok(match ty {
+                    Some(GoAsserted::Project { name, dir }) => {
+                        Some(self.go_method_in_package(&name, &r.reference_name, &dir, r)?)
+                    }
+                    Some(GoAsserted::Outside) => Some(None),
+                    None => None,
+                })
+            }
+        }
+    }
+}
diff --git a/codegraph-kernel/src/resolve/imports.rs b/codegraph-kernel/src/resolve/imports.rs
index cb1f7f23aa..ad63e8c0ea 100644
--- a/codegraph-kernel/src/resolve/imports.rs
+++ b/codegraph-kernel/src/resolve/imports.rs
@@ -34,7 +34,7 @@ impl KernelResolver {
         if import_path.starts_with('.') {
             return false;
         }
-        if self.workspaces.is_some() && self.resolve_workspace_import(import_path).is_some() {
+        if self.workspaces.is_some() && self.resolve_workspace_import(import_path, from_file).is_some() {
             return false;
         }
         if is_esm_import_language(language) {
@@ -79,27 +79,52 @@ impl KernelResolver {
         false
     }
 
+    /// The longest package name `import_path` names among `names` — `name` or
+    /// `name/…` (longestName, workspace-packages.ts).
+    fn longest_package_name<'a>(import_path: &str, names: impl Iterator<Item = &'a String>) -> Option<&'a str> {
+        let mut best = None;
+        for name in names {
+            if (import_path == name.as_str() || import_path.starts_with(&format!("{}/", name)))
+                && best.is_none_or(|b: &str| name.len() > b.len())
+            {
+                best = Some(name.as_str());
+            }
+        }
+        best
+    }
+
+    /// matchPackage (workspace-packages.ts): the path dependency the nearest
+    /// manifest above `from_file` maps the import to, else a workspace member.
+    fn match_workspace_package(&self, import_path: &str, from_file: &str) -> Option<(String, String)> {
+        let ws = self.workspaces.as_ref()?;
+        // scopedPackage: manifests above the importing file declare their own
+        // `file:`/`link:`/`portal:` dependencies for the files under them.
+        let mut dir = from_file.replace('\\', "/");
+        while !dir.is_empty() {
+            dir = dir.rfind('/').map_or(String::new(), |s| dir[..s].to_string());
+            if let Some(names) = ws.scoped_by_name.get(&dir) {
+                if let Some(name) = Self::longest_package_name(import_path, names.keys()) {
+                    return Some((name.to_string(), names[name].clone()));
+                }
+            }
+        }
+        let name = Self::longest_package_name(import_path, ws.by_name.keys())?;
+        Some((name.to_string(), ws.by_name[name].clone()))
+    }
+
     /// resolveWorkspaceImport (workspace-packages.ts): sourceEntries first,
-    /// then longest matching package name; a bare member import resolves to
-    /// its declared entry when the manifest names one.
-    pub(super) fn resolve_workspace_import(&self, import_path: &str) -> Option<String> {
+    /// then the matching package; a bare member import resolves to its
+    /// declared entry when the manifest names one.
+    pub(super) fn resolve_workspace_import(&self, import_path: &str, from_file: &str) -> Option<String> {
         let ws = self.workspaces.as_ref()?;
         if let Some((_, src)) = ws.source_entries.iter().find(|(k, _)| k == import_path) {
             return Some(src.clone());
         }
-        let mut best: Option<(&str, &str)> = None;
-        for (name, dir) in &ws.by_name {
-            if (import_path == name.as_str() || import_path.starts_with(&format!("{}/", name)))
-                && best.is_none_or(|(b, _)| name.len() > b.len())
-            {
-                best = Some((name, dir));
-            }
-        }
-        let (name, dir) = best?;
+        let (name, dir) = self.match_workspace_package(import_path, from_file)?;
         let subpath = &import_path[name.len()..]; // '' or '/widgets'
         if subpath.is_empty() {
             if let Some(entry_by_name) = &ws.entry_by_name {
-                if let Some(entry) = entry_by_name.get(name) {
+                if let Some(entry) = entry_by_name.get(&name) {
                     return Some(entry.clone());
                 }
             }
@@ -111,6 +136,99 @@ impl KernelResolver {
         Some(multi_slash().replace_all(&joined, "/").to_string())
     }
 
+    /// workspaceImportTargets (workspace-packages.ts): what the package's
+    /// manifest declares for the import, and its directory form.
+    fn workspace_import_targets(&self, import_path: &str, from_file: &str) -> Option<WorkspaceTargets> {
+        let ws = self.workspaces.as_ref()?;
+        let (name, dir) = self.match_workspace_package(import_path, from_file)?;
+        let subpath = &import_path[name.len()..]; // '' or '/widgets'
+        let joined = format!("{}{}", dir, subpath);
+        let directory = re!(r"/{2,}").replace_all(&joined, "/").to_string();
+        let ohpm = if subpath.is_empty() {
+            ws.entry_by_name.as_ref().and_then(|m| m.get(&name)).cloned()
+        } else {
+            None
+        };
+        let declared = match ohpm {
+            Some(entry) => vec![entry],
+            None => self.declared_workspace_entries(dir.as_str(), subpath),
+        };
+        Some(WorkspaceTargets { declared, directory, package_dir: dir })
+    }
+
+    /// declaredEntries: the targets a package's manifest declares for
+    /// `subpath` (`''` or `/widgets`), best first: its `exports` entry, then
+    /// the root's `main`-style fields.
+    fn declared_workspace_entries(&self, package_dir: &str, subpath: &str) -> Vec<String> {
+        let Some(entries) = self.workspaces.as_ref().and_then(|ws| ws.entries_by_dir.get(package_dir)) else {
+            return vec![];
+        };
+        let exported = exported_targets(&entries.exports, &format!(".{subpath}"));
+        if !subpath.is_empty() {
+            return exported;
+        }
+        let mut out = exported;
+        for m in &entries.main {
+            if !out.contains(m) {
+                out.push(m.clone());
+            }
+        }
+        out
+    }
+
+    /// indexedTarget (import-resolver.ts): `target` as a file the index
+    /// holds — as written, with the language's extensions or index files, or
+    /// as the source of an emitted `.js`. Only the index counts: build output
+    /// a local build left on disk is not linked.
+    fn indexed_target(&self, target: &str, language: &str) -> Option<String> {
+        let as_is = indexed_spelling(target, language);
+        if self.known_file(&as_is) {
+            return Some(as_is);
+        }
+        for ext in extension_resolution(language) {
+            let candidate = indexed_spelling(&format!("{target}{ext}"), language);
+            if self.known_file(&candidate) {
+                return Some(candidate);
+            }
+        }
+        // findSourceForEmittedSpecifier restricted to the index.
+        let sources = emitted_to_source(&as_is, language)?;
+        let stem_len = as_is.rfind('.')?;
+        let stem = &as_is[..stem_len];
+        for ext in sources {
+            let candidate = format!("{}{}", stem, ext);
+            if self.known_file(&candidate) {
+                return Some(candidate);
+            }
+        }
+        None
+    }
+
+    /// builtSourceOf: `target`, build output the index lacks, as the indexed
+    /// source it is built from (`dist/index.js` → `src/index.ts`).
+    fn built_source_of(&self, target: &str, package_dir: &str, language: &str) -> Option<String> {
+        for source in built_sources_of(target, package_dir) {
+            if let Some(hit) = self.indexed_target(&source, language) {
+                return Some(hit);
+            }
+        }
+        None
+    }
+
+    /// declaredWorkspaceEntry: the first declared target the index holds, or
+    /// that is build output the index lacks read as its source.
+    fn declared_workspace_entry(&self, targets: &WorkspaceTargets, language: &str) -> Option<String> {
+        for target in &targets.declared {
+            if let Some(hit) = self
+                .indexed_target(target, language)
+                .or_else(|| self.built_source_of(target, &targets.package_dir, language))
+            {
+                return Some(hit);
+            }
+        }
+        None
+    }
+
     /// applyAliases (path-aliases.ts): candidate paths relative to
     /// projectRoot in tsconfig priority order.
     pub(super) fn apply_aliases(&self, import_path: &str, alias_map: &KernelAliasMapIn) -> Vec<String> {
@@ -181,15 +299,20 @@ impl KernelResolver {
 
     /// The first existing file among `base` + each of the language's
     /// extensions, then `base` itself, then the source an emitted `.js`/`.d.ts`
-    /// path was compiled from.
+    /// path was compiled from — each spelled as the index keys it
+    /// (indexedSpelling, upstream 8651990a / #2577).
     pub(super) fn probe_extensions(&self, base: &str, language: &str) -> Option<String> {
         extension_resolution(language)
             .iter()
             .filter(|ext| !base.is_empty() || ext.starts_with('/'))
             .map(|ext| if base.is_empty() { ext.trim_start_matches('/').to_string() } else { format!("{base}{ext}") })
+            .map(|candidate| indexed_spelling(&candidate, language))
             .find(|candidate| self.file_exists(candidate))
-            .or_else(|| self.file_exists(base).then(|| base.to_string()))
-            .or_else(|| self.find_source_for_emitted(base, language))
+            .or_else(|| {
+                let as_is = indexed_spelling(base, language);
+                self.file_exists(&as_is).then_some(as_is)
+            })
+            .or_else(|| self.find_source_for_emitted(&indexed_spelling(base, language), language))
     }
 
     /// resolveAliasedImport (import-resolver.ts): tsconfig paths → workspace
@@ -228,9 +351,22 @@ impl KernelResolver {
             }
         }
         if self.workspaces.is_some() {
-            if let Some(base) = self.resolve_workspace_import(import_path) {
-                if let Some(hit) = self.probe_extensions(&base, language) {
-                    return Ok(Some(hit));
+            // The entry the package's manifest declares for the import (#2502),
+            // else the member's directory where extension/index permutations
+            // find its barrel, else the source its build output mirrors.
+            if let Some(targets) = self.workspace_import_targets(import_path, from_file) {
+                if let Some(declared) = self.declared_workspace_entry(&targets, language) {
+                    return Ok(Some(declared));
+                }
+                let direct = self.probe_extensions(&targets.directory, language);
+                if direct.as_ref().is_some_and(|d| self.known_file(d)) {
+                    return Ok(direct);
+                }
+                if let Some(built) = self.built_source_of(&targets.directory, &targets.package_dir, language) {
+                    return Ok(Some(built));
+                }
+                if direct.is_some() {
+                    return Ok(direct);
                 }
             }
         }
@@ -1564,6 +1700,11 @@ impl KernelResolver {
             if let [node] = nodes.as_slice() {
                 return Ok(Some(KCand { node: node.clone(), confidence: 0.9, resolved_by: "import" }));
             }
+            // A name the package defines once per build target: the twin the
+            // reference's file builds with, or nothing (#2581).
+            if let Some(node) = self.go_pick_twin(&nodes, r)? {
+                return Ok(Some(KCand { node, confidence: 0.9, resolved_by: "import" }));
+            }
         }
         Ok(None)
     }
@@ -1763,6 +1904,111 @@ fn plain_import_names(line: &str, source: &str) -> Option<bool> {
     Some(clause.split(',').any(|name| name.trim() == source))
 }
 
+/// indexedSpelling (import-resolver.ts, upstream 8651990a / #2577): a path as
+/// the index keys its files. The alias, workspace and direct-path branches
+/// join an import specifier as written, so `@/widgets/Chart/` made
+/// `src/widgets/Chart//index.tsx` and `src/widgets/./Chart` made
+/// `src/widgets/./Chart/index.tsx` — spellings no file node or `files` row is
+/// keyed by. An ES-module specifier is read lexically, so `.` and empty
+/// segments drop and `..` folds; a trailing slash still names a folder. Other
+/// languages keep the path as found — a C include's `a/../b.h` follows the
+/// folder `a` on disk, symlinks included.
+fn indexed_spelling(file_path: &str, language: &str) -> String {
+    let dirty = file_path.contains("//")
+        || file_path.split('/').any(|seg| seg == "." || seg == "..");
+    if is_esm_import_language(language) && dirty {
+        pos_normalize(file_path)
+    } else {
+        file_path.to_string()
+    }
+}
+
+/// WorkspaceImportTargets (workspace-packages.ts): where an import of a
+/// project package lands before any file is probed.
+struct WorkspaceTargets {
+    /// The entries the package declares for the import, best first.
+    declared: Vec<String>,
+    /// The package's directory plus the import's subpath, extension-less.
+    directory: String,
+    /// The package's directory.
+    package_dir: String,
+}
+
+/// exportedTargets (workspace-packages.ts): `exports`' targets for `key` —
+/// the exact key's, else the `*` pattern's with the longest prefix, its `*`
+/// filled in.
+fn exported_targets(exports: &[(String, Vec<String>)], key: &str) -> Vec<String> {
+    for (k, targets) in exports {
+        if k == key {
+            return targets.clone();
+        }
+    }
+    let mut best: Option<(usize, String, &Vec<String>)> = None;
+    for (pattern, targets) in exports {
+        let Some(star) = pattern.find('*') else { continue };
+        if pattern[star + 1..].contains('*') {
+            continue;
+        }
+        let (prefix, suffix) = (&pattern[..star], &pattern[star + 1..]);
+        if key.len() < prefix.len() + suffix.len() || !key.starts_with(prefix) || !key.ends_with(suffix) {
+            continue;
+        }
+        if best.as_ref().is_some_and(|(b, _, _)| prefix.len() <= *b) {
+            continue;
+        }
+        best = Some((
+            prefix.len(),
+            key[prefix.len()..key.len() - suffix.len()].to_string(),
+            targets,
+        ));
+    }
+    match best {
+        Some((_, matched, targets)) => targets.iter().map(|t| t.replace('*', &matched)).collect(),
+        None => vec![],
+    }
+}
+
+/// builtSourcesOf (import-resolver.ts): `target` inside `package_dir`'s build
+/// output (`dist/`, `lib/`, `esm/`…) as the `src/` sources it is built from,
+/// best first.
+fn built_sources_of(target: &str, package_dir: &str) -> Vec<String> {
+    let prefix = if package_dir.is_empty() {
+        String::new()
+    } else {
+        format!("{package_dir}/")
+    };
+    if !target.starts_with(&prefix) {
+        return vec![];
+    }
+    let in_package = &target[prefix.len()..];
+    fn build_root() -> Rc<Regex> {
+        re!(r"^(?:dist|build|lib|out|output|es|esm|cjs|umd)/")
+    }
+    fn build_format() -> Rc<Regex> {
+        re!(r"^(?:esm|cjs|es|mjs|module|modules|commonjs|types|typings|umd|node|browser|src)/")
+    }
+    fn emitted_extension() -> Rc<Regex> {
+        re!(r"(?:\.d)?\.(?:[cm]?[jt]s|[jt]sx)$")
+    }
+    let Some(root) = build_root().find(in_package) else {
+        return vec![];
+    };
+    let mirrored = &in_package[root.end()..];
+    let format = build_format().find(mirrored);
+    let mut stems = vec![mirrored.to_string()];
+    if let Some(f) = format {
+        stems.push(mirrored[f.end()..].to_string());
+    }
+    let mut seen = HashSet::new();
+    stems
+        .iter()
+        .map(|rest| emitted_extension().replace(rest, "").to_string())
+        .filter(|stem| !stem.is_empty() && !stem.starts_with("src/"))
+        .filter(|stem| seen.insert(stem.clone()))
+        .map(|stem| format!("{prefix}src/{stem}"))
+        .collect()
+}
+
 #[cfg(test)]
 mod plain_import_tests {
     use super::plain_import_names;
diff --git a/codegraph-kernel/src/resolve/kotlin_receiver.rs b/codegraph-kernel/src/resolve/kotlin_receiver.rs
index bae796fc17..f18143d4df 100644
--- a/codegraph-kernel/src/resolve/kotlin_receiver.rs
+++ b/codegraph-kernel/src/resolve/kotlin_receiver.rs
@@ -314,6 +314,14 @@ impl KernelResolver {
             let ty=simple_type(text(ty,source)).to_string();
             return Ok(self.resolve_bound_type(&ty,&site,0)?.map(|_|KotlinReceiverHit{ty,site,heuristic:false}));
         }
+        if matches!(node.kind(),"postfix_unary_expression"|"postfix_expression") {
+            return match node.named_child(0) {Some(inner)=>self.kotlin_expression_type(inner,source,r,implicit,depth+1),None=>Ok(None)};
+        }
+        if node.kind()=="this_expression" {
+            let enclosing=self.nodes_in_file(&site.file_path)?.iter().filter(|n|super::call_shape::type_kind(&n.kind) && n.start_line<=site.line && n.end_line>=site.line).min_by_key(|n|n.end_line-n.start_line).cloned();
+            let Some(owner)=enclosing else {return Ok(None)};
+            return Ok(Some(KotlinReceiverHit{ty:owner.name.clone(),site:site.clone().at(&owner),heuristic:false}));
+        }
         if node.kind() == "simple_identifier" {
             if let Some(hit)=self.kotlin_narrowed_identifier(node,source,&site,depth)? {return Ok(Some(hit));}
             let name = text(node, source);
@@ -394,6 +402,18 @@ impl KernelResolver {
                     None => {
                         let enclosing=self.nodes_in_file(&site.file_path)?.iter().filter(|n|super::call_shape::type_kind(&n.kind) && n.start_line<=site.line && n.end_line>=site.line).min_by_key(|n|n.end_line-n.start_line).cloned();
                         if let Some(owner)=enclosing {member=self.match_bound_type_member(&owner.name,name,&site)?.map(|c|c.node);}
+                        // `fun Shop.reopen() { newBuilder() }` — inside an extension body a bare
+                        // call reaches the receiver type's members: the caller's qualified owner
+                        // (kotlinCallResultType's same-owner pool, #2822).
+                        if member.is_none() {
+                            if let Some(caller)=self.node_by_opt_id(Some(site.from_node_id.as_str()))? {
+                                if let Some((owner,_))=caller.qualified_name.rsplit_once("::") {
+                                    for spelling in [owner.replace("::","."), owner.rsplit([':','.']).next().unwrap_or(owner).to_string()] {
+                                        if let Some(m)=self.match_bound_type_member(&spelling,name,&site)? {member=Some(m.node);break;}
+                                    }
+                                }
+                            }
+                        }
                         let candidates: Vec<_> = self.nodes_by_name(name)?.iter().filter(|n| n.language == "kotlin" && n.kind == "function").cloned().collect();
                         let mut visible = Vec::new();
                         for n in candidates { if self.kotlin_top_level_visible(&n, &site)? { visible.push(n); } }
@@ -508,4 +528,153 @@ impl KernelResolver {
         // A project scope function can return a different type.
         Ok(!self.kotlin_user_member(&receiver.ty, "apply", &site)? && !self.kotlin_user_scope_callee(func, "apply", file.text(), &site)?)
     }
+
+    /// matchKotlinCallResultCall (name-matcher.ts #2822): `repository().pending(1)`
+    /// is emitted as bare `pending` at the property's column; the receiver is
+    /// the inner call's declared return, so the method is the one that type
+    /// declares — never a same-named method elsewhere. `Some(None)` is
+    /// upstream's terminal `null`; `None` is `undefined`, leaving the name
+    /// strategies their old behavior.
+    pub(super) fn match_kotlin_call_result_call(&mut self, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
+        if r.language != "kotlin" || r.reference_kind != "calls" || !re!(r"^[A-Za-z_]\w*$").is_match(&r.reference_name) { return Ok(None); }
+        let Some(hit) = self.kotlin_call_result_receiver(r)? else { return Ok(None) };
+        let hit = self.kotlin_scoped_hit(hit)?;
+        let owner = self.resolve_bound_type(&hit.ty, &hit.site, 0)?;
+        // isKotlinProjectType — a type from outside the project is no help.
+        if owner.is_none() { return Ok(None); }
+        let found = self.kotlin_receiver_member(&hit, &r.reference_name, r)?;
+        match found {
+            Some(member) => Ok(Some(Some(KCand { node: member, confidence: 0.85, resolved_by: "instance-method" }))),
+            None => {
+                // An extension the index doesn't keep under the type may be it
+                // (a top-level function, or one kept under a bare/nested
+                // receiver name): keep the old name-match behavior.
+                let extension = self.nodes_by_name(&r.reference_name)?.iter().any(|n| {
+                    n.language == "kotlin" && (n.kind == "function"
+                        || (n.kind == "method" && !n.qualified_name.rsplit_once("::").is_some_and(|(path, _)| path.contains("::"))))
+                });
+                if extension { Ok(None) } else { Ok(Some(None)) }
+            }
+        }
+    }
+
+    /// `repository().pending` — the bare ref sits on the property identifier,
+    /// and its navigation's receiver being a `call_expression` is the shape.
+    /// The inner call is unqualified (`repository(`, `this.repository(`, as
+    /// upstream's KOTLIN_UNQUALIFIED_CALL requires) and the outer suffix names
+    /// the ref: `repository().other().pending()` keeps the inner call a call.
+    fn kotlin_call_result_receiver(&mut self, r: &ResolveRefIn) -> Res<Option<KotlinReceiverHit>> {
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None) };
+        let source = file.text();
+        let node = descendant_for_position(tree.root_node(), source, ((r.line - 1).max(0) as usize, r.column.max(0) as usize));
+        if node.kind() != "simple_identifier" { return Ok(None); }
+        let Some(suffix) = node.parent().filter(|p| p.kind() == "navigation_suffix") else { return Ok(None) };
+        let Some(nav) = suffix.parent().filter(|p| p.kind() == "navigation_expression") else { return Ok(None) };
+        let Some(mut recv) = nav.named_child(0) else { return Ok(None) };
+        while matches!(recv.kind(), "postfix_unary_expression" | "postfix_expression" | "parenthesized_expression") {
+            let Some(inner) = recv.named_child(0) else { return Ok(None) };
+            recv = inner;
+        }
+        if recv.kind() != "call_expression" || nav.parent().is_none_or(|p| p.kind() != "call_expression") { return Ok(None); }
+        if !Self::kotlin_unqualified_callee(recv, source) { return Ok(None); }
+        self.kotlin_expression_type(recv, source, r, None, 0)
+    }
+
+    /// KOTLIN_UNQUALIFIED_CALL — `(?:this\s*\.\s*)?[a-z_]\w*\s*(<…>)?(`: the
+    /// callee of `call` is a lowercase bare name or `this.`-qualified.
+    fn kotlin_unqualified_callee(call: Node, source: &str) -> bool {
+        let Some(func) = call.named_child(0) else { return false };
+        match func.kind() {
+            "simple_identifier" => text(func, source).chars().next().is_some_and(|c| c.is_ascii_lowercase() || c == '_'),
+            "navigation_expression" => func.named_child(0).is_some_and(|h| h.kind() == "this_expression")
+                && property(func).is_some_and(|p| text(p, source).chars().next().is_some_and(|c| c.is_ascii_lowercase() || c == '_')),
+            _ => false,
+        }
+    }
+
+    /// kotlinLocalCallResultType — `val repo = repository()` types the local
+    /// by the call's declared return; `var repo = this.repository()!!` too.
+    /// The initializer must be an unqualified call alone (#2805).
+    pub(super) fn kotlin_local_call_result_type(&mut self, receiver: &str, site: &ResolveRefIn) -> Res<Option<String>> {
+        let bindings = self.bindings(&site.file_path)?;
+        let Some(binding) = innermost_binding(&bindings, receiver, Some(site.line)).filter(|b| b.kind != "import") else { return Ok(None) };
+        let decl = self.node_by_opt_id(binding.node_id.as_deref())?;
+        let path = decl.as_ref().map_or(site.file_path.as_str(), |n| n.file_path.as_str());
+        let Some(file) = self.read_file(path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, site) else { return Ok(None) };
+        let prop = match &decl {
+            Some(d) => Self::kotlin_decl_tree_node(&tree, file.text(), d, "property_declaration"),
+            None => Self::kotlin_local_property(tree.root_node(), file.text(), binding),
+        };
+        let Some(prop) = prop else { return Ok(None) };
+        let Some(mut init) = named_children(prop).into_iter().last() else { return Ok(None) };
+        while matches!(init.kind(), "postfix_unary_expression" | "postfix_expression" | "parenthesized_expression") {
+            let Some(inner) = init.named_child(0) else { return Ok(None) };
+            init = inner;
+        }
+        if init.kind() != "call_expression" || !Self::kotlin_unqualified_callee(init, file.text()) { return Ok(None); }
+        let Some(hit) = self.kotlin_expression_type(init, file.text(), site, None, 0)? else { return Ok(None) };
+        let hit = self.kotlin_scoped_hit(hit)?;
+        if self.resolve_bound_type(&hit.ty, &hit.site, 0)?.is_none() { return Ok(None); }
+        Ok(Some(hit.ty))
+    }
+
+    /// The `hit` retyped by the callee's signature when it points at one:
+    /// `return_type` keeps a user_type's first identifier (`Request`), while
+    /// kotlinDeclaredReturnType reads the signature's whole path
+    /// (`Request.Builder`) and kotlinScopedReturnType writes a lone nested
+    /// name through its declaring outer (`Builder` → `Shop.Builder`).
+    fn kotlin_scoped_hit(&mut self, hit: KotlinReceiverHit) -> Res<KotlinReceiverHit> {
+        let members: Vec<_> = self.nodes_in_file(&hit.site.file_path)?.iter()
+            .filter(|n| matches!(n.kind.as_str(), "function" | "method") && n.start_line == hit.site.line).cloned().collect();
+        let [member] = members.as_slice() else { return Ok(hit) };
+        let Some(ty) = self.kotlin_scoped_return_type(member)? else { return Ok(hit) };
+        Ok(KotlinReceiverHit { ty, site: hit.site, heuristic: hit.heuristic })
+    }
+
+    /// kotlinScopedReturnType — the signature's declared return path, a lone
+    /// name taken as the nested type of the innermost declaring scope that
+    /// has it: `fun newBuilder(): Builder` in `Shop` returns `Shop.Builder`.
+    fn kotlin_scoped_return_type(&mut self, member: &KNode) -> Res<Option<String>> {
+        let Some(written) = member.signature.as_deref().and_then(Self::kotlin_declared_return_type) else { return Ok(None) };
+        if written.contains('.') { return Ok(Some(written)); }
+        let scopes: Vec<&str> = member.qualified_name.split("::").collect();
+        let scopes = &scopes[..scopes.len().saturating_sub(1)];
+        for i in (1..=scopes.len()).rev() {
+            let scope = scopes[..i].join("::");
+            let is_type = |q: String| -> Res<bool> { Ok(self.nodes_by_qualified_name(&q)?.iter().any(|n| super::call_shape::type_kind(&n.kind) || n.kind == "module")) };
+            if is_type(scope.clone())? && is_type(format!("{scope}::{written}"))? {
+                return Ok(Some(format!("{}.{}", scopes[i - 1], written)));
+            }
+        }
+        Ok(Some(written))
+    }
+
+    /// kotlinDeclaredReturnType — the signature's `(): path` after the closing
+    /// paren, from its outermost type on, without `?`, `<>` or a package:
+    /// `(source: Buffer): Hpack.Reader` → `Hpack.Reader`.
+    fn kotlin_declared_return_type(sig: &str) -> Option<String> {
+        let sig = sig.trim();
+        if !sig.starts_with('(') { return None; }
+        let bytes = sig.as_bytes();
+        let (mut depth, mut close, mut i) = (0usize, None, 0usize);
+        while i < bytes.len() {
+            let c = bytes[i];
+            if c == b'"' || c == b'\'' {
+                i += 1;
+                while i < bytes.len() && bytes[i] != c { i += if bytes[i] == b'\\' { 2 } else { 1 }; }
+            } else if c == b'(' { depth += 1; }
+            else if c == b')' { depth -= 1; if depth == 0 { close = Some(i); break; } }
+            i += 1;
+        }
+        let written = sig.get(close? + 1..)?.trim_start().strip_prefix(':')?.trim();
+        let written = written.trim_end_matches('?');
+        let written = if written.ends_with('>') { written.find('<').map_or(written, |at| written[..at].trim_end()) } else { written };
+        let path: Vec<&str> = written.split('.').map(str::trim).collect();
+        if !path.iter().all(|p| re!(r"^[A-Za-z_]\w*$").is_match(p)) { return None; }
+        let types: Vec<&str> = path.iter().skip_while(|p| !p.starts_with(|c: char| c.is_ascii_uppercase())).copied().collect();
+        if types.is_empty() || !types.iter().all(|p| p.starts_with(|c: char| c.is_ascii_uppercase())) { return None; }
+        Some(types.join("."))
+    }
 }
diff --git a/codegraph-kernel/src/resolve/lang_scope.rs b/codegraph-kernel/src/resolve/lang_scope.rs
index ff43137acd..25a8d5303e 100644
--- a/codegraph-kernel/src/resolve/lang_scope.rs
+++ b/codegraph-kernel/src/resolve/lang_scope.rs
@@ -214,6 +214,12 @@ impl KernelResolver {
         if n.language != "kotlin" {
             return Ok(false);
         }
+        // isReceiverLessKotlinCall — a name written through a receiver
+        // (`text().reverse`) answers to that receiver, not to member scope;
+        // scope only judges what a receiver-less name can reach (#2822).
+        if !self.is_receiver_less_call(r)? {
+            return Ok(true);
+        }
         if !self.is_kotlin_member(n)? {
             return Ok(true);
         }
diff --git a/codegraph-kernel/src/resolve/method_call.rs b/codegraph-kernel/src/resolve/method_call.rs
index 65e4e03511..b24bbcf36b 100644
--- a/codegraph-kernel/src/resolve/method_call.rs
+++ b/codegraph-kernel/src/resolve/method_call.rs
@@ -628,6 +628,28 @@ impl KernelResolver {
         }
 
         // `this.#field.method` keeps its ES private field (#1987).
+        // A Go composite literal's written type carries its type arguments
+        // (`Box[int]{}.Size` arrives as `Box[int].Size`, `lib.List[int]{}.Len`
+        // as `lib.List[int].Len`); an indexed receiver arrives bare, so a
+        // bracketed receiver here is always an instantiation.
+        if r.language == "go" {
+            if let Some(m) = re!(r"^([A-Za-z0-9_.]+\[[^\]]*\])\.([A-Za-z0-9_]+)$").captures(&r.reference_name) {
+                return Ok(McShape::Parsed {
+                    receiver: m[1].to_string(),
+                    method: m[2].to_string(),
+                    inferable: true,
+                    dotted: true,
+                });
+            }
+        }
+        // An element of a field — `this.listeners[type].push()`, emitted as
+        // `this.listeners[].push`: the element type the field's declaration
+        // writes, or nothing (matchMethodCall's elementOf arm).
+        if is_js_family(&r.language) {
+            if let Some(m) = re!(r"^this\.(#?[A-Za-z0-9_$]+)\[\]\.([A-Za-z0-9_$]+)$").captures(&r.reference_name) {
+                return Ok(McShape::Done(self.match_ts_this_field_call(&m[1], &m[2], r, true)?));
+            }
+        }
         let dot_re = re!(r"^((?:this\.#)?[A-Za-z0-9_.]+)\.([A-Za-z0-9_]+:?(?:[A-Za-z0-9_]+:)*)$");
         // A JS/TS method name may carry `$`, which `\w` doesn't: an RxJS-style
         // `this.organizationService.organizations$()`, vscode's RPC
@@ -687,7 +709,40 @@ impl KernelResolver {
 
         if inferable {
             if r.language == "go" {
-                if let Some(verdict) = self.go_asserted_member(&object_or_class, &method_name, r)? { return Ok(verdict); }
+                // `Box[int]`/`lib.List[int]` is the written type of the
+                // composite literal the call selects on — the type's method
+                // answers, or nothing does; no local inference applies.
+                if let Some(base) = object_or_class.strip_suffix(']').and_then(|s| s.split('[').next()) {
+                    if re!(r"^\*?[A-Za-z_]\w*(\.[A-Za-z_]\w*)?$").is_match(base) {
+                        return self.go_method_on_declared_type(base, &r.file_path, &method_name, r);
+                    }
+                }
+                if let Some(verdict) = self.go_asserted_member(&object_or_class, &method_name, r)? {
+                    if verdict.is_none() { self.go_mc_terminal = true; }
+                    return Ok(verdict);
+                }
+                // A package-level value's spec types its method calls
+                // (`var level = Level(2)` → `level.Label()` on Level).
+                if !object_or_class.contains('.') {
+                    if let Some(verdict) = self.match_go_package_value_call(&object_or_class, &method_name, r)? {
+                        return Ok(verdict);
+                    }
+                    // The declared type settles the call when it is readable:
+                    // a literal (`[]Gomega`) or a type no project package
+                    // declares methods on means no project method answers.
+                    if let Some(decl) = self.go_local_declaration_at(
+                        object_or_class.clone(), r.file_path.clone(), r.line, r.column)?
+                    {
+                        if let Some(text) = &decl.declared_type {
+                            if Self::go_named_type(text).is_none()
+                                || matches!(self.go_written_type(text, r)?, Some(super::go_asserted::GoAsserted::Outside))
+                            {
+                                self.go_mc_terminal = true;
+                                return Ok(None);
+                            }
+                        }
+                    }
+                }
             }
             // A PHP `instanceof` branch narrows the receiver inside its body.
             if let Some(t) = probe!(r, "mc:guarded", self.infer_guarded_receiver(&object_or_class, r)?) {
@@ -726,6 +781,7 @@ impl KernelResolver {
             }
             // TS passes requireReceiverEvidence (=true) as preserveQualifiedName
             // to both inferrers here — qualified names stay intact.
+            let mut go_type_file: Option<String> = None;
             let mut inferred = if matches!(r.language.as_str(), "java" | "kotlin" | "csharp") && self.explicit_this_receiver(&object_or_class, &method_name, r) {
                 self.infer_declared_member_receiver_type(&format!("this.{object_or_class}"), r)?
             } else if r.language == "cpp" {
@@ -733,7 +789,18 @@ impl KernelResolver {
             } else if r.language == "python" && object_or_class.contains('.') {
                 None
             } else {
-                probe!(r, "mc:infer-local", self.infer_local_receiver_type(&object_or_class, &site, true)?)
+                let local = if r.language == "go" && !object_or_class.contains('.') {
+                    match self.go_local_receiver_written(&object_or_class, r)? {
+                        Some((t, f)) => { go_type_file = Some(f); Some(t) }
+                        None => None,
+                    }
+                } else {
+                    None
+                };
+                probe!(r, "mc:infer-local", match local {
+                    Some(_) => Ok(local),
+                    None => self.infer_local_receiver_type(&object_or_class, &site, true),
+                }?)
             };
             if r.language == "objc" && inferred.is_none() {
                 inferred = self.objc_member_receiver_type(&object_or_class, r)?;
@@ -802,8 +869,23 @@ if inferred.is_none() && r.language == "dart" {
                 if let Some(b) = &binding {
                     bsite.line = b.line;
                 }
+                // A Go type the written source read names the file that
+                // knows its package (`model := query.Query().Session` —
+                // Session lives in query/, not the call's).
+                if let Some(f) = &go_type_file {
+                    bsite.file_path = f.clone();
+                }
                 let member = self.match_bound_type_member(&t, &method_name, &bsite)?;
-                if member.is_none() && r.language == "kotlin" {
+                if member.is_none() && r.language == "go" {
+                    // A Go standard method name the declared type lacks is no
+                    // other type's (`err.Error()`, `context.Done()`); any
+                    // other name goes on to name matching, as one on a
+                    // receiver of unread type does.
+                    if super::call_shape::is_std_method("go", &method_name) {
+                        self.go_mc_terminal = true;
+                        return Ok(None);
+                    }
+                } else if member.is_none() && r.language == "kotlin" {
                     // An extension function is no member of the receiver's class, and in a
                     // package its qualified name does not say which class it extends.
                     let hit = super::kotlin_receiver::KotlinReceiverHit { ty: t.clone(), site: bsite, heuristic: false };
@@ -814,9 +896,11 @@ if inferred.is_none() && r.language == "dart" {
             }
         }
 
-        // Go 2-hop field chain — exclusive branch.
+        // Go 2-hop field chain — exclusive branch; its miss is terminal.
         if r.language == "go" && dotted && object_or_class.contains('.') {
-            return self.match_go_field_chain_call(&object_or_class, &method_name, r);
+            let hit = self.match_go_field_chain_call(&object_or_class, &method_name, r)?;
+            if hit.is_none() { self.go_mc_terminal = true; }
+            return Ok(hit);
         }
         // rust field/self arms: rust is unmigrated — dead.
         // this.field arms: `this.` receivers are excluded by the claim gate —
@@ -852,6 +936,15 @@ if inferred.is_none() && r.language == "dart" {
         Ok(None)
     }
 
+    /// Whether the bound-receiver miss is a local the index cannot type —
+    /// upstream's strategy-3 name match runs for it (`ctx`, bound from an
+    /// assertion to a type a function declares); every other miss —
+    /// terminal arms included — is refused. Clears both markers either way.
+    fn take_go_mc_untyped(&mut self) -> bool {
+        self.go_mc_terminal = false;
+        std::mem::take(&mut self.go_mc_untyped_local)
+    }
+
     /// matchMethodCall(ref, context, requireReceiverEvidence=false) — the
     /// member-tail arm of matchReference, reached by refs the boundReceiver
     /// claim never took (`this.`/`self.` roots, non-call kinds, deep
@@ -885,6 +978,7 @@ if inferred.is_none() && r.language == "dart" {
             // inferrers run at the ref's own site with qualified names
             // normalized (preserveQualifiedName=false).
             let cpp_alias = if r.language == "cpp" { self.cpp_receiver_alias(&object_or_class, r)? } else { None };
+            let mut go_type_file: Option<String> = None;
             let inferred = if let Some(alias) = &cpp_alias {
                 match &alias.raw {
                     Some(raw) => match self.cpp_type_owner(raw, &alias.site, 0, false)? {
@@ -897,6 +991,11 @@ if inferred.is_none() && r.language == "dart" {
                 self.infer_cpp_receiver_type(&object_or_class, r, 0, false)?
             } else if r.language == "python" && object_or_class.contains('.') {
                 None
+            } else if r.language == "go" && !object_or_class.contains('.') {
+                match self.go_local_receiver_written(&object_or_class, r)? {
+                    Some((t, f)) => { go_type_file = Some(f); Some(t) }
+                    None => self.infer_local_receiver_type(&object_or_class, r, true)?,
+                }
             } else {
                 self.infer_local_receiver_type(&object_or_class, r, r.language == "go")?
             };
@@ -979,9 +1078,10 @@ if inferred.is_none() && r.language == "dart" {
                     }
                 }
                 // An awaited type resolves from the file that declares it,
-                // and a hit on that type itself must live there.
+                // and a hit on that type itself must live there. A Go type
+                // the written source read names that file the same way.
                 let mut site = r.clone();
-                if let Some(f) = &awaited_file {
+                if let Some(f) = awaited_file.as_ref().or(go_type_file.as_ref()) {
                     site.file_path = f.clone();
                 }
                 match self.resolve_method_on_type(
@@ -1057,16 +1157,16 @@ if inferred.is_none() && r.language == "dart" {
         }
 
         // TS/JS `this.field.method` — EXCLUSIVE; the field's declared type
-        // off the enclosing class, validated by rmot, or nothing.
+        // off the enclosing class, validated by rmot, or nothing. An element
+        // of a field — `this.listeners[type].push()`, emitted as
+        // `this.listeners[].push` — resolves on the element's type.
         if matches!(r.language.as_str(), "typescript" | "javascript" | "tsx" | "jsx")
             && dotted
             && object_or_class.starts_with("this.")
         {
-            return self.match_ts_this_field_call(
-                &object_or_class["this.".len()..],
-                &method_name,
-                r,
-            );
+            let field = &object_or_class["this.".len()..];
+            let (field, element) = field.strip_suffix("[]").map_or((field, false), |f| (f, true));
+            return self.match_ts_this_field_call(field, &method_name, r, element);
         }
 
         // Java/Kotlin field receiver inference — non-exclusive (a miss still
@@ -1497,27 +1597,56 @@ if inferred.is_none() && r.language == "dart" {
                 if (r.language == "java" || r.language == "kotlin" || r.language == "python") && self.resolve_bound_type(root, r, 0)?.is_some() {
                     return if receiver == root { self.match_bound_type_member(root, method, r) } else { self.enum_constant_call(receiver, method, r) };
                 }
-                return Ok(match self.resolve_via_import_member(r)? {
-                    Some(c) => {
-                        if matches!(
-                            c.node.kind.as_str(),
-                            "function" | "method" | "class" | "component"
-                        ) {
-                            Some(c)
-                        } else {
-                            None
+                let via_import = self.resolve_via_import_member(r)?.filter(|c| {
+                    // A Go `pkg.Name` can name any exported package member —
+                    // `pkg.Type(…)` conversions included; edge-kind rewriting
+                    // decides calls-vs-references downstream.
+                    let go_member = r.language == "go"
+                        && matches!(c.node.kind.as_str(),
+                            "struct" | "interface" | "type_alias" | "variable" | "constant");
+                    go_member || matches!(
+                        c.node.kind.as_str(),
+                        "function" | "method" | "class" | "component"
+                    )
+                });
+                return Ok(match via_import {
+                    Some(c) => Some(c),
+                    // A Go `pkg.Type{}.M`/`pkg.Type[args]{}.M` keeps the
+                    // composite literal's written type — `pkg.Type`'s method
+                    // or nothing.
+                    None if r.language == "go" => {
+                        match re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)\[[^\]]*\]$")
+                            .captures(receiver)
+                            .or_else(|| re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)$").captures(receiver))
+                        {
+                            Some(m) => self.go_method_on_declared_type(&m[1], &r.file_path, method, r)?,
+                            None => None,
                         }
                     }
                     None => None,
                 });
             }
-            return Ok(probe!(r, "brc:match_method_call", self.match_method_call(r)?));
+            let hit = probe!(r, "brc:match_method_call", self.match_method_call(r)?);
+            if hit.is_none() && r.language == "go" && self.take_go_mc_untyped() {
+                return self.match_method_call_free(r);
+            }
+            return Ok(hit);
         }
 
         if binding.as_ref().is_some_and(|b| b.kind == "import") {
             // The import resolver descends one member — a deeper receiver
             // must not mistake the first member for the call.
             if receiver.contains('.') {
+                // A Go `pkg.Type{}.M`/`pkg.Type[args]{}.M` keeps the
+                // literal's written type — `pkg.Type`'s method or nothing.
+                if r.language == "go" {
+                    if let Some(m) = re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)\[[^\]]*\]$")
+                        .captures(receiver)
+                        .or_else(|| re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)$").captures(receiver))
+                    {
+                        return self.go_method_on_declared_type(&m[1], &r.file_path, method, r);
+                    }
+                }
                 return Ok(None);
             }
             return Ok(match self.resolve_via_import_member(r)? {
@@ -1589,6 +1718,9 @@ if inferred.is_none() && r.language == "dart" {
         if let Some(c) = probe!(r, "brc:match_method_call", self.match_method_call(r)?) {
             return Ok(Some(c));
         }
+        if r.language == "go" && self.take_go_mc_untyped() {
+            return self.match_method_call_free(r);
+        }
         if binding.kind == "param" {
             return Ok(None);
         }
diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index ad22ab4418..b6d1d32d3a 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -100,6 +100,31 @@ pub struct KernelScopedAliasIn {
     pub map: KernelAliasMapIn,
 }
 
+/// A string-keyed entry whose value is a list — `exports` subpath → targets.
+#[cfg_attr(feature = "addon", napi(object))]
+pub struct KernelKvList {
+    pub key: String,
+    pub values: Vec<String>,
+}
+
+/// A package directory's declared entries (workspace-packages.ts PackageEntries).
+#[cfg_attr(feature = "addon", napi(object))]
+pub struct KernelPackageEntriesIn {
+    /// Package directory relative to projectRoot.
+    pub dir: String,
+    /// `exports` key (`.`, `./widgets`, `./schema/*`) → its targets, best first.
+    pub exports: Vec<KernelKvList>,
+    /// source/module/main/types/typings targets, best first.
+    pub main: Vec<String>,
+}
+
+/// A manifest directory's path-dependency names → package directories.
+#[cfg_attr(feature = "addon", napi(object))]
+pub struct KernelScopedPackageIn {
+    pub dir: String,
+    pub names: Vec<KernelKv>,
+}
+
 #[cfg_attr(feature = "addon", napi(object))]
 pub struct KernelWorkspaceIn {
     /// Import-source path prefix → workspace package name (longest prefix wins).
@@ -110,6 +135,10 @@ pub struct KernelWorkspaceIn {
     pub entry_by_name: Option<Vec<KernelKv>>,
     /// Link-source package names skipped during directory checks.
     pub local_link_names: Option<Vec<String>>,
+    /// Package directory → its manifest's declared entries (exports, main fields).
+    pub entries_by_dir: Option<Vec<KernelPackageEntriesIn>>,
+    /// Manifest directory → `file:`/`link:`/`portal:` dependency name → package dir.
+    pub scoped_by_name: Option<Vec<KernelScopedPackageIn>>,
 }
 
 #[cfg_attr(feature = "addon", napi(object))]
@@ -400,6 +429,11 @@ impl SourceFile {
         self.text.get_or_init(|| self.lines.join("\n"))
     }
 
+    /// The 0-based line, or None past the file's end.
+    pub(super) fn line(&self, i: usize) -> Option<&str> {
+        self.lines.get(i).map(String::as_str)
+    }
+
     fn dart_tokens(&self) -> &[dart_libraries::DartToken] {
         self.dart_tokens.get_or_init(|| dart_libraries::tokens(self.text()))
     }
@@ -591,6 +625,8 @@ mod fields;
 mod rust_impls;
 mod ts_known;
 mod go_asserted;
+mod go_build;
+mod go_value;
 mod method_call;
 mod pipeline;
 mod file_refs;
@@ -663,6 +699,23 @@ pub struct KernelResolver {
     /// The run token the table is shared under (see NodeTable); None keeps
     /// the table private.
     generation: Option<String>,
+    /// manualMockNames (#2455): the names every Jest/Vitest manual mock
+    /// (`__mocks__/`) declares; `None` when the project has none.
+    mock_names: OnceCell<Option<Rc<query::MockNames>>>,
+    /// Set for one `resolve_ref` from non-test code: node lookups then
+    /// answer as if no `__mocks__/` file were indexed (mocklessContextFor).
+    mockless: std::cell::Cell<bool>,
+    /// classExpressions (#2499): the named class expressions' index; `None`
+    /// when the project has none.
+    class_expr_index: OnceCell<Option<Rc<query::ClassExprIndex>>>,
+    /// Set for one `resolve_ref` written outside every named class
+    /// expression: node lookups then answer as if the classes those
+    /// expressions declare and their members were not indexed
+    /// (classExpressionFreeContextFor).
+    class_expr_free: std::cell::Cell<bool>,
+    /// classExpressionOnlyNames' set: the names only class expressions'
+    /// classes and members carry.
+    class_expr_only: OnceCell<Rc<HashSet<String>>>,
     /// A file's bindings rows. Lookups cluster by file, so 128 files keep
     /// nearly every hit: unbounded, n8n's workers held 86-140 MB each.
     bindings_cache: Lru<Rc<Vec<KBinding>>>,
@@ -681,6 +734,30 @@ pub struct KernelResolver {
     /// cppProjectScopeNames: every name a C or C++ qualifier may start with in this project.
     cpp_scope_names: Option<Rc<HashSet<String>>>,
     rust_trait_memo: HashMap<String, bool>,
+    /// RUST_TYPED_REFS (name-matcher.ts): refs a Rust typed-receiver path
+    /// resolved, by row id — a trait-declared method such a ref lands on is
+    /// the trait's, not a name guess.
+    rust_typed_refs: HashSet<i64>,
+    /// rustTraitOf, by method id → the enclosing trait node's id.
+    rust_trait_of_memo: HashMap<String, Option<String>>,
+    /// goDotImports, by file path.
+    go_dot_imports_memo: HashMap<String, fields::GoDotImports>,
+    /// A Go bound-receiver arm proved the receiver has no project method —
+    /// the miss is terminal, not a name-match candidate (`goHasNoProjectMethods`,
+    /// declared-type literals, field-chain and asserted-outside vetoes).
+    go_mc_terminal: bool,
+    /// The receiver is an asserted local whose type a function declares —
+    /// no index type answers, and upstream's strategy-3 name match applies.
+    go_mc_untyped_local: bool,
+    /// goAliasTarget, by type node id.
+    go_alias_target_memo: HashMap<String, fields::GoAliasTarget>,
+    /// goUnreadFileMethods, by file path: `None` when the file can't be read.
+    go_unread_methods_memo: HashMap<String, Option<HashSet<String>>>,
+    /// goFileConstraint, by file path: `None` builds everywhere or can't be
+    /// read.
+    go_build_constraint_memo: HashMap<String, Option<Rc<go_build::GoFileConstraint>>>,
+    /// preferGoBuildTwin's same-package same-name pool, by target node id.
+    go_build_twins_memo: HashMap<String, Rc<Vec<Arc<KNode>>>>,
     /// javaSupertypesOf, by type name.
     java_supers_memo: HashMap<String, Rc<Vec<String>>>,
     /// phpSupertypeQns, by declaration id.
@@ -908,6 +985,39 @@ impl KernelResolver {
                 .local_link_names
                 .map(|v| v.into_iter().collect())
                 .unwrap_or_default(),
+            entries_by_dir: w
+                .entries_by_dir
+                .map(|v| {
+                    v.into_iter()
+                        .map(|e| {
+                            (
+                                e.dir,
+                                WorkspaceEntriesK {
+                                    exports: e
+                                        .exports
+                                        .into_iter()
+                                        .map(|kv| (kv.key, kv.values))
+                                        .collect(),
+                                    main: e.main,
+                                },
+                            )
+                        })
+                        .collect()
+                })
+                .unwrap_or_default(),
+            scoped_by_name: w
+                .scoped_by_name
+                .map(|v| {
+                    v.into_iter()
+                        .map(|s| {
+                            (
+                                s.dir,
+                                s.names.into_iter().map(|kv| (kv.key, kv.value)).collect(),
+                            )
+                        })
+                        .collect()
+                })
+                .unwrap_or_default(),
         });
         // context.getCppIncludeDirs?.() ?? [] — the TS side resolves
         // compile_commands.json + convention heuristics and passes the list;
@@ -917,6 +1027,11 @@ impl KernelResolver {
             conn: Some(conn),
             live: !snapshot,
             table: std::cell::OnceCell::new(),
+            mock_names: std::cell::OnceCell::new(),
+            mockless: std::cell::Cell::new(false),
+            class_expr_index: std::cell::OnceCell::new(),
+            class_expr_free: std::cell::Cell::new(false),
+            class_expr_only: std::cell::OnceCell::new(),
             lookups: config.query_lookups.unwrap_or(false).then(Default::default),
             db_path: config.db_path,
             generation: config.generation,
@@ -946,6 +1061,15 @@ impl KernelResolver {
             cpp_macro_arguments_memo: HashMap::new(),
             cpp_scope_names: None,
             rust_trait_memo: HashMap::new(),
+            rust_typed_refs: HashSet::new(),
+            rust_trait_of_memo: HashMap::new(),
+            go_dot_imports_memo: HashMap::new(),
+            go_mc_terminal: false,
+            go_mc_untyped_local: false,
+            go_alias_target_memo: HashMap::new(),
+            go_unread_methods_memo: HashMap::new(),
+            go_build_constraint_memo: HashMap::new(),
+            go_build_twins_memo: HashMap::new(),
             java_supers_memo: HashMap::new(),
             php_supers_memo: HashMap::new(),
             vb: vbnet::VbMemo::default(),
@@ -1049,6 +1173,7 @@ impl KernelResolver {
     #[cfg_attr(feature = "addon", napi)]
     pub fn close(&mut self) {
         self.debug_stats("close");
+        prof_dump("close");
         self.release_conn();
         self.table.take();
         self.file_cache.clear();
@@ -1328,7 +1453,10 @@ impl KernelResolver {
             });
             out.push(match hit {
                 Ok(c) => match c {
-                    Some(c) => ResolveOutcome::resolved(&c.node, c.confidence, c.resolved_by, true, None),
+                    Some(c) => {
+                        let outcome = ResolveOutcome::resolved(&c.node, c.confidence, c.resolved_by, true, None);
+                        if r.language == "go" { self.prefer_go_build_twin(outcome, &r)? } else { outcome }
+                    }
                     None => ResolveOutcome::unresolved(),
                 },
                 Err(Halt::Napi(e)) => return Err(e),
diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index d8652be24b..493a67ed67 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -304,6 +304,41 @@ impl KernelResolver {
         Ok(is_trait)
     }
 
+    /// Mark that a Rust typed-receiver path resolved `r` (RUST_TYPED_REFS).
+    pub(super) fn mark_rust_typed(&mut self, r: &ResolveRefIn) {
+        if let Some(id) = r.row_id {
+            self.rust_typed_refs.insert(id);
+        }
+    }
+
+    /// rustTraitOf (name-matcher.ts): the `trait` node `Owner::method`'s
+    /// owner names when it encloses the method's lines, else None.
+    pub(super) fn rust_trait_of(&mut self, candidate: &KNode) -> Res<Option<Arc<KNode>>> {
+        if let Some(hit) = self.rust_trait_of_memo.get(&candidate.id) {
+            return Ok(match hit {
+                Some(id) => self.node_by_id(id)?,
+                None => None,
+            });
+        }
+        let owner = candidate
+            .qualified_name
+            .rsplit_once("::")
+            .map(|(q, _)| q.rsplit("::").next().unwrap_or(""))
+            .unwrap_or("");
+        let found = if owner.is_empty() {
+            None
+        } else {
+            self.nodes_in_file(&candidate.file_path)?.iter().find(|n| {
+                n.kind == "trait" && n.name == owner
+                    && n.start_line <= candidate.start_line
+                    && n.end_line >= candidate.start_line
+            }).cloned()
+        };
+        self.rust_trait_of_memo
+            .insert(candidate.id.clone(), found.as_ref().map(|t| t.id.clone()));
+        Ok(found)
+    }
+
     /// isCrossFileReachable (name-matcher.ts).
     pub(super) fn is_cross_file_reachable(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
         if r.language != "markdown"
@@ -331,8 +366,35 @@ impl KernelResolver {
         Ok(!self.is_sealed_module(&candidate.file_path)? && !self.is_unexported_module_binding(candidate)?)
     }
 
+    /// Whether the reference's own import names the file `target` is in: a
+    /// default or named binding whose specifier resolves to that file. A
+    /// function value reached this way is import-justified, so a module's
+    /// unexported-binding rule does not bar it.
+    pub(super) fn ref_imports_target_file(&mut self, target: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        let name = r.reference_name.trim();
+        if name.is_empty() { return Ok(false); }
+        let mappings = self.import_mappings(&r.file_path)?;
+        for mapping in mappings.iter() {
+            if mapping.local_name != name { continue; }
+            let Some(hit) = self.resolve_via_import(&r.clone().naming(&mapping.local_name, "references"))? else { continue; };
+            if hit.node.file_path == target.file_path { return Ok(true); }
+        }
+        Ok(false)
+    }
+
     /// isVisibleAcrossFiles (name-matcher.ts).
     pub(super) fn is_visible_across_files(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        self.is_visible_across_files_for(candidate, r, true)
+    }
+
+    /// `is_visible_across_files` for a pick a strategy made from the code's own
+    /// structure — a receiver's type, a function value — rather than from the
+    /// name. Upstream guards only the name strategies with this rule
+    /// (index.ts:1867), so a module's unexported binding is no bar to a typed
+    /// pick: `items$.getState().inc()` reaches the store action `inc`, and an
+    /// imported component reaches its default export. Every language's own
+    /// privacy still applies.
+    pub(super) fn is_visible_across_files_for(&mut self, candidate: &KNode, r: &ResolveRefIn, name_pick: bool) -> Res<bool> {
         if candidate.language == "go" {
             if self.go_external_qualified(r)? { return Ok(false); }
             if let Some(imp) = self.go_ref_qualifier(r)? {
@@ -373,7 +435,15 @@ impl KernelResolver {
             return Ok(false);
         }
         if lang == "go" {
-            return Ok(go_name_visible(candidate, r));
+            return self.go_name_visible(candidate, r);
+        }
+        // A Dart `_name` is its library's, which spans the library file and
+        // its parts: riverpod_generator's `class Counter extends _$Counter`
+        // names the class it wrote into `main.g.dart` (upstream f7820b58).
+        if lang == "dart" {
+            return Ok(candidate.visibility.as_deref() != Some("private")
+                || (r.language == "dart"
+                    && self.dart_same_library(&r.file_path, &candidate.file_path)));
         }
         if lang == "rust" {
             if candidate.visibility.as_deref() != Some("private") {
@@ -382,6 +452,18 @@ impl KernelResolver {
             if self.is_rust_trait_impl_method(candidate)? {
                 return Ok(true);
             }
+            // A method a trait declares carries no `pub` of its own: it is
+            // the trait's, reached through a value whose type the call's
+            // receiver declares (rust_written_call marks the ref typed). A
+            // guess by its name alone stays out.
+            if candidate.kind == "method"
+                && r.row_id.is_some_and(|id| self.rust_typed_refs.contains(&id))
+                && self
+                    .rust_trait_of(candidate)?
+                    .is_none_or(|t| t.visibility.as_deref() != Some("private"))
+            {
+                return Ok(true);
+            }
             let owner = rust_module_dir(&candidate.file_path);
             return Ok(r.file_path.starts_with(&format!("{}/", owner)));
         }
@@ -404,6 +486,9 @@ impl KernelResolver {
         if (lang == "lua" || lang == "luau") && self.is_lua_local(candidate) {
             return Ok(self.lua_alias_target(r)?.flatten().is_some_and(|n| n.id == candidate.id));
         }
+        if !name_pick && is_esm_family(&candidate.language) {
+            return Ok(true);
+        }
         self.is_cross_file_reachable(candidate, r)
     }
 
@@ -442,7 +527,7 @@ impl KernelResolver {
 
     /// The name in a Go file's `package` clause (the first line that starts
     /// with `package`, outside block comments).
-    fn go_package_clause(&mut self, file: &str) -> Option<String> {
+    pub(super) fn go_package_clause(&mut self, file: &str) -> Option<String> {
         let lines = self.read_file(file)?;
         let mut in_block = false;
         for line in lines.iter() {
@@ -464,6 +549,32 @@ impl KernelResolver {
         None
     }
 
+    /// isGoNameVisible (name-matcher.ts): by the name's first letter, not the
+    /// extractor's flag (unset for every Go method, exported or not); an
+    /// unexported name is its own package's. A package is its directory AND
+    /// package clause: `a_test` files beside `a` files are a package of their
+    /// own whose bare top-level names reach `a` only through an import —
+    /// qualified, or bare after a dot import and exported (#2581).
+    pub(super) fn go_name_visible(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        let dir = pos_dirname(&candidate.file_path);
+        if dir != pos_dirname(&r.file_path) {
+            return Ok(candidate.name.chars().next().is_some_and(|c| c.is_ascii_uppercase()));
+        }
+        if candidate.file_path == r.file_path
+            || matches!(candidate.kind.as_str(), "method" | "property" | "field" | "enum_member")
+            || r.reference_name.contains('.')
+        {
+            return Ok(true);
+        }
+        let own = self.go_package_clause(&r.file_path);
+        let theirs = self.go_package_clause(&candidate.file_path);
+        if own.is_none() || theirs.is_none() || own == theirs {
+            return Ok(true);
+        }
+        Ok(candidate.name.chars().next().is_some_and(|c| c.is_ascii_uppercase())
+            && self.go_dot_imports(&r.file_path)?.dirs.iter().any(|d| *d == dir))
+    }
+
     /// isBarePhpCall (name-matcher.ts): a PHP `calls` ref written without a
     /// receiver — `redirect($url)`, `view('books.show')` — rather than
     /// `$this->redirect()` / `Foo::view()`. PHP has no implicit `$this`, so
@@ -783,7 +894,11 @@ impl KernelResolver {
                 // And a Go name that isn't exported, only its own package's: prometheus
                 // tsdb's `[]*memSeries` is head.go's, not `tsdb/agent`'s, which scored the
                 // same by directory proximity and was then vetoed as invisible.
-                && (n.language != "go" || go_name_visible(&n, r))
+                && (n.language != "go" || self.go_name_visible(&n, r)?)
+                // A Dart `_name` another library declares: the reference's
+                // own library's declaration wins instead of the namesake
+                // picked and then declined (upstream f7820b58 / #2466).
+                && !(r.language == "dart" && n.language == "dart" && n.visibility.as_deref() == Some("private") && n.file_path != r.file_path && !self.dart_same_library(&r.file_path, &n.file_path))
                 && !(matches!(r.language.as_str(),"lua"|"luau") && r.reference_kind=="calls" && !r.reference_name.contains(['.',':']) && n.kind=="method")
                 && !(r.language=="python" && r.reference_kind=="calls" && n.file_path!=r.file_path && self.is_receiver_less_call(r)? && self.python_locally_bound(&r.reference_name,r)? && !self.python_fixture_reachable(&n,&r.file_path)) {
                 kept.push(n);
@@ -950,15 +1065,70 @@ impl KernelResolver {
         }
         if self.is_cross_file_reachable(&best, r)? {
             let proximity = compute_path_proximity(&r.file_path, &best.file_path);
+            let confidence = if self.is_decisive_same_file_match(&best, r, &candidates)? {
+                0.9
+            } else if proximity >= 30 {
+                0.7
+            } else {
+                0.4
+            };
             return Ok(Some(KCand {
                 node: best,
-                confidence: if proximity >= 30 { 0.7 } else { 0.4 },
+                confidence,
                 resolved_by: "exact-match",
             }));
         }
         Ok(None)
     }
 
+    /// Whether `findBestMatch` picked `best` because it is THE definition in
+    /// the call site's own file, so the edge deserves a same-file confidence
+    /// rather than the directory-proximity one. Proximity measures shared
+    /// folders, so a same-file match in a shallow path scored 0.4 like a guess
+    /// across unrelated modules. Decisive only when:
+    /// - `best` is the ONLY same-file candidate — several are separated by
+    ///   line distance, which is not evidence;
+    /// - a member of a type, module or namespace belongs to one the caller is
+    ///   inside — a bare call does not reach a sibling class's method just
+    ///   because it is written in that file. A method's owner is always such a
+    ///   scope; another kind's is judged when the file declares it as anything
+    ///   but a function; and
+    /// - `best` is not the caller itself.
+    ///
+    /// (name-matcher.ts isDecisiveSameFileMatch, upstream cde4cd74.)
+    fn is_decisive_same_file_match(
+        &self,
+        best: &Arc<KNode>,
+        r: &ResolveRefIn,
+        candidates: &[Arc<KNode>],
+    ) -> Res<bool> {
+        if best.file_path != r.file_path || best.id == r.from_node_id {
+            return Ok(false);
+        }
+        if candidates.iter().any(|c| c.id != best.id && c.file_path == r.file_path) {
+            return Ok(false);
+        }
+        let sep = best.qualified_name.rfind("::").unwrap_or(0);
+        if sep == 0 {
+            return Ok(best.kind != "method");
+        }
+        let owner = &best.qualified_name[..sep];
+        if best.kind != "method" {
+            let declared = self.nodes_in_file(&best.file_path)?;
+            if declared
+                .iter()
+                .filter(|n| n.qualified_name == owner)
+                .all(|n| n.kind == "function" || n.kind == "method")
+            {
+                return Ok(true);
+            }
+        }
+        let Some(from) = self.node_by_id(&r.from_node_id)? else {
+            return Ok(false);
+        };
+        Ok(from.qualified_name == owner || from.qualified_name.starts_with(&format!("{owner}::")))
+    }
+
     /// The candidates a PHP `$this->m()` / `self::m()` / `parent::m()` call
     /// allows: methods of the class hierarchy around the call site
     /// (matchByExactName / matchFuzzy, name-matcher.ts).
@@ -1989,11 +2159,3 @@ mod js_unit_tests {
         s.chars().map(char::len_utf16).sum()
     }
 }
-
-/// isGoNameVisible (name-matcher.ts): by the name's first letter, not the
-/// extractor's flag (unset for every Go method, exported or not); an
-/// unexported name is its own package's directory's.
-fn go_name_visible(candidate: &KNode, r: &ResolveRefIn) -> bool {
-    candidate.name.chars().next().is_some_and(|c| c.is_ascii_uppercase())
-        || pos_dirname(&candidate.file_path) == pos_dirname(&r.file_path)
-}
diff --git a/codegraph-kernel/src/resolve/node_table.rs b/codegraph-kernel/src/resolve/node_table.rs
index 79be11601c..1f54f6eaa4 100644
--- a/codegraph-kernel/src/resolve/node_table.rs
+++ b/codegraph-kernel/src/resolve/node_table.rs
@@ -351,6 +351,7 @@ pub(super) struct QueryLookups {
     by_lower: HashMap<String, NodeList>,
     by_qname: HashMap<String, NodeList>,
     by_file: HashMap<String, NodeList>,
+    by_kind: HashMap<String, NodeList>,
     by_id: HashMap<String, Option<Arc<KNode>>>,
     known_files: HashMap<String, bool>,
     /// `SELECT path FROM files`, sorted — the Lua/Rust file buckets.
@@ -362,6 +363,7 @@ pub(super) enum LookupKey<'a> {
     Lower(&'a str),
     QualifiedName(&'a str),
     File(&'a str),
+    Kind(&'a str),
 }
 
 impl QueryLookups {
@@ -387,6 +389,7 @@ impl QueryLookups {
             ),
             LookupKey::QualifiedName(k) => (self.by_qname.get(k), "WHERE qualified_name = ?1 ORDER BY rowid", k.to_string()),
             LookupKey::File(k) => (self.by_file.get(k), "WHERE file_path = ?1 ORDER BY start_line, rowid", k.to_string()),
+            LookupKey::Kind(k) => (self.by_kind.get(k), "WHERE kind = ?1 ORDER BY file_path, start_line, rowid", k.to_string()),
         };
         if let Some(hit) = memo_hit {
             return Ok(hit.clone());
@@ -400,6 +403,7 @@ impl QueryLookups {
             LookupKey::Lower(_) => &mut self.by_lower,
             LookupKey::QualifiedName(_) => &mut self.by_qname,
             LookupKey::File(_) => &mut self.by_file,
+            LookupKey::Kind(_) => &mut self.by_kind,
         };
         memo.insert(arg, list.clone());
         Ok(list)
@@ -544,11 +548,23 @@ pub(super) struct FileExportIndexK {
 
 /// WorkspacePackages (workspace-packages.ts).
 #[derive(Clone, Debug, Default)]
+/// workspace-packages.ts PackageEntries.
+pub(super) struct WorkspaceEntriesK {
+    /// `exports` key → targets, best first (ordered like the map was read).
+    pub(super) exports: Vec<(String, Vec<String>)>,
+    /// source/module/main/types/typings targets, best first.
+    pub(super) main: Vec<String>,
+}
+
 pub(super) struct WorkspaceK {
     pub(super) source_entries: Vec<(String, String)>,
     pub(super) by_name: HashMap<String, String>,
     pub(super) entry_by_name: Option<HashMap<String, String>>,
     pub(super) local_link_names: HashSet<String>,
+    /// Package directory → its manifest's declared entries.
+    pub(super) entries_by_dir: HashMap<String, WorkspaceEntriesK>,
+    /// Manifest directory → path-dependency name → package directory.
+    pub(super) scoped_by_name: HashMap<String, HashMap<String, String>>,
 }
 
 // ---------------------------------------------------------------------------
diff --git a/codegraph-kernel/src/resolve/overloads_upstream.rs b/codegraph-kernel/src/resolve/overloads_upstream.rs
index 7f52847462..62ee3dcbba 100644
--- a/codegraph-kernel/src/resolve/overloads_upstream.rs
+++ b/codegraph-kernel/src/resolve/overloads_upstream.rs
@@ -740,8 +740,18 @@ impl KernelResolver {
     }
 
     pub(super) fn name_post_guard(&mut self, hit: &KCand, r: &ResolveRefIn) -> Res<bool> {
-        if (r.language == "rust" && r.reference_kind == "calls" && !self.rust_foreign_impl_callable(&hit.node, r)?)
-            || self.is_import_binding_call_target(&hit.node, r)? {
+        if r.language == "rust" && r.reference_kind == "calls" {
+            // `J::from(i)` under `use serde_json::Value as J` reaches only the
+            // project's impls for the outside type — never a project type's
+            // same-named function (#2614).
+            if r.reference_name.contains("::") && !self.rust_path_call_reachable(&hit.node, r)? {
+                return Ok(false);
+            }
+            if !self.rust_foreign_impl_callable(&hit.node, r)? {
+                return Ok(false);
+            }
+        }
+        if self.is_import_binding_call_target(&hit.node, r)? {
             return Ok(false);
         }
         if self.java_outside_import(r)? || !self.language_type_visible(&hit.node, r)?
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index b4237a37d1..74b45378d5 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -2,6 +2,12 @@
 
 use super::*;
 
+/// TYPE_COMPANION_VALUE_KINDS (index.ts #2801): the values a TypeScript
+/// type may share its name with in its file, which a call or `new` of the
+/// name means.
+static TYPE_COMPANION_VALUE_KINDS: &[&str] =
+    &["function", "class", "component", "constant", "variable"];
+
 impl KernelResolver {
     // -----------------------------------------------------------------------
     // Non-bare c/cpp `imports` refs — the #include-path slice (resolveOneInner
@@ -662,7 +668,7 @@ if super::lang_scope::is_dart_member_read(r) {
 
     /// gateTargetKind (index.ts): the imports/inheritance target-kind gates
     /// plus the out-of-repo import check.
-    pub(super) fn gate_target_kind(&mut self, cand: KCand, r: &ResolveRefIn) -> Res<Option<KCand>> {
+    pub(super) fn gate_target_kind(&mut self, mut cand: KCand, r: &ResolveRefIn) -> Res<Option<KCand>> {
         if r.language == "python" && r.reference_kind == "calls" && self.is_python_property(&cand.node) {
             return Ok(None);
         }
@@ -670,6 +676,21 @@ if super::lang_scope::is_dart_member_read(r) {
         if r.reference_kind == "calls" && cpp::is_define(&cand.node) {
             return Ok(None);
         }
+        // A TypeScript interface or type alias is no value: nothing calls
+        // one or makes an instance of it. A strategy that found one by name
+        // meant the value its file declares beside it (`interface Ok` and
+        // `function Ok` in a result module); with none there, the name is a
+        // value from elsewhere that the project only types (`new
+        // Response()`, `new Worker()`), and links nothing (#2801).
+        if matches!(r.reference_kind.as_str(), "calls" | "instantiates")
+            && is_esm_import_language(&r.language)
+            && matches!(cand.node.kind.as_str(), "interface" | "type_alias")
+        {
+            let Some(value) = self.same_named_value_of_type(&cand.node)? else {
+                return Ok(None);
+            };
+            cand.node = value;
+        }
         if r.reference_kind == "imports" {
             if r.language == "python" && self.is_python_from_import_module(r.clone())
                 && !matches!(cand.node.kind.as_str(), "file" | "module") { return Ok(None); }
@@ -690,7 +711,6 @@ if super::lang_scope::is_dart_member_read(r) {
         if self.is_import_binding_call_target(&cand.node, r)? {
             return Ok(None);
         }
-        let mut cand = cand;
         if r.language == "go" && cand.node.language == "go" {
             let is_type = matches!(cand.node.kind.as_str(), "struct" | "interface" | "type_alias");
             if r.reference_kind == "calls" && is_type && !r.reference_name.contains('.') && !self.is_bare_go_call(r)? {
@@ -705,13 +725,22 @@ if super::lang_scope::is_dart_member_read(r) {
                 } else if let Some(imp) = self.go_ref_qualifier(r)? {
                     self.go_package_dir(&imp.source, &r.file_path)
                 } else if self.go_written_qualifier(r)?.is_none() {
-                    Some(pos_dirname(&r.file_path).to_string())
+                    self.go_bare_type_dir(name, &r.file_path)?
                 } else { None };
                 if let Some(package) = package {
-                    let types: Vec<_> = self.nodes_by_name(name)?.iter()
-                        .filter(|n| n.language == "go" && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
-                            && pos_dirname(&n.file_path) == package)
-                        .cloned().collect();
+                    // The package is its directory AND clause: `a_test`'s
+                    // type position cannot name `a`'s fixture (#2581).
+                    let list = self.nodes_by_name(name)?;
+                    let mut types: Vec<_> = Vec::new();
+                    for n in list.iter() {
+                        if n.language == "go"
+                            && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
+                            && pos_dirname(&n.file_path) == package
+                            && self.go_name_visible(n, r)?
+                        {
+                            types.push(n.clone());
+                        }
+                    }
                     if let Some(target) = prefer_call_site_file(types, &r.file_path).first() {
                         cand.node = target.clone();
                     } else { return Ok(None); }
@@ -734,9 +763,30 @@ if super::lang_scope::is_dart_member_read(r) {
         if self.is_bound_to_out_of_repo_import(r)? {
             return Ok(None);
         }
+        // One embedded bare that only a package the file dot-imports
+        // declares is that package's, not a namesake as near the file
+        // (goDotImportedSupertype).
+        if r.language == "go" {
+            let Some(node) = self.go_dot_imported_supertype(&cand.node, r)? else { return Ok(None); };
+            cand.node = node;
+        }
         Ok(Some(cand))
     }
 
+    /// The value a file declares beside a type of the same name — `export
+    /// function Ok()` beside `export interface Ok`, a class merged with an
+    /// interface — which a call or `new` written with the name reaches
+    /// (sameNamedValueOfType, #2801). The first by position; None when the
+    /// file declares none.
+    fn same_named_value_of_type(&self, ty: &KNode) -> Res<Option<Arc<KNode>>> {
+        Ok(self
+            .nodes_in_file(&ty.file_path)?
+            .iter()
+            .filter(|n| n.name == ty.name && TYPE_COMPANION_VALUE_KINDS.contains(&n.kind.as_str()))
+            .min_by_key(|n| (n.start_line, n.start_column))
+            .cloned())
+    }
+
     /// The one supertype-kind node a TypeScript value shares its name and file with.
     fn same_named_type_of_value(&self, value: &KNode) -> Res<Option<Arc<KNode>>> {
         if !matches!(value.kind.as_str(), "constant" | "variable")
@@ -870,6 +920,24 @@ if super::lang_scope::is_dart_member_read(r) {
 
     /// The per-ref pipeline: the Rust `::`-path arm, then one route.
     pub(super) fn resolve_ref(&mut self, r: &ResolveRefIn) -> Res<ResolveOutcome> {
+        // mocklessContextFor (#2455): a ref from non-test code resolves on a
+        // graph without the project's Jest/Vitest manual mocks — every name
+        // lookup answers as if no `__mocks__/` file were indexed. Test code,
+        // a mock included, keeps the whole graph.
+        let mockless = !is_test_path(&r.file_path) && self.manual_mock_names()?.is_some();
+        // classExpressionFreeContextFor (#2499): a ref written outside every
+        // named class expression resolves on a graph without the classes they
+        // declare and their members.
+        let class_free = self.class_expr_free_for(r)?;
+        let prev = self.mockless.replace(mockless);
+        let prev_free = self.class_expr_free.replace(class_free);
+        let outcome = self.resolve_ref_scoped(r);
+        self.mockless.set(prev);
+        self.class_expr_free.set(prev_free);
+        outcome
+    }
+
+    fn resolve_ref_scoped(&mut self, r: &ResolveRefIn) -> Res<ResolveOutcome> {
         let attribute = if r.language == "python" && r.reference_kind == "calls" {
             Some(self.resolve_python_attribute(r.clone())?)
         } else { None };
@@ -900,6 +968,12 @@ if super::lang_scope::is_dart_member_read(r) {
         if let Some(attribute) = attribute {
             if !attribute.type_from.is_empty() { outcome.type_from = Some(attribute.type_from); }
         }
+        // A Go name its package defines under complementary build
+        // constraints resolves to the twin the reference's file builds with
+        // (preferGoBuildTwin, #2581).
+        if r.language == "go" {
+            outcome = self.prefer_go_build_twin(outcome, r)?;
+        }
         Ok(outcome)
     }
 
@@ -929,10 +1003,18 @@ if super::lang_scope::is_dart_member_read(r) {
         }
         if let Some(result) = self.ts_scoped_reference(r)? {
             return match result {
-                Some(candidate) => match self.gate_target_kind(candidate, r)? {
-                    Some(candidate) => self.finish_pre_framework(r, candidate),
-                    None => Ok(self.refused()),
-                },
+                Some(mut candidate) => {
+                    // `extends`/`implements` resolve through the import
+                    // binding at upstream's `import` 0.9; the scoped arm's
+                    // 0.95 is for type-position `references` (#2825's dumps).
+                    if is_inheritance_ref(&r.reference_kind) && candidate.resolved_by == "import" {
+                        candidate.confidence = 0.9;
+                    }
+                    match self.gate_target_kind(candidate, r)? {
+                        Some(candidate) => self.finish_pre_framework(r, candidate),
+                        None => Ok(self.refused()),
+                    }
+                }
                 None => Ok(self.refused()),
             };
         }
@@ -1024,6 +1106,12 @@ if super::lang_scope::is_dart_member_read(r) {
                 None => Ok(ResolveOutcome::unresolved()),
             };
         }
+        // A Kotlin call on an unqualified call's result — `repository().pending()`
+        // — resolves against the inner call's declared return type, never a
+        // same-named method elsewhere (#2822). `Some(None)` is terminal.
+        if let Some(result) = self.match_kotlin_call_result_call(r)? {
+            return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
+        }
         if is_js_family(&r.language) && r.reference_kind == "calls" {
             // matchJsSuperCall: `super.m()` binds to the nearest `extends`
             // ancestor's method before any name strategy can guess (#2497).
@@ -1064,6 +1152,9 @@ if super::lang_scope::is_dart_member_read(r) {
         if let Some(result) = self.go_assertion_call(r)? {
             return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
         }
+        if let Some(result) = self.match_go_expr_call(r)? {
+            return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
+        }
         if let Some(result) = self.cpp_complex_call(r)? {
             return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
         }
@@ -1224,6 +1315,30 @@ if r.language == "dart" && r.reference_kind == "references"
                 }
             }
         }
+        // A definition its language makes file- or library-local cannot be
+        // what a name in another file means, whichever strategy chose it —
+        // name-matcher.ts isVisibleAcrossFiles at index.ts:1867 (#1730), run
+        // on the node after supertype/overload/alias retargets the way
+        // upstream vets the target matchReference reports. Upstream's import,
+        // file-path and framework results never reach that guard, and an
+        // import pick's alias forward can legitimately land on an unexported
+        // module member. A pick a strategy made from the code's structure —
+        // a receiver's type or a function value — keeps every language's own
+        // privacy but not a module's unexported-binding rule, which upstream
+        // applies to the name strategies alone.
+        // A function value the file's own import names is justified by that
+        // import, not by its name: an unexported inner function behind a
+        // default-exported wrapper stays reachable through the default import.
+        let name_pick = match winner.resolved_by {
+            "instance-method" | "field-call" => false,
+            "function-ref" => !self.ref_imports_target_file(&winner.node, r)?,
+            _ => true,
+        };
+        if !matches!(winner.resolved_by, "import" | "framework" | "file-path")
+            && !self.is_visible_across_files_for(&winner.node, r, name_pick)?
+        {
+            return Ok(ResolveOutcome::unresolved());
+        }
         Ok(ResolveOutcome::resolved(
             &winner.node,
             winner.confidence,
diff --git a/codegraph-kernel/src/resolve/prefilter.rs b/codegraph-kernel/src/resolve/prefilter.rs
index 8ca8f89f89..e32bc9df25 100644
--- a/codegraph-kernel/src/resolve/prefilter.rs
+++ b/codegraph-kernel/src/resolve/prefilter.rs
@@ -298,7 +298,7 @@ impl KernelResolver {
                 if self.known_file(&file) { return local; }
             }
         }
-        if self.workspaces.is_some() && self.resolve_workspace_import(&source).is_some() {
+        if self.workspaces.is_some() && self.resolve_workspace_import(&source, &r.file_path).is_some() {
             return local;
         }
         if !self.is_declared_outside_package(&source, &r.file_path)
@@ -359,7 +359,7 @@ impl KernelResolver {
     /// playground fixtures.
     pub(super) fn repository_package(&mut self, package: &str, from_file: &str) -> RepositoryPackage {
         if let Some(ws) = &self.workspaces {
-            if ws.local_link_names.contains(package) || self.resolve_workspace_import(package).is_some() {
+            if ws.local_link_names.contains(package) || self.resolve_workspace_import(package, from_file).is_some() {
                 return RepositoryPackage::Mapped;
             }
         }
diff --git a/codegraph-kernel/src/resolve/python_types.rs b/codegraph-kernel/src/resolve/python_types.rs
index 04555adf39..3fd5719d8b 100644
--- a/codegraph-kernel/src/resolve/python_types.rs
+++ b/codegraph-kernel/src/resolve/python_types.rs
@@ -2,6 +2,7 @@
 //! Syntax trees distinguish executable assignments/returns from strings,
 //! nested definitions and incomplete expressions. All evidence names its
 //! source files so incremental sync can reopen dependent edges.
+use super::super::bound::{python_def_params, python_param_names, PyFile};
 use super::*;
 use tree_sitter::Node as PyNode;
 
@@ -14,7 +15,7 @@ pub struct PythonAttributeResult {
     pub type_from: Vec<String>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 enum Answer {
     Class(Arc<KNode>),
     Declared(Arc<KNode>),
@@ -614,6 +615,7 @@ impl KernelResolver {
             return Ok(result);
         };
         let mut read = HashSet::new();
+        let mut strict_local = false;
         let answer = if let Some(callee) = receiver.strip_suffix("()") {
             if !simple_name(callee) {
                 return Ok(result);
@@ -624,13 +626,10 @@ impl KernelResolver {
                 return Ok(result);
             }
             self.python_callable_result(callee, r, &mut read, 0, false)?
-        } else {
-            let Some((head, attr)) = receiver
-                .split_once('.')
-                .filter(|(_, a)| simple_name(a) && !a.contains('.'))
-            else {
-                return Ok(result);
-            };
+        } else if let Some((head, attr)) = receiver
+            .split_once('.')
+            .filter(|(_, a)| simple_name(a) && !a.contains('.'))
+        {
             if self.python_outside_module_receiver(head, r)? {
                 result.claimed = true;
                 return Ok(result);
@@ -662,16 +661,71 @@ impl KernelResolver {
                 return Ok(result);
             };
             self.python_attribute_type(&class, attr, r, &mut read, &mut HashSet::new())?
+        } else {
+            // matchPythonTypedLocalCall (#2583): `reg.get()`-shaped calls —
+            // a plain local or parameter receiver on a builtin-named method —
+            // settle only through the strict scope evidence read; a name it
+            // cannot type, or whose evidence contests, stays refused rather
+            // than name-guessed. A `self`/`cls` receiver or a builtin type
+            // name keeps the ordinary paths.
+            if !re!(r"^[A-Za-z_]\w*$").is_match(receiver)
+                || !PYTHON_BUILT_IN_METHODS.contains(method)
+                || PYTHON_BUILT_IN_TYPES.contains(receiver)
+                || receiver == "self"
+                || receiver == "cls"
+            {
+                return Ok(result);
+            }
+            strict_local = true;
+            // A receiver that names a class declared here is a static-style
+            // call (`File.write(f, "x")`), which the ordinary paths resolve;
+            // the strict read is for a local or a parameter.
+            if self.python_ref_class(receiver, r)?.is_some() {
+                return Ok(result);
+            }
+            // A lambda's own parameter of the name shadows the outer binding;
+            // its default is that outer value, which the ordinary paths read.
+            if self.python_lambda_parameter_named(receiver, r)? {
+                return Ok(result);
+            }
+            // A binding a branch, loop or `try` may not run leaves no single
+            // value in effect; claim it and link nothing.
+            if self.python_conditional_bindings(receiver, r)? {
+                result.claimed = true;
+                return Ok(result);
+            }
+            // A lambda body reads its captured cell when invoked, and a name
+            // no binding reaches it yet (a future initialization) stays
+            // unresolved there, as the fork's receiver-scope rules hold.
+            let future = self.receiver_binding(receiver, r)?.is_some_and(|b| b.line > r.line);
+            if future && self.python_in_lambda_body(r)? {
+                result.claimed = true;
+                return Ok(result);
+            }
+            // `None` is upstream's `undefined`: no enclosing def binds the
+            // name, so it is no local — the ordinary paths keep it.
+            let Some(answer) = self.python_local_class(receiver, r, &mut read)? else {
+                return Ok(result);
+            };
+            result.claimed = true;
+            answer
         };
-        let declared = matches!(answer, Answer::Declared(_));
+        let declared = matches!(answer, Answer::Declared(_)) && !strict_local;
         match answer {
             Answer::Runtime => result.claimed = true,
             Answer::Class(class) | Answer::Declared(class) => {
                 result.claimed = true;
-                if let Some(mro) = self.python_mro(&class, 0)? {
-                    read.extend(mro.iter().map(|c| c.file_path.clone()));
-                }
-                let mut members = self.python_members(&class, method, r, &mut HashSet::new())?;
+                let mut members = if strict_local {
+                    // pythonMethodOnClass: own member, else a declared base's —
+                    // read through the file's imports so a base from outside
+                    // the project holds none of its methods.
+                    self.python_strict_members(&class, method, r, &mut HashSet::new())?
+                } else {
+                    if let Some(mro) = self.python_mro(&class, 0)? {
+                        read.extend(mro.iter().map(|c| c.file_path.clone()));
+                    }
+                    self.python_members(&class, method, r, &mut HashSet::new())?
+                };
                 if members.is_empty() && declared {
                     members = self.python_descendant_members(&class, method, r)?;
                 }
@@ -690,6 +744,684 @@ impl KernelResolver {
         result.type_from.sort();
         Ok(result)
     }
+
+    /// Whether the reference sits in a lambda body whose parameters include
+    /// `name`: the lambda's own parameter, whose default is that outer value.
+    fn python_lambda_parameter_named(&mut self, name: &str, r: &ResolveRefIn) -> Res<bool> {
+        let Some(source) = self.read_file(&r.file_path) else { return Ok(false) };
+        let Some(tree) = self.parsed_tree(&source, r) else { return Ok(false) };
+        let text = source.text();
+        let leaf = super::iteration::descendant_for_position(
+            tree.root_node(),
+            text,
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let at = leaf.start_byte();
+        let mut current = Some(leaf);
+        while let Some(node) = current {
+            if node.kind() == "lambda"
+                && node.child_by_field_name("body").is_some_and(|body| body.start_byte() <= at && at < body.end_byte())
+                && node.child_by_field_name("parameters").is_some_and(|params| {
+                    super::iteration::named_children(params).into_iter().any(|param| {
+                        let named = param.child_by_field_name("name").unwrap_or(param);
+                        named.kind() == "identifier" && &text[named.start_byte()..named.end_byte()] == name
+                    })
+                })
+            {
+                return Ok(true);
+            }
+            current = node.parent();
+        }
+        Ok(false)
+    }
+
+    /// Whether the reference `r` sits in a lambda's body (not its parameters or
+    /// a default), a deferred read with no graph function node of its own.
+    fn python_in_lambda_body(&mut self, r: &ResolveRefIn) -> Res<bool> {
+        let Some(source) = self.read_file(&r.file_path) else { return Ok(false) };
+        let Some(tree) = self.parsed_tree(&source, r) else { return Ok(false) };
+        let text = source.text();
+        let leaf = super::iteration::descendant_for_position(
+            tree.root_node(),
+            text,
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let at = leaf.start_byte();
+        let mut current = Some(leaf);
+        while let Some(node) = current {
+            if node.kind() == "lambda"
+                && node.child_by_field_name("body").is_some_and(|body| body.start_byte() <= at && at < body.end_byte())
+            {
+                return Ok(true);
+            }
+            current = node.parent();
+        }
+        Ok(false)
+    }
+
+    /// Whether the def around `r` binds `name` inside a branch, loop, `try` or
+    /// `with` before the call: no single value is in effect there, so the
+    /// strict read refuses rather than taking the last written assignment.
+    fn python_conditional_bindings(&mut self, name: &str, r: &ResolveRefIn) -> Res<bool> {
+        let Some(src) = self.read_file(&r.file_path) else { return Ok(false) };
+        let file = src.python_file();
+        let at = (r.line - 1).max(0) as usize;
+        let start = match file.stmt(at) {
+            Some((s, code)) if re!(r"^\s*(?:async\s+)?def\b").is_match(code) => Some(*s),
+            _ => file.scope.get(at).copied().flatten(),
+        };
+        let Some(d) = start else { return Ok(false) };
+        let assign = Self::cached_regex(&format!(r"^\s*{}\s*(?::[^=]*)?=[^=]", regex::escape(name)))?;
+        // One conditional binding beside a `None` placeholder or a later plain
+        // assignment still has a value to read. Two conditional bindings in
+        // different blocks do not.
+        let end = python_scope_end(file, d);
+        let mut conditional = 0;
+        for i in (d + 1)..=end.min(file.code.len().saturating_sub(1)) {
+            let Some(line) = src.get(i) else { break };
+            if !assign.is_match(line.trim_start()) { continue; }
+            let indent = line.len() - line.trim_start().len();
+            let mut j = i;
+            let mut inside = false;
+            while j > d {
+                j -= 1;
+                let Some(above) = src.get(j) else { break };
+                let trimmed = above.trim_start();
+                if trimmed.is_empty() || trimmed.starts_with('#') { continue; }
+                if above.len() - trimmed.len() >= indent { continue; }
+                if re!(r"^(?:if|elif|else|for|while|try|except|finally|with)\b").is_match(trimmed) {
+                    inside = true;
+                    break;
+                }
+            }
+            if inside {
+                conditional += 1;
+                if conditional >= 2 { return Ok(true); }
+            }
+        }
+        Ok(false)
+    }
+
+    /// pythonLocalClass (#2583): the project class the local or parameter
+    /// `name` holds at `r`, agreed by every binding of it in the binding
+    /// def's own body — a parameter annotation, `name: T`, `name = Ctor()`,
+    /// `name = factory()`, `name = None` (no evidence). Any other binding —
+    /// a `for`/`with`/`except`/comprehension target, a tuple or augmented
+    /// assignment, a walrus, an import, `del`, a nested `def` or `class` of
+    /// the name, a `nonlocal` write — leaves it unknown, and a contested
+    /// one is no class at all. `None` is no local at all — a `global`
+    /// binding, a module-level name, or no enclosing def — upstream's
+    /// `undefined`, where the ordinary paths keep the call.
+    fn python_local_class(&mut self, name: &str, r: &ResolveRefIn, read: &mut HashSet<String>) -> Res<Option<Answer>> {
+        let Some(src) = self.read_file(&r.file_path) else {
+            return Ok(None);
+        };
+        let file = src.python_file();
+        let at = (r.line - 1).max(0) as usize;
+        // pythonBindingScope: the innermost def around the ref that binds the
+        // name — a parameter, or any binding in its own body. A `global`
+        // binding or no such def is no local.
+        let start = match file.stmt(at) {
+            Some((s, code)) if re!(r"^\s*(?:async\s+)?def\b").is_match(code) => Some(*s),
+            _ => file.scope.get(at).copied().flatten(),
+        };
+        let mut scope: Option<(usize, Option<Option<String>>, Vec<PyBinding>)> = None;
+        for d in file.functions_around(start) {
+            let (param, bindings) = python_scope_state(file, &src, d, name)?;
+            if param.is_some() {
+                scope = Some((d, param, bindings));
+                break;
+            }
+            if bindings.iter().any(|b| matches!(b, PyBinding::Global)) {
+                return Ok(None);
+            }
+            if !bindings.is_empty() {
+                scope = Some((d, param, bindings));
+                break;
+            }
+        }
+        let Some((d, param, bindings)) = scope else {
+            return Ok(None);
+        };
+        let mut evidence: Vec<Answer> = Vec::new();
+        // (evidence index, line, whether it rebinds the name): a bare
+        // annotation (`store: B`) does not.
+        let mut lines: Vec<(usize, usize, bool)> = Vec::new();
+        if let Some(param) = param {
+            // A parameter without an annotation is no evidence.
+            let Some(ann) = param else {
+                return Ok(Some(Answer::Unknown));
+            };
+            let ev = self.python_ann_answer(&ann, r, read)?;
+            if matches!(ev, Answer::Unknown) {
+                return Ok(Some(Answer::Unknown));
+            }
+            lines.push((evidence.len(), 0, true));
+            evidence.push(ev);
+        }
+        for b in &bindings {
+            let PyBinding::Assign { ty, value, line } = b else {
+                return Ok(Some(Answer::Unknown));
+            };
+            let value = value.trim();
+            let annotation_only = ty.is_some() && value.is_empty();
+            let ev = if let Some(ty) = ty {
+                // `reg: Base = make()` trusts the annotation; `reg: A = B()` contradicts it.
+                if !value.is_empty() && value != "None" {
+                    if let Some(ctor) = python_constructor_call(value) {
+                        if ctor.rsplit('.').next() != ty.trim().trim_matches(['\'', '"']).rsplit('.').next() {
+                            return Ok(Some(Answer::Unknown));
+                        }
+                    }
+                }
+                self.python_ann_answer(ty, r, read)?
+            } else if value == "None" {
+                continue;
+            } else if re!(r"^[A-Za-z_]\w*$").is_match(value) {
+                // `reg = cap`: what the def's parameter `cap` is annotated
+                // with, unless the def binds `cap` anywhere else.
+                let (copied_param, copied_bindings) = python_scope_state(file, &src, d, value)?;
+                let Some(Some(ann)) = copied_param else {
+                    return Ok(Some(Answer::Unknown));
+                };
+                if !copied_bindings.is_empty() {
+                    return Ok(Some(Answer::Unknown));
+                }
+                self.python_ann_answer(&ann, r, read)?
+            } else {
+                // A callee the def binds (`Store = load(); reg = Store()`) is no evidence.
+                for callee in python_value_callees(value) {
+                    let root = callee.split('.').next().unwrap_or(&callee);
+                    if self.python_binds_locally(root, &r.file_path, (*line + 1) as i64, false)? {
+                        return Ok(Some(Answer::Unknown));
+                    }
+                }
+                self.python_value_text_answer(value, r, read, 0)?
+            };
+            if matches!(ev, Answer::Absent) {
+                continue;
+            }
+            lines.push((evidence.len(), *line, !annotation_only));
+            evidence.push(ev);
+        }
+        // Nothing here can be a project class: a builtin, or no evidence.
+        if !evidence.iter().any(|e| !matches!(e, Answer::Runtime)) {
+            return Ok(if evidence.is_empty() { Some(Answer::Unknown) } else { Some(Answer::Runtime) });
+        }
+        // A def or class of the name nested in the scope binds it there; a
+        // def nested in it can rebind the scope's own through `nonlocal`;
+        // `with … as (a, name)` binds it in a way bindings don't read.
+        let end = python_scope_end(file, d);
+        if self.nodes_in_file(&r.file_path)?.iter().any(|n| {
+            matches!(n.kind.as_str(), "function" | "method" | "class")
+                && n.name == name
+                && n.start_line > d as i64 + 1
+                && n.end_line <= end as i64 + 1
+        }) {
+            return Ok(Some(Answer::Unknown));
+        }
+        for i in d..=end.min(file.code.len().saturating_sub(1)) {
+            let Some((_, code)) = file.code.get(i) else { break };
+            if !code.contains(name) {
+                continue;
+            }
+            if re!(r"^\s*nonlocal\b").is_match(code) && bare_word(code, name) {
+                return Ok(Some(Answer::Unknown));
+            }
+            if let Some(cap) = re!(r"\bas\s*\(([^)]*)\)").captures(code) {
+                if bare_word(&cap[1], name) {
+                    return Ok(Some(Answer::Unknown));
+                }
+            }
+        }
+        // The fork's receiver-scope rule reads the binding in effect at the
+        // call, not every binding the def makes (`store = A(); store = B();
+        // store.get()` is B's). A same-line replacement, or a later one a
+        // closure's captured cell sees, leaves it unknown; so does a binding
+        // shape this read refuses (checked above).
+        if self.python_receiver_uncertain(r)? {
+            return Ok(Some(Answer::Unknown));
+        }
+        // A conditional, loop or `try` binding may not run, so no chronological
+        // order decides between it and another: `if flag: store = A() else:
+        // store = B()` leaves the call unknown, as #2821 refuses.
+        let control_bound = |line0: usize| -> bool {
+            let Some(binding) = src.get(line0) else { return false };
+            let binding_indent = binding.len() - binding.trim_start().len();
+            let mut i = line0;
+            while i > d {
+                i -= 1;
+                let Some(line) = src.get(i) else { break };
+                let trimmed = line.trim_start();
+                if trimmed.is_empty() || trimmed.starts_with('#') { continue; }
+                if line.len() - trimmed.len() >= binding_indent { continue; }
+                if re!(r"^(?:if|elif|else|for|while|try|except|finally|with)").is_match(trimmed) {
+                    return true;
+                }
+            }
+            false
+        };
+        // `PyBinding` lines are zero-based; the ref's line is one-based.
+        let at = r.line.max(0) as usize;
+        let eligible = |line: &usize, rebinds: &bool| *rebinds && *line < at;
+        if lines.iter().any(|(_, line, rebinds)| eligible(line, rebinds) && control_bound(*line)) {
+            return Ok(Some(Answer::Unknown));
+        }
+        if let Some((i, line, _)) = lines
+            .iter()
+            .filter(|(_, line, rebinds)| eligible(line, rebinds))
+            .max_by_key(|(_, line, _)| *line)
+        {
+            // A conflicting set where the binding in effect may not run stays
+            // unknown: `store = A(); if flag: store = B(); store.get()`.
+            if control_bound(*line) && matches!(agree(evidence.clone()), Answer::Unknown) {
+                return Ok(Some(Answer::Unknown));
+            }
+            return Ok(Some(evidence[*i].clone()));
+        }
+        // Nothing binds the name before the call: `store.get(); store = A()`
+        // raises UnboundLocalError in the def's own body. A nested def that
+        // captures the outer name reads it when invoked, which the fork keeps.
+        if start == Some(d) {
+            return Ok(Some(Answer::Unknown));
+        }
+        // A lone initialization, later or not, is retained only when it is the
+        // def's only evidence.
+        Ok(Some(agree(evidence)))
+    }
+
+    /// pythonFindMethod's member walk for the strict local path: `member` on
+    /// `cls` itself, else on a base the class's file declares — resolved
+    /// through that file's imports (`python_bases`), never through the
+    /// `extends` edges, so a base spelled from a module outside the project
+    /// holds none of its methods.
+    fn python_strict_members(
+        &mut self,
+        cls: &Arc<KNode>,
+        member: &str,
+        r: &ResolveRefIn,
+        seen: &mut HashSet<String>,
+    ) -> Res<Vec<Arc<KNode>>> {
+        if seen.len() >= 16 || !seen.insert(cls.id.clone()) {
+            return Ok(Vec::new());
+        }
+        if self.python_class_assigns(cls, member)? {
+            return Ok(vec![cls.clone()]);
+        }
+        let own: Vec<Arc<KNode>> = self
+            .nodes_by_qualified_name(&format!("{}::{}", cls.qualified_name, member))?
+            .iter()
+            .filter(|n| n.file_path == cls.file_path)
+            .cloned()
+            .collect();
+        if !own.is_empty() {
+            return Ok(own);
+        }
+        let mut out: Vec<Arc<KNode>> = Vec::new();
+        for base in self.python_bases(cls, r)? {
+            for n in self.python_strict_members(&base, member, r, seen)? {
+                if !out.iter().any(|o| o.id == n.id) {
+                    out.push(n);
+                }
+            }
+        }
+        Ok(out)
+    }
+
+    /// pythonAnnotationEvidence → pythonEvidenceClass: `Optional[T]`,
+    /// `Union[T, None]`, `T | None` and `"T"` unwrap to `T`; a runtime
+    /// container type is 'runtime', anything unreadable is unknown.
+    fn python_ann_answer(&mut self, raw: &str, site: &ResolveRefIn, read: &mut HashSet<String>) -> Res<Answer> {
+        let mut t = raw.trim().trim_matches(['\'', '"']).trim().to_string();
+        for _ in 0..4 {
+            if t.is_empty() {
+                break;
+            }
+            let cap = re!(r"^(?:typing\.)?Optional\s*\[\s*(.+)\s*\]$").captures(&t)
+                .or_else(|| re!(r"^(?:typing\.)?Union\s*\[\s*([^,\]]+?)\s*,\s*None\s*\]$").captures(&t))
+                .or_else(|| re!(r"^(.+?)\s*\|\s*None$").captures(&t))
+                .or_else(|| re!(r"^None\s*\|\s*(.+)$").captures(&t));
+            let Some(cap) = cap else {
+                break;
+            };
+            t = cap[1].trim().trim_matches(['\'', '"']).trim().to_string();
+        }
+        let head = t.split('[').next().unwrap_or("").trim().trim_start_matches("typing.");
+        if PYTHON_RUNTIME_TYPES.contains(head) {
+            return Ok(Answer::Runtime);
+        }
+        if t.contains('[') || !re!(r"^[A-Za-z_][\w.]*$").is_match(&t) || head == "Any" {
+            return Ok(Answer::Unknown);
+        }
+        self.python_named_answer(&t, site, read)
+    }
+
+    /// pythonValueEvidence → pythonEvidenceClass for a whole assigned value:
+    /// a conditional's arms must agree; literals and runtime containers are
+    /// 'runtime'; `Ctor()` is that class; `factory(...)` resolves by what the
+    /// factory produces; anything else is unknown.
+    fn python_value_text_answer(
+        &mut self,
+        raw: &str,
+        site: &ResolveRefIn,
+        read: &mut HashSet<String>,
+        depth: usize,
+    ) -> Res<Answer> {
+        if depth >= 8 {
+            return Ok(Answer::Unknown);
+        }
+        if let Some((a, b)) = python_conditional_arms(raw) {
+            let x = self.python_value_text_answer(&a, site, read, depth + 1)?;
+            let y = self.python_value_text_answer(&b, site, read, depth + 1)?;
+            return Ok(agree(vec![x, y]));
+        }
+        let mut awaited = false;
+        let mut v = raw.trim();
+        if let Some(rest) = v.strip_prefix("await") {
+            if rest.starts_with(char::is_whitespace) {
+                v = rest.trim();
+                awaited = true;
+            }
+        }
+        let Some(shape) = python_expr_shape(v) else {
+            return Ok(Answer::Unknown);
+        };
+        if re!(r"^(?:S(?: S)*|-?\d[\w.]*|True|False|\[\]|\{\}|\(\))$").is_match(&shape) {
+            return Ok(if awaited { Answer::Unknown } else { Answer::Runtime });
+        }
+        if let Some(cap) = re!(r"^([A-Za-z_][\w.]*) ?\(\)$").captures(&shape) {
+            let callee = cap[1].to_string();
+            if PYTHON_RUNTIME_TYPES.contains(callee.as_str()) {
+                return Ok(if awaited { Answer::Unknown } else { Answer::Runtime });
+            }
+            if callee
+                .rsplit('.')
+                .next()
+                .is_some_and(|leaf| leaf.starts_with(|c: char| c.is_ascii_uppercase()))
+            {
+                return if awaited {
+                    Ok(Answer::Unknown)
+                } else {
+                    self.python_named_answer(&callee, site, read)
+                };
+            }
+            return self.python_callable_result(&callee, site, read, depth + 1, awaited);
+        }
+        Ok(Answer::Unknown)
+    }
+}
+
+/// pythonScopeBindings: `name`'s parameter-annotation state in the def at
+/// statement line `d` — None when it is no parameter, Some(None) for a bare
+/// or starred one, Some(Some) for `name: T` — plus every binding of the name
+/// in the def's own body (a one-line body on the header line counts).
+fn python_scope_state(
+    file: &PyFile,
+    lines: &[String],
+    d: usize,
+    name: &str,
+) -> Res<(Option<Option<String>>, Vec<PyBinding>)> {
+    let header = file.stmt(d).map(|(_, h)| h.clone()).unwrap_or_default();
+    // Params are read off the raw header — the statement's strings are
+    // blanked, so `reg: "T"` reads `reg: "          "` there; offsets match.
+    let raw = file
+        .stmts
+        .iter()
+        .position(|(i, _)| *i == d)
+        .map(|k| python_raw_stmt(file, lines, k))
+        .unwrap_or_else(|| header.clone());
+    let params = python_def_params(&header)
+        .map(|p| raw.get(p.clone()).map_or_else(|| header[p].to_string(), str::to_string))
+        .unwrap_or_default();
+    let param = python_param_names(&params)
+        .contains(&name)
+        .then(|| python_param_ann(&params, name))
+        .flatten();
+    let mut bindings = Vec::new();
+    if let Some(body) = header_colon(&header)
+        .map(|at| &header[at + 1..])
+        .filter(|b| !b.trim().is_empty())
+    {
+        bindings.extend(python_stmt_bindings(body, body, name, d)?);
+    }
+    for (k, (i, code)) in file.stmts.iter().enumerate() {
+        if file.scope[*i] != Some(d) || !mentions(code, name) {
+            continue;
+        }
+        let raw = python_raw_stmt(file, lines, k);
+        bindings.extend(python_stmt_bindings(code, &raw, name, *i)?);
+    }
+    Ok((param, bindings))
+}
+
+/// The last line inside the `def`/`class` at line `d`, nested bodies
+/// included — the range a `nonlocal` or `as (…)` scan must cover.
+fn python_scope_end(file: &PyFile, d: usize) -> usize {
+    let mut end = d;
+    for (i, s) in file.scope.iter().enumerate().skip(d + 1) {
+        let mut at = *s;
+        while let Some(h) = at {
+            if h == d {
+                end = i;
+                break;
+            }
+            at = file.scope[h];
+        }
+    }
+    end
+}
+
+/// pythonBlankStrings: `line` with the contents of its string literals
+/// blanked (quotes kept), so a string never reads as code. A quote left open
+/// blanks the rest of the line.
+fn python_blank_strings(line: &str) -> String {
+    let bytes = line.as_bytes();
+    let mut out = bytes.to_vec();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let c = bytes[i];
+        if c != b'"' && c != b'\'' {
+            i += 1;
+            continue;
+        }
+        let triple = bytes.get(i + 1) == Some(&c) && bytes.get(i + 2) == Some(&c);
+        let qlen = if triple { 3 } else { 1 };
+        let mut j = i + qlen;
+        while j < bytes.len() && !line.get(j..).is_some_and(|s| s.starts_with(&line[i..i + qlen])) {
+            j += if bytes[j] == b'\\' { 2 } else { 1 };
+        }
+        for o in out.iter_mut().take(j.min(bytes.len())).skip(i + qlen) {
+            *o = b' ';
+        }
+        i = (j + qlen).min(bytes.len());
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// `name: T` or `name: T = d` in a def's parameter list: Some(Some(T)),
+/// Some(None) for a bare or starred parameter, None when not a parameter.
+/// Commas and the default's `=` are read on a string-blanked copy.
+fn python_param_ann(params: &str, name: &str) -> Option<Option<String>> {
+    let blank = python_blank_strings(params);
+    let mut depth = 0i32;
+    let mut from = 0usize;
+    let mut parts: Vec<std::ops::Range<usize>> = Vec::new();
+    for (i, c) in blank.char_indices() {
+        match c {
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            ',' if depth == 0 => {
+                parts.push(from..i);
+                from = i + 1;
+            }
+            _ => {}
+        }
+    }
+    parts.push(from..blank.len());
+    for range in parts {
+        let part = &params[range.clone()];
+        let Some(cap) = re!(r"^\s*(\*{0,2})([A-Za-z_]\w*)\s*(:?)").captures(part) else {
+            continue;
+        };
+        if &cap[2] != name {
+            continue;
+        }
+        if !cap[1].is_empty() || cap[3].is_empty() {
+            return Some(None);
+        }
+        let at = cap[0].len();
+        // The annotation runs up to the default's `=`, outside brackets.
+        let mut d = 0i32;
+        let mut to = part.len();
+        for (i, c) in blank[range.clone()][at..].char_indices() {
+            match c {
+                '(' | '[' | '{' => d += 1,
+                ')' | ']' | '}' => d -= 1,
+                '=' if d == 0 => {
+                    to = at + i;
+                    break;
+                }
+                _ => {}
+            }
+        }
+        let ann = part[at..to].trim();
+        return Some((!ann.is_empty()).then(|| ann.to_string()));
+    }
+    None
+}
+
+/// pythonValueCallees: the names `value` calls as a whole expression or
+/// conditional arm — `Client(...)`, `make()` — whose local rebinding would
+/// make the evidence wrong.
+fn python_value_callees(value: &str) -> Vec<String> {
+    if let Some((a, b)) = python_conditional_arms(value.trim()) {
+        return [a, b].into_iter().flat_map(|arm| python_value_callees(&arm)).collect();
+    }
+    let mut v = value.trim();
+    if let Some(rest) = v.strip_prefix("await") {
+        if rest.starts_with(char::is_whitespace) {
+            v = rest.trim();
+        }
+    }
+    python_expr_shape(v)
+        .and_then(|shape| re!(r"^([A-Za-z_][\w.]*) ?\(\)$").captures(&shape).map(|c| c[1].to_string()))
+        .into_iter()
+        .collect()
+}
+
+/// pythonConditionalArms: the two arms of a top-level `A if c else B`;
+/// keywords inside brackets or strings do not count.
+fn python_conditional_arms(raw: &str) -> Option<(String, String)> {
+    let mut depth = 0i32;
+    let mut if_at: Option<usize> = None;
+    let bytes = raw.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let c = bytes[i];
+        let ch = raw[i..].chars().next().unwrap();
+        if c == b'"' || c == b'\'' {
+            let triple = bytes.get(i + 1) == Some(&c) && bytes.get(i + 2) == Some(&c);
+            let close_len = if triple { 3 } else { 1 };
+            let close = &raw[i..i + close_len];
+            let mut j = i + close_len;
+            while j < bytes.len() && !raw.get(j..).is_some_and(|s| s.starts_with(close)) {
+                j += if bytes[j] == b'\\' { 2 } else { 1 };
+            }
+            i = j + close_len;
+            continue;
+        }
+        if matches!(c, b'(' | b'[' | b'{') {
+            depth += 1;
+        } else if matches!(c, b')' | b']' | b'}') {
+            depth -= 1;
+        } else if depth == 0 && raw[..i].chars().next_back().is_some_and(|p| p.is_whitespace()) {
+            let rest = &raw[i..];
+            if if_at.is_none()
+                && rest.starts_with("if")
+                && rest.len() > 2
+                && rest.as_bytes()[2].is_ascii_whitespace()
+            {
+                if_at = Some(i);
+            } else if if_at.is_some()
+                && rest.starts_with("else")
+                && rest.len() > 4
+                && rest.as_bytes()[4].is_ascii_whitespace()
+            {
+                let at = if_at.unwrap();
+                return Some((raw[..at].trim().to_string(), raw[i + 4..].trim().to_string()));
+            }
+        }
+        i += ch.len_utf8();
+    }
+    None
+}
+
+/// pythonExprShape: the top-level shape of a python expression — string
+/// literals collapse to `S` and everything inside brackets is dropped, so
+/// `Client(a, f(b))` reads `Client()` and `Client() if t else Fake()` keeps
+/// its `if`. None when the expression is left open or unrecoverable.
+fn python_expr_shape(raw: &str) -> Option<String> {
+    python_expr_scan(raw).0
+}
+
+/// pythonExprScan: `shape` plus why there is none — 'continues' for an open
+/// bracket or triple-quoted string or a trailing `\`, 'broken' for a
+/// single-line string left open or a bracket closed that was never opened.
+fn python_expr_scan(raw: &str) -> (Option<String>, &'static str) {
+    let mut out = String::new();
+    let mut depth = 0i32;
+    let bytes = raw.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let c = bytes[i];
+        let ch = raw[i..].chars().next().unwrap();
+        if c == b'"' || c == b'\'' {
+            let triple = bytes.get(i + 1) == Some(&c) && bytes.get(i + 2) == Some(&c);
+            let close_len = if triple { 3 } else { 1 };
+            let close = &raw[i..i + close_len];
+            let mut j = i + close_len;
+            while j < bytes.len() && !raw.get(j..).is_some_and(|s| s.starts_with(close)) {
+                j += if bytes[j] == b'\\' { 2 } else { 1 };
+            }
+            if j >= bytes.len() {
+                return (None, if triple { "continues" } else { "broken" });
+            }
+            if depth == 0 {
+                let strip = out
+                    .chars()
+                    .rev()
+                    .take(2)
+                    .take_while(|k| "rbfuRBFU".contains(*k))
+                    .count();
+                out.truncate(out.len() - strip);
+                out.push('S');
+            }
+            i = j + close_len;
+            continue;
+        }
+        if matches!(c, b'(' | b'[' | b'{') {
+            if depth == 0 {
+                out.push(ch);
+            }
+            depth += 1;
+        } else if matches!(c, b')' | b']' | b'}') {
+            depth -= 1;
+            if depth < 0 {
+                return (None, "broken");
+            }
+            if depth == 0 {
+                out.push(ch);
+            }
+        } else if depth == 0 {
+            out.push(ch);
+        }
+        i += ch.len_utf8();
+    }
+    let shape = out.split_whitespace().collect::<Vec<_>>().join(" ");
+    if depth > 0 || shape.ends_with('\\') {
+        return (None, "continues");
+    }
+    (Some(shape), "none")
 }
 #[cfg_attr(feature = "addon", napi)]
 impl KernelResolver {
diff --git a/codegraph-kernel/src/resolve/query.rs b/codegraph-kernel/src/resolve/query.rs
index 463f7a1429..82a26456a0 100644
--- a/codegraph-kernel/src/resolve/query.rs
+++ b/codegraph-kernel/src/resolve/query.rs
@@ -21,6 +21,52 @@ pub(super) fn read_source(path: impl AsRef<std::path::Path>) -> Option<String> {
     Some(String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned()))
 }
 
+/// manualMockNames' payload: every name (and its lowercase) a `__mocks__/`
+/// file declares.
+pub(super) struct MockNames {
+    pub names: HashSet<String>,
+    pub lower: HashSet<String>,
+}
+
+/// The mockless view's node filter: `__mocks__/` nodes out, order kept.
+fn drop_mock_nodes(list: NodeList) -> NodeList {
+    if !list.iter().any(|n| is_manual_mock_path(&n.file_path)) {
+        return list;
+    }
+    Arc::new(list.iter().filter(|n| !is_manual_mock_path(&n.file_path)).cloned().collect())
+}
+
+/// classExpressions' payload (#2499): the classes named class expressions
+/// declare — by name, by file, the files holding them, and the ids of them
+/// and their members, which a reference outside them resolves without.
+pub(super) struct ClassExprIndex {
+    pub by_name: HashMap<String, Vec<Arc<KNode>>>,
+    pub by_file: HashMap<String, Vec<Arc<KNode>>>,
+    pub files: HashSet<String>,
+    pub hidden_ids: HashSet<String>,
+}
+
+/// CLASS_EXPRESSION_REF_LANGUAGES: the languages a class expression's class
+/// and the references to its name can be written in — TS/JS, and the
+/// scripts of Vue, Svelte and Astro files.
+const CLASS_EXPR_LANGS: &[&str] = &[
+    "typescript", "tsx", "javascript", "jsx", "arkts", "vue", "svelte", "astro",
+];
+
+/// isJsClassExpression — a class a named class expression declares: its
+/// signature is its head (`class Widget extends Base`), which a class
+/// declaration doesn't carry.
+fn is_js_class_expression(n: &KNode) -> bool {
+    n.kind == "class" && n.signature.is_some() && CLASS_EXPR_LANGS.contains(&n.language.as_str())
+}
+
+/// writtenIn — `r` is written inside `node`'s source range.
+fn written_in(n: &KNode, r: &ResolveRefIn) -> bool {
+    n.file_path == r.file_path
+        && (r.line > n.start_line || (r.line == n.start_line && r.column >= n.start_column))
+        && (r.line < n.end_line || (r.line == n.end_line && r.column <= n.end_column))
+}
+
 impl KernelResolver {
     /// The live connection — errors once close() has run. Statements borrow
     /// it, so the Option indirection stays inside this accessor.
@@ -50,36 +96,240 @@ impl KernelResolver {
         })
     }
 
+    /// The class-expression-free view's node filter
+    /// (classExpressionFreeView's `keep`, #2499): the classes named class
+    /// expressions declare and their members, out; order kept.
+    fn drop_class_expr_nodes(&self, list: NodeList) -> Res<NodeList> {
+        let Some(idx) = self.class_expr_index()? else {
+            return Ok(list);
+        };
+        if !list.iter().any(|n| idx.hidden_ids.contains(&n.id)) {
+            return Ok(list);
+        }
+        Ok(Arc::new(list.iter().filter(|n| !idx.hidden_ids.contains(&n.id)).cloned().collect()))
+    }
+
     /// queries.getNodesByName — ORDER BY file_path, start_line.
     pub(super) fn nodes_by_name(&self, name: &str) -> Res<NodeList> {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
-            return r;
+        let mut list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
+            r?
+        } else {
+            let t = self.table()?;
+            t.by_name.get(name).cloned().unwrap_or_else(|| t.empty.clone())
+        };
+        // Only a name some mock declares can lose a node (mocklessContextFor).
+        if self.mockless.get() && self.manual_mock_names()?.is_some_and(|m| m.names.contains(name)) {
+            list = drop_mock_nodes(list);
         }
-        let t = self.table()?;
-        Ok(t.by_name.get(name).cloned().unwrap_or_else(|| t.empty.clone()))
+        if self.class_expr_free.get() {
+            list = self.drop_class_expr_nodes(list)?;
+        }
+        Ok(list)
     }
 
     /// queries.getNodesByLowerName — `WHERE lower(name) = lower(?)`, no
     /// ORDER BY (rowid order, same as the TS reader).
     pub(super) fn nodes_by_lower_name(&self, name: &str) -> Res<NodeList> {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Lower(name))) {
-            return r;
+        let mut list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Lower(name))) {
+            r?
+        } else {
+            let t = self.table()?;
+            t.by_lower().get(&name.to_ascii_lowercase()).cloned().unwrap_or_else(|| t.empty.clone())
+        };
+        if self.mockless.get()
+            && self.manual_mock_names()?.is_some_and(|m| m.lower.contains(&name.to_lowercase()))
+        {
+            list = drop_mock_nodes(list);
         }
-        let t = self.table()?;
-        Ok(t.by_lower().get(&name.to_ascii_lowercase()).cloned().unwrap_or_else(|| t.empty.clone()))
+        if self.class_expr_free.get() {
+            list = self.drop_class_expr_nodes(list)?;
+        }
+        Ok(list)
     }
 
     /// queries.getNodesByQualifiedName — no ORDER BY (TS uses rowid order).
     pub(super) fn nodes_by_qualified_name(&self, qname: &str) -> Res<NodeList> {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::QualifiedName(qname))) {
+        let mut list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::QualifiedName(qname))) {
+            r?
+        } else {
+            let t = self.table()?;
+            t.by_qname.get(qname).cloned().unwrap_or_else(|| t.empty.clone())
+        };
+        if self.mockless.get() && self.manual_mock_names()?.is_some() {
+            list = drop_mock_nodes(list);
+        }
+        if self.class_expr_free.get() {
+            list = self.drop_class_expr_nodes(list)?;
+        }
+        Ok(list)
+    }
+
+    /// manualMockNames (resolution/index.ts #2455): the names every Jest or
+    /// Vitest manual mock (`__mocks__/`) declares, `None` when the project
+    /// has none. Read once — the node table it feeds is a run constant.
+    pub(super) fn manual_mock_names(&self) -> Res<Option<Rc<MockNames>>> {
+        if let Some(v) = self.mock_names.get() {
+            return Ok(v.clone());
+        }
+        let files: Vec<String> = match &self.lookups {
+            Some(_) => self.sorted_files().unwrap_or_default().as_ref().clone(),
+            None => self.table()?.files.iter().cloned().collect(),
+        };
+        let mut names = HashSet::new();
+        let mut lower = HashSet::new();
+        for file in files.iter().filter(|f| is_manual_mock_path(f)) {
+            for n in self.nodes_in_file_unfiltered(file)?.iter() {
+                lower.insert(n.name.to_lowercase());
+                names.insert(n.name.clone());
+            }
+        }
+        let v = if names.is_empty() { None } else { Some(Rc::new(MockNames { names, lower })) };
+        Ok(self.mock_names.get_or_init(|| v).clone())
+    }
+
+    /// classExpressions (resolution/index.ts #2499): the classes named class
+    /// expressions declare — by name, by file, the files holding them, and
+    /// the ids of them and their members. A class a CommonJS module exports
+    /// is left out: the module binds it, so it reads as a declaration does.
+    /// Read once — the node table it feeds is a run constant.
+    pub(super) fn class_expr_index(&self) -> Res<Option<Rc<ClassExprIndex>>> {
+        if let Some(v) = self.class_expr_index.get() {
+            return Ok(v.clone());
+        }
+        let mut by_name: HashMap<String, Vec<Arc<KNode>>> = HashMap::new();
+        let mut by_file: HashMap<String, Vec<Arc<KNode>>> = HashMap::new();
+        let mut by_key: HashMap<(String, String), Arc<KNode>> = HashMap::new();
+        let mut files = HashSet::new();
+        let mut hidden_ids = HashSet::new();
+        for n in self.nodes_by_kind("class")?.iter() {
+            if !is_js_class_expression(n) || self.class_expr_common_js_exported(n) {
+                continue;
+            }
+            by_name.entry(n.name.clone()).or_default().push(n.clone());
+            by_file.entry(n.file_path.clone()).or_default().push(n.clone());
+            by_key.insert((n.file_path.clone(), n.qualified_name.clone()), n.clone());
+            files.insert(n.file_path.clone());
+            hidden_ids.insert(n.id.clone());
+        }
+        // A member is its class's when it is declared in its file under its
+        // qualified name (`Widget::run` of `Widget`).
+        for file in &files {
+            for n in self.nodes_in_file_unfiltered(file)?.iter() {
+                if !matches!(n.kind.as_str(), "method" | "property" | "field") {
+                    continue;
+                }
+                if let Some(cut) = n.qualified_name.rfind("::") {
+                    if by_key.contains_key(&(n.file_path.clone(), n.qualified_name[..cut].to_string())) {
+                        hidden_ids.insert(n.id.clone());
+                    }
+                }
+            }
+        }
+        let v = (!by_name.is_empty()).then(|| Rc::new(ClassExprIndex { by_name, by_file, files, hidden_ids }));
+        Ok(self.class_expr_index.get_or_init(|| v).clone())
+    }
+
+    /// isCommonJsExportedClass — `module.exports = class Router {…}` and
+    /// `exports.Store = class Store {…}` are their module's value, which a
+    /// require hands to every importer: the class is not scoped.
+    fn class_expr_common_js_exported(&self, n: &KNode) -> bool {
+        let Some(file) = self.read_file_uncached(&n.file_path) else {
+            return false;
+        };
+        let prev = (n.start_line >= 2)
+            .then(|| file.line((n.start_line - 2) as usize))
+            .flatten()
+            .unwrap_or("");
+        let Some(line) = file.line((n.start_line - 1) as usize) else {
+            return false;
+        };
+        let before = format!(
+            "{prev}\n{}",
+            &line[..usize::try_from(n.start_column).unwrap_or(0).min(line.len())]
+        );
+        re!(r"(?:^|[^\w$.])(?:module\.)?exports(?:\.[A-Za-z_$][\w$]*)?\s*=\s*$").is_match(&before)
+    }
+
+    /// classExpressionFreeContextFor (#2499): a reference written outside
+    /// every named class expression resolves without the classes they
+    /// declare and their members — `new Widget()` elsewhere links nothing,
+    /// and a same-named class, function or binding keeps its links. Inside
+    /// one the whole graph applies, unless the name is another class
+    /// expression's, bound inside that one alone.
+    pub(super) fn class_expr_free_for(&self, r: &ResolveRefIn) -> Res<bool> {
+        if !CLASS_EXPR_LANGS.contains(&r.language.as_str()) {
+            return Ok(false);
+        }
+        let Some(idx) = self.class_expr_index()? else {
+            return Ok(false);
+        };
+        let first = r.reference_name.split('.').next().unwrap_or("");
+        let named = idx.by_name.get(first);
+        let inside = idx
+            .by_file
+            .get(&r.file_path)
+            .is_some_and(|ns| ns.iter().any(|n| written_in(n, r)));
+        Ok(!inside || named.is_some_and(|ns| !ns.iter().any(|n| written_in(n, r))))
+    }
+
+    /// classExpressionOnlyNames (#2499): the names only class expressions'
+    /// classes and members carry — they name nothing in the free view, so
+    /// the prefilter drops the references that would search for them.
+    fn class_expr_only_names(&self) -> Res<Rc<HashSet<String>>> {
+        if let Some(v) = self.class_expr_only.get() {
+            return Ok(v.clone());
+        }
+        let mut only = HashSet::new();
+        if let Some(idx) = self.class_expr_index()? {
+            let mut names = HashSet::new();
+            for id in &idx.hidden_ids {
+                if let Some(n) = self.node_by_id(id)? {
+                    names.insert(n.name.clone());
+                }
+            }
+            for name in names {
+                if self
+                    .nodes_by_name(&name)?
+                    .iter()
+                    .all(|n| idx.hidden_ids.contains(&n.id))
+                {
+                    only.insert(name);
+                }
+            }
+        }
+        Ok(self.class_expr_only.get_or_init(|| Rc::new(only)).clone())
+    }
+
+    /// queries.getNodesByKind — ORDER BY file_path, start_line. The
+    /// class-expression index's raw read: no resolution path iterates nodes
+    /// by kind, so the free view has nothing to hide through it.
+    pub(super) fn nodes_by_kind(&self, kind: &str) -> Res<NodeList> {
+        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Kind(kind))) {
             return r;
         }
         let t = self.table()?;
-        Ok(t.by_qname.get(qname).cloned().unwrap_or_else(|| t.empty.clone()))
+        Ok(Arc::new(t.nodes.iter().filter(|n| n.kind == kind).cloned().collect()))
     }
 
-    /// queries.getNodesInFile — ORDER BY start_line.
+    /// queries.getNodesInFile — ORDER BY start_line. In the
+    /// class-expression-free view the classes' files lose their hidden
+    /// nodes; the lookups an import reads a module's exports by
+    /// (`file_export_index`, `manual_mock_names`) stay whole.
     pub(super) fn nodes_in_file(&self, file_path: &str) -> Res<NodeList> {
+        let list = self.nodes_in_file_unfiltered(file_path)?;
+        if self.class_expr_free.get()
+            && self
+                .class_expr_index()?
+                .is_some_and(|idx| idx.files.contains(file_path))
+        {
+            return self.drop_class_expr_nodes(list);
+        }
+        Ok(list)
+    }
+
+    /// `nodes_in_file` before either resolution view filters it — what the
+    /// indexes and the export lookups read.
+    pub(super) fn nodes_in_file_unfiltered(&self, file_path: &str) -> Res<NodeList> {
         if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::File(file_path))) {
             return r;
         }
@@ -104,12 +354,18 @@ impl KernelResolver {
     }
 
     /// knownSymbols membership (`SELECT DISTINCT name FROM nodes`); false
-    /// once closed.
+    /// once closed. In the class-expression-free view a name only their
+    /// classes and members carry names nothing (classExpressionOnlyNames,
+    /// #2499).
     pub(super) fn known_name(&self, name: &str) -> bool {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
-            return r.is_ok_and(|list| !list.is_empty());
-        }
-        self.table().is_ok_and(|t| t.by_name.contains_key(name))
+        let known = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
+            r.is_ok_and(|list| !list.is_empty())
+        } else {
+            self.table().is_ok_and(|t| t.by_name.contains_key(name))
+        };
+        known
+            && !(self.class_expr_free.get()
+                && self.class_expr_only_names().is_ok_and(|o| o.contains(name)))
     }
 
     /// knownFiles membership (`SELECT path FROM files`); false once closed.
@@ -303,7 +559,7 @@ impl KernelResolver {
         if let Some(v) = self.export_index.get(file_path) {
             return Ok(v.clone());
         }
-        let nodes = self.nodes_in_file(file_path)?;
+        let nodes = self.nodes_in_file_unfiltered(file_path)?;
         let mut by_name: HashMap<String, Arc<KNode>> = HashMap::new();
         let mut default_component: Option<Arc<KNode>> = None;
         for n in nodes.iter() {
diff --git a/codegraph-kernel/src/resolve/receivers.rs b/codegraph-kernel/src/resolve/receivers.rs
index 28c053019a..9ce3043f87 100644
--- a/codegraph-kernel/src/resolve/receivers.rs
+++ b/codegraph-kernel/src/resolve/receivers.rs
@@ -267,6 +267,9 @@ impl KernelResolver {
         if php_property {
             return self.infer_php_assigned_property_type(&scan_receiver, &lines, call_idx);
         }
+        if site.language == "kotlin" {
+            return self.kotlin_local_call_result_type(&scan_receiver, site);
+        }
         Ok(None)
     }
 
@@ -903,7 +906,7 @@ fn go_bare_result(
         }
         if let Some(id) = binding.node_id.as_deref() {
             let Some(node) = self.node_by_id(id)? else { return Ok(None) };
-            return Ok(go_result_from_node(&node).map(|ty| (ty, node)));
+            return Ok(go_result_from_node(self, &node).map(|ty| (ty, node)));
         }
         return Ok(None);
     }
@@ -915,7 +918,7 @@ fn go_bare_result(
             && pos_dirname(&n.file_path) == dir)
         .cloned().collect();
     let [node] = nodes.as_slice() else { return Ok(None) };
-    Ok(go_result_from_node(node).map(|ty| (ty, node.clone())))
+    Ok(go_result_from_node(self, node).map(|ty| (ty, node.clone())))
 }
 
     /// cppClassExists — an aggregate type with this last `::` segment exists.
@@ -1088,7 +1091,7 @@ fn go_bare_result(
                 && pos_dirname(&n.file_path) == dir)
             .cloned().collect();
         let [callee] = nodes.as_slice() else { return Ok(None) };
-        let Some(raw) = go_result_from_node(callee) else { return Ok(None) };
+        let Some(raw) = go_result_from_node(self, callee) else { return Ok(None) };
         self.go_method_on_declared_type(&raw, &callee.file_path, method, r)
     }
 
@@ -1218,9 +1221,12 @@ pub(super) fn pick_closest_jvm_candidate(candidates: &[Arc<KNode>], from_path: &
     best.clone()
 }
 
-fn go_result_from_node(node: &KNode) -> Option<String> {
+fn go_result_from_node(resolver: &mut KernelResolver, node: &KNode) -> Option<String> {
     if node.kind == "function" {
-        return node.return_type.clone().filter(|ty| !ty.is_empty());
+        // The result a type parameter spells is its constraint: `V` of
+        // `F[V Validator]` carries Validator's methods, `T` of `F[T any]`
+        // none — go_call_result_at reads the declaration for it.
+        return resolver.go_call_result_at(node, 0);
     }
     if !matches!(node.kind.as_str(), "variable" | "constant") {
         return None;
diff --git a/codegraph-kernel/src/resolve/resolver_upstream.rs b/codegraph-kernel/src/resolve/resolver_upstream.rs
index 439cc470da..7c5e7e760b 100644
--- a/codegraph-kernel/src/resolve/resolver_upstream.rs
+++ b/codegraph-kernel/src/resolve/resolver_upstream.rs
@@ -574,13 +574,18 @@ impl KernelResolver {
         if r.language != "go" || r.reference_kind == "imports" {
             return Ok(None);
         }
-        if let Some((root, _)) = r.reference_name.split_once('.') {
-            if !re!(r"^[A-Za-z_]\w*$").is_match(root) || self.is_shadowed_import(root, r)? { return Ok(None); }
-            if !self.import_mappings(&r.file_path)?.iter().any(|m| m.local_name == root)
-                && self.nodes_by_name(root)?.iter().any(|n| n.language == "go"
-                    && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
-                    && pos_dirname(&n.file_path) == pos_dirname(&r.file_path)) { return Ok(None); }
-            return Ok(Some(root.to_string()));
+        if let Some((root, rest)) = r.reference_name.split_once('.') {
+            // The root qualifies the leaf only in a `pkg.Name` ref — in
+            // `pkg.Type[args].M` or `pkg.F().M` it qualifies the receiver,
+            // not the method.
+            if re!(r"^[A-Za-z_]\w*$").is_match(rest) {
+                if !re!(r"^[A-Za-z_]\w*$").is_match(root) || self.is_shadowed_import(root, r)? { return Ok(None); }
+                if !self.import_mappings(&r.file_path)?.iter().any(|m| m.local_name == root)
+                    && self.nodes_by_name(root)?.iter().any(|n| n.language == "go"
+                        && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
+                        && pos_dirname(&n.file_path) == pos_dirname(&r.file_path)) { return Ok(None); }
+                return Ok(Some(root.to_string()));
+            }
         }
         let name = r.reference_name.rsplit('.').next().unwrap_or(&r.reference_name);
         if !re!(r"^[A-Za-z_]\w*$").is_match(name) {
@@ -611,7 +616,7 @@ impl KernelResolver {
     }
 
     pub(super) fn go_ref_qualifier(&mut self, r: &ResolveRefIn) -> Res<Option<KImport>> {
-        let Some(root) = self.go_written_qualifier(r)? else { return Ok(None); };
+        let Some(root) = self.go_written_qualifier(r)? else { return Ok(None) };
         Ok(self.import_mappings(&r.file_path)?.iter().find(|imp| imp.local_name == root).cloned())
     }
 
diff --git a/codegraph-kernel/src/resolve/rust_impls.rs b/codegraph-kernel/src/resolve/rust_impls.rs
index 911dfb2727..5c1700915d 100644
--- a/codegraph-kernel/src/resolve/rust_impls.rs
+++ b/codegraph-kernel/src/resolve/rust_impls.rs
@@ -1,6 +1,8 @@
 //! Rust associated calls and foreign-type trait implementations (#2697, #2700).
 use super::*;
 use super::iteration::descendant_for_position;
+use super::rust_modules::rust_paths::rust_at;
+use self::rust_types::Written;
 
 const STD_TYPES: &[&str] = &[
     "String", "str", "Vec", "VecDeque", "HashMap", "HashSet", "BTreeMap", "BTreeSet",
@@ -17,6 +19,8 @@ pub(super) struct SelfContext {
     pub(super) trait_name: Option<String>,
     trait_args: Vec<String>,
     is_trait: bool,
+    /// The impl header's `type` field as written (`serde_json::Value`, `&'a mut T`).
+    self_text: String,
 }
 
 fn type_name(node: tree_sitter::Node, text: &str) -> Option<String> {
@@ -39,7 +43,7 @@ impl KernelResolver {
         loop {
             if at.kind() == "trait_item" {
                 return Some(SelfContext { owner: type_name(at.child_by_field_name("name")?, text)?,
-                    root: None, trait_name: None, trait_args: Vec::new(), is_trait: true });
+                    root: None, trait_name: None, trait_args: Vec::new(), is_trait: true, self_text: String::new() });
             }
             if at.kind() == "impl_item" {
                 let ty = at.child_by_field_name("type")?;
@@ -54,7 +58,8 @@ impl KernelResolver {
                         re!(r"[A-Za-z_]\w*").find_iter(&args).map(|m| m.as_str().to_string())
                             .filter(|s| s != "mut" && s != "dyn").collect()
                     }).unwrap_or_default();
-                return Some(SelfContext { owner: type_name(ty, text)?, root, trait_name, trait_args, is_trait: false });
+                return Some(SelfContext { owner: type_name(ty, text)?, root, trait_name, trait_args,
+                    is_trait: false, self_text: written.to_string() });
             }
             at = at.parent()?;
         }
@@ -118,6 +123,296 @@ impl KernelResolver {
         Ok(true)
     }
 
+    /// The `use` path a local name binds at `at` (`use serde_json::Value as J`
+    /// binds `J` to `serde_json::Value`), innermost binding first.
+    fn rust_use_path_at(&mut self, name: &str, file: &str, at: usize) -> Option<Vec<String>> {
+        self.rust_visible_uses(file, at)
+            .into_iter()
+            .find(|(local, _, _)| local == name)
+            .map(|(_, p, _)| p)
+    }
+
+    /// The crate dir a file belongs to: the longest crate dir prefixing it, or
+    /// the root crate's "".
+    fn rust_crate_dir_of(file: &str, graph: &super::rust_crates::RustCrateGraph) -> Option<String> {
+        let mut best = graph.crates.contains_key("").then(String::new);
+        for dir in graph.crates.keys() {
+            if !dir.is_empty()
+                && file.starts_with(&format!("{dir}/"))
+                && best.as_ref().is_none_or(|b| dir.len() > b.len())
+            {
+                best = Some(dir.clone());
+            }
+        }
+        best
+    }
+
+    /// Whether a Rust path's first segment names std, or a crate the manifests
+    /// depend on that the project doesn't hold. A path dependency the project
+    /// holds, a workspace member or not, is the project's.
+    fn is_rust_outside_crate(&mut self, root: &str, r: &ResolveRefIn) -> Res<bool> {
+        if matches!(root, "std" | "core" | "alloc" | "proc_macro") {
+            return Ok(true);
+        }
+        if matches!(root, "crate" | "self" | "super") {
+            return Ok(false);
+        }
+        let graph = self.rust_crate_graph()?;
+        if graph.crates.values().any(|c| c.name == root) {
+            return Ok(false);
+        }
+        let _ = self.rust_use_facts(&r.file_path);
+        let Some(deps) = &self.upstream_rust_deps else {
+            return Ok(false);
+        };
+        if !deps.contains(root) {
+            return Ok(false);
+        }
+        if let Some(own) = Self::rust_crate_dir_of(&r.file_path, &graph) {
+            if graph.crates.get(&own).is_some_and(|c| c.keys.contains_key(root)) {
+                return Ok(false);
+            }
+        }
+        Ok(true)
+    }
+
+    /// The name of the type a Rust path `path::type` names from std or a
+    /// dependency, where the file's `use`s or the path itself say it is from
+    /// there — `J` under `use serde_json::Value as J` is `Value` — or None:
+    /// one of the project's, or one nothing written says is from outside it.
+    fn rust_outside_path_type(
+        &mut self,
+        ty: &str,
+        path: &[&str],
+        r: &ResolveRefIn,
+    ) -> Res<Option<String>> {
+        let at = self
+            .rust_tree_for(&r.file_path)
+            .map(|(s, t)| rust_at(&t, s.text(), r.line, r.column).start_byte())
+            .unwrap_or(0);
+        let (root, real);
+        if path.is_empty() {
+            let Some(bound) = self.rust_use_path_at(ty, &r.file_path, at) else {
+                return Ok(None);
+            };
+            if bound.len() < 2 {
+                return Ok(None);
+            }
+            root = bound[0].clone();
+            real = bound.last().unwrap().clone();
+        } else {
+            root = self
+                .rust_use_path_at(path[0], &r.file_path, at)
+                .and_then(|p| p.first().cloned())
+                .unwrap_or_else(|| path[0].to_string());
+            real = ty.to_string();
+        }
+        Ok(self.is_rust_outside_crate(&root, r)?.then_some(real))
+    }
+
+    /// `(segments, name)` of a written Rust path (`serde_json::Value` →
+    /// `(["serde_json"], "Value")`), trailing generic arguments dropped.
+    fn rust_path_head(text: &str) -> Option<(Vec<String>, String)> {
+        let t = text.trim().trim_start_matches("::").trim();
+        let t = if let Some(open) = t.find('<') {
+            let mut depth = 0usize;
+            let mut end = None;
+            for (i, c) in t[open..].char_indices() {
+                match c {
+                    '<' => depth += 1,
+                    '>' => {
+                        depth = depth.checked_sub(1)?;
+                        if depth == 0 {
+                            end = Some(open + i);
+                            break;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            if end != Some(t.len() - 1) {
+                return None;
+            }
+            t[..open].trim().trim_end_matches("::").trim()
+        } else {
+            t
+        };
+        let parts: Vec<String> = t.split("::").map(|s| s.trim().to_string()).collect();
+        if !parts.iter().all(|p| re!(r"^[A-Za-z_]\w*$").is_match(p)) {
+            return None;
+        }
+        let name = parts.last().cloned()?;
+        Some((parts[..parts.len() - 1].to_vec(), name))
+    }
+
+    /// Whether the type a `Written` names is std's or a dependency's, as the
+    /// written path or the file's `use`s say — the `outside` arm of
+    /// `rustReadType` (#2614): a `std::fs::File` parameter's, a
+    /// `serde_json::Value` the `use` binds, or a `File` leaf the file pulls
+    /// from outside and nothing inside.
+    fn rust_written_outside(
+        &mut self,
+        w: &Written,
+        leaf: &str,
+        head: &str,
+    ) -> Res<bool> {
+        let mut segs: Vec<String> = head.split("::").map(|s| s.trim().to_string()).collect();
+        let single = segs.len() == 1;
+        let mut has_root = !single;
+        if !single {
+            if let Some(bound) = self.rust_use_path_at(&segs[0], &w.file, w.at) {
+                if !bound.is_empty() {
+                    segs.splice(0..1, bound);
+                }
+            }
+        } else if let Some(bound) = self.rust_use_path_at(leaf, &w.file, w.at) {
+            if bound.len() > 1 {
+                segs = bound[..bound.len() - 1].to_vec();
+                has_root = true;
+            }
+        }
+        if has_root {
+            if let Some(root) = segs.first().map(String::as_str) {
+                if matches!(root, "std" | "core" | "alloc") {
+                    return Ok(true);
+                }
+                if !matches!(root, "crate" | "self" | "super")
+                    && !self
+                        .rust_crate_graph()?
+                        .crates
+                        .values()
+                        .any(|c| c.name == root)
+                {
+                    let _ = self.rust_use_facts(&w.file);
+                    if self
+                        .upstream_rust_deps
+                        .as_ref()
+                        .is_some_and(|d| d.contains(root))
+                    {
+                        return Ok(true);
+                    }
+                }
+            }
+        }
+        if single {
+            let facts = self.rust_use_facts(&w.file).unwrap_or_default();
+            if facts.external.contains(leaf) && !facts.bound.contains(leaf) {
+                return Ok(true);
+            }
+            if STD_TYPES.contains(&leaf) {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
+    /// Whether a Rust call through a type's path can mean `target` (#2614). A
+    /// type the path names from std or a dependency — through the file's `use`
+    /// (`J::from(i)` under `use serde_json::Value as J`, `Value::default()`
+    /// under `use serde_json::Value`) or as written
+    /// (`serde_json::Value::default()`) — is that crate's own: the project
+    /// holds a function of it only as its own impl of a trait for it (`impl
+    /// Blank for serde_json::Value`, `impl From<Fail> for PathBuf`), and a call
+    /// through a trait's path (`W::flush(s)` under `use std::io::Write as W`)
+    /// reaches the project's impls of that trait. A same-named function of a
+    /// project type is another type's: the reporter's `J::from(i)` went to a
+    /// local `impl From<io::Error> for Fail`, a guess by the name alone, and
+    /// `Value::default()` to a project `Value` of its own.
+    pub(super) fn rust_path_call_reachable(&mut self, target: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        if target.language != "rust" {
+            return Ok(true);
+        }
+        let segments: Vec<&str> = r.reference_name.split("::").collect();
+        if segments.len() < 2
+            || !segments.iter().all(|s| re!(r"^[A-Za-z_]\w*$").is_match(s))
+        {
+            return Ok(true);
+        }
+        let ty = segments[segments.len() - 2];
+        if !ty.starts_with(|c: char| c.is_ascii_uppercase()) || ty == "Self" {
+            return Ok(true);
+        }
+        let Some(outside) =
+            self.rust_outside_path_type(ty, &segments[..segments.len() - 2], r)?
+        else {
+            return Ok(true);
+        };
+        if target.kind != "method" {
+            return Ok(false);
+        }
+        let mut site = r.clone().at(target);
+        site.column = target.start_column;
+        let Some(cx) = self.rust_self_context(&site) else {
+            return Ok(false);
+        };
+        if cx.is_trait {
+            return Ok(false);
+        }
+        if cx.trait_name.as_deref() == Some(outside.as_str()) {
+            return Ok(true);
+        }
+        if cx.owner != outside {
+            return Ok(false);
+        }
+        // The type the impl is for, as its own file names it: the outside one,
+        // not a project namesake.
+        let text = re!(r"^(?:&\s*(?:'\w+\s+)?(?:mut\s+)?)+")
+            .replace(&cx.self_text, "")
+            .to_string();
+        let Some((written, name)) = Self::rust_path_head(&text) else {
+            return Ok(false);
+        };
+        let at = self
+            .rust_impl_start(&target.file_path, target.start_line, target.start_column)
+            .unwrap_or(0);
+        let mut segs = written.clone();
+        let mut real = name.clone();
+        if segs.is_empty() {
+            if let Some(bound) = self.rust_use_path_at(&name, &target.file_path, at) {
+                if bound.len() > 1 {
+                    real = bound.last().cloned().unwrap_or(real);
+                    segs = bound[..bound.len() - 1].to_vec();
+                }
+            }
+        } else if let Some(head) = self.rust_use_path_at(&segs[0], &target.file_path, at) {
+            if !head.is_empty() {
+                segs.splice(0..1, head);
+            }
+        }
+        if let Some(root) = segs.first().map(String::as_str) {
+            if matches!(root, "std" | "core" | "alloc") {
+                return Ok(true);
+            }
+            if !matches!(root, "crate" | "self" | "super")
+                && !self
+                    .rust_crate_graph()?
+                    .crates
+                    .values()
+                    .any(|c| c.name == root)
+            {
+                let _ = self.rust_use_facts(&target.file_path);
+                if self
+                    .upstream_rust_deps
+                    .as_ref()
+                    .is_some_and(|deps| deps.contains(root))
+                {
+                    return Ok(true);
+                }
+            }
+        }
+        if !self.rust_project_named(&real)? {
+            return Ok(true);
+        }
+        Ok(!self
+            .rust_type_decls(&Written {
+                text: text.clone(),
+                file: target.file_path.clone(),
+                at,
+            })?
+            .iter()
+            .any(|n| matches!(n.kind.as_str(), "struct" | "enum" | "union")))
+    }
+
     fn rust_outside_self(&mut self, cx: &SelfContext, r: &ResolveRefIn) -> Res<bool> {
         let facts = self.rust_use_facts(&r.file_path).unwrap_or_default();
         if let Some(root) = &cx.root {
diff --git a/codegraph-kernel/src/resolve/rust_types.rs b/codegraph-kernel/src/resolve/rust_types.rs
index 0a811164d3..75537086d4 100644
--- a/codegraph-kernel/src/resolve/rust_types.rs
+++ b/codegraph-kernel/src/resolve/rust_types.rs
@@ -3,10 +3,10 @@ use super::super::rust_modules::rust_paths::*;
 use super::super::*;
 
 #[derive(Clone, Debug)]
-struct Written {
-    text: String,
-    file: String,
-    at: usize,
+pub(super) struct Written {
+    pub(super) text: String,
+    pub(super) file: String,
+    pub(super) at: usize,
 }
 impl Written {
     fn with(&self, text: impl Into<String>) -> Self {
@@ -218,7 +218,7 @@ impl KernelResolver {
             cursor = cursor.parent()?;
         }
     }
-    fn rust_type_decls(&mut self, w: &Written) -> Res<Vec<Arc<KNode>>> {
+    pub(super) fn rust_type_decls(&mut self, w: &Written) -> Res<Vec<Arc<KNode>>> {
         let (head, _, _) = type_head(&w.text);
         let leaf = head.rsplit("::").next().unwrap_or(&head);
         let mut path: Vec<String> = head.split("::").map(str::to_string).collect();
@@ -855,6 +855,25 @@ impl KernelResolver {
                     }
                 }
                 if path.len() == 1 {
+                    let last = path[0].as_str();
+                    // A tuple struct (`Wrapper(x)`) or a `Some`/`Ok`/`Err`
+                    // variant makes a value of its own type; a SCREAMING name
+                    // is a const's call on nothing the index types.
+                    if last.starts_with(|c: char| c.is_ascii_uppercase()) {
+                        if last.len() > 1
+                            && last.chars().all(|c| {
+                                c.is_ascii_uppercase() || c.is_ascii_digit() || c == '_'
+                            })
+                        {
+                            return Ok(None);
+                        }
+                        let ty = match last {
+                            "Some" => "Option<_>",
+                            "Ok" | "Err" => "Result<_, _>",
+                            _ => last,
+                        };
+                        return Ok(Some(written(ty.to_string())));
+                    }
                     let mut scope = n;
                     loop {
                         let local = rust_children(scope).into_iter().find(|item|
@@ -1213,7 +1232,7 @@ impl KernelResolver {
             },
         }))
     }
-    fn rust_project_named(&mut self, name: &str) -> Res<bool> {
+    pub(super) fn rust_project_named(&mut self, name: &str) -> Res<bool> {
         Ok(self.nodes_by_name(name)?.iter().any(|n| {
             n.language == "rust"
                 && matches!(
@@ -1674,7 +1693,7 @@ impl KernelResolver {
             None
         })
     }
-    fn rust_impl_start(&mut self, file: &str, line: i64, col: i64) -> Option<usize> {
+    pub(super) fn rust_impl_start(&mut self, file: &str, line: i64, col: i64) -> Option<usize> {
         let (s, t) = self.rust_tree_for(file)?;
         rust_ancestor(
             rust_at(&t, s.text(), line, col),
@@ -1729,6 +1748,7 @@ impl KernelResolver {
         // chain arm types each link's return by name instead.
         if call_chain_re().is_match(&r.reference_name) {
             if let Some(hit) = self.match_call_chain(r)? {
+                self.mark_rust_typed(r);
                 return Ok(Some(Some(hit)));
             }
         }
@@ -1793,7 +1813,10 @@ impl KernelResolver {
                 }
                 if base.kind() == "call_expression" && base.child_by_field_name("function")
                     .is_some_and(|f| matches!(f.kind(), "scoped_identifier" | "generic_function")) {
-                    if let Some(hit) = self.match_call_chain(r)? { return Ok(Some(Some(hit))); }
+                    if let Some(hit) = self.match_call_chain(r)? {
+                        self.mark_rust_typed(r);
+                        return Ok(Some(Some(hit)));
+                    }
                 }
                 return Ok(Some(None));
             }
@@ -1865,11 +1888,150 @@ impl KernelResolver {
                 return Ok(None);
             }
         }
-        let node = self.rust_method_on(&written, &method, r, 0)?;
+        // A field chain or struct literal receiver — `vis.map.get("a")`,
+        // `Xyz { x: 1.0 }.to_val()` — whose type the receiver is written with
+        // says what the call reaches (matchRustWrittenReceiverCall). A type no
+        // declaration the index holds names — one a macro declares, like
+        // tokio's `type AtomicUnsignedShort = …` inside `cfg_has_atomic_u64!`
+        // — says nothing of it, unless a wrapper around it has the method
+        // itself (`Arc::clone`): the name strategies decide.
+        let leaf = head.rsplit("::").next().unwrap_or(&head);
+        if function.kind() == "field_expression" {
+            // `read.kind === 'named'`: a plain type path — not `Self`, a
+            // `&[T]`, a generic parameter's bound (`R: AsyncRead`), or a type
+            // std or a dependency owns (rust_written_outside).
+            let named = leaf != "Self"
+                && re!(r"^[A-Za-z_]\w*(?:::\s*[A-Za-z_]\w*)*$").is_match(&head)
+                && self
+                    .rust_generic_traits(leaf, &written.file, written.at)
+                    .is_none()
+                && !self.rust_written_outside(&written, leaf, &head)?;
+            if named
+                && !own_wrapper_method(&type_head(&written.text).0, &method)
+                && !self.rust_project_named(leaf)?
+                && self.rust_type_decls(&written)?.is_empty()
+                && self.rust_methods_named(leaf, &method)?.is_empty()
+            {
+                return Ok(None);
+            }
+        }
+        let node = match self.rust_method_on(&written, &method, r, 0)? {
+            Some(node) => Some(node),
+            // A provided method of a project trait the type derives counts
+            // (axum-extra's #[derive(TypedPath)]).
+            None if function.kind() == "field_expression" => {
+                self.rust_derived_trait_method(&written, &method, r)?
+            }
+            None => None,
+        };
+        if node.is_some() {
+            self.mark_rust_typed(r);
+        }
         Ok(Some(node.map(|node| KCand {
             node,
             confidence: 0.9,
             resolved_by: if function.kind() == "field_expression" { "instance-method" } else { "qualified-name" },
         })))
     }
+
+    /// The names a Rust type's `#[derive(…)]` attributes write, each by its
+    /// path's last segment.
+    fn rust_derived_names(&mut self, decl: &KNode) -> Res<Vec<String>> {
+        let Some((source, tree)) = self.rust_tree_for(&decl.file_path) else {
+            return Ok(Vec::new());
+        };
+        let text = source.text();
+        let Some(node) = self.rust_declaration_node(
+            decl,
+            &tree,
+            text,
+            &["struct_item", "enum_item", "union_item"],
+        ) else {
+            return Ok(Vec::new());
+        };
+        let mut names = Vec::new();
+        let mut attr = node.prev_named_sibling();
+        while let Some(a) = attr {
+            if a.kind() != "attribute_item" {
+                break;
+            }
+            for m in re!(r"\bderive\s*\(([^()]*)\)").captures_iter(rust_text(a, text)) {
+                for part in m[1].split(',') {
+                    if let Some(name) = part
+                        .trim()
+                        .rsplit("::")
+                        .next()
+                        .map(str::trim)
+                        .filter(|s| re!(r"^[A-Za-z_]\w*$").is_match(s))
+                    {
+                        names.push(name.to_string());
+                    }
+                }
+            }
+            attr = a.prev_named_sibling();
+        }
+        Ok(names)
+    }
+
+    /// Whether a Rust method's declaration writes a body — a provided trait
+    /// method is a `function_item`; a required one a `function_signature_item`.
+    fn rust_has_body(&mut self, m: &KNode) -> bool {
+        let Some((source, tree)) = self.rust_tree_for(&m.file_path) else {
+            return false;
+        };
+        self.rust_declaration_node(m, &tree, source.text(), &["function_item"])
+            .is_some()
+    }
+
+    /// The method a Rust project trait that a type derives provides, for a
+    /// call on a value of the type: `#[derive(TypedPath)] struct UsersShow {…}`
+    /// reaches axum-extra's `TypedPath::with_query_params` through the impl
+    /// the derive writes, which the index doesn't hold. None unless exactly
+    /// one derived trait in scope at the call declares the method with a body.
+    fn rust_derived_trait_method(
+        &mut self,
+        w: &Written,
+        method: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let decls = self.rust_type_decls(w)?;
+        let types: Vec<_> = decls
+            .into_iter()
+            .filter(|n| matches!(n.kind.as_str(), "struct" | "enum" | "union"))
+            .collect();
+        if types.len() != 1 {
+            return Ok(None);
+        }
+        let mut found: Vec<Arc<KNode>> = Vec::new();
+        for name in self.rust_derived_names(&types[0])? {
+            let traits: Vec<_> = self
+                .nodes_by_name(&name)?
+                .iter()
+                .filter(|n| n.kind == "trait" && n.language == "rust" && n.name == name)
+                .cloned()
+                .collect();
+            if traits.is_empty() {
+                continue;
+            }
+            for m in self.rust_trait_methods(w, &[name], method, 0)? {
+                let Some(trait_node) = self.rust_trait_of(&m)? else {
+                    continue;
+                };
+                if self.rust_has_body(&m)
+                    && self.rust_trait_in_scope(&trait_node.name, r, &m)?
+                {
+                    found.push(m);
+                }
+            }
+        }
+        found.sort_by(|a, b| a.id.cmp(&b.id));
+        found.dedup_by(|a, b| a.id == b.id);
+        let mut owners = HashSet::new();
+        for m in &found {
+            if let Some(t) = self.rust_trait_of(m)? {
+                owners.insert(t.id.clone());
+            }
+        }
+        Ok((owners.len() == 1).then(|| found.first().cloned()).flatten())
+    }
 }
diff --git a/codegraph-kernel/src/resolve/tables.rs b/codegraph-kernel/src/resolve/tables.rs
index e34a7ce77f..a2c57238f3 100644
--- a/codegraph-kernel/src/resolve/tables.rs
+++ b/codegraph-kernel/src/resolve/tables.rs
@@ -696,9 +696,10 @@ pub(super) fn is_importable_kind(kind: &str) -> bool {
     !matches!(kind, "property" | "field" | "method" | "enum_member" | "parameter")
 }
 
-/// PRIVATE_IS_FILE_LOCAL (name-matcher.ts).
+/// PRIVATE_IS_FILE_LOCAL (name-matcher.ts). A Dart `_name` is its library's,
+/// which can span several files: see is_visible_across_files (f7820b58).
 pub(super) fn private_is_file_local(lang: &str) -> bool {
-    matches!(lang, "kotlin" | "java" | "csharp" | "swift" | "scala" | "dart" | "php")
+    matches!(lang, "kotlin" | "java" | "csharp" | "swift" | "scala" | "php")
 }
 
 /// NO_NESTED_FUNCTIONS (name-matcher.ts).
@@ -1009,6 +1010,34 @@ pub(super) static PYTHON_BUILT_IN_METHODS: LazyLock<HashSet<&'static str>> = Laz
     .collect()
 });
 
+/// PYTHON_BUILT_IN_TYPES (index.ts isPythonBuiltinNamedMethodCall): receiver
+/// spellings that ARE the builtin type — `dict.get` is the dict's own method,
+/// never a project class's.
+pub(super) static PYTHON_BUILT_IN_TYPES: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
+    [
+        "list", "dict", "set", "tuple", "str", "int", "float", "bool",
+        "bytes", "bytearray", "frozenset", "object", "super",
+    ]
+    .into_iter()
+    .collect()
+});
+
+/// PYTHON_RUNTIME_TYPES (name-matcher.ts pythonAnnotationEvidence /
+/// pythonValueEvidence): annotation or `Ctor()` names that produce a runtime
+/// container, not a project class.
+pub(super) static PYTHON_RUNTIME_TYPES: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
+    [
+        "list", "dict", "set", "frozenset", "tuple", "str", "bytes", "bytearray",
+        "int", "float", "complex", "bool", "object", "type", "range", "slice",
+        "List", "Dict", "Set", "FrozenSet", "Tuple", "Sequence", "Mapping",
+        "MutableMapping", "MutableSequence", "Iterable", "Iterator", "Callable",
+        "deque", "defaultdict", "OrderedDict", "Counter",
+        "collections.deque", "collections.defaultdict", "collections.OrderedDict", "collections.Counter",
+    ]
+    .into_iter()
+    .collect()
+});
+
 // GO_STDLIB_PACKAGES (index.ts isBuiltInOrExternal `pkg.member` arm) — live
 // for non-bare names (`pkg.Member` where pkg is a stdlib import).
 pub(super) static GO_STDLIB_PACKAGES: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
@@ -1204,6 +1233,12 @@ pub(super) fn is_test_path(path: &str) -> bool {
         || re!(r"(?:^|/)(?:unittests|[\w.]+[-_]unittests?)/").is_match(&lower)
 }
 
+/// isManualMockPath (query-utils.ts #2455): a Jest or Vitest manual mock —
+/// a file under a `__mocks__/` directory.
+pub(super) fn is_manual_mock_path(path: &str) -> bool {
+    re!(r"(?:^|/)__mocks__/").is_match(&path.replace('\\', "/").to_lowercase())
+}
+
 #[cfg(test)]
 mod tests {
     use super::{collect_rust_use_bindings, is_test_path};
diff --git a/codegraph-kernel/src/resolve/ts_known.rs b/codegraph-kernel/src/resolve/ts_known.rs
index ec673841f2..68488c0b84 100644
--- a/codegraph-kernel/src/resolve/ts_known.rs
+++ b/codegraph-kernel/src/resolve/ts_known.rs
@@ -22,6 +22,9 @@ fn is_member_owner_kind(kind: &str) -> bool {
     matches!(kind, "class" | "interface")
 }
 
+/// Lines of a class header the type-parameter reader looks through: decorators, then `class C<…>` over several lines.
+const TS_CLASS_HEAD_LINES: usize = 24;
+
 impl KernelResolver {
     /// tsTypeDeclaredIn: the class or interface named `name` that `file` declares.
     pub(super) fn ts_type_declared_in(&mut self, file: &str, name: &str) -> Res<Option<Arc<KNode>>> {
@@ -397,16 +400,21 @@ impl KernelResolver {
         Ok(None)
     }
 
-    /// Is `name` one of the type parameters the head of the TS class or
-    /// interface `cls` declares (`class Emitter<T>`)?
-    fn ts_class_type_parameter(&mut self, cls: &KNode, name: &str) -> bool {
+    /// Is `name` one of the type parameters the head of the TS class,
+    /// interface or type alias `cls` declares (`class Emitter<T>`,
+    /// `type State<T> = …`)? The list is read from the `class` / `interface` /
+    /// `type` keyword to its own `>`, over several lines and through
+    /// constraints and defaults that hold braces (`<T extends { id: string }>`).
+    /// A list whose `>` is not found reads as declaring `name`: a caller drops
+    /// the type rather than take a parameter for a project class.
+    pub(super) fn ts_class_type_parameter(&mut self, cls: &KNode, name: &str) -> bool {
         let Some(source) = self.read_file(&cls.file_path) else { return false };
         let from = (cls.start_line - 1).max(0) as usize;
-        let head = source.get(from..(from + 3).min(source.len())).unwrap_or_default().join(" ");
+        let head = source.get(from..(from + TS_CLASS_HEAD_LINES).min(source.len())).unwrap_or_default().join("\n");
         // No `{`-cut: `class Shaped<Item extends { id: string }>` carries a
         // brace inside its parameter list; the `>` scan below is depth-aware.
         let head = head.as_str();
-        let Ok(open) = Self::cached_regex(&format!(r"(?-u:\b){}\s*<", regex::escape(&cls.name))) else { return false };
+        let Ok(open) = Self::cached_regex(&format!(r"(?-u:\b)(?:class|interface|type)\s+{}\s*<", regex::escape(&cls.name))) else { return false };
         let Some(open) = open.find(head) else { return false };
         // The parameters between the `<` after the name and its own `>`, split
         // at their top level: `T`, `K extends keyof T = never`.
@@ -437,7 +445,7 @@ impl KernelResolver {
                 _ => {}
             }
         }
-        false
+        true
     }
 }
 
@@ -1248,12 +1256,23 @@ impl KernelResolver {
                 }
                 let hit = self.resolve_via_import(&r.clone().naming(&written, "references"))?;
                 if hit.as_ref().is_some_and(|hit| hit.node.language == "arkts") { return Ok(Some(hit)); }
-                if let (Some(hit), Some(file)) = (&hit, self.resolve_import_path(&binding.source, &r.file_path, &r.language)?) {
-                    if !self.ts_import_target_visible(&hit.node, &file, r)? { return Ok(Some(None)); }
+                let file = self.resolve_import_path(&binding.source, &r.file_path, &r.language)?;
+                if let (Some(hit), Some(file)) = (&hit, &file) {
+                    if !self.ts_import_target_visible(&hit.node, file, r)? { return Ok(Some(None)); }
+                }
+                if hit.is_none() {
+                    // importedTypeMember (import-resolver.ts): a specifier the
+                    // import resolver can't follow — not to a file, not to a
+                    // `declare module` block — that a manifest declares outside
+                    // the repository is terminal (`null`); every other miss
+                    // keeps the ordinary strategies (`undefined`), including a
+                    // resolved package directory whose exports can't be read.
+                    let outside = file.is_none()
+                        && self.ts_ambient_lookup(&binding.source, "*", false, r)?.is_none()
+                        && self.is_out_of_repo_import(&binding.source, &r.file_path, &r.language)?;
+                    if outside { return Ok(Some(None)); }
+                    return Ok(None);
                 }
-                if hit.is_none() && self.resolve_import_path(&binding.source, &r.file_path, &r.language)?.is_some()
-                    && (binding.is_namespace || member.is_some() || binding.exported_name == binding.local_name) { return Ok(Some(None)); }
-                if hit.is_none() && !self.is_declared_outside_package(&binding.source, &r.file_path) { return Ok(None); }
                 return Ok(Some(hit));
             }
             if imported { return Ok(None); }
diff --git a/codegraph-kernel/src/resolve/vbnet/calls.rs b/codegraph-kernel/src/resolve/vbnet/calls.rs
index 6ba4a87c72..d9ecb914d7 100644
--- a/codegraph-kernel/src/resolve/vbnet/calls.rs
+++ b/codegraph-kernel/src/resolve/vbnet/calls.rs
@@ -5,13 +5,23 @@ struct VbReceiver {
     typed: Option<VbType>,
     through_type: bool,
     color_color: bool,
+    namespace: Option<Rc<Vec<String>>>,
+}
+
+impl VbReceiver {
+    fn owned(owners: Vec<Arc<KNode>>, typed: Option<VbType>, through_type: bool, color_color: bool) -> Self {
+        VbReceiver { owners, typed, through_type, color_color, namespace: None }
+    }
+    fn ns(namespace: Rc<Vec<String>>) -> Self {
+        VbReceiver { owners: vec![], typed: None, through_type: false, color_color: false, namespace: Some(namespace) }
+    }
 }
 
 
 impl KernelResolver {
     fn vb_value_receiver(&mut self, typed: Option<VbType>) -> Res<Option<VbReceiver>> {
         let Some(t) = typed.filter(|t| vb_key(t) != "object") else { return Ok(None); };
-        Ok(self.vb_owners(&t)?.map(|owners| VbReceiver { owners, typed: Some(t), through_type: false, color_color: false }))
+        Ok(self.vb_owners(&t)?.map(|owners| VbReceiver::owned(owners, Some(t), false, false)))
     }
     fn vb_path_receiver(&mut self, head: &str, links: &[&str], r: &ResolveRefIn) -> Res<Option<VbReceiver>> {
         let mut at = if head.starts_with('{') {
@@ -25,50 +35,229 @@ impl KernelResolver {
                     let base = self.vb_supers(&own)?.into_iter().find(|(_, implemented)| !implemented).map(|(t, _)| t);
                     self.vb_value_receiver(base)?
                 }
-                Some(own) => Some(VbReceiver { typed: Some(vb_simple(&own.name, r)), owners: vec![own], through_type: false, color_color: false }),
+                Some(own) => Some(VbReceiver::owned(vec![own.clone()], Some(vb_simple(&own.name, r)), false, false)),
                 None => None,
             }
         } else {
             let name = head.trim_matches(['[', ']']);
             let bound = self.vb_receiver_type(name, r, 0)?;
             let written = match &bound { None => Some(vb_simple(name, r)), Some(Some(t)) if !t.array && t.name.eq_ignore_ascii_case(name) => Some(t.clone()), _ => None };
-            if let Some(written) = written {
-                let (owners, ambiguous) = self.vb_types_at(&written, true)?;
-                (!ambiguous && !owners.is_empty()).then_some(VbReceiver { owners, typed: None, through_type: true, color_color: bound.is_some() })
-            } else { self.vb_value_receiver(bound.flatten())? }
+            match written {
+                Some(written) => {
+                    let (owners, ambiguous) = self.vb_types_at(&written, true)?;
+                    if ambiguous {
+                        None
+                    } else if !owners.is_empty() {
+                        Some(VbReceiver::owned(owners, None, true, bound.is_some()))
+                    } else {
+                        match bound.is_none() {
+                            true => self.vb_namespace_named(name, r)?.map(VbReceiver::ns),
+                            false => None,
+                        }
+                    }
+                }
+                None => self.vb_value_receiver(bound.flatten())?,
+            }
         };
         for link in links {
             let Some(prior) = at else { return Ok(None); };
             let name = link.trim_matches(['[', ']']);
+            if let Some(ns) = prior.namespace {
+                let types = self.vb_types_in_namespace(&ns, name, r)?;
+                at = match types {
+                    None => return Ok(None),
+                    Some(types) if !types.is_empty() => Some(VbReceiver::owned(types, None, true, false)),
+                    Some(_) => {
+                        let mut nested = (*ns).clone();
+                        nested.push(name.to_ascii_lowercase());
+                        if self.vb_known_namespaces()?.contains(&nested.join(".")) {
+                            Some(VbReceiver::ns(Rc::new(nested)))
+                        } else {
+                            let member = self.vb_module_member_in(&ns, name, r)?;
+                            let Some(member) = member else { return Ok(None); };
+                            let typed = self.vb_member_type(&VbMember { node: member, args: HashMap::new() })?;
+                            self.vb_value_receiver(typed)?
+                        }
+                    }
+                };
+                continue;
+            }
+            if prior.owners.is_empty() { return Ok(None); }
             let found = self.vb_member_on(&prior.owners, name, r, true, prior.typed.as_ref(), true)?
                 .or(self.vb_member_on(&prior.owners, &format!("[{name}]"), r, true, prior.typed.as_ref(), true)?);
             let Some(found) = found else { return Ok(None); };
             at = if vb_like_kind(&found.node.kind) {
-                prior.through_type.then_some(VbReceiver { owners: vec![found.node], typed: None, through_type: true, color_color: false })
+                prior.through_type.then_some(VbReceiver::owned(vec![found.node], None, true, false))
             } else { let typed = self.vb_member_type(&found)?; self.vb_value_receiver(typed)? };
         }
         Ok(at)
     }
+    /// The overload VB.NET runs where a method is named without parentheses,
+    /// unless `AddressOf`/`NameOf` only names it.
+    fn vb_run(&mut self, member: Arc<KNode>, named: bool, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if member.kind != "method" || named {
+            return Ok(Some(member));
+        }
+        self.vb_runnable_overload(member, r)
+    }
+    /// The field, property or Module variable a bare name before the dot
+    /// reads as well, where VB.NET binds the name to one (`Button1` in
+    /// `Button1.Text`). Null for a parameter or local of that name, for `Me`,
+    /// `MyBase` and `{T}`, for a `With` block's name, and for an outside
+    /// namesake (`Responser As Responser`).
+    fn vb_head_member(&mut self, head: &str, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if head.starts_with('{') || re!(r"(?i)^(Me|MyClass|MyBase)$").is_match(head) {
+            return Ok(None);
+        }
+        let name = head.trim_matches(['[', ']']);
+        let Some(line) = self.read_file(&r.file_path).and_then(|f| f.get((r.line - 1).max(0) as usize).cloned()) else {
+            return Ok(None);
+        };
+        let mut byte = super::names::js_unit_to_byte(&line, r.column.max(0) as usize).min(line.len());
+        let bracketed = line.as_bytes().get(byte) == Some(&b'[');
+        if bracketed {
+            byte += 1;
+        }
+        if line.len() < byte + name.len() || !line[byte..byte + name.len()].eq_ignore_ascii_case(name) {
+            return Ok(None);
+        }
+        byte += name.len();
+        if bracketed {
+            if line.as_bytes().get(byte) != Some(&b']') {
+                return Ok(None);
+            }
+            byte += 1;
+        }
+        while matches!(line.as_bytes().get(byte), Some(b' ' | b'\t')) {
+            byte += 1;
+        }
+        if line.as_bytes().get(byte) != Some(&b'.') {
+            return Ok(None);
+        }
+        if self.vb_local_bound(name, r)? {
+            return Ok(None);
+        }
+        let Some(found) = self.vb_member_around(name, r)? else {
+            return Ok(None);
+        };
+        let member = found.node;
+        if !vb_value_kind(&member.kind) || member.id == r.from_node_id {
+            return Ok(None);
+        }
+        // Another project's Module is one this code can't name without a reference to it.
+        let foreign = self.vb_project(&member.file_path) != self.vb_project(&r.file_path);
+        if foreign {
+            if let Some(qn) = vb_parent_qn(&member) {
+                let module = self
+                    .nodes_by_qualified_name(qn)?
+                    .iter()
+                    .any(|n| self.vb_module(n));
+                if module {
+                    return Ok(None);
+                }
+            }
+        }
+        if self.vb_is_outside_namesake(&member, &found.args)? {
+            return Ok(None);
+        }
+        Ok(Some(member))
+    }
+    /// withHead: the bare-name member before the dot is linked beside what is
+    /// read through it — alone when nothing reads through it, and never when
+    /// the read calls the member.
+    fn vb_with_head(&mut self, read: Option<VbHit>, head: &str, links: &[&str], r: &ResolveRefIn) -> Res<Option<VbHit>> {
+        let head_member = if links.is_empty() {
+            self.vb_head_member(head, r)?
+        } else {
+            None
+        };
+        Ok(match (head_member, read) {
+            (None, read) => read,
+            (Some(head), None) => Some(VbHit {
+                candidate: KCand { node: head, confidence: 0.9, resolved_by: "instance-method" },
+                edge_kind: None,
+                also: vec![],
+            }),
+            (Some(head), Some(mut read)) => {
+                if read.edge_kind.as_deref() != Some("calls") {
+                    read.also.push(head.id.clone());
+                }
+                Some(read)
+            }
+        })
+    }
     fn vb_member_read(&mut self, head: &str, links: &[&str], name: &str, r: &ResolveRefIn) -> Res<Option<VbHit>> {
         let Some(at) = self.vb_path_receiver(head, links, r)? else { return Ok(None); };
         let name = name.trim_matches(['[', ']']);
-        let found = self.vb_member_on(&at.owners, name, r, true, at.typed.as_ref(), true)?
-            .or(self.vb_member_on(&at.owners, &format!("[{name}]"), r, true, at.typed.as_ref(), true)?);
+        let line = self.read_file(&r.file_path).and_then(|f| f.get((r.line - 1).max(0) as usize).cloned()).unwrap_or_default();
+        let named = re!(r"(?i)\b(?:AddressOf\s+|NameOf\s*\(\s*)$").is_match(super::names::js_prefix(&line, r.column.max(0) as usize));
+        if let Some(ns) = &at.namespace {
+            // A type, or a Module's member, read through its namespace.
+            let types = self.vb_types_in_namespace(ns, name, r)?;
+            let target = match types {
+                Some(types) => match types.into_iter().next() {
+                    Some(first) => Some(first),
+                    None => match self.vb_module_member_in(ns, name, r)? {
+                        Some(member) => self.vb_run(member, named, r)?,
+                        None => None,
+                    },
+                },
+                None => None,
+            };
+            let Some(target) = target.filter(|t| t.id != r.from_node_id) else {
+                return Ok(None);
+            };
+            return Ok(Some(VbHit {
+                candidate: KCand {
+                    node: target.clone(),
+                    confidence: if target.kind == "method" { 0.85 } else { 0.9 },
+                    resolved_by: "qualified-name",
+                },
+                edge_kind: (target.kind == "method" && !named).then(|| "calls".to_string()),
+                also: vec![],
+            }));
+        }
+        if at.owners.is_empty() {
+            return self.vb_with_head(None, head, links, r);
+        }
+        if !at.through_type {
+            // The member the name means: the nearest the type declares or inherits.
+            let found = self.vb_member_on(&at.owners, name, r, true, at.typed.as_ref(), false)?
+                .or(self.vb_member_on(&at.owners, &format!("[{name}]"), r, true, at.typed.as_ref(), false)?);
+            let member = match found {
+                Some(found) => self.vb_run(found.node, named, r)?,
+                None => None,
+            };
+            let hit = member.filter(|m| m.id != r.from_node_id).map(|member| {
+                VbHit {
+                    candidate: KCand { node: member.clone(), confidence: 0.9, resolved_by: "instance-method" },
+                    edge_kind: (member.kind == "method" && !named).then(|| "calls".to_string()),
+                    also: vec![],
+                }
+            });
+            return self.vb_with_head(hit, head, links, r);
+        }
+        let found = self.vb_member_on(&at.owners, name, r, true, None, true)?
+            .or(self.vb_member_on(&at.owners, &format!("[{name}]"), r, true, None, true)?);
         let Some(mut found) = found else { return Ok(None); };
-        if found.node.id == r.from_node_id { return Ok(None); }
-        if !at.through_type && !matches!(found.node.kind.as_str(), "method" | "field" | "property" | "constant" | "variable") { return Ok(None); }
-        if at.through_type && !found.node.is_static {
+        if !found.node.is_static {
             if let Some(shared) = self.nodes_by_qualified_name(&found.node.qualified_name)?.iter().find(|n| n.is_static && n.file_path == found.node.file_path && n.id != r.from_node_id) { found.node = shared.clone(); }
         }
+        found.node = self.vb_run(found.node.clone(), named, r)?.unwrap_or(found.node);
         let constant = self.read_file(&found.node.file_path).and_then(|f| f.get((found.node.start_line - 1).max(0) as usize).cloned())
             .is_some_and(|line| re!(r"(?i)^\s*(?:(?:Public|Private|Protected|Friend|Shadows)\s+)*Const\b").is_match(&line));
         let shared = found.node.is_static || constant || matches!(found.node.kind.as_str(), "constant" | "enum_member") || at.owners.iter().any(|n| self.vb_module(n));
-        let through_value = !at.through_type || at.color_color && !shared;
-        let line = self.read_file(&r.file_path).and_then(|f| f.get((r.line - 1).max(0) as usize).cloned()).unwrap_or_default();
-        let named = re!(r"(?i)\b(?:AddressOf\s+|NameOf\s*\(\s*)$").is_match(super::names::js_prefix(&line, r.column.max(0) as usize));
+        if at.color_color && !shared {
+            return self.vb_with_head(Some(VbHit {
+                candidate: KCand { node: found.node.clone(), confidence: 0.9, resolved_by: "instance-method" },
+                edge_kind: (found.node.kind == "method" && !named).then(|| "calls".to_string()),
+                also: vec![],
+            }), head, links, r);
+        }
         let edge_kind = (found.node.kind == "method" && !named).then(|| "calls".to_string());
-        if through_value || found.node.kind == "method" || !links.is_empty() {
-            return Ok(Some(VbHit { candidate: KCand { node: found.node, confidence: if through_value { 0.9 } else { 0.85 }, resolved_by: if through_value { "instance-method" } else { "qualified-name" } }, edge_kind, also: vec![] }));
+        if found.node.kind == "method" || !links.is_empty() {
+            let confidence = if found.node.kind == "method" { 0.85 } else { 0.9 };
+            return Ok(Some(VbHit { candidate: KCand { node: found.node, confidence, resolved_by: "qualified-name" }, edge_kind, also: vec![] }));
         }
         self.vb_read_through(found.node, &at.owners, r, 0.9, edge_kind.as_deref())
     }
diff --git a/codegraph-kernel/src/resolve/vbnet/receivers.rs b/codegraph-kernel/src/resolve/vbnet/receivers.rs
index 6a453118c8..0669df11f6 100644
--- a/codegraph-kernel/src/resolve/vbnet/receivers.rs
+++ b/codegraph-kernel/src/resolve/vbnet/receivers.rs
@@ -320,36 +320,26 @@ impl KernelResolver {
             };
             return Ok(Some(ty));
         }
-        for owner in self.vb_around(&r.file_path, r.line)? {
-            for ancestor in self.vb_ancestry(&owner)? {
-                if let Some(node) = self
-                    .vb_members(&ancestor.node, name)?
-                    .into_iter()
-                    .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
-                {
-                    return self
-                        .vb_member_type(&VbMember {
-                            node,
-                            args: ancestor.args,
-                        })
-                        .map(Some);
-                }
-            }
-        }
-        if let Some(node) = self
-            .vb_module_members(name, r)?
-            .into_iter()
-            .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
-        {
-            return self
-                .vb_member_type(&VbMember {
-                    node,
-                    args: HashMap::new(),
-                })
-                .map(Some);
+        if let Some(member) = self.vb_member_around(name, r)? {
+            return self.vb_member_type(&member).map(Some);
         }
         Ok(None)
     }
+    /// localBinding: whether a parameter or local of `name` is in scope at the
+    /// reference — a member of that name is hidden where one is.
+    pub(in crate::resolve) fn vb_local_bound(&mut self, name: &str, r: &ResolveRefIn) -> Res<bool> {
+        let start = self.vb_scope_start(r)?;
+        let lines = self.vb_lines(&r.file_path);
+        for i in (start.max(1) as usize - 1..(r.line.max(0) as usize).min(lines.len())).rev() {
+            if self
+                .vb_binding_on(&lines[i], name, &r.file_path, i as i64 + 1)?
+                .is_some()
+            {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
     pub(in crate::resolve) fn vb_owners(&mut self, t: &VbType) -> Res<Option<Vec<Arc<KNode>>>> {
         if t.array || vb_builtin(t) {
             return Ok(Some(vec![]));
diff --git a/codegraph-kernel/src/resolve/vbnet/types.rs b/codegraph-kernel/src/resolve/vbnet/types.rs
index a7a57409f5..d10ce1613d 100644
--- a/codegraph-kernel/src/resolve/vbnet/types.rs
+++ b/codegraph-kernel/src/resolve/vbnet/types.rs
@@ -26,6 +26,11 @@ pub(in crate::resolve) struct VbMemo {
     pub(in crate::resolve) code: HashMap<String, Rc<Vec<String>>>,
     pub(in crate::resolve) projects: HashMap<String, Option<String>>,
     pub(in crate::resolve) headers: HashMap<String, Rc<VbHeader>>,
+    pub(in crate::resolve) namespaces: Option<Rc<HashSet<String>>>,
+    pub(in crate::resolve) ns_around: HashMap<(String, i64), Rc<Vec<String>>>,
+    pub(in crate::resolve) ns_named: HashMap<String, Option<Rc<Vec<String>>>>,
+    pub(in crate::resolve) no_args: HashMap<String, bool>,
+    pub(in crate::resolve) namesakes: HashMap<String, bool>,
 }
 #[derive(Clone)]
 pub(in crate::resolve) enum VbBinding {
@@ -733,4 +738,328 @@ impl KernelResolver {
         }
         Ok(None)
     }
+    /// knownNamespaces: every full namespace name the project's VB.NET code
+    /// declares (root namespaces included), lowercased and dot-joined.
+    pub(in crate::resolve) fn vb_known_namespaces(&mut self) -> Res<Rc<HashSet<String>>> {
+        if let Some(hit) = &self.vb.namespaces {
+            return Ok(hit.clone());
+        }
+        let mut known = HashSet::new();
+        let mut add = |segments: &[String]| {
+            for i in 1..=segments.len() {
+                known.insert(segments[..i].join("."));
+            }
+        };
+        let namespaces: Vec<Arc<KNode>> = self
+            .table()?
+            .nodes
+            .iter()
+            .filter(|n| n.language == "vbnet" && n.kind == "namespace")
+            .cloned()
+            .collect();
+        for n in &namespaces {
+            add(&self.vb_full(n));
+        }
+        let files: Vec<String> = self
+            .table()?
+            .by_file
+            .keys()
+            .filter(|f| f.to_ascii_lowercase().ends_with(".vb"))
+            .cloned()
+            .collect();
+        for file in files {
+            add(&self.vb_header(&file).root);
+        }
+        let out = Rc::new(known);
+        self.vb.namespaces = Some(out.clone());
+        Ok(out)
+    }
+    /// namespaceAround: the full segments of the namespace a line sits in —
+    /// the project's root namespace, then the `Namespace` block around it.
+    pub(in crate::resolve) fn vb_namespace_around(&mut self, file: &str, line: i64) -> Res<Rc<Vec<String>>> {
+        let key = (file.to_string(), line);
+        if let Some(hit) = self.vb.ns_around.get(&key) {
+            return Ok(hit.clone());
+        }
+        let root = self.vb_header(file).root.clone();
+        let around = self.vb_around(file, line)?;
+        let outer = around.last();
+        let out = match outer.and_then(|n| n.qualified_name.find("::").map(|cut| n.qualified_name[..cut].to_ascii_lowercase())) {
+            Some(head)
+                if self
+                    .nodes_in_file(file)?
+                    .iter()
+                    .any(|n| n.kind == "namespace" && n.qualified_name.eq_ignore_ascii_case(&head)) =>
+            {
+                let mut v = root;
+                v.extend(head.split('.').map(str::to_string));
+                v
+            }
+            _ => root,
+        };
+        let out = Rc::new(out);
+        self.vb.ns_around.insert(key, out.clone());
+        Ok(out)
+    }
+    /// namespaceNamed: the full segments of the namespace a first path segment
+    /// names where it is written — nested inside the namespaces around the
+    /// read, innermost first, else inside an imported one. None when the name
+    /// is no namespace there.
+    pub(in crate::resolve) fn vb_namespace_named(
+        &mut self,
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Rc<Vec<String>>>> {
+        let lower = name.to_ascii_lowercase();
+        let key = format!("{}:{}:{lower}", r.file_path, r.line);
+        if let Some(hit) = self.vb.ns_named.get(&key) {
+            return Ok(hit.clone());
+        }
+        let known = self.vb_known_namespaces()?;
+        let around = self.vb_namespace_around(&r.file_path, r.line)?;
+        let mut out = None;
+        for i in (0..=around.len()).rev() {
+            let mut candidate = around[..i].to_vec();
+            candidate.push(lower.clone());
+            if known.contains(&candidate.join(".")) {
+                out = Some(candidate);
+                break;
+            }
+        }
+        if out.is_none() {
+            for imported in self.vb_header(&r.file_path).imports.clone() {
+                let mut candidate: Vec<String> = imported.split('.').map(str::to_string).collect();
+                candidate.push(lower.clone());
+                if known.contains(&candidate.join(".")) {
+                    out = Some(candidate);
+                    break;
+                }
+            }
+        }
+        let out = out.map(Rc::new);
+        self.vb.ns_named.insert(key, out.clone());
+        Ok(out)
+    }
+    /// typesInNamespace: the project types named `name` declared directly in
+    /// namespace `ns` (full segments) — the caller's project's when it has
+    /// one, and None when that leaves two different types.
+    pub(in crate::resolve) fn vb_types_in_namespace(
+        &mut self,
+        ns: &[String],
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Vec<Arc<KNode>>>> {
+        let key = ns.join(".");
+        let mut found: Vec<Arc<KNode>> = Vec::new();
+        for n in self.nodes_by_lower_name(name)?.iter() {
+            if n.language != "vbnet" || !(vb_type_kind(&n.kind) || n.kind == "enum") {
+                continue;
+            }
+            let full = self.vb_full(n);
+            if full[..full.len() - 1].join(".") == key {
+                found.push(n.clone());
+            }
+        }
+        let own: Vec<_> = found
+            .iter()
+            .filter(|n| self.vb_same_project(&n.file_path, &r.file_path))
+            .cloned()
+            .collect();
+        if !own.is_empty() {
+            found = own;
+        }
+        let mut distinct = HashSet::new();
+        for n in &found {
+            distinct.insert((
+                self.vb_project(&n.file_path),
+                n.qualified_name.to_ascii_lowercase(),
+            ));
+        }
+        if distinct.len() > 1 {
+            return Ok(None);
+        }
+        found.sort_by_key(|n| n.file_path != r.file_path);
+        Ok(Some(found))
+    }
+    /// moduleMemberIn: a member named `name` of a `Module` declared directly
+    /// in namespace `ns`, which VB.NET reads through the namespace.
+    pub(in crate::resolve) fn vb_module_member_in(
+        &mut self,
+        ns: &[String],
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let key = ns.join(".");
+        for n in self.vb_module_members(name, r)?.iter() {
+            if !(vb_value_kind(&n.kind) || n.kind == "method") {
+                continue;
+            }
+            let full = self.vb_full(n);
+            if full.len() >= 2 && full[..full.len() - 2].join(".") == key {
+                return Ok(Some(n.clone()));
+            }
+        }
+        Ok(None)
+    }
+    /// memberAround: the field, property, function or Module member a
+    /// receiver-less `name` reads where a call is (upstream memberAround).
+    pub(in crate::resolve) fn vb_member_around(
+        &mut self,
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<VbMember>> {
+        for owner in self.vb_around(&r.file_path, r.line)? {
+            for ancestor in self.vb_ancestry(&owner)? {
+                if let Some(node) = self
+                    .vb_members(&ancestor.node, name)?
+                    .into_iter()
+                    .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
+                {
+                    return Ok(Some(VbMember {
+                        node,
+                        args: ancestor.args,
+                    }));
+                }
+            }
+        }
+        if let Some(node) = self
+            .vb_module_members(name, r)?
+            .into_iter()
+            .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
+        {
+            return Ok(Some(VbMember {
+                node,
+                args: HashMap::new(),
+            }));
+        }
+        Ok(None)
+    }
+    /// takesNoArguments: whether VB.NET can call a method with no arguments —
+    /// it declares no parameter, or only `Optional` ones and a `ParamArray`.
+    /// Read from its declaration; true when that can't be read.
+    pub(in crate::resolve) fn vb_takes_no_arguments(&mut self, n: &KNode) -> Res<bool> {
+        if let Some(hit) = self.vb.no_args.get(&n.id) {
+            return Ok(*hit);
+        }
+        let code = self
+            .vb_lines(&n.file_path)
+            .iter()
+            .skip((n.start_line - 1).max(0) as usize)
+            .take(7)
+            .cloned()
+            .collect::<Vec<_>>()
+            .join(" ");
+        let name = regex::escape(n.name.trim_matches(['[', ']']));
+        let head = Self::cached_regex(&format!(
+            r"(?i)\b(?:Sub|Function)\s+(\[?{name}\]?)(?:[^\w$%&!#@]|$)"
+        ))?
+        .captures(&code);
+        let mut none = true;
+        if let Some(head) = head {
+            let mut at = head.get(1).unwrap().end();
+            if re!(r"(?i)^\s*\(\s*Of\b").is_match(&code[at..]) {
+                // `Function Parse(Of T)(text As String)`: the type parameters come first.
+                at = code[at..]
+                    .find('(')
+                    .and_then(|i| vb_close(&code, at + i))
+                    .map_or(0, |close| close + 1);
+            }
+            let open = (at > 0).then(|| re!(r"^\s*\(").find(&code[at..])).flatten();
+            let params = open.and_then(|m| {
+                let open_at = at + m.end() - 1;
+                vb_close(&code, open_at).map(|close| vb_args(&code[open_at + 1..close]))
+            });
+            none = params.is_none_or(|params| {
+                params.iter().all(|p| {
+                    let param = re!(r"<[^<>]*>").replace_all(p, "");
+                    let param = param.trim_start_matches([' ', '\t', '_']);
+                    param.is_empty()
+                        || re!(r"(?i)^(?:(?:ByVal|ByRef)\s+)*(?:Optional|ParamArray)\b")
+                            .is_match(param)
+                })
+            });
+        }
+        self.vb.no_args.insert(n.id.clone(), none);
+        Ok(none)
+    }
+    /// runnableOverload: the overload of `member` VB.NET runs where a
+    /// reference names it without parentheses — one that takes no arguments,
+    /// and never the member the reference is in. `member` itself when the
+    /// overloads don't tell; None when the only one is the containing member.
+    pub(in crate::resolve) fn vb_runnable_overload(
+        &mut self,
+        member: Arc<KNode>,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let owner = match vb_parent_qn(&member) {
+            Some(qn) => self
+                .nodes_by_qualified_name(qn)?
+                .iter()
+                .find(|n| n.language == "vbnet" && vb_type_kind(&n.kind))
+                .cloned(),
+            None => None,
+        };
+        let project = self.vb_project(&member.file_path);
+        let overloads: Vec<Arc<KNode>> = match owner {
+            Some(owner) => self
+                .vb_members(&owner, &member.name)?
+                .into_iter()
+                .filter(|n| {
+                    n.kind == "method" && self.vb_project(&n.file_path) == project
+                })
+                .collect(),
+            None => vec![],
+        };
+        let others: Vec<_> = overloads
+            .into_iter()
+            .filter(|n| n.id != r.from_node_id)
+            .collect();
+        if others.is_empty() {
+            return Ok((member.id != r.from_node_id).then_some(member));
+        }
+        let mut runnable = Vec::new();
+        for n in &others {
+            if self.vb_takes_no_arguments(n)? {
+                runnable.push(n.clone());
+            }
+        }
+        let pool = if runnable.is_empty() { &others } else { &runnable };
+        Ok(Some(
+            pool.iter()
+                .find(|n| n.id == member.id)
+                .cloned()
+                .unwrap_or_else(|| pool[0].clone()),
+        ))
+    }
+    /// isOutsideNamesake: a member declared as a type of its own name that
+    /// isn't one of the project's (`Responser As Responser`), or naming two —
+    /// a read through its name may be one through that type.
+    pub(in crate::resolve) fn vb_is_outside_namesake(
+        &mut self,
+        member: &Arc<KNode>,
+        args: &HashMap<String, VbType>,
+    ) -> Res<bool> {
+        if args.is_empty() {
+            if let Some(hit) = self.vb.namesakes.get(&member.id) {
+                return Ok(*hit);
+            }
+        }
+        let declared = self.vb_member_type(&VbMember {
+            node: member.clone(),
+            args: args.clone(),
+        })?;
+        let mut namesake = false;
+        if let Some(d) = declared.filter(|d| {
+            !d.array
+                && d.name
+                    .eq_ignore_ascii_case(member.name.trim_matches(['[', ']']))
+        }) {
+            let (owners, ambiguous) = self.vb_types_at(&d, true)?;
+            namesake = ambiguous || owners.is_empty();
+        }
+        if args.is_empty() {
+            self.vb.namesakes.insert(member.id.clone(), namesake);
+        }
+        Ok(namesake)
+    }
 }
diff --git a/codegraph-kernel/src/tsjs/exports.rs b/codegraph-kernel/src/tsjs/exports.rs
index 64130642e4..f555368e72 100644
--- a/codegraph-kernel/src/tsjs/exports.rs
+++ b/codegraph-kernel/src/tsjs/exports.rs
@@ -79,11 +79,21 @@ impl<'t> Walker<'t> {
                 self.emit_reexport_binding("default", "default", &spec, expr);
             } else if right.kind() == "identifier" {
                 self.later_exports.entry(self.text(right).to_string()).or_insert(("default".to_string(), EXPORT_CJS));
+            } else if right.kind() == "class" {
+                // `module.exports = class Router {…}`: the class is the
+                // module's value — the local name it declares is the
+                // binding a `require` reaches (#2499).
+                if let Some(name) = right.child_by_field_name("name") {
+                    self.later_exports.entry(self.text(name).to_string()).or_insert(("default".to_string(), EXPORT_CJS));
+                }
             }
             return;
         }
         let fn_valued = matches!(right.kind(), "function_expression" | "arrow_function" | "generator_function");
-        if (right.kind() != "identifier" && !fn_valued) || !matches!(left.kind(), "member_expression" | "subscript_expression") {
+        // A named class expression is the member's value too: `exports.Store
+        // = class StoreImpl {…}` binds `Store` to `StoreImpl` (#2499).
+        let class_named = right.kind() == "class" && right.child_by_field_name("name").is_some();
+        if (right.kind() != "identifier" && !fn_valued && !class_named) || !matches!(left.kind(), "member_expression" | "subscript_expression") {
             return;
         }
         let Some(obj) = left.child_by_field_name("object") else { return };
@@ -100,7 +110,16 @@ impl<'t> Walker<'t> {
                 if fn_valued {
                     self.cjs_fn_exports.push((key, self.line_of(expr)));
                 } else {
-                    self.later_exports.entry(self.text(right).to_string()).or_insert((key, EXPORT_CJS));
+                    // A class binds by the name it declares (`exports.X =
+                    // class Y`), a bare identifier by its own text.
+                    let local = if class_named {
+                        right.child_by_field_name("name").map(|n| self.text(n).to_string())
+                    } else {
+                        Some(self.text(right).to_string())
+                    };
+                    if let Some(local) = local {
+                        self.later_exports.entry(local).or_insert((key, EXPORT_CJS));
+                    }
                 }
             }
         }
diff --git a/src/codegraph.ts b/src/codegraph.ts
index 7fb507b06a..cc998a8471 100644
--- a/src/codegraph.ts
+++ b/src/codegraph.ts
@@ -68,6 +68,7 @@ import { extractSegmentSearchWords, segmentLookupVariants, splitIdentifierSegmen
 import { seedLiteralsInQuery, seedRouteNamesInQuery } from './extraction/literal-capture';
 import { createYielder } from './resolution/cooperative-yield';
 import { createImportReader, reopenNameMatchedImports, reopenReferencesThroughAddedFiles, reopenReferencesThroughBarrels, reopenReferencesThroughChangedDefaults, reopenReferencesThroughDeclaredPackages } from './resolution/module-importers';
+import { ESM_IMPORT_LANGUAGES } from './resolution/import-resolver';
 import { minRefsForPool } from './resolution/resolver-pool';
 
 /** The extraction, resolution and watcher modules, loaded on first use. */
@@ -148,6 +149,7 @@ export interface IndexOptions {
  */
 /** project_metadata key for the Python package-root digest (see sync). */
 const PYTHON_ROOTS_METADATA_KEY = 'python_root_fingerprint';
+const WORKSPACE_METADATA_KEY = 'js_workspace_fingerprint';
 
 export class CodeGraph {
   private db: DatabaseConnection;
@@ -852,6 +854,7 @@ export class CodeGraph {
         // real full index — a sync touches a subset, so it must NOT advance the
         // extraction stamp (the bulk would still be stale). See extraction-version.ts.
         if (result.success) this.stampPythonRootFingerprint();
+        if (result.success) this.stampWorkspaceFingerprint();
 
         if (result.success && result.filesIndexed > 0) {
           try {
@@ -946,7 +949,11 @@ export class CodeGraph {
         return { success: false, filesIndexed: 0, filesSkipped: 0, filesErrored: 0, nodesCreated: 0, edgesCreated: 0, errors: [{ message: 'Could not acquire file lock - another process may be indexing', severity: 'error' as const }], durationMs: 0 };
       }
       try {
-        return this.orchestrator.indexFiles(filePaths);
+        // Awaited, so the write lock is held until the files are stored, as
+        // indexAll and sync hold it: returned unawaited, the promise left the
+        // `try` at once and the `finally` let the lock go as soon as indexing
+        // started, so another process could write meanwhile (#2845).
+        return await this.orchestrator.indexFiles(filePaths);
       } finally {
         this.fileLock.release();
       }
@@ -970,6 +977,13 @@ export class CodeGraph {
     } catch { /* metadata is advisory */ }
   }
 
+  /** Record the workspace-map digest a later sync compares against. */
+  private stampWorkspaceFingerprint(fingerprint = this.resolver.getWorkspaceFingerprint()): void {
+    try {
+      this.queries.setMetadata(WORKSPACE_METADATA_KEY, fingerprint);
+    } catch { /* metadata is advisory */ }
+  }
+
   async sync(options: IndexOptions = {}): Promise<SyncResult> {
     if (options.requireComplete && process.env.CODEGRAPH_SYNC_RESYNTHESIS === '0') {
       throw new Error('Complete reconciliation requires synthesized-edge refresh to be enabled.');
@@ -1238,7 +1252,8 @@ export class CodeGraph {
               const tAdded = Date.now();
               const reopened = reopenReferencesThroughAddedFiles(
                 this.queries, importReader, added, edgesBeforeResolution,
-                (specifier, fromFile, language) => this.resolver.resolveModuleFile(specifier, fromFile, language)
+                (specifier, fromFile, language) => this.resolver.resolveModuleFile(specifier, fromFile, language),
+                (file) => this.resolver.workspacePackageDirOf(file)
               );
               if (process.env.CODEGRAPH_SYNTH_TIMINGS) console.error(`[phase-timing] sync-added-module-importers: ${Date.now() - tAdded}ms (${reopened} refs re-opened)`);
             }
@@ -1456,6 +1471,40 @@ export class CodeGraph {
           }
         }
 
+        // Workspace packages and path dependencies (#2456, #2502). A
+        // package.json edit — a member's name, its `main` or `exports`, a
+        // `file:` dependency — moves what an import of the package resolves to
+        // in files it never touched, and no indexed file changes with it. A
+        // full reconcile (`codegraph sync`, a git hook, the watcher's catch-up)
+        // reads the manifests again; when what they declare moved, every
+        // JavaScript-family reference is re-opened, as a moved Python root set
+        // re-opens Python's above, and the orphan sweep below resolves them by
+        // the new map exactly as a fresh index would. Package.json edits that
+        // leave the map alone (a version bump, a new registry dependency) cost
+        // one read. The watcher's scoped syncs follow source files only and
+        // skip the read: a monorepo's manifests take a walk of the tree to
+        // find. An index stamped by an older engine has no digest: record one.
+        if (fullReconcile) {
+          const tWorkspace = Date.now();
+          if (walValve) { walValve.stop(); await walValve.drain(); }
+          try {
+            const before = this.queries.getMetadata(WORKSPACE_METADATA_KEY);
+            const now = this.resolver.refreshWorkspacePackages();
+            if (before !== null && before !== now) {
+              let reopened = 0;
+              for (const language of ESM_IMPORT_LANGUAGES) reopened += this.orchestrator.resurrectResolutionEdgesForLanguage(language);
+              this.queries.setSynthesisPending(true);
+              if (process.env.CODEGRAPH_SYNTH_TIMINGS) {
+                console.error(`[phase-timing] sync-workspace-packages: ${Date.now() - tWorkspace}ms (${reopened} refs re-opened)`);
+              }
+            }
+            if (before !== now) this.stampWorkspaceFingerprint(now);
+          } finally {
+            this.resolver.closeKernel();
+            walValve?.start();
+          }
+        }
+
         // 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/db/queries.ts b/src/db/queries.ts
index bb192ea7d1..fa6a08cce1 100644
--- a/src/db/queries.ts
+++ b/src/db/queries.ts
@@ -265,10 +265,14 @@ function rowToNode(row: NodeRow): Node {
 /**
  * Convert database row to Edge object
  */
-/** A failed python ref through one attribute (`self.c.send`) or a call receiver (`make().send`). */
+/** A failed python ref through one attribute (`self.c.send`), a call receiver
+ * (`make().send`), or a receiver-typed local's call (`reg.get`) — the last is
+ * the builtin-named-method shape the typed-local evidence pass may later
+ * satisfy once the file it reads its type from changes (#2583). One or two
+ * dots, not three: `a.b.c.d` chains never come back through a local's type. */
 const FAILED_PY_ATTR_REF = `status = 'failed' AND language = 'python'
-  AND reference_name NOT GLOB '*.*.*.*'
-  AND (reference_name GLOB '*.*.*' OR reference_name GLOB '*().*')`;
+  AND reference_name GLOB '*.*'
+  AND reference_name NOT GLOB '*.*.*.*'`;
 
 function rowToEdge(row: EdgeRow): Edge {
   return {
diff --git a/src/extraction/kernel/loader.ts b/src/extraction/kernel/loader.ts
index 607a324c2f..5317907151 100644
--- a/src/extraction/kernel/loader.ts
+++ b/src/extraction/kernel/loader.ts
@@ -178,11 +178,29 @@ export interface KernelAliasMapIn {
   patterns: KernelAliasPatternIn[];
 }
 
+export interface KernelKvList {
+  key: string;
+  values: string[];
+}
+
+export interface KernelPackageEntriesIn {
+  dir: string;
+  exports: KernelKvList[];
+  main: string[];
+}
+
+export interface KernelScopedPackageIn {
+  dir: string;
+  names: KernelKv[];
+}
+
 export interface KernelWorkspaceIn {
   sourceEntries: KernelKv[];
   byName: KernelKv[];
   entryByName?: KernelKv[];
   localLinkNames?: string[];
+  entriesByDir?: KernelPackageEntriesIn[];
+  scopedByName?: KernelScopedPackageIn[];
 }
 
 export interface KernelResolverConfig {
diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts
index fb6c060ce1..f8c2b5b383 100644
--- a/src/resolution/callback-synthesizer.ts
+++ b/src/resolution/callback-synthesizer.ts
@@ -2195,6 +2195,9 @@ const JSX_CHILD_KINDS = new Set<NodeKind>(['component', 'function', 'class']);
  */
 const JSX_CHILD_LANGUAGES = [...JS_FAMILY, 'vue', 'svelte'];
 
+/** A file whose tags the JSX pass reads: a script, or a single-file component's. */
+const JSX_INPUT_FILE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro)$/;
+
 /**
  * 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
@@ -2275,6 +2278,34 @@ function projectImport(ctx: ResolutionContext, name: string, file: string): { mo
   return { module, exported: binding.isDefault || binding.exportedName === 'default' ? 'default' : binding.exportedName };
 }
 
+/**
+ * The files a JSX file's project-imported tags are read through: each tag's
+ * module, the index or barrel that hands its component on, and the module
+ * that declares it (`exportedComponent`'s reads). A sync that edits one of
+ * them — `index.ts` forwarding another module, a default export rewired —
+ * redraws the tag. `memo` holds each module and export's reads for one run.
+ */
+function importedTagModules(ctx: ResolutionContext, file: string, content: string, memo: Map<string, Set<string>>): Set<string> {
+  const out = new Set<string>();
+  JSX_TAG_RE.lastIndex = 0;
+  const names = new Set<string>();
+  for (let m = JSX_TAG_RE.exec(content); m; m = JSX_TAG_RE.exec(content)) names.add(m[1]!);
+  for (const name of names) {
+    const imported = projectImport(ctx, name, file);
+    if (!imported) continue;
+    const key = `${imported.module}\0${imported.exported}`;
+    let reads = memo.get(key);
+    if (!reads) {
+      reads = new Set<string>();
+      exportedComponent(imported.module, imported.exported, ctx, new Set(), reads);
+      memo.set(key, reads);
+    }
+    for (const read of reads) out.add(read);
+  }
+  out.delete(file);
+  return out;
+}
+
 /**
  * The component a JSX tag names, among every node that shares the name.
  *
@@ -7188,12 +7219,19 @@ export function mayFeedSynthesis(filePath: string, content: string): boolean {
  * edges dropped out (a channel crossing the fan-out cap) or the file is gone.
  */
 export function collectSynthesisInputs(ctx: ResolutionContext): string[] {
-  const inputs: string[] = [];
+  const inputs = new Set<string>();
+  const tagModules = new Map<string, Set<string>>();
   for (const file of ctx.getAllFiles()) {
     const content = ctx.readFile(file);
-    if (content && mayFeedSynthesis(file, content)) inputs.push(file);
+    if (!content) continue;
+    if (mayFeedSynthesis(file, content)) inputs.add(file);
+    // Every file a tag imported from the project is read through feeds the
+    // JSX pass too — a rewired index redraws the tag (#2563).
+    if (JSX_INPUT_FILE.test(file) && (content.includes('</') || content.includes('/>'))) {
+      for (const read of importedTagModules(ctx, file, content, tagModules)) inputs.add(read);
+    }
   }
-  return inputs;
+  return [...inputs];
 }
 
 /**
diff --git a/src/resolution/go-type-visibility.ts b/src/resolution/go-type-visibility.ts
index ace101ff5f..04a8942b5b 100644
--- a/src/resolution/go-type-visibility.ts
+++ b/src/resolution/go-type-visibility.ts
@@ -5,7 +5,7 @@ import type { ImportMapping, ResolutionContext, ResolvedRef, UnresolvedRef } fro
 function lineAt(ref: UnresolvedRef, context: ResolutionContext): string | undefined {
   return context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1];
 }
-function goPackageDir(file: string): string { return path.posix.dirname(file.replace(/\\/g, '/')); }
+function goPackageDir(file: string): string { const dir = path.posix.dirname(file.replace(/\\/g, '/')); return dir === '.' ? '' : dir; }
 function goImportPackageDir(name: string, file: string, context: ResolutionContext): string | null | undefined {
   const imp = context.getImportMappings(file, 'go').find((m) => m.localName === name);
   return imp ? context.getGoPackageDir?.(imp.source, file) ?? null : undefined;
@@ -17,6 +17,83 @@ function preferCallSiteFile(nodes: Node[], file: string): Node[] {
   return [...nodes].sort((a, b) => Number(b.filePath === file) - Number(a.filePath === file));
 }
 export const GO_TYPE_KINDS: ReadonlySet<string> = new Set(['struct', 'interface', 'type_alias']);
+
+/** The project packages a Go file dot-imports, and whether it dot-imports one from outside the project. */
+interface GoDotImports {
+  dirs: string[];
+  outside: boolean;
+  /** The `type` declarations the file's text holds — function-local ones included — read on demand. */
+  types?: Set<string>;
+}
+
+const GO_DOT_IMPORTS = new WeakMap<ResolutionContext, Map<string, GoDotImports>>();
+
+function goDotImports(filePath: string, context: ResolutionContext): GoDotImports {
+  let memo = GO_DOT_IMPORTS.get(context);
+  if (!memo) GO_DOT_IMPORTS.set(context, (memo = new Map()));
+  let found = memo.get(filePath);
+  if (found) return found;
+  found = { dirs: [], outside: false };
+  for (const line of context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? []) {
+    // The imports come before any other declaration.
+    if (/^(?:func|type|var|const)\b/.test(line)) break;
+    const dot = /^\s*(?:import\s+)?\.\s+"([^"]+)"/.exec(line);
+    if (!dot || !context.getGoPackageDir) continue;
+    const dir = context.getGoPackageDir(dot[1]!, filePath);
+    if (dir) found.dirs.push(dir);
+    // A relative or `/internal/` path is the project's own, mapped or not.
+    else if (!dot[1]!.startsWith('.') && !dot[1]!.includes('/internal/')) found.outside = true;
+  }
+  memo.set(filePath, found);
+  return found;
+}
+
+/**
+ * The directory of the package that declares a Go type written bare in
+ * `filePath` (`Controller`, `*Manager`), as Go reads the name: the file's own
+ * package, else a package of the project the file dot-imports that declares
+ * it (harbor's config tests read `Controller` from `. ".../controller/config"`).
+ * Null for an exported name that only a package from outside the project the
+ * file dot-imports can give it (`. "github.com/onsi/gomega"`): no type of the
+ * project's. The file's own package when no package declares the name, as
+ * before: a type the index doesn't hold there, like one a function declares
+ * (ginkgo's `type CompleteSpecContext interface {…}` inside a test), which
+ * hides a dot import's.
+ */
+function goBareTypeDir(name: string, filePath: string, context: ResolutionContext): string | null {
+  const own = goPackageDir(filePath);
+  const dots = goDotImports(filePath, context);
+  if ((dots.dirs.length === 0 && !dots.outside) || goPackageTypes(name, own, context).length > 0) return own;
+  const dir = dots.dirs.find((d) => goPackageTypes(name, d, context).length > 0);
+  if (dir !== undefined) return dir;
+  if (!dots.outside || !/^[A-Z]\w*$/.test(name)) return own;
+  if (!dots.types) {
+    dots.types = new Set();
+    for (const line of context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? []) {
+      for (const m of line.replace(/\/\/.*$/, '').matchAll(/(?:^|[^\w.])type\s+([A-Za-z_]\w*)/g)) dots.types.add(m[1]!);
+    }
+  }
+  return dots.types.has(name) ? own : null;
+}
+
+/**
+ * What a Go embedding written bare (`*Manager`) names when the file's own
+ * package doesn't declare the name: the type of the package the file
+ * dot-imports that does (goBareTypeDir), not another package's namesake name
+ * matching found as near the file, or nothing for a name only a package from
+ * outside the project can give the file. Any other is left as it is.
+ */
+export function goDotImportedSupertype(result: ResolvedRef, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const name = ref.referenceName;
+  if (!/^[A-Za-z_]\w*$/.test(name)) return result;
+  const dir = goBareTypeDir(name, ref.filePath, context);
+  if (dir === goPackageDir(ref.filePath) || goRefQualification(ref, context).written !== undefined) return result;
+  if (dir === null) return null;
+  const target = context.getNodeById?.(result.targetNodeId);
+  if (target && goPackageDir(target.filePath) === dir) return result;
+  return { ...result, targetNodeId: preferCallSiteFile(goPackageTypes(name, dir, context), ref.filePath)[0]!.id };
+}
+
 interface GoQualification {
   /** The package name written before the reference's name, as spelled. */
   written?: string;
@@ -97,12 +174,14 @@ export function goTypePositionTarget(result: ResolvedRef, ref: UnresolvedRef, co
   } else {
     const { written, imported } = goRefQualification(ref, context);
     bare = written === undefined;
-    if (bare) pkgDir = goPackageDir(ref.filePath);
-    else if (imported) pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath) ?? null;
+    if (bare) {
+      pkgDir = goBareTypeDir(name, ref.filePath, context);
+      if (pkgDir === null) return null;
+    } else if (imported) pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath) ?? null;
   }
-  if (pkgDir === '') pkgDir = '.';
   if (isType && (!bare || goPackageDir(target.filePath) === pkgDir)) return result;
-  const types = pkgDir != null ? goPackageTypes(name, pkgDir, context) : [];
+  // `''` is a real directory — a module's root package — not a miss.
+  const types = pkgDir !== null && pkgDir !== undefined ? goPackageTypes(name, pkgDir, context) : [];
   if (types.length > 0) return { ...result, targetNodeId: preferCallSiteFile(types, ref.filePath)[0]!.id };
   return isType ? result : null;
 }
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index f556037d06..963fa72615 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -32,7 +32,7 @@ import { gateRustScope, clearRustScopeMemos } from './rust-scope';
 import { gateSuperSelfCall } from './super-self';
 import { gatePascalCall } from './pascal-scope';
 import { resurrectRefFromDroppedEdge } from './resurrect-ref';
-import { GO_TYPE_KINDS, isGoBareName, isGoUnknownQualified, goTypePositionTarget } from './go-type-visibility';
+import { GO_TYPE_KINDS, isGoBareName, isGoUnknownQualified, goTypePositionTarget, goDotImportedSupertype } from './go-type-visibility';
 import { ResolverPool, adaptiveEngageEnabled, minRefsForPool, shouldEngageAdaptively } from './resolver-pool';
 import { resolveAliasBinding } from './alias-binding';
 import { detectFrameworksWithSkips, getResolvingFrameworks } from './frameworks';
@@ -41,7 +41,7 @@ import { createYielder, type MaybeYield } from './cooperative-yield';
 import { MAX_SOURCE_FILE_SIZE_BYTES } from '../file-limits';
 import { loadProjectAliases, loadScopedAliases, scopedAliasesForFile, type AliasMap, type AliasScope } from './path-aliases';
 import { findGoModuleForImport, goModulePackageDir, loadGoModule, type GoModule } from './go-module';
-import { loadWorkspacePackages, type WorkspacePackages } from './workspace-packages';
+import { loadWorkspacePackages, workspaceFingerprint, workspacePackageDirOf, type WorkspacePackages } from './workspace-packages';
 import { logDebug } from '../errors';
 import { lexicalPathWithinRoot, safeJsonParse } from '../utils';
 import { builtinModules } from 'module';
@@ -1030,6 +1030,38 @@ export class ReferenceResolver {
     });
   }
 
+  /**
+   * The workspace packages and path dependencies as package.json files
+   * declare them now, read again from disk, and their fingerprint (see
+   * `workspaceFingerprint`). The resolver keeps the map for its lifetime, so
+   * a sync calls this to see a manifest edit; when the map moved, the
+   * resolver takes the new one and drops every memo resolved through the old
+   * one, and the caller re-opens what was linked by it.
+   */
+  refreshWorkspacePackages(): string {
+    const fresh = loadWorkspacePackages(this.projectRoot);
+    const fingerprint = workspaceFingerprint(fresh);
+    if (this.workspacePackages === undefined || workspaceFingerprint(this.workspacePackages) !== fingerprint) {
+      this.workspacePackages = fresh;
+      this.clearCaches();
+      // The kernel resolver takes the workspace map at construction: a moved
+      // map must reach a new instance, not just a cleared memo.
+      this.closeKernel();
+    }
+    return fingerprint;
+  }
+
+  /** The fingerprint of the workspace map this resolver resolves by (see `workspaceFingerprint`). */
+  getWorkspaceFingerprint(): string {
+    return workspaceFingerprint(this.context.getWorkspacePackages?.() ?? null);
+  }
+
+  /** The folder of the workspace package or path dependency `file` is in (see `workspacePackageDirOf`), or null. */
+  workspacePackageDirOf(file: string): string | null {
+    const ws = this.context.getWorkspacePackages?.();
+    return ws ? workspacePackageDirOf(ws, file) : null;
+  }
+
   getPythonReopenScope(changedFiles: string[]) {
     return this.withPythonKernel((kernel) => kernel.pythonPackageReopenScope(changedFiles));
   }
@@ -1366,6 +1398,16 @@ export class ReferenceResolver {
             byName: toKv(workspaces.byName),
             entryByName: workspaces.entryByName ? toKv(workspaces.entryByName) : undefined,
             localLinkNames: workspaces.localLinkNames ? [...workspaces.localLinkNames] : undefined,
+            entriesByDir: workspaces.entriesByDir
+              ? [...workspaces.entriesByDir.entries()].map(([dir, e]) => ({
+                  dir,
+                  exports: e.exports ? [...e.exports.entries()].map(([key, values]) => ({ key, values })) : [],
+                  main: e.main ?? [],
+                }))
+              : undefined,
+            scopedByName: workspaces.scopedByName
+              ? [...workspaces.scopedByName.entries()].map(([dir, names]) => ({ dir, names: toKv(names) }))
+              : undefined,
           }
         : undefined,
       goModules: this.getGoModules().map(m => ({ modulePath: m.modulePath, dir: path.relative(this.projectRoot, m.rootDir).split(path.sep).join('/') })),
@@ -1461,6 +1503,14 @@ export class ReferenceResolver {
         candidates.push(result);
       }
     }
+    // A reference a framework answers alone ends with the frameworks' answer
+    // (see FrameworkResolver.ownsReference): Nuxt's `navigateTo(x)` with a
+    // destination no route serves is no namesake's call.
+    if (this.frameworksFor(ref.language).some((f) => f.ownsReference?.(ref, this.context))) {
+      if (candidates.length === 0) return this.applyResolveTail(null, ref);
+      const owned = candidates.reduce((best, curr) => (curr.confidence > best.confidence ? curr : best));
+      return this.applyResolveTail(this.gateTargetKind(owned, ref), ref);
+    }
     // The kernel's ≥0.9 import verdict outranks <0.9 framework candidates —
     // resolveOneInner early-returns it and discards them. A verdict reported
     // without a candidate list is likewise already the merged winner.
@@ -3166,9 +3216,14 @@ export class ReferenceResolver {
     }
 
     // An `imports` reference names something importable — never a member that
-    // only exists inside a type.
+    // only exists inside a type, nor its own import statement. A module path
+    // that names no file (`./missing`, `stdio.h`, `pkg.mod`, a C# `using` of
+    // an outside namespace) reaches the statement by its qualified name; as an
+    // edge to itself it is never retried, while a failed ref is retried by the
+    // sync that adds the file it names.
     if (ref.referenceKind === 'imports') {
       const target = this.nodeById(result.targetNodeId);
+      if (target?.kind === 'import' && target.filePath === ref.filePath) return null;
       return target && !isImportableKind(target.kind) ? null : result;
     }
 
@@ -3196,6 +3251,14 @@ export class ReferenceResolver {
       result = { ...result, targetNodeId: type.id };
     }
     if (isBoundToOutOfRepoImport(ref, this.context)) return null;
+    // A Go type embedded through a package (`clientv3.KV`) is that package's.
+    // When the package is none of the file's imports as indexed (clientv3
+    // imported unaliased as `go.etcd.io/etcd/client/v3`), a type found by its
+    // bare name is some other package's namesake.
+    if (ref.language === 'go' && isGoUnknownQualified(ref, this.context)) return null;
+    // One embedded bare that only a package the file dot-imports declares is
+    // that package's, not a namesake as near the file.
+    if (ref.language === 'go') return goDotImportedSupertype(result, ref, this.context);
     return result;
   }