@quolu/lattice 0.70.0 → 0.71.0

package/sensor/dist/resolution/callback-synthesizer.js

@@ -1,12 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SYNTH_PROGRESS_STEPS = exports.SYNTH_PASSES = void 0;
+exports.hasSynthesisPattern = hasSynthesisPattern;
 exports.synthesizeCallbackEdges = synthesizeCallbackEdges;
 const generated_detection_1 = require("../extraction/generated-detection");
 const strip_comments_1 = require("./strip-comments");
 const c_fnptr_synthesizer_1 = require("./c-fnptr-synthesizer");
 const goframe_synthesizer_1 = require("./goframe-synthesizer");
+const expo_router_synthesizer_1 = require("./expo-router-synthesizer");
+const next_router_synthesizer_1 = require("./next-router-synthesizer");
+const react_router_synthesizer_1 = require("./react-router-synthesizer");
+const tanstack_router_synthesizer_1 = require("./tanstack-router-synthesizer");
+const vue_router_synthesizer_1 = require("./vue-router-synthesizer");
+const sveltekit_synthesizer_1 = require("./sveltekit-synthesizer");
 const cooperative_yield_1 = require("./cooperative-yield");
+const tier_synthesizer_1 = require("./tier-synthesizer");
+const synth_utils_1 = require("./synth-utils");
+const import_resolver_1 = require("./import-resolver");
+const name_matcher_1 = require("./name-matcher");
 const REGISTRAR_NAME = /^(on[A-Z]\w*|subscribe|addListener|addEventListener|register|watch|listen|addCallback)$/;
 const DISPATCHER_NAME = /(emit|trigger|notify|dispatch|fire|publish|flush)/i;
 const MAX_CALLBACKS_PER_CHANNEL = 40;
