@veewo/gitnexus 1.4.8-rc.2 → 1.4.9-rc

package/dist/cli/index.js

@@ -82,6 +82,7 @@ program
     .option('-g, --goal <text>', 'What you want to find')
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
+    .option('--scope-preset <preset>', 'Scope preset for retrieval: unity-gameplay|unity-all')
     .option('--unity-resources <mode>', 'Unity resource retrieval mode: off|on|auto', 'off')
     .option('--unity-hydration <mode>', 'Unity hydration mode when resources are enabled: parity|compact', 'compact')
     .action(createLazyAction(() => import('./tool.js'), 'queryCommand'));
@@ -101,6 +102,13 @@ program
     .option('--target-path <path>', 'Unity project root (default: cwd)')
     .option('--json', 'Output JSON')
     .action(createLazyAction(() => import('./unity-bindings.js'), 'unityBindingsCommand'));
+program
+    .command('unity-ui-trace <target>')
+    .description('Query-time Unity UI evidence tracing (asset_refs|template_refs|selector_bindings)')
+    .option('-r, --repo <name>', 'Target repository (omit if only one indexed)')
+    .option('--goal <goal>', 'Trace goal: asset_refs|template_refs|selector_bindings', 'asset_refs')
+    .option('--selector-mode <mode>', 'Selector matching mode for selector_bindings: strict|balanced', 'balanced')
+    .action(createLazyAction(() => import('./tool.js'), 'unityUiTraceCommand'));
 program
     .command('impact <target>')
     .description('Blast radius analysis: what breaks if you change a symbol')

package/dist/cli/tool.d.ts

@@ -21,6 +21,7 @@ export declare function queryCommand(queryText: string, options?: {
     goal?: string;
     limit?: string;
     content?: boolean;
+    scopePreset?: 'unity-gameplay' | 'unity-all';
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
 }): Promise<void>;
@@ -44,3 +45,13 @@ export declare function impactCommand(target: string, options?: {
 export declare function cypherCommand(query: string, options?: {
     repo?: string;
 }): Promise<void>;
+export declare function unityUiTraceCommand(target: string, options?: {
+    repo?: string;
+    goal?: string;
+    selectorMode?: string;
+}, deps?: {
+    backend?: {
+        callTool: (method: string, params: any) => Promise<any>;
+    };
+    output?: (data: any) => void;
+}): Promise<void>;

package/dist/cli/tool.js

@@ -53,6 +53,12 @@ function output(data) {
         process.stderr.write(text + '\n');
     }
 }
+function isUnityUiTraceGoal(value) {
+    return value === 'asset_refs' || value === 'template_refs' || value === 'selector_bindings';
+}
+function isUnityUiSelectorMode(value) {
+    return value === 'strict' || value === 'balanced';
+}
 export async function queryCommand(queryText, options) {
     if (!queryText?.trim()) {
         console.error('Usage: gitnexus query <search_query>');
@@ -65,6 +71,7 @@ export async function queryCommand(queryText, options) {
         goal: options?.goal,
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
+        scope_preset: options?.scopePreset,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
         repo: options?.repo,
@@ -130,3 +137,27 @@ export async function cypherCommand(query, options) {
     });
     output(result);
 }
+export async function unityUiTraceCommand(target, options, deps) {
+    if (!target?.trim()) {
+        console.error('Usage: gitnexus unity-ui-trace <target> --goal asset_refs|template_refs|selector_bindings');
+        process.exit(1);
+    }
+    const goal = String(options?.goal || 'asset_refs').trim();
+    if (!isUnityUiTraceGoal(goal)) {
+        console.error('Invalid --goal. Use one of: asset_refs, template_refs, selector_bindings');
+        process.exit(1);
+    }
+    const selectorMode = String(options?.selectorMode || 'balanced').trim();
+    if (!isUnityUiSelectorMode(selectorMode)) {
+        console.error('Invalid --selector-mode. Use one of: strict, balanced');
+        process.exit(1);
+    }
+    const backend = deps?.backend || await getBackend();
+    const result = await backend.callTool('unity_ui_trace', {
+        target,
+        goal,
+        selector_mode: selectorMode,
+        repo: options?.repo,
+    });
+    (deps?.output || output)(result);
+}

package/dist/cli/unity-ui-trace.test.d.ts

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

package/dist/cli/unity-ui-trace.test.js

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { unityUiTraceCommand } from './tool.js';
+test('unity-ui-trace command forwards params and prints result', async () => {
+    const calls = [];
+    let printed = null;
+    await unityUiTraceCommand('EliteBossScreenController', { goal: 'selector_bindings', selectorMode: 'strict', repo: 'mini-unity-ui' }, {
+        backend: {
+            async callTool(method, params) {
+                calls.push({ method, params });
+                return { goal: 'selector_bindings', results: [{ evidence_chain: [{ path: 'a', line: 1 }] }], diagnostics: [] };
+            },
+        },
+        output: (value) => {
+            printed = value;
+        },
+    });
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].method, 'unity_ui_trace');
+    assert.equal(calls[0].params.target, 'EliteBossScreenController');
+    assert.equal(calls[0].params.goal, 'selector_bindings');
+    assert.equal(calls[0].params.selector_mode, 'strict');
+    assert.equal(printed.goal, 'selector_bindings');
+});

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

