@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

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

@@ -1,25 +1,30 @@
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage, isLanguageAvailable, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
 import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { typeConfigs } from './type-extractors/index.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
+import { TREE_SITTER_MAX_BUFFER } from './constants.js';
 // isNodeExported imported from ./export-detection.js (shared module)
 // Re-export for backward compatibility with any external consumers
 export { isNodeExported } from './export-detection.js';
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
-const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress) => {
+const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress, onRawFallbackParse) => {
     // Filter to parseable files only
     const parseableFiles = [];
     for (const file of files) {
         const lang = getLanguageFromFilename(file.path);
-        if (lang)
-            parseableFiles.push({ path: file.path, content: file.content });
+        if (lang) {
+            parseableFiles.push({
+                path: file.path,
+                content: file.content,
+                ...(file.rawContent ? { rawContent: file.rawContent } : {}),
+            });
+        }
     }
     if (parseableFiles.length === 0)
         return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
@@ -34,6 +39,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allHeritage = [];
     const allRoutes = [];
     const allConstructorBindings = [];
+    let rawFallbackCount = 0;
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -57,7 +63,10 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
         allConstructorBindings.push(...result.constructorBindings);
+        rawFallbackCount += result.csharpPreprocFallbackFiles;
     }
+    if (rawFallbackCount > 0)
+        onRawFallbackParse?.(rawFallbackCount);
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
     for (const result of chunkResults) {
@@ -78,7 +87,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 // ============================================================================
 // Sequential fallback (original implementation)
 // ============================================================================
-const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
+const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress, onRawFallbackParse) => {
     const parser = await loadParser();
     const total = files.length;
     const skippedLanguages = new Map();
@@ -106,11 +115,35 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            tree = parseContent(file.content);
         }
-        catch (parseError) {
-            console.warn(`Skipping unparseable file: ${file.path}`);
-            continue;
+        catch {
+            if (file.rawContent && file.rawContent !== file.content) {
+                try {
+                    tree = parseContent(file.rawContent);
+                    onRawFallbackParse?.(1);
+                }
+                catch {
+                    console.warn(`Skipping unparseable file: ${file.path}`);
+                    continue;
+                }
+            }
+            else {
+                console.warn(`Skipping unparseable file: ${file.path}`);
+                continue;
+            }
+        }
+        if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+            try {
+                const rawTree = parseContent(file.rawContent);
+                if (!rawTree.rootNode?.hasError) {
+                    tree = rawTree;
+                    onRawFallbackParse?.(1);
+                }
+            }
+            catch {
+                // Keep normalized parse result when raw fallback fails
+            }
         }
         astCache.set(file.path, tree);
         const queryString = LANGUAGE_QUERIES[language];
@@ -274,16 +307,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
 // ============================================================================
 // Public API
 // ============================================================================
-export const processParsing = async (graph, files, symbolTable, astCache, onFileProgress, workerPool) => {
+export const processParsing = async (graph, files, symbolTable, astCache, onFileProgress, workerPool, onRawFallbackParse) => {
     if (workerPool) {
         try {
-            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
+            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress, onRawFallbackParse);
         }
         catch (err) {
             console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
         }
     }
     // Fallback: sequential parsing (no pre-extracted data)
-    await processParsingSequential(graph, files, symbolTable, astCache, onFileProgress);
+    await processParsingSequential(graph, files, symbolTable, astCache, onFileProgress, onRawFallbackParse);
     return null;
 };

package/dist/core/ingestion/pipeline.js

@@ -11,11 +11,14 @@ import { processUnityResources } from './unity-resource-processor.js';
 import { applyUnityLifecycleSyntheticCalls } from './unity-lifecycle-synthetic-calls.js';
 import { applyUnityRuntimeBindingRules } from './unity-runtime-binding-rules.js';
 import { resolveUnityConfig } from '../config/unity-config.js';
