@quolu/lattice 0.43.0 → 0.45.0

package/sensor/dist/resolution/c-fnptr-synthesizer.js

@@ -83,17 +83,55 @@ exports.cFnPointerDispatchEdges = cFnPointerDispatchEdges;
  * Whole-graph pass after base resolution; all edges are `provenance:'heuristic'`
  * (`synthesizedBy:'fn-pointer-dispatch'`). High precision via the (type, field)
  * key + a real-function gate; a project with no fn-pointer dispatch is a no-op.
+ *
+ * ## Fuse-then-link architecture (§7a.8, task #5 step 1)
+ *
+ * The pass used to sweep every file's text FOUR times (typedefs, registrations,
+ * propagation, dispatch), and on the Linux kernel the all-or-nothing source
+ * cache declines, so each sweep re-read + re-stripped the whole corpus — 4.4
+ * strips/file, ~78s of the ~230s kernel-scale wall (§7a.8 calibration). It now
+ * runs as ONE extraction sweep plus filtered linking stages:
+ *
+ *   1. **Extraction sweep** — reads + strips each file ONCE and collects, per
+ *      file: typedef names, each struct node's field declarations (parsed
+ *      structurally, fn-pointer classification deferred — the typedef sets
+ *      aren't complete mid-sweep), the resolved local includes, and cheap
+ *      SURVIVAL FILTERS for the later stages (distinct initializer type
+ *      tokens, array element types, inline-struct summaries, field-assignment
+ *      field pairs, dispatch field / array names — all interned, a few MB even
+ *      on the kernel).
+ *   2. **Struct-layout linking** — classifies the deferred fields against the
+ *      now-complete typedef sets and registers layouts by replaying the struct
+ *      kind-scan, so registration order (which decides same-name layout
+ *      precedence) is byte-identical to the old dedicated pass.
+ *   3. **Registration / propagation / dispatch** — the original pass bodies,
+ *      UNCHANGED, but each file is first checked against its survival filter
+ *      and only surviving files are re-stripped (LRU-served). The filters only
+ *      ever over-approximate: a filtered-out file is one where every match
+ *      would have failed the pass's own gates before any side effect, so
+ *      skipping it cannot change the edge set. On the kernel only ~16% of
+ *      files have any dispatch-shaped match at all, so the lazy re-strips are
+ *      a fraction of a sweep and total strip work drops ~4.4× → ~1.5×.
+ *
+ * The extraction sweep is also the step-2 boundary: a native per-file extractor
+ * can replace the sweep's scans without touching the linking stages.
  */
 const path = __importStar(require("node:path"));
+const memory_budget_1 = require("./memory-budget");
 const lru_cache_1 = require("./lru-cache");
 const strip_comments_1 = require("./strip-comments");
+const loader_1 = require("../extraction/kernel/loader");
 const C_CPP_EXT = /\.(c|h|cc|cpp|cxx|hpp|hh|hxx|cppm|ipp|inl|tcc)$/i;
 const FN_KINDS = new Set(['function', 'method']);
 const FANOUT_CAP = 300; // a real command table (git ~150) is legitimate fan-out; this only stops pathological cases.
