@aroman22/codegraph-vba-darwin-arm64 1.5.2 → 1.6.0

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

@@ -5,6 +5,7 @@ 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 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;
@@ -39,6 +40,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('');
 }
@@ -74,6 +84,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;
@@ -113,10 +152,13 @@ function* methodAndFunctionNodes(queries) {
     yield* queries.iterateNodesByKind('function');
 }
 /** Phase 1: field-backed observer channels (registrar/dispatcher share a store). */
-function fieldChannelEdges(queries, ctx) {
+async function fieldChannelEdges(queries, ctx, onYield) {
     const registrars = [];
     const dispatchers = [];
+    let scanned = 0;
     for (const m of methodAndFunctionNodes(queries)) {
+        if ((++scanned & 255) === 0)
+            await onYield(); // #1091: yield mid-scan on huge graphs
         const isReg = REGISTRAR_NAME.test(m.name);
         const isDisp = DISPATCHER_NAME.test(m.name);
         if (!isReg && !isDisp)
@@ -197,7 +239,7 @@ function fieldChannelEdges(queries, ctx) {
  * subclass `DataRequest.validate`), bounded by a fan-out cap so a generic field
  * name shared across unrelated classes can't fan out into noise.
  */
-function closureCollectionEdges(queries, ctx) {
+async function closureCollectionEdges(queries, ctx, onYield) {
     const dispatchers = new Map(); // field → dispatcher methods + forEach line
     const registrars = new Map(); // field → registrar methods + append line
     const addReg = (field, node, absLine) => {
@@ -208,7 +250,18 @@ function closureCollectionEdges(queries, ctx) {
             arr.push({ node, line: absLine });
         registrars.set(field, arr);
     };
+    // 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)
@@ -217,11 +270,13 @@ function closureCollectionEdges(queries, ctx) {
         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) });
@@ -231,12 +286,18 @@ function closureCollectionEdges(queries, ctx) {
         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 = [];
@@ -265,10 +326,16 @@ function closureCollectionEdges(queries, ctx) {
     return edges;
 }
 /** Phase 2: string-keyed EventEmitter channels (on('e', fn) ↔ emit('e')). */
-function eventEmitterEdges(ctx) {
+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);
         if (!content)
             continue;
@@ -277,7 +344,7 @@ function eventEmitterEdges(ctx) {
         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;
@@ -340,10 +407,13 @@ function eventEmitterEdges(ctx) {
  * `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')) {
+    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');
@@ -383,10 +453,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');
@@ -417,6 +490,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,
@@ -427,14 +773,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;
@@ -488,6 +837,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
@@ -501,7 +851,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
@@ -509,11 +860,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);
@@ -573,7 +937,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']);
@@ -581,7 +946,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`
@@ -651,13 +1020,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)
@@ -691,7 +1067,8 @@ 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
@@ -703,7 +1080,9 @@ function interfaceOverrideEdges(queries) {
     // 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();
             const implMethods = methodsOf(cls.id).filter((n) => IFACE_OVERRIDE_LANGS.has(n.language));
             if (implMethods.length === 0)
                 continue;
@@ -777,7 +1156,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$/;
@@ -789,7 +1169,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);
@@ -872,11 +1254,17 @@ function goGrpcStubImplEdges(queries) {
  * component/function/class node — TS generics like `Array<Foo>` resolve to a type
  * (or nothing) and are dropped.
  */
-function reactJsxChildEdges(ctx) {
+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);
         if (!content || (!content.includes('</') && !content.includes('/>')))
             continue; // JSX-file gate
@@ -924,7 +1312,9 @@ function reactJsxChildEdges(ctx) {
  * 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']);
@@ -938,12 +1328,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);
@@ -1077,18 +1471,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)
@@ -1271,11 +1668,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>`
@@ -1324,7 +1724,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']);
@@ -1346,6 +1747,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);
@@ -1396,17 +1799,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);
@@ -1459,12 +1872,15 @@ 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();
     // 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('::');
@@ -1480,6 +1896,8 @@ function mybatisJavaXmlEdges(queries) {
             javaIndex.set(key, [m]);
     }
     for (const xml of queries.iterateNodesByKind('method')) {
+        if ((++scanned255 & 63) === 0)
+            await onYield();
         if (xml.language !== 'xml')
             continue;
         // Qualified name: `<namespace>::<id>`. Extract the simple class name.
@@ -1593,10 +2011,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);
@@ -1611,6 +2033,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);
@@ -1666,10 +2090,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');
@@ -1705,12 +2132,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;
@@ -1759,10 +2189,13 @@ function svelteKitLoadEdges(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))
@@ -1893,10 +2326,16 @@ function resolveRegistryHandler(ctx, name, chained) {
     // entry resolving to the global URL constant).
     return cands.find((n) => n.kind === 'method') ?? null;
 }
-function objectRegistryEdges(ctx) {
+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))
             continue;
         const content = ctx.readFile(file);
@@ -2006,10 +2445,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;
@@ -2053,10 +2495,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);
@@ -2072,6 +2517,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);
@@ -2144,7 +2591,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);
@@ -2182,6 +2630,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);
@@ -2241,7 +2691,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.
@@ -2285,6 +2736,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);
@@ -2363,15 +2816,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)
@@ -2411,12 +2873,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;
@@ -2501,10 +2964,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);
@@ -2538,6 +3004,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);
@@ -2601,7 +3069,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();
@@ -2638,6 +3107,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);
@@ -2673,6 +3144,414 @@ function sidekiqDispatchEdges(ctx) {
     }
     return edges;
 }
+// ── 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
@@ -2719,7 +3598,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) => {
@@ -2736,6 +3616,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);
@@ -2781,6 +3663,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);
@@ -2831,53 +3715,169 @@ 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.
  */
-function synthesizeCallbackEdges(queries, ctx) {
+async function synthesizeCallbackEdges(queries, ctx) {
+    // 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
+    // watchdog to SIGKILL the process mid-index (#1091), since its heartbeat lives
+    // on this same thread. Yield between passes so the heartbeat can fire; a pass
+    // 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)();
+    // Per-pass wall-clock timing to stderr, opt-in via CODEGRAPH_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.CODEGRAPH_SYNTH_TIMINGS && (dt > 250 || process.env.CODEGRAPH_SYNTH_TIMINGS === 'all')) {
+            console.error(`[synth-timing] ${label}: ${dt}ms`);
+        }
+    };
+    // 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 JS_FAMILY = ['typescript', 'javascript', 'tsx', 'jsx'];
+    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);
+    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 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);
-    const fieldEdges = fieldChannelEdges(queries, ctx);
-    const closureCollEdges = closureCollectionEdges(queries, ctx);
-    const emitterEdges = eventEmitterEdges(ctx);
-    const renderEdges = reactRenderEdges(queries, ctx);
-    const jsxEdges = reactJsxChildEdges(ctx);
-    const vueEdges = vueTemplateEdges(ctx);
-    const svelteKitEdges = svelteKitLoadEdges(ctx);
-    const pascalEdges = pascalFormEdges(ctx);
-    const flutterEdges = flutterBuildEdges(queries, ctx);
-    const cppEdges = cppOverrideEdges(queries);
-    const ifaceEdges = interfaceOverrideEdges(queries);
-    const kotlinExpectActual = kotlinExpectActualEdges(queries);
-    const goGrpcEdges = goGrpcStubImplEdges(queries);
-    const rnEventEdgesList = rnEventEdges(ctx);
-    const fabricNativeEdges = fabricNativeImplEdges(ctx);
-    const expoXPlatEdges = expoCrossPlatformEdges(queries);
-    const rnXPlatEdges = rnCrossPlatformEdges(queries);
-    const mybatisEdges = mybatisJavaXmlEdges(queries);
-    const ginEdges = ginMiddlewareChainEdges(queries, ctx);
-    const thunkEdges = reduxThunkEdges(queries, ctx);
-    const registryEdges = objectRegistryEdges(ctx);
-    const rtkEdges = rtkQueryEdges(queries, ctx);
-    const piniaEdges = piniaStoreEdges(ctx);
-    const vuexEdges = vuexDispatchEdges(ctx);
-    const celeryEdges = celeryDispatchEdges(ctx);
-    const springEdges = springEventEdges(ctx);
-    const mediatrEdges = mediatrDispatchEdges(ctx);
-    const sidekiqEdges = sidekiqDispatchEdges(ctx);
-    const laravelEdges = laravelEventEdges(ctx);
-    const cFnPtrEdges = (0, c_fnptr_synthesizer_1.cFnPointerDispatchEdges)(queries, ctx);
-    const goframeEdges = (0, goframe_synthesizer_1.goframeRouteEdges)(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 yieldToLoop();
+    __mark('goImplements');
+    const fieldEdges = await fieldChannelEdges(queries, ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('fieldEdges');
+    const closureCollEdges = await closureCollectionEdges(queries, ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('closureCollEdges');
+    const emitterEdges = await eventEmitterEdges(ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('emitterEdges');
+    const renderEdges = await reactRenderEdges(queries, ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('renderEdges');
+    const jsxEdges = await reactJsxChildEdges(ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('jsxEdges');
+    const vueEdges = has('vue') ? await vueTemplateEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('vueEdges');
+    const svelteKitEdges = has('svelte') ? await svelteKitLoadEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('svelteKitEdges');
+    const pascalEdges = await pascalFormEdges(ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('pascalEdges');
+    const flutterEdges = has('dart') ? await flutterBuildEdges(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('flutterEdges');
+    const arkuiStateEdges = has('arkts') ? await arkuiStateBuildEdges(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('arkuiStateEdges');
+    const arkuiEmitter = has('arkts') ? await arkuiEmitterEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('arkuiEmitter');
+    const arkuiRoutes = has('arkts') ? await arkuiRouterEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('arkuiRoutes');
+    const cppEdges = has('cpp') ? await cppOverrideEdges(queries, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('cppEdges');
+    const ifaceEdges = has('java', 'kotlin', 'csharp', 'swift', 'scala', 'go', 'rust', 'arkts', ...JS_FAMILY)
+        ? await interfaceOverrideEdges(queries, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('ifaceEdges');
+    const kotlinExpectActual = has('kotlin') ? await kotlinExpectActualEdges(queries, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('kotlinExpectActual');
+    const goGrpcEdges = has('go') ? await goGrpcStubImplEdges(queries, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('goGrpcEdges');
+    const rnEventEdgesList = has(...JS_FAMILY) ? await rnEventEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('rnEventEdgesList');
+    const fabricNativeEdges = await fabricNativeImplEdges(ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('fabricNativeEdges');
+    const expoXPlatEdges = await expoCrossPlatformEdges(queries, yieldToLoop);
+    await yieldToLoop();
+    __mark('expoXPlatEdges');
+    const rnXPlatEdges = await rnCrossPlatformEdges(queries, yieldToLoop);
+    await yieldToLoop();
+    __mark('rnXPlatEdges');
+    const mybatisEdges = has('java', 'kotlin') && has('xml') ? await mybatisJavaXmlEdges(queries, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('mybatisEdges');
+    const ginEdges = has('go') ? await ginMiddlewareChainEdges(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('ginEdges');
+    const thunkEdges = has(...JS_FAMILY) ? await reduxThunkEdges(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('thunkEdges');
+    const registryEdges = await objectRegistryEdges(ctx, yieldToLoop);
+    await yieldToLoop();
+    __mark('registryEdges');
+    const rtkEdges = has(...JS_FAMILY) ? await rtkQueryEdges(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('rtkEdges');
+    const piniaEdges = has('vue', ...JS_FAMILY) ? await piniaStoreEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('piniaEdges');
+    const vuexEdges = has('vue', ...JS_FAMILY) ? await vuexDispatchEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('vuexEdges');
+    const celeryEdges = has('python') ? await celeryDispatchEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('celeryEdges');
+    const springEdges = has('java') ? await springEventEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('springEdges');
+    const mediatrEdges = has('csharp') ? await mediatrDispatchEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('mediatrEdges');
+    const sidekiqEdges = has('ruby') ? await sidekiqDispatchEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('sidekiqEdges');
+    const erlangBehaviourEdges = has('erlang') ? await erlangBehaviourDispatchEdges(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('erlangBehaviourEdges');
+    const laravelEdges = has('php') ? await laravelEventEdges(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('laravelEdges');
+    const cFnPtrEdges = has('c', 'cpp') ? await (0, c_fnptr_synthesizer_1.cFnPointerDispatchEdges)(queries, ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('cFnPtrEdges');
+    const goframeEdges = has('go') ? await (0, goframe_synthesizer_1.goframeRouteEdges)(ctx, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('goframeEdges');
+    const nixOptionEdges = has('nix') ? await nixOptionPathEdges(queries, yieldToLoop) : NONE;
+    await yieldToLoop();
+    __mark('nixOptionEdges');
     const merged = [];
     const seen = new Set();
     for (const e of [
@@ -2890,6 +3890,9 @@ function synthesizeCallbackEdges(queries, ctx) {
         ...svelteKitEdges,
         ...pascalEdges,
         ...flutterEdges,
+        ...arkuiStateEdges,
+        ...arkuiEmitter,
+        ...arkuiRoutes,
         ...cppEdges,
         ...ifaceEdges,
         ...kotlinExpectActual,
@@ -2909,9 +3912,11 @@ function synthesizeCallbackEdges(queries, ctx) {
         ...springEdges,
         ...mediatrEdges,
         ...sidekiqEdges,
+        ...erlangBehaviourEdges,
         ...laravelEdges,
         ...cFnPtrEdges,
         ...goframeEdges,
+        ...nixOptionEdges,
     ]) {
         const key = `${e.source}>${e.target}`;
         if (seen.has(key))
@@ -2919,8 +3924,15 @@ function synthesizeCallbackEdges(queries, ctx) {
         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();
+    }
+    __mark('insertMergedEdges');
     return merged.length + goImpl.length + goMethodContains.length;
 }
 //# sourceMappingURL=callback-synthesizer.js.map