homegraph 1.2.0 → 1.5.0

package/dist/resolution/callback-synthesizer.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNTH_PROGRESS_STEPS = exports.SYNTH_PASSES = void 0;
 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 cooperative_yield_1 = require("./cooperative-yield");
 const arkts_entry_1 = require("./frameworks/arkts-entry");
+const cooperative_yield_1 = require("./cooperative-yield");
 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;
@@ -41,6 +42,15 @@ const CC_DISPATCH_RE = /(\w+)\.forEach\s*\{\s*(?:\$0|it)\s*\(/g;
 const CC_APPEND_WRITE_RE = /(\w+)\.write\s*\{\s*\$0(?:\.(\w+))?\.(?:append|add|push|insert)\s*\(/g;
 const CC_APPEND_DIRECT_RE = /(\w+)\.(?:append|add|push|insert)\s*\(/g;
 const CC_FANOUT_CAP = 8; // skip a field name with more dispatchers/registrars than this (too generic to pair confidently)
+// The dispatcher gate — `{ $0( ` / `{ it( ` element-invocation — is Swift/Kotlin
+// trailing-closure syntax, so ONLY those languages can ever contribute a
+// dispatcher, and a cross-language registrar pairing (a JS `.push(` against a
+// Swift dispatcher's field name) would be a wrong edge, not a missed one.
+// Gating both sides here isn't just precision: `.push(`/`.add(` is everywhere
+// in JS/PHP, so an ungated scan slices + regexes nearly every function on repos
+// where the pass cannot emit a single edge — on a 12k-file PHP/JS app that was
+// 20+ minutes of the "Resolving refs" tail and a #850 watchdog kill (#1235).
+const CC_LANGUAGES = new Set(['swift', 'kotlin']);
 function kebabToPascal(s) {
     return s.split('-').map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
 }
@@ -76,6 +86,35 @@ 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;
@@ -213,13 +252,18 @@ async function closureCollectionEdges(queries, ctx, onYield) {
             arr.push({ node, line: absLine });
         registrars.set(field, arr);
     };
-    // Slices EVERY method/function's source (no cheap name-gate), so on a repo
-    // with a huge file this is the heaviest synthesis pass — yield mid-scan so it
-    // can't wedge the #850 watchdog on its own (#1091).
+    // Slices EVERY Swift/Kotlin method/function's source (no cheap name-gate), so
+    // on a repo with a huge file this is the heaviest synthesis pass — yield
+    // mid-scan (and mid-match-loop below: a single generated function dense with
+    // matches must not starve the watchdog either) so it can't wedge the #850
+    // watchdog on its own (#1091, #1235).
     let scanned = 0;
+    let matchTick = 0;
     for (const m of methodAndFunctionNodes(queries)) {
         if ((++scanned & 127) === 0)
             await onYield();
+        if (!CC_LANGUAGES.has(m.language))
+            continue;
         const content = ctx.readFile(m.filePath);
         const src = content && sliceLines(content, m.startLine, m.endLine);
         if (!src)
@@ -228,11 +272,13 @@ 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 = (idx) => (m.startLine ?? 1) + src.slice(0, idx).split('\n').length - 1;
+        const lineAt = makeLineAt(src, m.startLine ?? 1);
         if (hasForEach) {
             CC_DISPATCH_RE.lastIndex = 0;
             let d;
             while ((d = CC_DISPATCH_RE.exec(src))) {
+                if ((++matchTick & 255) === 0)
+                    await onYield();
                 const arr = dispatchers.get(d[1]) ?? [];
                 if (!arr.some((n) => n.node.id === m.id))
                     arr.push({ node: m, line: lineAt(d.index) });
@@ -242,12 +288,18 @@ async function closureCollectionEdges(queries, ctx, onYield) {
         if (hasAppend) {
             CC_APPEND_WRITE_RE.lastIndex = 0;
             let w;
-            while ((w = CC_APPEND_WRITE_RE.exec(src)))
+            while ((w = CC_APPEND_WRITE_RE.exec(src))) {
+                if ((++matchTick & 255) === 0)
+                    await onYield();
                 addReg(w[2] || w[1], m, lineAt(w.index)); // nested `$0.streams` else the `.write` receiver
+            }
             CC_APPEND_DIRECT_RE.lastIndex = 0;
             let a;
-            while ((a = CC_APPEND_DIRECT_RE.exec(src)))
+            while ((a = CC_APPEND_DIRECT_RE.exec(src))) {
+                if ((++matchTick & 255) === 0)
+                    await onYield();
                 addReg(a[1], m, lineAt(a.index));
+            }
         }
     }
     const edges = [];
@@ -277,10 +329,13 @@ async function closureCollectionEdges(queries, ctx, onYield) {
 }
 /** Phase 2: string-keyed EventEmitter channels (on('e', fn) ↔ emit('e')). */
 async function eventEmitterEdges(ctx, onYield) {
+    let scannedFiles = 0;
     const emitsByEvent = new Map(); // event → dispatcher node ids
     const handlersByEvent = new Map(); // event → handler id → registration site (file:line)
     let scanned = 0;
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if ((++scanned & 255) === 0)
             await onYield(); // #1091: yield mid-scan on huge graphs
         const content = ctx.readFile(file);
@@ -291,7 +346,7 @@ async function eventEmitterEdges(ctx, onYield) {
         if (!hasEmit && !hasOn)
             continue;
         const nodesInFile = ctx.getNodesInFile(file);
-        const lineOf = (idx) => content.slice(0, idx).split('\n').length;
+        const lineOf = makeLineAt(content, 1);
         if (hasEmit) {
             EMIT_RE.lastIndex = 0;
             let m;
@@ -354,10 +409,32 @@ async function eventEmitterEdges(ctx, onYield) {
  * `this.setState`). Over-approximation (all setState methods reach render) is
  * accepted — it's reachability-correct, like the callback channels.
  */
-function reactRenderEdges(queries, ctx) {
+async function reactRenderEdges(queries, ctx, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
-    for (const cls of queries.getNodesByKind('class')) {
+    // A class can only emit here if it CONTAINS a method named `render` — so one
+    // indexed name lookup bounds the candidate set up front, and the class scan
+    // below skips everything else before its per-class edge/node queries. On a
+    // repo with few/no render methods (any non-React codebase) this collapses
+    // the pass from every-class fan-out to ~zero DB work, with identical output:
+    // the skipped classes fail the same `render` check today, just after paying
+    // for their children. (Not a language gate: `render` + `this.setState(` in
+    // Java — e.g. Litho — legitimately matches today and still does.)
+    const renderOwners = new Set();
+    for (const n of ctx.getNodesByName('render')) {
+        if (n.kind !== 'method')
+            continue;
+        for (const e of queries.getIncomingEdges(n.id, ['contains']))
+            renderOwners.add(e.source);
+    }
+    if (renderOwners.size === 0)
+        return edges;
+    for (const cls of queries.iterateNodesByKind('class')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if (!renderOwners.has(cls.id))
+            continue;
         const children = queries.getOutgoingEdges(cls.id, ['contains'])
             .map((e) => queries.getNodeById(e.target))
             .filter((n) => !!n && n.kind === 'method');
@@ -397,10 +474,13 @@ function reactRenderEdges(queries, ctx) {
  * body calls `setState(` → `build`. The setState gate + `.dart` file keep this to
  * Flutter State classes. Over-approximation accepted (reachability-correct).
  */
-function flutterBuildEdges(queries, ctx) {
+async function flutterBuildEdges(queries, ctx, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
-    for (const cls of queries.getNodesByKind('class')) {
+    for (const cls of queries.iterateNodesByKind('class')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         const children = queries.getOutgoingEdges(cls.id, ['contains'])
             .map((e) => queries.getNodeById(e.target))
             .filter((n) => !!n && n.kind === 'method');
@@ -431,6 +511,279 @@ function flutterBuildEdges(queries, ctx) {
     }
     return edges;
 }
+/**
+ * Reactive ArkUI property decorators: assigning a property carrying one of
+ * these re-runs the owning struct's `build()`. Covers both state models —
+ * V1 (`@Component`: State/Prop/Link/Provide/Consume/Storage*) and V2
+ * (`@ComponentV2`: Local/Provider/Consumer; `@Param` is read-only in V2 so
+ * the assignment gate never fires on it, and `@Trace` lives on `@ObservedV2`
+ * data classes, not struct properties).
+ */
+const ARKUI_REACTIVE_DECORATORS = new Set([
+    'State', 'Prop', 'Link', 'Provide', 'Consume', 'StorageLink', 'StorageProp',
+    'LocalStorageLink', 'LocalStorageProp', 'ObjectLink',
+    'Local', 'Provider', 'Consumer',
+]);
+/** ArkUI-observed array mutators — `this.todos.push(x)` re-renders like an assignment. */
+const ARKUI_ARRAY_MUTATORS = 'push|pop|shift|unshift|splice|sort|reverse|fill';
+/**
+ * Phase 4b-ets: ArkUI state → build (the ArkTS analog of react-render /
+ * flutter-build). Assigning a reactive-decorated property (`@State count`,
+ * `@Link selected`, …) re-runs the `@Component struct`'s `build()`, but that
+ * hop is framework-internal — no static edge — so "onClick → markAllDone →
+ * this.todos = […] → rebuilt list" dead-ends at the assignment. Bridge it:
+ * for each arkts struct with a `build()` method and at least one reactive
+ * property, link every sibling method whose body ASSIGNS (or array-mutates)
+ * one of those properties → `build`. Assignment-gated on the struct's OWN
+ * reactive property names — a method that merely reads state, or a struct
+ * with no reactive properties, gets nothing (this is the precision line the
+ * all-sibling-methods design would erase).
+ */
+async function arkuiStateBuildEdges(queries, ctx, onYield) {
+    let scanned255 = 0;
+    const edges = [];
+    const seen = new Set();
+    for (const struct of queries.iterateNodesByKind('struct')) {
+        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);
+        const build = children.find((n) => n.kind === 'method' && n.name === 'build');
+        if (!build)
+            continue;
+        const reactiveProps = children.filter((n) => n.kind === 'property' && (n.decorators ?? []).some((d) => ARKUI_REACTIVE_DECORATORS.has(d)));
+        if (reactiveProps.length === 0)
+            continue;
+        const propAlternation = reactiveProps
+            .map((p) => p.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            .join('|');
+        // `this.count = …` / `+=` / `++` / `--` / `this.todos.push(…)`. The
+        // `=(?!=)` keeps `this.done == x` comparisons out.
+        const mutationRe = new RegExp(`this\\.(?:${propAlternation})\\s*(?:=(?!=)|\\+\\+|--|[+\\-*/%&|^]=|\\.(?:${ARKUI_ARRAY_MUTATORS})\\s*\\()`);
+        let added = 0;
+        for (const m of children) {
+            if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                break;
+            if (m.kind !== 'method' || m.id === build.id)
+                continue;
+            const content = ctx.readFile(m.filePath);
+            const src = content && sliceLines(content, m.startLine, m.endLine);
+            if (!src || !mutationRe.test((0, strip_comments_1.stripCommentsForRegex)(src, 'typescript')))
+                continue;
+            const key = `${m.id}>${build.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({
+                source: m.id, target: build.id, kind: 'calls', line: m.startLine,
+                provenance: 'heuristic',
+                metadata: { synthesizedBy: 'arkui-state', via: 'state assignment', registeredAt: `${build.filePath}:${build.startLine}` },
+            });
+            added++;
+        }
+    }
+    return edges;
+}
+/** Emit/subscribe call sites of HarmonyOS's `@ohos.events.emitter` bus. */
+const ARKUI_EMITTER_CALL_RE = /\bemitter\s*\.\s*(emit|on|once)\s*\(\s*([A-Za-z_$][\w$.]*|\{[^)]{0,120}?\beventId\s*:\s*[^,}]+[^)]*?\})/g;
+/** Cap per event bucket — a generic key with many parties is dynamic routing, not a static pair. */
+const ARKUI_EMITTER_FANOUT_CAP = 8;
+/**
+ * Phase 4b-ets2: HarmonyOS `@ohos.events.emitter` bridge. The cross-component
+ * bus — `emitter.emit(eventId)` fires `emitter.on(eventId, cb)` — is
+ * framework-internal, so an order flow riding it (OrangeShopping's
+ * add-to-cart) dead-ends at the emit. Link emit-site enclosing
+ * function/method → on/once-site enclosing function/method when both
+ * reference the SAME statically-recoverable event key.
+ *
+ * Key recovery, per call site (comment-stripped enclosing-file source): the
+ * first argument is an `{ eventId: K }` literal, a `Names.Dotted` constant, or
+ * a local whose same-file declaration is `new EventsId(K)` / `= K` — chase one
+ * level. Precision scoping learned from the samples monorepo (thousands of
+ * unrelated samples, most using eventId 1): NUMERIC keys pair within the same
+ * FILE only; NAMED keys pair within the same workspace module directory (or
+ * the whole project when it declares no modules — the single-app case), both
+ * behind a fan-out cap. Inline `on(id, (e) => {…})` arrows need no special
+ * handling — their bodies' calls already attribute to the registering method,
+ * so targeting that method keeps the chain connected.
+ */
+async function arkuiEmitterEdges(ctx, onYield) {
+    let scannedFiles = 0;
+    // bucket key -> emit sites / handler sites
+    const emits = new Map();
+    const handlers = new Map();
+    const moduleDirs = (() => {
+        const ws = ctx.getWorkspacePackages?.();
+        return ws ? [...new Set(ws.byName.values())].sort((a, b) => b.length - a.length) : [];
+    })();
+    const moduleScopeOf = (file) => {
+        for (const dir of moduleDirs) {
+            if (file === dir || file.startsWith(dir + '/'))
+                return dir;
+        }
+        return '';
+    };
+    for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
+        if (!file.endsWith('.ets'))
+            continue;
+        const content = ctx.readFile(file);
+        if (!content || !content.includes('emitter.'))
+            continue;
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'typescript');
+        const nodes = ctx.getNodesInFile(file)
+            .filter((n) => n.kind === 'method' || n.kind === 'function');
+        ARKUI_EMITTER_CALL_RE.lastIndex = 0;
+        let m;
+        while ((m = ARKUI_EMITTER_CALL_RE.exec(safe))) {
+            const verb = m[1];
+            const arg = m[2].trim();
+            const line = safe.slice(0, m.index).split('\n').length;
+            const encl = nodes
+                .filter((n) => n.startLine <= line && n.endLine >= line)
+                .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+            if (!encl)
+                continue;
+            // Recover the event key from the first argument.
+            let key = null;
+            const idLit = arg.startsWith('{') ? arg.match(/\beventId\s*:\s*([\w$.]+)/)?.[1] : undefined;
+            const token = idLit ?? arg;
+            if (token !== undefined) {
+                if (/^\d+$/.test(token)) {
+                    key = `num:${file}:${token}`; // numeric: same-file only
+                }
+                else if (token.includes('.')) {
+                    key = `name:${moduleScopeOf(file)}:${token}`;
+                }
+                else {
+                    // Local variable — chase its same-file declaration one level:
+                    // `let x = new EventsId(K)` / `const x = K`.
+                    const declRe = new RegExp(`\\b${token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b\\s*(?::[^=\\n]+)?=\\s*(?:new\\s+[\\w$.]+\\(\\s*([^)\\n]+?)\\s*\\)|([\\w$.]+))`);
+                    const decl = safe.match(declRe);
+                    const inner = (decl?.[1] ?? decl?.[2])?.trim();
+                    if (inner && /^\d+$/.test(inner))
+                        key = `num:${file}:${inner}`;
+                    else if (inner && /^[\w$.]+$/.test(inner))
+                        key = `name:${moduleScopeOf(file)}:${inner}`;
+                }
+            }
+            if (!key)
+                continue;
+            const site = { nodeId: encl.id, file, line };
+            if (verb === 'emit') {
+                (emits.get(key) ?? emits.set(key, []).get(key)).push(site);
+            }
+            else {
+                (handlers.get(key) ?? handlers.set(key, []).get(key)).push(site);
+            }
+        }
+    }
+    const edges = [];
+    const seen = new Set();
+    for (const [key, emitSites] of emits) {
+        const handlerSites = handlers.get(key);
+        if (!handlerSites)
+            continue;
+        if (emitSites.length > ARKUI_EMITTER_FANOUT_CAP || handlerSites.length > ARKUI_EMITTER_FANOUT_CAP)
+            continue;
+        const eventLabel = key.slice(key.lastIndexOf(':') + 1);
+        for (const e of emitSites)
+            for (const h of handlerSites) {
+                if (e.nodeId === h.nodeId)
+                    continue;
+                const dedupe = `${e.nodeId}>${h.nodeId}`;
+                if (seen.has(dedupe))
+                    continue;
+                seen.add(dedupe);
+                edges.push({
+                    source: e.nodeId, target: h.nodeId, kind: 'calls', line: e.line,
+                    provenance: 'heuristic',
+                    metadata: { synthesizedBy: 'arkui-emitter', event: eventLabel, registeredAt: `${h.file}:${h.line}` },
+                });
+            }
+    }
+    return edges;
+}
+/** `router.pushUrl({ url: 'pages/Detail' })` / replaceUrl — literal urls only. */
+const ARKUI_ROUTER_RE = /\brouter\s*\.\s*(?:pushUrl|replaceUrl)\s*\(\s*\{[^)]{0,200}?\burl\s*:\s*['"]([\w\-./]+)['"]/g;
+/**
+ * Phase 4b-ets3: HarmonyOS page navigation. `router.pushUrl({ url:
+ * 'pages/Detail' })` reaches the `@Entry struct` of
+ * `<module>/src/main/ets/pages/Detail.ets`, but the hop is a string — no
+ * static edge — so "tap → openDetail → ???" ends at the router call. Bridge
+ * literal urls to the page struct: the url resolves against the standard
+ * `src/main/ets/` layout (what main_pages.json entries name); candidates
+ * prefer the caller's own workspace module (routes are module-scoped), and
+ * anything still ambiguous is dropped rather than guessed. Only `@Entry`
+ * structs qualify as targets — the decorator is what makes a file a page.
+ */
+async function arkuiRouterEdges(ctx, onYield) {
+    const edges = [];
+    const seen = new Set();
+    const allFiles = ctx.getAllFiles();
+    const moduleDirs = (() => {
+        const ws = ctx.getWorkspacePackages?.();
+        return ws ? [...new Set(ws.byName.values())].sort((a, b) => b.length - a.length) : [];
+    })();
+    const moduleScopeOf = (file) => {
+        for (const dir of moduleDirs) {
+            if (file === dir || file.startsWith(dir + '/'))
+                return dir;
+        }
+        return '';
+    };
+    let scannedFiles = 0;
+    for (const file of allFiles) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
+        if (!file.endsWith('.ets'))
+            continue;
+        const content = ctx.readFile(file);
+        if (!content || !content.includes('router.'))
+            continue;
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'typescript');
+        const nodes = ctx.getNodesInFile(file)
+            .filter((n) => n.kind === 'method' || n.kind === 'function');
+        ARKUI_ROUTER_RE.lastIndex = 0;
+        let m;
+        while ((m = ARKUI_ROUTER_RE.exec(safe))) {
+            const url = m[1];
+            const line = safe.slice(0, m.index).split('\n').length;
+            const encl = nodes
+                .filter((n) => n.startLine <= line && n.endLine >= line)
+                .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+            if (!encl)
+                continue;
+            const suffix = `/src/main/ets/${url}.ets`;
+            let candidates = allFiles.filter((f) => f.endsWith(suffix));
+            if (candidates.length > 1) {
+                const scope = moduleScopeOf(file);
+                const sameModule = candidates.filter((f) => moduleScopeOf(f) === scope);
+                if (sameModule.length > 0)
+                    candidates = sameModule;
+            }
+            if (candidates.length !== 1)
+                continue; // ambiguous or unresolved — never guess
+            const page = ctx.getNodesInFile(candidates[0]).find((n) => n.kind === 'struct' && (n.decorators ?? []).includes('Entry'));
+            if (!page)
+                continue;
+            const key = `${encl.id}>${page.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({
+                source: encl.id, target: page.id, kind: 'calls', line,
+                provenance: 'heuristic',
+                metadata: { synthesizedBy: 'arkui-route', event: url, registeredAt: `${candidates[0]}:${page.startLine}` },
+            });
+        }
+    }
+    return edges;
+}
 /**
  * Phase 4c: C++ virtual override. A call through a base/interface pointer
  * (`db->Get(...)`, `iter->Next()`) dispatches at runtime to a subclass override,
@@ -441,14 +794,17 @@ function flutterBuildEdges(queries, ctx) {
  * implementation(s). Over-approximation accepted (reachability-correct); capped
  * per class and gated to C++ to avoid touching other languages' dispatch.
  */
-function cppOverrideEdges(queries) {
+async function cppOverrideEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const methodsOf = (classId) => queries
         .getOutgoingEdges(classId, ['contains'])
         .map((e) => queries.getNodeById(e.target))
         .filter((n) => !!n && n.kind === 'method');
-    for (const cls of queries.getNodesByKind('class')) {
+    for (const cls of queries.iterateNodesByKind('class')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         const subMethods = methodsOf(cls.id).filter((n) => n.language === 'cpp');
         if (subMethods.length === 0)
             continue;
@@ -502,6 +858,7 @@ function cppOverrideEdges(queries) {
 // or an `object` (Scala) so the loop also iterates those kinds.
 const IFACE_OVERRIDE_LANGS = new Set([
     'java', 'kotlin', 'csharp', 'typescript', 'javascript', 'swift', 'scala', 'go', 'rust',
+    'arkts',
 ]);
 /**
  * Go implicit interface satisfaction (#584). Go has no `implements` keyword — a
@@ -515,7 +872,8 @@ const IFACE_OVERRIDE_LANGS = new Set([
  * with the other dispatch synthesizers; capped per interface. Empty interfaces
  * (`any`) are skipped so they don't match every struct.
  */
-function goImplementsEdges(queries) {
+async function goImplementsEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const methodNameSet = (id) => new Set(queries
@@ -523,11 +881,24 @@ function goImplementsEdges(queries) {
         .map((e) => queries.getNodeById(e.target))
         .filter((n) => !!n && n.kind === 'method')
         .map((n) => n.name));
-    const goStructs = queries.getNodesByKind('struct').filter((s) => s.language === 'go');
+    // Materializes GO structs only (the pass is language-gated by the caller),
+    // never the whole struct kind — that array is O(nodes) on struct-heavy
+    // repos like the Linux kernel (#1212).
+    const goStructs = [];
+    for (const s of queries.iterateNodesByKind('struct')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if (s.language === 'go')
+            goStructs.push(s);
+    }
     const structMethods = new Map();
     for (const s of goStructs)
         structMethods.set(s.id, methodNameSet(s.id));
-    for (const iface of queries.getNodesByKind('interface')) {
+    for (const iface of queries.iterateNodesByKind('interface')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (iface.language !== 'go')
             continue;
         const want = methodNameSet(iface.id);
@@ -587,7 +958,8 @@ function goImplementsEdges(queries) {
  * matching the same-file edges extraction already emits). Skips methods that
  * already have a type parent (the same-file case). (#583, cross-file half)
  */
-function goCrossFileMethodContainsEdges(queries) {
+async function goCrossFileMethodContainsEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const TYPE_KINDS = new Set(['struct', 'class', 'interface', 'enum', 'type_alias']);
@@ -595,7 +967,11 @@ function goCrossFileMethodContainsEdges(queries) {
         const i = p.replace(/\\/g, '/').lastIndexOf('/');
         return i >= 0 ? p.slice(0, i) : '';
     };
-    for (const method of queries.getNodesByKind('method')) {
+    for (const method of queries.iterateNodesByKind('method')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (method.language !== 'go')
             continue;
         // The receiver type is encoded in the method's qualifiedName as `Recv::name`
@@ -665,13 +1041,20 @@ const KMP_TYPE_KINDS = new Set(['class', 'interface', 'struct', 'enum', 'type_al
 function kmpKindsCompatible(a, b) {
     return a === b || (KMP_TYPE_KINDS.has(a) && KMP_TYPE_KINDS.has(b));
 }
-function kotlinExpectActualEdges(queries) {
+async function kotlinExpectActualEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
-    const actuals = queries
-        .getAllNodes()
-        .filter((n) => n.language === 'kotlin' && !!n.decorators?.includes('actual'));
-    for (const act of actuals) {
+    // SQL-side language+decorator pre-filter, streamed. The old
+    // `getAllNodes().filter(...)` hydrated the ENTIRE node table into one array
+    // just to find kotlin `actual` declarations — on a 2M-node graph that alone
+    // exceeded Node's default heap and killed the index (#1212). The LIKE
+    // pre-filter can over-match (substring), so the exact decorator check stays.
+    for (const act of queries.iterateNodesByLanguageWithDecorator('kotlin', 'actual')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if (!act.decorators?.includes('actual'))
+            continue;
         let added = 0;
         for (const cand of queries.getNodesByQualifiedNameExact(act.qualifiedName)) {
             if (added >= MAX_CALLBACKS_PER_CHANNEL)
@@ -705,23 +1088,43 @@ function kotlinExpectActualEdges(queries) {
     }
     return edges;
 }
-function interfaceOverrideEdges(queries) {
+async function interfaceOverrideEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
-    const methodsOf = (classId) => queries
-        .getOutgoingEdges(classId, ['contains'])
-        .map((e) => queries.getNodeById(e.target))
-        .filter((n) => !!n && n.kind === 'method');
+    // Memoized: a popular base interface's method list is otherwise re-fetched
+    // once per implementer (dubbo-style hub interfaces have hundreds), and the
+    // memo only ever serves reads. Same rows, same order — byte-identical.
+    const methodsMemo = new Map();
+    const methodsOf = (classId) => {
+        const hit = methodsMemo.get(classId);
+        if (hit)
+            return hit;
+        const methods = queries
+            .getOutgoingEdges(classId, ['contains'])
+            .map((e) => queries.getNodeById(e.target))
+            .filter((n) => !!n && n.kind === 'method');
+        methodsMemo.set(classId, 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'];
     for (const kind of concreteKinds) {
-        for (const cls of queries.getNodesByKind(kind)) {
+        for (const cls of queries.iterateNodesByKind(kind)) {
+            if ((++scanned255 & 63) === 0)
+                await onYield();
+            // A class can only emit here if it HAS a supertype edge — check that
+            // (one edge query) before materializing its methods: most classes in a
+            // typical graph extend/implement nothing and skip in one hop.
+            const sups = queries.getOutgoingEdges(cls.id, ['implements', 'extends']);
+            if (sups.length === 0)
+                continue;
             const implMethods = methodsOf(cls.id).filter((n) => IFACE_OVERRIDE_LANGS.has(n.language));
             if (implMethods.length === 0)
                 continue;
-            for (const sup of queries.getOutgoingEdges(cls.id, ['implements', 'extends'])) {
+            for (const sup of sups) {
                 const base = queries.getNodeById(sup.target);
                 if (!base || !IFACE_OVERRIDE_LANGS.has(base.language) || base.id === cls.id)
                     continue;
@@ -791,7 +1194,8 @@ function interfaceOverrideEdges(queries) {
  * Provenance: `heuristic`, `synthesizedBy: 'go-grpc-stub-impl'`. The
  * stub's source line is the wiring site shown in the trace trail.
  */
-function goGrpcStubImplEdges(queries) {
+async function goGrpcStubImplEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const STUB_RE = /^Unimplemented.*Server$/;
@@ -803,7 +1207,9 @@ function goGrpcStubImplEdges(queries) {
     const methodNamesByStruct = new Map();
     const methodNodesByStruct = new Map();
     const goStructs = [];
-    for (const s of queries.getNodesByKind('struct')) {
+    for (const s of queries.iterateNodesByKind('struct')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (s.language !== 'go')
             continue;
         goStructs.push(s);
@@ -887,11 +1293,14 @@ function goGrpcStubImplEdges(queries) {
  * (or nothing) and are dropped.
  */
 async function reactJsxChildEdges(ctx, onYield) {
+    let scannedFiles = 0;
     const edges = [];
     const seen = new Set();
     const PARENT_KINDS = new Set(['method', 'function', 'component']);
     let scanned = 0;
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if ((++scanned & 255) === 0)
             await onYield(); // #1091: yield mid-scan on huge graphs
         const content = ctx.readFile(file);
@@ -941,7 +1350,9 @@ async function reactJsxChildEdges(ctx, onYield) {
  * component, handler→function/method) keeps precision; inline arrows / `$emit`
  * skipped.
  */
-function vueTemplateEdges(ctx) {
+async function vueTemplateEdges(ctx, onYield) {
+    let scannedFiles = 0;
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const COMPONENT_KINDS = new Set(['component', 'function', 'class']);
@@ -955,12 +1366,16 @@ function vueTemplateEdges(ctx) {
     // misses it (flat components match by basename and don't need this). Map each
     // nested component's Nuxt name → node so those template usages resolve.
     const nuxtComponents = new Map();
-    for (const c of ctx.getNodesByKind('component')) {
+    for (const c of (ctx.iterateNodesByKind?.('component') ?? ctx.getNodesByKind('component'))) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         const nn = nuxtComponentName(c.filePath);
         if (nn && !nuxtComponents.has(nn))
             nuxtComponents.set(nn, c);
     }
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!file.endsWith('.vue'))
             continue;
         const content = ctx.readFile(file);
@@ -1094,18 +1509,21 @@ const RN_JVM_EMIT_RE = /\.emit\s*\(\s*"([^"]+)"\s*,/g;
 // statement and stops at a block boundary, so the wrapper DEFINITION (whose `(`
 // is followed by `… ) {`) never matches. Multi-line tolerant. (java/kotlin/swift)
 const RN_NATIVE_SENDEVENT_RE = /\bsendEvent\s*\([^;{}]*?"([^"]+)"/g;
-function rnEventEdges(ctx) {
+async function rnEventEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // Native dispatchers (source = the native method whose body sends the
     // event) and JS handlers (target = the function/method registered as
     // the listener) keyed by event name.
     const nativeDispatchersByEvent = new Map();
     const jsHandlersByEvent = new Map();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         const content = ctx.readFile(file);
         if (!content)
             continue;
         const nodesInFile = ctx.getNodesInFile(file);
-        const lineOf = (idx) => content.slice(0, idx).split('\n').length;
+        const lineOf = makeLineAt(content, 1);
         const addDispatcher = (event, line) => {
             const disp = enclosingFn(nodesInFile, line);
             if (!disp)
@@ -1288,11 +1706,14 @@ const FABRIC_NATIVE_SUFFIXES = ['', 'View', 'ViewManager', 'ComponentView', 'Man
  * caller. The Expo method nodes are id-prefixed `expo-module:` and qualified
  * `<file>::<module>.<method>` by the framework extractor.
  */
-function expoCrossPlatformEdges(queries) {
+async function expoCrossPlatformEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const byKey = new Map();
-    for (const m of queries.getNodesByKind('method')) {
+    for (const m of queries.iterateNodesByKind('method')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (!m.id.startsWith('expo-module:'))
             continue;
         const key = m.qualifiedName.split('::').pop(); // `<module>.<method>`
@@ -1341,7 +1762,8 @@ function expoCrossPlatformEdges(queries) {
  * `getFreeDiskStorage`) — that's the JS-visible name, and how the iOS selector
  * lines up with the bare Android method name.
  */
-function rnCrossPlatformEdges(queries) {
+async function rnCrossPlatformEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     const NATIVE = new Set(['java', 'kotlin', 'objc', 'cpp']);
@@ -1363,6 +1785,8 @@ function rnCrossPlatformEdges(queries) {
     // below only runs for genuine cross-platform candidates.
     const byName = new Map();
     for (const m of queries.iterateNodesByKind('method')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (!NATIVE.has(m.language))
             continue;
         const key = norm(m.name);
@@ -1413,17 +1837,27 @@ function rnCrossPlatformEdges(queries) {
     }
     return edges;
 }
-function fabricNativeImplEdges(ctx) {
+async function fabricNativeImplEdges(ctx, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     // The Fabric extractor IDs are prefixed `fabric-component:` so we can
-    // filter to just those without iterating all `component` nodes.
-    const components = ctx.getNodesByKind('component').filter((n) => n.id.startsWith('fabric-component:'));
+    // filter to just those while streaming — never materializing the whole
+    // `component` kind (#1212).
+    const components = [];
+    for (const n of (ctx.iterateNodesByKind?.('component') ?? ctx.getNodesByKind('component'))) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if (n.id.startsWith('fabric-component:'))
+            components.push(n);
+    }
     if (components.length === 0)
         return edges;
     // Pre-index native classes by name for O(1) lookup.
     const nativeClassesByName = new Map();
-    for (const n of ctx.getNodesByKind('class')) {
+    for (const n of (ctx.iterateNodesByKind?.('class') ?? ctx.getNodesByKind('class'))) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (n.language !== 'objc' && n.language !== 'kotlin' && n.language !== 'java' && n.language !== 'cpp')
             continue;
         const arr = nativeClassesByName.get(n.name);
@@ -1476,12 +1910,29 @@ function fabricNativeImplEdges(ctx) {
  * same simple name) are dropped. We need-not bridge by package because Java
  * mapper interfaces are typically uniquely named within a project.
  */
-function mybatisJavaXmlEdges(queries) {
+async function mybatisJavaXmlEdges(queries, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
+    // Collect the XML side FIRST (mapper `<select id=…>` statements extracted as
+    // xml-language method nodes): if the project has none — every Java+XML repo
+    // that doesn't use MyBatis — return before paying the full java-method
+    // 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')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if (m.language === 'xml')
+            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')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (m.language !== 'java' && m.language !== 'kotlin')
             continue;
         const parts = m.qualifiedName.split('::');
@@ -1496,9 +1947,9 @@ function mybatisJavaXmlEdges(queries) {
         else
             javaIndex.set(key, [m]);
     }
-    for (const xml of queries.iterateNodesByKind('method')) {
-        if (xml.language !== 'xml')
-            continue;
+    for (const xml of xmlMethods) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         // Qualified name: `<namespace>::<id>`. Extract the simple class name.
         const colonIdx = xml.qualifiedName.lastIndexOf('::');
         if (colonIdx < 0)
@@ -1610,10 +2061,14 @@ function goHandlerIdent(expr) {
     const m = cleaned.match(/(?:\.|^)([A-Za-z_]\w*)$/);
     return m ? m[1] : null;
 }
-function ginMiddlewareChainEdges(queries, ctx) {
+async function ginMiddlewareChainEdges(queries, ctx, onYield) {
+    let scanned255 = 0;
+    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')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (n.language !== 'go')
             continue;
         const content = ctx.readFile(n.filePath);
@@ -1628,6 +2083,8 @@ function ginMiddlewareChainEdges(queries, ctx) {
     //    closures are dropped by goHandlerIdent; the rest are HandlerFuncs.
     const registered = new Map(); // name → registeredAt (file:line)
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!file.endsWith('.go'))
             continue;
         const content = ctx.readFile(file);
@@ -1683,10 +2140,13 @@ function ginMiddlewareChainEdges(queries, ctx) {
  * clause. Link the unit → its form so a `.dfm`/`.fmx` used only as a form
  * definition isn't orphaned, and editing the form surfaces its code-behind unit.
  */
-function pascalFormEdges(ctx) {
+async function pascalFormEdges(ctx, onYield) {
+    let scannedFiles = 0;
     const edges = [];
     const allFiles = new Set(ctx.getAllFiles());
     for (const file of allFiles) {
+        if ((++scannedFiles & 255) === 0)
+            await onYield();
         if (!/\.(dfm|fmx)$/i.test(file))
             continue;
         const pasFile = file.replace(/\.(dfm|fmx)$/i, '.pas');
@@ -1722,12 +2182,15 @@ function pascalFormEdges(ctx) {
  * a loader's data shows the page it feeds) and the page's dependencies include
  * its loader.
  */
-function svelteKitLoadEdges(ctx) {
+async function svelteKitLoadEdges(ctx, onYield) {
+    let scannedFiles = 0;
     const edges = [];
     const allFiles = new Set(ctx.getAllFiles());
     const HOOKS = new Set(['load', 'actions']);
     const HOOK_KINDS = new Set(['function', 'method', 'constant', 'variable']);
     for (const file of allFiles) {
+        if ((++scannedFiles & 255) === 0)
+            await onYield();
         const m = file.match(/(.*\/)(\+(?:page|layout))\.svelte$/);
         if (!m)
             continue;
@@ -1760,91 +2223,6 @@ function svelteKitLoadEdges(ctx) {
     }
     return edges;
 }
-/** ArkTS startup + UI lifecycle: loadContent → first screen, Ability chain, aboutToAppear → build. */
-function arktsEntryEdges(queries, ctx) {
-    const edges = [];
-    const seen = new Set();
-    const add = (source, target, synthesizedBy, extra = {}) => {
-        const key = `${source}>${target}`;
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        const targetNode = queries.getNodeById(target);
-        edges.push({
-            source,
-            target,
-            kind: 'calls',
-            provenance: 'heuristic',
-            metadata: {
-                synthesizedBy,
-                registeredAt: targetNode ? `${targetNode.filePath}:${targetNode.startLine}` : '',
-                ...extra,
-            },
-        });
-    };
-    for (const m of methodAndFunctionNodes(queries)) {
-        if (m.language !== 'arkts')
-            continue;
-        const content = ctx.readFile(m.filePath);
-        if (!content)
-            continue;
-        const lines = content.split('\n');
-        const start = Math.max((m.startLine ?? 1) - 1, 0);
-        const end = Math.min(m.endLine ?? m.startLine ?? lines.length, lines.length);
-        const body = lines.slice(start, end).join('\n');
-        const loadMatch = body.match(/loadContent\s*\(\s*['"]([^'"]+)['"]/);
-        if (!loadMatch)
-            continue;
-        const page = loadMatch[1];
-        const pageComponent = (0, arkts_entry_1.findArktsEntryPageComponent)(ctx, page);
-        if (pageComponent) {
-            const aboutToAppear = (0, arkts_entry_1.findArktsLifecycleMethod)(ctx, pageComponent, 'aboutToAppear');
-            if (aboutToAppear) {
-                add(m.id, aboutToAppear.id, 'arkts-load-content', { page });
-            }
-        }
-    }
-    for (const cls of [...queries.getNodesByKind('class'), ...queries.getNodesByKind('struct')]) {
-        if (cls.language !== 'arkts')
-            continue;
-        const methods = queries
-            .getOutgoingEdges(cls.id, ['contains'])
-            .map((e) => queries.getNodeById(e.target))
-            .filter((n) => !!n && n.kind === 'method');
-        const onCreate = methods.find((n) => n.name === 'onCreate');
-        const onWindowStageCreate = methods.find((n) => n.name === 'onWindowStageCreate');
-        if (onCreate && onWindowStageCreate) {
-            add(onCreate.id, onWindowStageCreate.id, 'arkts-lifecycle', { via: 'ability' });
-        }
-    }
-    for (const comp of [
-        ...queries.getNodesByKind('component'),
-        ...queries.getNodesByKind('class'),
-        ...queries.getNodesByKind('struct'),
-    ]) {
-        if (comp.language !== 'arkts')
-            continue;
-        const owner = comp.kind === 'component'
-            ? queries.getNodesByKind('struct').find((c) => c.filePath === comp.filePath && c.name === comp.name) ??
-                queries.getNodesByKind('class').find((c) => c.filePath === comp.filePath && c.name === comp.name) ??
-                comp
-            : comp;
-        const methods = queries
-            .getOutgoingEdges(owner.id, ['contains'])
-            .map((e) => queries.getNodeById(e.target))
-            .filter((n) => !!n && n.kind === 'method');
-        const build = methods.find((n) => n.name === 'build');
-        if (!build)
-            continue;
-        for (const life of ['aboutToAppear', 'onPageShow']) {
-            const lifeMethod = methods.find((n) => n.name === life);
-            if (lifeMethod) {
-                add(lifeMethod.id, build.id, 'arkts-lifecycle', { via: life });
-            }
-        }
-    }
-    return edges;
-}
 /**
  * Redux-thunk dispatch chain. `export const X = createAsyncThunk(prefix, async (a, api) => {...})`
  * (or a wrapper like trezor's `createThunk(...)`) passes the async body as an ARGUMENT, so
@@ -1861,10 +2239,13 @@ function arktsEntryEdges(queries, ctx) {
 const THUNK_DECL_RE = /create(?:Async)?Thunk/;
 const THUNK_DISPATCH_RE = /\bdispatch\s*\(\s*([A-Za-z_]\w*)\s*[(),]/g;
 const THUNK_FANOUT_CAP = 24;
-function reduxThunkEdges(queries, ctx) {
+async function reduxThunkEdges(queries, ctx, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     for (const node of queries.iterateNodesByKind('constant')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         // Cheap gate: the initializer (captured in `signature`) must be a create(Async)Thunk call —
         // avoids reading every constant's body on a large repo.
         if (!node.signature || !THUNK_DECL_RE.test(node.signature))
@@ -1996,10 +2377,13 @@ function resolveRegistryHandler(ctx, name, chained) {
     return cands.find((n) => n.kind === 'method') ?? null;
 }
 async function objectRegistryEdges(ctx, onYield) {
+    let scannedFiles = 0;
     const edges = [];
     const seen = new Set();
     let scanned = 0;
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if ((++scanned & 255) === 0)
             await onYield(); // #1091: yield mid-scan on huge graphs
         if (!REGISTRY_JS_EXT.test(file))
@@ -2111,10 +2495,13 @@ function rtkEndpointNameFromHook(hook) {
         return null;
     return mid.charAt(0).toLowerCase() + mid.slice(1);
 }
-function rtkQueryEdges(queries, ctx) {
+async function rtkQueryEdges(queries, ctx, onYield) {
+    let scanned255 = 0;
     const edges = [];
     const seen = new Set();
     for (const hook of queries.iterateNodesByKind('function')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         // Only our extracted generated-hook bindings (sentinel) — not a real hook fn.
         if (hook.signature !== RTK_GENERATED_HOOK_SIGNATURE)
             continue;
@@ -2158,10 +2545,13 @@ const PINIA_FACTORY_RE = /\b(?:export\s+)?const\s+(\w+)\s*=\s*defineStore\s*\(/g
 const PINIA_BIND_RE = /\bconst\s+(\w+)\s*=\s*(?:await\s+)?(\w+)\s*\(/g;
 const PINIA_CALL_RE = /(\w+)\s*\.\s*(\w+)\s*\(/g;
 const PINIA_FANOUT_CAP = 80;
-function piniaStoreEdges(ctx) {
+async function piniaStoreEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // 1. Map each `const useXStore = defineStore(...)` factory → its store file.
     const factoryFile = new Map();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!PINIA_CONSUMER_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2177,6 +2567,8 @@ function piniaStoreEdges(ctx) {
     const edges = [];
     const seen = new Set();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!PINIA_CONSUMER_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2249,7 +2641,8 @@ const VUEX_FANOUT_CAP = 120;
 function pathHasSegment(filePath, seg) {
     return new RegExp('[\\\\/]' + seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '[\\\\/.]').test(filePath);
 }
-function vuexDispatchEdges(ctx) {
+async function vuexDispatchEdges(ctx, onYield) {
+    let scannedFiles = 0;
     const storeFileCache = new Map();
     const isStoreFile = (file) => {
         let v = storeFileCache.get(file);
@@ -2287,6 +2680,8 @@ function vuexDispatchEdges(ctx) {
     const edges = [];
     const seen = new Set();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!PINIA_CONSUMER_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2346,7 +2741,8 @@ const CELERY_TASK_DECORATOR_RE = /@\s*(?:[A-Za-z_][\w.]*\.)?(?:shared_task|task)
 const CELERY_PY_EXT = /\.py$/;
 const CELERY_FANOUT_CAP = 80;
 const CELERY_DECORATOR_LOOKBACK = 12; // max lines above a `def` to scan for its decorators
-function celeryDispatchEdges(ctx) {
+async function celeryDispatchEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // Memoize the decorator check per task-candidate node: it reads the file and scans a few
     // lines above the def. Only called on names that are actually `.delay`/`.apply_async`
     // receivers, so the candidate set stays small.
@@ -2390,6 +2786,8 @@ function celeryDispatchEdges(ctx) {
     const edges = [];
     const seen = new Set();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!CELERY_PY_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2468,15 +2866,24 @@ function springFirstParamType(sig) {
     const type = toks[toks.length - 2].replace(/<.*$/, ''); // drop generic args
     return /^[A-Z][A-Za-z0-9_]*$/.test(type) ? type : null;
 }
-function springEventEdges(ctx) {
+async function springEventEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // Pass 1 — event-type → listener methods, scanning only event-relevant files.
+    // This is the ONLY full read sweep: publisher files are recorded here so
+    // pass 2 re-reads just those instead of every .java file again (#1212 —
+    // the double full-repo read was one of the tail's longest unyielded spans).
     const listeners = new Map();
+    const publisherFiles = [];
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!SPRING_JAVA_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
         if (!content)
             continue;
+        if (content.includes('.publishEvent('))
+            publisherFiles.push(file);
         const hasAnno = content.includes('@EventListener') || content.includes('@TransactionalEventListener');
         const hasAppListener = SPRING_APP_LISTENER_RE.test(content);
         if (!hasAnno && !hasAppListener)
@@ -2516,12 +2923,13 @@ function springEventEdges(ctx) {
     }
     if (!listeners.size)
         return [];
-    // Pass 2 — link each publishEvent(new XEvent(...)) site → every listener of XEvent.
+    // Pass 2 — link each publishEvent(new XEvent(...)) site → every listener of
+    // XEvent. Only the publisher files recorded in pass 1 are (re-)read.
     const edges = [];
     const seen = new Set();
-    for (const file of ctx.getAllFiles()) {
-        if (!SPRING_JAVA_EXT.test(file))
-            continue;
+    for (const file of publisherFiles) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         const content = ctx.readFile(file);
         if (!content || !content.includes('.publishEvent('))
             continue;
@@ -2606,10 +3014,13 @@ function resolveMediatrArgType(arg, lines, methodStart, dispatchLine) {
     }
     return declType;
 }
-function mediatrDispatchEdges(ctx) {
+async function mediatrDispatchEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // Pass 1 — request/notification type → the Handle method of each handler class.
     const handlers = new Map();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!MEDIATR_CS_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2643,6 +3054,8 @@ function mediatrDispatchEdges(ctx) {
     const edges = [];
     const seen = new Set();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!MEDIATR_CS_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2706,7 +3119,8 @@ const SIDEKIQ_DISPATCH_RE = /([A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)\s*\.\
 const SIDEKIQ_WORKER_RE = /\binclude\s+Sidekiq::(?:Job|Worker)\b/;
 const SIDEKIQ_RB_EXT = /\.rb$/;
 const SIDEKIQ_FANOUT_CAP = 80;
-function sidekiqDispatchEdges(ctx) {
+async function sidekiqDispatchEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // class node id → its instance `perform` method (null if the class isn't a Sidekiq worker),
     // memoized. Reads the class body for the mixin; only consulted for actual dispatch receivers.
     const performCache = new Map();
@@ -2743,6 +3157,8 @@ function sidekiqDispatchEdges(ctx) {
     const edges = [];
     const seen = new Set();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!SIDEKIQ_RB_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2778,7 +3194,415 @@ function sidekiqDispatchEdges(ctx) {
     }
     return edges;
 }
-// ── Laravel events (PHP) ──────────────────────────────────────────────────────
+// ── Erlang behaviour-callback dispatch ────────────────────────────────────────
+// An Erlang behaviour is a compile-checked callback contract: the behaviour
+// module declares `-callback init(...) -> ...`, implementers declare
+// `-behaviour(B)` and export the callbacks, and the framework side dispatches
+// through a VARIABLE module — cowboy's `Handler:init(Req, Opts)` and
+// `Middleware:execute(Req, Env)` folds, ejabberd's `Mod:start/2`. Extraction
+// deliberately leaves var-module calls silent (no static target), so the flow
+// breaks at exactly the hop agents ask about (request → handler init). Bridge:
+//
+//   dispatch site `Var:fn(args…)` → every in-repo implementer of the behaviour
+//   declaring `fn` with the SITE's arity — provided exactly ONE in-repo
+//   behaviour declares (fn, arity); a name+arity collision across behaviours
+//   bails (silent beats wrong) — and the implementer defines and exports `fn`.
+//
+// Behaviours are discovered by scanning every Erlang file for `-callback`
+// declarations (not just `implements` targets), so a behaviour with zero
+// implementers still participates in the ambiguity gate. Fan-out control: a
+// mega-behaviour (ejabberd's gen_mod, ~200 mod_* implementers) would mint
+// hundreds of edges per site that READ as complete coverage while being
+// arbitrary — above the cap the site is skipped entirely and the boundary
+// stays visibly dynamic (explore's boundary announcer covers it) instead of
+// silently truncated.
+const ERLANG_EXT = /\.(?:erl|hrl)$/;
+// `Var:fn(` — variable (capitalized) module, lowercase function, immediate
+// open-paren. The leading char class rejects `?MODULE:fn(` (macro), `a:b(`
+// (static remote call, already linked), and mid-word matches.
+const ERLANG_DISPATCH_RE = /(^|[^?\w@'])([A-Z][A-Za-z0-9_@]*):([a-z][A-Za-z0-9_@]*)\(/g;
+const ERLANG_CALLBACK_DECL_RE = /(^|\n)\s*-callback\s+('[^'\n]+'|[a-z][A-Za-z0-9_@]*)\s*\(/g;
+const ERLANG_BEHAVIOUR_FANOUT_CAP = 24;
+/**
+ * Argument count of the call/declaration whose `(` sits at `openIdx` —
+ * top-level commas + 1, `()` → 0, unbalanced/oversized → -1. Skips nested
+ * (), [], {}, <<>> content, `"strings"`, `'atoms'`, and `$c` char literals,
+ * so `-callback init(fun((a, b) -> ok), #{k => v}) -> ok.` counts 2.
+ */
+function erlangArityAt(src, openIdx) {
+    let depth = 1;
+    let commas = 0;
+    let sawArg = false;
+    const limit = Math.min(src.length, openIdx + 4000);
+    for (let i = openIdx + 1; i < limit; i++) {
+        const ch = src[i];
+        if (ch === '"' || ch === "'") {
+            i++;
+            while (i < limit && src[i] !== ch) {
+                if (src[i] === '\\')
+                    i++;
+                i++;
+            }
+            sawArg = true;
+            continue;
+        }
+        if (ch === '$') {
+            i++;
+            if (src[i] === '\\')
+                i++;
+            sawArg = true;
+            continue;
+        }
+        if (ch === '(' || ch === '[' || ch === '{') {
+            depth++;
+            sawArg = true;
+            continue;
+        }
+        if (ch === ')' || ch === ']' || ch === '}') {
+            depth--;
+            if (depth === 0)
+                return sawArg ? commas + 1 : 0;
+            continue;
+        }
+        if (ch === ',' && depth === 1) {
+            commas++;
+            continue;
+        }
+        if (!/\s/.test(ch))
+            sawArg = true;
+    }
+    return -1;
+}
+/**
+ * Nix module-system option wiring. A NixOS/home-manager/nix-darwin option is
+ * DECLARED in one module (`options.launchd.user.agents = mkOption { ... }`)
+ * and SET in others (`launchd.user.agents.yabai = { ... }` inside a module's
+ * config) — the connection happens by option-path unification inside the
+ * module-system evaluator, so there is no static call/import edge to follow
+ * and flow questions ("how does services.yabai.enable become a launchd
+ * service?") go dark at the module boundary.
+ *
+ * This pass links each config-write binding to the option declaration whose
+ * path is the longest static-segment prefix of the write path. Precision gates:
+ *  - only STATIC segments participate: plain identifiers, plus quoted segments
+ *    (`"git/config"`, `"com.apple.dock"`) as opaque verbatim tokens that match
+ *    only quote-exactly; an interpolated (`${name}`) segment ends the prefix,
+ *    so dynamic paths never match beyond their static head;
+ *  - matched prefixes must be ≥2 segments: 1-segment paths would wrongly link
+ *    every package's `meta = { ... }` attrset to nixos's `options.meta`;
+ *  - a prefix declared in more than one file is ambiguous → no edge (a wrong
+ *    edge is worse than none);
+ *  - writes physically inside an options block are declaration internals
+ *    (types, defaults, examples), never config writes → excluded.
+ * Both declaration spellings register: flat (`options.a.b = ...`) by name, and
+ * nested (`options = { a.b = ...; }`) by line-span containment.
+ */
+function nixLeadingPlainSegments(name) {
+    const segs = [];
+    let i = 0;
+    const n = name.length;
+    while (i < n) {
+        if (name[i] === '"') {
+            // Quoted segment — an opaque verbatim token (quotes kept, so it can
+            // never collide with a plain identifier). `NSGlobalDomain."com.apple.
+            // mouse.tapBehavior"` must match ITS OWN quoted declaration, not
+            // whichever sibling registered the shared plain prefix first.
+            let j = i + 1;
+            while (j < n && name[j] !== '"') {
+                if (name[j] === '\\')
+                    j++;
+                j++;
+            }
+            if (j >= n)
+                return segs; // unterminated — stop at the static head
+            const tok = name.slice(i, j + 1);
+            if (tok.includes('${'))
+                return segs; // interpolated → dynamic → stop
+            segs.push(tok);
+            i = j + 1;
+            if (i >= n)
+                break;
+            if (name[i] !== '.')
+                return segs;
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j < n && name[j] !== '.') {
+            if (name[j] === '"' || (name[j] === '$' && name[j + 1] === '{'))
+                return segs;
+            j++;
+        }
+        const seg = name.slice(i, j);
+        if (!/^[A-Za-z_][A-Za-z0-9_'-]*$/.test(seg))
+            return segs;
+        segs.push(seg);
+        i = j + 1;
+    }
+    return segs;
+}
+async function nixOptionPathEdges(queries, onYield) {
+    let scanned255 = 0;
+    // One streaming pass over nix bindings (variables + the odd function-valued
+    // option); memory stays O(bindings-kept), not O(all nodes) (#610).
+    const byFile = new Map();
+    let scanned = 0;
+    for (const kind of ['variable', 'function']) {
+        for (const node of queries.iterateNodesByKind(kind)) {
+            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;
+            const rec = {
+                id: node.id,
+                filePath: node.filePath,
+                startLine: node.startLine,
+                endLine: node.endLine,
+                segs,
+            };
+            const arr = byFile.get(node.filePath);
+            if (arr)
+                arr.push(rec);
+            else
+                byFile.set(node.filePath, [rec]);
+        }
+    }
+    // Per file: walk bindings outermost-first with a stack of active option
+    // spans, composing nested declaration paths (`options = { services.foo = {
+    // enable = mkOption ...; }; }` registers services.foo AND services.foo.enable).
+    // An `options` binding nested inside another option span is a SUBMODULE's
+    // 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 decls = new Map();
+    const writes = [];
+    const register = (path, rec) => {
+        if (path.length < 2 || path.includes(SUBMODULE))
+            return;
+        const key = path.join('.');
+        const arr = decls.get(key);
+        if (arr)
+            arr.push(rec);
+        else
+            decls.set(key, [rec]);
+    };
+    for (const recs of byFile.values()) {
+        recs.sort((a, b) => a.startLine - b.startLine || b.endLine - a.endLine);
+        const stack = [];
+        for (const rec of recs) {
+            while (stack.length > 0 && stack[stack.length - 1].end < rec.startLine)
+                stack.pop();
+            // Strict containment at line granularity: a one-line nested binding is
+            // indistinguishable from its container, so it stays unclassified (rare
+            // in module code, where option blocks are multi-line).
+            const enclosing = stack.length > 0 &&
+                rec.startLine >= stack[stack.length - 1].start &&
+                rec.endLine <= stack[stack.length - 1].end &&
+                !(rec.startLine === stack[stack.length - 1].start && rec.endLine === stack[stack.length - 1].end)
+                ? stack[stack.length - 1]
+                : null;
+            if (rec.segs[0] === 'options') {
+                const ownPath = rec.segs.slice(1); // [] for the bare `options = { ... }` spelling
+                const prefix = enclosing ? [SUBMODULE] : ownPath;
+                register(prefix, rec);
+                stack.push({ start: rec.startLine, end: rec.endLine, prefix });
+                continue;
+            }
+            if (enclosing) {
+                const composed = [...enclosing.prefix, ...rec.segs];
+                register(composed, rec);
+                stack.push({ start: rec.startLine, end: rec.endLine, prefix: composed });
+                continue;
+            }
+            if (rec.segs.length >= 2) {
+                writes.push(rec);
+            }
+        }
+    }
+    if (decls.size === 0 || writes.length === 0)
+        return [];
+    const edges = [];
+    for (const w of writes) {
+        // `config.services.x = ...` spells the same write with an explicit prefix.
+        const segs = w.segs[0] === 'config' ? w.segs.slice(1) : w.segs;
+        if (segs.length < 2)
+            continue;
+        // Longest prefix wins; an ambiguous longest match does NOT fall back to a
+        // shorter one (that would link `services.nginx.virtualHosts.x` to
+        // `options.services.nginx` when virtualHosts is the contested path).
+        for (let len = Math.min(segs.length, 6); len >= 2; len--) {
+            const candidates = decls.get(segs.slice(0, len).join('.'));
+            if (!candidates || candidates.length === 0)
+                continue;
+            const files = new Set(candidates.map((c) => c.filePath));
+            if (files.size === 1) {
+                const target = candidates[0];
+                if (target.id !== w.id) {
+                    edges.push({
+                        source: w.id,
+                        target: target.id,
+                        kind: 'references',
+                        line: w.startLine,
+                        provenance: 'heuristic',
+                        metadata: {
+                            synthesizedBy: 'nix-option-path',
+                            optionPath: segs.slice(0, len).join('.'),
+                            registeredAt: `${target.filePath}:${target.startLine}`,
+                        },
+                    });
+                }
+            }
+            break; // longest hit decides, matched or ambiguous
+        }
+    }
+    return edges;
+}
+async function erlangBehaviourDispatchEdges(queries, ctx, onYield) {
+    let scannedFiles = 0;
+    let scanned255 = 0;
+    // 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')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
+        if (n.language === 'erlang')
+            erlangModules.push(n);
+    }
+    if (erlangModules.length === 0)
+        return [];
+    // Pass 1 — scan every Erlang file with `-callback` decls: behaviour module →
+    // its (name, arity) callback set, and the global `name/arity` → declaring
+    // behaviours map that drives the ambiguity gate.
+    const moduleByFile = new Map();
+    for (const ns of erlangModules) {
+        if (!moduleByFile.has(ns.filePath))
+            moduleByFile.set(ns.filePath, ns);
+    }
+    const declaringBehaviours = new Map(); // `fn/arity` → behaviour namespaces
+    const callbackNames = new Set();
+    for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
+        if (!ERLANG_EXT.test(file))
+            continue;
+        const behaviour = moduleByFile.get(file);
+        if (!behaviour)
+            continue; // a .hrl or module-less file can't be a behaviour
+        const content = ctx.readFile(file);
+        if (!content || !content.includes('-callback'))
+            continue;
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'erlang');
+        ERLANG_CALLBACK_DECL_RE.lastIndex = 0;
+        let m;
+        while ((m = ERLANG_CALLBACK_DECL_RE.exec(safe))) {
+            const name = m[2].replace(/^'|'$/g, '');
+            const arity = erlangArityAt(safe, m.index + m[0].length - 1);
+            if (arity < 0)
+                continue;
+            const key = `${name}/${arity}`;
+            const arr = declaringBehaviours.get(key);
+            if (arr) {
+                if (!arr.some((b) => b.id === behaviour.id))
+                    arr.push(behaviour);
+            }
+            else {
+                declaringBehaviours.set(key, [behaviour]);
+            }
+            callbackNames.add(name);
+        }
+    }
+    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.
+    const targetCache = new Map();
+    const targetsOf = (behaviour, fn) => {
+        const cacheKey = `${behaviour.id}#${fn}`;
+        let targets = targetCache.get(cacheKey);
+        if (targets)
+            return targets;
+        targets = [];
+        for (const e of queries.getIncomingEdges(behaviour.id, ['implements'])) {
+            const impl = queries.getNodeById(e.source);
+            if (!impl || impl.language !== 'erlang' || impl.kind !== 'namespace')
+                continue;
+            const fnNode = ctx
+                .getNodesInFile(impl.filePath)
+                .find((n) => n.kind === 'function' && n.name === fn && n.isExported !== false);
+            if (fnNode)
+                targets.push(fnNode);
+        }
+        targetCache.set(cacheKey, targets);
+        return targets;
+    };
+    // Pass 2 — dispatch sites. Only files containing a var-module call shape are
+    // scanned in full.
+    const edges = [];
+    const seen = new Set();
+    for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
+        if (!ERLANG_EXT.test(file))
+            continue;
+        const content = ctx.readFile(file);
+        if (!content || !/[A-Z][A-Za-z0-9_@]*:[a-z]/.test(content))
+            continue;
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'erlang');
+        const nodesInFile = ctx.getNodesInFile(file);
+        ERLANG_DISPATCH_RE.lastIndex = 0;
+        let m;
+        while ((m = ERLANG_DISPATCH_RE.exec(safe))) {
+            const fn = m[3];
+            if (!callbackNames.has(fn))
+                continue;
+            const openIdx = m.index + m[0].length - 1;
+            const arity = erlangArityAt(safe, openIdx);
+            if (arity < 0)
+                continue;
+            const behaviours = declaringBehaviours.get(`${fn}/${arity}`);
+            if (!behaviours || behaviours.length !== 1)
+                continue; // unknown or ambiguous
+            const behaviour = behaviours[0];
+            const targets = targetsOf(behaviour, fn);
+            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);
+            if (!disp)
+                continue;
+            for (const target of targets) {
+                if (target.id === disp.id)
+                    continue;
+                const key = `${disp.id}>${target.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: disp.id,
+                    target: target.id,
+                    kind: 'calls',
+                    line,
+                    provenance: 'heuristic',
+                    metadata: {
+                        synthesizedBy: 'erlang-behaviour',
+                        via: `${behaviour.name}:${fn}/${arity}`,
+                        registeredAt: `${file}:${line}`,
+                    },
+                });
+            }
+        }
+    }
+    return edges;
+}
+// ── Laravel events (PHP) ──────────────────────────────────────────────────────
 // Laravel decouples an event dispatch from its listener(s), linked by the EVENT CLASS:
 //   // app/Events/PlaybackStarted.php  +  app/Listeners/UpdateLastfmNowPlaying.php
 //   class UpdateLastfmNowPlaying { public function handle(PlaybackStarted $event) { … } }
@@ -2824,7 +3648,8 @@ function phpArrayBody(src, openIdx) {
     }
     return null;
 }
-function laravelEventEdges(ctx) {
+async function laravelEventEdges(ctx, onYield) {
+    let scannedFiles = 0;
     // event short name → its listener `handle` methods (deduped by node id).
     const listeners = new Map();
     const add = (event, handle) => {
@@ -2841,6 +3666,8 @@ function laravelEventEdges(ctx) {
         && n.startLine >= cls.startLine && n.startLine <= (cls.endLine ?? cls.startLine)) ?? null;
     // Pass 1 — build the event→handle map from both registration mechanisms.
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!LARAVEL_PHP_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2886,6 +3713,8 @@ function laravelEventEdges(ctx) {
     const edges = [];
     const seen = new Set();
     for (const file of ctx.getAllFiles()) {
+        if ((++scannedFiles & 15) === 0)
+            await onYield();
         if (!LARAVEL_PHP_EXT.test(file))
             continue;
         const content = ctx.readFile(file);
@@ -2936,7 +3765,182 @@ function laravelEventEdges(ctx) {
  * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
  * Returns the count added. Never throws into indexing — callers wrap in try/catch.
  */
-async function synthesizeCallbackEdges(queries, ctx) {
+/**
+ * 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'];
+/** ArkTS startup + UI lifecycle: loadContent → first screen, Ability chain, aboutToAppear → build. */
+function arktsEntryEdges(queries, ctx) {
+    const edges = [];
+    const seen = new Set();
+    const add = (source, target, synthesizedBy, extra = {}) => {
+        const key = `${source}>${target}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        const targetNode = queries.getNodeById(target);
+        edges.push({
+            source,
+            target,
+            kind: 'calls',
+            provenance: 'heuristic',
+            metadata: {
+                synthesizedBy,
+                registeredAt: targetNode ? `${targetNode.filePath}:${targetNode.startLine}` : '',
+                ...extra,
+            },
+        });
+    };
+    for (const m of methodAndFunctionNodes(queries)) {
+        if (m.language !== 'arkts')
+            continue;
+        const content = ctx.readFile(m.filePath);
+        if (!content)
+            continue;
+        const lines = content.split('\n');
+        const start = Math.max((m.startLine ?? 1) - 1, 0);
+        const end = Math.min(m.endLine ?? m.startLine ?? lines.length, lines.length);
+        const body = lines.slice(start, end).join('\n');
+        const loadMatch = body.match(/loadContent\s*\(\s*['"]([^'"]+)['"]/);
+        if (!loadMatch)
+            continue;
+        const page = loadMatch[1];
+        const pageComponent = (0, arkts_entry_1.findArktsEntryPageComponent)(ctx, page);
+        if (pageComponent) {
+            const aboutToAppear = (0, arkts_entry_1.findArktsLifecycleMethod)(ctx, pageComponent, 'aboutToAppear');
+            if (aboutToAppear) {
+                add(m.id, aboutToAppear.id, 'arkts-load-content', { page });
+            }
+        }
+    }
+    for (const cls of [...queries.getNodesByKind('class'), ...queries.getNodesByKind('struct')]) {
+        if (cls.language !== 'arkts')
+            continue;
+        const methods = queries
+            .getOutgoingEdges(cls.id, ['contains'])
+            .map((e) => queries.getNodeById(e.target))
+            .filter((n) => !!n && n.kind === 'method');
+        const onCreate = methods.find((n) => n.name === 'onCreate');
+        const onWindowStageCreate = methods.find((n) => n.name === 'onWindowStageCreate');
+        if (onCreate && onWindowStageCreate) {
+            add(onCreate.id, onWindowStageCreate.id, 'arkts-lifecycle', { via: 'ability' });
+        }
+    }
+    for (const comp of [
+        ...queries.getNodesByKind('component'),
+        ...queries.getNodesByKind('class'),
+        ...queries.getNodesByKind('struct'),
+    ]) {
+        if (comp.language !== 'arkts')
+            continue;
+        const owner = comp.kind === 'component'
+            ? queries.getNodesByKind('struct').find((c) => c.filePath === comp.filePath && c.name === comp.name) ??
+                queries.getNodesByKind('class').find((c) => c.filePath === comp.filePath && c.name === comp.name) ??
+                comp
+            : comp;
+        const methods = queries
+            .getOutgoingEdges(owner.id, ['contains'])
+            .map((e) => queries.getNodeById(e.target))
+            .filter((n) => !!n && n.kind === 'method');
+        const build = methods.find((n) => n.name === 'build');
+        if (!build)
+            continue;
+        for (const life of ['aboutToAppear', 'onPageShow']) {
+            const lifeMethod = methods.find((n) => n.name === life);
+            if (lifeMethod) {
+                add(lifeMethod.id, build.id, 'arkts-lifecycle', { via: life });
+            }
+        }
+    }
+    return edges;
+}
+const ALWAYS = () => true;
+/**
+ * The independent passes, in MERGE ORDER — the first-seen dedup in
+ * synthesizeCallbackEdges follows this array, so reordering entries changes
+ * which duplicate edge wins. The two Go pre-passes (cross-file method
+ * `contains`, implicit `implements`) are NOT here: they persist before these
+ * run because interfaceOverrideEdges reads their edges from the DB.
+ */
+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) },
+    { 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: '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) },
+    { name: 'flutterEdges', gate: (has) => has('dart'), run: (q, c, y) => flutterBuildEdges(q, c, y) },
+    { name: 'arkuiStateEdges', gate: (has) => has('arkts'), run: (q, c, y) => arkuiStateBuildEdges(q, c, y) },
+    { name: 'arkuiEmitter', gate: (has) => has('arkts'), run: (_q, c, y) => arkuiEmitterEdges(c, y) },
+    { name: 'arkuiRoutes', gate: (has) => has('arkts'), run: (_q, c, y) => arkuiRouterEdges(c, y) },
+    { name: 'arktsStartupEdges', gate: (has) => has('arkts'), run: async (q, c) => arktsEntryEdges(q, c) },
+    { name: 'cppEdges', gate: (has) => has('cpp'), run: (q, _c, y) => cppOverrideEdges(q, y) },
+    {
+        name: 'ifaceEdges',
+        gate: (has) => has('java', 'kotlin', 'csharp', 'swift', 'scala', 'go', 'rust', 'arkts', ...JS_FAMILY),
+        run: (q, _c, y) => interfaceOverrideEdges(q, y),
+    },
+    { name: 'kotlinExpectActual', gate: (has) => has('kotlin'), run: (q, _c, y) => kotlinExpectActualEdges(q, y) },
+    { name: 'goGrpcEdges', gate: (has) => has('go'), run: (q, _c, y) => goGrpcStubImplEdges(q, y) },
+    { name: 'rnEventEdgesList', gate: (has) => has(...JS_FAMILY), run: (_q, c, y) => rnEventEdges(c, y) },
+    { name: 'fabricNativeEdges', gate: ALWAYS, run: (_q, c, y) => fabricNativeImplEdges(c, y) },
+    // Expo module nodes (`expo-module:` ids) are emitted only from .swift/.kt
+    // files, and a pair needs BOTH platforms — so without both languages the
+    // pass's only collection loop is provably empty (it was streaming every
+    // method row on pure-Java repos to find nothing).
+    { name: 'expoXPlatEdges', gate: (has) => has('swift') && has('kotlin'), run: (q, _c, y) => expoCrossPlatformEdges(q, y) },
+    // An RN cross-platform edge requires a JS-language caller on the native
+    // method (`isBridge`) — no JS-family files means no JS-language nodes, so
+    // the result is provably empty.
+    { name: 'rnXPlatEdges', gate: (has) => has(...JS_FAMILY), run: (q, _c, y) => rnCrossPlatformEdges(q, y) },
+    {
+        name: 'mybatisEdges',
+        gate: (has) => has('java', 'kotlin') && has('xml'),
+        run: (q, _c, y) => mybatisJavaXmlEdges(q, y),
+    },
+    { name: 'ginEdges', gate: (has) => has('go'), run: (q, c, y) => ginMiddlewareChainEdges(q, c, y) },
+    { name: 'thunkEdges', gate: (has) => has(...JS_FAMILY), run: (q, c, y) => reduxThunkEdges(q, c, y) },
+    { name: 'registryEdges', gate: ALWAYS, run: (_q, c, y) => objectRegistryEdges(c, y) },
+    { name: 'rtkEdges', gate: (has) => has(...JS_FAMILY), run: (q, c, y) => rtkQueryEdges(q, c, y) },
+    { name: 'piniaEdges', gate: (has) => has('vue', ...JS_FAMILY), run: (_q, c, y) => piniaStoreEdges(c, y) },
+    { name: 'vuexEdges', gate: (has) => has('vue', ...JS_FAMILY), run: (_q, c, y) => vuexDispatchEdges(c, y) },
+    { name: 'celeryEdges', gate: (has) => has('python'), run: (_q, c, y) => celeryDispatchEdges(c, y) },
+    { name: 'springEdges', gate: (has) => has('java'), run: (_q, c, y) => springEventEdges(c, y) },
+    { name: 'mediatrEdges', gate: (has) => has('csharp'), run: (_q, c, y) => mediatrDispatchEdges(c, y) },
+    { name: 'sidekiqEdges', gate: (has) => has('ruby'), run: (_q, c, y) => sidekiqDispatchEdges(c, y) },
+    {
+        name: 'erlangBehaviourEdges',
+        gate: (has) => has('erlang'),
+        run: (q, c, y) => erlangBehaviourDispatchEdges(q, c, y),
+    },
+    { name: 'laravelEdges', gate: (has) => has('php'), run: (_q, c, y) => laravelEventEdges(c, y) },
+    {
+        name: 'cFnPtrEdges',
+        gate: (has) => has('c', 'cpp'),
+        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) },
+    { name: 'nixOptionEdges', gate: (has) => has('nix'), run: (q, _c, y) => nixOptionPathEdges(q, y) },
+];
+/** 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;
+async function synthesizeCallbackEdges(queries, ctx, onProgress, 
+// A live resolver pool to fan the independent passes across (structural type
+// so this file never imports the pool — resolver-worker imports THIS file).
+// Null/omitted → the sequential path, byte-identical to the pool path.
+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) {
     // 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
@@ -2945,131 +3949,169 @@ async function synthesizeCallbackEdges(queries, ctx) {
     // that itself hangs (a real wedge) never reaches the next yield, so the
     // watchdog still catches that. See ./cooperative-yield.
     const yieldToLoop = (0, cooperative_yield_1.createYielder)();
+    // Synthesis runs AFTER the resolution progress bar reaches 100%, so without
+    // its own progress the UI freezes at "Resolving refs 100%" for the whole
+    // tail — long enough on big repos that users conclude the index hung and
+    // kill it. Report each completed pass; the caller surfaces it as its own
+    // progress phase. Emit 0/total up front so the phase flips immediately.
+    // Emissions are throttled to whole-percent movement (each consumes a UI
+    // message); values may be fractional steps from within-pass reporting.
+    let passesDone = 0;
+    let lastPct = -1;
+    const emit = (value) => {
+        if (!onProgress)
+            return;
+        const v = Math.min(value, exports.SYNTH_PROGRESS_STEPS);
+        const pct = Math.floor((v / exports.SYNTH_PROGRESS_STEPS) * 100);
+        if (pct === lastPct)
+            return;
+        lastPct = pct;
+        onProgress(v, exports.SYNTH_PROGRESS_STEPS);
+    };
+    // A single long pass otherwise parks the bar between steps; a pass that
+    // takes this callback reports a 0..1 fraction of its own work, surfaced
+    // here as fractional progress within its step.
+    const subProgress = (fraction) => emit(passesDone + Math.max(0, Math.min(fraction, 1)));
+    emit(0);
+    // Per-pass wall-clock timing to stderr, opt-in via HOMEGRAPH_SYNTH_TIMINGS
+    // (=1: passes over 250ms; =all: every pass). This is the diagnostic that
+    // located both the #1091/#1122 watchdog stalls and the #1212 OOM — keep it.
+    const markT = { t: Date.now() };
+    const __mark = (label) => {
+        const now = Date.now();
+        const dt = now - markT.t;
+        markT.t = now;
+        if (process.env.HOMEGRAPH_SYNTH_TIMINGS && (dt > 250 || process.env.HOMEGRAPH_SYNTH_TIMINGS === 'all')) {
+            console.error(`[synth-timing] ${label}: ${dt}ms`);
+        }
+        passesDone++;
+        emit(passesDone);
+    };
+    // Language gating: one indexed DISTINCT over the files table lets a pass
+    // whose own filters reference a specific language/extension be skipped
+    // outright when the project has no such files — its result is provably
+    // empty, so skipping is behavior-identical and the cost drops to zero
+    // (the Kotlin pass was the OOM culprit on the pure-C Linux kernel, #1212).
+    // Passes without an explicit language filter always run.
+    const langs = queries.getDistinctFileLanguages();
+    const has = (...ls) => ls.some((l) => langs.has(l));
+    const NONE = [];
     // Cross-file Go method→type `contains` edges must be synthesized AND persisted
     // FIRST: a method declared in a different file from its receiver type is
     // otherwise orphaned from the struct, and goImplementsEdges (next) derives a
     // struct's method set from its `contains` edges — so without this it would
     // under-count the interfaces a cross-file struct satisfies. (#583)
-    const goMethodContains = goCrossFileMethodContainsEdges(queries);
-    if (goMethodContains.length > 0)
-        queries.insertEdges(goMethodContains);
+    // Writer-side WAL backstop for the insert loops here (see the param doc):
+    // one fstat when under the valve's hard cap, a parked full backfill past it.
+    const foldIfOver = async () => {
+        const bp = backpressure?.();
+        if (bp)
+            await bp;
+    };
+    const goMethodContains = has('go') ? await goCrossFileMethodContainsEdges(queries, yieldToLoop) : NONE;
+    for (let i = 0; i < goMethodContains.length; i += 2000) {
+        queries.insertEdges(goMethodContains.slice(i, i + 2000));
+        await yieldToLoop();
+        await foldIfOver();
+    }
     await yieldToLoop();
+    __mark('goMethodContains');
     // Go implicit `implements` edges must be synthesized AND persisted next: the
     // interface-dispatch bridge below reads `implements` edges from the DB, and
     // Go has none statically. (Other languages already have static implements
     // edges from extraction, so they don't need this pre-pass.)
-    const goImpl = goImplementsEdges(queries);
-    if (goImpl.length > 0)
-        queries.insertEdges(goImpl);
-    await yieldToLoop();
-    const fieldEdges = await fieldChannelEdges(queries, ctx, yieldToLoop);
-    await yieldToLoop();
-    const closureCollEdges = await closureCollectionEdges(queries, ctx, yieldToLoop);
-    await yieldToLoop();
-    const emitterEdges = await eventEmitterEdges(ctx, yieldToLoop);
-    await yieldToLoop();
-    const renderEdges = reactRenderEdges(queries, ctx);
-    await yieldToLoop();
-    const jsxEdges = await reactJsxChildEdges(ctx, yieldToLoop);
-    await yieldToLoop();
-    const vueEdges = vueTemplateEdges(ctx);
-    await yieldToLoop();
-    const svelteKitEdges = svelteKitLoadEdges(ctx);
-    await yieldToLoop();
-    const pascalEdges = pascalFormEdges(ctx);
-    await yieldToLoop();
-    const flutterEdges = flutterBuildEdges(queries, ctx);
-    await yieldToLoop();
-    const cppEdges = cppOverrideEdges(queries);
-    await yieldToLoop();
-    const ifaceEdges = interfaceOverrideEdges(queries);
-    await yieldToLoop();
-    const kotlinExpectActual = kotlinExpectActualEdges(queries);
-    await yieldToLoop();
-    const goGrpcEdges = goGrpcStubImplEdges(queries);
-    await yieldToLoop();
-    const rnEventEdgesList = rnEventEdges(ctx);
-    await yieldToLoop();
-    const fabricNativeEdges = fabricNativeImplEdges(ctx);
-    await yieldToLoop();
-    const expoXPlatEdges = expoCrossPlatformEdges(queries);
-    await yieldToLoop();
-    const rnXPlatEdges = rnCrossPlatformEdges(queries);
-    await yieldToLoop();
-    const mybatisEdges = mybatisJavaXmlEdges(queries);
-    await yieldToLoop();
-    const ginEdges = ginMiddlewareChainEdges(queries, ctx);
-    await yieldToLoop();
-    const thunkEdges = reduxThunkEdges(queries, ctx);
-    await yieldToLoop();
-    const registryEdges = await objectRegistryEdges(ctx, yieldToLoop);
-    await yieldToLoop();
-    const rtkEdges = rtkQueryEdges(queries, ctx);
-    await yieldToLoop();
-    const piniaEdges = piniaStoreEdges(ctx);
-    await yieldToLoop();
-    const vuexEdges = vuexDispatchEdges(ctx);
-    await yieldToLoop();
-    const celeryEdges = celeryDispatchEdges(ctx);
-    await yieldToLoop();
-    const springEdges = springEventEdges(ctx);
-    await yieldToLoop();
-    const mediatrEdges = mediatrDispatchEdges(ctx);
-    await yieldToLoop();
-    const sidekiqEdges = sidekiqDispatchEdges(ctx);
-    await yieldToLoop();
-    const laravelEdges = laravelEventEdges(ctx);
-    await yieldToLoop();
-    const cFnPtrEdges = (0, c_fnptr_synthesizer_1.cFnPointerDispatchEdges)(queries, ctx);
-    await yieldToLoop();
-    const goframeEdges = (0, goframe_synthesizer_1.goframeRouteEdges)(ctx);
-    await yieldToLoop();
-    const arktsStartupEdges = arktsEntryEdges(queries, ctx);
+    const goImpl = has('go') ? await goImplementsEdges(queries, yieldToLoop) : NONE;
+    for (let i = 0; i < goImpl.length; i += 2000) {
+        queries.insertEdges(goImpl.slice(i, i + 2000));
+        await yieldToLoop();
+        await foldIfOver();
+    }
     await yieldToLoop();
+    __mark('goImplements');
+    // Run the independent passes (see SYNTH_PASSES). Their results are merged in
+    // REGISTRY ORDER below regardless of execution order, and none of their edges
+    // persist until that merge — so every pass sees the same committed
+    // post-resolution DB state whether it runs sequentially here or on a resolver
+    // pool worker. With a live pool (already booted on ≥150k-ref repos), passes
+    // fan out across its read-only workers and the per-pass wall-clock comes from
+    // the worker; a pass that fails on a worker falls back to running on the main
+    // thread, so a worker crash isolates to a retry instead of failing synthesis.
+    const passEdges = new Array(exports.SYNTH_PASSES.length).fill(NONE);
+    const markPass = (label, dt) => {
+        if (process.env.HOMEGRAPH_SYNTH_TIMINGS && (dt > 250 || process.env.HOMEGRAPH_SYNTH_TIMINGS === 'all')) {
+            console.error(`[synth-timing] ${label}: ${dt}ms`);
+        }
+        passesDone++;
+        emit(passesDone);
+    };
+    const runPassOnMain = async (i) => {
+        const pass = exports.SYNTH_PASSES[i];
+        const t0 = Date.now();
+        passEdges[i] = await pass.run(queries, ctx, yieldToLoop, subProgress);
+        await yieldToLoop();
+        markPass(pass.name, Date.now() - t0);
+    };
+    const gatedIn = [];
+    for (let i = 0; i < exports.SYNTH_PASSES.length; i++) {
+        if (exports.SYNTH_PASSES[i].gate(has))
+            gatedIn.push(i);
+        else
+            markPass(exports.SYNTH_PASSES[i].name, 0);
+    }
+    // Above this node count, a pass that OOM-killed its worker must NOT be
+    // retried on the main thread — the retry would OOM the whole process and
+    // take the index with it (the #1212 failure class). Below it, a worker
+    // failure is more likely a transient crash than a memory ceiling, and the
+    // main-thread retry keeps coverage. Skipping loses only that pass's
+    // synthesized edges; the index still completes.
+    const MAIN_RETRY_MAX_NODES = 1_500_000;
+    const graphNodes = queries.getNodeAndEdgeCount().nodes;
+    if (pool && gatedIn.length > 1) {
+        await Promise.all(gatedIn.map(async (i) => {
+            const pass = exports.SYNTH_PASSES[i];
+            try {
+                const out = await pool.runSynthPass(pass.name);
+                passEdges[i] = out.edges;
+                markPass(pass.name, out.ms);
+            }
+            catch (err) {
+                if (graphNodes > MAIN_RETRY_MAX_NODES) {
+                    // Worker died at a scale where the main-thread retry is a process
+                    // OOM risk: skip the pass, keep the index alive, and say so.
+                    console.error(`[synthesis] pass '${pass.name}' failed on a worker at ${graphNodes} nodes — skipped (edges from this pass are absent): ${err instanceof Error ? err.message : String(err)}`);
+                    markPass(`${pass.name} (skipped at scale)`, 0);
+                    return;
+                }
+                // Worker-side failure (crash, OOM, unknown pass after a version
+                // mismatch): retry this one pass on the main thread.
+                await runPassOnMain(i);
+            }
+        }));
+    }
+    else {
+        for (const i of gatedIn) {
+            await runPassOnMain(i);
+        }
+    }
     const merged = [];
     const seen = new Set();
-    for (const e of [
-        ...fieldEdges,
-        ...closureCollEdges,
-        ...emitterEdges,
-        ...renderEdges,
-        ...jsxEdges,
-        ...vueEdges,
-        ...svelteKitEdges,
-        ...pascalEdges,
-        ...flutterEdges,
-        ...cppEdges,
-        ...ifaceEdges,
-        ...kotlinExpectActual,
-        ...goGrpcEdges,
-        ...rnEventEdgesList,
-        ...fabricNativeEdges,
-        ...expoXPlatEdges,
-        ...rnXPlatEdges,
-        ...mybatisEdges,
-        ...ginEdges,
-        ...thunkEdges,
-        ...registryEdges,
-        ...rtkEdges,
-        ...piniaEdges,
-        ...vuexEdges,
-        ...celeryEdges,
-        ...springEdges,
-        ...mediatrEdges,
-        ...sidekiqEdges,
-        ...laravelEdges,
-        ...cFnPtrEdges,
-        ...goframeEdges,
-        ...arktsStartupEdges,
-    ]) {
+    for (const e of passEdges.flat()) {
         const key = `${e.source}>${e.target}`;
         if (seen.has(key))
             continue;
         seen.add(key);
         merged.push(e);
     }
-    if (merged.length > 0)
-        queries.insertEdges(merged);
+    __mark('dedupe-merge');
+    // Chunked insert with yields: on the Linux kernel the merged synthesized
+    // edge set is ~275k rows, and one transaction for all of them was a 20s
+    // unyielded main-thread span (#1212 follow-up) — the last one in the tail.
+    for (let i = 0; i < merged.length; i += 2000) {
+        queries.insertEdges(merged.slice(i, i + 2000));
+        await yieldToLoop();
+        await foldIfOver();
+    }
+    __mark('insertMergedEdges');
     return merged.length + goImpl.length + goMethodContains.length;
 }
 //# sourceMappingURL=callback-synthesizer.js.map