homegraph 1.4.1 → 1.5.0

package/dist/resolution/callback-synthesizer.d.ts

@@ -1,23 +1,59 @@
+/**
+ * Callback / observer edge synthesis — Phase 1 + 2.
+ *
+ * Closes dynamic-dispatch holes where a dispatcher invokes callbacks registered
+ * elsewhere. Two channel shapes:
+ *
+ *  (1) Field-backed observer (Phase 1):
+ *      onUpdate(cb) { this.callbacks.add(cb); }            // registrar
+ *      triggerUpdate() { for (cb of this.callbacks) cb(); } // dispatcher
+ *      scene.onUpdate(this.triggerRender)                  // registration
+ *      → synthesize triggerUpdate → triggerRender
+ *
+ *  (2) String-keyed EventEmitter (Phase 2):
+ *      this.on('mount', function onmount(){...})           // registration
+ *      fn.emit('mount', this)                              // dispatch
+ *      → synthesize (method containing emit('mount')) → onmount
+ *
+ * Whole-graph pass after base resolution. High-precision/low-recall by design:
+ * named callbacks only; field channels paired by file+field; EventEmitter
+ * channels capped by event fan-out (generic names like 'error' skipped — they
+ * need receiver-type matching, deferred to Phase 3). All synthesized edges are
+ * tagged `provenance:'heuristic'`. See docs/design/callback-edge-synthesis.md.
+ */
+import type { Edge } from '../types';
 import type { QueryBuilder } from '../db/queries';
 import type { ResolutionContext } from './types';
+import { type MaybeYield } from './cooperative-yield';
+/** `has(...)` shape passed to pass gates — true when the project contains any of the languages. */
+type HasLang = (...ls: string[]) => boolean;
 /**
- * Synthesize dispatcher→callback edges (field observers + EventEmitters +
- * React re-render + JSX children + Vue templates + SvelteKit load + RN event
- * channel + Fabric native-impl + MyBatis Java↔XML + Gin middleware chain +
- * Redux-thunk dispatch chain + object-literal registry dispatch + RTK Query
- * generated-hook → endpoint + Pinia useStore().action() + Vuex string dispatch +
- * Celery task .delay()/.apply_async() → task body + Spring publishEvent → @EventListener +
- * MediatR Send/Publish → IRequestHandler/INotificationHandler +
- * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
- * Returns the count added. Never throws into indexing — callers wrap in try/catch.
+ * One independent synthesis pass. Every pass scans the COMMITTED graph (plus
+ * source via ctx) and returns an edge list; nothing it produces is persisted
+ * until the ordered merge in synthesizeCallbackEdges — which is what makes
+ * execution order free and the passes safe to fan out across the resolver
+ * pool's read-only workers. `gate` short-circuits a pass whose language never
+ * appears in the project (its result is provably empty — see #1212).
  */
+export interface SynthPassDef {
+    name: string;
+    gate: (has: HasLang) => boolean;
+    run: (queries: QueryBuilder, ctx: ResolutionContext, yieldToLoop: MaybeYield, subProgress?: (fraction: number) => void) => Promise<Edge[]>;
+}
 /**
- * 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 `__mark(` call count so adding a pass without
- * bumping this fails loudly instead of silently skewing the bar.
+ * 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.
  */
-export declare const SYNTH_PROGRESS_STEPS = 40;
-export declare function synthesizeCallbackEdges(queries: QueryBuilder, ctx: ResolutionContext, onProgress?: (done: number, total: number) => void): Promise<number>;
+export declare const SYNTH_PASSES: SynthPassDef[];
+export declare const SYNTH_PROGRESS_STEPS: number;
+export declare function synthesizeCallbackEdges(queries: QueryBuilder, ctx: ResolutionContext, onProgress?: (done: number, total: number) => void, pool?: {
+    runSynthPass(name: string): Promise<{
+        edges: Edge[];
+        ms: number;
+    }>;
+} | null, backpressure?: () => Promise<void> | null): Promise<number>;
+export {};
 //# sourceMappingURL=callback-synthesizer.d.ts.map

