@veewo/gitnexus 1.4.11-rc.2 → 1.5.0-rc.2

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

@@ -12,33 +12,13 @@ const LIFECYCLE_CALLBACKS = new Set([
     'OnDisable',
     'OnDestroy',
 ]);
-const RUNTIME_LOADER_ANCHORS = new Set([
-    'Equip',
-    'EquipWithEvent',
-    'RegisterGraphEvents',
-    'RegisterEvents',
-    'StartRoutineWithEvents',
-    'GetValue',
-    'CheckReload',
-    'ReloadRoutine',
-]);
-const DETERMINISTIC_LOADER_BRIDGES = [
-    ['Equip', 'EquipWithEvent'],
-    ['EquipWithEvent', 'RegisterEvents'],
-    ['RegisterGraphEvents', 'RegisterEvents'],
-    ['RegisterEvents', 'StartRoutineWithEvents'],
-    ['StartRoutineWithEvents', 'GetValue'],
-    ['GetValue', 'CheckReload'],
-    ['CheckReload', 'ReloadRoutine'],
-];
 const SYNTHETIC_RUNTIME_ROOT_NAME = 'unity-runtime-root';
 const SYNTHETIC_RUNTIME_ROOT_ID = generateId('Method', SYNTHETIC_RUNTIME_ROOT_NAME);
 export const DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG = {
-    enabled: false,
+    enabled: true,
     maxSyntheticEdgesPerClass: 12,
     maxSyntheticEdgesTotal: 256,
     lifecycleEdgeConfidence: 0.72,
-    loaderEdgeConfidence: 0.68,
 };
 export const detectUnityLifecycleHosts = (graph) => {
     const methodsByClass = new Map();
@@ -79,12 +59,10 @@ export const detectUnityLifecycleHosts = (graph) => {
             continue;
         const methods = methodsByClass.get(node.id) ?? [];
         const lifecycleCallbacks = methods.filter((method) => LIFECYCLE_CALLBACKS.has(method.properties.name));
-        const loaderAnchors = methods.filter((method) => RUNTIME_LOADER_ANCHORS.has(method.properties.name));
         hosts.push({
             classNode: node,
             baseType,
             lifecycleCallbacks: sortMethodsByName(lifecycleCallbacks),
-            loaderAnchors: sortMethodsByName(loaderAnchors),
             methods: sortMethodsByName(methods),
         });
     }
@@ -95,15 +73,6 @@ export const applyUnityLifecycleSyntheticCalls = (graph, config = {}) => {
         ...DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG,
         ...config,
     };
-    if (!cfg.enabled) {
-        return {
-            syntheticEdgeCount: 0,
-            lifecycleEdgeCount: 0,
-            loaderEdgeCount: 0,
-            hostCount: 0,
-            rejectedHostCount: 0,
-        };
-    }
     const hosts = detectUnityLifecycleHosts(graph);
     const acceptedHosts = [];
     let rejectedHostCount = 0;
@@ -114,27 +83,11 @@ export const applyUnityLifecycleSyntheticCalls = (graph, config = {}) => {
         }
         acceptedHosts.push(host);
     }
-    acceptedHosts.sort((left, right) => scoreUnityHost(right) - scoreUnityHost(left));
+    acceptedHosts.sort((left, right) => right.lifecycleCallbacks.length - left.lifecycleCallbacks.length);
     if (acceptedHosts.length === 0) {
-        return {
-            syntheticEdgeCount: 0,
-            lifecycleEdgeCount: 0,
-            loaderEdgeCount: 0,
-            hostCount: 0,
-            rejectedHostCount,
-        };
+        return { syntheticEdgeCount: 0, lifecycleEdgeCount: 0, loaderEdgeCount: 0, hostCount: 0, rejectedHostCount };
     }
     ensureRuntimeRootNode(graph);
