gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/languages/c/capture-side-channel.d.ts

@@ -0,0 +1,62 @@
+/**
+ * C capture-time side-channel serialization (#1983).
+ *
+ * `emitCScopeCaptures` populates one MODULE-LEVEL, per-file map as a side
+ * effect that is NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `staticNames`  (static-linkage.ts) — the simple names of functions
+ *     declared with `static` storage class (file-local / translation-unit
+ *     linkage in C), recorded via `markStaticName` from the
+ *     `@declaration.name` capture when the function node has a `static`
+ *     storage-class specifier.
+ *
+ * On the worker path that map is filled in the WORKER process and lost across
+ * the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction (the #1983 fix that avoids a main-thread
+ * tree-sitter re-parse / OOM on huge repos — e.g. the Linux kernel). The main
+ * thread then reads the map empty in `isStaticName` (consulted by
+ * `isFileLocalDef` in `c/scope-resolver.ts` and by `expandCWildcardNames` in
+ * static-linkage.ts) — so file-local `static` functions become eligible for
+ * cross-file global free-call resolution (false CALLS edges) and `#include`
+ * wildcard imports over-expose them.
+ *
+ * This module snapshots the per-file slice of that map into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It mirrors the C++ pattern
+ * in `cpp/capture-side-channel.ts` and the Kotlin pattern in
+ * `kotlin/capture-side-channel.ts`.
+ *
+ * The single generic `ParsedFile.captureSideChannel` field is shared with C++
+ * and Kotlin, which is safe because each file is one language (a `.c` file uses
+ * the C provider). The payload is self-describing (`{ kind: 'c', staticNames }`)
+ * so `applyCStaticLinkageSideChannel` only restores C state and ignores a
+ * foreign-shaped snapshot.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+/**
+ * Plain JSON-serializable snapshot of the per-file C capture-time
+ * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
+ * `kind` tag makes the payload self-describing so `apply` can distinguish a C
+ * snapshot from another language's (C++ and Kotlin share the same field).
+ */
+export interface CCaptureSideChannel {
+    readonly kind: 'c';
+    /** Simple names of `static` (file-local linkage) functions in this file. */
+    readonly staticNames: readonly string[];
+}
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for C.
+ * Returns `undefined` when this file recorded no static names at all, so the
+ * produced `ParsedFile` carries the field only when there's data to ship.
+ */
+export declare function collectCStaticLinkageSideChannel(filePath: string): CCaptureSideChannel | undefined;
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for C. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and re-populates
+ * the module-level static-linkage map via `markStaticName`. Tolerant of
+ * `undefined` (file carried no data) and of an unexpected / foreign shape
+ * (defensive — the `kind` tag guards against restoring a non-C payload).
+ * Does NO tree-sitter parse.
+ */
+export declare function applyCStaticLinkageSideChannel(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/c/capture-side-channel.js

@@ -0,0 +1,65 @@
+/**
+ * C capture-time side-channel serialization (#1983).
+ *
+ * `emitCScopeCaptures` populates one MODULE-LEVEL, per-file map as a side
+ * effect that is NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `staticNames`  (static-linkage.ts) — the simple names of functions
+ *     declared with `static` storage class (file-local / translation-unit
+ *     linkage in C), recorded via `markStaticName` from the
+ *     `@declaration.name` capture when the function node has a `static`
+ *     storage-class specifier.
+ *
+ * On the worker path that map is filled in the WORKER process and lost across
+ * the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction (the #1983 fix that avoids a main-thread
+ * tree-sitter re-parse / OOM on huge repos — e.g. the Linux kernel). The main
+ * thread then reads the map empty in `isStaticName` (consulted by
+ * `isFileLocalDef` in `c/scope-resolver.ts` and by `expandCWildcardNames` in
+ * static-linkage.ts) — so file-local `static` functions become eligible for
+ * cross-file global free-call resolution (false CALLS edges) and `#include`
+ * wildcard imports over-expose them.
+ *
+ * This module snapshots the per-file slice of that map into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It mirrors the C++ pattern
+ * in `cpp/capture-side-channel.ts` and the Kotlin pattern in
+ * `kotlin/capture-side-channel.ts`.
+ *
+ * The single generic `ParsedFile.captureSideChannel` field is shared with C++
+ * and Kotlin, which is safe because each file is one language (a `.c` file uses
+ * the C provider). The payload is self-describing (`{ kind: 'c', staticNames }`)
+ * so `applyCStaticLinkageSideChannel` only restores C state and ignores a
+ * foreign-shaped snapshot.
+ */
+import { getStaticNamesForFile, markStaticName } from './static-linkage.js';
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for C.
+ * Returns `undefined` when this file recorded no static names at all, so the
+ * produced `ParsedFile` carries the field only when there's data to ship.
+ */
+export function collectCStaticLinkageSideChannel(filePath) {
+    const staticNames = getStaticNamesForFile(filePath);
+    if (staticNames.length === 0)
+        return undefined;
+    return { kind: 'c', staticNames };
+}
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for C. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and re-populates
+ * the module-level static-linkage map via `markStaticName`. Tolerant of
+ * `undefined` (file carried no data) and of an unexpected / foreign shape
+ * (defensive — the `kind` tag guards against restoring a non-C payload).
+ * Does NO tree-sitter parse.
+ */
+export function applyCStaticLinkageSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined || data === null || typeof data !== 'object')
+        return;
+    if (data.kind !== 'c' || !Array.isArray(data.staticNames))
+        return;
+    for (const name of data.staticNames) {
+        markStaticName(parsed.filePath, name);
+    }
+}

