cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/c/arity-metadata.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeCDeclarationArity = computeCDeclarationArity;
+exports.computeCCallArity = computeCCallArity;
+/**
+ * Compute declaration arity from a C function definition or declaration node.
+ */
+function computeCDeclarationArity(node) {
+    // Find the function_declarator child (may be wrapped in pointer_declarator)
+    const funcDecl = findFuncDeclarator(node);
+    if (funcDecl === null)
+        return {};
+    const paramList = funcDecl.childForFieldName('parameters');
+    if (paramList === null)
+        return {};
+    const params = [];
+    for (let i = 0; i < paramList.childCount; i++) {
+        const child = paramList.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'parameter_declaration' || child.type === 'variadic_parameter') {
+            params.push(child);
+        }
+    }
+    // K&R old-style declaration: `int foo()` has an empty parameter_list with
+    // no parameter_declaration or variadic_parameter children. Per C89/C99,
+    // this means the function accepts an unspecified number/types of arguments —
+    // NOT zero arguments. Return unknown arity to avoid false 'incompatible'.
+    // `int foo(void)` is the explicit zero-parameter form and is handled below.
+    if (params.length === 0)
+        return {};
+    // (void) means zero parameters
+    if (params.length === 1 && params[0].type === 'parameter_declaration') {
+        const typeNode = params[0].childForFieldName('type');
+        const hasDeclarator = params[0].childForFieldName('declarator') !== null;
+        if (typeNode !== null && typeNode.text === 'void' && !hasDeclarator) {
+            return { parameterCount: 0, requiredParameterCount: 0, parameterTypes: [] };
+        }
+    }
+    const isVariadic = params.some((p) => p.type === 'variadic_parameter');
+    const nonVariadicCount = params.filter((p) => p.type !== 'variadic_parameter').length;
+    const types = [];
+    for (const p of params) {
+        if (p.type === 'variadic_parameter') {
+            types.push('...');
+        }
+        else {
+            const typeNode = p.childForFieldName('type');
+            types.push(typeNode?.text ?? 'unknown');
+        }
+    }
+    return {
+        parameterCount: isVariadic ? undefined : nonVariadicCount,
+        requiredParameterCount: nonVariadicCount,
+        parameterTypes: types,
+    };
+}
+/**
+ * Compute call-site arity from a call_expression node.
+ */
+function computeCCallArity(node) {
+    const argList = node.childForFieldName('arguments');
+    if (argList === null)
+        return 0;
+    let count = 0;
+    for (let i = 0; i < argList.childCount; i++) {
+        const child = argList.child(i);
+        if (child === null)
+            continue;
+        // Skip punctuation (commas, parens)
+        if (child.type !== ',' && child.type !== '(' && child.type !== ')') {
+            count++;
+        }
+    }
+    return count;
+}
+function findFuncDeclarator(node) {
+    // Direct child
+    let decl = node.childForFieldName('declarator');
+    if (decl === null) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator')
+                return c;
+        }
+        return null;
+    }
+    // Unwrap pointer_declarator
+    while (decl.type === 'pointer_declarator') {
+        const next = decl.childForFieldName('declarator');
+        if (next === null)
+            break;
+        decl = next;
+    }
+    if (decl.type === 'function_declarator')
+        return decl;
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/c/arity.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cArityCompatibility = cArityCompatibility;
+/**
+ * C arity compatibility: no overloading. Variadic functions detected
+ * via '...' in parameterTypes. Otherwise exact match or unknown.
+ */
+function cArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    if (!Number.isFinite(callsite.arity) || callsite.arity < 0)
+        return 'unknown';
+    const variadic = def.parameterTypes?.some((t) => t === '...') ?? false;
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    if (max !== undefined && callsite.arity > max && !variadic)
+        return 'incompatible';
+    return 'compatible';
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectCStaticLinkageSideChannel = collectCStaticLinkageSideChannel;
+exports.applyCStaticLinkageSideChannel = applyCStaticLinkageSideChannel;
+const static_linkage_js_1 = require("./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.
+ */
+function collectCStaticLinkageSideChannel(filePath) {
+    const staticNames = (0, static_linkage_js_1.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.
+ */
+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) {
+        (0, static_linkage_js_1.markStaticName)(parsed.filePath, name);
+    }
+}

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitCScopeCaptures = emitCScopeCaptures;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const query_js_1 = require("./query.js");
+const constants_js_1 = require("../../constants.js");
+const safe_parse_js_1 = require("../../../tree-sitter/safe-parse.js");
+const import_decomposer_js_1 = require("./import-decomposer.js");
+const arity_metadata_js_1 = require("./arity-metadata.js");
+const static_linkage_js_1 = require("./static-linkage.js");
+const receiver_chain_captures_js_1 = require("../../utils/receiver-chain-captures.js");
+const callable_flow_captures_js_1 = require("../../utils/callable-flow-captures.js");
+const C_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_definition']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration']),
+    bindingNodeTypes: new Set(['init_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'field_identifier', 'type_identifier']),
+    callableSignatureDeclarationNodeTypes: new Set(['declaration', 'parameter_declaration']),
+    emitCanonicalInvokeReference: true,
+    parameterPassingMode: (parameter) => containsNodeType(parameter, 'pointer_declarator') ? 'pointer' : 'value',
+    expectedSignature: (container, destination) => functionDeclaratorSignature(destination) ?? functionDeclaratorSignature(container),
+};
+function emitCScopeCaptures(sourceText, filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = (0, safe_parse_js_1.parseSourceSafe)((0, query_js_1.getCParser)(), sourceText, undefined, {
+            bufferSize: (0, constants_js_1.getTreeSitterBufferSize)(sourceText),
+        });
+    }
+    const rawMatches = (0, query_js_1.getCScopeQuery)().matches(tree.rootNode);
+    const out = [];
+    // 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] = (0, ast_helpers_js_1.nodeToCapture)(tag, c.node);
+            nodeMap[tag] = c.node;
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Handle #include statements. `@import.statement` is captured directly on
+        // the `preproc_include` node.
+        if (grouped['@import.statement'] !== undefined) {
+            const includeNode = (0, ast_helpers_js_1.nodeIfType)(nodeMap['@import.statement'], 'preproc_include');
+            if (includeNode !== null) {
+                const split = (0, import_decomposer_js_1.splitCInclude)(includeNode);
+                if (split !== null) {
+                    out.push(split);
+                    continue;
+                }
+            }
+        }
+        // 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 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 (concreteTypedefRanges.has(key))
+                continue;
+        }
+        // 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 = (0, ast_helpers_js_1.nodeIfType)(nodeMap['@declaration.function'], 'function_definition', 'declaration');
+            if (fnNode !== null) {
+                const arity = (0, arity_metadata_js_1.computeCDeclarationArity)(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
+                }
+                // Detect static storage class (file-local linkage)
+                if (hasStaticStorageClass(fnNode)) {
+                    const nameText = grouped['@declaration.name']?.text;
+                    if (nameText !== undefined) {
+                        (0, static_linkage_js_1.markStaticName)(filePath, nameText);
+                    }
+                }
+            }
+        }
+        // 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 = (0, ast_helpers_js_1.nodeIfType)(callAnchorNode, 'call_expression');
+            if (callNode !== null) {
+                grouped['@reference.arity'] = (0, ast_helpers_js_1.syntheticCapture)('@reference.arity', callNode, String((0, arity_metadata_js_1.computeCCallArity)(callNode)));
+            }
+        }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        (0, receiver_chain_captures_js_1.synthesizeReceiverChainCapture)(grouped, nodeMap['@reference.receiver']);
+        out.push(grouped);
+    }
+    out.push(...(0, callable_flow_captures_js_1.synthesizeCallableFlowCaptures)(tree.rootNode, C_CALLABLE_CAPTURE_OPTIONS));
+    return out;
+}
+function functionDeclaratorSignature(node) {
+    const declarator = findDescendantOfType(node, 'function_declarator');
+    const parameters = declarator?.childForFieldName('parameters');
+    if (parameters === null || parameters === undefined)
+        return undefined;
+    const parameterNodes = parameters.namedChildren.filter((child) => child !== null && child.type === 'parameter_declaration');
+    // tree-sitter-c materializes `...` as a NAMED `variadic_parameter` node —
+    // the anonymous-token checks never matched, so variadic signatures were
+    // emitted with a wrong fixed arity (#2522 review). Keep the token checks
+    // for grammar variants that expose `...` as an anonymous literal.
+    const hasEllipsis = parameters.children.some((child) => child.type === 'variadic_parameter' ||
+        child.type === '...' ||
+        (!child.isNamed && child.text === '...'));
+    const isVoidOnly = parameterNodes.length === 1 &&
+        parameterNodes[0].namedChildCount === 1 &&
+        parameterNodes[0].firstNamedChild?.text === 'void';
+    if (isVoidOnly)
+        return { parameterCount: 0, parameterTypes: [] };
+    const parameterTypes = parameterNodes.map((parameter) => parameter.childForFieldName('type')?.text ?? 'unknown');
+    if (hasEllipsis)
+        parameterTypes.push('...');
+    return {
+        ...(hasEllipsis ? {} : { parameterCount: parameterNodes.length }),
+        parameterTypes,
+    };
+}
+function containsNodeType(root, type) {
+    return findDescendantOfType(root, type) !== null;
+}
+function findDescendantOfType(root, type) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === type)
+            return node;
+        for (const child of node.namedChildren)
+            if (child !== null)
+                stack.push(child);
+    }
+    return null;
+}
+/**
+ * Check if a C function_definition or declaration has `static` storage class.
+ * Walks direct children for a `storage_class_specifier` node with text `static`.
+ */
+function hasStaticStorageClass(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child !== null && child.type === 'storage_class_specifier' && child.text === 'static') {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/core/code/engine/core/ingestion/languages/c/header-scan.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanHeaderFiles = scanHeaderFiles;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/** C header extensions to scan for in the workspace. */
+const HEADER_EXTENSIONS = new Set(['.h']);
+/**
+ * Walk `repoPath` recursively and return relative paths of all `.h` files.
+ * Used by `loadResolutionConfig` so the C resolver can resolve `#include`
+ * targets that live in `.h` files (classified as C++ by language detection
+ * but importable from `.c` files).
+ */
+function scanHeaderFiles(repoPath) {
+    const headers = new Set();
+    walk(repoPath, repoPath, headers);
+    return headers;
+}
+function walk(dir, root, out) {
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true, encoding: 'utf8' });
+    }
+    catch {
+        return; // permission denied, etc.
+    }
+    for (const entry of entries) {
+        const name = entry.name;
+        const full = (0, path_1.join)(dir, name);
+        if (entry.isDirectory()) {
+            // Skip common non-source directories and build output dirs.
+            // Build dirs (dist, build, out, target, _build, .next, cmake-build-*)
+            // may contain generated headers that shadow source headers.
+            if (name === 'node_modules' ||
+                name === '.git' ||
+                name === 'vendor' ||
+                name === 'dist' ||
+                name === 'build' ||
+                name === 'out' ||
+                name === 'target' ||
+                name === '_build' ||
+                name === '.next' ||
+                name.startsWith('cmake-build')) {
+                continue;
+            }
+            walk(full, root, out);
+        }
+        else if (entry.isFile()) {
+            const ext = name.slice(name.lastIndexOf('.'));
+            if (HEADER_EXTENSIONS.has(ext)) {
+                // Normalize to forward slashes for cross-platform consistency.
+                // path.relative() returns backslash-separated paths on Windows,
+                // but the scope-resolution pipeline uses forward slashes uniformly.
+                out.add((0, path_1.relative)(root, full).replace(/\\/g, '/'));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCInclude = splitCInclude;
+const ast_helpers_js_1 = require("../../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).
+ */
+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
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child === null)
+                continue;
+            if (child.type === 'string_literal' || child.type === 'system_lib_string') {
+                return buildIncludeCapture(node, child);
+            }
+        }
+        return null;
+    }
+    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, `"`
+        // Use namedChildren to find the string_content node
+        const content = pathNode.namedChildren.find((c) => c.type === 'string_content');
+        raw = content?.text ?? pathNode.text.replace(/^"|"$/g, '');
+    }
+    else {
+        // system_lib_string: <stdio.h> → strip angle brackets
+        raw = pathNode.text;
+        if (raw.startsWith('<') && raw.endsWith('>')) {
+            raw = raw.slice(1, -1);
+        }
+    }
+    const isSystem = pathNode.type === 'system_lib_string';
+    const result = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', node),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', node, 'wildcard'),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', node, raw),
+    };
+    if (isSystem) {
+        result['@import.system'] = (0, ast_helpers_js_1.syntheticCapture)('@import.system', node, 'true');
+    }
+    return result;
+}

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCImportTarget = resolveCImportTarget;
+const path_1 = require("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.
+ *
+ * Strategy:
+ * 1. Check for a same-directory sibling relative to the including file
+ *    (matches C compiler `#include "…"` relative-lookup semantics).
+ * 2. Check for an exact match (path as-is in the workspace).
+ * 3. Fall back to suffix matching against all workspace file paths.
+ *    Tie-breaking: prefer the match with the fewest path components
+ *    (closest to root). On equal depth, break ties lexicographically
+ *    by normalized path to ensure deterministic resolution regardless
+ *    of filesystem iteration order.
+ */
+function resolveCImportTarget(targetRaw, fromFile, allFilePaths) {
+    if (!targetRaw)
+        return null;
+    const normalizedTarget = targetRaw.replace(/\\/g, '/');
+    // Same-directory sibling first: mirrors the C compiler's #include "…"
+    // relative-lookup semantics where the directory of the including
+    // file is searched before the include-path list.
+    if (fromFile) {
+        const siblingRaw = (0, path_1.join)((0, path_1.dirname)(fromFile), targetRaw);
+        const sibling = siblingRaw.replace(/\\/g, '/');
+        if (allFilePaths.has(sibling))
+            return sibling;
+        // When targetRaw contains backslashes, the normalized form may
+        // resolve to a different sibling path — try it as well.
+        if (targetRaw !== normalizedTarget) {
+            const siblingAlt = (0, path_1.join)((0, path_1.dirname)(fromFile), normalizedTarget);
+            const siblingAltNorm = siblingAlt.replace(/\\/g, '/');
+            if (allFilePaths.has(siblingAltNorm))
+                return siblingAltNorm;
+        }
+    }
+    // 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.
+    // 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 cand of bucket) {
+        if (cand.normalized === normalizedTarget || cand.normalized.endsWith(suffix)) {
+            // Prefer shortest path (closest match)
+            if (cand.depth < bestDepth ||
+                (cand.depth === bestDepth && cand.normalized < bestNormalized)) {
+                bestDepth = cand.depth;
+                bestMatch = cand.original;
+                bestNormalized = cand.normalized;
+            }
+        }
+    }
+    return bestMatch;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCStaticLinkageSideChannel = exports.collectCStaticLinkageSideChannel = exports.getStaticNamesForFile = exports.expandCWildcardNames = exports.clearStaticNames = exports.isStaticName = exports.markStaticName = exports.resolveCImportTarget = exports.cReceiverBinding = exports.cImportOwningScope = exports.cBindingScopeFor = exports.cMergeBindings = exports.cArityCompatibility = exports.splitCInclude = exports.normalizeCTypeName = exports.interpretCTypeBinding = exports.interpretCImport = exports.emitCScopeCaptures = void 0;
+/**
+ * C scope-resolution hooks (RFC #909 Ring 3).
+ */
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitCScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitCScopeCaptures; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretCImport", { enumerable: true, get: function () { return interpret_js_1.interpretCImport; } });
+Object.defineProperty(exports, "interpretCTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretCTypeBinding; } });
+Object.defineProperty(exports, "normalizeCTypeName", { enumerable: true, get: function () { return interpret_js_1.normalizeCTypeName; } });
+var import_decomposer_js_1 = require("./import-decomposer.js");
+Object.defineProperty(exports, "splitCInclude", { enumerable: true, get: function () { return import_decomposer_js_1.splitCInclude; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "cArityCompatibility", { enumerable: true, get: function () { return arity_js_1.cArityCompatibility; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "cMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.cMergeBindings; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "cBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.cBindingScopeFor; } });
+Object.defineProperty(exports, "cImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.cImportOwningScope; } });
+Object.defineProperty(exports, "cReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.cReceiverBinding; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveCImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveCImportTarget; } });
+var static_linkage_js_1 = require("./static-linkage.js");
+Object.defineProperty(exports, "markStaticName", { enumerable: true, get: function () { return static_linkage_js_1.markStaticName; } });
+Object.defineProperty(exports, "isStaticName", { enumerable: true, get: function () { return static_linkage_js_1.isStaticName; } });
+Object.defineProperty(exports, "clearStaticNames", { enumerable: true, get: function () { return static_linkage_js_1.clearStaticNames; } });
+Object.defineProperty(exports, "expandCWildcardNames", { enumerable: true, get: function () { return static_linkage_js_1.expandCWildcardNames; } });
+Object.defineProperty(exports, "getStaticNamesForFile", { enumerable: true, get: function () { return static_linkage_js_1.getStaticNamesForFile; } });
+var capture_side_channel_js_1 = require("./capture-side-channel.js");
+Object.defineProperty(exports, "collectCStaticLinkageSideChannel", { enumerable: true, get: function () { return capture_side_channel_js_1.collectCStaticLinkageSideChannel; } });
+Object.defineProperty(exports, "applyCStaticLinkageSideChannel", { enumerable: true, get: function () { return capture_side_channel_js_1.applyCStaticLinkageSideChannel; } });