+import { loadCSharpDefineProfileFromCsproj } from '../tree-sitter/csharp-define-profile.js';
+import { normalizeCSharpPreprocessorBranches } from '../tree-sitter/csharp-preproc-normalizer.js';
 import { loadAnalyzeRules } from '../../mcp/local/runtime-claim-rule-registry.js';
 import { createResolutionContext } from './resolution-context.js';
 import { createASTCache } from './ast-cache.js';
 import { walkRepositoryPaths, readFileContents, walkUnityResourcePaths } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { createWorkerPool } from './workers/worker-pool.js';
 import { selectEntriesByScopeRules } from './scope-filter.js';
@@ -39,7 +42,24 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         astCache.clear();
         ctx.clear();
     };
+    let csharpDefineSymbols;
+    const csharpUndefinedSymbols = new Set();
+    let csharpPreprocDiagnostics;
     try {
+        if (options?.csharpDefineCsproj) {
+            const defineProfile = await loadCSharpDefineProfileFromCsproj(options.csharpDefineCsproj);
+            csharpDefineSymbols = defineProfile.symbols;
+            csharpPreprocDiagnostics = {
+                enabled: true,
+                sourcePath: defineProfile.sourcePath,
+                defineSymbolCount: defineProfile.symbols.size,
+                normalizedFiles: 0,
+                fallbackFiles: 0,
+                skippedFiles: 0,
+                expressionErrors: 0,
+                undefinedSymbols: [],
+            };
+        }
         // ── Phase 1: Scan paths only (no content read) ─────────────────────
         onProgress({
             phase: 'extracting',
@@ -184,7 +204,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         // Calls/heritage use the symbol table built so far (symbols from earlier chunks
         // are already registered). This trades ~5% cross-chunk resolution accuracy for
         // 200-400MB less memory — critical for Linux-kernel-scale repos.
-        const sequentialChunkPaths = [];
+        const sequentialChunkFiles = [];
         try {
             for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
                 const chunkPaths = chunks[chunkIdx];
@@ -192,7 +212,27 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                 const chunkContents = await readFileContents(repoPath, chunkPaths);
                 const chunkFiles = chunkPaths
                     .filter(p => chunkContents.has(p))
-                    .map(p => ({ path: p, content: chunkContents.get(p) }));
+                    .map((p) => {
+                    const originalContent = chunkContents.get(p);
+                    if (!csharpDefineSymbols || getLanguageFromFilename(p) !== SupportedLanguages.CSharp) {
+                        return { path: p, content: originalContent };
+                    }
+                    const normalized = normalizeCSharpPreprocessorBranches(originalContent, csharpDefineSymbols);
+                    csharpPreprocDiagnostics.expressionErrors += normalized.diagnostics.expressionErrors;
+                    for (const symbol of normalized.diagnostics.undefinedSymbols) {
+                        csharpUndefinedSymbols.add(symbol);
+                    }
+                    if (!normalized.changed) {
+                        csharpPreprocDiagnostics.skippedFiles += 1;
+                        return { path: p, content: originalContent };
+                    }
+                    csharpPreprocDiagnostics.normalizedFiles += 1;
+                    return {
+                        path: p,
+                        content: normalized.normalizedText,
+                        rawContent: originalContent,
+                    };
+                });
                 // Parse this chunk (workers or sequential fallback)
                 const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, (current, _total, filePath) => {
                     const globalCurrent = filesParsedSoFar + current;
@@ -204,7 +244,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                         detail: filePath,
                         stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
                     });
-                }, workerPool);
+                }, workerPool, (count) => {
+                    if (csharpPreprocDiagnostics)
+                        csharpPreprocDiagnostics.fallbackFiles += count;
+                });
                 const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62);
                 if (chunkWorkerData) {
                     // Imports
@@ -251,8 +294,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                     ]);
                 }
                 else {
-                    await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
-                    sequentialChunkPaths.push(chunkPaths);
+                    await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths, (count) => {
+                        if (csharpPreprocDiagnostics)
+                            csharpPreprocDiagnostics.fallbackFiles += count;
+                    });
+                    sequentialChunkFiles.push(chunkFiles);
                 }
                 filesParsedSoFar += chunkFiles.length;
                 // Clear AST cache between chunks to free memory
