@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/core/ingestion/unity-runtime-binding-rules.js

@@ -1,6 +1,7 @@
 import { generateId } from '../../lib/utils.js';
 const RULE_EDGE_CONFIDENCE = 0.75;
-export function applyUnityRuntimeBindingRules(graph, rules, _config) {
+const RULE_ANOMALY_PREVIEW_LIMIT = 5;
+export function applyUnityRuntimeBindingRules(graph, rules, config) {
     const ruleResults = [];
     let totalEdges = 0;
     const existingPairs = new Set();
@@ -27,7 +28,10 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
     };
     // Pre-build indexes
     const methodsByClassId = new Map();
-    const classNodes = [];
+    const containerNodes = [];
+    const containerLabels = config.enableContainerNodes
+        ? new Set(['Class', 'Struct', 'Interface', 'Record'])
+        : new Set(['Class']);
     for (const rel of graph.iterRelationships()) {
         if (rel.type !== 'HAS_METHOD')
             continue;
@@ -39,8 +43,8 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
         methodsByClassId.set(rel.sourceId, list);
     }
     for (const node of graph.iterNodes()) {
-        if (node.label === 'Class')
-            classNodes.push(node);
+        if (containerLabels.has(node.label))
+            containerNodes.push(node);
     }
     // Collect UNITY_ASSET_GUID_REF and UNITY_COMPONENT_INSTANCE edges
     const assetGuidRefs = [];
@@ -51,6 +55,24 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
         else if (rel.type === 'UNITY_COMPONENT_INSTANCE')
             componentInstances.push(rel);
     }
+    const prefabSourceTargetsBySource = buildPrefabSourceTargetsBySource(assetGuidRefs);
+    const methodsByResourceId = buildMethodsByResourceId(componentInstances, methodsByClassId);
+    const executionState = {
+        methodsByResourceId,
+        resourceMethodLookupCache: new Map(),
+        sceneRuntimeResourceIdsCache: new Map(),
+        diagnostics: {
+            rulesEvaluated: rules.length,
+            bindingsEvaluated: 0,
+            bindingsByKind: {},
+            methodLookupCalls: 0,
+            methodLookupCacheHits: 0,
+            sceneRuntimeTraversalCalls: 0,
+            sceneRuntimeTraversalCacheHits: 0,
+            sceneRuntimeResourcesVisited: 0,
+            anomalySet: new Set(),
+        },
+    };
     // Pre-build scene file index: lowercase scene name → fileId[]
     const sceneFilesByName = new Map();
     for (const node of graph.iterNodes()) {
@@ -67,51 +89,69 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
     for (const rule of rules) {
         let ruleEdges = 0;
         for (const binding of rule.resource_bindings ?? []) {
-            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addSyntheticEdge);
+            executionState.diagnostics.bindingsEvaluated += 1;
+            executionState.diagnostics.bindingsByKind[binding.kind] =
+                (executionState.diagnostics.bindingsByKind[binding.kind] || 0) + 1;
+            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addSyntheticEdge);
         }
         if (rule.lifecycle_overrides?.additional_entry_points?.length) {
-            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, classNodes, addSyntheticEdge);
+            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, containerNodes, addSyntheticEdge);
         }
         totalEdges += ruleEdges;
         ruleResults.push({ ruleId: rule.id, edgesInjected: ruleEdges });
     }
-    return { edgesInjected: totalEdges, ruleResults };
+    return {
+        edgesInjected: totalEdges,
+        ruleResults,
+        diagnostics: finalizeRuleBindingDiagnostics(executionState.diagnostics, totalEdges),
+    };
 }