-function sliceLines(content, startLine, endLine) {
+/** Slice a node's body from a pre-split line array — the per-file sweeps
+ *  call this once per NODE, and splitting the whole file per node was an
+ *  O(nodes × file-size) term (~1.6M full-file splits on the Linux tree,
+ *  §7a.3 cFnPtr round). Split once per file, slice many times. */
+function sliceLinesPre(lines, startLine, endLine) {
     if (!startLine)
         return '';
-    return content.split('\n').slice(startLine - 1, endLine ?? startLine).join('\n');
+    return lines.slice(startLine - 1, endLine ?? startLine).join('\n');
 }
 /** Index of the `}` matching the `{` at `open` (which must point at a `{`). -1 if unbalanced. */
 function matchBrace(src, open) {
@@ -338,16 +376,66 @@ const C_TYPE_KEYWORDS = new Set([
 const INCLUDE_RE = /#[ \t]*include[ \t]+"([^"\n]+)"/g;
 /** Included files worth scanning for registration tables (e.g. a generated `.def`). */
 const INCLUDABLE_EXT = /\.(def|inc|h|hh|hpp|hxx|c|cc|cpp|cxx|ipp|tcc|tbl)$/i;
+/** `#define NAME single_identifier` (possibly `struct`-prefixed) — an
+ *  object-macro that COULD alias a struct type name (`resolveTypeName`'s exact
+ *  value shape). The extraction sweep collects every such NAME into a global
+ *  set: an initializer type token that direct-misses the struct layouts still
+ *  survives the registration filter when it is alias-SHAPED anywhere, so the
+ *  per-file macro-env alias resolution (redis' `COMMAND_STRUCT`) keeps working
+ *  without retaining per-file object-macro tables (6.1M `#define`s on the
+ *  Linux tree — the amdgpu register headers — rule that out). Numeric values
+ *  are excluded: `resolveTypeName` would rewrite to a dead-end token that can
+ *  never name a struct, so skipping them is exact, and it drops the register
+ *  flood. */
+const OBJ_ALIAS_RE = /^[ \t]*#[ \t]*define[ \t]+(\w+)[ \t]+(?:struct[ \t]+)*[A-Za-z_]\w*[ \t\r]*$/gm;
+/** `(?:struct )?TYPE name[opt] = {` initializers, where TYPE is a struct that
+ *  has ≥1 fn-pointer field. Handles both single (`= {…}`) and array
+ *  (`[] = { {…}, {…} }`) forms. Macro calls inside an element are expanded first. */
+const INIT_RE = /(?:^|[;{}])\s*(?:(?:static|const|extern|register|volatile)\s+)*(?:struct\s+)?(\w+)\s+(\w+)\s*(\[[^\]]*\])?\s*=\s*\{/g;
+/** `struct TAG { … } var[opt] [= {…}]` — the struct is defined INLINE with the
+ *  table (vim's `cmdname`/`nv_cmd`); its layout never became a node, so parse it
+ *  here and register it before reading the entries. No leading anchor: a
+ *  `struct TAG {` with a brace body is always a definition (it may be preceded
+ *  by a `#define …` line ending in a digit, as in vim), and the trailing
+ *  `var … = {` check below is what distinguishes a TABLE from a plain type. */
+const INLINE_STRUCT_RE = /\bstruct\s+(\w+)\s*\{/g;
+/** `(?:static …)* ELEMTYPE [*] name[…] = { … }` — a bare array of function
+ *  pointers (no struct wrapper). The optional `*` covers a function-TYPE
+ *  typedef element (`opcode_t *opcodes[]`); a function-pointer typedef element
+ *  (`zend_rc_dtor_func_t t[]`) needs none. The typedef-set membership gate
+ *  is what separates this from a plain data/struct array. */
+const ARRAY_TABLE_RE = /(?:^|[;{}])\s*(?:(?:static|const|extern|register|volatile)\s+)*(\w+)\s+(\*\s*)?(\w+)\s*\[[^\]]*\]\s*=\s*\{/g;
+/** Dispatch sites: `base->…->field(` or `base.…field(` where `field` is a known
+ *  fn-pointer field. The base may be a chain (`c->cmd->proc`) or carry array
+ *  subscripts (`cmdnames[i].cmd_func`). An optional `)` before the call covers
+ *  the parenthesized form `(cmdnames[i].cmd_func)(&ea)` vim uses. */
+const DISPATCH_RE = /((?:\w+(?:\s*\[[^\][]*\])?\s*(?:->|\.)\s*)+)(\w+)\s*\)?\s*\(/g;
+/** Bare-array dispatch: `tbl[i](…)` or the explicit-deref `(*tbl[i])(…)`. The
+ *  subscript may itself contain a call (`tbl[GC_TYPE(p)](…)`), so the index
+ *  class excludes only brackets. Precision comes from the `arrayReg` gate —
+ *  this fires only when `tbl` is a known fn-pointer array. */
+const ARRAY_DISPATCH_RE = /(?:\(\s*\*\s*)?\b(\w+)\s*\[[^\][]*\]\s*\)?\s*\(/g;
+/** Field←field propagation sites: `a->f = b->g`. */
+const FIELD_ASSIGN_RE = /(\w+)\s*(?:->|\.)\s*(\w+)\s*=\s*(\w+)\s*(?:->|\.)\s*(\w+)/g;
+const NO_INCLUDES = [];
 async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
     let scannedFiles = 0;
     const files = ctx.getAllFiles().filter((f) => C_CPP_EXT.test(f));
     if (files.length === 0)
         return [];
+    // LATTICE_SENSOR_SYNTH_TIMINGS sub-attribution: this pass is 86% of kernel-scale
+    // synthesis (306s, §7a.2/§7a.3) — per-stage walls + read/strip accounting
+    // name which stage and which cost class owns it. Post-refactor mapping:
+    // A = extraction sweep, B = struct-layout linking, C = registration,
+    // D = propagation, E = dispatch.
+    const prof = process.env.LATTICE_SENSOR_SYNTH_TIMINGS
+        ? { A: 0, B: 0, C: 0, D: 0, E: 0, readMs: 0, readN: 0, stripMs: 0, stripN: 0, nodesMs: 0, nodesN: 0 }
+        : null;
     // Within-pass progress: this is the pass that parks the "Linking dynamic
     // dispatch" bar on C-heavy repos, so it reports a real fraction of its
-    // dominant work. `files` is swept once per file loop below (passes A, C, D,
-    // E — pass B is node-bound and comparatively brief), reported at the same
-    // per-16-files cadence as the cooperative yield.
+    // dominant work. `files` is swept once per stage loop below (extraction,
+    // registration, propagation, dispatch), reported at the same per-16-files
+    // cadence as the cooperative yield.
     const FILE_SWEEPS = 4;
     const tick = async () => {
         if ((++scannedFiles & 15) === 0) {
@@ -358,18 +446,35 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
     // Cache raw + stripped source per file, LRU-BOUNDED. The old unbounded Maps
     // retained every C/C++ file's raw AND stripped text for the whole pass —
     // multiple GB on the Linux kernel, one of the two OOM culprits in #1212.
-    // Every sweep below iterates in `files` order, and node-kind scans return
-    // rows in file-commit order, so access is near-sequential and a small LRU
-    // hits; a miss just re-reads + re-strips.
-    const rawCache = new lru_cache_1.LRUCache(128);
+    // The extraction sweep reads sequentially; the linking stages re-request
+    // only surviving files (plus include units), so access is near-sequential
+    // and a small LRU hits; a miss just re-reads + re-strips.
+    // Cache sizing is memory-budget-aware AND all-or-nothing (§7a.3 cFnPtr
+    // round): a partial LRU is WORSE than useless for cyclic sweeps (a first
+    // attempt sized ~61k against 63.8k files thrashed to a ~0% cross-sweep hit
+    // rate). Hold every stripped file (~24KB each measured on the Linux tree)
+    // only when 40% of the live memory budget covers it; otherwise keep the
+    // within-stage-locality 128. When the big cache declines (the kernel), the
+    // survival filters keep the linking stages' re-strips to a fraction of a
+    // sweep. Slack over files.length: non-indexed includes (.def/.inc, generated
+    // headers) join the working set mid-pass. Pass-scoped transient, freed on
+    // return.
+    const fullCacheCap = Math.ceil(files.length * 1.05) + 512;
+    const cacheCap = (0, memory_budget_1.memoryBudgetBytes)() * 0.5 >= fullCacheCap * 24_576 ? fullCacheCap : 128;
+    const rawCache = new lru_cache_1.LRUCache(Math.min(cacheCap, 4096));
     const raw = (file) => {
         if (rawCache.has(file))
             return rawCache.get(file);
+        const t0 = prof ? Date.now() : 0;
         const r = ctx.readFile(file);
+        if (prof) {
+            prof.readMs += Date.now() - t0;
+            prof.readN++;
+        }
         rawCache.set(file, r);
         return r;
     };
-    const srcCache = new lru_cache_1.LRUCache(128);
+    const srcCache = new lru_cache_1.LRUCache(cacheCap);
     const src = (file) => {
         // A cached '' (empty or unreadable file) returns '' where the miss path
         // returns null for unreadable — every caller falsy-checks, so the two are
@@ -378,7 +483,12 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
         if (hit !== undefined)
             return hit;
         const r = raw(file);
+        const t0 = prof ? Date.now() : 0;
         const s = r == null ? '' : (0, strip_comments_1.stripCommentsForRegex)(r, 'c');
+        if (prof) {
+            prof.stripMs += Date.now() - t0;
+            prof.stripN++;
+        }
         srcCache.set(file, s);
         return r == null ? null : s;
     };
@@ -394,45 +504,40 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             return inc;
         return null;
     };
-    // ---- Pass A: function-pointer AND function-type typedefs (cross-file) ----
+    // Retained strings are interned through here. Regex captures off a big file
+    // string are V8 sliced strings — retaining one pins the whole parent file
+    // text, and the facts tables retain captures from EVERY file for the whole
+    // pass. The Buffer round-trip forces a flat copy on first sight; repeats
+    // (field names recur heavily) then share the one flat instance.
+    const interned = new Map();
+    const intern = (x) => {
+        let f = interned.get(x);
+        if (f === undefined) {
+            f = Buffer.from(x, 'utf8').toString('utf8');
+            interned.set(f, f);
+        }
+        return f;
+    };
+    // ---- Global tables the extraction sweep fills ----
     //   fn-pointer:  typedef RET (*NAME)(…)        → a field `NAME f` is a fn ptr
     //   fn-type:     typedef RET NAME(params)       → a field `NAME *f` is a fn ptr
     // The fn-type form is redis' command idiom: `typedef void redisCommandProc(client*)`
     // declared as `redisCommandProc *proc;`. Without this, `proc` reads as data.
     const fnPtrTypedefs = new Set();
     const fnTypeTypedefs = new Set();
-    for (const file of files) {
-        await tick();
-        const s = src(file);
-        if (!s || !s.includes('typedef'))
-            continue;
-        FNPTR_TYPEDEF_RE.lastIndex = 0;
-        let m;
-        while ((m = FNPTR_TYPEDEF_RE.exec(s)))
-            fnPtrTypedefs.add(m[1]);
-        FNTYPE_TYPEDEF_STMT_RE.lastIndex = 0;
-        while ((m = FNTYPE_TYPEDEF_STMT_RE.exec(s))) {
-            const guts = m[1];
-            if (guts.includes('(*') || guts.includes('( *'))
-                continue; // pointer form — handled above
-            const fm = guts.match(/\b(\w+)\s*\(/); // last identifier before the param list
-            if (fm && !C_TYPE_KEYWORDS.has(fm[1]))
-                fnTypeTypedefs.add(fm[1]);
-        }
-    }
-    // ---- Pass B: struct field layouts ----
-    // structLayout: struct name → ordered fields, for structs with ≥1 fn-pointer
-    //   field (drives positional registration + dispatch).
-    // allStructFields: EVERY struct name → ALL its field layouts (a name can be
-    //   reused across files — e.g. redis has two unrelated `client` structs), used
-    //   to walk a chained receiver's field types (`c->cmd->proc`: client.cmd →
-    //   redisCommand). The walk searches every same-named layout for the field.
-    // fieldToStructs: fn-pointer field name → set of struct names that declare it.
-    const structLayout = new Map();
-    const allStructFields = new Map();
-    const fieldToStructs = new Map();
-    // Parse a struct body (the text between its `{` and `}`) into ordered fields.
-    const parseStructFields = (inner) => {
+    /** Struct node id → its structurally-parsed fields (classified + registered
+     *  in the linking stage, in kind-scan order). */
+    const rawFieldsByNode = new Map();
+    const factsByFile = new Map();
+    /** Every inline-struct candidate tag anywhere — an over-approximation of the
+     *  tags the registration stage can add to `structLayout` mid-stage, folded
+     *  into the registration filter's layout check. */
+    const inlineTags = new Set();
+    /** Object-macro names with an alias-shaped value anywhere (see OBJ_ALIAS_RE). */
+    const aliasNames = new Set();
+    // Parse a struct body (the text between its `{` and `}`) into ordered fields,
+    // structure only — see RawFieldDecl for why classification is deferred.
+    const parseStructFieldsRaw = (inner) => {
         const fields = [];
         let idx = 0;
         for (const rawDecl of splitTopLevel(inner, ';')) {
@@ -449,11 +554,11 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
                 const p = parts[pi].trim();
                 let name = null;
                 let type = '';
-                let isFnPtr = false;
-                const ptr = p.match(FNPTR_DECL_RE);
-                if (ptr) {
-                    name = ptr[1]; // `… (*name)(…)` — a function pointer
-                    isFnPtr = true;
+                let ptr = false;
+                const pm = p.match(FNPTR_DECL_RE);
+                if (pm) {
+                    name = pm[1]; // `… (*name)(…)` — a function pointer
+                    ptr = true;
                 }
                 else if (pi === 0) {
                     if (firstTyped) {
@@ -469,17 +574,288 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
                         type = sharedType;
                     }
                 }
-                if (!ptr && type)
-                    isFnPtr = fnPtrTypedefs.has(type) || fnTypeTypedefs.has(type);
                 // Always advance the positional index. An unparsed field (anonymous
                 // union, exotic declarator) still occupies one slot, and macro-expanded
                 // positional tables (redis' MAKE_CMD) only align if every field counts.
-                fields.push({ name: name ?? '', index: idx, isFnPtr: !!name && isFnPtr, type });
+                fields.push({ name, index: idx, ptr, type });
                 idx++;
             }
         }
         return fields;
     };
+    // Classify deferred fields against the (now-complete) typedef sets.
+    const classifyFields = (rawFields) => rawFields.map((f) => ({
+        name: f.name ?? '',
+        index: f.index,
+        isFnPtr: !!f.name &&
+            (f.ptr || (!!f.type && (fnPtrTypedefs.has(f.type) || fnTypeTypedefs.has(f.type)))),
+        type: f.type,
+    }));
+    const parseStructFields = (inner) => classifyFields(parseStructFieldsRaw(inner));
+    // Exact per-file include resolution (from RAW source — string contents survive).
+    const scanIncludes = (file) => {
+        const rawText = raw(file);
+        if (!rawText || !rawText.includes('include'))
+            return NO_INCLUDES;
+        const out = [];
+        INCLUDE_RE.lastIndex = 0;
+        let im;
+        while ((im = INCLUDE_RE.exec(rawText))) {
+            if (!INCLUDABLE_EXT.test(im[1]))
+                continue;
+            const t = resolveInclude(file, im[1]);
+            if (t)
+                out.push(intern(t));
+        }
+        return out.length ? out : NO_INCLUDES;
+    };
+    // Indexed files answer from their facts; non-indexed includes (reached by
+    // buildEnv's depth-2 recursion) fall back to a bounded lazy scan.
+    const includeCache = new lru_cache_1.LRUCache(1024);
+    const localIncludesOf = (file) => {
+        const f = factsByFile.get(file);
+        if (f)
+            return f.includes;
+        let out = includeCache.get(file);
+        if (out)
+            return out;
+        out = scanIncludes(file);
+        includeCache.set(file, out);
+        return out;
+    };
+    // ---- Stage A: the extraction sweep — ONE read + strip per file ----
+    //
+    // Two implementations, record-identical by the differential suite:
+    //   • native (task #5 step 2): the kernel's `cfnptrScanFiles` strips and
+    //     scans a BATCH of files per NAPI call (lattice-sensor-kernel/src/cfnptr.rs —
+    //     hand-rolled byte machines replicating the JS regex semantics), and the
+    //     TS side only reads files, ships batches, and interns the returned
+    //     facts. Include-path resolution stays here (it needs the filesystem).
+    //   • JS: the original sweep, kept verbatim — the fallback for platforms
+    //     without a kernel binary, older binaries (feature detection), the
+    //     LATTICE_SENSOR_KERNEL=0 kill switch, and LATTICE_SENSOR_KERNEL_CFNPTR=0 (this
+    //     scanner's own switch).
+    const kernel = process.env.LATTICE_SENSOR_KERNEL === '0' || process.env.LATTICE_SENSOR_KERNEL_CFNPTR === '0'
+        ? null
+        : (0, loader_1.getKernel)();
+    const nativeSweep = kernel && typeof kernel.cfnptrScanFiles === 'function' ? kernel.cfnptrScanFiles.bind(kernel) : null;
+    const mergeNativeFacts = (file, out) => {
+        for (const t of out.fnPtrTypedefs)
+            fnPtrTypedefs.add(intern(t));
+        for (const t of out.fnTypeTypedefs)
+            fnTypeTypedefs.add(intern(t));
+        for (const so of out.structs) {
+            if (!so.parsed)
+                continue; // body never parsed — the JS sweep records nothing either
+            rawFieldsByNode.set(so.id, so.fields.map((f) => ({ name: f.name || null, index: f.index, ptr: f.ptr, type: f.type })));
+        }
+        for (const t of out.inlineTags)
+            inlineTags.add(intern(t));
+        for (const t of out.aliasNames)
+            aliasNames.add(intern(t));
+        const includes = [];
+        for (const cap of out.includes) {
+            if (!INCLUDABLE_EXT.test(cap))
+                continue;
+            const t = resolveInclude(file, cap);
+            if (t)
+                includes.push(intern(t));
+        }
+        if (out.initTokens.length || out.arrayElems.length || out.inlinePtr || out.inlineTypes.length ||
+            out.dPairs.length || out.dispatchFields.length || out.arrayDispatchNames.length || includes.length) {
+            factsByFile.set(file, {
+                initTokens: out.initTokens.length ? out.initTokens.map(intern) : null,
+                arrayElems: out.arrayElems.length ? out.arrayElems.map(intern) : null,
+                inlinePtr: out.inlinePtr,
+                inlineTypes: out.inlineTypes.length ? out.inlineTypes.map(intern) : null,
+                dPairs: out.dPairs.length ? out.dPairs.map(intern) : null,
+                dispatchFields: out.dispatchFields.length ? out.dispatchFields.map(intern) : null,
+                arrayDispatchNames: out.arrayDispatchNames.length ? out.arrayDispatchNames.map(intern) : null,
+                includes: includes.length ? includes : NO_INCLUDES,
+            });
+        }
+    };
+    let tPass = Date.now();
+    if (nativeSweep) {
+        // Batch of 16 = the tick/onFraction cadence, so yielding and progress
+        // reporting keep their shape while the boundary crossing amortizes.
+        const BATCH = 16;
+        let batch = [];
+        const flush = () => {
+            if (batch.length === 0)
+                return;
+            const outs = nativeSweep(batch.map((b) => b.input));
+            for (let bi = 0; bi < batch.length; bi++)
+                mergeNativeFacts(batch[bi].file, outs[bi]);
+            batch = [];
+        };
+        for (const file of files) {
+            await tick();
+            const rawText = raw(file);
+            if (!rawText)
+                continue; // unreadable or empty — the JS sweep skips these too
+            const tN = prof ? Date.now() : 0;
+            const fileNodes = ctx.getNodesInFile(file);
+            if (prof) {
+                prof.nodesMs += Date.now() - tN;
+                prof.nodesN++;
+            }
+            const structs = [];
+            for (const st of fileNodes) {
+                if (st.kind !== 'struct')
+                    continue;
+                // sliceLinesPre semantics ride along: falsy startLine never parses,
+                // and `endLine ?? startLine` is applied here so the kernel sees the
+                // exact slice bounds the JS sweep would use.
+                structs.push({ id: st.id, startLine: st.startLine ?? 0, endLine: st.endLine ?? st.startLine ?? 0 });
+            }
+            batch.push({ file, input: { text: rawText, structs } });
+            if (batch.length >= BATCH)
+                flush();
+        }
+        flush();
+    }
+    // JS sweep (fallback path — see the stage comment above).
+    if (!nativeSweep)
+        for (const file of files) {
+            await tick();
+            const s = src(file);
+            if (!s)
+                continue;
+            // Typedefs (cross-file).
+            if (s.includes('typedef')) {
+                FNPTR_TYPEDEF_RE.lastIndex = 0;
+                let m;
+                while ((m = FNPTR_TYPEDEF_RE.exec(s)))
+                    fnPtrTypedefs.add(intern(m[1]));
+                FNTYPE_TYPEDEF_STMT_RE.lastIndex = 0;
+                while ((m = FNTYPE_TYPEDEF_STMT_RE.exec(s))) {
+                    const guts = m[1];
+                    if (guts.includes('(*') || guts.includes('( *'))
+                        continue; // pointer form — handled above
+                    const fm = guts.match(/\b(\w+)\s*\(/); // last identifier before the param list
+                    if (fm && !C_TYPE_KEYWORDS.has(fm[1]))
+                        fnTypeTypedefs.add(intern(fm[1]));
+                }
+            }
+            // Struct-node field declarations (registered later in kind-scan order).
+            const tN = prof ? Date.now() : 0;
+            const fileNodes = ctx.getNodesInFile(file);
+            if (prof) {
+                prof.nodesMs += Date.now() - tN;
+                prof.nodesN++;
+            }
+            let lines = null;
+            for (const st of fileNodes) {
+                if (st.kind !== 'struct')
+                    continue;
+                lines ??= s.split('\n');
+                const body = sliceLinesPre(lines, st.startLine, st.endLine);
+                const open = body.indexOf('{');
+                const close = open >= 0 ? matchBrace(body, open) : -1;
+                if (open < 0 || close < 0)
+                    continue;
+                rawFieldsByNode.set(st.id, parseStructFieldsRaw(body.slice(open + 1, close)));
+            }
+            // Registration filters. These are full-file, NO-SKIP scans: the original
+            // registration pass jumps its scan cursor past a processed initializer
+            // body, so a no-skip scan finds a SUPERSET of its matches — exactly the
+            // over-approximation the filter needs.
+            const initTokens = new Set();
+            const arrayElems = new Set();
+            const inlineTypes = new Set();
+            let inlinePtr = false;
+            if (s.includes('{')) {
+                INLINE_STRUCT_RE.lastIndex = 0;
+                let im;
+                while ((im = INLINE_STRUCT_RE.exec(s))) {
+                    const sOpen = im.index + im[0].length - 1;
+                    const sClose = matchBrace(s, sOpen);
+                    if (sClose < 0)
+                        continue;
+                    // After `}`, expect `var [opt] [= {…}]` to be a table candidate.
+                    const vm = s.slice(sClose + 1).match(/^\s*(\w+)\s*(\[[^\]]*\])?\s*(=\s*\{)?/);
+                    if (!vm || !vm[1])
+                        continue;
+                    inlineTags.add(intern(im[1]));
+                    for (const f of parseStructFieldsRaw(s.slice(sOpen + 1, sClose))) {
+                        if (!f.name)
+                            continue;
+                        if (f.ptr)
+                            inlinePtr = true;
+                        else if (f.type)
+                            inlineTypes.add(intern(f.type));
+                    }
+                }
+                if (s.includes('=')) {
+                    INIT_RE.lastIndex = 0;
+                    let m;
+                    while ((m = INIT_RE.exec(s)))
+                        initTokens.add(intern(m[1]));
+                    ARRAY_TABLE_RE.lastIndex = 0;
+                    while ((m = ARRAY_TABLE_RE.exec(s)))
+                        arrayElems.add(intern((m[2] ? '*' : '') + m[1]));
+                }
+            }
+            // Alias-shaped object macros (registration filter support).
+            if (s.includes('#define') || s.includes('# define')) {
+                const joined = s.replace(/\\\r?\n/g, ' ');
+                OBJ_ALIAS_RE.lastIndex = 0;
+                let m;
+                while ((m = OBJ_ALIAS_RE.exec(joined)))
+                    aliasNames.add(intern(m[1]));
+            }
+            // Propagation + dispatch filters (full-file scans ⊇ the per-function-body
+            // scans the pass bodies run — a body slice is a substring of the file).
+            const dPairs = new Set();
+            if (s.includes('=')) {
+                FIELD_ASSIGN_RE.lastIndex = 0;
+                let m;
+                while ((m = FIELD_ASSIGN_RE.exec(s)))
+                    dPairs.add(intern(m[2] + '\0' + m[4]));
+            }
+            const dispatchFields = new Set();
+            const arrayNames = new Set();
+            DISPATCH_RE.lastIndex = 0;
+            let dm;
+            while ((dm = DISPATCH_RE.exec(s)))
+                dispatchFields.add(intern(dm[2]));
+            ARRAY_DISPATCH_RE.lastIndex = 0;
+            while ((dm = ARRAY_DISPATCH_RE.exec(s)))
+                arrayNames.add(intern(dm[1]));
+            const includes = scanIncludes(file);
+            if (initTokens.size || arrayElems.size || inlinePtr || inlineTypes.size ||
+                dPairs.size || dispatchFields.size || arrayNames.size || includes.length) {
+                factsByFile.set(file, {
+                    initTokens: initTokens.size ? [...initTokens] : null,
+                    arrayElems: arrayElems.size ? [...arrayElems] : null,
+                    inlinePtr,
+                    inlineTypes: inlineTypes.size ? [...inlineTypes] : null,
+                    dPairs: dPairs.size ? [...dPairs] : null,
+                    dispatchFields: dispatchFields.size ? [...dispatchFields] : null,
+                    arrayDispatchNames: arrayNames.size ? [...arrayNames] : null,
+                    includes,
+                });
+            }
+        }
+    if (prof) {
+        prof.A = Date.now() - tPass;
+        tPass = Date.now();
+    }
+    // ---- Stage B: struct field layouts (linking — text-free) ----
+    // structLayout: struct name → ordered fields, for structs with ≥1 fn-pointer
+    //   field (drives positional registration + dispatch).
+    // allStructFields: EVERY struct name → ALL its field layouts (a name can be
+    //   reused across files — e.g. redis has two unrelated `client` structs), used
+    //   to walk a chained receiver's field types (`c->cmd->proc`: client.cmd →
+    //   redisCommand). The walk searches every same-named layout for the field.
+    // fieldToStructs: fn-pointer field name → set of struct names that declare it.
+    // Registration REPLAYS the struct kind-scan (rowid order, ≠ the extraction
+    // sweep's path order): same-name layout precedence — `structLayout.set`
+    // last-wins, `allStructFields` first-match in the chain walk — depends on it.
+    const structLayout = new Map();
+    const allStructFields = new Map();
+    const fieldToStructs = new Map();
     // Register a parsed struct under `name` into the three indexes.
     const registerStructLayout = (name, fields) => {
         if (!allStructFields.has(name))
@@ -500,22 +876,22 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             await onYield();
         if (!C_CPP_EXT.test(st.filePath))
             continue;
-        const s = src(st.filePath);
-        if (!s)
-            continue;
-        const body = sliceLines(s, st.startLine, st.endLine);
-        const open = body.indexOf('{');
-        const close = open >= 0 ? matchBrace(body, open) : -1;
-        if (open < 0 || close < 0)
-            continue;
-        registerStructLayout(st.name, parseStructFields(body.slice(open + 1, close)));
+        const rawFields = rawFieldsByNode.get(st.id);
+        if (!rawFields)
+            continue; // file unreadable or body unparsable at sweep time — the old pass skipped it too
+        registerStructLayout(st.name, classifyFields(rawFields));
+    }
+    rawFieldsByNode.clear();
+    if (prof) {
+        prof.B = Date.now() - tPass;
+        tPass = Date.now();
     }
     // NB: no early return on an empty structLayout here — an inline `struct TAG
     // { … } var[]` table whose struct never became a node (vim's `cmdname`, broken
     // up by `#ifdef`) is discovered later during the unit scan. The `reg.size === 0`
     // guard after registration still short-circuits when nothing bridges.
     const fnPtrFieldOf = (struct, field) => !!structLayout.get(struct)?.some((f) => f.name === field && f.isFnPtr);
-    // C/C++ function + method nodes are STREAMED per sweep (see passes D/E) —
+    // C/C++ function + method nodes are STREAMED per stage (see D/E) —
     // the old materialized `cFns` array held every function node on the repo
     // (O(nodes) memory, part of the #1212 kernel OOM).
     // ---- function-name → node resolution (prefer a function in the same file) ----
@@ -532,7 +908,7 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
         }
         return cands[0];
     };
-    // ---- Pass C: registrations — Map<"struct.field", Set<funcNodeId>> ----
+    // ---- Stage C: registrations — Map<"struct.field", Set<funcNodeId>> ----
     // Ids only — retaining the full Node per registration (the old `idToNode`)
     // was write-only dead weight at O(registrations) memory.
     const reg = new Map();
@@ -634,6 +1010,10 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
     };
     // Per-file macro + include parsing (any file, indexed or not), cached.
     // Derived per-file caches, LRU-bounded like the content caches (#1212).
+    // These stay LAZY (recompute-on-miss through `src`): retaining every file's
+    // parsed tables is ruled out by the kernel's 6.1M `#define`s, and the
+    // registration stage below only builds an env for files that survive its
+    // filter or carry local includes, so most files never need one.
     const fnMacroCache = new lru_cache_1.LRUCache(256);
     const fileFnMacros = (file) => {
         let m = fnMacroCache.get(file);
@@ -661,27 +1041,6 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
         }
         return d;
     };
-    const includeCache = new lru_cache_1.LRUCache(1024);
-    const localIncludesOf = (file) => {
-        let out = includeCache.get(file);
-        if (out)
-            return out;
-        out = [];
-        const rawText = raw(file);
-        if (rawText && rawText.includes('include')) {
-            INCLUDE_RE.lastIndex = 0;
-            let im;
-            while ((im = INCLUDE_RE.exec(rawText))) {
-                if (!INCLUDABLE_EXT.test(im[1]))
-                    continue;
-                const t = resolveInclude(file, im[1]);
-                if (t)
-                    out.push(t);
-            }
-        }
-        includeCache.set(file, out);
-        return out;
-    };
     // A file's effective macro environment = its own #defines PLUS those of the
     // headers it #includes (redis' `MAKE_CMD` sits beside the table; sqlite's
     // `FUNCTION` lives in `sqliteInt.h`, included by the file with the table).
@@ -727,23 +1086,6 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             registerStructValue(struct, body, file, env);
         }
     };
-    // `(?:struct )?TYPE name[opt] = {` initializers, where TYPE is a struct that
-    // has ≥1 fn-pointer field. Handles both single (`= {…}`) and array
-    // (`[] = { {…}, {…} }`) forms. Macro calls inside an element are expanded first.
-    const INIT_RE = /(?:^|[;{}])\s*(?:(?:static|const|extern|register|volatile)\s+)*(?:struct\s+)?(\w+)\s+(\w+)\s*(\[[^\]]*\])?\s*=\s*\{/g;
-    // `struct TAG { … } var[opt] [= {…}]` — the struct is defined INLINE with the
-    // table (vim's `cmdname`/`nv_cmd`); its layout never became a node, so parse it
-    // here and register it before reading the entries. No leading anchor: a
-    // `struct TAG {` with a brace body is always a definition (it may be preceded
-    // by a `#define …` line ending in a digit, as in vim), and the trailing
-    // `var … = {` check below is what distinguishes a TABLE from a plain type.
-    const INLINE_STRUCT_RE = /\bstruct\s+(\w+)\s*\{/g;
-    // `(?:static …)* ELEMTYPE [*] name[…] = { … }` — a bare array of function
-    // pointers (no struct wrapper). The optional `*` covers a function-TYPE
-    // typedef element (`opcode_t *opcodes[]`); a function-pointer typedef element
-    // (`zend_rc_dtor_func_t t[]`) needs none. The typedef-set membership gate
-    // (below) is what separates this from a plain data/struct array.
-    const ARRAY_TABLE_RE = /(?:^|[;{}])\s*(?:(?:static|const|extern|register|volatile)\s+)*(\w+)\s+(\*\s*)?(\w+)\s*\[[^\]]*\]\s*=\s*\{/g;
     // Process ONE unit's text and discard it. The old shape built every unit up
     // front (`const units: Unit[]`) — the full text of every C file plus its
     // expanded includes held simultaneously, gigabytes on the kernel (#1212).
@@ -817,18 +1159,42 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             ARRAY_TABLE_RE.lastIndex = close;
         }
     };
-    // ---- Pass C: registrations — stream each file (and its qualifying local
-    // includes) through processUnit, one at a time.
+    // Can this file's OWN unit have any side effect? Every check mirrors a gate
+    // in processUnit, over-approximated to the filter's coarser knowledge:
+    //   • inline structs — the fn-ptr-field gate, with per-candidate field types
+    //     unioned per file;
+    //   • initializers — `structLayout.has` against the layouts' SUPERSET
+    //     (kind-scan layouts ∪ every inline tag — structLayout only grows during
+    //     this stage), with alias-shaped tokens surviving in place of the
+    //     per-file `resolveTypeName` walk;
+    //   • bare arrays — the exact typedef-set gate.
+    // A filtered-out file is one where every match fails its gate before any
+    // side effect, so skipping the unit cannot change the outcome.
+    const typedefHit = (t) => fnPtrTypedefs.has(t) || fnTypeTypedefs.has(t);
+    const regSurvives = (f) => f.inlinePtr ||
+        (f.inlineTypes?.some(typedefHit) ?? false) ||
+        (f.initTokens?.some((t) => structLayout.has(t) || inlineTags.has(t) || aliasNames.has(t)) ?? false) ||
+        (f.arrayElems?.some((e) => e.charCodeAt(0) === 42 /* '*' */ ? typedefHit(e.slice(1)) : fnPtrTypedefs.has(e)) ?? false);
+    // ---- Stage C: registrations — stream each surviving file (and every file's
+    // qualifying local includes) through processUnit, one at a time.
     for (const file of files) {
         await tick();
+        const facts = factsByFile.get(file);
+        if (!facts)
+            continue; // no facts ⇒ nothing matched at sweep time ⇒ the old pass would no-op here
+        const survives = regSurvives(facts);
+        if (!survives && facts.includes.length === 0)
+            continue;
         const env = new Map();
         const objEnv = new Map();
         const defined = new Set();
         buildEnv(file, 2, new Set(), env, objEnv, defined);
-        const s = src(file);
-        if (s)
-            processUnit({ text: s, file, env, objEnv });
-        for (const target of localIncludesOf(file)) {
+        if (survives) {
+            const s = src(file);
+            if (s)
+                processUnit({ text: s, file, env, objEnv });
+        }
+        for (const target of facts.includes) {
             if (seenInclude.has(`${file}>${target}`))
                 continue;
             const incSrc = src(target);
@@ -857,11 +1223,21 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             processUnit({ text, file: target, env: incEnv, objEnv: incObjEnv });
         }
     }
+    if (prof) {
+        prof.C = Date.now() - tPass;
+        tPass = Date.now();
+    }
     // ---- receiver-type resolution within a function's source ----
     // `(?:struct )?TYPE [*]recv` declared in the params or body → TYPE (if a known
     //  fn-pointer-bearing struct).
+    const recvReCache = new Map();
     const recvTypeIn = (fnSrc, recv) => {
-        const re = new RegExp(`(?:struct\\s+)?(\\w+)\\s*\\*?\\s*\\b${recv}\\b\\s*(?:[,)=;]|\\[)`, 'g');
+        let re = recvReCache.get(recv);
+        if (!re) {
+            re = new RegExp(`(?:struct\\s+)?(\\w+)\\s*\\*?\\s*\\b${recv}\\b\\s*(?:[,)=;]|\\[)`, 'g');
+            recvReCache.set(recv, re);
+        }
+        re.lastIndex = 0;
         let m;
         while ((m = re.exec(fnSrc))) {
             if (structLayout.has(m[1]))
@@ -873,8 +1249,14 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
     // structs (the base of a chained receiver needn't carry a fn pointer itself).
     // Falls back to a file-scope table variable (`cmdnames` in `cmdnames[i].fn()`).
     const escapeRe = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const varReCache = new Map();
     const varTypeIn = (fnSrc, v) => {
-        const re = new RegExp(`(?:struct\\s+)?(\\w+)\\s*\\*?\\s*\\b${escapeRe(v)}\\b\\s*(?:[,)=;]|\\[)`, 'g');
+        let re = varReCache.get(v);
+        if (!re) {
+            re = new RegExp(`(?:struct\\s+)?(\\w+)\\s*\\*?\\s*\\b${escapeRe(v)}\\b\\s*(?:[,)=;]|\\[)`, 'g');
+            varReCache.set(v, re);
+        }
+        re.lastIndex = 0;
         let m;
         while ((m = re.exec(fnSrc))) {
             if (!C_TYPE_KEYWORDS.has(m[1]))
@@ -904,26 +1286,47 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
         }
         return t;
     };
-    // ---- Pass D: field←field propagation (`a->f = b->g`) ----
+    // ---- Stage D: field←field propagation (`a->f = b->g`) ----
     // Collected as (targetStruct.field ← sourceStruct.field) pairs, then merged to
     // a fixpoint so a hook slot inherits a registry field's handlers.
-    const FIELD_ASSIGN_RE = /(\w+)\s*(?:->|\.)\s*(\w+)\s*=\s*(\w+)\s*(?:->|\.)\s*(\w+)/g;
+    // Filter: a file matters only if SOME collected pair has BOTH fields known as
+    // fn-pointer fields — the loop body's own pre-gate. A skipped file's matches
+    // would all `continue` there, so skipping is side-effect-free.
     const propagations = [];
     for (const file of files) {
         await tick();
+        const facts = factsByFile.get(file);
+        if (!facts?.dPairs?.some((p) => {
+            const i = p.indexOf('\0');
+            return fieldToStructs.has(p.slice(0, i)) && fieldToStructs.has(p.slice(i + 1));
+        }))
+            continue;
         const s = src(file);
         if (!s || !s.includes('='))
             continue;
-        for (const fn of ctx.getNodesInFile(file)) {
+        const tN = prof ? Date.now() : 0;
+        const fnsD = ctx.getNodesInFile(file);
+        if (prof) {
+            prof.nodesMs += Date.now() - tN;
+            prof.nodesN++;
+        }
+        const dLines = s.split('\n');
+        for (const fn of fnsD) {
             if (!FN_KINDS.has(fn.kind))
                 continue;
-            const body = sliceLines(s, fn.startLine, fn.endLine);
+            const body = sliceLinesPre(dLines, fn.startLine, fn.endLine);
             if (!body.includes('='))
                 continue;
             FIELD_ASSIGN_RE.lastIndex = 0;
             let m;
             while ((m = FIELD_ASSIGN_RE.exec(body))) {
                 const [, lrecv, lfield, rrecv, rfield] = m;
+                // Pre-gate on field NAMES: `a->f = b->g` matches every struct-field
+                // assignment in the tree (millions on the kernel), but only fields
+                // that are fn-pointer fields of SOME struct can pass fnPtrFieldOf —
+                // skip the two regex type resolutions for the ~99% that can't.
+                if (!fieldToStructs.has(lfield) || !fieldToStructs.has(rfield))
+                    continue;
                 const lt = recvTypeIn(body, lrecv);
                 const rt = recvTypeIn(body, rrecv);
                 if (lt && rt && fnPtrFieldOf(lt, lfield) && fnPtrFieldOf(rt, rfield)) {
@@ -951,33 +1354,57 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
         if (!changed)
             break;
     }
+    if (prof) {
+        prof.D = Date.now() - tPass;
+        tPass = Date.now();
+    }
     if (reg.size === 0 && arrayReg.size === 0)
         return [];
-    // ---- Pass E: dispatch sites → edges ----
-    // `base->…->field(` or `base.…field(` where `field` is a known fn-pointer field.
-    // The base may be a chain (`c->cmd->proc`) or carry array subscripts
-    // (`cmdnames[i].cmd_func`). An optional `)` before the call covers the
-    // parenthesized form `(cmdnames[i].cmd_func)(&ea)` vim uses.
-    const DISPATCH_RE = /((?:\w+(?:\s*\[[^\][]*\])?\s*(?:->|\.)\s*)+)(\w+)\s*\)?\s*\(/g;
-    // Bare-array dispatch: `tbl[i](…)` or the explicit-deref `(*tbl[i])(…)`. The
-    // subscript may itself contain a call (`tbl[GC_TYPE(p)](…)`), so the index
-    // class excludes only brackets. Precision comes from the `arrayReg` gate below
-    // — this fires only when `tbl` is a known fn-pointer array.
-    const ARRAY_DISPATCH_RE = /(?:\(\s*\*\s*)?\b(\w+)\s*\[[^\][]*\]\s*\)?\s*\(/g;
+    // ---- Stage E: dispatch sites → edges ----
+    // Filter: a file matters only if some dispatch field is a known fn-pointer
+    // field, or some subscripted name is a registered fn-pointer array — the loop
+    // body's own first gates (`owners` / `entries`), which a skipped file's
+    // matches would all fail before touching `seen`/`added`/`edges`.
     const edges = [];
     const seen = new Set();
     for (const file of files) {
         await tick();
+        const facts = factsByFile.get(file);
+        if (!facts)
+            continue;
+        const eSurvives = (facts.dispatchFields?.some((f) => fieldToStructs.has(f)) ?? false) ||
+            (arrayReg.size > 0 && (facts.arrayDispatchNames?.some((n) => arrayReg.has(n)) ?? false));
+        if (!eSurvives)
+            continue;
         const s = src(file);
         if (!s)
             continue;
-        for (const fn of ctx.getNodesInFile(file)) {
+        const tN = prof ? Date.now() : 0;
+        const fnsE = ctx.getNodesInFile(file);
+        if (prof) {
+            prof.nodesMs += Date.now() - tN;
+            prof.nodesN++;
+        }
+        const eLines = s.split('\n');
+        for (const fn of fnsE) {
             if (!FN_KINDS.has(fn.kind))
                 continue;
-            const body = sliceLines(s, fn.startLine, fn.endLine);
+            const body = sliceLinesPre(eLines, fn.startLine, fn.endLine);
             DISPATCH_RE.lastIndex = 0;
             let m;
             let added = 0;
+            // Incremental line counting: matches arrive in ascending index order, so
+            // count newlines since the previous match instead of re-splitting the
+            // whole body prefix per match (O(body) each — real time on god-files).
+            let lcIdx = 0;
+            let lcLine = fn.startLine;
+            const lineAt = (idx) => {
+                for (let i = lcIdx; i < idx; i++)
+                    if (body.charCodeAt(i) === 10)
+                        lcLine++;
+                lcIdx = idx;
+                return lcLine;
+            };
             while ((m = DISPATCH_RE.exec(body)) && added < FANOUT_CAP) {
                 const baseChain = m[1].replace(/\s*(?:->|\.)\s*$/, '').trim(); // receiver, minus the trailing arrow
                 const field = m[2];
@@ -1000,7 +1427,7 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
                 const targets = reg.get(`${struct}.${field}`);
                 if (!targets)
                     continue;
-                const line = fn.startLine + body.slice(0, m.index).split('\n').length - 1;
+                const line = lineAt(m.index);
                 for (const tid of targets) {
                     if (tid === fn.id)
                         continue;
@@ -1026,6 +1453,9 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             }
             // ---- bare array-of-fn-pointers dispatch (`tbl[i](…)`) ----
             if (arrayReg.size && added < FANOUT_CAP) {
+                // Fresh scan from the body's start — rewind the line-count cursor too.
+                lcIdx = 0;
+                lcLine = fn.startLine;
                 ARRAY_DISPATCH_RE.lastIndex = 0;
                 while ((m = ARRAY_DISPATCH_RE.exec(body)) && added < FANOUT_CAP) {
                     const entries = arrayReg.get(m[1]);
@@ -1038,7 +1468,7 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
                         : (entries.find((e) => e.file === fn.filePath)?.ids ?? null);
                     if (!ids)
                         continue;
-                    const line = fn.startLine + body.slice(0, m.index).split('\n').length - 1;
+                    const line = lineAt(m.index);
                     for (const tid of ids) {
                         if (tid === fn.id)
                             continue;
@@ -1065,6 +1495,10 @@ async function cFnPointerDispatchEdges(_queries, ctx, onYield, onFraction) {
             }
         }
     }
+    if (prof) {
+        prof.E = Date.now() - tPass;
+        console.error(`[synth-timing] cFnPtr sub: A=${prof.A}ms B=${prof.B}ms C=${prof.C}ms D=${prof.D}ms E=${prof.E}ms | read n=${prof.readN} ${prof.readMs}ms strip n=${prof.stripN} ${prof.stripMs}ms nodesInFile n=${prof.nodesN} ${prof.nodesMs}ms`);
+    }
     return edges;
 }
 //# sourceMappingURL=c-fnptr-synthesizer.js.map