@@ -263,15 +309,17 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         finally {
             await workerPool?.terminate();
         }
-        // Sequential fallback chunks: re-read source for call/heritage resolution
-        for (const chunkPaths of sequentialChunkPaths) {
-            const chunkContents = await readFileContents(repoPath, chunkPaths);
-            const chunkFiles = chunkPaths
-                .filter(p => chunkContents.has(p))
-                .map(p => ({ path: p, content: chunkContents.get(p) }));
+        // Sequential fallback chunks: use the same normalized-or-raw source for call/heritage resolution
+        for (const chunkFiles of sequentialChunkFiles) {
             astCache = createASTCache(chunkFiles.length);
-            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx);
-            await processHeritage(graph, chunkFiles, astCache, ctx);
+            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, (count) => {
+                if (csharpPreprocDiagnostics)
+                    csharpPreprocDiagnostics.fallbackFiles += count;
+            });
+            await processHeritage(graph, chunkFiles, astCache, ctx, undefined, (count) => {
+                if (csharpPreprocDiagnostics)
+                    csharpPreprocDiagnostics.fallbackFiles += count;
+            });
             if (rubyHeritage.length > 0) {
                 await processHeritageFromExtracted(graph, rubyHeritage, ctx);
             }
@@ -293,6 +341,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         let communityResult;
         let processResult;
         let unityResult;