-    const hostMethodToClassId = new Map();
-    const methodsByName = new Map();
-    for (const host of acceptedHosts) {
-        for (const method of host.methods) {
-            hostMethodToClassId.set(method.id, host.classNode.id);
-            const list = methodsByName.get(method.properties.name) ?? [];
-            list.push(method);
-            methodsByName.set(method.properties.name, list);
-        }
-    }
     const existingPairs = new Set();
     for (const rel of graph.iterRelationships()) {
         if (rel.type === 'CALLS')
@@ -143,89 +96,35 @@ export const applyUnityLifecycleSyntheticCalls = (graph, config = {}) => {
     const syntheticEdgesPerClass = new Map();
     let syntheticEdgeCount = 0;
     let lifecycleEdgeCount = 0;
-    let loaderEdgeCount = 0;
-    const reservedBridgeBudget = Math.max(1, Math.floor(cfg.maxSyntheticEdgesTotal * 0.5));
-    const preBridgeBudget = Math.max(0, cfg.maxSyntheticEdgesTotal - reservedBridgeBudget);
-    const canAllocate = (classId, phase = 'pre_bridge') => {
-        if (syntheticEdgeCount >= cfg.maxSyntheticEdgesTotal)
-            return false;
-        if (phase === 'pre_bridge' && syntheticEdgeCount >= preBridgeBudget)
-            return false;
-        const classCount = syntheticEdgesPerClass.get(classId) ?? 0;
-        return classCount < cfg.maxSyntheticEdgesPerClass;
-    };
-    const addSyntheticEdge = (sourceId, targetId, reason, confidence, classId, phase = 'pre_bridge') => {
-        if (sourceId === targetId)
-            return false;
-        if (!canAllocate(classId, phase))
-            return false;
-        if (PLACEHOLDER_RE.test(sourceId) || PLACEHOLDER_RE.test(targetId))
-            return false;
-        const pairKey = `${sourceId}->${targetId}`;
-        if (existingPairs.has(pairKey))
-            return false;
-        graph.addRelationship({
-            id: generateId('CALLS', `${sourceId}->${targetId}:${reason}`),
-            sourceId,
-            targetId,
-            type: 'CALLS',
-            confidence,
-            reason,
-        });
-        existingPairs.add(pairKey);
-        syntheticEdgeCount += 1;
-        syntheticEdgesPerClass.set(classId, (syntheticEdgesPerClass.get(classId) ?? 0) + 1);
-        if (reason === 'unity-lifecycle-synthetic')
-            lifecycleEdgeCount += 1;
-        if (reason === 'unity-runtime-loader-synthetic')
-            loaderEdgeCount += 1;
-        return true;
-    };
     for (const host of acceptedHosts) {
         const classId = host.classNode.id;
         for (const callback of host.lifecycleCallbacks) {
-            if (!canAllocate(classId))
+            const classCount = syntheticEdgesPerClass.get(classId) ?? 0;
+            if (syntheticEdgeCount >= cfg.maxSyntheticEdgesTotal)
                 break;
-            addSyntheticEdge(SYNTHETIC_RUNTIME_ROOT_ID, callback.id, 'unity-lifecycle-synthetic', cfg.lifecycleEdgeConfidence, classId, 'pre_bridge');
-        }
-        if (!canAllocate(classId))
-            continue;
-        for (const callback of host.lifecycleCallbacks) {
-            if (!canAllocate(classId))
+            if (classCount >= cfg.maxSyntheticEdgesPerClass)
                 break;
-            for (const loader of host.loaderAnchors) {
-                if (!canAllocate(classId))
-                    break;
-                addSyntheticEdge(callback.id, loader.id, 'unity-runtime-loader-synthetic', cfg.loaderEdgeConfidence, classId, 'pre_bridge');
-            }
-        }
-    }
-    for (const [sourceName, targetName] of DETERMINISTIC_LOADER_BRIDGES) {
-        const sourceMethods = [...(methodsByName.get(sourceName) ?? [])].sort((left, right) => scoreRuntimeLoaderMethod(right) - scoreRuntimeLoaderMethod(left));
-        const targetMethods = [...(methodsByName.get(targetName) ?? [])].sort((left, right) => scoreRuntimeLoaderMethod(right) - scoreRuntimeLoaderMethod(left));
-        if (sourceMethods.length === 0 || targetMethods.length === 0)
-            continue;
-        const topSource = sourceMethods[0];
-        const topTarget = targetMethods[0];
-        const topSourceClassId = topSource ? hostMethodToClassId.get(topSource.id) : undefined;
-        if (topSource && topTarget && topSourceClassId) {
-            addSyntheticEdge(topSource.id, topTarget.id, 'unity-runtime-loader-synthetic', cfg.loaderEdgeConfidence, topSourceClassId, 'bridge');
-        }
-        for (const sourceMethod of sourceMethods) {
-            const classId = hostMethodToClassId.get(sourceMethod.id);
-            if (!classId || !canAllocate(classId, 'bridge'))
+            const pairKey = `${SYNTHETIC_RUNTIME_ROOT_ID}->${callback.id}`;
+            if (existingPairs.has(pairKey))
                 continue;
-            for (const targetMethod of targetMethods) {
-                if (!canAllocate(classId, 'bridge'))
-                    break;
-                addSyntheticEdge(sourceMethod.id, targetMethod.id, 'unity-runtime-loader-synthetic', cfg.loaderEdgeConfidence, classId, 'bridge');
-            }
+            graph.addRelationship({
+                id: generateId('CALLS', `${SYNTHETIC_RUNTIME_ROOT_ID}->${callback.id}:unity-lifecycle-synthetic`),
+                sourceId: SYNTHETIC_RUNTIME_ROOT_ID,
+                targetId: callback.id,
+                type: 'CALLS',
+                confidence: cfg.lifecycleEdgeConfidence,
+                reason: 'unity-lifecycle-synthetic',
+            });
+            existingPairs.add(pairKey);
+            syntheticEdgeCount += 1;
+            lifecycleEdgeCount += 1;
+            syntheticEdgesPerClass.set(classId, classCount + 1);
         }
     }
     return {
         syntheticEdgeCount,
         lifecycleEdgeCount,
-        loaderEdgeCount,
+        loaderEdgeCount: 0,
         hostCount: acceptedHosts.length,
         rejectedHostCount,
         runtimeRootNodeId: syntheticEdgeCount > 0 ? SYNTHETIC_RUNTIME_ROOT_ID : undefined,
@@ -237,11 +136,7 @@ const resolveUnityBaseType = (graph, extendsByClass, classIdsByName, classId, vi
     visited.add(classId);
     for (const edge of extendsByClass.get(classId) ?? []) {
         const targetNode = graph.getNode(edge.targetId);
-        const candidates = [
-            targetNode?.properties?.name ?? '',
-            edge.targetId,
-            edge.reason,
-        ];
+        const candidates = [targetNode?.properties?.name ?? '', edge.targetId, edge.reason];
         for (const candidate of candidates) {
             const normalized = normalizeBaseType(candidate);
             if (normalized)
@@ -264,12 +159,10 @@ const normalizeBaseType = (value) => {
     const text = String(value || '').trim();
     if (!text)
         return undefined;
-    if (text.endsWith(UNITY_MONOBEHAVIOUR) || text.includes(`.${UNITY_MONOBEHAVIOUR}`)) {
+    if (text.endsWith(UNITY_MONOBEHAVIOUR) || text.includes(`.${UNITY_MONOBEHAVIOUR}`))
         return UNITY_MONOBEHAVIOUR;
-    }
-    if (text.endsWith(UNITY_SCRIPTABLE_OBJECT) || text.includes(`.${UNITY_SCRIPTABLE_OBJECT}`)) {
+    if (text.endsWith(UNITY_SCRIPTABLE_OBJECT) || text.includes(`.${UNITY_SCRIPTABLE_OBJECT}`))
         return UNITY_SCRIPTABLE_OBJECT;
-    }
     return undefined;
 };
 const ensureRuntimeRootNode = (graph) => {
@@ -278,10 +171,7 @@ const ensureRuntimeRootNode = (graph) => {
     graph.addNode({
         id: SYNTHETIC_RUNTIME_ROOT_ID,
         label: 'Method',
-        properties: {
-            name: SYNTHETIC_RUNTIME_ROOT_NAME,
-            filePath: '',
-        },
+        properties: { name: SYNTHETIC_RUNTIME_ROOT_NAME, filePath: '' },
     });
 };
 const isPlaceholderHost = (host) => {
@@ -299,86 +189,9 @@ const sortMethodsByName = (methods) => [...methods].sort((left, right) => {
         return byName;
     return left.id.localeCompare(right.id);
 });
-const scoreUnityHost = (host) => {
-    const filePath = String(host.classNode.properties.filePath || '');
-    let score = 0;
-    score += host.loaderAnchors.length * 40;
-    score += host.lifecycleCallbacks.length * 8;
-    if (filePath.includes('Assets/NEON/Code/Game/'))
-        score += 200;
-    else if (filePath.includes('Assets/NEON/Code/'))
-        score += 120;
-    else if (filePath.includes('Assets/'))
-        score += 40;
-    if (filePath.includes('/Graph/'))
-        score += 60;
-    if (filePath.includes('/PowerUps/'))
-        score += 40;
-    if (filePath.includes('/Core/'))
-        score += 30;
-    if (filePath.includes('/Reload'))
-        score += 30;
-    if (filePath.includes('/Packages/'))
-        score -= 120;
-    if (filePath.includes('/Legacy/'))
-        score -= 80;
-    if (filePath.startsWith('Assets/Scripts/'))
-        score -= 60;
-    for (const method of host.loaderAnchors) {
-        const methodName = String(method.properties.name || '');
-        if (methodName === 'RegisterGraphEvents' || methodName === 'RegisterEvents')
-            score += 25;
-        if (methodName === 'StartRoutineWithEvents')
-            score += 25;
-        if (methodName === 'GetValue' || methodName === 'CheckReload' || methodName === 'ReloadRoutine')
-            score += 20;
-        if (methodName === 'Equip' || methodName === 'EquipWithEvent')
-            score += 15;
-    }
-    return score;
-};
-const scoreRuntimeLoaderMethod = (method) => {
-    const filePath = String(method.properties.filePath || '');
-    const methodName = String(method.properties.name || '');
-    let score = 0;
-    if (filePath.includes('GunGraphMB'))
-        score += 200;
-    if (filePath.includes('/Graph/Graphs/GunGraph.cs'))
-        score += 220;
-    if (filePath.includes('/Graph/Nodes/Reloads/'))
-        score += 240;
-    if (filePath.includes('/PowerUps/WeaponPowerUp.cs'))
-        score += 180;
-    if (filePath.includes('/Game/Core/'))
-        score += 80;
-    if (filePath.includes('/Game/Graph/'))
-        score += 120;
-    if (filePath.includes('/Packages/'))
-        score -= 100;
-    if (filePath.includes('/Legacy/'))
-        score -= 80;
-    if (filePath.includes('/MonoScript/Minion'))
-        score -= 60;
-    if (methodName === 'RegisterGraphEvents')
-        score += 50;
-    if (methodName === 'RegisterEvents')
-        score += 60;
-    if (methodName === 'StartRoutineWithEvents')
-        score += 70;
-    if (methodName === 'GetValue')
-        score += 90;
-    if (methodName === 'CheckReload')
-        score += 90;
-    if (methodName === 'ReloadRoutine')
-        score += 90;
-    if (methodName === 'Equip' || methodName === 'EquipWithEvent')
-        score += 50;
-    return score;
-};
 const resolveNamedClassTargets = (classIdsByName, rawTargetId) => {
     const text = String(rawTargetId || '').trim();
     if (!text.startsWith('Class:'))
         return [];
-    const className = text.slice('Class:'.length);
-    return classIdsByName.get(className) ?? [];
+    return classIdsByName.get(text.slice('Class:'.length)) ?? [];
 };

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

@@ -243,7 +243,7 @@ test('detects Unity hosts through transitive inheritance chains', () => {
     const gunGraphHost = hosts.find((host) => host.classNode.id === gunGraphId);
     assert.ok(gunGraphHost);
     assert.equal(gunGraphHost.baseType, 'ScriptableObject');
-    assert.deepEqual(gunGraphHost.loaderAnchors.map((method) => method.properties.name), ['RegisterEvents', 'StartRoutineWithEvents']);
+    assert.ok(gunGraphHost.methods.length > 0);
 });
 test('prioritizes gameplay lifecycle hosts when synthetic edge budget is tight', () => {
     const graph = createKnowledgeGraph();

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

@@ -3,6 +3,7 @@ import { generateId } from '../../lib/utils.js';
 import { buildUnityScanContext } from '../unity/scan-context.js';
 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;
 export async function processUnityResources(graph, options, deps) {
     const tStart = performance.now();
@@ -116,6 +117,53 @@ export async function processUnityResources(graph, options, deps) {
             };
             for (const binding of resolved.resourceBindings) {
                 bindingCount += 1;
+                componentCount += 1;
+                const resourceFileId = ensureResourceFileNode(graph, binding.resourcePath);
+                const componentPayload = buildUnityPayload(binding, payloadMode);
+                graph.addRelationship({
+                    id: generateId('UNITY_COMPONENT_INSTANCE', `${classNode.id}->${resourceFileId}:${binding.componentObjectId}`),
+                    type: 'UNITY_COMPONENT_INSTANCE',
+                    sourceId: classNode.id,
+                    targetId: resourceFileId,
+                    confidence: 1.0,
+                    reason: JSON.stringify(componentPayload),
+                });
+                graph.addRelationship({
+                    id: generateId('UNITY_GRAPH_NODE_SCRIPT_REF', `${resourceFileId}->${classNode.id}`),
+                    type: 'UNITY_GRAPH_NODE_SCRIPT_REF',
+                    sourceId: resourceFileId,
+                    targetId: classNode.id,
+                    confidence: 1.0,
+                    reason: JSON.stringify({
+                        resourcePath: normalizePath(binding.resourcePath),
+                        resourceType: binding.resourceType,
+                        bindingKind: binding.bindingKind,
+                        componentObjectId: binding.componentObjectId,
+                    }),
+                });
+                for (const ref of binding.resolvedReferences || []) {
+                    const targetAssetPath = normalizePath(String(ref.target?.assetPath || '').trim());
+                    const referenceGuid = String(ref.guid || '').trim();
+                    if (!targetAssetPath || !referenceGuid)
+                        continue;
+                    const sourceFileId = ensureResourceFileNode(graph, binding.resourcePath);
+                    const targetFileId = ensureResourceFileNode(graph, targetAssetPath);
+                    graph.addRelationship({
+                        id: generateId('UNITY_ASSET_GUID_REF', `${sourceFileId}->${targetFileId}:${ref.fieldName}:${referenceGuid}:${String(ref.fileId || '')}`),
+                        type: 'UNITY_ASSET_GUID_REF',
+                        sourceId: sourceFileId,
+                        targetId: targetFileId,
+                        confidence: 1.0,
+                        reason: JSON.stringify({
+                            resourcePath: normalizePath(binding.resourcePath),
+                            targetResourcePath: targetAssetPath,
+                            guid: referenceGuid.toLowerCase(),
+                            fileId: String(ref.fileId || ''),
+                            fieldName: ref.fieldName,
+                            sourceLayer: ref.sourceLayer || 'unknown',
+                        }),
+                    });
+                }
                 appendSummary(classNode.id, binding);
                 const serializableTypeLinking = collectSerializableTypeTargetsForBinding(symbol, binding, scanContext, canonicalClassNodeBySymbol);
                 serializedTypeEdgeCount += serializableTypeLinking.edgeCount;
@@ -123,8 +171,22 @@ export async function processUnityResources(graph, options, deps) {
                 for (const hitSymbol of serializableTypeLinking.symbols) {
                     serializedTypeSymbols.add(hitSymbol);
                 }
-                for (const targetClassId of serializableTypeLinking.targetClassIds) {
-                    appendSummary(targetClassId, binding);
+                for (const link of serializableTypeLinking.links) {
+                    appendSummary(link.targetClassId, binding);
+                    graph.addRelationship({
+                        id: generateId('UNITY_SERIALIZED_TYPE_IN', `${classNode.id}->${link.targetClassId}:${normalizePath(binding.resourcePath)}:${link.fieldName}`),
+                        type: 'UNITY_SERIALIZED_TYPE_IN',
+                        sourceId: classNode.id,
+                        targetId: link.targetClassId,
+                        confidence: 1.0,
+                        reason: JSON.stringify({
+                            hostSymbol: symbol,
+                            declaredType: link.declaredType,
+                            fieldName: link.fieldName,
+                            sourceLayer: link.sourceLayer,
+                            resourcePath: normalizePath(binding.resourcePath),
+                        }),
+                    });
                 }
             }
             for (const [sourceNodeId, perPath] of summaryBySource.entries()) {
@@ -205,24 +267,7 @@ function normalizePath(filePath) {
 function resolveUnityPayloadMode(explicit) {
     if (explicit)
         return explicit;
-    const envMode = String(process.env.GITNEXUS_UNITY_PAYLOAD_MODE || '').trim().toLowerCase();
-    if (envMode === 'full')
-        return 'full';
-    return 'compact';
-}
-function createComponentNode(symbol, binding, payloadMode) {
-    const payload = buildUnityPayload(binding, payloadMode);
-    return {
-        id: generateId('CodeElement', `${binding.resourcePath}:${binding.componentObjectId}`),
-        label: 'CodeElement',
-        properties: {
-            name: `${symbol}@${binding.componentObjectId}`,
-            filePath: binding.resourcePath,
-            startLine: binding.evidence.line,
-            endLine: binding.evidence.line,
-            description: JSON.stringify(payload),
-        },
-    };
+    return resolveUnityConfig().config.payloadMode ?? 'compact';
 }
 function buildUnityPayload(binding, mode) {
     const payload = {
@@ -285,7 +330,7 @@ function collectSerializableTypeTargetsForBinding(hostSymbol, binding, scanConte
         edgeCount: 0,
         missCount: 0,
         symbols: new Set(),
-        targetClassIds: new Set(),
+        links: [],
     };
     if (!scanContext)
         return stats;
@@ -310,7 +355,12 @@ function collectSerializableTypeTargetsForBinding(hostSymbol, binding, scanConte
             stats.missCount += 1;
             continue;
         }
-        stats.targetClassIds.add(serializableNode.id);
+        stats.links.push({
+            targetClassId: serializableNode.id,
+            fieldName,
+            declaredType,
+            sourceLayer,
+        });
         stats.edgeCount += 1;
         stats.symbols.add(declaredType);
     }
@@ -330,6 +380,21 @@ function collectBindingFieldSources(binding) {
     }
     return fieldSources;
 }
+function ensureResourceFileNode(graph, resourcePath) {
+    const normalizedPath = normalizePath(resourcePath);
+    const fileId = generateId('File', normalizedPath);
+    if (!graph.getNode(fileId)) {
+        graph.addNode({
+            id: fileId,
+            label: 'File',
+            properties: {
+                name: normalizedPath.split('/').pop() || normalizedPath,
+                filePath: normalizedPath,
+            },
+        });
+    }
+    return fileId;
+}
 function collectResourceSummaryRows(bindings) {
     const summaryByPath = new Map();
     for (const binding of bindings) {

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

@@ -32,7 +32,7 @@ const listRelativeFixtureFiles = async (root) => {
     }
     return out;
 };
-test('processUnityResources does not emit UNITY_COMPONENT_IN or synthetic resource File nodes', async () => {
+test('processUnityResources emits schema-compatible component-instance edges and materialized resource file nodes', async () => {
     const graph = createKnowledgeGraph();
     for (const symbol of symbols) {
         const filePath = `Assets/Scripts/${symbol}.cs`;
@@ -65,12 +65,14 @@ test('processUnityResources does not emit UNITY_COMPONENT_IN or synthetic resour
     }
     const result = await processUnityResources(graph, { repoPath: fixtureRoot });
     const unityFileRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_IN');
+    const unityComponentInstanceRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_INSTANCE');
     const unitySummaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
     const syntheticResourceFiles = [...graph.iterNodes()].filter((node) => node.label === 'File' && /\.(prefab|unity|asset)$/.test(String(node.properties.filePath)));
     const componentNodes = [...graph.iterNodes()].filter((node) => node.label === 'CodeElement');
     assert.equal(result.bindingCount > 0, true);
     assert.equal(unityFileRelations.length, 0);
-    assert.equal(syntheticResourceFiles.length, 0);
+    assert.ok(unityComponentInstanceRelations.length > 0);
+    assert.ok(syntheticResourceFiles.length > 0);
     assert.ok(unitySummaryRelations.length > 0);
     assert.equal(componentNodes.length, 0);
     assert.ok(result.bindingCount >= symbols.length);
@@ -452,6 +454,69 @@ test('processUnityResources writes UNITY_RESOURCE_SUMMARY for serializable class
     const summaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
     const serializableSummary = summaryRelations.filter((rel) => rel.sourceId === serializableClassId);
     assert.equal(serializableSummary.length, 1);
+    const serializedTypeRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_SERIALIZED_TYPE_IN');
+    assert.equal(serializedTypeRelations.length, 1);
+    const reason = JSON.parse(String(serializedTypeRelations[0]?.reason || '{}'));
+    assert.equal(reason.fieldName, 'assetRef');
+    assert.equal(reason.declaredType, 'AssetRef');
+    assert.equal(reason.hostSymbol, 'HostClass');
+});
+test('processUnityResources writes asset-guid and graph-node reference edges from resolved references', async () => {
+    const graph = createKnowledgeGraph();
+    const hostPath = 'Assets/Scripts/WeaponConfig.cs';
+    const classId = generateId('Class', `${hostPath}:WeaponConfig`);
+    graph.addNode({
+        id: classId,
+        label: 'Class',
+        properties: { name: 'WeaponConfig', filePath: hostPath },
+    });
+    const fakeScanContext = {
+        symbolToScriptPath: new Map([['WeaponConfig', hostPath]]),
+        scriptPathToGuid: new Map([[hostPath, '11111111111111111111111111111111']]),
+        guidToResourceHits: new Map([
+            ['11111111111111111111111111111111', [{ resourcePath: 'Assets/Data/WeaponConfig.asset', resourceType: 'asset', line: 3, lineText: 'guid: 1111' }]],
+        ]),
+        resourceDocCache: new Map(),
+    };
+    await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({
+            symbol: 'WeaponConfig',
+            scriptPath: hostPath,
+            scriptGuid: '11111111111111111111111111111111',
+            resourceBindings: [
+                {
+                    resourcePath: 'Assets/Data/WeaponConfig.asset',
+                    resourceType: 'asset',
+                    bindingKind: 'direct',
+                    componentObjectId: '11400000',
+                    evidence: { line: 3, lineText: 'guid: 1111' },
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [
+                        {
+                            fieldName: 'gungraph',
+                            sourceLayer: 'asset',
+                            fileId: '11400000',
+                            guid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                            fromList: false,
+                            resolution: 'external-asset',
+                            target: { assetPath: 'Assets/Graphs/Weapon.asset' },
+                        },
+                    ],
+                },
+            ],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        }),
+    });
+    const graphNodeRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_GRAPH_NODE_SCRIPT_REF');
+    const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+    assert.equal(graphNodeRefs.length, 1);
+    assert.equal(guidRefs.length, 1);
+    const guidReason = JSON.parse(String(guidRefs[0]?.reason || '{}'));
+    assert.equal(guidReason.guid, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
+    assert.equal(guidReason.targetResourcePath, 'Assets/Graphs/Weapon.asset');
+    assert.equal(guidReason.fieldName, 'gungraph');
 });
 test('processUnityResources writes compact UNITY_RESOURCE_SUMMARY reason by default', async () => {
     const graph = createKnowledgeGraph();

package/dist/core/ingestion/unity-runtime-binding-rules.d.ts

@@ -0,0 +1,11 @@
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { RuntimeClaimRule } from '../../mcp/local/runtime-claim-rule-registry.js';
+import type { UnityConfig } from '../config/unity-config.js';
+export interface UnityRuntimeBindingResult {
+    edgesInjected: number;
+    ruleResults: Array<{
+        ruleId: string;
+        edgesInjected: number;
+    }>;
+}
+export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], _config: UnityConfig): UnityRuntimeBindingResult;