@veewo/gitnexus 1.5.0 → 1.5.2

package/dist/mcp/local/process-confidence.test.js

@@ -11,8 +11,10 @@ describe('process confidence', () => {
     it('deriveConfidence returns medium for method projected rows', () => {
         expect(deriveConfidence({ evidenceMode: 'method_projected' })).toBe('medium');
     });
-    it('deriveConfidence returns low for resource heuristic rows', () => {
-        expect(deriveConfidence({ evidenceMode: 'resource_heuristic', hasPartialUnityEvidence: true })).toBe('low');
+    it('rejects legacy heuristic evidence mode at type/runtime boundary', () => {
+        expect(deriveConfidence({ evidenceMode: 'method_projected' })).toBe('medium');
+        // @ts-expect-error legacy mode removed
+        deriveConfidence({ evidenceMode: 'resource_heuristic' });
     });
     it('buildVerificationHint includes parity retry guidance for low confidence rows', () => {
         const hint = buildVerificationHint({

package/dist/mcp/local/process-evidence.d.ts

@@ -1,4 +1,4 @@
-import { type ProcessConfidence, type ProcessEvidenceMode, type VerificationHint } from './process-confidence.js';
+import { type ProcessConfidence, type ProcessEvidenceMode } from './process-confidence.js';
 import { type RuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
 export interface ProcessEvidenceRow {
     pid: string;
@@ -10,20 +10,13 @@ export interface ProcessEvidenceRow {
 export interface ProjectedProcessEvidenceRow extends ProcessEvidenceRow {
     viaMethodId?: string;
 }
-export interface HeuristicProcessEvidenceRow extends ProcessEvidenceRow {
-    processSubtype?: string;
-    needsParityRetry?: boolean;
-    verificationTarget?: string;
-}
 export interface MergedProcessEvidenceRow extends ProcessEvidenceRow {
     evidence_mode: ProcessEvidenceMode;
     confidence: ProcessConfidence;
     runtime_chain_evidence_level: RuntimeChainEvidenceLevel;
-    verification_hint?: VerificationHint;
 }
 export declare function deriveEvidenceFingerprint(...parts: unknown[]): string;
 export declare function mergeProcessEvidence(input: {
     directRows: ProcessEvidenceRow[];
     projectedRows: ProjectedProcessEvidenceRow[];
-    heuristicRows?: HeuristicProcessEvidenceRow[];
 }): MergedProcessEvidenceRow[];

package/dist/mcp/local/process-evidence.js

@@ -1,4 +1,4 @@
-import { buildVerificationHint, deriveConfidence, } from './process-confidence.js';
+import { deriveConfidence, } from './process-confidence.js';
 import { deriveRuntimeChainEvidenceLevel, } from './runtime-chain-evidence.js';
 function asFingerprintToken(value) {
     if (value === null || value === undefined)
@@ -29,28 +29,6 @@ const normalizeProcessConfidence = (raw, fallback) => {
 };
 export function mergeProcessEvidence(input) {
     const byPid = new Map();
-    for (const row of input.heuristicRows || []) {
-        const confidence = deriveConfidence({
-            evidenceMode: 'resource_heuristic',
-            processSubtype: String(row.processSubtype || ''),
-            hasPartialUnityEvidence: true,
-        });
-        byPid.set(row.pid, {
-            ...row,
-            pid: row.pid,
-            label: row.label,
-            step: row.step,
-            stepCount: row.stepCount,
-            evidence_mode: 'resource_heuristic',
-            confidence,
-            runtime_chain_evidence_level: deriveRuntimeChainEvidenceLevel({ mode: 'heuristic_clue' }),
-            verification_hint: buildVerificationHint({
-                confidence,
-                needsParityRetry: Boolean(row.needsParityRetry),
-                target: row.verificationTarget || row.label || row.pid,
-            }),
-        });
-    }
     for (const row of input.projectedRows) {
         byPid.set(row.pid, {
             ...row,

package/dist/mcp/local/process-evidence.test.js

@@ -33,26 +33,12 @@ test('direct rows dominate projected rows for same process id', () => {
     assert.equal(out[0].evidence_mode, 'direct_step');
     assert.equal(out[0].confidence, 'high');
 });
-test('heuristic-only rows emit low confidence with verification hint', () => {
+test('mergeProcessEvidence never emits resource_heuristic rows', () => {
     const out = mergeProcessEvidence({
         directRows: [],
         projectedRows: [],
-        heuristicRows: [
-            {
-                pid: 'proc:reload-clue',
-                label: 'Reload runtime clue',
-                step: 0,
-                stepCount: 0,
-                processSubtype: 'unity_lifecycle',
-                needsParityRetry: true,
-                verificationTarget: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
-            },
-        ],
     });
-    assert.equal(out[0].evidence_mode, 'resource_heuristic');
-    assert.equal(out[0].confidence, 'low');
-    assert.equal(out[0].verification_hint?.action, 'rerun_parity_hydration');
-    assert.match(out[0].verification_hint?.next_command || '', /parity/i);
+    assert.equal(out.some((row) => String(row.evidence_mode) === 'resource_heuristic'), false);
 });
 test('deriveEvidenceFingerprint is stable for same input ordering', () => {
     const left = deriveEvidenceFingerprint({ resourcePath: 'Assets/A.prefab', bindingKind: 'component', line: 10 }, { pid: 'proc:123', step: 1 });

package/dist/mcp/local/process-ref.d.ts

@@ -1,5 +1,5 @@
 export type ProcessRefKind = 'persistent' | 'derived';
-export type ProcessRefOrigin = 'step_in_process' | 'method_projected' | 'resource_heuristic';
+export type ProcessRefOrigin = 'step_in_process' | 'method_projected';
 export interface ProcessRef {
     id: string;
     kind: ProcessRefKind;

package/dist/mcp/local/runtime-chain-closure-evaluator.d.ts

@@ -0,0 +1,33 @@
+import type { RuntimeGraphCandidate } from './runtime-chain-graph-candidates.js';
+type RuntimeChainStatus = 'pending' | 'verified_partial' | 'verified_full' | 'failed';
+type RuntimeChainEvidenceLevel = 'none' | 'clue' | 'verified_segment' | 'verified_chain';
+interface RuntimeChainGap {
+    segment: 'resource' | 'guid_map' | 'loader' | 'runtime';
+    reason: string;
+    next_command: string;
+    why_not_next?: string;
+}
+export interface RuntimeClosureEvaluation {
+    status: RuntimeChainStatus;
+    evidence_level: RuntimeChainEvidenceLevel;
+    gaps: RuntimeChainGap[];
+    segments: {
+        anchor: boolean;
+        bind: boolean;
+        bridge: boolean;
+        runtime: boolean;
+    };
+}
+interface EvaluateRuntimeClosureInput {
+    queryText?: string;
+    symbolName?: string;
+    resourceSeedPath?: string;
+    mappedSeedTargets?: string[];
+    resourceBindings?: Array<{
+        resourcePath?: string;
+    }>;
+    candidates: RuntimeGraphCandidate[];
+    nextCommand: string;
+}
+export declare function evaluateRuntimeClosure(input: EvaluateRuntimeClosureInput): RuntimeClosureEvaluation;
+export {};

package/dist/mcp/local/runtime-chain-closure-evaluator.js

@@ -0,0 +1,273 @@
+function normalize(value) {
+    return String(value || '').trim().toLowerCase();
+}
+function tokenize(value) {
+    return normalize(value)
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+function normalizeLoose(value) {
+    return normalize(value).replace(/[^a-z0-9]+/g, '');
+}
+function basenameStem(value) {
+    const text = String(value || '').trim();
+    if (!text)
+        return '';
+    const parts = text.split(/[\\/]/);
+    const base = parts[parts.length - 1] || '';
+    const stem = base.replace(/\.[^.]+$/, '');
+    return normalize(stem);
+}
+function isBridgeCandidate(candidate) {
+    const reason = normalize(candidate.reason);
+    return reason.includes('bridge') || reason.startsWith('unity-rule-');
+}
+function isAnchoredEndpoint(input, endpoint) {
+    const symbolName = normalize(input.symbolName);
+    if (!symbolName)
+        return false;
+    const looseSymbol = normalizeLoose(symbolName);
+    if (normalize(endpoint.name) === symbolName)
+        return true;
+    const anchoredNeighborhood = [endpoint.id, endpoint.filePath];
+    return anchoredNeighborhood.some((value) => normalizeLoose(value).includes(looseSymbol));
+}
+function candidateNodeKey(endpoint) {
+    const id = normalize(endpoint.id);
+    if (id)
+        return `id:${id}`;
+    const name = normalize(endpoint.name);
+    if (!name)
+        return '';
+    const filePath = normalize(endpoint.filePath);
+    return filePath ? `nf:${name}@${filePath}` : `n:${name}`;
+}
+function collectAnchorNodeKeys(input) {
+    const anchorKeys = new Set();
+    for (const candidate of input.candidates) {
+        const sourceKey = candidateNodeKey({
+            id: candidate.sourceId,
+            name: candidate.sourceName,
+            filePath: candidate.sourceFilePath,
+        });
+        const targetKey = candidateNodeKey({
+            id: candidate.targetId,
+            name: candidate.targetName,
+            filePath: candidate.targetFilePath,
+        });
+        if (sourceKey
+            && isAnchoredEndpoint(input, {
+                name: candidate.sourceName,
+                id: candidate.sourceId,
+                filePath: candidate.sourceFilePath,
+            })) {
+            anchorKeys.add(sourceKey);
+        }
+        if (targetKey
+            && isAnchoredEndpoint(input, {
+                name: candidate.targetName,
+                id: candidate.targetId,
+                filePath: candidate.targetFilePath,
+            })) {
+            anchorKeys.add(targetKey);
+        }
+    }
+    return anchorKeys;
+}
+function evaluateAnchorSegment(input) {
+    return collectAnchorNodeKeys(input).size > 0;
+}
+function evaluateBindSegment(input) {
+    const seedPath = normalize(input.resourceSeedPath);
+    if (!seedPath)
+        return false;
+    const mapped = new Set((input.mappedSeedTargets || []).map((value) => normalize(value)).filter(Boolean));
+    const bindings = new Set((input.resourceBindings || []).map((binding) => normalize(binding.resourcePath)).filter(Boolean));
+    if (bindings.has(seedPath))
+        return true;
+    if (mapped.size === 0)
+        return false;
+    const mappedStems = new Set(Array.from(mapped).map((value) => basenameStem(value)).filter(Boolean));
+    for (const binding of bindings) {
+        if (mapped.has(binding))
+            return true;
+        const bindingStem = basenameStem(binding);
+        if (bindingStem && mappedStems.has(bindingStem))
+            return true;
+    }
+    return false;
+}
+function evaluateBridgeSegment(input, anchorSatisfied) {
+    if (!anchorSatisfied)
+        return false;
+    return input.candidates.some((candidate) => isBridgeCandidate(candidate));
+}
+function evaluateRuntimeSegment(input) {
+    const anchorKeys = collectAnchorNodeKeys(input);
+    if (anchorKeys.size === 0)
+        return false;
+    const adjacency = new Map();
+    const edgeByPair = new Map();
+    for (const candidate of input.candidates) {
+        const sourceKey = candidateNodeKey({
+            id: candidate.sourceId,
+            name: candidate.sourceName,
+            filePath: candidate.sourceFilePath,
+        });
+        const targetKey = candidateNodeKey({
+            id: candidate.targetId,
+            name: candidate.targetName,
+            filePath: candidate.targetFilePath,
+        });
+        if (!sourceKey || !targetKey)
+            continue;
+        const sourceNeighbors = adjacency.get(sourceKey) || new Set();
+        sourceNeighbors.add(targetKey);
+        adjacency.set(sourceKey, sourceNeighbors);
+        const targetNeighbors = adjacency.get(targetKey) || new Set();
+        targetNeighbors.add(sourceKey);
+        adjacency.set(targetKey, targetNeighbors);
+        const pair = [sourceKey, targetKey].sort().join('||');
+        const existing = edgeByPair.get(pair) || { bridge: false, runtime: false };
+        const bridge = isBridgeCandidate(candidate);
+        edgeByPair.set(pair, {
+            bridge: existing.bridge || bridge,
+            runtime: existing.runtime || !bridge,
+        });
+    }
+    const seenNodes = new Set();
+    for (const node of anchorKeys) {
+        if (seenNodes.has(node))
+            continue;
+        const queue = [node];
+        seenNodes.add(node);
+        const componentNodes = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            componentNodes.push(current);
+            const neighbors = adjacency.get(current) || new Set();
+            for (const neighbor of neighbors) {
+                if (seenNodes.has(neighbor))
+                    continue;
+                seenNodes.add(neighbor);
+                queue.push(neighbor);
+            }
+        }
+        let hasBridge = false;
+        let hasRuntime = false;
+        for (const componentNode of componentNodes) {
+            const neighbors = adjacency.get(componentNode) || new Set();
+            for (const neighbor of neighbors) {
+                const pair = [componentNode, neighbor].sort().join('||');
+                const edge = edgeByPair.get(pair);
+                if (!edge)
+                    continue;
+                if (edge.bridge)
+                    hasBridge = true;
+                if (edge.runtime)
+                    hasRuntime = true;
+            }
+            if (hasBridge && hasRuntime)
+                return true;
+        }
+    }
+    return false;
+}
+function hasAnchorIntersection(input) {
+    const symbolTokens = new Set(tokenize(input.symbolName));
+    if (symbolTokens.size === 0)
+        return false;
+    const resourceTokens = new Set([
+        ...tokenize(input.resourceSeedPath),
+        ...(input.mappedSeedTargets || []).flatMap((value) => tokenize(value)),
+        ...(input.resourceBindings || []).flatMap((binding) => tokenize(binding.resourcePath)),
+    ]);
+    if (resourceTokens.size === 0)
+        return false;
+    for (const token of symbolTokens) {
+        if (resourceTokens.has(token))
+            return true;
+    }
+    return false;
+}
+function hasUbiquitousRuntimeSignal(input) {
+    const ubiquitous = new Set(['getcomponent', 'awake', 'start', 'update', 'lateupdate', 'fixedupdate', 'onenable']);
+    return input.candidates.some((candidate) => {
+        const source = normalize(candidate.sourceName);
+        const target = normalize(candidate.targetName);
+        return ubiquitous.has(source) || ubiquitous.has(target);
+    });
+}
+export function evaluateRuntimeClosure(input) {
+    const anchor = evaluateAnchorSegment(input);
+    const bind = evaluateBindSegment(input);
+    const bridge = evaluateBridgeSegment(input, anchor);
+    const runtime = evaluateRuntimeSegment(input);
+    const anchorIntersection = hasAnchorIntersection(input);
+    const ubiquitousRuntimeSignal = hasUbiquitousRuntimeSignal(input);
+    const segments = { anchor, bind, bridge, runtime };
+    const allSatisfied = anchor && bind && bridge && runtime;
+    const precisionPenalty = allSatisfied && !anchorIntersection && ubiquitousRuntimeSignal;
+    const anySatisfied = anchor || bind || bridge || runtime;
+    const gaps = [];
+    if (!anchor) {
+        gaps.push({
+            segment: 'loader',
+            reason: 'anchor segment missing',
+            next_command: input.nextCommand,
+        });
+    }
+    if (!bind) {
+        gaps.push({
+            segment: 'guid_map',
+            reason: 'bind segment missing',
+            next_command: input.nextCommand,
+        });
+    }
+    if (!bridge) {
+        gaps.push({
+            segment: 'loader',
+            reason: 'bridge segment missing',
+            next_command: input.nextCommand,
+        });
+    }
+    if (!runtime) {
+        gaps.push({
+            segment: 'runtime',
+            reason: 'runtime segment missing',
+            next_command: input.nextCommand,
+        });
+    }
+    if (precisionPenalty) {
+        gaps.push({
+            segment: 'loader',
+            reason: 'anchor intersection absent; downgraded for precision-first policy',
+            next_command: input.nextCommand,
+        });
+    }
+    if (allSatisfied && !precisionPenalty) {
+        return {
+            status: 'verified_full',
+            evidence_level: 'verified_chain',
+            gaps: [],
+            segments,
+        };
+    }
+    if (anySatisfied) {
+        return {
+            status: 'verified_partial',
+            evidence_level: 'verified_segment',
+            gaps,
+            segments,
+        };
+    }
+    return {
+        status: 'failed',
+        evidence_level: 'none',
+        gaps,
+        segments,
+    };
+}

package/dist/mcp/local/runtime-chain-graph-candidates.d.ts

@@ -0,0 +1,23 @@
+interface QueryExecutor {
+    (query: string, params?: Record<string, unknown>): Promise<any[]>;
+}
+interface GraphCandidateInput {
+    executeParameterized: QueryExecutor;
+    symbolName?: string;
+    symbolFilePath?: string;
+    maxSymbols?: number;
+    maxEdgesPerSymbol?: number;
+}
+export interface RuntimeGraphCandidate {
+    sourceId?: string;
+    sourceName: string;
+    sourceFilePath?: string;
+    sourceStartLine?: number;
+    targetId?: string;
+    targetName: string;
+    targetFilePath?: string;
+    targetStartLine?: number;
+    reason?: string;
+}
+export declare function extractRuntimeGraphCandidates(input: GraphCandidateInput): Promise<RuntimeGraphCandidate[]>;
+export {};

package/dist/mcp/local/runtime-chain-graph-candidates.js

@@ -0,0 +1,131 @@
+function normalizeName(value) {
+    return String(value || '').trim();
+}
+function dedupeCandidates(candidates) {
+    const out = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const source = normalizeName(candidate.sourceId) || `${normalizeName(candidate.sourceName)}@${normalizeName(candidate.sourceFilePath)}`;
+        const target = normalizeName(candidate.targetId) || `${normalizeName(candidate.targetName)}@${normalizeName(candidate.targetFilePath)}`;
+        const key = `${source}->${target}`;
+        if (!source || !target || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(candidate);
+    }
+    return out;
+}
+async function resolveAnchorSymbols(input) {
+    const symbolName = normalizeName(input.symbolName);
+    if (!symbolName)
+        return [];
+    const maxSymbols = Math.max(1, Number(input.maxSymbols || 8));
+    const symbolFilePath = normalizeName(input.symbolFilePath);
+    if (symbolFilePath) {
+        const byFile = await input.executeParameterized(`
+      MATCH (n)
+      WHERE n.filePath = $filePath AND n.name = $symbolName
+      RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.startLine AS startLine
+      LIMIT ${maxSymbols}
+    `, { filePath: symbolFilePath, symbolName });
+        if (Array.isArray(byFile) && byFile.length > 0) {
+            return byFile.map((row) => ({
+                id: normalizeName(row.id),
+                name: normalizeName(row.name),
+                filePath: normalizeName(row.filePath) || undefined,
+                startLine: Number(row.startLine || 1),
+            })).filter((row) => row.id && row.name);
+        }
+    }
+    const byName = await input.executeParameterized(`
+    MATCH (n)
+    WHERE n.name IN $symbolNames
+    RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.startLine AS startLine
+    LIMIT ${maxSymbols}
+  `, { symbolNames: [symbolName] });
+    return (Array.isArray(byName) ? byName : [])
+        .map((row) => ({
+        id: normalizeName(row.id),
+        name: normalizeName(row.name),
+        filePath: normalizeName(row.filePath) || undefined,
+        startLine: Number(row.startLine || 1),
+    }))
+        .filter((row) => row.id && row.name);
+}
+function toCandidate(row) {
+    const sourceName = normalizeName(row.sourceName);
+    const targetName = normalizeName(row.targetName);
+    if (!sourceName || !targetName)
+        return undefined;
+    return {
+        sourceId: normalizeName(row.sourceId) || undefined,
+        sourceName,
+        sourceFilePath: normalizeName(row.sourceFilePath) || undefined,
+        sourceStartLine: Number(row.sourceStartLine || 1),
+        targetId: normalizeName(row.targetId) || undefined,
+        targetName,
+        targetFilePath: normalizeName(row.targetFilePath) || undefined,
+        targetStartLine: Number(row.targetStartLine || 1),
+        reason: normalizeName(row.reason) || undefined,
+    };
+}
+export async function extractRuntimeGraphCandidates(input) {
+    const anchors = await resolveAnchorSymbols(input);
+    if (anchors.length === 0)
+        return [];
+    const maxEdgesPerSymbol = Math.max(1, Number(input.maxEdgesPerSymbol || 16));
+    const rawCandidates = [];
+    for (const symbol of anchors) {
+        const directRows = await input.executeParameterized(`
+      MATCH (s {id: $symbolId})-[r:CodeRelation {type: 'CALLS'}]->(t)
+      RETURN s.id AS sourceId, s.name AS sourceName, s.filePath AS sourceFilePath, s.startLine AS sourceStartLine,
+             t.id AS targetId, t.name AS targetName, t.filePath AS targetFilePath, t.startLine AS targetStartLine,
+             r.reason AS reason
+      LIMIT ${maxEdgesPerSymbol}
+    `, { symbolId: symbol.id });
+        for (const row of Array.isArray(directRows) ? directRows : []) {
+            const candidate = toCandidate(row);
+            if (candidate)
+                rawCandidates.push(candidate);
+        }
+        const methodRows = await input.executeParameterized(`
+      MATCH (n {id: $symbolId})-[:CodeRelation {type: 'HAS_METHOD'}]->(m)
+      MATCH (m)-[r:CodeRelation {type: 'CALLS'}]->(t)
+      RETURN m.id AS sourceId, m.name AS sourceName, m.filePath AS sourceFilePath, m.startLine AS sourceStartLine,
+             t.id AS targetId, t.name AS targetName, t.filePath AS targetFilePath, t.startLine AS targetStartLine,
+             r.reason AS reason
+      LIMIT ${maxEdgesPerSymbol}
+    `, { symbolId: symbol.id });
+        for (const row of Array.isArray(methodRows) ? methodRows : []) {
+            const candidate = toCandidate(row);
+            if (candidate)
+                rawCandidates.push(candidate);
+        }
+        const incomingClassRows = await input.executeParameterized(`
+      MATCH (caller)-[r:CodeRelation {type: 'CALLS'}]->(s {id: $symbolId})
+      RETURN caller.id AS sourceId, caller.name AS sourceName, caller.filePath AS sourceFilePath, caller.startLine AS sourceStartLine,
+             s.id AS targetId, s.name AS targetName, s.filePath AS targetFilePath, s.startLine AS targetStartLine,
+             r.reason AS reason
+      LIMIT ${maxEdgesPerSymbol}
+    `, { symbolId: symbol.id });
+        for (const row of Array.isArray(incomingClassRows) ? incomingClassRows : []) {
+            const candidate = toCandidate(row);
+            if (candidate)
+                rawCandidates.push(candidate);
+        }
+        const incomingMethodRows = await input.executeParameterized(`
+      MATCH (n {id: $symbolId})-[:CodeRelation {type: 'HAS_METHOD'}]->(m)
+      MATCH (caller)-[r:CodeRelation {type: 'CALLS'}]->(m)
+      RETURN caller.id AS sourceId, caller.name AS sourceName, caller.filePath AS sourceFilePath, caller.startLine AS sourceStartLine,
+             m.id AS targetId, m.name AS targetName, m.filePath AS targetFilePath, m.startLine AS targetStartLine,
+             r.reason AS reason
+      LIMIT ${maxEdgesPerSymbol}
+    `, { symbolId: symbol.id });
+        for (const row of Array.isArray(incomingMethodRows) ? incomingMethodRows : []) {
+            const candidate = toCandidate(row);
+            if (candidate)
+                rawCandidates.push(candidate);
+        }
+    }
+    return dedupeCandidates(rawCandidates);
+}

package/dist/mcp/local/runtime-chain-verify.d.ts

@@ -1,6 +1,6 @@
 import type { RuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
 import { type RuntimeClaim } from './runtime-claim.js';
-import { type RuntimeClaimRule } from './runtime-claim-rule-registry.js';
+import type { RuntimeClaimRule } from './runtime-claim-rule-registry.js';
 export type RuntimeChainVerifyMode = 'off' | 'on-demand';
 export type RuntimeChainStatus = 'pending' | 'verified_partial' | 'verified_full' | 'failed';
 export type RuntimeChainHopType = 'resource' | 'guid_map' | 'code_loader' | 'code_runtime';