gitnexus 1.4.8 → 1.4.10

package/dist/core/ingestion/{resolvers → import-resolvers}/rust.js

@@ -2,11 +2,13 @@
  * Rust module import resolution.
  * Handles crate::, super::, self:: prefix paths and :: separators.
  */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { resolveStandard } from './standard.js';
 /**
- * Resolve Rust use-path to a file.
+ * Resolve Rust use-path to a file (low-level helper).
  * Handles crate::, super::, self:: prefixes and :: path separators.
  */
-export function resolveRustImport(currentFile, importPath, allFiles) {
+export function resolveRustImportInternal(currentFile, importPath, allFiles) {
     let rustPath;
     if (importPath.startsWith('crate::')) {
         // crate:: resolves from src/ directory (standard Rust layout)
@@ -71,3 +73,40 @@ export function tryRustModulePath(modulePath, allFiles) {
     }
     return null;
 }
+/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
+export function resolveRustImport(rawImportPath, filePath, ctx) {
+    // Top-level grouped: use {crate::a, crate::b}
+    if (rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
+        const inner = rawImportPath.slice(1, -1);
+        const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
+        const resolved = [];
+        for (const part of parts) {
+            const r = resolveRustImportInternal(filePath, part, ctx.allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
+    }
+    // Scoped grouped: use crate::models::{User, Repo}
+    const braceIdx = rawImportPath.indexOf('::{');
+    if (braceIdx !== -1 && rawImportPath.endsWith('}')) {
+        const pathPrefix = rawImportPath.substring(0, braceIdx);
+        const braceContent = rawImportPath.substring(braceIdx + 3, rawImportPath.length - 1);
+        const items = braceContent.split(',').map(s => s.trim()).filter(Boolean);
+        const resolved = [];
+        for (const item of items) {
+            // Handle `use crate::models::{User, Repo as R}` — strip alias for resolution
+            const itemName = item.includes(' as ') ? item.split(' as ')[0].trim() : item;
+            const r = resolveRustImportInternal(filePath, `${pathPrefix}::${itemName}`, ctx.allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        if (resolved.length > 0)
+            return { kind: 'files', files: resolved };
+        // Fallback: resolve the prefix path itself (e.g. crate::models -> models.rs)
+        const prefixResult = resolveRustImportInternal(filePath, pathPrefix, ctx.allFilePaths);
+        if (prefixResult)
+            return { kind: 'files', files: [prefixResult] };
+    }
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Rust);
+}

package/dist/core/ingestion/{resolvers → import-resolvers}/standard.d.ts

@@ -5,13 +5,8 @@
  */
 import type { SuffixIndex } from './utils.js';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
-/** TypeScript path alias config parsed from tsconfig.json */
-export interface TsconfigPaths {
-    /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
-    aliases: Map<string, string>;
-    /** Base URL for path resolution (relative to repo root) */
-    baseUrl: string;
-}
+import type { ImportResult, ImportResolverFn, ResolveCtx } from './types.js';
+import type { TsconfigPaths } from '../language-config.js';
 /** Max entries in the resolve cache. Beyond this, entries are evicted.
  *  100K entries ≈ 15MB — covers the most common import patterns. */
 export declare const RESOLVE_CACHE_CAP = 100000;
@@ -26,3 +21,16 @@ export declare const RESOLVE_CACHE_CAP = 100000;
  * because they resolve to multiple files.
  */
 export declare const resolveImportPath: (currentFile: string, importPath: string, allFiles: Set<string>, allFileList: string[], normalizedFileList: string[], resolveCache: Map<string, string | null>, language: SupportedLanguages, tsconfigPaths: TsconfigPaths | null, index?: SuffixIndex) => string | null;
+/**
+ * Standard single-file resolution (TS/JS/C/C++ and fallback for other languages).
+ * Handles relative imports, tsconfig path aliases, and suffix matching.
+ */
+export declare function resolveStandard(rawImportPath: string, filePath: string, ctx: ResolveCtx, language: SupportedLanguages): ImportResult;
+/** JavaScript: standard single-file resolution. */
+export declare const resolveJavascriptImport: ImportResolverFn;
+/** TypeScript: standard single-file resolution. */
+export declare const resolveTypescriptImport: ImportResolverFn;
+/** C: standard single-file resolution for #include directives. */
+export declare const resolveCImport: ImportResolverFn;
+/** C++: standard single-file resolution for #include directives. */
+export declare const resolveCppImport: ImportResolverFn;

package/dist/core/ingestion/{resolvers → import-resolvers}/standard.js

@@ -4,7 +4,7 @@
  * Used as the fallback when language-specific resolvers don't match.
  */
 import { tryResolveWithExtensions, suffixResolve } from './utils.js';
-import { resolveRustImport } from './rust.js';
+import { resolveRustImportInternal } from './rust.js';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
 /** Max entries in the resolve cache. Beyond this, entries are evicted.
  *  100K entries ≈ 15MB — covers the most common import patterns. */
@@ -78,13 +78,13 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
             const inner = importPath.slice(1, -1);
             const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
             for (const part of parts) {
-                const partResult = resolveRustImport(currentFile, part, allFiles);
+                const partResult = resolveRustImportInternal(currentFile, part, allFiles);
                 if (partResult)
                     return cache(partResult);
             }
             return cache(null);
         }
-        const rustResult = resolveRustImport(currentFile, rustImportPath, allFiles);
+        const rustResult = resolveRustImportInternal(currentFile, rustImportPath, allFiles);
         if (rustResult)
             return cache(rustResult);
         // Fall through to generic resolution if Rust-specific didn't match
@@ -121,3 +121,22 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
     const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
     return cache(resolved);
 };
+// ============================================================================
+// Per-language dispatch functions (moved from import-resolution.ts)
+// ============================================================================
+/**
+ * Standard single-file resolution (TS/JS/C/C++ and fallback for other languages).
+ * Handles relative imports, tsconfig path aliases, and suffix matching.
+ */
+export function resolveStandard(rawImportPath, filePath, ctx, language) {
+    const resolvedPath = resolveImportPath(filePath, rawImportPath, ctx.allFilePaths, ctx.allFileList, ctx.normalizedFileList, ctx.resolveCache, language, ctx.configs.tsconfigPaths, ctx.index);
+    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
+}
+/** JavaScript: standard single-file resolution. */
+export const resolveJavascriptImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.JavaScript);
+/** TypeScript: standard single-file resolution. */
+export const resolveTypescriptImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.TypeScript);
+/** C: standard single-file resolution for #include directives. */
+export const resolveCImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.C);
+/** C++: standard single-file resolution for #include directives. */
+export const resolveCppImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.CPlusPlus);

