@veewo/gitnexus 1.3.7 → 1.3.9

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

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
+test('buildSerializableTypeIndex extracts serializable symbols and host field declared types', () => {
+    const index = buildSerializableTypeIndexFromSources([
+        {
+            filePath: 'Assets/Scripts/AssetRef.cs',
+            content: `
+        [System.Serializable]
+        public class AssetRef { public string guid; }
+      `,
+        },
+        {
+            filePath: 'Assets/Scripts/InventoryConfig.cs',
+            content: `
+        using UnityEngine;
+        using System.Collections.Generic;
+        public class InventoryConfig : ScriptableObject {
+          public AssetRef icon;
+          public AssetRef<GameObject> iconPrefab;
+          [SerializeField] private List<AssetRef> drops;
+          [SerializeField] private List<AssetRef<Sprite>> iconVariants;
+          [SerializeField] private int ignored;
+        }
+      `,
+        },
+    ]);
+    assert.equal(index.serializableSymbols.has('AssetRef'), true);
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('icon'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('iconPrefab'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('drops'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('iconVariants'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.has('ignored'), false);
+});

package/dist/core/unity/u2-thresholds.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/u2-thresholds.test.js

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveUnityBindings } from './resolver.js';
+import { buildUnityScanContext } from './scan-context.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
+const U2_REFERENCE_RESOLUTION_RATE_THRESHOLD = 0.8;
+const U2_LIST_REFERENCE_PARSE_RATE_THRESHOLD = 1.0;
+function countListCandidatesFromScalarFields(scalarFields) {
+    let total = 0;
+    for (const field of scalarFields) {
+        const lines = field.value.split(/\r?\n/);
+        for (const line of lines) {
+            if (/^\s*-\s*\{[^}]*fileID\s*:/.test(line)) {
+                total += 1;
+            }
+        }
+    }
+    return total;
+}
+function countResolvedSuccesses(references) {
+    return references.filter((ref) => ref.resolution === 'local-object' || ref.resolution === 'external-asset').length;
+}
+function collectU2ReferenceStats(results) {
+    let candidateRefs = 0;
+    let resolvedRefs = 0;
+    let listCandidates = 0;
+    let parsedListRefs = 0;
+    for (const result of results) {
+        for (const binding of result.resourceBindings) {
+            const listCandidatesForBinding = countListCandidatesFromScalarFields(binding.serializedFields.scalarFields);
+            const directCandidatesForBinding = binding.serializedFields.referenceFields.length;
+            candidateRefs += directCandidatesForBinding + listCandidatesForBinding;
+            listCandidates += listCandidatesForBinding;
+            resolvedRefs += countResolvedSuccesses(binding.resolvedReferences);
+            parsedListRefs += binding.resolvedReferences.filter((ref) => ref.fromList).length;
+        }
+    }
+    return { candidateRefs, resolvedRefs, listCandidates, parsedListRefs };
+}
+test('U2 threshold: reference_resolution_rate stays above baseline', async () => {
+    const scanContext = await buildUnityScanContext({
+        repoRoot: fixtureRoot,
+        scopedPaths: [
+            'Assets/Scripts/MainUIManager.cs',
+            'Assets/Scripts/MainUIManager.cs.meta',
+            'Assets/Scene/MainUIManager.unity',
+            'Assets/Config/MainUIDocument.asset.meta',
+            'Assets/Scripts/MenuScreenCarrier.cs',
+            'Assets/Scripts/MenuScreenCarrier.cs.meta',
+            'Assets/Prefabs/MenuScreenCarrier.prefab',
+        ],
+    });
+    const [mainUIManager, menuScreenCarrier] = await Promise.all([
+        resolveUnityBindings({ repoRoot: fixtureRoot, symbol: 'MainUIManager', scanContext }),
+        resolveUnityBindings({ repoRoot: fixtureRoot, symbol: 'MenuScreenCarrier', scanContext }),
+    ]);
+    const stats = collectU2ReferenceStats([mainUIManager, menuScreenCarrier]);
+    assert.ok(stats.candidateRefs > 0, 'candidate reference count must be > 0');
+    const referenceResolutionRate = stats.resolvedRefs / stats.candidateRefs;
+    assert.ok(referenceResolutionRate >= U2_REFERENCE_RESOLUTION_RATE_THRESHOLD, `reference_resolution_rate=${referenceResolutionRate.toFixed(3)} below threshold=${U2_REFERENCE_RESOLUTION_RATE_THRESHOLD.toFixed(3)} (resolved=${stats.resolvedRefs}, candidates=${stats.candidateRefs})`);
+});
+test('U2 threshold: list_reference_parse_rate stays above baseline', async () => {
+    const result = await resolveUnityBindings({ repoRoot: fixtureRoot, symbol: 'MenuScreenCarrier' });
+    const stats = collectU2ReferenceStats([result]);
+    assert.ok(stats.listCandidates > 0, 'list reference candidate count must be > 0');
+    const listReferenceParseRate = stats.parsedListRefs / stats.listCandidates;
+    assert.ok(listReferenceParseRate >= U2_LIST_REFERENCE_PARSE_RATE_THRESHOLD, `list_reference_parse_rate=${listReferenceParseRate.toFixed(3)} below threshold=${U2_LIST_REFERENCE_PARSE_RATE_THRESHOLD.toFixed(3)} (parsed=${stats.parsedListRefs}, candidates=${stats.listCandidates})`);
+});

package/dist/core/unity/yaml-object-graph.d.ts

@@ -0,0 +1,9 @@
+export type UnityObjectType = 'MonoBehaviour' | 'PrefabInstance' | 'GameObject';
+export interface UnityObjectBlock {
+    objectId: string;
+    objectType: UnityObjectType;
+    stripped: boolean;
+    fields: Record<string, string>;
+    rawBody: string;
+}
+export declare function parseUnityYamlObjects(text: string): UnityObjectBlock[];

package/dist/core/unity/yaml-object-graph.js

@@ -0,0 +1,92 @@
+const SUPPORTED_TYPES = new Set(['MonoBehaviour', 'PrefabInstance', 'GameObject']);
+export function parseUnityYamlObjects(text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const blocks = [];
+    let currentHeader = null;
+    let currentBody = [];
+    const flush = () => {
+        if (!currentHeader)
+            return;
+        const objectType = findObjectType(currentBody);
+        if (!objectType) {
+            currentHeader = null;
+            currentBody = [];
+            return;
+        }
+        blocks.push({
+            objectId: currentHeader.objectId,
+            objectType,
+            stripped: currentHeader.stripped,
+            fields: parseFields(currentBody),
+            rawBody: currentBody.join('\n'),
+        });
+        currentHeader = null;
+        currentBody = [];
+    };
+    for (const line of lines) {
+        const header = line.match(/^--- !u!\d+ &(\d+)(?:\s+(\w+))?\s*$/);
+        if (header) {
+            flush();
+            currentHeader = {
+                objectId: header[1],
+                stripped: header[2] === 'stripped',
+            };
+            continue;
+        }
+        if (currentHeader) {
+            currentBody.push(line);
+        }
+    }
+    flush();
+    return blocks;
+}
+function findObjectType(lines) {
+    for (const line of lines) {
+        const match = line.match(/^(MonoBehaviour|PrefabInstance|GameObject):\s*$/);
+        if (match && SUPPORTED_TYPES.has(match[1])) {
+            return match[1];
+        }
+    }
+    return null;
+}
+function parseFields(lines) {
+    const fields = {};
+    const rootIndex = lines.findIndex((line) => /^(MonoBehaviour|PrefabInstance|GameObject):\s*$/.test(line));
+    if (rootIndex === -1)
+        return fields;
+    let currentKey = null;
+    let currentValue = [];
+    const flush = () => {
+        if (!currentKey)
+            return;
+        fields[currentKey] = currentValue.join('\n').trim();
+        currentKey = null;
+        currentValue = [];
+    };
+    for (const line of lines.slice(rootIndex + 1)) {
+        if (!line.trim()) {
+            if (currentKey)
+                currentValue.push('');
+            continue;
+        }
+        const topLevelMatch = line.match(/^ {2}(?!-)([^ ][^:]*):(.*)$/);
+        if (topLevelMatch) {
+            flush();
+            currentKey = topLevelMatch[1].trim();
+            const inlineValue = topLevelMatch[2].trim();
+            if (inlineValue)
+                currentValue.push(inlineValue);
+            continue;
+        }
+        if (currentKey) {
+            currentValue.push(stripCommonIndent(line));
+        }
+    }
+    flush();
+    return fields;
+}
+function stripCommonIndent(line) {
+    if (line.startsWith('    '))
+        return line.slice(4);
+    return line.trimStart();
+}

package/dist/core/unity/yaml-object-graph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/yaml-object-graph.test.js

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseUnityYamlObjects } from './yaml-object-graph.js';
+const sampleYaml = `--- !u!1 &1000
+GameObject:
+  m_Name: MainUIRoot
+--- !u!114 &11400000 stripped
+MonoBehaviour:
+  m_CorrespondingSourceObject: {fileID: 11400000, guid: abcdef0123456789abcdef0123456789, type: 3}
+  m_PrefabInstance: {fileID: 2000}
+  needPause: 0
+  mainUIDocument: {fileID: 11400000, guid: fedcba9876543210fedcba9876543210, type: 2}
+--- !u!1001 &2000
+PrefabInstance:
+  m_Modification:
+    m_Modifications:
+    - target: {fileID: 11400000}
+      propertyPath: needPause
+      value: 1
+      objectReference: {fileID: 0}
+`;
+test('parseUnityYamlObjects parses stripped MonoBehaviour and PrefabInstance blocks', () => {
+    const blocks = parseUnityYamlObjects(sampleYaml);
+    assert.equal(blocks.length, 3);
+    assert.deepEqual(blocks.map((block) => ({ id: block.objectId, type: block.objectType, stripped: block.stripped })), [
+        { id: '1000', type: 'GameObject', stripped: false },
+        { id: '11400000', type: 'MonoBehaviour', stripped: true },
+        { id: '2000', type: 'PrefabInstance', stripped: false },
+    ]);
+    assert.equal(blocks[1].fields.needPause, '0');
+    assert.match(blocks[1].fields.mainUIDocument, /fileID: 11400000/);
+    assert.match(blocks[2].fields.m_Modification, /propertyPath: needPause/);
+});
+test('parseUnityYamlObjects keeps inline list entries under their parent field', () => {
+    const yamlWithInlineList = `--- !u!114 &11400001
+MonoBehaviour:
+  buttonMappings:
+  - {fileID: 11400000, guid: fedcba9876543210fedcba9876543210, type: 2}
+  - {fileID: 0}
+  needPause: 0
+`;
+    const blocks = parseUnityYamlObjects(yamlWithInlineList);
+    assert.equal(blocks.length, 1);
+    const mono = blocks[0];
+    assert.equal(mono.objectType, 'MonoBehaviour');
+    assert.ok(mono.fields.buttonMappings.includes('- {fileID: 11400000'));
+    assert.equal(mono.fields['- {fileID'], undefined);
+    assert.equal(mono.fields.needPause, '0');
+});

package/dist/mcp/local/cluster-aggregation.d.ts

@@ -0,0 +1,20 @@
+export interface RawCluster {
+    id: string;
+    label?: string;
+    heuristicLabel?: string;
+    cohesion?: number;
+    symbolCount?: number;
+}
+export interface AggregatedCluster {
+    id: string;
+    label: string;
+    heuristicLabel: string;
+    symbolCount: number;
+    cohesion: number;
+    subCommunities: number;
+}
+export interface ClusterAggregationOptions {
+    minSymbolCount?: number;
+    configuredIdPrefix?: string;
+}
+export declare function aggregateClusters(clusters: RawCluster[], options?: ClusterAggregationOptions): AggregatedCluster[];

package/dist/mcp/local/cluster-aggregation.js

@@ -0,0 +1,48 @@
+const DEFAULT_MIN_SYMBOL_COUNT = 5;
+const DEFAULT_CONFIGURED_ID_PREFIX = 'comm_cfg_';
+export function aggregateClusters(clusters, options = {}) {
+    const minSymbolCount = options.minSymbolCount ?? DEFAULT_MIN_SYMBOL_COUNT;
+    const configuredIdPrefix = options.configuredIdPrefix ?? DEFAULT_CONFIGURED_ID_PREFIX;
+    const groups = new Map();
+    for (const cluster of clusters) {
+        const label = cluster.heuristicLabel || cluster.label || 'Unknown';
+        const symbols = cluster.symbolCount || 0;
+        const cohesion = cluster.cohesion || 0;
+        const isConfigured = cluster.id.startsWith(configuredIdPrefix);
+        const existing = groups.get(label);
+        if (!existing) {
+            groups.set(label, {
+                ids: [cluster.id],
+                totalSymbols: symbols,
+                weightedCohesion: cohesion * symbols,
+                largest: cluster,
+                hasConfigured: isConfigured,
+            });
+            continue;
+        }
+        existing.ids.push(cluster.id);
+        existing.totalSymbols += symbols;
+        existing.weightedCohesion += cohesion * symbols;
+        existing.hasConfigured = existing.hasConfigured || isConfigured;
+        if (symbols > (existing.largest.symbolCount || 0)) {
+            existing.largest = cluster;
+        }
+    }
+    return Array.from(groups.entries())
+        .map(([label, g]) => ({
+        id: g.largest.id,
+        label,
+        heuristicLabel: label,
+        symbolCount: g.totalSymbols,
+        cohesion: g.totalSymbols > 0 ? g.weightedCohesion / g.totalSymbols : 0,
+        subCommunities: g.ids.length,
+        hasConfigured: g.hasConfigured,
+    }))
+        .filter((c) => c.symbolCount >= minSymbolCount || c.hasConfigured)
+        .sort((a, b) => {
+        if (a.symbolCount !== b.symbolCount)
+            return b.symbolCount - a.symbolCount;
+        return a.heuristicLabel.localeCompare(b.heuristicLabel);
+    })
+        .map(({ hasConfigured: _hasConfigured, ...rest }) => rest);
+}

package/dist/mcp/local/cluster-aggregation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/local/cluster-aggregation.test.js

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { aggregateClusters } from './cluster-aggregation.js';
+test('keeps auto tiny clusters filtered but includes empty configured modules', () => {
+    const out = aggregateClusters([
+        { id: 'comm_1', label: 'AutoTiny', heuristicLabel: 'AutoTiny', cohesion: 0.2, symbolCount: 1 },
+        { id: 'comm_cfg_battle', label: 'Battle', heuristicLabel: 'Battle', cohesion: 0, symbolCount: 0 },
+        { id: 'comm_2', label: 'Gameplay', heuristicLabel: 'Gameplay', cohesion: 0.8, symbolCount: 9 },
+    ], { minSymbolCount: 5, configuredIdPrefix: 'comm_cfg_' });
+    assert.ok(out.some((c) => c.heuristicLabel === 'Battle' && c.symbolCount === 0));
+    assert.ok(!out.some((c) => c.heuristicLabel === 'AutoTiny'));
+    assert.ok(out.some((c) => c.heuristicLabel === 'Gameplay' && c.symbolCount === 9));
+});
+test('aggregates same-name clusters with weighted cohesion', () => {
+    const out = aggregateClusters([
+        { id: 'comm_1', label: 'Gameplay', heuristicLabel: 'Gameplay', cohesion: 0.5, symbolCount: 4 },
+        { id: 'comm_2', label: 'Gameplay', heuristicLabel: 'Gameplay', cohesion: 1.0, symbolCount: 6 },
+    ], { minSymbolCount: 5, configuredIdPrefix: 'comm_cfg_' });
+    assert.equal(out.length, 1);
+    assert.equal(out[0].symbolCount, 10);
+    assert.equal(Math.round(out[0].cohesion * 100), 80);
+});

package/dist/mcp/local/local-backend.js

@@ -8,6 +8,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { initKuzu, executeQuery, closeKuzu, isKuzuReady } from '../core/kuzu-adapter.js';
+import { parseUnityResourcesMode } from '../../core/unity/options.js';
+import { loadUnityContext } from './unity-enrichment.js';
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
@@ -285,6 +287,7 @@ export class LocalBackend {
         const processLimit = params.limit || 5;
         const maxSymbolsPerProcess = params.max_symbols || 10;
         const includeContent = params.include_content ?? false;
+        const unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
         const searchQuery = params.query.trim();
         // Step 1: Run hybrid search to get matching symbols
         const searchLimit = processLimit * maxSymbolsPerProcess; // fetch enough raw results
@@ -383,6 +386,9 @@ export class LocalBackend {
                 endLine: sym.endLine,
                 ...(module ? { module } : {}),
                 ...(includeContent && content ? { content } : {}),
+                ...((unityResourcesMode !== 'off' && sym.nodeId && sym.type === 'Class')
+                    ? await loadUnityContext(repo.id, sym.nodeId, (query) => executeQuery(repo.id, query))
+                    : {}),
             };
             if (processRows.length === 0) {
                 // Symbol not in any process — goes to definitions
@@ -796,6 +802,7 @@ export class LocalBackend {
     async context(repo, params) {
         await this.ensureInitialized(repo.id);
         const { name, uid, file_path, include_content } = params;
+        const unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
         if (!name && !uid) {
             return { error: 'Either "name" or "uid" parameter is required.' };
         }
@@ -948,7 +955,7 @@ export class LocalBackend {
             }
             return cats;
         };
-        return {
+        const result = {
             status: 'found',
             symbol: {
                 uid: getRowValue(sym, 'id', 0),
@@ -968,6 +975,10 @@ export class LocalBackend {
                 step_count: getRowValue(r, 'stepCount', 3),
             })),
         };
+        if (unityResourcesMode !== 'off' && symNodeId && symKind === 'Class') {
+            Object.assign(result, await loadUnityContext(repo.id, symNodeId, (query) => executeQuery(repo.id, query)));
+        }
+        return result;
     }
     /**
      * Legacy explore — kept for backwards compatibility with resources.ts.

package/dist/mcp/local/unity-enrichment.d.ts

@@ -0,0 +1,6 @@
+import type { ResolveOutput } from '../../core/unity/resolver.js';
+export interface UnityContextPayload extends Pick<ResolveOutput, 'resourceBindings' | 'serializedFields' | 'unityDiagnostics'> {
+}
+export type ExecuteQuery = (query: string) => Promise<any[]>;
+export declare function loadUnityContext(_repoId: string, symbolId: string, execute: ExecuteQuery): Promise<UnityContextPayload>;
+export declare function projectUnityBindings(rows: any[]): UnityContextPayload;

package/dist/mcp/local/unity-enrichment.js

@@ -0,0 +1,91 @@
+import { extractAssetRefPathReferences } from '../../core/unity/resolver.js';
+export async function loadUnityContext(_repoId, symbolId, execute) {
+    const escapedSymbolId = symbolId.replace(/'/g, "''");
+    const rows = await execute(`
+    MATCH (symbol {id: '${escapedSymbolId}'})-[r:CodeRelation]->(component:CodeElement)
+    WHERE r.type IN ['UNITY_COMPONENT_INSTANCE', 'UNITY_SERIALIZED_TYPE_IN']
+    RETURN component.filePath AS resourcePath, component.description AS payload, r.type AS relationType, r.reason AS relationReason
+    ORDER BY component.filePath, component.id
+  `);
+    return projectUnityBindings(rows);
+}
+export function projectUnityBindings(rows) {
+    const resourceBindings = [];
+    const scalarFields = [];
+    const referenceFields = [];
+    const unityDiagnostics = [];
+    for (const row of rows) {
+        const rawPayload = row?.payload ?? row?.description ?? row?.[1];
+        if (typeof rawPayload !== 'string' || rawPayload.length === 0) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(rawPayload);
+            const binding = {
+                resourcePath: parsed.resourcePath || row?.resourcePath || row?.[0] || '',
+                resourceType: parsed.resourceType || inferResourceType(parsed.resourcePath || row?.resourcePath || row?.[0] || ''),
+                bindingKind: parsed.bindingKind || 'direct',
+                componentObjectId: parsed.componentObjectId || '',
+                evidence: parsed.evidence || buildSyntheticEvidence(row),
+                serializedFields: parsed.serializedFields || { scalarFields: [], referenceFields: [] },
+                resolvedReferences: parsed.resolvedReferences || [],
+                assetRefPaths: normalizeAssetRefPaths(parsed.assetRefPaths) || extractAssetRefPathReferences(parsed.serializedFields || { scalarFields: [], referenceFields: [] }),
+            };
+            resourceBindings.push(binding);
+            scalarFields.push(...binding.serializedFields.scalarFields);
+            referenceFields.push(...binding.serializedFields.referenceFields);
+        }
+        catch (error) {
+            unityDiagnostics.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    return {
+        resourceBindings,
+        serializedFields: {
+            scalarFields,
+            referenceFields,
+        },
+        unityDiagnostics,
+    };
+}
+function inferResourceType(resourcePath) {
+    if (resourcePath.endsWith('.prefab'))
+        return 'prefab';
+    if (resourcePath.endsWith('.asset'))
+        return 'asset';
+    return 'scene';
+}
+function buildSyntheticEvidence(row) {
+    const relationType = String(row?.relationType || '').trim();
+    const relationReason = String(row?.relationReason || '').trim();
+    if (!relationType && !relationReason) {
+        return { line: 0, lineText: '' };
+    }
+    return {
+        line: 0,
+        lineText: relationReason ? `${relationType}:${relationReason}` : relationType,
+    };
+}
+function normalizeAssetRefPaths(input) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return undefined;
+    }
+    const rows = [];
+    for (const row of input) {
+        if (!row || typeof row !== 'object')
+            continue;
+        const parentFieldName = String(row.parentFieldName || '').trim();
+        const fieldName = String(row.fieldName || '').trim();
+        const relativePath = String(row.relativePath || '');
+        const sourceLayer = String(row.sourceLayer || 'unknown');
+        rows.push({
+            parentFieldName: parentFieldName || fieldName || 'unknown',
+            fieldName: fieldName || parentFieldName || 'unknown',
+            relativePath,
+            sourceLayer,
+            isEmpty: Boolean(row.isEmpty ?? relativePath.length === 0),
+            isSprite: Boolean(row.isSprite),
+        });
+    }
+    return rows.length > 0 ? rows : undefined;
+}

package/dist/mcp/local/unity-enrichment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/local/unity-enrichment.test.js

@@ -0,0 +1,130 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { loadUnityContext, projectUnityBindings } from './unity-enrichment.js';
+test('projectUnityBindings restores graph-native Unity payload rows', () => {
+    const out = projectUnityBindings([
+        {
+            resourcePath: 'Assets/Scene/MainUIManager.unity',
+            payload: JSON.stringify({
+                resourcePath: 'Assets/Scene/MainUIManager.unity',
+                resourceType: 'scene',
+                bindingKind: 'nested',
+                componentObjectId: '11400000',
+                evidence: { line: 9, lineText: '  m_Script: {...}' },
+                serializedFields: {
+                    scalarFields: [{ name: 'needPause', value: '1', valueType: 'number', sourceLayer: 'scene' }],
+                    referenceFields: [{ name: 'mainUIDocument', guid: 'abc', sourceLayer: 'scene' }],
+                },
+            }),
+        },
+    ]);
+    assert.equal(out.resourceBindings[0].bindingKind, 'nested');
+    assert.ok(out.serializedFields.scalarFields.length >= 1);
+    assert.ok(out.serializedFields.referenceFields.length >= 1);
+});
+test('loadUnityContext queries component payload rows and projects stable output', async () => {
+    const out = await loadUnityContext('repo-id', 'Class:Assets/Scripts/MainUIManager.cs:MainUIManager', async (query) => {
+        assert.match(query, /UNITY_COMPONENT_INSTANCE/);
+        assert.match(query, /UNITY_SERIALIZED_TYPE_IN/);
+        return [
+            {
+                resourcePath: 'Assets/Scene/MainUIManager.unity',
+                payload: JSON.stringify({
+                    resourcePath: 'Assets/Scene/MainUIManager.unity',
+                    resourceType: 'scene',
+                    bindingKind: 'scene-override',
+                    componentObjectId: '11400000',
+                    evidence: { line: 9, lineText: '  m_Script: {...}' },
+                    serializedFields: {
+                        scalarFields: [{ name: 'needPause', value: '1', valueType: 'number', sourceLayer: 'scene' }],
+                        referenceFields: [],
+                    },
+                }),
+            },
+        ];
+    });
+    assert.equal(out.resourceBindings[0]?.bindingKind, 'scene-override');
+    assert.equal(out.serializedFields.scalarFields[0]?.name, 'needPause');
+    assert.deepEqual(out.unityDiagnostics, []);
+});
+test('loadUnityContext returns resourceBindings for UNITY_SERIALIZED_TYPE_IN relations', async () => {
+    const out = await loadUnityContext('repo-id', 'Class:Assets/Scripts/AssetRef.cs:AssetRef', async () => [
+        {
+            relationType: 'UNITY_SERIALIZED_TYPE_IN',
+            relationReason: '{"hostSymbol":"InventoryConfig","fieldName":"icon","declaredType":"AssetRef"}',
+            resourcePath: 'Assets/Config/Inventory.asset',
+            payload: JSON.stringify({
+                resourceType: 'asset',
+                serializedFields: { scalarFields: [], referenceFields: [] },
+            }),
+        },
+    ]);
+    assert.equal(out.resourceBindings.length, 1);
+    assert.equal(out.resourceBindings[0]?.resourcePath, 'Assets/Config/Inventory.asset');
+    assert.equal(out.resourceBindings[0]?.resourceType, 'asset');
+});
+test('projectUnityBindings preserves structured assetRefPaths from payload', () => {
+    const out = projectUnityBindings([
+        {
+            resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+            payload: JSON.stringify({
+                resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+                resourceType: 'asset',
+                bindingKind: 'prefab-instance',
+                componentObjectId: '11400000',
+                assetRefPaths: [
+                    {
+                        parentFieldName: 'Values',
+                        fieldName: '_Head_Ref',
+                        relativePath: 'Assets/NEON/Art/Sprites/UI/0_pixle/ui_character_head/hero_head_Nik.png',
+                        sourceLayer: 'asset',
+                        isEmpty: false,
+                        isSprite: true,
+                    },
+                ],
+                serializedFields: {
+                    scalarFields: [],
+                    referenceFields: [],
+                },
+            }),
+        },
+    ]);
+    assert.equal(out.resourceBindings.length, 1);
+    assert.equal(out.resourceBindings[0]?.assetRefPaths?.length, 1);
+    assert.equal(out.resourceBindings[0]?.assetRefPaths?.[0]?.fieldName, '_Head_Ref');
+    assert.equal(out.resourceBindings[0]?.assetRefPaths?.[0]?.isSprite, true);
+});
+test('projectUnityBindings derives assetRefPaths from serialized scalar fields when payload lacks structured rows', () => {
+    const out = projectUnityBindings([
+        {
+            resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+            payload: JSON.stringify({
+                resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+                resourceType: 'asset',
+                bindingKind: 'prefab-instance',
+                componentObjectId: '11400000',
+                serializedFields: {
+                    scalarFields: [
+                        {
+                            name: 'Values',
+                            sourceLayer: 'asset',
+                            value: `
+_Head_Ref:
+  _relativePath: Assets/NEON/Art/Sprites/UI/0_pixle/ui_character_head/hero_head_Nik.png
+_actorPrefabRef:
+  _relativePath: Assets/ActorPrefab/Actor_Nik/V_Actor_Nik.prefab
+`,
+                        },
+                    ],
+                    referenceFields: [],
+                },
+            }),
+        },
+    ]);
+    const refs = out.resourceBindings[0]?.assetRefPaths || [];
+    assert.equal(refs.length, 2);
+    assert.equal(refs[0]?.fieldName, '_Head_Ref');
+    assert.equal(refs[0]?.isSprite, true);
+    assert.equal(refs[1]?.fieldName, '_actorPrefabRef');
+    assert.equal(refs[1]?.isSprite, false);
+});