package/dist/core/ingestion/languages/c/captures.js

@@ -1,4 +1,4 @@
-import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { getCParser, getCScopeQuery } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
@@ -14,23 +14,36 @@ export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
     }
     const rawMatches = getCScopeQuery().matches(tree.rootNode);
     const out = [];
-    // Track ranges where typedef-struct/union was captured as @declaration.struct/union
-    // so we can suppress the duplicate @declaration.typedef match at the same range.
-    const structTypedefRanges = new Set();
+    // Track ranges where typedef-struct/union/enum was captured as its concrete
+    // type so we can suppress the duplicate @declaration.typedef match.
+    const concreteTypedefRanges = new Set();
     for (const m of rawMatches) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
+        // hands us each matched node as `c.node`, so anchors resolve via a
+        // type-guarded lookup (`nodeIfType`) instead of re-deriving them with
+        // `findNodeAtRange(tree.rootNode, ...)` per match — the
+        // O(matches × rootChildren) root-walk fixed for go #1848 / python #1918 /
+        // rust/csharp #1915 / java #1951, mirrored here for C. Every C scope-query
+        // anchor below captures directly ON the node the old root-walk re-derived
+        // (verified against C_SCOPE_QUERY in query.ts: @import.statement on
+        // preproc_include, @declaration.function on function_definition/declaration,
+        // @reference.call.free/.member on call_expression), so the type check is
+        // exact. C has no inheritance construct, so there is no heritage synthesis.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             if (tag.startsWith('@_'))
                 continue;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
-        // Handle #include statements
+        // Handle #include statements. `@import.statement` is captured directly on
+        // the `preproc_include` node.
         if (grouped['@import.statement'] !== undefined) {
-            const anchor = grouped['@import.statement'];
-            const includeNode = findNodeAtRange(tree.rootNode, anchor.range, 'preproc_include');
+            const includeNode = nodeIfType(nodeMap['@import.statement'], 'preproc_include');
             if (includeNode !== null) {
                 const split = splitCInclude(includeNode);
                 if (split !== null) {
@@ -39,25 +52,28 @@ export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
                 }
             }
         }