package/dist/core/ingestion/import-resolvers/swift.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Swift module import resolution.
+ * Handles module imports via Package.swift target map.
+ */
+import type { ImportResult, ResolveCtx } from './types.js';
+/** Swift: module imports via Package.swift target map. */
+export declare function resolveSwiftImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/swift.js

@@ -0,0 +1,23 @@
+/**
+ * Swift module import resolution.
+ * Handles module imports via Package.swift target map.
+ */
+/** Swift: module imports via Package.swift target map. */
+export function resolveSwiftImport(rawImportPath, _filePath, ctx) {
+    const swiftPackageConfig = ctx.configs.swiftPackageConfig;
+    if (swiftPackageConfig) {
+        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
+        if (targetDir) {
+            const dirPrefix = targetDir + '/';
+            const files = [];
+            for (let i = 0; i < ctx.normalizedFileList.length; i++) {
+                if (ctx.normalizedFileList[i].startsWith(dirPrefix) && ctx.normalizedFileList[i].endsWith('.swift')) {
+                    files.push(ctx.allFileList[i]);
+                }
+            }
+            if (files.length > 0)
+                return { kind: 'files', files };
+        }
+    }
+    return null; // External framework (Foundation, UIKit, etc.)
+}

package/dist/core/ingestion/import-resolvers/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Import resolution types — shared across all per-language resolvers.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from '../language-config.js';
+import type { SwiftPackageConfig } from '../language-config.js';
+import type { SuffixIndex } from './utils.js';
+/**
+ * Result of resolving an import via language-specific dispatch.
+ * - 'files': resolved to one or more files -> add to ImportMap
+ * - 'package': resolved to a directory -> add graph edges + store dirSuffix in PackageMap
+ * - null: no resolution (external dependency, etc.)
+ */
+export type ImportResult = {
+    kind: 'files';
+    files: string[];
+} | {
+    kind: 'package';
+    files: string[];
+    dirSuffix: string;
+} | null;
+/** Bundled language-specific configs loaded once per ingestion run. */
+export interface ImportConfigs {
+    tsconfigPaths: TsconfigPaths | null;
+    goModule: GoModuleConfig | null;
+    composerConfig: ComposerConfig | null;
+    swiftPackageConfig: SwiftPackageConfig | null;
+    csharpConfigs: CSharpProjectConfig[];
+}
+/** Pre-built lookup structures for import resolution. Build once, reuse across chunks. */
+export interface ImportResolutionContext {
+    allFilePaths: Set<string>;
+    allFileList: string[];
+    normalizedFileList: string[];
+    index: SuffixIndex;
+    resolveCache: Map<string, string | null>;
+}
+/** Full context for import resolution: file lookups + language configs. */
+export interface ResolveCtx extends ImportResolutionContext {
+    configs: ImportConfigs;
+}
+/** Per-language import resolver -- function alias matching ExportChecker/CallRouter pattern. */
+export type ImportResolverFn = (rawImportPath: string, filePath: string, resolveCtx: ResolveCtx) => ImportResult;

