gitnexus 1.6.4 → 1.6.5-rc.10

package/dist/core/ingestion/call-processor.js

@@ -29,6 +29,7 @@ import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index
 import { isRegistryPrimary } from './registry-primary-flag.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { FUNCTION_NODE_TYPES, findEnclosingClassId, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
 import { typeTagForId, constTagForId, buildCollisionGroups } from './utils/method-props.js';
 import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from './utils/call-analysis.js';
@@ -614,7 +615,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
@@ -2586,7 +2587,7 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }

package/dist/core/ingestion/heritage-processor.js

@@ -19,6 +19,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename } from '../../_shared/index.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { getProvider } from './languages/index.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { resolveExtendsType } from './model/heritage-map.js';
@@ -152,7 +153,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             // re-parses see the same input as the cached AST.
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
@@ -300,7 +301,7 @@ export async function extractExtractedHeritageFromFiles(files, astCache) {
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }

package/dist/core/ingestion/import-processor.js

@@ -5,6 +5,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename } from '../../_shared/index.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { loadImportConfigs } from './language-config.js';
 import { buildSuffixIndex } from './import-resolvers/utils.js';
@@ -243,7 +244,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }

package/dist/core/ingestion/languages/c/arity-metadata.d.ts

@@ -0,0 +1,14 @@
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+export interface CArityInfo {
+    parameterCount?: number;
+    requiredParameterCount?: number;
+    parameterTypes?: string[];
+}
+/**
+ * Compute declaration arity from a C function definition or declaration node.
+ */
+export declare function computeCDeclarationArity(node: SyntaxNode): CArityInfo;
+/**
+ * Compute call-site arity from a call_expression node.
+ */
+export declare function computeCCallArity(node: SyntaxNode): number;

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

@@ -0,0 +1,94 @@
+/**
+ * Compute declaration arity from a C function definition or declaration node.
+ */
+export 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.
+ */
+export 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/ingestion/languages/c/arity.d.ts

@@ -0,0 +1,6 @@
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+/**
+ * C arity compatibility: no overloading. Variadic functions detected
+ * via '...' in parameterTypes. Otherwise exact match or unknown.
+ */
+export declare function cArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

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

@@ -0,0 +1,18 @@
+/**
+ * C arity compatibility: no overloading. Variadic functions detected
+ * via '...' in parameterTypes. Otherwise exact match or unknown.
+ */
+export 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/ingestion/languages/c/captures.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitCScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

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

@@ -0,0 +1,105 @@
+import { findNodeAtRange, 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';
+import { splitCInclude } from './import-decomposer.js';
+import { computeCDeclarationArity, computeCCallArity } from './arity-metadata.js';
+import { markStaticName } from './static-linkage.js';
+export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = parseSourceSafe(getCParser(), sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
+    }
+    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();
+    for (const m of rawMatches) {
+        const grouped = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            if (tag.startsWith('@_'))
+                continue;
+            grouped[tag] = nodeToCapture(tag, c.node);
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Handle #include statements
+        if (grouped['@import.statement'] !== undefined) {
+            const anchor = grouped['@import.statement'];
+            const includeNode = findNodeAtRange(tree.rootNode, anchor.range, 'preproc_include');
+            if (includeNode !== null) {
+                const split = splitCInclude(includeNode);
+                if (split !== null) {
+                    out.push(split);
+                    continue;
+                }
+            }
+        }
+        // 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}`);
+        }
+        // Suppress @declaration.typedef if the same range was already captured as struct/union
+        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))
+                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');
+            if (fnNode !== null) {
+                const arity = computeCDeclarationArity(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = 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) {
+                        markStaticName(filePath, nameText);
+                    }
+                }
+            }
+        }
+        // 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');
+            if (callNode !== null) {
+                grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeCCallArity(callNode)));
+            }
+        }
+        out.push(grouped);
+    }
+    return out;
+}
+/**
+ * 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/ingestion/languages/c/header-scan.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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).
+ */
+export declare function scanHeaderFiles(repoPath: string): ReadonlySet<string>;

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

@@ -0,0 +1,55 @@
+import { readdirSync } from 'fs';
+import { join, relative } from '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).
+ */
+export function scanHeaderFiles(repoPath) {
+    const headers = new Set();
+    walk(repoPath, repoPath, headers);
+    return headers;
+}
+function walk(dir, root, out) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: 'utf8' });
+    }
+    catch {
+        return; // permission denied, etc.
+    }
+    for (const entry of entries) {
+        const name = entry.name;
+        const full = 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(relative(root, full).replace(/\\/g, '/'));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+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).
+ */
+export declare function splitCInclude(node: SyntaxNode): CaptureMatch | null;

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

@@ -0,0 +1,50 @@
+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).
+ */
+export function splitCInclude(node) {
+    // node.type === 'preproc_include'
+    // path field: (string_literal (string_content)) | (system_lib_string)
+    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) {
+    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': nodeToCapture('@import.statement', node),
+        '@import.kind': syntheticCapture('@import.kind', node, 'wildcard'),
+        '@import.source': syntheticCapture('@import.source', node, raw),
+    };
+    if (isSystem) {
+        result['@import.system'] = syntheticCapture('@import.system', node, 'true');
+    }
+    return result;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export declare function resolveCImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>): string | null;

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