@@ -15,6 +26,7 @@ const ON_RE = /\.(?:on|once|addListener)\(\s*['"]([^'"]+)['"]\s*,\s*(?:function\
 const EMIT_RE = /\.(?:emit|fire|dispatchEvent)\(\s*['"]([^'"]+)['"]/g;
 const SETSTATE_RE = /this\.setState\s*\(/;
 const FLUTTER_SETSTATE_RE = /\bsetState\s*\(/; // Flutter: setState((){…}) / this.setState
+const JS_FAMILY = ['typescript', 'javascript', 'tsx', 'jsx'];
 const JSX_TAG_RE = /<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
 const MAX_JSX_CHILDREN = 30;
 // Vue SFC templates: kebab-case child components (<el-button> → ElButton) and
@@ -85,35 +97,6 @@ function sliceLines(content, startLine, endLine) {
         return null;
     return content.split('\n').slice(startLine - 1, endLine).join('\n');
 }
-/**
- * Per-match line resolver over `src`, 1-based at `baseLine`. The inline
- * `src.slice(0, idx).split('\n').length` idiom is O(source-length) PER MATCH,
- * which goes quadratic on a match-dense source (a generated function full of
- * `.push(` calls re-scanned tens of thousands of times was most of the #1235
- * indexing wedge). Builds the newline index once — lazily, since most sources
- * never produce a match — then answers each call with a binary search.
- */
-function makeLineAt(src, baseLine) {
-    let nl = null;
-    return (idx) => {
-        if (!nl) {
-            nl = [];
-            for (let i = src.indexOf('\n'); i !== -1; i = src.indexOf('\n', i + 1))
-                nl.push(i);
-        }
-        // Count newlines strictly before idx.
-        let lo = 0;
-        let hi = nl.length;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (nl[mid] < idx)
-                lo = mid + 1;
-            else
-                hi = mid;
-        }
-        return baseLine + lo;
-    };
-}
 function registrarField(src) {
     const m = src.match(/this\.(\w+)\.(?:add|push|set)\(/);
     return m ? m[1] : null;
@@ -127,21 +110,6 @@ function dispatcherField(src) {
         return forEach[1];
     return null;
 }
-const FN_KINDS = new Set(['method', 'function', 'component']);
-/** Innermost function/method node whose line range contains `line`. */
-function enclosingFn(nodesInFile, line) {
-    let best = null;
-    for (const n of nodesInFile) {
-        if (!FN_KINDS.has(n.kind))
-            continue;
-        const end = n.endLine ?? n.startLine;
-        if (n.startLine <= line && end >= line) {
-            if (!best || n.startLine >= best.startLine)
-                best = n; // prefer the tightest (latest-starting) encloser
-        }
-    }
-    return best;
-}
 /**
  * Stream method + function nodes lazily. The synthesizers only scan-and-filter
  * down to a tiny matched subset, so materializing every function/method (which
@@ -185,7 +153,7 @@ async function fieldChannelEdges(queries, ctx, onYield) {
         const chDispatchers = dispatchers.filter((d) => d.node.filePath === reg.node.filePath && d.field === reg.field);
         if (chDispatchers.length === 0)
             continue;
-        const argRe = new RegExp(`${reg.node.name}\\s*\\(\\s*(?:this\\.)?(\\w+)`);
+        const argRe = new RegExp(`${reg.node.name}\\s*\\(\\s*(this\\.\\w+|\\w+)\\s*(?=[,)])`);
         let added = 0;
         for (const e of queries.getIncomingEdges(reg.node.id, ['calls'])) {
             if (added >= MAX_CALLBACKS_PER_CHANNEL)
@@ -199,8 +167,15 @@ async function fieldChannelEdges(queries, ctx, onYield) {
             const am = line?.match(argRe);
             if (!am)
                 continue;
-            const fn = ctx.getNodesByName(am[1]).find((n) => n.kind === 'method' || n.kind === 'function');
-            if (!fn)
+            // Reuse the resolved value at this registration site: it retains the
+            // receiver's class/inheritance and import binding, unlike a name lookup.
+            const refs = queries.getOutgoingEdges(caller.id, ['references']).filter((r) => r.line === e.line && r.metadata?.fnRef === true && r.metadata.refName === am[1]);
+            if (refs.length !== 1)
+                continue;
+            const fn = queries.getNodeById(refs[0].target);
+            if (!fn || (fn.kind !== 'method' && fn.kind !== 'function'))
+                continue;
+            if (!am[1].startsWith('this.') && fn.filePath !== caller.filePath && refs[0].metadata?.resolvedBy !== 'import')
                 continue;
             for (const disp of chDispatchers) {
                 if (disp.node.id === fn.id)
@@ -271,7 +246,7 @@ async function closureCollectionEdges(queries, ctx, onYield) {
         const hasAppend = src.includes('.append(') || src.includes('.add(') || src.includes('.push(') || src.includes('.insert(');
         if (!hasForEach && !hasAppend)
             continue;
-        const lineAt = makeLineAt(src, m.startLine ?? 1);
+        const lineAt = (0, synth_utils_1.makeLineAt)(src, m.startLine ?? 1);
         if (hasForEach) {
             CC_DISPATCH_RE.lastIndex = 0;
             let d;
@@ -345,12 +320,12 @@ async function eventEmitterEdges(ctx, onYield) {
         if (!hasEmit && !hasOn)
             continue;
         const nodesInFile = ctx.getNodesInFile(file);
-        const lineOf = makeLineAt(content, 1);
+        const lineOf = (0, synth_utils_1.makeLineAt)(content, 1);
         if (hasEmit) {
             EMIT_RE.lastIndex = 0;
             let m;
             while ((m = EMIT_RE.exec(content))) {
-                const disp = enclosingFn(nodesInFile, lineOf(m.index));
+                const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, lineOf(m.index));
                 if (!disp)
                     continue;
                 const set = emitsByEvent.get(m[1]) ?? new Set();
@@ -542,11 +517,9 @@ async function arkuiStateBuildEdges(queries, ctx, onYield) {
     let scanned255 = 0;
     const edges = [];
     const seen = new Set();
-    for (const struct of queries.iterateNodesByKind('struct')) {
+    for (const struct of queries.iterateNodesByKindIn('struct', ['arkts'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (struct.language !== 'arkts')
-            continue;
         const children = queries.getOutgoingEdges(struct.id, ['contains'])
             .map((e) => queries.getNodeById(e.target))
             .filter((n) => !!n);
@@ -884,22 +857,17 @@ async function goImplementsEdges(queries, onYield) {
     // never the whole struct kind — that array is O(nodes) on struct-heavy
     // repos like the Linux kernel (#1212).
     const goStructs = [];
-    for (const s of queries.iterateNodesByKind('struct')) {
+    for (const s of queries.iterateNodesByKindIn('struct', ['go'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (s.language === 'go')
-            goStructs.push(s);
+        goStructs.push(s);
     }
     const structMethods = new Map();
     for (const s of goStructs)
         structMethods.set(s.id, methodNameSet(s.id));
-    for (const iface of queries.iterateNodesByKind('interface')) {
+    for (const iface of queries.iterateNodesByKindIn('interface', ['go'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if ((++scanned255 & 63) === 0)
-            await onYield();
-        if (iface.language !== 'go')
-            continue;
         const want = methodNameSet(iface.id);
         if (want.size === 0)
             continue; // empty interface (`any`) — would match everything
@@ -952,9 +920,10 @@ async function goImplementsEdges(queries, onYield) {
  *
  * Go guarantees a method's receiver type is declared in the SAME PACKAGE as the
  * method, and a Go package is a single directory — so this is a deterministic
- * structural link, not a heuristic: find the same-named type in the method's own
- * directory and add the missing `contains` edge (no `provenance: 'heuristic'`,
- * matching the same-file edges extraction already emits). Skips methods that
+ * structural link, not a heuristic: find the same-named type in the method's
+ * own directory and add the missing `contains` edge with no provenance, matching
+ * same-file extraction. Tag synthesis ownership so an incremental
+ * refresh can replace it alongside implicit `implements`. Skips methods that
  * already have a type parent (the same-file case). (#583, cross-file half)
  */
 async function goCrossFileMethodContainsEdges(queries, onYield) {
@@ -966,13 +935,9 @@ async function goCrossFileMethodContainsEdges(queries, onYield) {
         const i = p.replace(/\\/g, '/').lastIndexOf('/');
         return i >= 0 ? p.slice(0, i) : '';
     };
-    for (const method of queries.iterateNodesByKind('method')) {
-        if ((++scanned255 & 63) === 0)
-            await onYield();
+    for (const method of queries.iterateNodesByKindIn('method', ['go'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (method.language !== 'go')
-            continue;
         // The receiver type is encoded in the method's qualifiedName as `Recv::name`
         // (extraction sets `${receiverType}::${name}` for receiver methods).
         const qn = method.qualifiedName;
@@ -1007,7 +972,8 @@ async function goCrossFileMethodContainsEdges(queries, onYield) {
         if (seen.has(key))
             continue;
         seen.add(key);
-        edges.push({ source: owner.id, target: method.id, kind: 'contains', line: method.startLine });
+        edges.push({ source: owner.id, target: method.id, kind: 'contains', line: method.startLine,
+            metadata: { synthesizedBy: 'go-method-contains' } });
     }
     return edges;
 }
@@ -1106,10 +1072,31 @@ async function interfaceOverrideEdges(queries, onYield) {
         methodsMemo.set(classId, methods);
         return methods;
     };
+    // A Swift protocol's methods live in its extensions: requirements are not
+    // extracted as methods, and `extension EventMonitor { func request(…) }` is
+    // where the default implementations a conformer overrides are. A class-kind
+    // node sharing a protocol's name is one of its extensions.
+    const protocolMemo = new Map();
+    const baseMethodsOf = (base) => {
+        if (base.language !== 'swift' || base.kind !== 'interface')
+            return methodsOf(base.id);
+        const hit = protocolMemo.get(base.id);
+        if (hit)
+            return hit;
+        const methods = [
+            ...methodsOf(base.id),
+            ...queries
+                .getNodesByName(base.name)
+                .filter((n) => n.language === 'swift' && n.kind === 'class')
+                .flatMap((n) => methodsOf(n.id)),
+        ];
+        protocolMemo.set(base.id, methods);
+        return methods;
+    };
     // Concrete-side kinds vary by language: `class` covers Java / Kotlin /
     // C# / TS / Swift-classes / Scala-classes; `struct` covers Swift value
     // types that conform to protocols. Iterate both.
-    const concreteKinds = ['class', 'struct'];
+    const concreteKinds = ['class', 'struct', 'union'];
     for (const kind of concreteKinds) {
         for (const cls of queries.iterateNodesByKind(kind)) {
             if ((++scanned255 & 63) === 0)
@@ -1140,7 +1127,7 @@ async function interfaceOverrideEdges(queries, onYield) {
                         implByName.set(m.name, [m]);
                 }
                 let added = 0;
-                for (const bm of methodsOf(base.id)) {
+                for (const bm of baseMethodsOf(base)) {
                     if (added >= MAX_CALLBACKS_PER_CHANNEL)
                         break;
                     for (const m of implByName.get(bm.name) ?? []) {
@@ -1206,11 +1193,9 @@ async function goGrpcStubImplEdges(queries, onYield) {
     const methodNamesByStruct = new Map();
     const methodNodesByStruct = new Map();
     const goStructs = [];
-    for (const s of queries.iterateNodesByKind('struct')) {
+    for (const s of queries.iterateNodesByKindIn('struct', ['go'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (s.language !== 'go')
-            continue;
         goStructs.push(s);
         const ms = queries
             .getOutgoingEdges(s.id, ['contains'])
@@ -1282,6 +1267,60 @@ async function goGrpcStubImplEdges(queries, onYield) {
     }
     return edges;
 }
+/** Kinds a JSX tag can name. A tag that resolves only to a type is markup we drop. */
+const JSX_CHILD_KINDS = new Set(['component', 'function', 'class']);
+/**
+ * The languages a JSX tag can plausibly name a component in. Preferred over a
+ * same-named symbol in another language, never required — a React Native tag
+ * whose only match is the native class it bridges to (`requireNativeComponent`)
+ * still links there.
+ */
+const JSX_CHILD_LANGUAGES = [...JS_FAMILY, 'vue', 'svelte'];
+/** `localName` → the project file it is imported from, for one file's imports. */
+function importedFrom(ctx, file, language) {
+    const out = new Map();
+    for (const im of ctx.getImportMappings(file, language)) {
+        // The mappings name the module as written; the file it is comes from the
+        // same resolution the import resolver uses (aliases, extensions, index files).
+        const resolved = im.resolvedPath ?? (0, import_resolver_1.resolveImportPath)(im.source, file, language, ctx);
+        if (resolved)
+            out.set(im.localName, resolved);
+    }
+    return out;
+}
+/**
+ * The component a JSX tag names, among every node that shares the name.
+ *
+ * A tag is written in one file, and that file already says which `FrameCard` it
+ * means: the one it declares, or the one it imports. Taking the FIRST node of
+ * that name — which is what this did — is a coin flip once a name repeats, and
+ * it costs twice over. The parent gets an edge to a component it never renders,
+ * and the component it does render is left with no caller at all, so every walk
+ * back from that subtree dead-ends: on an Expo app whose `<FrameCard/>` was one
+ * of two, the folder sheet's `openBackgroundNoiseDetail` stood alone on Screens
+ * with no screen behind it, while the edge pointed at an unrelated card in
+ * another sheet.
+ *
+ * Same file first — a small component declared beside its use is the commonest
+ * shape, and the one an import can never disambiguate. Then the file the name
+ * is imported from. Then the language, which only decides a tie: a `.tsx` tag
+ * naming both a TS component and a same-named Swift class means the TS one.
+ */
+function jsxChild(ctx, name, file, importsOf) {
+    const candidates = ctx.getNodesByName(name).filter((n) => JSX_CHILD_KINDS.has(n.kind));
+    if (candidates.length <= 1)
+        return candidates[0];
+    const local = candidates.find((n) => n.filePath === file);
+    if (local)
+        return local;
+    const from = importsOf().get(name);
+    if (from) {
+        const imported = candidates.find((n) => n.filePath === from);
+        if (imported)
+            return imported;
+    }
+    return candidates.find((n) => JSX_CHILD_LANGUAGES.includes(n.language)) ?? candidates[0];
+}
 /**
  * Phase 5: React JSX child rendering. A component that returns `<Child .../>`
  * mounts Child — React calls it — but JSX instantiation isn't a static call edge,
@@ -1305,7 +1344,14 @@ async function reactJsxChildEdges(ctx, onYield) {
         const content = ctx.readFile(file);
         if (!content || (!content.includes('</') && !content.includes('/>')))
             continue; // JSX-file gate
-        const parents = ctx.getNodesInFile(file).filter((n) => PARENT_KINDS.has(n.kind));
+        // File-level language gate, not merely a project-level one: mixed C/JS
+        // monorepos must not interpret `"<Foo/>"` inside C as JSX (#1560).
+        const parents = ctx.getNodesInFile(file).filter((n) => PARENT_KINDS.has(n.kind) && JS_FAMILY.includes(n.language));
+        if (parents.length === 0)
+            continue;
+        // Read once per file, and only when a name actually turns out ambiguous.
+        let imports = null;
+        const importsOf = () => (imports ??= importedFrom(ctx, file, parents[0].language));
         for (const parent of parents) {
             const src = sliceLines(content, parent.startLine, parent.endLine);
             if (!src || (!src.includes('</') && !src.includes('/>')))
@@ -1319,8 +1365,8 @@ async function reactJsxChildEdges(ctx, onYield) {
             for (const name of names) {
                 if (added >= MAX_JSX_CHILDREN)
                     break;
-                const child = ctx.getNodesByName(name).find((n) => n.kind === 'component' || n.kind === 'function' || n.kind === 'class');
-                if (!child || child.id === parent.id)
+                const child = jsxChild(ctx, name, file, importsOf);
+                if (!child || child.id === parent.id || (0, name_matcher_1.crossesCodeBoundary)(parent.language, child.language))
                     continue;
                 const key = `${parent.id}>${child.id}`;
                 if (seen.has(key))
@@ -1402,7 +1448,8 @@ async function vueTemplateEdges(ctx, onYield) {
         }
         let added = 0;
         const addEdge = (target, meta) => {
-            if (added >= MAX_JSX_CHILDREN || !target || target.id === comp.id)
+            if (added >= MAX_JSX_CHILDREN || !target || target.id === comp.id ||
+                (0, name_matcher_1.crossesCodeBoundary)(comp.language, target.language))
                 return;
             const k = `${comp.id}>${target.id}>${meta.synthesizedBy}`;
             if (seen.has(k))
@@ -1479,10 +1526,13 @@ async function vueTemplateEdges(ctx, onYield) {
  *     DeviceEventEmitter.addListener("locationUpdate", handler);
  *
  * Synthesize: native dispatch site → JS handler, keyed by the literal
- * event name. Only matches NAMED handlers (the existing `ON_RE` named-
- * capture form). Inline arrow handlers like `addListener('x', d => …)`
- * aren't named at extraction time and would need link-through-body
- * support; matches the deliberate scope of the in-language synthesizer.
+ * event name. A NAMED handler (`addListener('x', handleX)`) is the target
+ * when it is a node; an unnamed one — a parameter passed through, or an
+ * inline `(data) => {…}` written in a `useEffect` — is attributed to the
+ * enclosing function, where the event demonstrably lands. (The in-language
+ * synthesizer stays named-only; this channel pairs across a language
+ * boundary on a literal, which is the evidence that makes the wider
+ * attribution safe.)
  *
  * Provenance `'heuristic'`, synthesizedBy `'rn-event-channel'`.
  */
@@ -1522,9 +1572,9 @@ async function rnEventEdges(ctx, onYield) {
         if (!content)
             continue;
         const nodesInFile = ctx.getNodesInFile(file);
-        const lineOf = makeLineAt(content, 1);
+        const lineOf = (0, synth_utils_1.makeLineAt)(content, 1);
         const addDispatcher = (event, line) => {
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 return;
             const set = nativeDispatchersByEvent.get(event) ?? new Set();
@@ -1590,6 +1640,8 @@ async function rnEventEdges(ctx, onYield) {
             // function (the abstraction layer), giving a reachability-correct
             // hop even when the actual user-side handler lives one call up.
             const ADDLISTENER_ANY = /\.(?:on|once|addListener)\(\s*['"]([^'"]+)['"]\s*,\s*([A-Za-z_][\w.]*)/g;
+            // The inline form: `.addListener('x', (data) => {…})` / `function () {…}`.
+            const ADDLISTENER_INLINE = /\.(?:on|once|addListener)\(\s*['"]([^'"]+)['"]\s*,\s*(?:async\s*)?(?:\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>|function\s*\()/g;
             ADDLISTENER_ANY.lastIndex = 0;
             let m;
             while ((m = ADDLISTENER_ANY.exec(content))) {
@@ -1607,7 +1659,7 @@ async function rnEventEdges(ctx, onYield) {
                     // Fall back to the enclosing function — the subscribe-wrapper
                     // pattern means the event fires THROUGH this function on its
                     // way to user code. Reachability-correct attribution.
-                    const enclosing = enclosingFn(nodesInFile, lineOf(m.index));
+                    const enclosing = (0, synth_utils_1.enclosingFn)(nodesInFile, lineOf(m.index));
                     targetId = enclosing?.id ?? null;
                 }
                 if (!targetId) {
@@ -1637,6 +1689,26 @@ async function rnEventEdges(ctx, onYield) {
                 map.set(targetId, `${file}:${lineOf(m.index)}`);
                 jsHandlersByEvent.set(event, map);
             }
+            // Inline listeners — the shape a React component registers inside a
+            // `useEffect`: `nativeEmitter.addListener('onCaptureComplete', (data) =>
+            // { … router.push('/review') })`. There is no handler symbol to name,
+            // so the subscription is attributed to the enclosing function exactly
+            // as the unnamed-argument form above is: the native event lands in that
+            // component, and its body is where a reader looks next. This channel
+            // only — the in-language synthesizer keeps its named-handler policy.
+            ADDLISTENER_INLINE.lastIndex = 0;
+            while ((m = ADDLISTENER_INLINE.exec(content))) {
+                const event = m[1];
+                if (!event)
+                    continue;
+                const enclosing = (0, synth_utils_1.enclosingFn)(nodesInFile, lineOf(m.index));
+                if (!enclosing)
+                    continue;
+                const map = jsHandlersByEvent.get(event) ?? new Map();
+                if (!map.has(enclosing.id))
+                    map.set(enclosing.id, `${file}:${lineOf(m.index)}`);
+                jsHandlersByEvent.set(event, map);
+            }
         }
     }
     const edges = [];
@@ -1783,11 +1855,9 @@ async function rnCrossPlatformEdges(queries, onYield) {
     // impls in ≥2 native languages can pair, so the per-method JS-caller check
     // below only runs for genuine cross-platform candidates.
     const byName = new Map();
-    for (const m of queries.iterateNodesByKind('method')) {
+    for (const m of queries.iterateNodesByKindIn('method', [...NATIVE])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (!NATIVE.has(m.language))
-            continue;
         const key = norm(m.name);
         const arr = byName.get(key);
         if (arr)
@@ -1919,21 +1989,18 @@ async function mybatisJavaXmlEdges(queries, onYield) {
     // stream below. Same rowid stream order as matching inline, so the edge
     // output is byte-identical when mappers do exist.
     const xmlMethods = [];
-    for (const m of queries.iterateNodesByKind('method')) {
+    for (const m of queries.iterateNodesByKindIn('method', ['xml'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (m.language === 'xml')
-            xmlMethods.push(m);
+        xmlMethods.push(m);
     }
     if (xmlMethods.length === 0)
         return edges;
     // Index Java methods by `<ClassName>::<methodName>` for O(1) lookup.
     const javaIndex = new Map();
-    for (const m of queries.iterateNodesByKind('method')) {
+    for (const m of queries.iterateNodesByKindIn('method', ['java', 'kotlin'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (m.language !== 'java' && m.language !== 'kotlin')
-            continue;
         const parts = m.qualifiedName.split('::');
         const last = parts[parts.length - 1];
         const cls = parts[parts.length - 2];
@@ -2065,11 +2132,9 @@ async function ginMiddlewareChainEdges(queries, ctx, onYield) {
     let scannedFiles = 0;
     // 1. Find the chain dispatcher(s): a Go method that invokes a `handlers` slice by index.
     const dispatchers = [];
-    for (const n of queries.iterateNodesByKind('method')) {
+    for (const n of queries.iterateNodesByKindIn('method', ['go'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (n.language !== 'go')
-            continue;
         const content = ctx.readFile(n.filePath);
         const src = content && sliceLines(content, n.startLine, n.endLine);
         if (src && GIN_DISPATCH_RE.test(src))
@@ -2203,12 +2268,17 @@ async function svelteKitLoadEdges(ctx, onYield) {
             if (!allFiles.has(loaderFile))
                 continue;
             for (const hook of ctx.getNodesInFile(loaderFile)) {
-                if (!HOOK_KINDS.has(hook.kind) || !HOOKS.has(hook.name))
+                // `load` and `actions` by name, and every function the loader file
+                // declares — a form action is an arrow inside `actions`, and it is a
+                // node of its own (`default`, `logout`), where the redirect that ends
+                // the submission is actually written.
+                const named = HOOK_KINDS.has(hook.kind) && HOOKS.has(hook.name);
+                if (!named && hook.kind !== 'function' && hook.kind !== 'method')
                     continue;
                 edges.push({
                     source: page.id,
                     target: hook.id,
-                    kind: 'references',
+                    kind: 'calls',
                     line: page.startLine,
                     provenance: 'heuristic',
                     metadata: {
@@ -2306,12 +2376,38 @@ async function reduxThunkEdges(queries, ctx, onYield) {
 // the SAME file (the cross-file barrel-namespace variant, e.g. trezor's getMethod, is
 // deferred). Gated on a real object literal with ≥2 entries that RESOLVE to callables (a
 // `{ width: 5 }` literal resolves to nothing → no edges); fan-out capped.
-const REGISTRY_ASSIGN_RE = /(?:(?:const|let|var)\s+([A-Za-z_$][\w$]*)|((?:this\.)?[A-Za-z_$][\w$]*))\s*=\s*\{/g;
-const REGISTRY_DISPATCH_RE = /(?:\bnew\s+)?((?:this\.)?[A-Za-z_$][\w$]*)\s*\[\s*([A-Za-z_$][\w$.]*)\s*\]\s*(?:\(|\.[A-Za-z_$])/g;
+// Both scans only START a name at an identifier's first character (or at a `this.`): the
+// engine otherwise retries the greedy name at every later character of every identifier in
+// the file. A match found from inside an identifier always has one from the identifier's
+// start (same name tail, same continuation), so the result is unchanged — except where the
+// scan itself resumes mid-identifier after a dispatch ending in `.method`, which
+// `nextRegistryDispatch` covers with the unguarded pattern.
+const REGISTRY_NAME_START = String.raw `(?:(?<![A-Za-z_$])(?<![A-Za-z_$][\w$]+)|(?=this\.))`;
+const REGISTRY_ASSIGN_RE = new RegExp(String.raw `(?:(?:const|let|var)\s+([A-Za-z_$][\w$]*)|${REGISTRY_NAME_START}((?:this\.)?[A-Za-z_$][\w$]*))\s*=\s*\{`, 'g');
+const REGISTRY_DISPATCH_SRC = String.raw `(?:\bnew\s+)?((?:this\.)?[A-Za-z_$][\w$]*)\s*\[\s*([A-Za-z_$][\w$.]*)\s*\]\s*(?:\(|\.[A-Za-z_$])`;
+const REGISTRY_DISPATCH_AT = new RegExp(REGISTRY_DISPATCH_SRC, 'y');
+// `\bnew` can follow a `$` inside an identifier run, hence the extra `(?<!\w)` start.
+const REGISTRY_DISPATCH_RE = new RegExp(String.raw `(?:(?<!\w)|${REGISTRY_NAME_START})${REGISTRY_DISPATCH_SRC}`, 'g');
+const IDENT_RUN_CHAR = /[\w$]/;
 const REGISTRY_MIN_ENTRIES = 2;
 const REGISTRY_FANOUT_CAP = 40;
 const REGISTRY_CLASS_ENTRY = new Set(['execute', 'run', 'handle', 'perform', 'process', 'call', 'apply', 'dispatch']);
 const REGISTRY_JS_EXT = /\.(?:ts|tsx|js|jsx|mjs|cjs)$/;
+/** The first registry dispatch at or after `from`, exactly as a `g` scan of the unguarded
+ *  pattern resuming at `from` would find it. */
+function nextRegistryDispatch(src, from) {
+    let at = from;
+    if (at > 0 && at < src.length && IDENT_RUN_CHAR.test(src[at - 1]) && IDENT_RUN_CHAR.test(src[at])) {
+        for (; at < src.length && IDENT_RUN_CHAR.test(src[at]); at++) {
+            REGISTRY_DISPATCH_AT.lastIndex = at;
+            const m = REGISTRY_DISPATCH_AT.exec(src);
+            if (m)
+                return m;
+        }
+    }
+    REGISTRY_DISPATCH_RE.lastIndex = at;
+    return REGISTRY_DISPATCH_RE.exec(src);
+}
 /** From the index of an opening `{`, return the brace-balanced body up to its matching `}`. */
 function braceBody(src, openIdx) {
     let depth = 0;
@@ -2400,13 +2496,12 @@ async function objectRegistryEdges(ctx, onYield) {
         const safe = (0, strip_comments_1.stripCommentsForRegex)(content, /\.(?:jsx?|mjs|cjs)$/.test(file) ? 'javascript' : 'typescript');
         // 1. Dispatch sites: `(new )?<ref>[<ident-key>]` followed by a call or a chained method.
         //    A quoted-string key (`['save']`) does NOT match — that's a static access, not dispatch.
-        REGISTRY_DISPATCH_RE.lastIndex = 0;
+        const lineOf = (0, synth_utils_1.makeLineAt)(safe, 1);
         const dispatches = [];
-        let dm;
-        while ((dm = REGISTRY_DISPATCH_RE.exec(safe))) {
+        for (let dm = nextRegistryDispatch(safe, 0); dm; dm = nextRegistryDispatch(safe, dm.index + dm[0].length)) {
             const win = safe.slice(dm.index, dm.index + 160);
             const cm = /\]\s*\([^)]*\)\s*\.\s*([A-Za-z_$][\w$]*)/.exec(win) || /\]\s*\.\s*([A-Za-z_$][\w$]*)/.exec(win);
-            dispatches.push({ ref: dm[1], line: safe.slice(0, dm.index).split('\n').length, chained: cm ? cm[1] : null });
+            dispatches.push({ ref: dm[1], line: lineOf(dm.index), chained: cm ? cm[1] : null });
         }
         if (!dispatches.length)
             continue;
@@ -2427,7 +2522,7 @@ async function objectRegistryEdges(ctx, onYield) {
                 continue;
             const names = registryEntryNames(body); // depth-0 `key: Identifier` entries only
             if (names.length >= REGISTRY_MIN_ENTRIES) {
-                registries.set(lhs, { names, line: safe.slice(0, am.index).split('\n').length });
+                registries.set(lhs, { names, line: lineOf(am.index) });
             }
         }
         if (!registries.size)
@@ -2438,7 +2533,7 @@ async function objectRegistryEdges(ctx, onYield) {
             const reg = registries.get(norm(d.ref));
             if (!reg)
                 continue;
-            const disp = enclosingFn(nodesInFile, d.line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, d.line);
             if (!disp)
                 continue;
             let added = 0;
@@ -2597,7 +2692,7 @@ async function piniaStoreEdges(ctx, onYield) {
                 continue;
             const method = cm[2];
             const line = safe.slice(0, cm.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line) ?? fallbackDispatcher;
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line) ?? fallbackDispatcher;
             if (!disp)
                 continue;
             const target = ctx
@@ -2695,7 +2790,7 @@ async function vuexDispatchEdges(ctx, onYield) {
         while ((m = VUEX_DISPATCH_RE.exec(safe)) && added < VUEX_FANOUT_CAP) {
             const key = m[1];
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line) ?? fallback;
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line) ?? fallback;
             if (!disp)
                 continue;
             const target = resolve(key, file);
@@ -2800,7 +2895,7 @@ async function celeryDispatchEdges(ctx, onYield) {
         while ((m = CELERY_DISPATCH_RE.exec(safe)) && added < CELERY_FANOUT_CAP) {
             const name = m[1];
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 continue; // module-level dispatch — no source symbol to attribute
             const target = resolve(name, file);
@@ -2942,7 +3037,7 @@ async function springEventEdges(ctx, onYield) {
             if (!targets || !targets.length)
                 continue;
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 continue;
             for (const target of targets) {
@@ -3070,7 +3165,7 @@ async function mediatrDispatchEdges(ctx, onYield) {
             if (!MEDIATR_RECEIVER_RE.test(m[1]))
                 continue; // not a mediator (MessagingCenter, HttpClient, …)
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 continue;
             const type = resolveMediatrArgType(m[2], safeLines, disp.startLine, line);
@@ -3170,7 +3265,7 @@ async function sidekiqDispatchEdges(ctx, onYield) {
         let added = 0;
         while ((m = SIDEKIQ_DISPATCH_RE.exec(safe)) && added < SIDEKIQ_FANOUT_CAP) {
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 continue;
             const target = resolve(m[1]);
@@ -3230,6 +3325,10 @@ const ERLANG_BEHAVIOUR_FANOUT_CAP = 24;
  */
 function erlangArityAt(src, openIdx) {
     let depth = 1;
+    // `<<1,2,3>>` binary literals: commas inside are element separators, not
+    // argument separators. Tracked separately from bracket depth because the
+    // single-char `<`/`>` comparison operators must stay inert (#1358).
+    let binDepth = 0;
     let commas = 0;
     let sawArg = false;
     const limit = Math.min(src.length, openIdx + 4000);
@@ -3252,6 +3351,17 @@ function erlangArityAt(src, openIdx) {
             sawArg = true;
             continue;
         }
+        if (ch === '<' && src[i + 1] === '<') {
+            binDepth++;
+            i++;
+            sawArg = true;
+            continue;
+        }
+        if (ch === '>' && src[i + 1] === '>' && binDepth > 0) {
+            binDepth--;
+            i++;
+            continue;
+        }
         if (ch === '(' || ch === '[' || ch === '{') {
             depth++;
             sawArg = true;
@@ -3263,7 +3373,7 @@ function erlangArityAt(src, openIdx) {
                 return sawArg ? commas + 1 : 0;
             continue;
         }
-        if (ch === ',' && depth === 1) {
+        if (ch === ',' && depth === 1 && binDepth === 0) {
             commas++;
             continue;
         }
@@ -3347,13 +3457,11 @@ async function nixOptionPathEdges(queries, onYield) {
     const byFile = new Map();
     let scanned = 0;
     for (const kind of ['variable', 'function']) {
-        for (const node of queries.iterateNodesByKind(kind)) {
+        for (const node of queries.iterateNodesByKindIn(kind, ['nix'])) {
             if ((++scanned255 & 63) === 0)
                 await onYield();
             if ((++scanned & 0x3fff) === 0 && onYield)
                 await onYield();
-            if (node.language !== 'nix')
-                continue;
             const segs = nixLeadingPlainSegments(node.name);
             if (segs.length === 0)
                 continue;
@@ -3378,7 +3486,7 @@ async function nixOptionPathEdges(queries, onYield) {
     // own namespace (`attrsOf (submodule { options = ...; })`) — its internals
     // are not globally addressable, so the sentinel blocks registration below it
     // while still excluding the region from write candidates.
-    const SUBMODULE = 'submodule';
+    const SUBMODULE = '\u0000submodule';
     const decls = new Map();
     const writes = [];
     const register = (path, rec) => {
@@ -3468,11 +3576,10 @@ async function erlangBehaviourDispatchEdges(queries, ctx, onYield) {
     // Cheap language gate: no Erlang modules → no cost beyond one streamed
     // kind scan (never a materialized array of every namespace — #1212).
     const erlangModules = [];
-    for (const n of queries.iterateNodesByKind('namespace')) {
+    for (const n of queries.iterateNodesByKindIn('namespace', ['erlang'])) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (n.language === 'erlang')
-            erlangModules.push(n);
+        erlangModules.push(n);
     }
     if (erlangModules.length === 0)
         return [];
@@ -3519,12 +3626,18 @@ async function erlangBehaviourDispatchEdges(queries, ctx, onYield) {
     }
     if (declaringBehaviours.size === 0)
         return [];
-    // Implementer target lookup, lazy per (behaviour, fn): implementers come
-    // from the `implements` edges extraction resolved, and the target is the
-    // implementer module's own exported `fn` function node.
+    // Implementer target lookup, lazy per (behaviour, fn, arity): implementers
+    // come from the `implements` edges extraction resolved, and the target is
+    // the implementer module's own exported `fn` node OF THE SITE'S ARITY —
+    // function qualifiedNames carry arity (`mod::fn/2`, #1610), so the arity the
+    // dispatch site used selects among same-named definitions.
     const targetCache = new Map();
-    const targetsOf = (behaviour, fn) => {
-        const cacheKey = `${behaviour.id}#${fn}`;
+    const qnArity = (qn) => {
+        const m = /\/(\d{1,3})$/.exec(qn);
+        return m ? Number(m[1]) : -1;
+    };
+    const targetsOf = (behaviour, fn, arity) => {
+        const cacheKey = `${behaviour.id}#${fn}/${arity}`;
         let targets = targetCache.get(cacheKey);
         if (targets)
             return targets;
@@ -3535,7 +3648,10 @@ async function erlangBehaviourDispatchEdges(queries, ctx, onYield) {
                 continue;
             const fnNode = ctx
                 .getNodesInFile(impl.filePath)
-                .find((n) => n.kind === 'function' && n.name === fn && n.isExported !== false);
+                .find((n) => n.kind === 'function' &&
+                n.name === fn &&
+                qnArity(n.qualifiedName) === arity &&
+                n.isExported !== false);
             if (fnNode)
                 targets.push(fnNode);
         }
@@ -3570,11 +3686,11 @@ async function erlangBehaviourDispatchEdges(queries, ctx, onYield) {
             if (!behaviours || behaviours.length !== 1)
                 continue; // unknown or ambiguous
             const behaviour = behaviours[0];
-            const targets = targetsOf(behaviour, fn);
+            const targets = targetsOf(behaviour, fn, arity);
             if (targets.length === 0 || targets.length > ERLANG_BEHAVIOUR_FANOUT_CAP)
                 continue;
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 continue;
             for (const target of targets) {
@@ -3729,7 +3845,7 @@ async function laravelEventEdges(ctx, onYield) {
             if (!targets)
                 continue;
             const line = safe.slice(0, m.index).split('\n').length;
-            const disp = enclosingFn(nodesInFile, line);
+            const disp = (0, synth_utils_1.enclosingFn)(nodesInFile, line);
             if (!disp)
                 continue;
             for (const target of targets.values()) {
@@ -3753,27 +3869,43 @@ async function laravelEventEdges(ctx, onYield) {
     }
     return edges;
 }
-/**
- * Synthesize dispatcher→callback edges (field observers + EventEmitters +
- * React re-render + JSX children + Vue templates + SvelteKit load + RN event
- * channel + Fabric native-impl + MyBatis Java↔XML + Gin middleware chain +
- * Redux-thunk dispatch chain + object-literal registry dispatch + RTK Query
- * generated-hook → endpoint + Pinia useStore().action() + Vuex string dispatch +
- * Celery task .delay()/.apply_async() → task body + Spring publishEvent → @EventListener +
- * MediatR Send/Publish → IRequestHandler/INotificationHandler +
- * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
- * Returns the count added. Never throws into indexing — callers wrap in try/catch.
- */
-/**
- * Number of progress steps synthesizeCallbackEdges reports: one per `__mark()`
- * call (every synthesis pass, plus the dedupe-merge and edge-insert steps).
- * Cosmetic only — drift just makes the progress bar end early or jump — and a
- * test pins it to the actual step count (registry passes + the fixed
- * pre/post marks) so adding a pass without bumping this fails loudly instead
- * of silently skewing the bar.
- */
-const JS_FAMILY = ['typescript', 'javascript', 'tsx', 'jsx'];
 const ALWAYS = () => true;
+/** Conservative input gates for SYNTH_PASSES; keep these in sync when adding a pass. */
+function hasSynthesisPattern(filePath, content) {
+    // These passes consume declarations/layouts as well as dispatch sites. A
+    // header or markup edit can change a channel whose endpoints live elsewhere.
+    if (/\.(?:vue|svelte|dfm|fmx|nix|xml)$/.test(filePath))
+        return true;
+    if (/\.(?:c|h|cc|cpp|cxx|hpp|hh|hxx|cppm|ipp|inl|tcc|def|inc|tbl)$/i.test(filePath) &&
+        /\b(?:struct|union|typedef|virtual|override)\b|#\s*(?:include|define|if)|=|->|\[/.test(content))
+        return true;
+    if (/\b(?:class|interface|protocol|trait|impl|extends|implements|expect|actual)\b/.test(content))
+        return true;
+    if (/\.go$/.test(filePath) && /\b(?:struct|interface)\b|\bfunc\s*\(/.test(content))
+        return true;
+    if ((0, tier_synthesizer_1.hasCrossTierPattern)(content) || (0, tier_synthesizer_1.hasTestRequestPattern)(filePath, content))
+        return true;
+    if (/\b(?:render|build|setState|defineStore|createStore|createApi|Store|href|sendEvent|sendEventWithName)\b|<\/|\/>/.test(content))
+        return true;
+    if (/\.(?:forEach|append|add|push|insert|fire|dispatchEvent|addListener|Use|GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|Any|Handle)\s*\(/.test(content))
+        return true;
+    if (/[\w$]\s*\[\s*[A-Za-z_$]/.test(content) || /\b(?:dispatch|commit)\s*\(/.test(content))
+        return true;
+    const patterns = [THUNK_DECL_RE, CELERY_TASK_DECORATOR_RE, CELERY_DISPATCH_RE,
+        SPRING_LISTENER_ANNO_RE, SPRING_APP_LISTENER_RE, SPRING_PUBLISH_RE,
+        MEDIATR_HANDLER_BASE_RE, MEDIATR_DISPATCH_RE, SIDEKIQ_WORKER_RE, SIDEKIQ_DISPATCH_RE,
+        ERLANG_CALLBACK_DECL_RE, ERLANG_DISPATCH_RE, LARAVEL_DISPATCH_RE, ARKUI_EMITTER_CALL_RE,
+        ARKUI_ROUTER_RE];
+    for (const re of patterns) {
+        re.lastIndex = 0;
+        const matches = re.test(content);
+        re.lastIndex = 0;
+        if (matches)
+            return true;
+    }
+    // Field-backed observers use method-name gates rather than fixed call names.
+    return (content.match(/[A-Za-z_$][\w$]*/g) ?? []).some((name) => REGISTRAR_NAME.test(name) || DISPATCHER_NAME.test(name));
+}
 /**
  * The independent passes, in MERGE ORDER — the first-seen dedup in
  * synthesizeCallbackEdges follows this array, so reordering entries changes
@@ -3784,9 +3916,18 @@ const ALWAYS = () => true;
 exports.SYNTH_PASSES = [
     { name: 'fieldEdges', gate: ALWAYS, run: (q, c, y) => fieldChannelEdges(q, c, y) },
     { name: 'closureCollEdges', gate: ALWAYS, run: (q, c, y) => closureCollectionEdges(q, c, y) },
+    // Cross-tier channels — a client's `fetch('/api/x')` onto its own route,
+    // a queue job onto its consumer, a bus / socket event onto its handler.
+    // Before the in-process emitter pass: the same (source, target) pair
+    // keeps the more specific edge — the one that says which tier it crosses.
+    { name: 'tierEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => (0, tier_synthesizer_1.crossTierEdges)(c, y) },
+    // A Spring / Laravel test's request (`mockMvc.perform(post("/x"))`,
+    // `$this->postJson('api/x')`) onto the route it reaches, so the handler
+    // counts as tested.
+    { name: 'testRequestEdges', gate: (has) => has('java', 'kotlin', 'php'), run: (_q, c, y) => (0, tier_synthesizer_1.testRequestEdges)(c, y) },
     { name: 'emitterEdges', gate: ALWAYS, run: (_q, c, y) => eventEmitterEdges(c, y) },
     { name: 'renderEdges', gate: ALWAYS, run: (q, c, y) => reactRenderEdges(q, c, y) },
-    { name: 'jsxEdges', gate: ALWAYS, run: (_q, c, y) => reactJsxChildEdges(c, y) },
+    { name: 'jsxEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => reactJsxChildEdges(c, y) },
     { name: 'vueEdges', gate: (has) => has('vue'), run: (_q, c, y) => vueTemplateEdges(c, y) },
     { name: 'svelteKitEdges', gate: (has) => has('svelte'), run: (_q, c, y) => svelteKitLoadEdges(c, y) },
     { name: 'pascalEdges', gate: ALWAYS, run: (_q, c, y) => pascalFormEdges(c, y) },
@@ -3840,8 +3981,31 @@ exports.SYNTH_PASSES = [
         run: (q, c, y, sub) => (0, c_fnptr_synthesizer_1.cFnPointerDispatchEdges)(q, c, y, sub),
     },
     { name: 'goframeEdges', gate: (has) => has('go'), run: (_q, c, y) => (0, goframe_synthesizer_1.goframeRouteEdges)(c, y) },
+    // `router.push(await helper())` — the helper's return literals are the screens.
+    { name: 'expoRouterReturnEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => (0, expo_router_synthesizer_1.expoRouterReturnEdges)(c, y) },
+    // `<Link href="/x">` / an internal `<a href>` — markup, not a call; the component navigates.
+    { name: 'nextLinkEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => (0, next_router_synthesizer_1.nextLinkEdges)(c, y) },
+    { name: 'reactRouterLinkEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => (0, react_router_synthesizer_1.reactRouterLinkEdges)(c, y) },
+    { name: 'tanstackLinkEdges', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => (0, tanstack_router_synthesizer_1.tanstackLinkEdges)(c, y) },
+    { name: 'vueRouterLinkEdges', gate: (has) => has('vue', ...JS_FAMILY), run: (_q, c, y) => (0, vue_router_synthesizer_1.vueRouterLinkEdges)(c, y) },
+    { name: 'svelteKitPageEdges', gate: (has) => has('svelte'), run: (_q, c, y) => (0, sveltekit_synthesizer_1.svelteKitPageComponentEdges)(c, y) },
+    { name: 'svelteKitLinkEdges', gate: (has) => has('svelte'), run: (_q, c, y) => (0, sveltekit_synthesizer_1.svelteKitLinkEdges)(c, y) },
     { name: 'nixOptionEdges', gate: (has) => has('nix'), run: (q, _c, y) => nixOptionPathEdges(q, y) },
 ];
+/**
+ * Rough relative cost of the passes that run longest on large repos. Only
+ * the pooled dispatch ORDER reads it — heaviest first, so the longest passes
+ * start before the short ones fill the workers; unlisted passes keep registry
+ * order after these. A wrong hint costs wall time, never edges.
+ */
+const SYNTH_PASS_COST_HINT = {
+    cFnPtrEdges: 100, registryEdges: 60, tierEdges: 55, jsxEdges: 25, rnEventEdgesList: 24,
+    ifaceEdges: 18, flutterEdges: 16, cppEdges: 15, emitterEdges: 12, fieldEdges: 11,
+    mybatisEdges: 10, vuexEdges: 8, closureCollEdges: 6, piniaEdges: 5, renderEdges: 4,
+};
+function synthPassCostHint(name) {
+    return SYNTH_PASS_COST_HINT[name] ?? 0;
+}
 /** Fixed non-registry steps: goMethodContains, goImplements, dedupe-merge, insertMergedEdges. */
 const FIXED_SYNTH_STEPS = 4;
 exports.SYNTH_PROGRESS_STEPS = exports.SYNTH_PASSES.length + FIXED_SYNTH_STEPS;
@@ -3853,7 +4017,10 @@ pool,
 // WAL-valve writer backstop (WalCheckpointValve.backpressure), called at
 // pool-idle points in the edge-insert loops below — the passes themselves
 // only read; every write in this function happens with the pool idle.
-backpressure) {
+backpressure, 
+// Main-thread work to run while the pool computes the passes (the main
+// thread otherwise only waits there) — e.g. building a deferred index.
+whilePoolBusy) {
     // Each sub-pass below is a whole-graph scan, and there are ~30 of them, all
     // running synchronously on the indexer's main thread. Their AGGREGATE can run
     // for well over a minute on a large repo — long enough for the #850 liveness
@@ -3979,8 +4146,23 @@ backpressure) {
     // synthesized edges; the index still completes.
     const MAIN_RETRY_MAX_NODES = 1_500_000;
     const graphNodes = queries.getNodeAndEdgeCount().nodes;
+    // Files whose text could feed a pass (inputs that produce NO edges included,
+    // e.g. an over-cap channel: deleting one may make the full pass viable). It
+    // depends only on the files, so with a pool the main thread reads them while
+    // the workers run the passes instead of after.
+    const collectInputs = async () => {
+        const found = [];
+        for (const file of ctx.getAllFiles()) {
+            const content = ctx.readFile(file);
+            if (content !== null && hasSynthesisPattern(file, content))
+                found.push(file);
+            await yieldToLoop();
+        }
+        return found;
+    };
+    let inputs = null;
     if (pool && gatedIn.length > 1) {
-        await Promise.all(gatedIn.map(async (i) => {
+        const runPooled = async (i) => {
             const pass = exports.SYNTH_PASSES[i];
             try {
                 const out = await pool.runSynthPass(pass.name);
@@ -3999,7 +4181,25 @@ backpressure) {
                 // mismatch): retry this one pass on the main thread.
                 await runPassOnMain(i);
             }
-        }));
+        };
+        // One pass per worker at a time, heaviest first. Handing every pass out
+        // at once split them by count, and a worker interleaves what it holds, so
+        // a heavy pass finished only with its worker's whole share: on vscode the
+        // 6s registry pass ended ~16s in. Pulling keeps workers busy until the
+        // queue drains. Edges merge by registry index below, so order is free.
+        const lanes = Math.min(pool.size ?? gatedIn.length, gatedIn.length);
+        const queue = [...gatedIn].sort((a, b) => synthPassCostHint(exports.SYNTH_PASSES[b].name) - synthPassCostHint(exports.SYNTH_PASSES[a].name) || a - b);
+        const lane = async () => {
+            for (let i = queue.shift(); i !== undefined; i = queue.shift())
+                await runPooled(i);
+        };
+        const fanOut = Promise.all(Array.from({ length: lanes }, lane));
+        // Observed now, awaited below: a rejection while the scan runs must not
+        // surface as an unhandled one.
+        fanOut.catch(() => undefined);
+        whilePoolBusy?.();
+        inputs = await collectInputs();
+        await fanOut;
     }
     else {
         for (const i of gatedIn) {
@@ -4024,6 +4224,7 @@ backpressure) {
         await yieldToLoop();
         await foldIfOver();
     }
+    queries.replaceSynthesisInputs(inputs ?? await collectInputs());
     __mark('insertMergedEdges');
     return merged.length + goImpl.length + goMethodContains.length;
 }