package/dist/core/ingestion/import-resolvers/types.js

@@ -0,0 +1,6 @@
+/**
+ * Import resolution types — shared across all per-language resolvers.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+export {};

package/dist/core/ingestion/{resolvers → import-resolvers}/utils.d.ts

@@ -2,7 +2,6 @@
  * Shared utilities for import resolution.
  * Extracted from import-processor.ts to reduce file size.
  */
-import type { SyntaxNode } from '../utils.js';
 /** All file extensions to try during resolution */
 export declare const EXTENSIONS: string[];
 /**
@@ -34,5 +33,3 @@ export declare function buildSuffixIndex(normalizedFileList: string[], allFileLi
  * Suffix-based resolution using index. O(1) per lookup instead of O(files).
  */
 export declare function suffixResolve(pathParts: string[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
-/** Find the first direct named child of a tree-sitter node matching the given type. */
-export declare function findChild(node: SyntaxNode, type: string): SyntaxNode | null;

package/dist/core/ingestion/{resolvers → import-resolvers}/utils.js

@@ -127,12 +127,3 @@ export function suffixResolve(pathParts, normalizedFileList, allFileList, index)
     }
     return null;
 }
-/** Find the first direct named child of a tree-sitter node matching the given type. */
-export function findChild(node, type) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === type)
-            return child;
-    }
-    return null;
-}

package/dist/core/ingestion/language-config.d.ts