+        let unityRuleBindingResult;
         if (!options?.skipGraphPhases) {
             // ── Phase 4.5: Method Resolution Order ──────────────────────────────
             onProgress({
@@ -358,7 +407,9 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             // ── Phase 5.6: Unity lifecycle synthetic calls (auto-detect) ────────
             const isUnityProject = allPaths.some(p => p.startsWith('Assets/') && p.endsWith('.cs'));
             const unityConfig = resolveUnityConfig();
-            const persistLifecycleProcessMetadata = unityConfig.config.persistLifecycleProcessMetadata ?? false;
+            // Persistence is coupled to the Unity resource-binding indexing flow:
+            // if Unity project auto-detection is active, persist lifecycle metadata.
+            const persistLifecycleProcessMetadata = isUnityProject;
             const unityLifecycleSyntheticResult = isUnityProject
                 ? applyUnityLifecycleSyntheticCalls(graph, {
                     maxSyntheticEdgesPerClass: unityConfig.config.maxSyntheticEdgesPerClass,
@@ -374,16 +425,41 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             // Phase 5.7: rule-driven binding injection (Phase 3)
             try {
                 const analyzeRules = await loadAnalyzeRules(repoPath);
-                if (analyzeRules.length > 0) {
-                    const bindingResult = applyUnityRuntimeBindingRules(graph, analyzeRules, unityConfig.config);
-                    if (isDev && bindingResult.edgesInjected > 0) {
-                        console.log(`[UnityRuleBinding] injected ${bindingResult.edgesInjected} edges from ${analyzeRules.length} rule(s)`);
-                    }
+                const bindingResult = applyUnityRuntimeBindingRules(graph, analyzeRules, unityConfig.config);
+                unityRuleBindingResult = bindingResult;
+                if (isDev && bindingResult.edgesInjected > 0) {
+                    console.log(`[UnityRuleBinding] injected ${bindingResult.edgesInjected} edges from ${analyzeRules.length} rule(s)`);
                 }
             }
             catch (err) {
                 // rule catalog missing or invalid — skip silently
                 console.warn(`[UnityRuleBinding] failed to load or apply analyze rules: ${err instanceof Error ? err.message : String(err)}`);
+                const reason = err instanceof Error ? err.message : String(err);
+                unityRuleBindingResult = {
+                    edgesInjected: 0,
+                    ruleResults: [],
+                    diagnostics: {
+                        rulesEvaluated: 0,
+                        bindingsEvaluated: 0,
+                        bindingsByKind: {},
+                        methodLookupCalls: 0,
+                        methodLookupCacheHits: 0,
+                        sceneRuntimeTraversalCalls: 0,
+                        sceneRuntimeTraversalCacheHits: 0,
+                        sceneRuntimeResourcesVisited: 0,
+                        anomalies: [`failed to load/apply analyze rules: ${reason}`],
+                        shouldAgentReport: true,
+                        agentReportReason: 'failed to load/apply analyze rules',
+                        summary: [
+                            'rule_binding.summary: rules=0, bindings=0, edges=0',
+                            'rule_binding.bindings_by_kind: none',
+                            'rule_binding.lookup: method_calls=0, cache_hits=0',
+                            'rule_binding.scene_closure: traversals=0, cache_hits=0, visited_resources=0',
+                            'rule_binding.agent_report: should_report=true reason="failed to load/apply analyze rules"',
+                            `rule_binding.anomaly: failed to load/apply analyze rules: ${reason}`,
+                        ],
+                    },
+                };
             }
             // ── Phase 6: Processes ─────────────────────────────────────────────
             onProgress({
@@ -459,6 +535,9 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             },
         });
         astCache.clear();
+        if (csharpPreprocDiagnostics) {
+            csharpPreprocDiagnostics.undefinedSymbols = [...csharpUndefinedSymbols].sort();
+        }
         return {
             graph,
             repoPath,
@@ -466,7 +545,9 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             communityResult,
             processResult,
             unityResult,
+            unityRuleBindingResult,
             scopeDiagnostics: scopeSelection.diagnostics,
+            csharpPreprocDiagnostics,
         };
     }
     catch (error) {

package/dist/core/ingestion/unity-lifecycle-synthetic-calls.test.js

@@ -245,7 +245,7 @@ test('detects Unity hosts through transitive inheritance chains', () => {
     assert.equal(gunGraphHost.baseType, 'ScriptableObject');
     assert.ok(gunGraphHost.methods.length > 0);
 });
-test('prioritizes gameplay lifecycle hosts when synthetic edge budget is tight', () => {
+test('respects global lifecycle edge budget without emitting loader bridges', () => {
     const graph = createKnowledgeGraph();
     for (let i = 0; i < 6; i += 1) {
         addClass(graph, {
@@ -275,12 +275,13 @@ test('prioritizes gameplay lifecycle hosts when synthetic edge budget is tight',
         maxSyntheticEdgesPerClass: 4,
         maxSyntheticEdgesTotal: 8,
     });
-    const runtimeEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' &&
-        (edge.reason === 'unity-lifecycle-synthetic' || edge.reason === 'unity-runtime-loader-synthetic'));
-    const targets = new Set(runtimeEdges.map((edge) => edge.targetId));
+    const lifecycleEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-lifecycle-synthetic');
+    const loaderEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
     assert.equal(result.syntheticEdgeCount, 8);
-    assert.equal([...targets].some((id) => id.includes('Assets/NEON/Code/Game/Core/GunGraphMB.cs')), true);
-    assert.equal([...targets].some((id) => id.includes('Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadConfig.cs')), true);
+    assert.equal(result.lifecycleEdgeCount, 8);
+    assert.equal(result.loaderEdgeCount, 0);
+    assert.equal(lifecycleEdges.length, 8);
+    assert.equal(loaderEdges.length, 0);
 });
 test('resolves named class inheritance targets when direct target node lookup is ambiguous', () => {
     const graph = createKnowledgeGraph();
@@ -336,7 +337,7 @@ test('resolves named class inheritance targets when direct target node lookup is
     assert.ok(gunGraphHost);
     assert.equal(gunGraphHost.baseType, 'ScriptableObject');
 });
-test('emits deterministic runtime loader bridge chain after pre-bridge budget is exhausted', () => {
+test('lifecycle phase does not emit runtime-loader bridge edges', () => {
     const graph = createKnowledgeGraph();
     addClass(graph, {
         className: 'GunGraphMB',
@@ -429,16 +430,15 @@ test('emits deterministic runtime loader bridge chain after pre-bridge budget is
         maxSyntheticEdgesPerClass: 12,
         maxSyntheticEdgesTotal: 10,
     });
-    const syntheticEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
-    const syntheticPairs = new Set(syntheticEdges.map((edge) => `${edge.sourceId}->${edge.targetId}`));
-    assert.equal(result.syntheticEdgeCount, 10);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Core/GunGraphMB.cs:GunGraphMB.RegisterGraphEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.RegisterEvents')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.RegisterEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.StartRoutineWithEvents')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.StartRoutineWithEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.GetValue')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.GetValue')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.CheckReload')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.CheckReload')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/Reload.cs:Reload.ReloadRoutine')}`), true);
+    const syntheticLoaderEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
+    const lifecycleEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-lifecycle-synthetic');
+    assert.equal(result.syntheticEdgeCount, 3);
+    assert.equal(result.lifecycleEdgeCount, 3);
+    assert.equal(result.loaderEdgeCount, 0);
+    assert.equal(lifecycleEdges.length, 3);
+    assert.equal(syntheticLoaderEdges.length, 0);
 });
-test('preserves bridge budget when accepted host count exceeds synthetic edge cap', () => {
+test('lifecycle edge cap does not rely on runtime-loader bridge injection', () => {
     const graph = createKnowledgeGraph();
     for (let i = 0; i < 20; i += 1) {
         addClass(graph, {
@@ -534,8 +534,6 @@ test('preserves bridge budget when accepted host count exceeds synthetic edge ca
         maxSyntheticEdgesPerClass: 12,
         maxSyntheticEdgesTotal: 12,
     });
-    const syntheticPairs = new Set([...graph.iterRelationships()]
-        .filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic')
-        .map((edge) => `${edge.sourceId}->${edge.targetId}`));
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Core/GunGraphMB.cs:GunGraphMB.RegisterGraphEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.RegisterEvents')}`), true);
+    const loaderEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
+    assert.equal(loaderEdges.length, 0);
 });

package/dist/core/ingestion/unity-parity-seed.d.ts

@@ -1,9 +1,10 @@
-import type { UnityScanContext } from '../unity/scan-context.js';
+import type { UnityPrefabSourceRef, UnityScanContext } from '../unity/scan-context.js';
 export interface UnityParitySeed {
     version: 1;
     symbolToScriptPath: Record<string, string>;
     scriptPathToGuid: Record<string, string>;
     guidToResourcePaths: Record<string, string[]>;
     assetGuidToPath?: Record<string, string>;
+    prefabSourceRefs?: UnityPrefabSourceRef[];
 }
 export declare function buildUnityParitySeed(scanContext: UnityScanContext): UnityParitySeed;

package/dist/core/ingestion/unity-parity-seed.js

@@ -59,6 +59,14 @@ export function buildUnityParitySeed(scanContext) {
         scriptPathToGuid: sortRecord(scriptPathToGuid),
         guidToResourcePaths: sortRecord(guidToResourcePaths),
         assetGuidToPath: Object.keys(assetGuidToPath).length > 0 ? sortRecord(assetGuidToPath) : undefined,
+        prefabSourceRefs: scanContext.prefabSourceRefs?.map((row) => ({
+            sourceResourcePath: normalizePath(row.sourceResourcePath),
+            targetGuid: String(row.targetGuid || '').trim().toLowerCase(),
+            targetResourcePath: normalizePath(row.targetResourcePath || '') || undefined,
+            fileId: String(row.fileId || '').trim() || undefined,
+            fieldName: 'm_SourcePrefab',
+            sourceLayer: row.sourceLayer === 'scene' ? 'scene' : 'prefab',
+        })),
     };
 }
 function normalizePath(input) {

package/dist/core/ingestion/unity-resource-processor.d.ts

@@ -7,6 +7,7 @@ export interface UnityResourceProcessingResult {
     bindingCount: number;
     componentCount: number;
     diagnostics: string[];
+    prefabSourceStats: PrefabSourcePassStats;
     paritySeed?: UnityParitySeed;
     timingsMs: {
         scanContext: number;
@@ -25,4 +26,14 @@ export interface UnityResourceProcessingDeps {
     buildScanContext?: typeof buildUnityScanContext;
     resolveBindings?: typeof resolveUnityBindings;
 }
+interface PrefabSourcePassStats {
+    rowsParsed: number;
+    rowsFilteredZeroGuid: number;
+    rowsFilteredPlaceholder: number;
+    rowsFilteredUnresolved: number;
+    rowsDeduped: number;
+    rowsEmitted: number;
+    fileErrors: number;
+}
 export declare function processUnityResources(graph: KnowledgeGraph, options: UnityResourceProcessingOptions, deps?: UnityResourceProcessingDeps): Promise<UnityResourceProcessingResult>;
+export {};

package/dist/core/ingestion/unity-resource-processor.js

@@ -5,6 +5,7 @@ import { resolveUnityBindings } from '../unity/resolver.js';
 import { buildUnityParitySeed } from './unity-parity-seed.js';
 import { resolveUnityConfig } from '../config/unity-config.js';
 const UNITY_DIAGNOSTIC_SAMPLE_LIMIT = 3;
+const PREFAB_SOURCE_PASS_DISABLE_ENV = 'GITNEXUS_DISABLE_PREFAB_SOURCE_PASS';
 export async function processUnityResources(graph, options, deps) {
     const tStart = performance.now();
     const buildScanContextFn = deps?.buildScanContext || buildUnityScanContext;
@@ -36,6 +37,7 @@ export async function processUnityResources(graph, options, deps) {
     let scanContextMs = 0;
     let resolveMs = 0;
     let graphWriteMs = 0;
+    let prefabSourceStats = initPrefabSourcePassStats();
     try {
         const tScanContextStart = performance.now();
         scanContext = await buildScanContextFn({
@@ -51,6 +53,22 @@ export async function processUnityResources(graph, options, deps) {
             }
         }
         diagnostics.push(`scanContext: scripts=${scanContext.symbolToScriptPath.size}, guids=${scanContext.scriptPathToGuid.size}, resources=${uniqueResourcePaths.size}`);
+        if (isPrefabSourcePassDisabledByEnv()) {
+            diagnostics.push(`prefab-source: skipped (env ${PREFAB_SOURCE_PASS_DISABLE_ENV}=1)`);
+        }
+        else {
+            const tPrefabSourceStart = performance.now();
+            prefabSourceStats = await emitPrefabSourceGuidRefsFromScanContext(graph, scanContext);
+            graphWriteMs += performance.now() - tPrefabSourceStart;
+            diagnostics.push(`prefab-source: emitted=${prefabSourceStats.rowsEmitted}`);
+            diagnostics.push(`prefab_source.rows_parsed=${prefabSourceStats.rowsParsed}`);
+            diagnostics.push(`prefab_source.rows_filtered_zero_guid=${prefabSourceStats.rowsFilteredZeroGuid}`);
+            diagnostics.push(`prefab_source.rows_filtered_placeholder=${prefabSourceStats.rowsFilteredPlaceholder}`);
+            diagnostics.push(`prefab_source.rows_filtered_unresolved=${prefabSourceStats.rowsFilteredUnresolved}`);
+            diagnostics.push(`prefab_source.rows_deduped=${prefabSourceStats.rowsDeduped}`);
+            diagnostics.push(`prefab_source.rows_emitted=${prefabSourceStats.rowsEmitted}`);
+            diagnostics.push(`prefab_source.file_errors=${prefabSourceStats.fileErrors}`);
+        }
         symbolsWithResourceHits = collectSymbolsWithResourceHits(scanContext);
     }
     catch (error) {
@@ -228,6 +246,7 @@ export async function processUnityResources(graph, options, deps) {
         bindingCount,
         componentCount,
         diagnostics,
+        prefabSourceStats,
         paritySeed: scanContext ? buildUnityParitySeed(scanContext) : undefined,
         timingsMs: {
             scanContext: roundMs(scanContextMs),
@@ -460,3 +479,86 @@ function classifyUnityDiagnostic(message) {
     }
     return 'other';
 }
+async function emitPrefabSourceGuidRefsFromScanContext(graph, scanContext) {
+    const stats = initPrefabSourcePassStats();
+    const dedupeBySource = new Map();
+    const iterable = typeof scanContext.streamPrefabSourceRefs === 'function'
+        ? scanContext.streamPrefabSourceRefs({
+            hooks: {
+                onFileError: () => {
+                    stats.fileErrors += 1;
+                },
+            },
+        })
+        : (async function* () {
+            for (const row of scanContext.prefabSourceRefs || []) {
+                yield row;
+            }
+        })();
+    for await (const row of iterable) {
+        stats.rowsParsed += 1;
+        const source = normalizePath(String(row.sourceResourcePath || '').trim());
+        const guid = String(row.targetGuid || '').trim().toLowerCase();
+        if (!guid || guid === '00000000000000000000000000000000') {
+            stats.rowsFilteredZeroGuid += 1;
+            continue;
+        }
+        const hintedTarget = normalizePath(String(row.targetResourcePath || '').trim());
+        if (hintedTarget === '__PLACEHOLDER__') {
+            stats.rowsFilteredPlaceholder += 1;
+            continue;
+        }
+        const resolvedTarget = hintedTarget
+            || normalizePath(scanContext.assetGuidToPath?.get(guid) || scanContext.assetGuidToPath?.get(guid.toLowerCase()) || '');
+        if (!resolvedTarget || !resolvedTarget.endsWith('.prefab')) {
+            stats.rowsFilteredUnresolved += 1;
+            continue;
+        }
+        if (!source) {
+            stats.rowsFilteredUnresolved += 1;
+            continue;
+        }
+        const perSourceDedupe = dedupeBySource.get(source) || new Set();
+        const dedupeKey = `${resolvedTarget}|m_SourcePrefab|${guid}|${String(row.fileId || '').trim()}|${row.sourceLayer === 'scene' ? 'scene' : 'prefab'}`;
+        if (perSourceDedupe.has(dedupeKey)) {
+            stats.rowsDeduped += 1;
+            continue;
+        }
+        perSourceDedupe.add(dedupeKey);
+        dedupeBySource.set(source, perSourceDedupe);
+        const sourceFileId = ensureResourceFileNode(graph, source);
+        const targetFileId = ensureResourceFileNode(graph, resolvedTarget);
+        graph.addRelationship({
+            id: generateId('UNITY_ASSET_GUID_REF', `${sourceFileId}->${targetFileId}:m_SourcePrefab:${guid}:${String(row.fileId || '')}`),
+            type: 'UNITY_ASSET_GUID_REF',
+            sourceId: sourceFileId,
+            targetId: targetFileId,
+            confidence: 1.0,
+            reason: JSON.stringify({
+                resourcePath: source,
+                targetResourcePath: resolvedTarget,
+                guid,
+                fileId: String(row.fileId || ''),
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: row.sourceLayer === 'scene' ? 'scene' : 'prefab',
+            }),
+        });
+        stats.rowsEmitted += 1;
+    }
+    return stats;
+}
+function initPrefabSourcePassStats() {
+    return {
+        rowsParsed: 0,
+        rowsFilteredZeroGuid: 0,
+        rowsFilteredPlaceholder: 0,
+        rowsFilteredUnresolved: 0,
+        rowsDeduped: 0,
+        rowsEmitted: 0,
+        fileErrors: 0,
+    };
+}
+function isPrefabSourcePassDisabledByEnv() {
+    const value = String(process.env[PREFAB_SOURCE_PASS_DISABLE_ENV] || '').trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}