gitnexus 1.6.5-rc.2 → 1.6.5-rc.21

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;

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

@@ -0,0 +1,161 @@
+import Parser from 'tree-sitter';
+import C from 'tree-sitter-c';
+const C_SCOPE_QUERY = `
+;; Scopes
+(translation_unit) @scope.module
+(struct_specifier) @scope.class
+(union_specifier) @scope.class
+(function_definition) @scope.function
+(compound_statement) @scope.block
+(if_statement) @scope.block
+(for_statement) @scope.block
+(while_statement) @scope.block
+(do_statement) @scope.block
+(switch_statement) @scope.block
+(case_statement) @scope.block
+
+;; Declarations — struct (named)
+(struct_specifier
+  name: (type_identifier) @declaration.name
+  body: (field_declaration_list)) @declaration.struct
+
+;; Declarations — struct (typedef struct { ... } Name)
+(type_definition
+  type: (struct_specifier
+    body: (field_declaration_list))
+  declarator: (type_identifier) @declaration.name) @declaration.struct
+
+;; Declarations — union (named)
+(union_specifier
+  name: (type_identifier) @declaration.name
+  body: (field_declaration_list)) @declaration.union
+
+;; Declarations — union (typedef union { ... } Name)
+(type_definition
+  type: (union_specifier
+    body: (field_declaration_list))
+  declarator: (type_identifier) @declaration.name) @declaration.union
+
+;; Declarations — enum
+(enum_specifier
+  name: (type_identifier) @declaration.name) @declaration.enum
+
+;; Declarations — function definition
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @declaration.name)) @declaration.function
+
+;; Declarations — function definition with pointer return
+(function_definition
+  declarator: (pointer_declarator
+    declarator: (function_declarator
+      declarator: (identifier) @declaration.name))) @declaration.function
+
+;; Declarations — function declaration (prototype)
+;; Note: Both prototypes and definitions are captured as @declaration.function.
+;; This may produce duplicate Function nodes in the knowledge graph when a
+;; function is declared in a header and defined in a .c file. CALLS edges
+;; resolve correctly through scope-based wildcard import chains; the
+;; duplication is a graph-quality concern only (no false edges).
+(declaration
+  declarator: (function_declarator
+    declarator: (identifier) @declaration.name)) @declaration.function
+
+;; Declarations — function declaration with pointer return (prototype)
+(declaration
+  declarator: (pointer_declarator
+    declarator: (function_declarator
+      declarator: (identifier) @declaration.name))) @declaration.function
+
+;; Declarations — typedef
+(type_definition
+  declarator: (type_identifier) @declaration.name) @declaration.typedef
+
+;; Declarations — typedef for function pointers: typedef void (*callback)(int, int)
+(type_definition
+  declarator: (function_declarator
+    declarator: (parenthesized_declarator
+      (pointer_declarator
+        declarator: (type_identifier) @declaration.name)))) @declaration.typedef
+
+;; Declarations — struct fields
+(field_declaration
+  declarator: (field_identifier) @declaration.name) @declaration.field
+
+;; Declarations — struct fields (pointer)
+(field_declaration
+  declarator: (pointer_declarator
+    declarator: (field_identifier) @declaration.name)) @declaration.field
+
+;; Declarations — variables (with initializer)
+(declaration
+  declarator: (init_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
+;; Declarations — macro definitions
+(preproc_def
+  name: (identifier) @declaration.name) @declaration.macro
+
+(preproc_function_def
+  name: (identifier) @declaration.name) @declaration.macro
+
+;; Declarations — enum constants
+(enumerator
+  name: (identifier) @declaration.name) @declaration.const
+
+;; Imports
+(preproc_include) @import.statement
+
+;; Type bindings — parameter annotations
+(parameter_declaration
+  type: (_) @type-binding.type
+  declarator: (identifier) @type-binding.name) @type-binding.parameter
+
+;; Type bindings — variable with type (init_declarator)
+(declaration
+  type: (_) @type-binding.type
+  declarator: (init_declarator
+    declarator: (identifier) @type-binding.name)) @type-binding.assignment
+
+;; References — free calls
+;; Note: This also captures calls through function pointer variables (e.g. fp(x))
+;; since tree-sitter-c produces structurally identical AST nodes for both direct
+;; function calls and function-pointer-variable calls. A type-based guard to
+;; distinguish variable-calls from function-calls is not implemented — this is a
+;; known architectural trade-off shared with the Go resolver. The uniqueness
+;; constraint in pickUniqueGlobalCallable limits false edge exposure.
+(call_expression
+  function: (identifier) @reference.name) @reference.call.free
+
+;; References — member calls via pointer (ptr->func())
+(call_expression
+  function: (field_expression
+    argument: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.call.member
+
+;; References — field reads
+(field_expression
+  argument: (_) @reference.receiver
+  field: (field_identifier) @reference.name) @reference.read
+
+;; References — field writes (assignment)
+(assignment_expression
+  left: (field_expression
+    argument: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.write
+`;
+let _parser = null;
+let _query = null;
+export function getCParser() {
+    if (_parser === null) {
+        _parser = new Parser();
+        _parser.setLanguage(C);
+    }
+    return _parser;
+}
+export function getCScopeQuery() {
+    if (_query === null) {
+        _query = new Parser.Query(C, C_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/ingestion/languages/c/scope-resolver.d.ts

@@ -0,0 +1,13 @@
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+/**
+ * C `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * C is a structurally simple language for scope resolution:
+ * - No classes (structs are value types, no method dispatch)
+ * - No inheritance (no MRO needed beyond the shared first-wins default)
+ * - No overloading (arity check is simple: variadic detection only)
+ * - `#include` is wildcard import (all symbols from header are visible)
+ * - `static` functions are file-local (not exported)
+ */
+export declare const cScopeResolver: ScopeResolver;

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

@@ -0,0 +1,60 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+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';
+/**
+ * C `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * C is a structurally simple language for scope resolution:
+ * - No classes (structs are value types, no method dispatch)
+ * - No inheritance (no MRO needed beyond the shared first-wins default)
+ * - No overloading (arity check is simple: variadic detection only)
+ * - `#include` is wildcard import (all symbols from header are visible)
+ * - `static` functions are file-local (not exported)
+ */
+export const cScopeResolver = {
+    language: SupportedLanguages.C,
+    languageProvider: cProvider,
+    importEdgeReason: 'c-scope: include',
+    loadResolutionConfig: (repoPath) => {
+        // Clear stale static-linkage data from any previous invocation to
+        // prevent cross-repo contamination in server-mode scenarios.
+        clearStaticNames();
+        return scanHeaderFiles(repoPath);
+    },
+    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, allFilePaths);
+    },
+    expandsWildcardTo: (targetModuleScope, parsedFiles) => expandCWildcardNames(targetModuleScope, parsedFiles),
+    mergeBindings: (existing, incoming, scopeId) => cMergeBindings(existing, incoming, scopeId),
+    arityCompatibility: (callsite, def) => cArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    isSuperReceiver: () => false,
+    // C is statically typed — disable field fallback heuristic
+    fieldFallbackOnMethodLookup: false,
+    // C has no method return types to propagate
+    propagatesReturnTypesAcrossImports: false,
+    // C #include brings in all symbols — enable global free call fallback
+    allowGlobalFreeCallFallback: true,
+    // C `static` functions have file-local (translation-unit) linkage —
+    // exclude them from global free-call fallback cross-file resolution.
+    isFileLocalDef: (def) => {
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        return isStaticName(def.filePath, simple);
+    },
+};

package/dist/core/ingestion/languages/c/simple-hooks.d.ts

@@ -0,0 +1,14 @@
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+/**
+ * C binding scope: always use default auto-hoist (null).
+ * C has no self/receiver bindings that need special scoping.
+ */
+export declare function cBindingScopeFor(_decl: CaptureMatch, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/**
+ * C import owning scope: always use default (null).
+ */
+export declare function cImportOwningScope(_imp: ParsedImport, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/**
+ * C receiver binding: always null. C has no methods or receivers.
+ */
+export declare function cReceiverBinding(_functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/c/simple-hooks.js

@@ -0,0 +1,19 @@
+/**
+ * C binding scope: always use default auto-hoist (null).
+ * C has no self/receiver bindings that need special scoping.
+ */
+export function cBindingScopeFor(_decl, _innermost, _tree) {
+    return null;
+}
+/**
+ * C import owning scope: always use default (null).
+ */
+export function cImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+/**
+ * C receiver binding: always null. C has no methods or receivers.
+ */
+export function cReceiverBinding(_functionScope) {
+    return null;
+}

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

@@ -0,0 +1,13 @@
+import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+/** Record a symbol name as `static` (file-local linkage) for the given file. */
+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;
+/** Clear tracked static names (for testing). */
+export declare function clearStaticNames(): void;
+/**
+ * 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 declare function expandCWildcardNames(targetModuleScope: ScopeId, parsedFiles: readonly ParsedFile[]): readonly string[];

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

@@ -0,0 +1,57 @@
+/**
+ * Per-file set of function names declared with `static` storage class.
+ * Populated during `emitCScopeCaptures` and consumed by `expandCWildcardNames`
+ * to exclude file-local symbols from cross-file wildcard import visibility.
+ *
+ * NOTE: module-level state, single-process-single-repo use only.
+ * For server-mode or multi-repo-in-one-process use cases, call
+ * `clearStaticNames()` at the start of each resolution pass to avoid
+ * stale static-linkage data from a previous invocation.
+ *
+ * Key: filePath, Value: Set of static function names.
+ */
+const staticNames = new Map();
+/** Record a symbol name as `static` (file-local linkage) for the given file. */
+export function markStaticName(filePath, name) {
+    let names = staticNames.get(filePath);
+    if (names === undefined) {
+        names = new Set();
+        staticNames.set(filePath, names);
+    }
+    names.add(name);
+}
+/** Check whether a symbol name has `static` linkage in the given file. */
+export function isStaticName(filePath, name) {
+    return staticNames.get(filePath)?.has(name) ?? false;
+}
+/** Clear tracked static names (for testing). */
+export function clearStaticNames() {
+    staticNames.clear();
+}
+/**
+ * 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);
+    if (target === undefined)
+        return [];
+    const seen = new Set();
+    const names = [];
+    for (const def of target.localDefs) {
+        const name = simpleName(def);
+        if (name === '')
+            continue;
+        if (isStaticName(target.filePath, name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}
+function simpleName(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}