-        // Track typedef-struct ranges to suppress duplicate typedef declarations
-        const structAnchor = grouped['@declaration.struct'] ?? grouped['@declaration.union'];
-        if (structAnchor !== undefined) {
-            const r = structAnchor.range;
-            structTypedefRanges.add(`${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`);
+        // Track typedef struct/union/enum ranges to suppress duplicate typedef declarations
+        const concreteTypeAnchor = grouped['@declaration.struct'] ??
+            grouped['@declaration.union'] ??
+            grouped['@declaration.enum'];
+        if (concreteTypeAnchor !== undefined) {
+            const r = concreteTypeAnchor.range;
+            concreteTypedefRanges.add(`${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`);
         }
-        // Suppress @declaration.typedef if the same range was already captured as struct/union
+        // Suppress @declaration.typedef if the same range was already captured as a concrete type.
         const typedefAnchor = grouped['@declaration.typedef'];
         if (typedefAnchor !== undefined) {
             const r = typedefAnchor.range;
             const key = `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
-            if (structTypedefRanges.has(key))
+            if (concreteTypedefRanges.has(key))
                 continue;
         }
-        // Enrich function declarations with arity metadata and detect static linkage
-        const declAnchor = grouped['@declaration.function'];
-        if (declAnchor !== undefined) {
-            const fnNode = findNodeAtRange(tree.rootNode, declAnchor.range, 'function_definition') ??
-                findNodeAtRange(tree.rootNode, declAnchor.range, 'declaration');
+        // Enrich function declarations with arity metadata and detect static linkage.
+        // `@declaration.function` is captured directly on the `function_definition`
+        // node (definitions) or the `declaration` node (prototypes) — the captured
+        // node IS what the old findNodeAtRange re-derived.
+        if (grouped['@declaration.function'] !== undefined) {
+            const fnNode = nodeIfType(nodeMap['@declaration.function'], 'function_definition', 'declaration');
             if (fnNode !== null) {
                 const arity = computeCDeclarationArity(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -78,10 +94,12 @@ export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
                 }
             }
         }
-        // Enrich call references with arity
-        const callAnchor = grouped['@reference.call.free'] ?? grouped['@reference.call.member'];
-        if (callAnchor !== undefined && grouped['@reference.arity'] === undefined) {
-            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression');
+        // Enrich call references with arity. @reference.call.free / .member are both
+        // captured directly on the `call_expression` node — the captured node IS
+        // what the old findNodeAtRange re-derived.
+        const callAnchorNode = nodeMap['@reference.call.free'] ?? nodeMap['@reference.call.member'];
+        if (callAnchorNode !== undefined && grouped['@reference.arity'] === undefined) {
+            const callNode = nodeIfType(callAnchorNode, 'call_expression');
             if (callNode !== null) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeCCallArity(callNode)));
             }

package/dist/core/ingestion/languages/c/import-decomposer.d.ts

@@ -4,5 +4,14 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C #include maps to a wildcard import (all symbols
  * from the header are visible).
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <stdio.h>   → system_lib_string
+ *   #include "local.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path). Emitting it as an import
+ * source produces a garbage literal edge, so we skip it entirely — matching
+ * the convention in interpretCImport, which drops imports with no resolvable
+ * source (issue #1919 F5).
  */
 export declare function splitCInclude(node: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/c/import-decomposer.js

@@ -3,10 +3,20 @@ import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C #include maps to a wildcard import (all symbols
  * from the header are visible).
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <stdio.h>   → system_lib_string
+ *   #include "local.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path). Emitting it as an import
+ * source produces a garbage literal edge, so we skip it entirely — matching
+ * the convention in interpretCImport, which drops imports with no resolvable
+ * source (issue #1919 F5).
  */
 export function splitCInclude(node) {
     // node.type === 'preproc_include'
     // path field: (string_literal (string_content)) | (system_lib_string)
+    //             | (identifier)  ← computed macro include, NOT a header path
     const pathNode = node.childForFieldName?.('path') ?? null;
     if (pathNode === null) {
         // Fallback: scan children
@@ -23,6 +33,11 @@ export function splitCInclude(node) {
     return buildIncludeCapture(node, pathNode);
 }
 function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
     let raw;
     if (pathNode.type === 'string_literal') {
         // string_literal has children: `"`, string_content, `"`

package/dist/core/ingestion/languages/c/import-target.js

@@ -1,4 +1,39 @@
 import { dirname, join } from 'path';
+/**
+ * Per-pass memo: workspace paths bucketed by basename (last path segment),
+ * keyed on the `allFilePaths` set identity.
+ *
+ * `resolveCImportTarget` is called once per (quoted) C/C++ `#include` with the
+ * same `allFilePaths` set per pass (the augmented set is itself memoized in
+ * the C resolver). The old suffix-match fallback scanned ALL workspace paths
+ * per include — with a per-element `.replace`/`.split` and no early exit
+ * (the fewest-path-components tie-break forces a full scan) — i.e.
+ * O(R_suffix × (F+H)). A path can satisfy `endsWith('/'+target)` (or equal
+ * the target) ONLY IF its basename equals the target's last segment, so we
+ * pre-bucket by basename once (O(F+H), `normalized`/`depth` precomputed) and
+ * the fallback inspects a single small bucket → O(F+H) build + ~O(1)/include.
+ * `WeakMap`-keyed so it is reclaimed with the pass (no cross-pass staleness).
+ * Shared by C and C++ (`resolveCppImportTarget` delegates here).
+ */
+const suffixIndexByPaths = new WeakMap();
+function suffixIndex(allFilePaths) {
+    let index = suffixIndexByPaths.get(allFilePaths);
+    if (index === undefined) {
+        index = new Map();
+        for (const original of allFilePaths) {
+            const normalized = original.replace(/\\/g, '/');
+            const basename = normalized.slice(normalized.lastIndexOf('/') + 1);
+            let bucket = index.get(basename);
+            if (bucket === undefined) {
+                bucket = [];
+                index.set(basename, bucket);
+            }
+            bucket.push({ original, normalized, depth: normalized.split('/').length });
+        }
+        suffixIndexByPaths.set(allFilePaths, index);
+    }
+    return index;
+}
 /**
  * Resolve a C #include path to a file in the workspace.
  *
@@ -36,20 +71,28 @@ export function resolveCImportTarget(targetRaw, fromFile, allFilePaths) {
     // Exact match (path as-is in the workspace)
     if (allFilePaths.has(normalizedTarget))
         return normalizedTarget;
-    // Suffix match: find files ending with /targetRaw or equal to targetRaw
+    // Suffix match: find files ending with /targetRaw or equal to targetRaw.
+    // A path can only match `=== normalizedTarget` or `endsWith('/'+target)` if
+    // its basename equals the target's last segment, so we inspect only that
+    // basename bucket (built once per pass) instead of scanning every workspace
+    // path. Match condition + tie-break (fewest path components, then
+    // lexicographic on the normalized path) are byte-identical to the prior scan.
     const suffix = '/' + normalizedTarget;
+    const targetBasename = normalizedTarget.slice(normalizedTarget.lastIndexOf('/') + 1);
+    const bucket = suffixIndex(allFilePaths).get(targetBasename);
+    if (bucket === undefined)
+        return null;
     let bestMatch = null;
     let bestDepth = Infinity;
     let bestNormalized = '';
-    for (const filePath of allFilePaths) {
-        const normalized = filePath.replace(/\\/g, '/');
-        if (normalized === normalizedTarget || normalized.endsWith(suffix)) {
+    for (const cand of bucket) {
+        if (cand.normalized === normalizedTarget || cand.normalized.endsWith(suffix)) {
             // Prefer shortest path (closest match)
-            const depth = normalized.split('/').length;
-            if (depth < bestDepth || (depth === bestDepth && normalized < bestNormalized)) {
-                bestDepth = depth;
-                bestMatch = filePath;
-                bestNormalized = normalized;
+            if (cand.depth < bestDepth ||
+                (cand.depth === bestDepth && cand.normalized < bestNormalized)) {
+                bestDepth = cand.depth;
+                bestMatch = cand.original;
+                bestNormalized = cand.normalized;
             }
         }
     }

package/dist/core/ingestion/languages/c/index.d.ts

@@ -8,4 +8,5 @@ export { cArityCompatibility } from './arity.js';
 export { cMergeBindings } from './merge-bindings.js';
 export { cBindingScopeFor, cImportOwningScope, cReceiverBinding } from './simple-hooks.js';
 export { resolveCImportTarget } from './import-target.js';
-export { markStaticName, isStaticName, clearStaticNames, expandCWildcardNames, } from './static-linkage.js';
+export { markStaticName, isStaticName, clearStaticNames, expandCWildcardNames, getStaticNamesForFile, } from './static-linkage.js';
+export { collectCStaticLinkageSideChannel, applyCStaticLinkageSideChannel, } from './capture-side-channel.js';

package/dist/core/ingestion/languages/c/index.js

@@ -8,4 +8,5 @@ export { cArityCompatibility } from './arity.js';
 export { cMergeBindings } from './merge-bindings.js';
 export { cBindingScopeFor, cImportOwningScope, cReceiverBinding } from './simple-hooks.js';
 export { resolveCImportTarget } from './import-target.js';
-export { markStaticName, isStaticName, clearStaticNames, expandCWildcardNames, } from './static-linkage.js';
+export { markStaticName, isStaticName, clearStaticNames, expandCWildcardNames, getStaticNamesForFile, } from './static-linkage.js';
+export { collectCStaticLinkageSideChannel, applyCStaticLinkageSideChannel, } from './capture-side-channel.js';

package/dist/core/ingestion/languages/c/query.js

@@ -40,6 +40,12 @@ const C_SCOPE_QUERY = `
 (enum_specifier
   name: (type_identifier) @declaration.name) @declaration.enum
 
+;; Declarations — enum (typedef enum { ... } Name)
+(type_definition
+  type: (enum_specifier
+    body: (enumerator_list))
+  declarator: (type_identifier) @declaration.name) @declaration.enum
+
 ;; Declarations — function definition
 (function_definition
   declarator: (function_declarator
@@ -92,6 +98,15 @@ const C_SCOPE_QUERY = `
   declarator: (init_declarator
     declarator: (identifier) @declaration.name)) @declaration.variable
 
+;; Declarations — variables (without initializer), including non-leading
+;; declarators in mixed declaration lists.
+(declaration
+  declarator: (identifier) @declaration.name) @declaration.variable
+
+(declaration
+  declarator: (pointer_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
 ;; Declarations — macro definitions
 (preproc_def
   name: (identifier) @declaration.name) @declaration.macro

package/dist/core/ingestion/languages/c/scope-resolver.js

@@ -5,6 +5,36 @@ import { cProvider } from '../c-cpp.js';
 import { cArityCompatibility, cMergeBindings, resolveCImportTarget } from './index.js';
 import { scanHeaderFiles } from './header-scan.js';
 import { expandCWildcardNames, isStaticName, clearStaticNames } from './static-linkage.js';
+import { applyCStaticLinkageSideChannel } from './capture-side-channel.js';
+/**
+ * Per-pass memo of the augmented `#include`-resolution file set
+ * (`allFilePaths` ∪ header `.h` paths), keyed on the two stable source sets.
+ *
+ * `resolveImportTarget` is called once per C `#include`; the old code rebuilt
+ * a fresh ~F-entry `Set` on EVERY call (O(R × (F+H)) inserts + GC churn) and,
+ * worse, defeated `resolveCImportTarget`'s own per-set suffix-index memo by
+ * handing it a new set identity each time. Both `allFilePaths` (built once in
+ * scope-resolution `run.ts`) and the header set (`loadResolutionConfig`
+ * result) are stable per pass, so the union is built once and reused.
+ * `WeakMap`-keyed → reclaimed with the pass (no cross-pass staleness).
+ */
+const augmentedPathsByPass = new WeakMap();
+function augmentedFilePaths(allFilePaths, headerPaths) {
+    let byHeaders = augmentedPathsByPass.get(allFilePaths);
+    if (byHeaders === undefined) {
+        byHeaders = new WeakMap();
+        augmentedPathsByPass.set(allFilePaths, byHeaders);
+    }
+    let augmented = byHeaders.get(headerPaths);
+    if (augmented === undefined) {
+        const set = new Set(allFilePaths);
+        for (const h of headerPaths)
+            set.add(h);
+        augmented = set;
+        byHeaders.set(headerPaths, augmented);
+    }
+    return augmented;
+}
 /**
  * C `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -26,16 +56,29 @@ export const cScopeResolver = {
         clearStaticNames();
         return scanHeaderFiles(repoPath);
     },
+    // Worker-boundary restore (see `ScopeResolver.applyCaptureSideChannel`).
+    // `emitCScopeCaptures` records per-file `static`-linkage names
+    // (`markStaticName` → `staticNames`) as a SIDE EFFECT — that state is NOT
+    // serialized onto the returned ParsedFile's scopes/defs. On the worker path
+    // those marks are populated in the worker process and lost across the
+    // MessageChannel / disk store; the main thread reuses the serialized
+    // ParsedFile and skips `extractParsedFile`, so `isStaticName` (read by
+    // `isFileLocalDef` and `expandCWildcardNames`) sees an empty map and C
+    // `static` functions leak into cross-file global free-call resolution
+    // (false CALLS edges) and `#include` wildcard imports. The worker stashed a
+    // plain-data snapshot on `parsed.captureSideChannel` via
+    // `cProvider.collectCaptureSideChannel`; this restores it into the module
+    // map WITHOUT any tree-sitter re-parse (the #1983 fix). The
+    // freshly-extracted leg never calls this — its marks were just populated in
+    // this process. Runs BEFORE `populateOwners`.
+    applyCaptureSideChannel: applyCStaticLinkageSideChannel,
     resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
         // Augment allFilePaths with .h files discovered via loadResolutionConfig
         // since the phase only passes .c files to the C resolver but #include
         // targets .h files classified as C++ in language detection.
         const headerPaths = resolutionConfig;
         if (headerPaths !== undefined && headerPaths.size > 0) {
-            const augmented = new Set(allFilePaths);
-            for (const h of headerPaths)
-                augmented.add(h);
-            return resolveCImportTarget(targetRaw, fromFile, augmented);
+            return resolveCImportTarget(targetRaw, fromFile, augmentedFilePaths(allFilePaths, headerPaths));
         }
         return resolveCImportTarget(targetRaw, fromFile, allFilePaths);
     },

package/dist/core/ingestion/languages/c/static-linkage.d.ts

@@ -3,6 +3,14 @@ import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
 export declare function markStaticName(filePath: string, name: string): void;
 /** Check whether a symbol name has `static` linkage in the given file. */
 export declare function isStaticName(filePath: string, name: string): boolean;
+/**
+ * Return the `static` (file-local) names recorded for the given file as a
+ * plain array (empty when none). Used to snapshot the per-file slice of the
+ * module-level `staticNames` map into `ParsedFile.captureSideChannel` so it
+ * survives the worker→main boundary (#1983 — the worker is the sole parse
+ * path). See `c/capture-side-channel.ts`.
+ */
+export declare function getStaticNamesForFile(filePath: string): string[];
 /** Clear tracked static names (for testing). */
 export declare function clearStaticNames(): void;
 /**

package/dist/core/ingestion/languages/c/static-linkage.js

@@ -24,17 +24,62 @@ export function markStaticName(filePath, name) {
 export function isStaticName(filePath, name) {
     return staticNames.get(filePath)?.has(name) ?? false;
 }
+/**
+ * Return the `static` (file-local) names recorded for the given file as a
+ * plain array (empty when none). Used to snapshot the per-file slice of the
+ * module-level `staticNames` map into `ParsedFile.captureSideChannel` so it
+ * survives the worker→main boundary (#1983 — the worker is the sole parse
+ * path). See `c/capture-side-channel.ts`.
+ */
+export function getStaticNamesForFile(filePath) {
+    const names = staticNames.get(filePath);
+    return names === undefined ? [] : [...names];
+}
 /** Clear tracked static names (for testing). */
 export function clearStaticNames() {
     staticNames.clear();
 }
+/**
+ * Per-pass memo: `moduleScope` → owning `ParsedFile`, keyed on the
+ * `parsedFiles` array identity.
+ *
+ * The shared finalize Phase-4 loop calls `expandsWildcardTo`
+ * (→ `expandCWildcardNames`) ONCE PER RESOLVED `#include` edge, every time
+ * with the SAME `parsedFiles` reference (wired at scope-resolution
+ * `run.ts` — `allFilePaths`/`parsedFiles` are built once per pass). The old
+ * `parsedFiles.find(...)` therefore did a full O(F) scan per edge →
+ * O(R_include × F) overall; at Linux-kernel scale (F ≈ 63k C files, tens of
+ * thousands of resolved includes) that is ~10^10+ comparisons on a single
+ * thread — the dominant term in the scope-resolution finalize grind.
+ *
+ * Building the lookup once collapses it to O(R_include + F). `WeakMap`-keyed
+ * on the array so the index is reclaimed with the pass — no cross-pass
+ * staleness (mirrors the {@link clearStaticNames} discipline for server-mode
+ * / multi-repo reuse), and a fresh array transparently rebuilds.
+ */
+const moduleScopeIndexByPass = new WeakMap();
+function moduleScopeIndex(parsedFiles) {
+    let index = moduleScopeIndexByPass.get(parsedFiles);
+    if (index === undefined) {
+        index = new Map();
+        // First-wins to preserve `Array.find` semantics (returns the first match).
+        // `moduleScope` is unique per file in practice, so collisions are absent;
+        // the guard only formalises identical behaviour to the prior `.find`.
+        for (const p of parsedFiles) {
+            if (!index.has(p.moduleScope))
+                index.set(p.moduleScope, p);
+        }
+        moduleScopeIndexByPass.set(parsedFiles, index);
+    }
+    return index;
+}
 /**
  * Return the names visible through a C wildcard import (`#include`).
  * All module-scope defs from the target file are visible EXCEPT those
  * declared with `static` storage class (file-local linkage in C).
  */
 export function expandCWildcardNames(targetModuleScope, parsedFiles) {
-    const target = parsedFiles.find((p) => p.moduleScope === targetModuleScope);
+    const target = moduleScopeIndex(parsedFiles).get(targetModuleScope);
     if (target === undefined)
         return [];
     const seen = new Set();

package/dist/core/ingestion/languages/c-cpp.js

@@ -35,10 +35,9 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { cVariableConfig, cppVariableConfig } from '../variable-extractors/configs/c-cpp.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { stripUeMacros } from '../cpp-ue-preprocessor.js';
-import { emitCScopeCaptures, interpretCImport, interpretCTypeBinding, cArityCompatibility, cBindingScopeFor, cImportOwningScope, cReceiverBinding, } from './c/index.js';
-import { emitCppScopeCaptures, interpretCppImport, interpretCppTypeBinding, cppArityCompatibility, cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding, } from './cpp/index.js';
+import { emitCScopeCaptures, interpretCImport, interpretCTypeBinding, cArityCompatibility, cBindingScopeFor, cImportOwningScope, cReceiverBinding, collectCStaticLinkageSideChannel, } from './c/index.js';
+import { emitCppScopeCaptures, interpretCppImport, interpretCppTypeBinding, cppArityCompatibility, cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding, collectCppCaptureSideChannel, } from './cpp/index.js';
 import { extractCppTemplateConstraints } from './cpp/constraint-extractor.js';
 const C_BUILT_INS = new Set([
     'printf',
@@ -339,7 +338,6 @@ export const cProvider = defineLanguage({
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
     importResolver: createImportResolver(cImportConfig),
-    importSemantics: 'wildcard-transitive',
     callExtractor: createCallExtractor(cCallConfig),
     fieldExtractor: createFieldExtractor(cFieldConfig),
     methodExtractor: createMethodExtractor({
@@ -348,11 +346,19 @@ export const cProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(cVariableConfig),
     classExtractor: cClassExtractor,
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.C),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     emitScopeCaptures: emitCScopeCaptures,
+    // Worker-side: snapshot the module-level `static`-linkage marks
+    // `emitCScopeCaptures` just populated for this file (`markStaticName` →
+    // `staticNames`) into plain data on `ParsedFile.captureSideChannel`, so the
+    // main thread can restore them via `applyCaptureSideChannel` WITHOUT a
+    // re-parse (#1983 — the worker is the sole parse path). Without this, C
+    // `static` functions look non-file-local on the main thread and leak into
+    // cross-file global free-call resolution / wildcard imports. See
+    // `c/capture-side-channel.ts`.
+    collectCaptureSideChannel: collectCStaticLinkageSideChannel,
     interpretImport: interpretCImport,
     interpretTypeBinding: interpretCTypeBinding,
     bindingScopeFor: cBindingScopeFor,
@@ -407,7 +413,6 @@ export const cppProvider = defineLanguage({
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
     importResolver: createImportResolver(cppImportConfig),
-    importSemantics: 'wildcard-transitive',
     mroStrategy: 'leftmost-base',
     callExtractor: createCallExtractor(cppCallConfig),
     fieldExtractor: createFieldExtractor(cppFieldConfig),
@@ -417,12 +422,16 @@ export const cppProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(cppVariableConfig),
     classExtractor: cppClassExtractor,
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.CPlusPlus),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
     extractTemplateConstraints: extractCppTemplateConstraintsForProvider,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     emitScopeCaptures: emitCppScopeCaptures,
+    // Worker-side: snapshot the module-level capture marks `emitCppScopeCaptures`
+    // just populated for this file into plain data on `ParsedFile.captureSideChannel`,
+    // so the main thread can restore them via `applyCaptureSideChannel` WITHOUT a
+    // re-parse (#1983). See `cpp/capture-side-channel.ts`.
+    collectCaptureSideChannel: collectCppCaptureSideChannel,
     interpretImport: interpretCppImport,
     interpretTypeBinding: interpretCppTypeBinding,
     bindingScopeFor: cppBindingScopeFor,