-function findMethodsOnResource(resourceFileId, componentInstances, methodsByClassId, entryPoints) {
-    const results = [];
+function findMethodsOnResource(resourceFileId, executionState, entryPoints) {
+    executionState.diagnostics.methodLookupCalls += 1;
+    const cacheKey = `${resourceFileId}::${entryPoints.join('|')}`;
+    const cached = executionState.resourceMethodLookupCache.get(cacheKey);
+    if (cached) {
+        executionState.diagnostics.methodLookupCacheHits += 1;
+        return cached;
+    }
+    const methods = executionState.methodsByResourceId.get(resourceFileId) ?? [];
+    if (methods.length === 0) {
+        executionState.resourceMethodLookupCache.set(cacheKey, []);
+        return [];
+    }
     const entrySet = new Set(entryPoints);
-    for (const ci of componentInstances) {
-        if (ci.targetId !== resourceFileId)
-            continue;
-        const classId = ci.sourceId;
-        for (const method of methodsByClassId.get(classId) ?? []) {
-            if (entrySet.has(method.properties.name))
-                results.push(method);
-        }
+    const results = [];
+    for (const method of methods) {
+        if (entrySet.has(method.properties.name))
+            results.push(method);
     }
+    executionState.resourceMethodLookupCache.set(cacheKey, results);
     return results;
 }
-function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addEdge) {
+function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge) {
     if (binding.kind === 'asset_ref_loads_components') {
-        return processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, addEdge);
+        return processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, executionState, addEdge);
     }
     if (binding.kind === 'method_triggers_field_load') {
-        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge);
+        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, executionState, addEdge);
     }
     if (binding.kind === 'method_triggers_scene_load') {
-        return processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addEdge);
+        return processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge);
     }
     if (binding.kind === 'method_triggers_method') {
-        return processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNodes, addEdge);
+        return processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge);
     }
+    addAnomaly(executionState.diagnostics, `rule=${ruleId}: unsupported resource_binding kind "${binding.kind}"`);
     return 0;
 }
-function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, addEdge) {
+function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, executionState, addEdge) {
     let count = 0;
     const pattern = binding.ref_field_pattern ? new RegExp(binding.ref_field_pattern) : null;
     const entryPoints = binding.target_entry_points ?? [];
-    if (!pattern || entryPoints.length === 0)
+    if (!pattern || entryPoints.length === 0) {
+        addAnomaly(executionState.diagnostics, `rule=${ruleId}: asset_ref_loads_components missing ref_field_pattern or target_entry_points`);
         return 0;
+    }
     const runtimeRootId = generateId('Method', 'unity-runtime-root');
     for (const ref of assetGuidRefs) {
         let fieldName = '';
@@ -124,7 +164,7 @@ function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componen
         }
         if (!pattern.test(fieldName))
             continue;
-        const targetMethods = findMethodsOnResource(ref.targetId, componentInstances, methodsByClassId, entryPoints);
+        const targetMethods = findMethodsOnResource(ref.targetId, executionState, entryPoints);
         for (const method of targetMethods) {
             if (addEdge(runtimeRootId, method.id, `unity-rule-resource-load:${ruleId}`))
                 count++;
@@ -132,15 +172,17 @@ function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componen
     }
     return count;
 }
