@veewo/gitnexus 1.3.9 → 1.3.11-rc.1

package/dist/core/unity/options.test.js

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { parseUnityResourcesMode } from './options.js';
+import { parseUnityHydrationMode, parseUnityResourcesMode } from './options.js';
 test('parseUnityResourcesMode defaults to off', () => {
     assert.equal(parseUnityResourcesMode(undefined), 'off');
 });
@@ -8,3 +8,10 @@ test('parseUnityResourcesMode validates mode', () => {
     assert.equal(parseUnityResourcesMode('on'), 'on');
     assert.throws(() => parseUnityResourcesMode('bad'), /unity resources mode/i);
 });
+test('parseUnityHydrationMode defaults to compact', () => {
+    assert.equal(parseUnityHydrationMode(undefined), 'compact');
+});
+test('parseUnityHydrationMode validates mode', () => {
+    assert.equal(parseUnityHydrationMode('compact'), 'compact');
+    assert.throws(() => parseUnityHydrationMode('bad'), /unity hydration mode/i);
+});

package/dist/core/unity/resolver.d.ts

@@ -5,6 +5,8 @@ export interface ResolveInput {
     repoRoot: string;
     symbol: string;
     scanContext?: UnityScanContext;
+    resourcePathAllowlist?: string[];
+    deepParseLargeResources?: boolean;
 }
 export interface UnityScalarField {
     name: string;
@@ -58,6 +60,7 @@ export interface ResolvedUnityBinding {
     resourceType: 'prefab' | 'scene' | 'asset';
     bindingKind: UnityBindingKind;
     componentObjectId: string;
+    lightweight?: boolean;
     evidence: UnityBindingEvidence;
     serializedFields: UnitySerializedFields;
     resolvedReferences: UnityResolvedReference[];

package/dist/core/unity/resolver.js

@@ -5,15 +5,24 @@ import { buildMetaIndex } from './meta-index.js';
 import { mergeOverrideChain } from './override-merger.js';
 import { findGuidHits } from './resource-hit-scanner.js';
 import { parseUnityYamlObjects } from './yaml-object-graph.js';
+const MAX_CACHED_RESOURCE_BYTES = 512 * 1024;
 export async function resolveUnityBindings(input) {
     const scriptPath = await resolveSymbolScriptPath(input.repoRoot, input.symbol, input.scanContext);
     const scriptGuid = await resolveScriptGuid(input.repoRoot, scriptPath, input.scanContext);
-    const hits = input.scanContext
+    const rawHits = input.scanContext
         ? (input.scanContext.guidToResourceHits.get(scriptGuid) ?? [])
         : await findGuidHits(input.repoRoot, scriptGuid);
+    const hits = applyResourceAllowlist(rawHits, input.resourcePathAllowlist);
     const resourceBindings = [];
     const unityDiagnostics = [];
+    const resourceSizeCache = new Map();
     for (const hit of hits) {
+        const shouldUseLightweightBinding = !input.deepParseLargeResources
+            && await isLargeResourceForDeepParse(input.repoRoot, hit.resourcePath, resourceSizeCache);
+        if (shouldUseLightweightBinding) {
+            resourceBindings.push(createLightweightBinding(hit));
+            continue;
+        }
         const blocks = await getResourceBlocks(input.repoRoot, hit.resourcePath, input.scanContext);
         const matchedComponents = blocks.filter((block) => block.objectType === 'MonoBehaviour' && block.fields.m_Script?.includes(scriptGuid));
         if (matchedComponents.length === 0) {
@@ -46,6 +55,44 @@ export async function resolveUnityBindings(input) {
         unityDiagnostics,
     };
 }
+function applyResourceAllowlist(hits, allowlist) {
+    if (!allowlist || allowlist.length === 0) {
+        return hits;
+    }
+    const normalizedAllowlist = new Set(allowlist.map((value) => normalizePath(value)));
+    return hits.filter((hit) => normalizedAllowlist.has(normalizePath(hit.resourcePath)));
+}
+function createLightweightBinding(hit) {
+    return {
+        resourcePath: hit.resourcePath,
+        resourceType: hit.resourceType,
+        bindingKind: hit.resourceType === 'scene' ? 'scene-override' : 'direct',
+        componentObjectId: `line-${hit.line}`,
+        lightweight: true,
+        evidence: {
+            line: hit.line,
+            lineText: hit.lineText,
+        },
+        serializedFields: {
+            scalarFields: [],
+            referenceFields: [],
+        },
+        resolvedReferences: [],
+        assetRefPaths: [],
+    };
+}
+async function isLargeResourceForDeepParse(repoRoot, resourcePath, cache) {
+    const normalizedPath = normalizePath(resourcePath);
+    const cached = cache.get(normalizedPath);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const absolutePath = path.join(repoRoot, normalizedPath);
+    const stat = await fs.stat(absolutePath);
+    const isLarge = stat.size > MAX_CACHED_RESOURCE_BYTES;
+    cache.set(normalizedPath, isLarge);
+    return isLarge;
+}
 export function hasCoverage(resultSet) {
     return {
         hasScalar: resultSet.some((result) => result.serializedFields.scalarFields.length > 0),
@@ -102,9 +149,16 @@ async function getResourceBlocks(repoRoot, resourcePath, scanContext) {
         return cached;
     }
     const absoluteResourcePath = path.join(repoRoot, normalizedResourcePath);
+    let allowCache = Boolean(scanContext);
+    if (allowCache) {
+        const stat = await fs.stat(absoluteResourcePath);
+        allowCache = stat.size <= MAX_CACHED_RESOURCE_BYTES;
+    }
     const raw = await fs.readFile(absoluteResourcePath, 'utf-8');
     const blocks = parseUnityYamlObjects(raw);
-    scanContext?.resourceDocCache.set(normalizedResourcePath, blocks);
+    if (allowCache) {
+        scanContext?.resourceDocCache.set(normalizedResourcePath, blocks);
+    }
     return blocks;
 }
 function resolveBindingForComponent(componentBlock, blocks, hit, scanContext) {

package/dist/core/unity/resolver.test.js

@@ -188,6 +188,52 @@ test('resolveUnityBindings keeps existing scene serializedFields stable when .as
     assert.equal(mainUIDocument?.sourceLayer, 'scene');
     assert.equal(mainUIDocument?.guid, '44444444444444444444444444444444');
 });
+test('resolveUnityBindings supports resourcePathAllowlist filtering', async () => {
+    const result = await resolveUnityBindings({
+        repoRoot: fixtureRoot,
+        symbol: 'MainUIManager',
+        resourcePathAllowlist: ['Assets/Scene/NonExisting.unity'],
+    });
+    assert.equal(result.resourceBindings.length, 0);
+});
+test('resolveUnityBindings deepParseLargeResources can override lightweight fallback', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(path.dirname(fixtureRoot), 'tmp-large-unity-'));
+    const scriptsDir = path.join(tempRoot, 'Assets/Scripts');
+    const sceneDir = path.join(tempRoot, 'Assets/Scene');
+    await fs.mkdir(scriptsDir, { recursive: true });
+    await fs.mkdir(sceneDir, { recursive: true });
+    try {
+        const scriptPath = 'Assets/Scripts/LargeSymbol.cs';
+        const scenePath = 'Assets/Scene/LargeScene.unity';
+        const scriptGuid = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+        const padding = '#'.repeat(600 * 1024);
+        await fs.writeFile(path.join(tempRoot, scriptPath), 'public class LargeSymbol {}', 'utf-8');
+        await fs.writeFile(path.join(tempRoot, `${scriptPath}.meta`), `guid: ${scriptGuid}\n`, 'utf-8');
+        await fs.writeFile(path.join(tempRoot, scenePath), `--- !u!114 &11400000\nMonoBehaviour:\n  m_Script: {fileID: 11500000, guid: ${scriptGuid}, type: 3}\n  needPause: 1\n${padding}\n`, 'utf-8');
+        const scanContext = await buildUnityScanContext({
+            repoRoot: tempRoot,
+            scopedPaths: [scriptPath, `${scriptPath}.meta`, scenePath],
+            symbolDeclarations: [{ symbol: 'LargeSymbol', scriptPath }],
+        });
+        const lightweight = await resolveUnityBindings({
+            repoRoot: tempRoot,
+            symbol: 'LargeSymbol',
+            scanContext,
+        });
+        assert.equal(lightweight.resourceBindings[0]?.lightweight, true);
+        const expanded = await resolveUnityBindings({
+            repoRoot: tempRoot,
+            symbol: 'LargeSymbol',
+            scanContext,
+            deepParseLargeResources: true,
+        });
+        assert.equal(expanded.resourceBindings[0]?.lightweight, undefined);
+        assert.equal(expanded.resourceBindings[0]?.componentObjectId, '11400000');
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+});
 test('extractAssetRefPathReferences parses nested _relativePath rows and marks sprite assets', () => {
     const refs = extractAssetRefPathReferences({
         scalarFields: [

package/dist/core/unity/scan-context.d.ts

@@ -1,5 +1,6 @@
 import type { UnityResourceGuidHit } from './resource-hit-scanner.js';
 import type { UnityObjectBlock } from './yaml-object-graph.js';
+import type { UnityParitySeed } from '../ingestion/unity-parity-seed.js';
 export interface BuildScanContextInput {
     repoRoot: string;
     scopedPaths?: string[];
@@ -21,3 +22,7 @@ export interface UnityScanContext {
     resourceDocCache: Map<string, UnityObjectBlock[]>;
 }
 export declare function buildUnityScanContext(input: BuildScanContextInput): Promise<UnityScanContext>;
+export declare function buildUnityScanContextFromSeed(input: {
+    seed: UnityParitySeed;
+    symbolDeclarations?: UnitySymbolDeclaration[];
+}): UnityScanContext;

package/dist/core/unity/scan-context.js

@@ -1,11 +1,13 @@
 import fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
 import path from 'node:path';
+import { createInterface } from 'node:readline';
 import { glob } from 'glob';
 import { buildAssetMetaIndex, buildMetaIndex } from './meta-index.js';
-import { buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
+import { buildSerializableTypeIndexFromFiles } from './serialized-type-index.js';
 const DECLARATION_PATTERN = /\b(?:class|struct|interface)\s+([A-Za-z_][A-Za-z0-9_]*)\b/g;
-const GUID_IN_LINE_PATTERN = /\bguid:\s*([0-9a-f]{32})\b/gi;
-const RESOURCE_HIT_SCAN_CONCURRENCY = 16;
+const SCRIPT_GUID_IN_LINE_PATTERN = /\bm_Script\s*:\s*\{[^}]*\bguid\s*:\s*([0-9a-f]{32})\b/gi;
+const RESOURCE_HIT_SCAN_CONCURRENCY = 4;
 export async function buildUnityScanContext(input) {
     const scriptFiles = input.symbolDeclarations && input.symbolDeclarations.length > 0
         ? resolveScriptFilesFromSymbolDeclarations(input.repoRoot, input.symbolDeclarations, input.scopedPaths)
@@ -13,8 +15,13 @@ export async function buildUnityScanContext(input) {
     const symbolToScriptPaths = input.symbolDeclarations && input.symbolDeclarations.length > 0
         ? buildSymbolScriptPathIndexFromDeclarations(input.repoRoot, input.symbolDeclarations, input.scopedPaths)
         : await buildSymbolScriptPathIndex(input.repoRoot, scriptFiles);
-    const scriptSources = await loadScriptSources(input.repoRoot, scriptFiles);
-    const serializableTypeIndex = buildSerializableTypeIndexFromSources(scriptSources);
+    const serializableTypeIndex = await buildSerializableTypeIndexFromFiles(scriptFiles.map((scriptPath) => {
+        const normalizedPath = normalizeSlashes(scriptPath);
+        return {
+            filePath: normalizedPath,
+            read: async () => fs.readFile(path.join(input.repoRoot, normalizedPath), 'utf-8'),
+        };
+    }));
     const metaFiles = scriptFiles.map((scriptPath) => `${scriptPath}.meta`);
     const guidToScriptPath = await buildMetaIndex(input.repoRoot, { metaFiles });
     const scriptPathToGuid = new Map();
@@ -39,21 +46,91 @@ export async function buildUnityScanContext(input) {
         resourceDocCache: new Map(),
     };
 }
-async function loadScriptSources(repoRoot, scriptFiles) {
-    const sources = [];
-    for (const scriptPath of scriptFiles) {
+export function buildUnityScanContextFromSeed(input) {
+    const seed = input.seed;
+    const requestedSymbols = new Set((input.symbolDeclarations || [])
+        .map((entry) => String(entry.symbol || '').trim())
+        .filter((value) => value.length > 0));
+    const requestedScripts = new Set((input.symbolDeclarations || [])
+        .map((entry) => normalizeSlashes(String(entry.scriptPath || '').trim()))
+        .filter((value) => value.length > 0));
+    const symbolToScriptPath = new Map();
+    for (const [symbol, scriptPath] of Object.entries(seed.symbolToScriptPath || {})) {
         const normalizedPath = normalizeSlashes(scriptPath);
-        try {
-            const content = await fs.readFile(path.join(repoRoot, normalizedPath), 'utf-8');
-            sources.push({ filePath: normalizedPath, content });
+        if (!normalizedPath)
+            continue;
+        if (requestedSymbols.size > 0 && !requestedSymbols.has(symbol))
+            continue;
+        symbolToScriptPath.set(symbol, normalizedPath);
+        requestedScripts.add(normalizedPath);
+    }
+    if (symbolToScriptPath.size === 0 && requestedSymbols.size > 0) {
+        for (const declaration of input.symbolDeclarations || []) {
+            const symbol = String(declaration.symbol || '').trim();
+            const scriptPath = normalizeSlashes(String(declaration.scriptPath || '').trim());
+            if (!symbol || !scriptPath)
+                continue;
+            symbolToScriptPath.set(symbol, scriptPath);
+            requestedScripts.add(scriptPath);
         }
-        catch (error) {
-            if (error.code === 'ENOENT')
+    }
+    const symbolToCanonicalScriptPath = new Map(symbolToScriptPath);
+    const symbolToScriptPaths = new Map();
+    for (const [symbol, scriptPath] of symbolToScriptPath.entries()) {
+        symbolToScriptPaths.set(symbol, [scriptPath]);
+    }
+    const scriptPathToGuid = new Map();
+    const normalizedScriptPathToGuidEntries = Object.entries(seed.scriptPathToGuid || {})
+        .map(([scriptPath, guid]) => [normalizeSlashes(scriptPath), String(guid || '').trim()])
+        .filter(([scriptPath, guid]) => scriptPath.length > 0 && guid.length > 0);
+    for (const [scriptPath, guid] of normalizedScriptPathToGuidEntries) {
+        if (requestedScripts.size > 0 && !requestedScripts.has(scriptPath))
+            continue;
+        scriptPathToGuid.set(scriptPath, guid);
+    }
+    if (scriptPathToGuid.size === 0 && requestedScripts.size > 0) {
+        for (const [scriptPath, guid] of normalizedScriptPathToGuidEntries) {
+            if (!requestedScripts.has(scriptPath))
                 continue;
-            throw error;
+            scriptPathToGuid.set(scriptPath, guid);
+        }
+    }
+    const selectedGuids = new Set(scriptPathToGuid.values());
+    const guidToResourceHits = new Map();
+    for (const [guid, resourcePaths] of Object.entries(seed.guidToResourcePaths || {})) {
+        if (selectedGuids.size > 0 && !selectedGuids.has(guid))
+            continue;
+        const hits = (resourcePaths || [])
+            .map((resourcePathRaw) => normalizeSlashes(String(resourcePathRaw || '').trim()))
+            .filter((resourcePath) => resourcePath.length > 0)
+            .map((resourcePath) => ({
+            resourcePath,
+            resourceType: inferResourceType(resourcePath),
+            line: 0,
+            lineText: 'seed',
+        }));
+        if (hits.length > 0) {
+            guidToResourceHits.set(guid, hits);
         }
     }
-    return sources;
+    const assetGuidToPath = new Map();
+    for (const [guid, assetPath] of Object.entries(seed.assetGuidToPath || {})) {
+        const normalizedPath = normalizeSlashes(String(assetPath || '').trim());
+        if (!guid || !normalizedPath)
+            continue;
+        assetGuidToPath.set(guid, normalizedPath);
+    }
+    return {
+        symbolToScriptPaths,
+        symbolToCanonicalScriptPath,
+        symbolToScriptPath,
+        scriptPathToGuid,
+        guidToResourceHits,
+        serializableSymbols: new Set(),
+        hostFieldTypeHints: new Map(),
+        assetGuidToPath,
+        resourceDocCache: new Map(),
+    };
 }
 async function buildSymbolScriptPathIndex(repoRoot, scriptFiles) {
     const candidates = new Map();
@@ -93,53 +170,65 @@ async function buildGuidHitIndex(repoRoot, scriptPathToGuid, resourceFiles) {
     }
     const perResourceHits = await mapWithConcurrency(resourceFiles, RESOURCE_HIT_SCAN_CONCURRENCY, async (resourcePathRaw) => {
         const resourcePath = normalizeSlashes(resourcePathRaw);
-        const absolutePath = path.join(repoRoot, resourcePath);
-        let content = '';
-        try {
-            content = await fs.readFile(absolutePath, 'utf-8');
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ENOENT' || code === 'EISDIR') {
-                return new Map();
-            }
-            throw error;
-        }
         const resourceType = inferResourceType(resourcePath);
-        const lines = content.split(/\r?\n/);
         const hits = new Map();
-        for (let index = 0; index < lines.length; index += 1) {
-            const line = lines[index];
+        await scanGuidHitsInResourceFile(repoRoot, resourcePath, resourceType, guidLookup, hits);
+        return hits;
+    });
+    const guidToResourceHits = new Map();
+    for (const hitMap of perResourceHits) {
+        for (const [guid, hits] of hitMap.entries()) {
+            const existing = guidToResourceHits.get(guid) || [];
+            existing.push(...hits);
+            guidToResourceHits.set(guid, existing);
+        }
+    }
+    return guidToResourceHits;
+}
+async function scanGuidHitsInResourceFile(repoRoot, resourcePath, resourceType, guidLookup, hits) {
+    const absolutePath = path.join(repoRoot, resourcePath);
+    const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+    const reader = createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    const seenGuidInResource = new Set();
+    let lineNumber = 0;
+    try {
+        for await (const line of reader) {
+            lineNumber += 1;
             const seenCanonical = new Set();
-            GUID_IN_LINE_PATTERN.lastIndex = 0;
-            let match = GUID_IN_LINE_PATTERN.exec(line);
+            SCRIPT_GUID_IN_LINE_PATTERN.lastIndex = 0;
+            let match = SCRIPT_GUID_IN_LINE_PATTERN.exec(line);
             while (match) {
                 const canonicalGuid = guidLookup.get(match[1].toLowerCase());
-                if (canonicalGuid && !seenCanonical.has(canonicalGuid)) {
+                if (canonicalGuid && !seenCanonical.has(canonicalGuid) && !seenGuidInResource.has(canonicalGuid)) {
                     seenCanonical.add(canonicalGuid);
+                    seenGuidInResource.add(canonicalGuid);
                     const existing = hits.get(canonicalGuid) || [];
                     existing.push({
                         resourcePath,
                         resourceType,
-                        line: index + 1,
+                        line: lineNumber,
                         lineText: line,
                     });
                     hits.set(canonicalGuid, existing);
                 }
-                match = GUID_IN_LINE_PATTERN.exec(line);
+                match = SCRIPT_GUID_IN_LINE_PATTERN.exec(line);
             }
         }
-        return hits;
-    });
-    const guidToResourceHits = new Map();
-    for (const hitMap of perResourceHits) {
-        for (const [guid, hits] of hitMap.entries()) {
-            const existing = guidToResourceHits.get(guid) || [];
-            existing.push(...hits);
-            guidToResourceHits.set(guid, existing);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR') {
+            return;
         }
+        throw error;
+    }
+    finally {
+        reader.close();
+        stream.destroy();
     }
-    return guidToResourceHits;
 }
 async function resolveScriptFiles(repoRoot, scopedPaths) {
     if (!scopedPaths || scopedPaths.length === 0) {

package/dist/core/unity/scan-context.test.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
-import { buildUnityScanContext } from './scan-context.js';
+import { buildUnityScanContext, buildUnityScanContextFromSeed } from './scan-context.js';
 import { resolveUnityBindings } from './resolver.js';
 const here = path.dirname(fileURLToPath(import.meta.url));
 const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
@@ -74,7 +74,7 @@ test('buildUnityScanContext selects canonical script for duplicated symbol decla
         await fs.writeFile(path.join(scriptsDir, 'PlayerActor.Visual.cs'), 'public partial class PlayerActor {}', 'utf-8');
         await fs.writeFile(path.join(scriptsDir, 'PlayerActor.cs.meta'), 'guid: 11111111111111111111111111111111\n', 'utf-8');
         await fs.writeFile(path.join(scriptsDir, 'PlayerActor.Visual.cs.meta'), 'guid: 22222222222222222222222222222222\n', 'utf-8');
-        await fs.writeFile(path.join(sceneDir, 'Test.unity'), '--- !u!1 &1\nguid: 11111111111111111111111111111111\n', 'utf-8');
+        await fs.writeFile(path.join(sceneDir, 'Test.unity'), '--- !u!114 &1\nMonoBehaviour:\n  m_Script: {fileID: 11500000, guid: 11111111111111111111111111111111, type: 3}\n', 'utf-8');
         const context = await buildUnityScanContext({
             repoRoot: tempRoot,
             symbolDeclarations: [
@@ -116,3 +116,42 @@ test('buildUnityScanContext exposes serializable symbol index and host field typ
         await fs.rm(tempRoot, { recursive: true, force: true });
     }
 });
+test('buildUnityScanContext builds serializable index from files without preloading source array', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-serializable-streaming-'));
+    const scriptsDir = path.join(tempRoot, 'Assets/Scripts');
+    await fs.mkdir(scriptsDir, { recursive: true });
+    try {
+        await fs.writeFile(path.join(scriptsDir, 'AssetRef.cs'), '[Serializable] class AssetRef {}', 'utf-8');
+        await fs.writeFile(path.join(scriptsDir, 'Host.cs'), 'class Host { AssetRef icon; }', 'utf-8');
+        const context = await buildUnityScanContext({ repoRoot: tempRoot });
+        assert.equal(context.serializableSymbols.has('AssetRef'), true);
+        assert.equal(context.hostFieldTypeHints.get('Host')?.get('icon'), 'AssetRef');
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+});
+test('buildUnityScanContextFromSeed reconstructs lookup maps for resolver fast path', async () => {
+    const context = buildUnityScanContextFromSeed({
+        seed: {
+            version: 1,
+            symbolToScriptPath: {
+                MainUIManager: 'Assets/Scripts/MainUIManager.cs',
+            },
+            scriptPathToGuid: {
+                'Assets/Scripts/MainUIManager.cs': '11111111111111111111111111111111',
+            },
+            guidToResourcePaths: {
+                '11111111111111111111111111111111': ['Assets/Scene/MainUIManager.unity'],
+            },
+            assetGuidToPath: {
+                '44444444444444444444444444444444': 'Assets/Config/MainUIDocument.asset',
+            },
+        },
+        symbolDeclarations: [{ symbol: 'MainUIManager', scriptPath: 'Assets/Scripts/MainUIManager.cs' }],
+    });
+    assert.equal(context.symbolToScriptPath.get('MainUIManager'), 'Assets/Scripts/MainUIManager.cs');
+    assert.equal(context.scriptPathToGuid.get('Assets/Scripts/MainUIManager.cs'), '11111111111111111111111111111111');
+    assert.equal(context.guidToResourceHits.get('11111111111111111111111111111111')?.length, 1);
+    assert.equal(context.assetGuidToPath?.get('44444444444444444444444444444444'), 'Assets/Config/MainUIDocument.asset');
+});

package/dist/core/unity/serialized-type-index.d.ts

@@ -6,5 +6,10 @@ interface SourceFile {
     filePath: string;
     content: string;
 }
+interface SourceFileReader {
+    filePath: string;
+    read: () => Promise<string>;
+}
 export declare function buildSerializableTypeIndexFromSources(sources: SourceFile[]): SerializableTypeIndex;
+export declare function buildSerializableTypeIndexFromFiles(files: SourceFileReader[]): Promise<SerializableTypeIndex>;
 export {};

package/dist/core/unity/serialized-type-index.js

@@ -4,25 +4,56 @@ const FIELD_DECLARATION_PATTERN = /(?:\[[^\]]+\]\s*)*(?:(?:public|private|protec
 export function buildSerializableTypeIndexFromSources(sources) {
     const serializableSymbols = new Set();
     for (const source of sources) {
-        SERIALIZABLE_DECLARATION_PATTERN.lastIndex = 0;
-        let match = SERIALIZABLE_DECLARATION_PATTERN.exec(source.content);
-        while (match) {
-            serializableSymbols.add(match[1]);
-            match = SERIALIZABLE_DECLARATION_PATTERN.exec(source.content);
-        }
+        collectSerializableDeclarations(source.content, serializableSymbols);
     }
     const hostFieldTypeHints = new Map();
     for (const source of sources) {
-        const classBodies = extractClassBodies(source.content);
-        for (const classBody of classBodies) {
-            const fieldHints = extractHostFieldHints(classBody.body, serializableSymbols);
-            if (fieldHints.size > 0) {
-                hostFieldTypeHints.set(classBody.name, fieldHints);
-            }
-        }
+        collectHostFieldTypeHints(source.content, serializableSymbols, hostFieldTypeHints);
+    }
+    return { serializableSymbols, hostFieldTypeHints };
+}
+export async function buildSerializableTypeIndexFromFiles(files) {
+    const serializableSymbols = new Set();
+    for (const file of files) {
+        const content = await safeReadFileContent(file);
+        collectSerializableDeclarations(content, serializableSymbols);
+    }
+    const hostFieldTypeHints = new Map();
+    for (const file of files) {
+        const content = await safeReadFileContent(file);
+        collectHostFieldTypeHints(content, serializableSymbols, hostFieldTypeHints);
     }
     return { serializableSymbols, hostFieldTypeHints };
 }
+function collectSerializableDeclarations(content, serializableSymbols) {
+    SERIALIZABLE_DECLARATION_PATTERN.lastIndex = 0;
+    let match = SERIALIZABLE_DECLARATION_PATTERN.exec(content);
+    while (match) {
+        serializableSymbols.add(match[1]);
+        match = SERIALIZABLE_DECLARATION_PATTERN.exec(content);
+    }
+}
+function collectHostFieldTypeHints(content, serializableSymbols, hostFieldTypeHints) {
+    const classBodies = extractClassBodies(content);
+    for (const classBody of classBodies) {
+        const fieldHints = extractHostFieldHints(classBody.body, serializableSymbols);
+        if (fieldHints.size > 0) {
+            hostFieldTypeHints.set(classBody.name, fieldHints);
+        }
+    }
+}
+async function safeReadFileContent(file) {
+    try {
+        return await file.read();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR') {
+            return '';
+        }
+        throw error;
+    }
+}
 function extractClassBodies(content) {
     const result = [];
     CLASS_DECLARATION_PATTERN.lastIndex = 0;

package/dist/core/unity/serialized-type-index.test.js

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
+import { buildSerializableTypeIndexFromFiles, buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
 test('buildSerializableTypeIndex extracts serializable symbols and host field declared types', () => {
     const index = buildSerializableTypeIndexFromSources([
         {
@@ -32,3 +32,11 @@ test('buildSerializableTypeIndex extracts serializable symbols and host field de
     assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('iconVariants'), 'AssetRef');
     assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.has('ignored'), false);
 });
+test('buildSerializableTypeIndexFromFiles does not require preloaded source array', async () => {
+    const out = await buildSerializableTypeIndexFromFiles([
+        { filePath: 'Assets/A.cs', read: async () => '[Serializable] class AssetRef {}' },
+        { filePath: 'Assets/B.cs', read: async () => 'class Host { AssetRef icon; }' },
+    ]);
+    assert.equal(out.serializableSymbols.has('AssetRef'), true);
+    assert.equal(out.hostFieldTypeHints.get('Host')?.get('icon'), 'AssetRef');
+});

package/dist/mcp/local/local-backend.d.ts

@@ -5,7 +5,14 @@
  * Supports multiple indexed repositories via a global registry.
  * KuzuDB connections are opened lazily per repo on first query.
  */
+import { type ResolvedUnityBinding } from '../../core/unity/resolver.js';
+import { type UnityContextPayload, type UnityHydrationMeta } from './unity-enrichment.js';
 import { type RegistryEntry } from '../../storage/repo-manager.js';
+export declare function mergeUnityBindings(baseBindings: ResolvedUnityBinding[], resolvedByPath: Map<string, ResolvedUnityBinding[]>): ResolvedUnityBinding[];
+export declare function mergeParityUnityBindings(baseNonLightweightBindings: ResolvedUnityBinding[], resolvedBindings: ResolvedUnityBinding[]): ResolvedUnityBinding[];
+export declare function attachUnityHydrationMeta(payload: UnityContextPayload, input: Pick<UnityHydrationMeta, 'requestedMode' | 'effectiveMode' | 'elapsedMs' | 'fallbackToCompact'> & {
+    hasExpandableBindings: boolean;
+}): UnityContextPayload;
 export interface CodebaseContext {
     projectName: string;
     stats: {
@@ -119,6 +126,15 @@ export declare class LocalBackend {
      * Routes cluster/process types to direct graph queries.
      */
     private explore;
+    private hydrateUnityContext;
+    private buildParityWarmupKey;
+    private scheduleParityWarmup;
+    private shouldEnableParityWarmup;
+    private getOrRunParityHydration;
+    private computeParityPayload;
+    private hydrateUnityContextParity;
+    private hydrateUnityContextCompact;
+    private toUnityContextPayload;
     /**
      * Detect changes — git-diff based impact analysis.
      * Maps changed lines to indexed symbols, then finds affected processes.