@@ -1,4 +1,4 @@
-import type { ImportConfigs } from './import-resolution.js';
+import type { ImportConfigs } from './import-resolvers/types.js';
 /** TypeScript path alias config parsed from tsconfig.json */
 export interface TsconfigPaths {
     /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
@@ -15,6 +15,9 @@ export interface GoModuleConfig {
 export interface ComposerConfig {
     /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
     psr4: Map<string, string>;
+    /** PSR-4 entries sorted by namespace length descending (longest match wins).
+     *  Cached once at config load time to avoid re-sorting on every import. */
+    psr4Sorted?: readonly [string, string][];
 }
 /** C# project config parsed from .csproj files */
 export interface CSharpProjectConfig {

package/dist/core/ingestion/language-provider.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Language Provider interface — the complete capability contract for a supported language.
+ *
+ * Each language implements this interface in a single file under `languages/`.
+ * The pipeline accesses all per-language behavior through this interface.
+ *
+ * Design pattern: Strategy pattern with compile-time exhaustiveness.
+ * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
+ * so adding a language to the enum without creating a provider is a compiler error.
+ */
+import type { SupportedLanguages } from '../../config/supported-languages.js';
+import type { LanguageTypeConfig } from './type-extractors/types.js';
+import type { CallRouter } from './call-routing.js';
+import type { ExportChecker } from './export-detection.js';
+import type { FieldExtractor } from './field-extractor.js';
+import type { ImportResolverFn } from './import-resolvers/types.js';
+import type { NamedBindingExtractorFn } from './named-bindings/types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { NodeLabel } from '../graph/types.js';
+/** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
+export type CaptureMap = Record<string, SyntaxNode | undefined>;
+/** MRO strategy for multiple inheritance resolution. */
+export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax';
+/** How a language handles imports — determines wildcard synthesis behavior. */
+export type ImportSemantics = 'named' | 'wildcard' | 'namespace';
+/**
+ * Everything a language needs to provide.
+ * Required fields must be explicitly set; optional fields have defaults
+ * applied by defineLanguage().
+ */
+interface LanguageProviderConfig {
+    readonly id: SupportedLanguages;
+    /** File extensions that map to this language (e.g., ['.ts', '.tsx']) */
+    readonly extensions: readonly string[];
+    /** Parse strategy: 'tree-sitter' (default) uses AST parsing via tree-sitter.
+     *  'standalone' means the language has its own regex-based processor and
+     *  should be skipped by the tree-sitter pipeline (e.g., COBOL, Markdown). */
+    readonly parseStrategy?: 'tree-sitter' | 'standalone';
+    /** Tree-sitter query strings for definitions, imports, calls, heritage.
+     *  Required for tree-sitter languages; empty string for standalone processors. */
+    readonly treeSitterQueries: string;
+    /** Type extraction: declarations, initializers, for-loop bindings */
+    readonly typeConfig: LanguageTypeConfig;
+    /** Export detection: is this AST node a public/exported symbol? */
+    readonly exportChecker: ExportChecker;
+    /** Import resolution: resolves raw import path to file system path */
+    readonly importResolver: ImportResolverFn;
+    /** Call routing for languages that express imports/heritage as calls (e.g., Ruby).
+     *  Default: no routing (all calls are normal call expressions). */
+    readonly callRouter?: CallRouter;
+    /** Named binding extraction from import statements.
+     *  Default: undefined (language uses wildcard/whole-module imports). */
+    readonly namedBindingExtractor?: NamedBindingExtractorFn;
+    /** How this language handles imports.
+     *  - 'named': per-symbol imports (JS/TS, Java, C#, Rust, PHP, Kotlin)
+     *  - 'wildcard': whole-module imports, needs synthesis (Go, Ruby, C/C++, Swift)
+     *  - 'namespace': namespace imports, needs moduleAliasMap (Python)
+     *  Default: 'named'. */
+    readonly importSemantics?: ImportSemantics;
+    /** Language-specific transformation of raw import path text before resolution.
+     *  Called after sanitization. E.g., Kotlin appends wildcard suffixes.
+     *  Default: undefined (no preprocessing). */
+    readonly importPathPreprocessor?: (cleaned: string, importNode: SyntaxNode) => string;
+    /** Wire implicit inter-file imports for languages where all files in a module
+     *  see each other (e.g., Swift targets, C header inclusion units).
+     *  Called with only THIS language's files (pre-grouped by the processor).
+     *  Default: undefined (no implicit imports). */
+    readonly implicitImportWirer?: (languageFiles: string[], importMap: ReadonlyMap<string, ReadonlySet<string>>, addImportEdge: (src: string, target: string) => void, projectConfig: unknown) => void;
+    /** Resolve the enclosing function name + label from an AST ancestor node
+     *  that is NOT a standard FUNCTION_NODE_TYPE.  For languages where the
+     *  function body is a sibling of the signature (e.g. Dart: function_body ↔
+     *  function_signature are siblings under program/class_body), the default
+     *  parent walk cannot find the enclosing function.  This hook lets the
+     *  language provider inspect each ancestor and return the resolved result.
+     *  Return null to continue the default walk.
+     *  Default: undefined (standard parent walk only). */
+    readonly enclosingFunctionFinder?: (ancestorNode: SyntaxNode) => {
+        funcName: string;
+        label: NodeLabel;
+    } | null;
+    /** Override the default node label for definition.function captures.
+     *  Return null to skip (C/C++ duplicate), a different label to reclassify
+     *  (e.g., 'Method' for Kotlin), or defaultLabel to keep as-is.
+     *  Default: undefined (standard label assignment). */
+    readonly labelOverride?: (functionNode: SyntaxNode, defaultLabel: NodeLabel) => NodeLabel | null;
+    /** Default edge type when parent symbol is ambiguous (interface vs class).
+     *  Default: 'EXTENDS'. */
+    readonly heritageDefaultEdge?: 'EXTENDS' | 'IMPLEMENTS';
+    /** Regex to detect interface names by convention (e.g., /^I[A-Z]/ for C#/Java).
+     *  When matched, IMPLEMENTS edge is used instead of heritageDefaultEdge. */
+    readonly interfaceNamePattern?: RegExp;
+    /** MRO strategy for multiple inheritance resolution.
+     *  Default: 'first-wins'. */
+    readonly mroStrategy?: MroStrategy;
+    /** Field extractor for extracting field/property definitions from class/struct
+     *  declarations. Produces FieldInfo[] with name, type, visibility, static,
+     *  readonly metadata. Default: undefined (no field extraction). */
+    readonly fieldExtractor?: FieldExtractor;
+    /** Extract a semantic description for a definition node (e.g., PHP Eloquent
+     *  property arrays, relation method descriptions).
+     *  Default: undefined (no description extraction). */
+    readonly descriptionExtractor?: (nodeLabel: NodeLabel, nodeName: string, captureMap: CaptureMap) => string | undefined;
+    /** Detect if a file contains framework route definitions (e.g., Laravel routes.php).
+     *  When true, the worker extracts routes via the language's route extraction logic.
+     *  Default: undefined (no route files). */
+    readonly isRouteFile?: (filePath: string) => boolean;
+    /** Built-in/stdlib names that should be filtered from the call graph for this language.
+     *  Default: undefined (no language-specific filtering). */
+    readonly builtInNames?: ReadonlySet<string>;
+}
+/** Runtime type — same as LanguageProviderConfig but with defaults guaranteed present. */
+export interface LanguageProvider extends Omit<LanguageProviderConfig, 'importSemantics' | 'heritageDefaultEdge' | 'mroStrategy'> {
+    readonly importSemantics: ImportSemantics;
+    readonly heritageDefaultEdge: 'EXTENDS' | 'IMPLEMENTS';
+    readonly mroStrategy: MroStrategy;
+    /** Check if a name is a built-in/stdlib function that should be filtered from the call graph. */
+    readonly isBuiltInName: (name: string) => boolean;
+}
+/** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */
+export declare function defineLanguage(config: LanguageProviderConfig): LanguageProvider;
+export {};

package/dist/core/ingestion/language-provider.js

@@ -0,0 +1,24 @@
+/**
+ * Language Provider interface — the complete capability contract for a supported language.
+ *
+ * Each language implements this interface in a single file under `languages/`.
+ * The pipeline accesses all per-language behavior through this interface.
+ *
+ * Design pattern: Strategy pattern with compile-time exhaustiveness.
+ * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
+ * so adding a language to the enum without creating a provider is a compiler error.
+ */
+const DEFAULTS = {
+    importSemantics: 'named',
+    heritageDefaultEdge: 'EXTENDS',
+    mroStrategy: 'first-wins',
+};
+/** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */
+export function defineLanguage(config) {
+    const builtIns = config.builtInNames;
+    return {
+        ...DEFAULTS,
+        ...config,
+        isBuiltInName: builtIns ? (name) => builtIns.has(name) : () => false,
+    };
+}

package/dist/core/ingestion/languages/c-cpp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import type { LanguageProvider } from '../language-provider.js';
+export declare const cProvider: LanguageProvider;
+export declare const cppProvider: LanguageProvider;

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

@@ -0,0 +1,71 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as cCppConfig } from '../type-extractors/c-cpp.js';
+import { cCppExportChecker } from '../export-detection.js';
+import { resolveCImport, resolveCppImport } from '../import-resolvers/standard.js';
+import { C_QUERIES, CPP_QUERIES } from '../tree-sitter-queries.js';
+import { isCppInsideClassOrStruct } from '../utils/ast-helpers.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { cConfig as cFieldConfig, cppConfig as cppFieldConfig } from '../field-extractors/configs/c-cpp.js';
+const C_BUILT_INS = new Set([
+    'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
+    'scanf', 'fscanf', 'sscanf',
+    'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
+    'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr',
+    'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod',
+    'sizeof', 'offsetof', 'typeof',
+    'assert', 'abort', 'exit', '_exit',
+    'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
+    'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
+    'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
+    'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
+    'min', 'max', 'clamp', 'abs', 'swap',
+    'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
+    'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
+    'GFP_KERNEL', 'GFP_ATOMIC',
+    'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
+    'mutex_lock', 'mutex_unlock', 'mutex_init',
+    'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
+    'get', 'put',
+]);
+/** Label override shared by C and C++: skip function_definition captures inside class/struct
+ *  bodies (they're duplicates of definition.method captures). */
+const cppLabelOverride = (functionNode, defaultLabel) => {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    return isCppInsideClassOrStruct(functionNode) ? null : defaultLabel;
+};
+export const cProvider = defineLanguage({
+    id: SupportedLanguages.C,
+    extensions: ['.c'],
+    treeSitterQueries: C_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: resolveCImport,
+    importSemantics: 'wildcard',
+    fieldExtractor: createFieldExtractor(cFieldConfig),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});
+export const cppProvider = defineLanguage({
+    id: SupportedLanguages.CPlusPlus,
+    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+    treeSitterQueries: CPP_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: resolveCppImport,
+    importSemantics: 'wildcard',
+    mroStrategy: 'leftmost-base',
+    fieldExtractor: createFieldExtractor(cppFieldConfig),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});

package/dist/core/ingestion/languages/cobol.d.ts

@@ -0,0 +1 @@
+export declare const cobolProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/cobol.js

@@ -0,0 +1,26 @@
+/**
+ * COBOL Language Provider
+ *
+ * Standalone regex-based processor — no tree-sitter grammar.
+ * COBOL files (.cbl, .cob, .cobol, .cpy, .copybook) are detected and
+ * processed by cobol-processor.ts in pipeline Phase 2.6, not by the
+ * tree-sitter pipeline.
+ *
+ * This provider exists to satisfy the SupportedLanguages exhaustiveness
+ * checks and to declare parseStrategy: 'standalone'.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+export const cobolProvider = defineLanguage({
+    id: SupportedLanguages.Cobol,
+    parseStrategy: 'standalone',
+    extensions: [], // COBOL files detected by cobol-processor's isCobolFile/isJclFile
+    treeSitterQueries: '',
+    typeConfig: {
+        declarationNodeTypes: new Set(),
+        extractDeclaration: () => null,
+        extractParameter: () => null,
+    },
+    exportChecker: () => false,
+    importResolver: () => null,
+});

package/dist/core/ingestion/languages/csharp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * C# language provider.
+ *
+ * C# uses named imports (using directives), modifier-based export detection,
+ * and an implements-split MRO strategy for multiple interface implementation.
+ * Interface names follow the I-prefix convention (e.g., IDisposable).
+ */
+export declare const csharpProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,49 @@
+/**
+ * C# language provider.
+ *
+ * C# uses named imports (using directives), modifier-based export detection,
+ * and an implements-split MRO strategy for multiple interface implementation.
+ * Interface names follow the I-prefix convention (e.g., IDisposable).
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as csharpConfig } from '../type-extractors/csharp.js';
+import { csharpExportChecker } from '../export-detection.js';
+import { resolveCSharpImport } from '../import-resolvers/csharp.js';
+import { extractCSharpNamedBindings } from '../named-bindings/csharp.js';
+import { CSHARP_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { csharpConfig as csharpFieldConfig } from '../field-extractors/configs/csharp.js';
+const BUILT_INS = new Set([
+    'Console', 'WriteLine', 'ReadLine', 'Write',
+    'Task', 'Run', 'Wait', 'WhenAll', 'WhenAny', 'FromResult', 'Delay', 'ContinueWith',
+    'ConfigureAwait', 'GetAwaiter', 'GetResult',
+    'ToString', 'GetType', 'Equals', 'GetHashCode', 'ReferenceEquals',
+    'Add', 'Remove', 'Contains', 'Clear', 'Count', 'Any', 'All',
+    'Where', 'Select', 'SelectMany', 'OrderBy', 'OrderByDescending', 'GroupBy',
+    'First', 'FirstOrDefault', 'Single', 'SingleOrDefault', 'Last', 'LastOrDefault',
+    'ToList', 'ToArray', 'ToDictionary', 'AsEnumerable', 'AsQueryable',
+    'Aggregate', 'Sum', 'Average', 'Min', 'Max', 'Distinct', 'Skip', 'Take',
+    'String', 'Format', 'IsNullOrEmpty', 'IsNullOrWhiteSpace', 'Concat', 'Join',
+    'Trim', 'TrimStart', 'TrimEnd', 'Split', 'Replace', 'StartsWith', 'EndsWith',
+    'Convert', 'ToInt32', 'ToDouble', 'ToBoolean', 'ToByte',
+    'Math', 'Abs', 'Ceiling', 'Floor', 'Round', 'Pow', 'Sqrt',
+    'Dispose', 'Close',
+    'TryParse', 'Parse',
+    'AddRange', 'RemoveAt', 'RemoveAll', 'FindAll', 'Exists', 'TrueForAll',
+    'ContainsKey', 'TryGetValue', 'AddOrUpdate',
+    'Throw', 'ThrowIfNull',
+]);
+export const csharpProvider = defineLanguage({
+    id: SupportedLanguages.CSharp,
+    extensions: ['.cs'],
+    treeSitterQueries: CSHARP_QUERIES,
+    typeConfig: csharpConfig,
+    exportChecker: csharpExportChecker,
+    importResolver: resolveCSharpImport,
+    namedBindingExtractor: extractCSharpNamedBindings,
+    interfaceNamePattern: /^I[A-Z]/,
+    mroStrategy: 'implements-split',
+    fieldExtractor: createFieldExtractor(csharpFieldConfig),
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/dart.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard' (Dart imports bring everything public into scope)
+ *   - exportChecker: public if no leading underscore
+ *   - Dart SDK imports (dart:*) and external packages are skipped
+ *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
+ *     as a sibling of function_signature/method_signature (not as a child).
+ *     The hook resolves the enclosing function by inspecting the previous sibling.
+ */
+export declare const dartProvider: import("../language-provider.js").LanguageProvider;