-function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge) {
+function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, executionState, addEdge) {
     let count = 0;
     const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
     const loaderMethodNames = new Set(binding.loader_methods ?? []);
     const entryPoints = binding.target_entry_points ?? [];
     const defaultEntryPoints = ['OnEnable', 'Awake', 'Start'];
     const resolvedEntryPoints = entryPoints.length > 0 ? entryPoints : defaultEntryPoints;
-    if (!classPattern || loaderMethodNames.size === 0)
+    if (!classPattern || loaderMethodNames.size === 0) {
+        addAnomaly(executionState.diagnostics, `rule=${ruleId}: method_triggers_field_load missing host_class_pattern or loader_methods`);
         return 0;
+    }
     // Build asset ref index by source file
     const refsBySource = new Map();
     for (const ref of assetGuidRefs) {
@@ -148,7 +190,7 @@ function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componen
         list.push(ref);
         refsBySource.set(ref.sourceId, list);
     }
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (!classPattern.test(cls.properties.name))
             continue;
         const methods = methodsByClassId.get(cls.id) ?? [];
@@ -164,7 +206,7 @@ function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componen
         // Follow asset refs from those resource files
         for (const resourceFileId of resourceFileIds) {
             for (const ref of refsBySource.get(resourceFileId) ?? []) {
-                const targetMethods = findMethodsOnResource(ref.targetId, componentInstances, methodsByClassId, resolvedEntryPoints);
+                const targetMethods = findMethodsOnResource(ref.targetId, executionState, resolvedEntryPoints);
                 for (const loader of loaders) {
                     for (const target of targetMethods) {
                         if (addEdge(loader.id, target.id, `unity-rule-loader-bridge:${ruleId}`))
@@ -176,7 +218,7 @@ function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componen
     }
     return count;
 }
-function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addEdge) {
+function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge) {
     const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
     const loaderMethodNames = new Set(binding.loader_methods ?? []);
     const sceneName = binding.scene_name;
@@ -184,13 +226,17 @@ function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, met
     const entryPoints = (binding.target_entry_points ?? []).length > 0
         ? binding.target_entry_points
         : defaultEntryPoints;
-    if (!classPattern || loaderMethodNames.size === 0 || !sceneName)
+    if (!classPattern || loaderMethodNames.size === 0 || !sceneName) {
+        addAnomaly(executionState.diagnostics, `rule=${ruleId}: method_triggers_scene_load missing host_class_pattern, loader_methods, or scene_name`);
         return 0;
+    }
     const sceneFileIds = sceneFilesByName.get(sceneName.toLowerCase()) ?? [];
-    if (sceneFileIds.length === 0)
+    if (sceneFileIds.length === 0) {
+        addAnomaly(executionState.diagnostics, `rule=${ruleId}: scene "${sceneName}" not found in File(.unity) index`);
         return 0;
+    }
     let count = 0;
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (!classPattern.test(cls.properties.name))
             continue;
         const methods = methodsByClassId.get(cls.id) ?? [];
@@ -198,18 +244,82 @@ function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, met
         if (loaders.length === 0)
             continue;
         for (const sceneFileId of sceneFileIds) {
-            const targetMethods = findMethodsOnResource(sceneFileId, componentInstances, methodsByClassId, entryPoints);
-            for (const loader of loaders) {
-                for (const target of targetMethods) {
-                    if (addEdge(loader.id, target.id, `unity-rule-scene-load:${ruleId}`))
-                        count++;
+            const runtimeResourceIds = getSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource, executionState);
+            for (const runtimeResourceId of runtimeResourceIds) {
+                const targetMethods = findMethodsOnResource(runtimeResourceId, executionState, entryPoints);
+                for (const loader of loaders) {
+                    for (const target of targetMethods) {
+                        if (addEdge(loader.id, target.id, `unity-rule-scene-load:${ruleId}`))
+                            count++;
+                    }
                 }
             }
         }
     }
     return count;
 }
-function processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNodes, addEdge) {
+function buildMethodsByResourceId(componentInstances, methodsByClassId) {
+    const methodsByResourceId = new Map();
+    for (const componentRef of componentInstances) {
+        const methods = methodsByClassId.get(componentRef.sourceId) ?? [];
+        if (methods.length === 0)
+            continue;
+        const list = methodsByResourceId.get(componentRef.targetId) ?? [];
+        list.push(...methods);
+        methodsByResourceId.set(componentRef.targetId, list);
+    }
+    return methodsByResourceId;
+}
+function buildPrefabSourceTargetsBySource(assetGuidRefs) {
+    const targetsBySource = new Map();
+    for (const ref of assetGuidRefs) {
+        let fieldName = '';
+        try {
+            const parsed = JSON.parse(String(ref.reason || '{}'));
+            fieldName = String(parsed?.fieldName || '');
+        }
+        catch {
+            continue;
+        }
+        if (fieldName !== 'm_SourcePrefab')
+            continue;
+        const targets = targetsBySource.get(ref.sourceId) ?? new Set();
+        targets.add(ref.targetId);
+        targetsBySource.set(ref.sourceId, targets);
+    }
+    const out = new Map();
+    for (const [sourceId, targets] of targetsBySource.entries()) {
+        out.set(sourceId, [...targets]);
+    }
+    return out;
+}
+function collectSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource) {
+    const visited = new Set([sceneFileId]);
+    const queue = [sceneFileId];
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        for (const targetId of prefabSourceTargetsBySource.get(currentId) ?? []) {
+            if (visited.has(targetId))
+                continue;
+            visited.add(targetId);
+            queue.push(targetId);
+        }
+    }
+    return [...visited];
+}
+function getSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource, executionState) {
+    executionState.diagnostics.sceneRuntimeTraversalCalls += 1;
+    const cached = executionState.sceneRuntimeResourceIdsCache.get(sceneFileId);
+    if (cached) {
+        executionState.diagnostics.sceneRuntimeTraversalCacheHits += 1;
+        return cached;
+    }
+    const ids = collectSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource);
+    executionState.sceneRuntimeResourceIdsCache.set(sceneFileId, ids);
+    executionState.diagnostics.sceneRuntimeResourcesVisited += ids.length;
+    return ids;
+}
+function processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge) {
     const { source_class_pattern, source_method, target_class_pattern, target_method } = binding;
     if (!source_class_pattern || !source_method || !target_class_pattern || !target_method)
         return 0;
@@ -217,7 +327,7 @@ function processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNod
     const tgtPattern = new RegExp(target_class_pattern);
     let sourceMethodId;
     let targetMethodId;
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (!sourceMethodId && srcPattern.test(cls.properties.name)) {
             const match = (methodsByClassId.get(cls.id) ?? []).find(m => m.properties.name === source_method);
             if (match)
@@ -235,7 +345,7 @@ function processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNod
         return 0;
     return addEdge(sourceMethodId, targetMethodId, `unity-rule-method-bridge:${ruleId}`) ? 1 : 0;
 }
-function processLifecycleOverrides(rule, methodsByClassId, classNodes, addEdge) {
+function processLifecycleOverrides(rule, methodsByClassId, containerNodes, addEdge) {
     const overrides = rule.lifecycle_overrides;
     if (!overrides?.additional_entry_points?.length)
         return 0;
@@ -243,7 +353,7 @@ function processLifecycleOverrides(rule, methodsByClassId, classNodes, addEdge)
     const scopePattern = overrides.scope ? new RegExp(overrides.scope) : null;
     let count = 0;
     const runtimeRootId = generateId('Method', 'unity-runtime-root');
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (scopePattern && !scopePattern.test(cls.properties.filePath ?? cls.properties.name))
             continue;
         for (const method of methodsByClassId.get(cls.id) ?? []) {
@@ -255,3 +365,44 @@ function processLifecycleOverrides(rule, methodsByClassId, classNodes, addEdge)
     }
     return count;
 }
+function addAnomaly(diagnostics, message) {
+    diagnostics.anomalySet.add(message);
+}
+function finalizeRuleBindingDiagnostics(diagnostics, edgesInjected) {
+    const anomalies = [...diagnostics.anomalySet];
+    const shouldAgentReport = anomalies.length > 0;
+    const bindingsByKind = Object.fromEntries(Object.entries(diagnostics.bindingsByKind).sort(([a], [b]) => a.localeCompare(b)));
+    const kindSummary = Object.entries(bindingsByKind)
+        .map(([kind, count]) => `${kind}=${count}`)
+        .join(', ') || 'none';
+    const summary = [
+        `rule_binding.summary: rules=${diagnostics.rulesEvaluated}, bindings=${diagnostics.bindingsEvaluated}, edges=${edgesInjected}`,
+        `rule_binding.bindings_by_kind: ${kindSummary}`,
+        `rule_binding.lookup: method_calls=${diagnostics.methodLookupCalls}, cache_hits=${diagnostics.methodLookupCacheHits}`,
+        `rule_binding.scene_closure: traversals=${diagnostics.sceneRuntimeTraversalCalls}, cache_hits=${diagnostics.sceneRuntimeTraversalCacheHits}, visited_resources=${diagnostics.sceneRuntimeResourcesVisited}`,
+        `rule_binding.agent_report: should_report=${shouldAgentReport} reason="${shouldAgentReport ? 'rule-binding anomalies detected' : 'no anomalies detected'}"`,
+    ];
+    if (anomalies.length > 0) {
+        summary.push(`rule_binding.anomalies: count=${anomalies.length}`);
+        for (const anomaly of anomalies.slice(0, RULE_ANOMALY_PREVIEW_LIMIT)) {
+            summary.push(`rule_binding.anomaly: ${anomaly}`);
+        }
+        if (anomalies.length > RULE_ANOMALY_PREVIEW_LIMIT) {
+            summary.push(`rule_binding.anomaly: ... ${anomalies.length - RULE_ANOMALY_PREVIEW_LIMIT} more`);
+        }
+    }
+    return {
+        rulesEvaluated: diagnostics.rulesEvaluated,
+        bindingsEvaluated: diagnostics.bindingsEvaluated,
+        bindingsByKind,
+        methodLookupCalls: diagnostics.methodLookupCalls,
+        methodLookupCacheHits: diagnostics.methodLookupCacheHits,
+        sceneRuntimeTraversalCalls: diagnostics.sceneRuntimeTraversalCalls,
+        sceneRuntimeTraversalCacheHits: diagnostics.sceneRuntimeTraversalCacheHits,
+        sceneRuntimeResourcesVisited: diagnostics.sceneRuntimeResourcesVisited,
+        anomalies,
+        shouldAgentReport,
+        agentReportReason: shouldAgentReport ? 'rule-binding anomalies detected' : 'no anomalies detected',
+        summary,
+    };
+}

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -97,10 +97,12 @@ export interface ParseWorkerResult {
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];
     skippedLanguages: Record<string, number>;
+    csharpPreprocFallbackFiles: number;
     fileCount: number;
 }
 export interface ParseWorkerInput {
     path: string;
     content: string;
+    rawContent?: string;
 }
 export {};

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

@@ -14,7 +14,7 @@ import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
 import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../constants.js';
+import { TREE_SITTER_MAX_BUFFER } from '../constants.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;
@@ -166,6 +166,7 @@ const processBatch = (files, onProgress) => {
         routes: [],
         constructorBindings: [],
         skippedLanguages: {},
+        csharpPreprocFallbackFiles: 0,
         fileCount: 0,
     };
     // Group by language to minimize setLanguage calls
@@ -716,14 +717,56 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
         let tree;
+        let usedRawContentFallback = false;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            const MAX_CHUNK = 4096;
+            tree = parser.parse((index) => {
+                if (index >= file.content.length)
+                    return null;
+                return file.content.slice(index, index + MAX_CHUNK);
+            });
         }
         catch (err) {
-            console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
-            continue;
+            if (file.rawContent && file.rawContent !== file.content) {
+                try {
+                    const MAX_CHUNK = 4096;
+                    tree = parser.parse((index) => {
+                        if (index >= file.rawContent.length)
+                            return null;
+                        return file.rawContent.slice(index, index + MAX_CHUNK);
+                    });
+                    usedRawContentFallback = true;
+                }
+                catch {
+                    console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+                    continue;
+                }
+            }
+            else {
+                console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
+        if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+            try {
+                const MAX_CHUNK = 4096;
+                const rawTree = parser.parse((index) => {
+                    if (index >= file.rawContent.length)
+                        return null;
+                    return file.rawContent.slice(index, index + MAX_CHUNK);
+                });
+                if (!rawTree.rootNode?.hasError) {
+                    tree = rawTree;
+                    usedRawContentFallback = true;
+                }
+            }
+            catch {
+                // Keep normalized parse result when raw fallback parsing fails
+            }
         }
         result.fileCount++;
+        if (usedRawContentFallback)
+            result.csharpPreprocFallbackFiles += 1;
         onFileProcessed?.();
         // Build per-file type environment + constructor bindings in a single AST walk.
         // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
@@ -1030,7 +1073,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
+    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, csharpPreprocFallbackFiles: 0, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -1045,6 +1088,7 @@ const mergeResult = (target, src) => {
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }
+    target.csharpPreprocFallbackFiles += src.csharpPreprocFallbackFiles;
     target.fileCount += src.fileCount;
 };
 parentPort.on('message', (msg) => {
@@ -1064,7 +1108,7 @@ parentPort.on('message', (msg) => {
         if (msg && msg.type === 'flush') {
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
-            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, csharpPreprocFallbackFiles: 0, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }

package/dist/core/lbug/csv-generator.test.js

@@ -1,8 +1,8 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { FileContentCache, toCodeElementCsvRow } from './csv-generator.js';
-test('FileContentCache evicts oldest entries when byte budget is exceeded', async () => {
-    const cache = new FileContentCache('/tmp/repo', 10);
+test('FileContentCache evicts oldest entries when max entry count is exceeded', async () => {
+    const cache = new FileContentCache('/tmp/repo', 1);
     cache.setForTest('a.cs', '123456');
     cache.setForTest('b.cs', '123456');
     assert.equal(cache.hasForTest('a.cs'), false);

package/dist/core/tree-sitter/csharp-define-profile.d.ts

@@ -0,0 +1,6 @@
+export interface CSharpDefineProfile {
+    symbols: Set<string>;
+    sourcePath: string;
+    rawDefineConstants: string[];
+}
+export declare function loadCSharpDefineProfileFromCsproj(csprojPath: string): Promise<CSharpDefineProfile>;

package/dist/core/tree-sitter/csharp-define-profile.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+const DEFINE_CONSTANTS_RE = /<DefineConstants>\s*([\s\S]*?)\s*<\/DefineConstants>/gi;
+const CSHARP_SYMBOL_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseSymbols(rawDefineConstants) {
+    const symbols = new Set();
+    for (const raw of rawDefineConstants) {
+        for (const token of raw.split(';')) {
+            const symbol = token.trim();
+            if (!symbol)
+                continue;
+            // Drop MSBuild placeholders such as $(DefineConstants)
+            if (symbol.includes('$('))
+                continue;
+            if (!CSHARP_SYMBOL_RE.test(symbol))
+                continue;
+            symbols.add(symbol);
+        }
+    }
+    return symbols;
+}
+export async function loadCSharpDefineProfileFromCsproj(csprojPath) {
+    const sourcePath = path.resolve(csprojPath);
+    let content;
+    try {
+        content = await fs.readFile(sourcePath, 'utf-8');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read C# csproj: ${sourcePath} (${message})`);
+    }
+    const rawDefineConstants = [];
+    for (const match of content.matchAll(DEFINE_CONSTANTS_RE)) {
+        const raw = (match[1] || '').trim();
+        if (raw)
+            rawDefineConstants.push(raw);
+    }
+    return {
+        symbols: parseSymbols(rawDefineConstants),
+        sourcePath,
+        rawDefineConstants,
+    };
+}

package/dist/core/tree-sitter/csharp-preproc-normalizer.d.ts

@@ -0,0 +1,14 @@
+export interface CSharpPreprocNormalizationDiagnostics {
+    directivesSeen: number;
+    inactiveLines: number;
+    undefinedSymbols: string[];
+    expressionErrors: number;
+    unmatchedEndif: number;
+    unterminatedIfBlocks: number;
+}
+export interface CSharpPreprocNormalizationResult {
+    normalizedText: string;
+    changed: boolean;
+    diagnostics: CSharpPreprocNormalizationDiagnostics;
+}
+export declare function normalizeCSharpPreprocessorBranches(source: string, defines: Set<string>): CSharpPreprocNormalizationResult;