package/dist/resolution/callback-synthesizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callback-synthesizer.d.ts","sourceRoot":"","sources":["../../src/resolution/callback-synthesizer.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAi7GjD;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,iBAAiB,EACtB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACjD,OAAO,CAAC,MAAM,CAAC,CAkLjB"}
+{"version":3,"file":"callback-synthesizer.d.ts","sourceRoot":"","sources":["../../src/resolution/callback-synthesizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AASjD,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AA64GrE,mGAAmG;AACnG,KAAK,OAAO,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;IAChC,GAAG,EAAE,CACH,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,UAAU,EACvB,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,KACrC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;CACtB;AA6FD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,YAAY,EA6DtC,CAAC;AAIF,eAAO,MAAM,oBAAoB,QAA0C,CAAC;AAC5E,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,iBAAiB,EACtB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,EAIlD,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,GAAG,IAAI,EAIpF,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GACxC,OAAO,CAAC,MAAM,CAAC,CAmLjB"}

package/dist/resolution/callback-synthesizer.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SYNTH_PROGRESS_STEPS = void 0;
+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;
@@ -413,9 +413,28 @@ async function reactRenderEdges(queries, ctx, onYield) {
     let scanned255 = 0;
     const edges = [];
     const seen = new Set();
+    // 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');
@@ -1073,10 +1092,21 @@ 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.
@@ -1085,10 +1115,16 @@ async function interfaceOverrideEdges(queries, onYield) {
         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;
@@ -1878,6 +1914,20 @@ 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')) {
@@ -1897,11 +1947,9 @@ async function mybatisJavaXmlEdges(queries, onYield) {
         else
             javaIndex.set(key, [m]);
     }
-    for (const xml of queries.iterateNodesByKind('method')) {
+    for (const xml of xmlMethods) {
         if ((++scanned255 & 63) === 0)
             await onYield();
-        if (xml.language !== 'xml')
-            continue;
         // Qualified name: `<namespace>::<id>`. Extract the simple class name.
         const colonIdx = xml.qualifiedName.lastIndexOf('::');
         if (colonIdx < 0)
@@ -3706,6 +3754,26 @@ async function laravelEventEdges(ctx, onYield) {
     }
     return edges;
 }
+/**
+ * Synthesize dispatcher→callback edges (field observers + EventEmitters +
+ * React re-render + JSX children + Vue templates + SvelteKit load + RN event
+ * channel + Fabric native-impl + MyBatis Java↔XML + Gin middleware chain +
+ * Redux-thunk dispatch chain + object-literal registry dispatch + RTK Query
+ * generated-hook → endpoint + Pinia useStore().action() + Vuex string dispatch +
+ * Celery task .delay()/.apply_async() → task body + Spring publishEvent → @EventListener +
+ * MediatR Send/Publish → IRequestHandler/INotificationHandler +
+ * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
+ * Returns the count added. Never throws into indexing — callers wrap in try/catch.
+ */
+/**
+ * Number of progress steps synthesizeCallbackEdges reports: one per `__mark()`
+ * call (every synthesis pass, plus the dedupe-merge and edge-insert steps).
+ * Cosmetic only — drift just makes the progress bar end early or jump — and a
+ * test pins it to the actual step count (registry passes + the fixed
+ * pre/post marks) so adding a pass without bumping this fails loudly instead
+ * of silently skewing the bar.
+ */
+const JS_FAMILY = ['typescript', 'javascript', 'tsx', 'jsx'];
 /** ArkTS startup + UI lifecycle: loadContent → first screen, Ability chain, aboutToAppear → build. */
 function arktsEntryEdges(queries, ctx) {
     const edges = [];
@@ -3791,26 +3859,88 @@ function arktsEntryEdges(queries, ctx) {
     }
     return edges;
 }
+const ALWAYS = () => true;
 /**
- * Synthesize dispatcher→callback edges (field observers + EventEmitters +
- * React re-render + JSX children + Vue templates + SvelteKit load + RN event
- * channel + Fabric native-impl + MyBatis Java↔XML + Gin middleware chain +
- * Redux-thunk dispatch chain + object-literal registry dispatch + RTK Query
- * generated-hook → endpoint + Pinia useStore().action() + Vuex string dispatch +
- * Celery task .delay()/.apply_async() → task body + Spring publishEvent → @EventListener +
- * MediatR Send/Publish → IRequestHandler/INotificationHandler +
- * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
- * Returns the count added. Never throws into indexing — callers wrap in try/catch.
- */
-/**
- * Number of progress steps synthesizeCallbackEdges reports: one per `__mark()`
- * call (every synthesis pass, plus the dedupe-merge and edge-insert steps).
- * Cosmetic only — drift just makes the progress bar end early or jump — and a
- * test pins it to the actual `__mark(` call count so adding a pass without
- * bumping this fails loudly instead of silently skewing the bar.
+ * 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_PROGRESS_STEPS = 40;
-async function synthesizeCallbackEdges(queries, ctx, onProgress) {
+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
@@ -3865,17 +3995,24 @@ async function synthesizeCallbackEdges(queries, ctx, onProgress) {
     // 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)
+    // 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');
@@ -3887,162 +4024,78 @@ async function synthesizeCallbackEdges(queries, ctx, onProgress) {
     for (let i = 0; i < goImpl.length; i += 2000) {
         queries.insertEdges(goImpl.slice(i, i + 2000));
         await yieldToLoop();
+        await foldIfOver();
     }
     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, subProgress) : 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 arktsStartupEdges = has('arkts') ? arktsEntryEdges(queries, ctx) : NONE;
-    await yieldToLoop();
-    __mark('arktsStartupEdges');
+    // 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,
-        ...arkuiStateEdges,
-        ...arkuiEmitter,
-        ...arkuiRoutes,
-        ...cppEdges,
-        ...ifaceEdges,
-        ...kotlinExpectActual,
-        ...goGrpcEdges,
-        ...rnEventEdgesList,
-        ...fabricNativeEdges,
-        ...expoXPlatEdges,
-        ...rnXPlatEdges,
-        ...mybatisEdges,
-        ...ginEdges,
-        ...thunkEdges,
-        ...registryEdges,
-        ...rtkEdges,
-        ...piniaEdges,
-        ...vuexEdges,
-        ...celeryEdges,
-        ...springEdges,
-        ...mediatrEdges,
-        ...sidekiqEdges,
-        ...erlangBehaviourEdges,
-        ...laravelEdges,
-        ...cFnPtrEdges,
-        ...goframeEdges,
-        ...nixOptionEdges,
-        ...arktsStartupEdges,
-    ]) {
+    for (const e of passEdges.flat()) {
         const key = `${e.source}>${e.target}`;
         if (seen.has(key))
             continue;
@@ -4056,6 +4109,7 @@ async function synthesizeCallbackEdges(queries, ctx, onProgress) {
     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;