gitnexus 1.6.4 → 1.6.5-rc.10

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 ?? '';
+}

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

@@ -37,6 +37,7 @@ 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';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -338,6 +339,15 @@ export const cProvider = defineLanguage({
     heritageExtractor: createHeritageExtractor(SupportedLanguages.C),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    emitScopeCaptures: emitCScopeCaptures,
+    interpretImport: interpretCImport,
+    interpretTypeBinding: interpretCTypeBinding,
+    bindingScopeFor: cBindingScopeFor,
+    importOwningScope: cImportOwningScope,
+    receiverBinding: cReceiverBinding,
+    arityCompatibility: cArityCompatibility,
+    // mergeBindings + resolveImportTarget live on ScopeResolver (see c/scope-resolver.ts).
 });
 export const cppProvider = defineLanguage({
     id: SupportedLanguages.CPlusPlus,

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

@@ -22,6 +22,7 @@ import { synthesizeCsharpReceiverBinding } from './receiver-binding.js';
 import { getCsharpParser, getCsharpScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = [
     '@declaration.method',
@@ -75,7 +76,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
     // the LanguageProvider contract layer; cast here at the use site.
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = getCsharpParser().parse(sourceText, undefined, {
+        tree = parseSourceSafe(getCsharpParser(), sourceText, undefined, {
             bufferSize: getTreeSitterBufferSize(sourceText),
         });
         recordCacheMiss();

package/dist/core/ingestion/languages/csharp/namespace-siblings.js

@@ -32,6 +32,7 @@
  */
 import { getCsharpParser } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 /** Build a structural view of a C# file by walking the tree-sitter
  *  AST. Prefers `cachedTree` (handed in via `treeCache`) so we don't
  *  re-parse files the orchestrator already parsed for `extractParsedFile`;
@@ -39,7 +40,7 @@ import { getTreeSitterBufferSize } from '../../constants.js';
  *  shared across calls. */
 function extractFileStructure(content, cachedTree) {
     const tree = cachedTree ??
-        getCsharpParser().parse(content, undefined, {
+        parseSourceSafe(getCsharpParser(), content, undefined, {
             bufferSize: getTreeSitterBufferSize(content),
         });
     const namespaces = [];
@@ -332,7 +333,7 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             const key = q.includes('.') ? q.slice(q.lastIndexOf('.') + 1) : q;
             if (key === '')
                 continue;
-            const arr = defsByName.get(key) ?? [];
+            const arr = [...(defsByName.get(key) ?? [])];
             arr.push(def);
             defsByName.set(key, arr);
         }

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

@@ -6,10 +6,11 @@ import { splitGoImportStatement } from './import-decomposer.js';
 import { synthesizeGoReceiverBinding } from './receiver-binding.js';
 import { synthesizeGoTypeBindings } from './type-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = getGoParser().parse(sourceText, undefined, {
+        tree = parseSourceSafe(getGoParser(), sourceText, undefined, {
             bufferSize: getTreeSitterBufferSize(sourceText),
         });
         recordGoCacheMiss();

package/dist/core/ingestion/languages/go/range-binding.js

@@ -1,5 +1,6 @@
 import { getGoParser } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 export function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
     const parser = getGoParser();
     for (const parsed of parsedFiles) {
@@ -8,7 +9,7 @@ export function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
             continue;
         const cachedTree = ctx.treeCache?.get(parsed.filePath);
         const tree = cachedTree ??
-            parser.parse(sourceText, undefined, {
+            parseSourceSafe(parser, sourceText, undefined, {
                 bufferSize: getTreeSitterBufferSize(sourceText),
             });
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');

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

@@ -22,6 +22,7 @@ import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
 import { computePythonArityMetadata } from './arity-metadata.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { pythonFunctionDefinitionLabel } from './simple-hooks.js';
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (parse phase's ASTCache) already
@@ -32,7 +33,7 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
         try {
-            tree = getPythonParser().parse(sourceText, undefined, {
+            tree = parseSourceSafe(getPythonParser(), sourceText, undefined, {
                 bufferSize: getTreeSitterBufferSize(sourceText),
             });
         }

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

@@ -31,6 +31,7 @@ import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { synthesizeTsReceiverBinding } from './receiver-binding.js';
 import { computeTsArityMetadata } from './arity-metadata.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 /** tree-sitter-typescript node types for function-like scopes that may
  *  carry a synthesized `this` binding. Kept in sync with the
  *  `@scope.function` patterns in `query.ts`. */
@@ -119,7 +120,7 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
         tree = undefined;
     }
     if (tree === undefined) {
-        tree = getTsParser(filePath).parse(sourceText, undefined, {
+        tree = parseSourceSafe(getTsParser(filePath), sourceText, undefined, {
             bufferSize: getTreeSitterBufferSize(sourceText),
         });
         recordCacheMiss();

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

@@ -5,6 +5,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
 import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
@@ -274,7 +275,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
         }
         let tree;
         try {
-            tree = parser.parse(parseContent, undefined, {
+            tree = parseSourceSafe(parser, parseContent, undefined, {
                 bufferSize: getTreeSitterBufferSize(parseContent),
             });
         }

package/dist/core/ingestion/registry-primary-flag.js

@@ -69,6 +69,7 @@ export const MIGRATED_LANGUAGES = new Set([
     SupportedLanguages.CSharp,
     SupportedLanguages.TypeScript,
     SupportedLanguages.Go,
+    SupportedLanguages.C,
 ]);
 /**
  * Return the env-var name that controls a given language's registry-

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -414,6 +414,17 @@ export interface ScopeResolver {
      * but is too loose as a default for strict module systems.
      */
     readonly allowGlobalFreeCallFallback?: boolean;
+    /**
+     * Optional predicate to identify definitions with file-local linkage
+     * (e.g. C `static` functions). When provided, `pickUniqueGlobalCallable`
+     * excludes defs where `isFileLocalDef(def) === true` and the def lives
+     * in a different file from the caller. This prevents the global free-call
+     * fallback from creating CALLS edges to file-local symbols that are
+     * logically invisible from the caller's translation unit.
+     *
+     * Languages without file-local linkage semantics leave this undefined.
+     */
+    readonly isFileLocalDef?: (def: SymbolDefinition) => boolean;
     /**
      * Optional post-finalize hook to inject cross-file bindings that
      * aren't modeled via explicit imports. Runs after

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -16,7 +16,7 @@
  * Generic; promoted from `languages/python/scope-resolver.ts` per the scope-resolution
  * generalization plan.
  */
-import type { ParsedFile, Reference, ScopeId } from '../../../../_shared/index.js';
+import type { ParsedFile, Reference, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { SemanticModel } from '../../model/semantic-model.js';
@@ -26,4 +26,5 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
     readonly bySourceScope: ReadonlyMap<ScopeId, readonly Reference[]>;
 }, handledSites: Set<string>, model: SemanticModel, workspaceIndex: WorkspaceResolutionIndex, options?: {
     readonly allowGlobalFallback?: boolean;
+    readonly isFileLocalDef?: (def: SymbolDefinition) => boolean;
 }): number;

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -55,7 +55,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the caller does not import the target package. Same-package calls are
             // caught by findCallableBindingInScope above before reaching here.
             if (fnDef === undefined && options.allowGlobalFallback === true) {
-                fnDef = pickUniqueGlobalCallable(site.name, model, scopes);
+                fnDef = pickUniqueGlobalCallable(site.name, model, scopes, parsed.filePath, options.isFileLocalDef);
             }
             if (fnDef === undefined)
                 continue;
@@ -88,7 +88,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     }
     return emitted;
 }
-function pickUniqueGlobalCallable(name, model, scopes) {
+function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLocalDef) {
     const scopeDefs = [];
     const scopeSeen = new Set();
     for (const def of scopes.defs.byId.values()) {
@@ -97,6 +97,11 @@ function pickUniqueGlobalCallable(name, model, scopes) {
             continue;
         if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
             continue;
+        // Skip file-local defs (e.g. C `static` functions) that live in a
+        // different file from the caller — they are logically invisible.
+        if (isFileLocalDef !== undefined && def.filePath !== callerFilePath && isFileLocalDef(def)) {
+            continue;
+        }
         const key = logicalCallableKey(def);
         if (scopeSeen.has(key))
             continue;
@@ -109,6 +114,12 @@ function pickUniqueGlobalCallable(name, model, scopes) {
     const seen = new Set();
     const push = (pool) => {
         for (const def of pool) {
+            // Apply the same file-local linkage filter as Phase 1 —
+            // cross-file static defs must never leak through the
+            // SemanticModel fallback path.
+            if (isFileLocalDef !== undefined && def.filePath !== callerFilePath && isFileLocalDef(def)) {
+                continue;
+            }
             const key = logicalCallableKey(def);
             if (seen.has(key))
                 continue;

package/dist/core/ingestion/scope-resolution/pipeline/registry.js

@@ -13,6 +13,7 @@ import { pythonScopeResolver } from '../../languages/python/scope-resolver.js';
 import { csharpScopeResolver } from '../../languages/csharp/scope-resolver.js';
 import { typescriptScopeResolver } from '../../languages/typescript/scope-resolver.js';
 import { goScopeResolver } from '../../languages/go/scope-resolver.js';
+import { cScopeResolver } from '../../languages/c/scope-resolver.js';
 /** Map of `SupportedLanguages` → `ScopeResolver`. The phase iterates
  *  this map intersected with `MIGRATED_LANGUAGES` (the per-language
  *  flag set) so adding a resolver here without flipping the flag is
@@ -22,4 +23,5 @@ export const SCOPE_RESOLVERS = new Map([
     [SupportedLanguages.CSharp, csharpScopeResolver],
     [SupportedLanguages.TypeScript, typescriptScopeResolver],
     [SupportedLanguages.Go, goScopeResolver],
+    [SupportedLanguages.C, cScopeResolver],
 ]);

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -169,7 +169,10 @@ export function runScopeResolution(input, provider) {
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
     const handledSites = new Set();
     const receiverExtras = emitReceiverBoundCalls(graph, indexes, parsedFiles, nodeLookup, handledSites, provider, workspaceIndex, readonlyModel);
-    const freeCallExtras = emitFreeCallFallback(graph, indexes, parsedFiles, nodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, { allowGlobalFallback: provider.allowGlobalFreeCallFallback === true });
+    const freeCallExtras = emitFreeCallFallback(graph, indexes, parsedFiles, nodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
+        allowGlobalFallback: provider.allowGlobalFreeCallFallback === true,
+        isFileLocalDef: provider.isFileLocalDef,
+    });
     const { emitted, skipped } = emitReferencesViaLookup(graph, indexes, referenceIndex, nodeLookup, handledSites);
     const importsEmitted = emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);
     if (PROF) {

package/dist/core/ingestion/workers/parse-worker.js

@@ -16,6 +16,7 @@ import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { getProvider } from '../languages/index.js';
 import { getTreeSitterBufferSize, getTreeSitterContentByteLength, TREE_SITTER_MAX_BUFFER, } from '../constants.js';
+import { parseSourceSafe } from '../../tree-sitter/safe-parse.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;
@@ -1026,7 +1027,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         clearCaches(); // Reset memoization before each new file
         let tree;
         try {
-            tree = parser.parse(parseContent, undefined, {
+            tree = parseSourceSafe(parser, parseContent, undefined, {
                 bufferSize: getTreeSitterBufferSize(parseContent),
             });
         }

package/dist/core/lbug/lbug-adapter.js

@@ -1102,6 +1102,14 @@ export const loadVectorExtension = async (targetConn, opts = {}) => {
     const useModuleState = targetConn === undefined;
     if (useModuleState && vectorExtensionLoaded)
         return true;
+    // INSTALL VECTOR crashes with SIGSEGV on Windows: the KuzuDB native extension
+    // installer has an unhandled error path on Windows that raises a fatal signal
+    // that JS try/catch cannot intercept. Skip loading — vector/embedding search
+    // is unavailable but all graph index queries still work. Do NOT set
+    // vectorExtensionLoaded here: the flag means "successfully loaded", and a
+    // subsequent call would otherwise short-circuit to `return true` at the top.
+    if (process.platform === 'win32')
+        return false;
     if (!isVectorExtensionSupportedByPlatform())
         return false;
     const c = targetConn ?? conn;