@@ -0,0 +1,57 @@
+import { dirname, join } from 'path';
+/**
+ * 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.
+ */
+export 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 = join(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 = join(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
+    const suffix = '/' + normalizedTarget;
+    let bestMatch = null;
+    let bestDepth = Infinity;
+    let bestNormalized = '';
+    for (const filePath of allFilePaths) {
+        const normalized = filePath.replace(/\\/g, '/');
+        if (normalized === normalizedTarget || 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;
+            }
+        }
+    }
+    return bestMatch;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * C scope-resolution hooks (RFC #909 Ring 3).
+ */
+export { emitCScopeCaptures } from './captures.js';
+export { interpretCImport, interpretCTypeBinding, normalizeCTypeName } from './interpret.js';
+export { splitCInclude } from './import-decomposer.js';
+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';

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

@@ -0,0 +1,11 @@
+/**
+ * C scope-resolution hooks (RFC #909 Ring 3).
+ */
+export { emitCScopeCaptures } from './captures.js';
+export { interpretCImport, interpretCTypeBinding, normalizeCTypeName } from './interpret.js';
+export { splitCInclude } from './import-decomposer.js';
+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';

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

@@ -0,0 +1,14 @@
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
+/**
+ * Interpret a C #include capture into a ParsedImport.
+ * C includes are always wildcard imports (all symbols from the header).
+ */
+export declare function interpretCImport(captures: CaptureMatch): ParsedImport | null;
+/**
+ * Interpret a C type-binding capture into a ParsedTypeBinding.
+ */
+export declare function interpretCTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+/**
+ * Normalize a C type name: strip pointer/array syntax, qualifiers.
+ */
+export declare function normalizeCTypeName(text: string): string;

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

@@ -0,0 +1,48 @@
+/**
+ * Interpret a C #include capture into a ParsedImport.
+ * C includes are always wildcard imports (all symbols from the header).
+ */
+export function interpretCImport(captures) {
+    const source = captures['@import.source']?.text;
+    if (source === undefined)
+        return null;
+    // System headers (e.g. <stdio.h>) are not resolved to local files
+    if (captures['@import.system'] !== undefined)
+        return null;
+    return { kind: 'wildcard', targetRaw: source };
+}
+/**
+ * Interpret a C type-binding capture into a ParsedTypeBinding.
+ */
+export function interpretCTypeBinding(captures) {
+    const name = captures['@type-binding.name']?.text;
+    const type = captures['@type-binding.type']?.text;
+    if (name === undefined || type === undefined)
+        return null;
+    let source = 'annotation';
+    if (captures['@type-binding.parameter'] !== undefined) {
+        source = 'parameter-annotation';
+    }
+    else if (captures['@type-binding.assignment'] !== undefined) {
+        source = 'assignment-inferred';
+    }
+    return { boundName: name, rawTypeName: normalizeCTypeName(type), source };
+}
+/**
+ * Normalize a C type name: strip pointer/array syntax, qualifiers.
+ */
+export function normalizeCTypeName(text) {
+    let t = text.trim();
+    // Strip const, volatile, restrict qualifiers
+    t = t.replace(/\b(const|volatile|restrict|static|extern|inline)\b/g, '').trim();
+    // Strip pointer stars
+    while (t.endsWith('*'))
+        t = t.slice(0, -1).trim();
+    while (t.startsWith('*'))
+        t = t.slice(1).trim();
+    // Strip array brackets
+    t = t.replace(/\[.*?\]/g, '').trim();
+    // Strip struct/union/enum prefixes
+    t = t.replace(/^(struct|union|enum)\s+/, '');
+    return t;
+}

package/dist/core/ingestion/languages/c/merge-bindings.d.ts

@@ -0,0 +1,7 @@
+import type { BindingRef } from '../../../../_shared/index.js';
+/**
+ * C merge bindings: simple first-wins by tier (local > import > wildcard).
+ * C has no namespaces or reexports, but the tiers are defined for
+ * compatibility with the shared infrastructure.
+ */
+export declare function cMergeBindings(existing: readonly BindingRef[], incoming: readonly BindingRef[], _scopeId: string): BindingRef[];

package/dist/core/ingestion/languages/c/merge-bindings.js

@@ -0,0 +1,23 @@
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+/**
+ * C merge bindings: simple first-wins by tier (local > import > wildcard).
+ * C has no namespaces or reexports, but the tiers are defined for
+ * compatibility with the shared infrastructure.
+ */
+export function cMergeBindings(existing, incoming, _scopeId) {
+    const seen = new Set();
+    return [...existing, ...incoming]
+        .sort((a, b) => (TIER[a.origin] ?? 99) - (TIER[b.origin] ?? 99) || a.def.nodeId.localeCompare(b.def.nodeId))
+        .filter((binding) => {
+        if (seen.has(binding.def.nodeId))
+            return false;
+        seen.add(binding.def.nodeId);
+        return true;
+    });
+}

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

@@ -0,0 +1,3 @@
+import Parser from 'tree-sitter';
+export declare function getCParser(): Parser;
+export declare function getCScopeQuery(): Parser.Query;