@@ -35,7 +35,15 @@ const findEnclosingFunction = (node, filePath, ctx) => {
  */
 const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
     const verified = new Map();
-    for (const { scope, varName, calleeName, receiverClassName } of bindings) {
+    for (const { scope, varName, calleeName, receiverClassName, inferredTypeName } of bindings) {
+        if (inferredTypeName) {
+            const inferred = ctx.resolve(inferredTypeName, filePath);
+            const isReceivableType = inferred?.candidates.some(def => def.type === 'Class' || def.type === 'Interface' || def.type === 'Struct' || def.type === 'Enum') ?? false;
+            if (isReceivableType) {
+                verified.set(receiverKey(scope, varName), inferredTypeName);
+                continue;
+            }
+        }
         const tiered = ctx.resolve(calleeName, filePath);
         const isClass = tiered?.candidates.some(def => def.type === 'Class') ?? false;
         if (isClass) {

package/dist/core/ingestion/type-env.d.ts

@@ -46,4 +46,6 @@ export interface ConstructorBinding {
     calleeName: string;
     /** Enclosing class name when callee is a method on a known receiver (e.g. $this) */
     receiverClassName?: string;
+    /** Optional direct type hint extracted from safe generic invocation patterns. */
+    inferredTypeName?: string;
 }

package/dist/core/ingestion/type-extractors/csharp.js

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
+import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
 /** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
 const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([
@@ -145,7 +145,22 @@ const scanConstructorBinding = (node) => {
     const calleeName = extractSimpleTypeName(func);
     if (!calleeName)
         return undefined;
-    return { varName: nameNode.text, calleeName };
+    // Safe generic-invocation receiver hint:
+    //   var user = GetComponentInParent<User>()
+    //   var user = svc.GetComponentInParent<User>()
+    // infer user -> User directly from the single type argument.
+    let inferredTypeName;
+    const genericCallee = func.type === 'generic_name'
+        ? func
+        : func.type === 'member_access_expression'
+            ? func.childForFieldName('name')
+            : null;
+    if (genericCallee?.type === 'generic_name') {
+        const typeArgs = extractGenericTypeArgs(genericCallee);
+        if (typeArgs.length === 1)
+            inferredTypeName = typeArgs[0];
+    }
+    return { varName: nameNode.text, calleeName, inferredTypeName };
 };
 const FOR_LOOP_NODE_TYPES = new Set([
     'foreach_statement',

package/dist/core/ingestion/type-extractors/types.d.ts

@@ -13,11 +13,14 @@ export type InitializerExtractor = (node: SyntaxNode, env: Map<string, string>,
 /** Scans an AST node for untyped `var = callee()` patterns for return-type inference.
  *  Returns { varName, calleeName } if the node matches, undefined otherwise.
  *  `receiverClassName` — optional hint for method calls on known receivers
- *  (e.g. $this->getUser() in PHP provides the enclosing class name). */
+ *  (e.g. $this->getUser() in PHP provides the enclosing class name).
+ *  `inferredTypeName` — optional direct type hint from safe generic invocations
+ *  (e.g. `var x = GetComponentInParent<User>()` gives `User`). */
 export type ConstructorBindingScanner = (node: SyntaxNode) => {
     varName: string;
     calleeName: string;
     receiverClassName?: string;
+    inferredTypeName?: string;
 } | undefined;
 /** Extracts a return type string from a method/function definition node.
  *  Used for languages where return types are expressed in comments (e.g. YARD @return [Type])

package/dist/core/unity/csharp-selector-binding.d.ts

@@ -0,0 +1,7 @@
+export interface CsharpSelectorBinding {
+    className: string;
+    line: number;
+    snippet: string;
+    isDynamic: boolean;
+}
+export declare function extractCsharpSelectorBindings(content: string): CsharpSelectorBinding[];

package/dist/core/unity/csharp-selector-binding.js

@@ -0,0 +1,32 @@
+const ADD_TO_CLASS_LIST_LITERAL = /\bAddToClassList\s*\(\s*"([^"]+)"\s*\)/g;
+const Q_CLASS_NAME_LITERAL = /\bQ\s*<[^>]*>\s*\([^)]*\bclassName\s*:\s*"([^"]+)"[^)]*\)/g;
+export function extractCsharpSelectorBindings(content) {
+    const out = [];
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        ADD_TO_CLASS_LIST_LITERAL.lastIndex = 0;
+        let addMatch = ADD_TO_CLASS_LIST_LITERAL.exec(line);
+        while (addMatch) {
+            out.push({
+                className: addMatch[1],
+                line: i + 1,
+                snippet: line.trim(),
+                isDynamic: false,
+            });
+            addMatch = ADD_TO_CLASS_LIST_LITERAL.exec(line);
+        }
+        Q_CLASS_NAME_LITERAL.lastIndex = 0;
+        let qMatch = Q_CLASS_NAME_LITERAL.exec(line);
+        while (qMatch) {
+            out.push({
+                className: qMatch[1],
+                line: i + 1,
+                snippet: line.trim(),
+                isDynamic: false,
+            });
+            qMatch = Q_CLASS_NAME_LITERAL.exec(line);
+        }
+    }
+    return out;
+}

package/dist/core/unity/csharp-selector-binding.test.d.ts

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

package/dist/core/unity/csharp-selector-binding.test.js

@@ -0,0 +1,14 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { extractCsharpSelectorBindings } from './csharp-selector-binding.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity-ui');
+test('extracts static-only selector bindings from csharp', async () => {
+    const source = await fs.readFile(path.join(fixtureRoot, 'Assets/Scripts/EliteBossScreenController.cs'), 'utf-8');
+    const bindings = extractCsharpSelectorBindings(source);
+    assert.equal(bindings.some((entry) => entry.className === 'tooltip-box'), true);
+    assert.equal(bindings.some((entry) => entry.isDynamic), false);
+});

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

@@ -19,6 +19,8 @@ export interface UnityScanContext {
     serializableSymbols: Set<string>;
     hostFieldTypeHints: Map<string, Map<string, string>>;
     assetGuidToPath?: Map<string, string>;
+    uxmlGuidToPath?: Map<string, string>;
+    ussGuidToPath?: Map<string, string>;
     resourceDocCache: Map<string, UnityObjectBlock[]>;
 }
 export declare function buildUnityScanContext(input: BuildScanContextInput): Promise<UnityScanContext>;

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

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { glob } from 'glob';
 import { buildAssetMetaIndex, buildMetaIndex } from './meta-index.js';
+import { buildUnityUiMetaIndex } from './ui-meta-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 SCRIPT_GUID_IN_LINE_PATTERN = /\bm_Script\s*:\s*\{[^}]*\bguid\s*:\s*([0-9a-f]{32})\b/gi;
@@ -32,6 +33,7 @@ export async function buildUnityScanContext(input) {
     const guidToResourceHits = await buildGuidHitIndex(input.repoRoot, scriptPathToGuid, resourceFiles);
     const assetMetaFiles = resolveAssetMetaFiles(input.repoRoot, input.scopedPaths, scriptFiles, resourceFiles);
     const assetGuidToPath = await buildAssetMetaIndex(input.repoRoot, { metaFiles: assetMetaFiles });
+    const uiMetaIndex = await buildUnityUiMetaIndex(input.repoRoot, { scopedPaths: input.scopedPaths });
     const symbolToCanonicalScriptPath = buildCanonicalScriptPathIndex(symbolToScriptPaths, scriptPathToGuid, guidToResourceHits);
     const symbolToScriptPath = new Map(symbolToCanonicalScriptPath);
     return {
@@ -43,6 +45,8 @@ export async function buildUnityScanContext(input) {
         serializableSymbols: serializableTypeIndex.serializableSymbols,
         hostFieldTypeHints: serializableTypeIndex.hostFieldTypeHints,
         assetGuidToPath,
+        uxmlGuidToPath: uiMetaIndex.uxmlGuidToPath,
+        ussGuidToPath: uiMetaIndex.ussGuidToPath,
         resourceDocCache: new Map(),
     };
 }
@@ -114,11 +118,22 @@ export function buildUnityScanContextFromSeed(input) {
         }
     }
     const assetGuidToPath = new Map();
+    const uxmlGuidToPath = new Map();
+    const ussGuidToPath = 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);
+        assetGuidToPath.set(guid.toLowerCase(), normalizedPath);
+        if (normalizedPath.endsWith('.uxml')) {
+            uxmlGuidToPath.set(guid, normalizedPath);
+            uxmlGuidToPath.set(guid.toLowerCase(), normalizedPath);
+        }
+        if (normalizedPath.endsWith('.uss')) {
+            ussGuidToPath.set(guid, normalizedPath);
+            ussGuidToPath.set(guid.toLowerCase(), normalizedPath);
+        }
     }
     return {
         symbolToScriptPaths,
@@ -129,6 +144,8 @@ export function buildUnityScanContextFromSeed(input) {
         serializableSymbols: new Set(),
         hostFieldTypeHints: new Map(),
         assetGuidToPath,
+        uxmlGuidToPath,
+        ussGuidToPath,
         resourceDocCache: new Map(),
     };
 }

package/dist/core/unity/ui-asset-ref-scanner.d.ts

@@ -0,0 +1,14 @@
+export interface UiAssetRefEvidence {
+    sourceType: 'prefab' | 'asset';
+    sourcePath: string;
+    line: number;
+    fieldName: string;
+    guid: string;
+    snippet: string;
+}
+export interface ScanUiAssetRefInput {
+    repoRoot: string;
+    scopedPaths?: string[];
+    targetGuids?: string[];
+}
+export declare function scanUiAssetRefs(input: ScanUiAssetRefInput): Promise<UiAssetRefEvidence[]>;

package/dist/core/unity/ui-asset-ref-scanner.js

@@ -0,0 +1,213 @@
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+import { glob } from 'glob';
+const YAML_INLINE_GUID_PATTERN = /\bguid\s*:\s*([0-9a-f]{32})\b/i;
+const YAML_FIELD_OPEN_PATTERN = /^\s*([A-Za-z0-9_]+)\s*:\s*\{/;
+const YAML_INLINE_FIELD_PATTERN = /^\s*([A-Za-z0-9_]+)\s*:\s*\{[^}]*\bguid\s*:\s*([0-9a-f]{32})\b[^}]*\}/i;
+const SCAN_CONCURRENCY = 8;
+export async function scanUiAssetRefs(input) {
+    const resourceFiles = await resolveFiles(input.repoRoot, input.scopedPaths);
+    const guidFilter = toGuidFilter(input.targetGuids);
+    const candidateFiles = guidFilter && guidFilter.size > 0
+        ? await findCandidateFilesByGuid(input.repoRoot, resourceFiles, guidFilter)
+        : resourceFiles;
+    const perFile = await mapWithConcurrency(candidateFiles, SCAN_CONCURRENCY, async (resourcePath) => {
+        const sourceType = resourcePath.endsWith('.prefab') ? 'prefab' : 'asset';
+        return scanResourceFileForGuidRefs(input.repoRoot, resourcePath, sourceType, guidFilter);
+    });
+    const all = [];
+    for (const entries of perFile) {
+        all.push(...entries);
+    }
+    return all;
+}
+async function findCandidateFilesByGuid(repoRoot, resourceFiles, guidFilter) {
+    const candidates = await mapWithConcurrency(resourceFiles, SCAN_CONCURRENCY, async (resourcePath) => {
+        const absolutePath = path.join(repoRoot, resourcePath);
+        const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+        const reader = createInterface({ input: stream, crlfDelay: Infinity });
+        try {
+            for await (const line of reader) {
+                const lower = line.toLowerCase();
+                for (const guid of guidFilter) {
+                    if (lower.includes(guid))
+                        return resourcePath;
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT' || code === 'EISDIR')
+                return null;
+            throw error;
+        }
+        finally {
+            reader.close();
+            stream.destroy();
+        }
+    });
+    return candidates
+        .filter((value) => Boolean(value))
+        .sort((left, right) => left.localeCompare(right));
+}
+async function scanResourceFileForGuidRefs(repoRoot, resourcePath, sourceType, guidFilter) {
+    const absolutePath = path.join(repoRoot, resourcePath);
+    const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+    const reader = createInterface({ input: stream, crlfDelay: Infinity });
+    const out = [];
+    let lineNumber = 0;
+    let currentField = '';
+    let currentStartLine = 0;
+    let currentLines = [];
+    let currentGuidLine = 0;
+    let braceDepth = 0;
+    const flushCurrentBlock = () => {
+        if (!currentField || currentLines.length === 0) {
+            resetCurrentBlock();
+            return;
+        }
+        const combined = currentLines.join('\n');
+        const guidMatch = combined.match(YAML_INLINE_GUID_PATTERN);
+        if (!guidMatch) {
+            resetCurrentBlock();
+            return;
+        }
+        const guid = guidMatch[1].toLowerCase();
+        if (guidFilter && !guidFilter.has(guid)) {
+            resetCurrentBlock();
+            return;
+        }
+        out.push({
+            sourceType,
+            sourcePath: resourcePath,
+            line: currentGuidLine || currentStartLine || 1,
+            fieldName: currentField,
+            guid,
+            snippet: currentLines[0].trim(),
+        });
+        resetCurrentBlock();
+    };
+    const resetCurrentBlock = () => {
+        currentField = '';
+        currentStartLine = 0;
+        currentLines = [];
+        currentGuidLine = 0;
+        braceDepth = 0;
+    };
+    try {
+        for await (const line of reader) {
+            lineNumber += 1;
+            const inlineMatch = line.match(YAML_INLINE_FIELD_PATTERN);
+            if (inlineMatch) {
+                const guid = inlineMatch[2].toLowerCase();
+                if (!guidFilter || guidFilter.has(guid)) {
+                    out.push({
+                        sourceType,
+                        sourcePath: resourcePath,
+                        line: lineNumber,
+                        fieldName: inlineMatch[1],
+                        guid,
+                        snippet: line.trim(),
+                    });
+                }
+                continue;
+            }
+            if (currentField) {
+                currentLines.push(line);
+                if (!currentGuidLine && YAML_INLINE_GUID_PATTERN.test(line)) {
+                    currentGuidLine = lineNumber;
+                }
+                braceDepth += countChar(line, '{');
+                braceDepth -= countChar(line, '}');
+                if (braceDepth <= 0 || line.includes('}')) {
+                    flushCurrentBlock();
+                }
+                continue;
+            }
+            const openMatch = line.match(YAML_FIELD_OPEN_PATTERN);
+            if (!openMatch)
+                continue;
+            currentField = openMatch[1];
+            currentStartLine = lineNumber;
+            currentLines = [line];
+            currentGuidLine = YAML_INLINE_GUID_PATTERN.test(line) ? lineNumber : 0;
+            braceDepth = Math.max(1, countChar(line, '{') - countChar(line, '}'));
+            if (line.includes('}') || braceDepth <= 0) {
+                flushCurrentBlock();
+            }
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR') {
+            return [];
+        }
+        throw error;
+    }
+    finally {
+        reader.close();
+        stream.destroy();
+    }
+    if (currentField) {
+        flushCurrentBlock();
+    }
+    return out;
+}
+async function resolveFiles(repoRoot, scopedPaths) {
+    if (!scopedPaths || scopedPaths.length === 0) {
+        return (await glob(['**/*.prefab', '**/*.asset'], {
+            cwd: repoRoot,
+            nodir: true,
+            dot: false,
+        })).sort((left, right) => left.localeCompare(right));
+    }
+    const normalized = scopedPaths
+        .filter((value) => value.endsWith('.prefab') || value.endsWith('.asset'))
+        .map((value) => normalizeRelativePath(repoRoot, value))
+        .filter((value) => value !== null)
+        .sort((left, right) => left.localeCompare(right));
+    return [...new Set(normalized)];
+}
+function normalizeRelativePath(repoRoot, filePath) {
+    const relativePath = path.isAbsolute(filePath) ? path.relative(repoRoot, filePath) : filePath;
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (normalized.startsWith('../'))
+        return null;
+    return normalized;
+}
+function toGuidFilter(guidInputs) {
+    if (!guidInputs || guidInputs.length === 0)
+        return null;
+    const normalized = guidInputs
+        .map((value) => String(value || '').trim().toLowerCase())
+        .filter((value) => /^[0-9a-f]{32}$/.test(value));
+    if (normalized.length === 0)
+        return null;
+    return new Set(normalized);
+}
+function countChar(input, char) {
+    let count = 0;
+    for (let i = 0; i < input.length; i += 1) {
+        if (input[i] === char)
+            count += 1;
+    }
+    return count;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    const safeConcurrency = Math.max(1, Math.min(concurrency, items.length || 1));
+    const results = new Array(items.length);
+    let cursor = 0;
+    const workers = Array.from({ length: safeConcurrency }, async () => {
+        while (true) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= items.length)
+                break;
+            results[index] = await mapper(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/core/unity/ui-asset-ref-scanner.test.d.ts

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

package/dist/core/unity/ui-asset-ref-scanner.test.js

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { scanUiAssetRefs } from './ui-asset-ref-scanner.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity-ui');
+test('scans prefab and asset VisualTreeAsset refs with evidence lines', async () => {
+    const refs = await scanUiAssetRefs({ repoRoot: fixtureRoot });
+    assert.ok(refs.some((entry) => entry.sourceType === 'prefab'
+        && entry.sourcePath === 'Assets/Prefabs/EliteBossScreen.prefab'
+        && entry.guid === 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+        && entry.line > 0));
+    assert.ok(refs.some((entry) => entry.sourceType === 'asset'
+        && entry.sourcePath === 'Assets/Config/DressUpScreenConfig.asset'
+        && entry.guid === 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+        && entry.line > 0));
+});
+test('parses multiline YAML object refs and supports target guid prefilter', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-ui-asset-scan-'));
+    await fs.mkdir(path.join(tempRoot, 'Assets/Prefabs'), { recursive: true });
+    await fs.writeFile(path.join(tempRoot, 'Assets/Prefabs/MultiLine.prefab'), [
+        '%YAML 1.1',
+        '--- !u!114 &11400000',
+        'MonoBehaviour:',
+        '  m_ObjectHideFlags: 0',
+        '  m_VisualTreeAsset: {',
+        '    fileID: 9197481965408888,',
+        '    guid: abcdefabcdefabcdefabcdefabcdefab,',
+        '    type: 3',
+        '  }',
+    ].join('\n'), 'utf-8');
+    const refs = await scanUiAssetRefs({
+        repoRoot: tempRoot,
+        targetGuids: ['abcdefabcdefabcdefabcdefabcdefab'],
+    });
+    assert.equal(refs.length, 1);
+    assert.equal(refs[0].sourcePath, 'Assets/Prefabs/MultiLine.prefab');
+    assert.equal(refs[0].fieldName, 'm_VisualTreeAsset');
+    assert.equal(refs[0].guid, 'abcdefabcdefabcdefabcdefabcdefab');
+    await fs.rm(tempRoot, { recursive: true, force: true });
+});

package/dist/core/unity/ui-meta-index.d.ts

@@ -0,0 +1,8 @@
+export interface UnityUiMetaIndex {
+    uxmlGuidToPath: Map<string, string>;
+    ussGuidToPath: Map<string, string>;
+}
+export interface BuildUnityUiMetaIndexOptions {
+    scopedPaths?: string[];
+}
+export declare function buildUnityUiMetaIndex(repoRoot: string, options?: BuildUnityUiMetaIndexOptions): Promise<UnityUiMetaIndex>;