unity-open-mcp 0.1.2 → 0.3.1

package/dist/offline.js

@@ -1,6 +1,5 @@
 // Offline asset reader — parses text-serialized Unity assets (.prefab/.unity/
-// .asset) from disk without a running Editor. Ported from unity-scanner
-// internal/unityasset (yaml.go, scan.go, kind.go, project.go).
+// .asset) from disk without a running Editor.
 //
 // Single runtime module (so it loads cleanly under node --experimental-strip-
 // types in tests: no cross-file runtime imports). Type-only contract lives in
@@ -13,7 +12,7 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import { join, basename, extname, relative, sep } from "node:path";
 // ===========================================================================
-// Native Unity class IDs → names (from unity-scanner yaml.go).
+// Native Unity class IDs → names.
 // ===========================================================================
 const nativeClassNames = {
     1: "GameObject",
@@ -45,10 +44,11 @@ function nativeClassName(classID) {
     return nativeClassNames[classID] ?? "";
 }
 // ===========================================================================
-// Kind / extension utilities (from unity-scanner kind.go).
+// Kind / extension utilities.
 // ===========================================================================
 const extToKind = {
     ".anim": "anim",
+    ".asmdef": "asmdef",
     ".asset": "asset",
     ".controller": "controller",
     ".cs": "cs",
@@ -58,13 +58,47 @@ const extToKind = {
     ".physicMaterial": "physics",
     ".playable": "playable",
     ".prefab": "prefab",
+    ".preset": "preset",
     ".shader": "shader",
+    ".shadergraph": "shadergraph",
+    ".shadersubgraph": "shadergraph",
     ".spriteatlas": "atlas",
+    ".terrainlayer": "terrainlayer",
     ".unity": "scene",
     ".uss": "uss",
     ".uxml": "uxml",
+    ".vfx": "vfx",
     ".meta": "meta",
 };
+// ===========================================================================
+// M24 — offline-parseable extension sets.
+// YAML_PARSEABLE covers text-serialized Unity YAML; JSON_PARSEABLE covers the
+// JSON asset kinds unity-scanner does not handle (our differentiator). Both are
+// merged into OFFLINE_PARSEABLE for the read_asset / search / find_references
+// gates. LISTABLE stays broader (it never parses, only enumerates files).
+// ===========================================================================
+const YAML_PARSEABLE_EXTENSIONS = new Set([
+    ".prefab", ".unity", ".asset", ".mat", ".controller", ".anim", ".playable",
+    ".preset", ".spriteatlas", ".terrainlayer", ".vfx",
+]);
+const JSON_PARSEABLE_EXTENSIONS = new Set([
+    ".asmdef", ".shadergraph", ".shadersubgraph",
+]);
+const OFFLINE_PARSEABLE_EXTENSIONS = new Set([
+    ...YAML_PARSEABLE_EXTENSIONS,
+    ...JSON_PARSEABLE_EXTENSIONS,
+]);
+function offlineParseKind(assetPath) {
+    const dot = assetPath.lastIndexOf(".");
+    if (dot < 0)
+        return null;
+    const ext = assetPath.slice(dot).toLowerCase();
+    if (YAML_PARSEABLE_EXTENSIONS.has(ext))
+        return "yaml";
+    if (JSON_PARSEABLE_EXTENSIONS.has(ext))
+        return "json";
+    return null;
+}
 const kindAliases = {
     prefabs: "prefab",
     scenes: "scene",
@@ -106,7 +140,6 @@ function shouldSkipDir(name) {
 }
 // ===========================================================================
 // YAML parser — split YAML into documents, extract key fields per object.
-// (Ported from unity-scanner yaml.go ParseAssetWithOptions.)
 // ===========================================================================
 function parseAsset(data) {
     const objects = [];
@@ -848,7 +881,7 @@ function shortGUID(guid) {
     return guid.slice(0, 8);
 }
 // ===========================================================================
-// GUID index builder — reads .meta files (from unity-scanner yaml.go).
+// GUID index builder — reads .meta files.
 // ===========================================================================
 function readMetaGUID(data) {
     let start;
@@ -953,29 +986,65 @@ async function walkMeta(dir, fn) {
 // ===========================================================================
 // readAssetOffline — parse a text-serialized asset → AssetModel.
 // ===========================================================================
-const OFFLINE_EXTENSIONS = new Set([
-    ".prefab", ".unity", ".asset", ".mat", ".controller", ".anim", ".playable",
-]);
 export function isOfflineAsset(assetPath) {
-    const dot = assetPath.lastIndexOf(".");
-    if (dot < 0)
-        return false;
-    return OFFLINE_EXTENSIONS.has(assetPath.slice(dot).toLowerCase());
+    return offlineParseKind(assetPath) !== null;
+}
+/**
+ * M24 — full-hierarchy parity helper. The offline `objectCount` counts every
+ * YAML object in the file; the live `read_asset` bridge counts only GameObjects
+ * + the components attached to them (it walks the loaded Transform tree, not
+ * the raw YAML). This helper returns the live-comparable counts so an
+ * acceptance test can verify the offline-reconstructed tree matches a live read
+ * node-for-node and component-for-component, without depending on the bridge.
+ *
+ * Returns `{ nodes, components }` where `nodes` is the GameObject count and
+ * `components` is the sum of components across the tree — the two numbers the
+ * live `ReadAssetTool` emits as `objectCount` (nodes+components) and
+ * `componentCount`.
+ */
+export function countHierarchy(model) {
+    let nodes = 0;
+    let components = 0;
+    const walk = (list) => {
+        for (const node of list) {
+            nodes++;
+            components += node.components.length;
+            walk(node.children);
+        }
+    };
+    walk(model.roots);
+    return { nodes, components };
 }
 export async function readAssetOffline(assetPath, opts) {
     const absPath = join(opts.projectRoot, assetPath);
     const data = await readFile(absPath, "utf-8");
+    const kind = kindForPath(assetPath);
+    const guid = await safeReadMetaGUID(absPath + ".meta");
+    const parseKind = offlineParseKind(assetPath);
+    // M24 — JSON asset kinds (.asmdef/.shadergraph/.shadersubgraph/.vfx) parse
+    // through a separate path; unity-scanner handles YAML only, so this is the
+    // coverage differentiator. vfx is YAML+binary, but its object headers + GUID
+    // refs still parse via the YAML path (binary blobs are skipped).
+    if (parseKind === "json") {
+        const guidIndex = await buildGUIDIndex(opts.projectRoot, new Set(findGUIDs(data)));
+        const model = buildJsonAssetModel(data, assetPath, kind, guid, guidIndex, opts.fieldLimit);
+        return { model, source: "offline" };
+    }
     const parsed = parseAsset(data);
     parsed.path = assetPath;
-    parsed.kind = kindForPath(assetPath);
-    parsed.guid = await safeReadMetaGUID(absPath + ".meta");
+    parsed.kind = kind;
+    parsed.guid = guid;
     const wantedScripts = scriptGUIDs(parsed);
     const scriptIndex = await buildScriptIndex(opts.projectRoot, wantedScripts);
     const wantedGUIDs = collectFieldGUIDs(parsed);
     const guidIndex = await buildGUIDIndex(opts.projectRoot, wantedGUIDs);
     for (const [g, p] of scriptIndex)
         guidIndex.set(g, p);
-    return { model: buildAssetModel(parsed, scriptIndex, guidIndex, opts.fieldLimit), source: "offline" };
+    const integrity = runYamlIntegrityChecks(parsed, guidIndex);
+    return {
+        model: { ...buildAssetModel(parsed, scriptIndex, guidIndex, opts.fieldLimit), ...(integrity ? { integrity } : {}) },
+        source: "offline",
+    };
 }
 async function safeReadMetaGUID(metaPath) {
     try {
@@ -1041,6 +1110,261 @@ function buildAssetModel(parsed, scriptIndex, guidIndex, fieldLimit) {
         ...(overrides.length > 0 ? { overrides } : {}),
     };
 }
+// ===========================================================================
+// M24 — JSON asset parser (.asmdef / .shadergraph / .shadersubgraph).
+//
+// unity-scanner handles YAML only; this path is the coverage differentiator.
+// Each kind has a distinct on-disk shape:
+//  - .asmdef  → a single JSON object (assembly-definition manifest).
+//  - .shadergraph / .shadersubgraph → a JSON-document stream: multiple pretty-
+//    printed JSON objects concatenated on blank-line boundaries, each carrying
+//    an "m_Type" discriminator. The first is always the graph root.
+// GUID references inside the JSON are resolved against the meta index the same
+// way YAML field refs are.
+// ===========================================================================
+function buildJsonAssetModel(data, assetPath, kind, guid, guidIndex, fieldLimit) {
+    const issues = [];
+    const objects = parseJsonAsset(data, issues);
+    const flatObjects = [];
+    for (const obj of objects) {
+        const fields = jsonFields(obj.value, fieldLimit, guidIndex);
+        flatObjects.push({
+            name: obj.name,
+            type: obj.type,
+            fields: fields.length > 0 ? fields : undefined,
+        });
+    }
+    const integrity = runJsonIntegrityChecks(kind, objects, issues, assetPath);
+    return {
+        kind,
+        path: assetPath,
+        guid: guid || undefined,
+        objectCount: objects.length,
+        componentCount: 0,
+        roots: [],
+        flatObjects,
+        ...(integrity.length > 0 ? { integrity } : {}),
+    };
+}
+/**
+ * Parse a JSON asset into one or more JsonParsedObjects. `.asmdef` is a single
+ * object; `.shadergraph` is a stream of objects. Malformed JSON records an
+ * integrity issue instead of throwing — a partial read is more useful to an
+ * agent than a hard failure when the bridge is down.
+ */
+function parseJsonAsset(data, issues) {
+    const ext = "json";
+    const chunks = splitJsonStream(data);
+    if (chunks.length === 0) {
+        issues.push({ code: "malformed_json", detail: "no JSON objects found", severity: "error" });
+        return [];
+    }
+    const out = [];
+    for (let i = 0; i < chunks.length; i++) {
+        let value;
+        try {
+            value = JSON.parse(chunks[i]);
+        }
+        catch (e) {
+            issues.push({
+                code: "malformed_json",
+                detail: `object ${i + 1}: ${e.message}`,
+                severity: "error",
+            });
+            continue;
+        }
+        out.push(jsonParsedObject(value, i));
+    }
+    return out;
+    function jsonParsedObject(value, index) {
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            const obj = value;
+            const type = typeof obj.m_Type === "string" && obj.m_Type !== ""
+                ? jsonShortType(obj.m_Type)
+                : "json";
+            const name = pickString(obj.m_Name) ??
+                pickString(obj.m_ObjectId) ??
+                pickString(obj.name) ??
+                (type !== "json" ? `${type}#${index}` : `object#${index}`);
+            return { name, type, value };
+        }
+        return { name: `value#${index}`, type: ext, value };
+    }
+}
+function pickString(v) {
+    return typeof v === "string" && v !== "" ? v : undefined;
+}
+/** Shorten a ShaderGraph m_Type like "UnityEditor.ShaderGraph.MultiplyNode" → "MultiplyNode". */
+function jsonShortType(full) {
+    const dot = full.lastIndexOf(".");
+    return dot >= 0 ? full.slice(dot + 1) : full;
+}
+/**
+ * A `.shadergraph` is a stream of pretty-printed JSON objects. They are
+ * separated by blank lines, but a single object's pretty-printed body also
+ * contains newlines — so the split must track brace depth, not line gaps.
+ * `.asmdef` is a single object; this still returns a one-element array.
+ */
+function splitJsonStream(data) {
+    const trimmed = data.trim();
+    if (trimmed === "")
+        return [];
+    const chunks = [];
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let start = -1;
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (inString) {
+            if (escape)
+                escape = false;
+            else if (ch === "\\")
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0 && start >= 0) {
+                chunks.push(trimmed.slice(start, i + 1));
+                start = -1;
+            }
+        }
+    }
+    // Fallback: if brace tracking found nothing (e.g. a top-level array or a
+    // malformed file), try a single JSON.parse on the whole content so the
+    // malformed_json issue path can report it.
+    if (chunks.length === 0)
+        chunks.push(trimmed);
+    return chunks;
+}
+/**
+ * Flatten a parsed JSON value into display fields. Scalars, arrays, and nested
+ * objects are summarized into short `name: value` rows, mirroring the YAML
+ * field renderer. GUID refs are resolved against the meta index.
+ */
+function jsonFields(value, limit, guidIndex) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const obj = value;
+    const out = [];
+    for (const [key, raw] of Object.entries(obj)) {
+        if (out.length >= limit && limit > 0)
+            break;
+        out.push({ name: key, value: jsonScalar(raw, guidIndex) });
+    }
+    return out;
+}
+function jsonScalar(value, guidIndex) {
+    if (value === null)
+        return "null";
+    switch (typeof value) {
+        case "string":
+            return resolveReferences(value, guidIndex, EMPTY_PARSED);
+        case "number":
+        case "boolean":
+            return String(value);
+        default: {
+            if (Array.isArray(value))
+                return `[${value.length}]`;
+            const obj = value;
+            // Inline {fileID, guid, type} PPtr → resolve to asset name.
+            if (typeof obj.guid === "string" && obj.guid.length === 32) {
+                return resolveReferences(`{fileID: ${obj.fileID ?? 0}, guid: ${obj.guid}, type: ${obj.type ?? 0}}`, guidIndex, EMPTY_PARSED);
+            }
+            const keys = Object.keys(obj);
+            if (keys.length === 0)
+                return "{}";
+            return `{${keys.slice(0, 4).join(", ")}${keys.length > 4 ? ", …" : ""}}`;
+        }
+    }
+}
+// A ParsedAsset stand-in used only by resolveReferences' local-reference path.
+// JSON assets have no in-file fileIDs, so local ref resolution is a no-op.
+const EMPTY_PARSED = { path: "", kind: "", guid: "", objects: [], byID: new Map() };
+// ===========================================================================
+// M24 — offline integrity checks. The verify rule suite (M25) consumes these
+// signals; here we only emit asset-local findings derivable from raw bytes.
+// ===========================================================================
+function runYamlIntegrityChecks(parsed, guidIndex) {
+    const issues = [];
+    // Orphaned PrefabInstance: a PrefabInstance whose m_SourcePrefab GUID is
+    // missing from the project (the base prefab was deleted or never imported).
+    for (const obj of parsed.objects) {
+        if (obj.type !== "PrefabInstance")
+            continue;
+        const sourceGuid = readGUIDField(obj.lines, "m_SourcePrefab");
+        if (sourceGuid !== "" && !guidIndex.has(sourceGuid)) {
+            issues.push({
+                code: "orphaned_prefab_instance",
+                detail: `m_SourcePrefab guid ${sourceGuid} not found in project`,
+                severity: "warning",
+            });
+        }
+    }
+    // Unresolved field GUIDs (missing references) — every guid: in a field that
+    // the meta index cannot resolve. Component m_Script guids get their own code
+    // so a missing-script is distinguishable from a missing asset ref.
+    const missingScripts = new Set();
+    const missingRefs = new Set();
+    for (const obj of parsed.objects) {
+        for (const line of obj.lines) {
+            if (!line.includes("guid:"))
+                continue;
+            const isScript = line.includes("m_Script");
+            for (const g of findGUIDs(line)) {
+                if (guidIndex.has(g))
+                    continue;
+                if (isScript)
+                    missingScripts.add(g);
+                else
+                    missingRefs.add(g);
+            }
+        }
+    }
+    for (const g of missingScripts) {
+        issues.push({ code: "missing_script_reference", detail: `script guid ${g} unresolved`, severity: "error" });
+    }
+    for (const g of missingRefs) {
+        issues.push({ code: "missing_reference", detail: `asset guid ${g} unresolved`, severity: "warning" });
+    }
+    return issues;
+}
+function runJsonIntegrityChecks(kind, objects, parseIssues, _assetPath) {
+    const issues = [...parseIssues];
+    if (kind === "asmdef") {
+        const first = objects[0]?.value;
+        if (first && typeof first === "object" && !Array.isArray(first)) {
+            const obj = first;
+            if (pickString(obj.name) === undefined) {
+                issues.push({ code: "asmdef_missing_name", detail: "asmdef has no 'name' field", severity: "error" });
+            }
+        }
+    }
+    if (kind === "shadergraph") {
+        // A valid graph stream must start with the GraphData root.
+        const rootType = objects[0]?.type;
+        if (rootType !== undefined && !rootType.includes("GraphData")) {
+            issues.push({
+                code: "shadergraph_root_missing",
+                detail: `first object is ${rootType}, expected a GraphData root`,
+                severity: "warning",
+            });
+        }
+    }
+    return issues;
+}
 function convertNode(node, parsed, scriptIndex, guidIndex, fieldLimit) {
     const comps = componentsFor(parsed, node.gameObject.id, scriptIndex);
     const components = comps.map((c) => {
@@ -1069,9 +1393,7 @@ function toComponentField(f) {
 // ===========================================================================
 // searchAssetsOffline — scan Assets/ → SearchModel.
 // ===========================================================================
-const SEARCHABLE_EXTENSIONS = new Set([
-    ".prefab", ".unity", ".asset", ".mat", ".controller", ".anim", ".playable",
-]);
+const SEARCHABLE_EXTENSIONS = OFFLINE_PARSEABLE_EXTENSIONS;
 export async function searchAssetsOffline(opts) {
     const nameQuery = (opts.name ?? "").trim().toLowerCase();
     const componentQuery = (opts.component ?? "").trim().toLowerCase();
@@ -1098,6 +1420,24 @@ export async function searchAssetsOffline(opts) {
         const kind = kindForPath(filePath);
         if (typeFilter && typeFilter.size > 0 && !typeFilter.has(kind))
             continue;
+        const guid = await safeReadMetaGUID(filePath + ".meta");
+        // M24 — JSON asset kinds route through a content-based match path (they
+        // have no GameObject/component tree for the YAML matcher to walk).
+        if (offlineParseKind(filePath) === "json") {
+            let content;
+            try {
+                content = await readFile(filePath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const match = checkJsonMatch(content, guidIndex, assetPath, kind, guid, {
+                nameQuery, componentQuery, guidQuery,
+            });
+            if (match)
+                matches.push(match);
+            continue;
+        }
         let parsed;
         try {
             parsed = parseAsset(await readFile(filePath, "utf-8"));
@@ -1107,7 +1447,6 @@ export async function searchAssetsOffline(opts) {
         }
         parsed.path = assetPath;
         parsed.kind = kind;
-        const guid = await safeReadMetaGUID(filePath + ".meta");
         const match = checkMatch(parsed, scriptIndex, guidIndex, assetPath, kind, guid, { nameQuery, componentQuery, guidQuery });
         if (match)
             matches.push(match);
@@ -1172,6 +1511,39 @@ function checkMatch(parsed, scriptIndex, guidIndex, assetPath, kind, guid, crite
         return null;
     return { path: assetPath, guid: guid || undefined, kind, reasons, objects: objects.length > 0 ? objects : undefined };
 }
+/**
+ * M24 — content-based matcher for JSON asset kinds (.asmdef/.shadergraph).
+ * They have no GameObject tree, so matching is by file name, raw-text GUID
+ * presence, and content substring (name/component queries search the raw text
+ * since JSON is human-readable). This keeps `search_assets` offline-capable for
+ * the expanded type set.
+ */
+function checkJsonMatch(content, guidIndex, assetPath, kind, guid, criteria) {
+    const reasons = [];
+    const { nameQuery, componentQuery, guidQuery } = criteria;
+    const fileName = basename(assetPath);
+    const lower = content.toLowerCase();
+    if (nameQuery && fileName.toLowerCase().includes(nameQuery))
+        reasons.push("file-name");
+    if (guidQuery) {
+        if (guid.toLowerCase() === guidQuery)
+            reasons.push("guid");
+        else if (lower.includes(guidQuery))
+            reasons.push("guid");
+    }
+    if (nameQuery && !reasons.includes("file-name") && lower.includes(nameQuery)) {
+        reasons.push("gameobject");
+    }
+    if (componentQuery && lower.includes(componentQuery)) {
+        reasons.push("component");
+    }
+    if (!componentQuery && !nameQuery && !guidQuery)
+        reasons.push("file-name");
+    if (reasons.length === 0)
+        return null;
+    void guidIndex;
+    return { path: assetPath, guid: guid || undefined, kind, reasons };
+}
 function flattenHierarchy(nodes) {
     const out = [];
     const walk = (ns) => {
@@ -1245,6 +1617,9 @@ const LISTABLE_EXTENSIONS = new Set([
     ".prefab", ".unity", ".asset", ".mat", ".controller", ".anim", ".playable",
     ".cs", ".shader", ".spriteatlas", ".physicMaterial", ".physicsMaterial2D",
     ".overrideController", ".uxml", ".uss",
+    // M24 — expanded offline-parseable kinds (also listable so they show up in
+    // directory listings; listing never parses, so they cost nothing to include).
+    ".asmdef", ".shadergraph", ".shadersubgraph", ".vfx", ".preset", ".terrainlayer",
 ]);
 export async function listAssetsOffline(opts) {
     const folder = opts.folder ?? "Assets";
@@ -1336,9 +1711,7 @@ async function walkFiles(dir, projectRoot, fn) {
 // fast-filter (content.includes(guid)) → optional YAML parse for verbose
 // locations → group + cap + collapse.
 // ===========================================================================
-const REFERENCEABLE_EXTENSIONS = new Set([
-    ".prefab", ".unity", ".asset", ".mat", ".controller", ".anim", ".playable",
-]);
+const REFERENCEABLE_EXTENSIONS = OFFLINE_PARSEABLE_EXTENSIONS;
 export async function findReferencesOffline(opts) {
     const detail = (opts.detail ?? "normal");
     const maxResults = opts.maxResults ?? 100;
@@ -1492,4 +1865,424 @@ function extractReferenceLocations(content, targetGuid, maxPerFile) {
     }
     return locations;
 }
+/** Collect the forward edges declared by a single asset: every external GUID
+ *  reference (field PPtrs + m_Script + PrefabInstance m_SourcePrefab). This is
+ *  the offline forward-edge primitive — unity-scanner has no full forward-edge
+ *  builder, so this is authored net-new on the existing GUID-extraction
+ *  primitives (findGUIDs / readGUIDField / parseAsset). */
+function collectForwardEdges(parsed) {
+    const edges = [];
+    const seen = new Set();
+    // 1. PrefabInstance.m_SourcePrefab — the base-prefab edge of a variant.
+    for (const obj of parsed.objects) {
+        if (obj.type !== "PrefabInstance")
+            continue;
+        const sourceGuid = readGUIDField(obj.lines, "m_SourcePrefab");
+        if (sourceGuid !== "" && seen.add(`prefab:${sourceGuid}`)) {
+            edges.push({ guid: sourceGuid, assetPath: "", kind: "prefab_source", resolved: false });
+        }
+    }
+    // 2. m_Script GUIDs on MonoBehaviours — the script-class edge.
+    for (const obj of parsed.objects) {
+        if (obj.type !== "MonoBehaviour")
+            continue;
+        if (obj.scriptGUID !== "" && seen.add(`script:${obj.scriptGUID}`)) {
+            edges.push({ guid: obj.scriptGUID, assetPath: "", kind: "script", resolved: false });
+        }
+    }
+    // 3. Every other guid: field — material refs, asset refs, animation clips,
+    //    etc. m_Script is handled above; m_SourcePrefab target: GUIDs inside
+    //    PrefabInstance.m_Modifications are included here so variant overrides
+    //    count as forward edges too.
+    for (const obj of parsed.objects) {
+        for (const line of obj.lines) {
+            if (!line.includes("guid:"))
+                continue;
+            if (line.includes("m_Script:"))
+                continue; // handled as a script edge above
+            for (const g of findGUIDs(line)) {
+                if (!seen.add(`pptr:${g}`))
+                    continue;
+                edges.push({ guid: g, assetPath: "", kind: "pptr", resolved: false });
+            }
+        }
+    }
+    return edges;
+}
+/** Resolve forward edges against the GUID→path index. Mutates each edge in
+ *  place: sets assetPath + resolved. Returns the broken (unresolved) GUIDs. */
+function resolveForwardEdges(edges, guidIndex) {
+    const broken = [];
+    const brokenSeen = new Set();
+    for (const edge of edges) {
+        const path = guidIndex.get(edge.guid);
+        if (path !== undefined) {
+            edge.assetPath = path;
+            edge.resolved = true;
+        }
+        else if (brokenSeen.add(edge.guid)) {
+            broken.push(edge.guid);
+        }
+    }
+    return broken;
+}
+export async function dependenciesOffline(opts) {
+    const detail = (opts.detail ?? "normal");
+    const maxResults = opts.maxResults ?? 100;
+    const includeImpact = opts.includeImpact ?? false;
+    const maxImpactDepth = opts.maxImpactDepth ?? 5;
+    const maxCycleDepth = opts.maxCycleDepth ?? 8;
+    // Resolve target GUID + path (mirrors findReferencesOffline's resolution).
+    let targetGuid = "";
+    let targetPath = "";
+    if (opts.guid) {
+        targetGuid = opts.guid.toLowerCase();
+    }
+    else if (opts.assetPath) {
+        targetPath = opts.assetPath;
+        targetGuid = (await safeReadMetaGUID(join(opts.projectRoot, opts.assetPath + ".meta"))).toLowerCase();
+    }
+    if (targetGuid === "") {
+        return emptyDependencies(targetPath, "", detail);
+    }
+    if (targetPath === "") {
+        const idx = await buildGUIDIndex(opts.projectRoot, new Set([targetGuid]));
+        targetPath = idx.get(targetGuid) ?? "";
+    }
+    // ---- Forward edges ----
+    // Parse the queried asset + collect its declared edges, then resolve each
+    // against a GUID→path index scoped to exactly the GUIDs this asset names.
+    let forwardEdges = [];
+    let brokenGuids = [];
+    let cycles = [];
+    let forwardSkipped;
+    const absPath = join(opts.projectRoot, targetPath);
+    let data;
+    try {
+        data = await readFile(absPath, "utf-8");
+    }
+    catch {
+        // The queried asset isn't on disk (GUID resolve but path is stale). No
+        // forward edges can be extracted; reverse edges still computed below.
+        forwardSkipped = "queried asset not readable on disk";
+    }
+    if (data !== undefined) {
+        try {
+            const parsed = parseAsset(data);
+            parsed.path = targetPath;
+            forwardEdges = collectForwardEdges(parsed);
+            const wanted = new Set(forwardEdges.map((e) => e.guid));
+            const guidIndex = await buildGUIDIndex(opts.projectRoot, wanted);
+            brokenGuids = resolveForwardEdges(forwardEdges, guidIndex);
+            if (forwardEdges.length > 0) {
+                cycles = await detectCyclesOffline(targetPath, forwardEdges, opts.projectRoot, maxCycleDepth);
+            }
+        }
+        catch (err) {
+            // Not parseable as Unity YAML (JSON-only kind, binary, malformed). The
+            // forward arrays stay empty; reverse edges are unaffected. This is the
+            // honest signal — the offline forward parser covers text-serialized YAML
+            // only, matching the documented offline coverage.
+            forwardSkipped = err instanceof Error ? err.message : String(err);
+        }
+    }
+    // ---- Reverse edges ---- (reuse the findReferencesOffline machinery).
+    const refResult = await findReferencesOffline({
+        assetPath: targetPath || undefined,
+        guid: targetGuid,
+        detail: "normal",
+        projectRoot: opts.projectRoot,
+    });
+    const reverseEdges = refResult.referencedBy.map((e) => ({
+        assetPath: e.assetPath,
+        guid: e.guid ?? "",
+        kind: e.kind,
+    }));
+    // ---- Transitive impact (optional) ----
+    let impact;
+    if (includeImpact) {
+        impact = await computeTransitiveImpact(targetGuid, targetPath, opts.projectRoot, maxImpactDepth);
+    }
+    // ---- Apply detail + caps ----
+    const displayForward = detail === "summary" ? [] : forwardEdges;
+    const totalCount = reverseEdges.length;
+    let displayReverse;
+    let truncated = 0;
+    if (detail === "summary") {
+        displayReverse = [];
+    }
+    else if (maxResults > 0 && totalCount > maxResults) {
+        displayReverse = reverseEdges.slice(0, maxResults);
+        truncated = totalCount - maxResults;
+    }
+    else {
+        displayReverse = reverseEdges;
+    }
+    return {
+        queriedAssetPath: targetPath,
+        queriedAssetGuid: targetGuid,
+        forwardDependencies: displayForward,
+        forwardCount: forwardEdges.length,
+        brokenForwardGuids: brokenGuids,
+        cycles,
+        reverseDependencies: displayReverse,
+        reverseCount: totalCount,
+        impact,
+        detail,
+        truncated,
+        ...(forwardSkipped ? { forwardSkipped } : {}),
+        _source: "offline",
+    };
+}
+function emptyDependencies(path, guid, detail) {
+    return {
+        queriedAssetPath: path,
+        queriedAssetGuid: guid,
+        forwardDependencies: [],
+        forwardCount: 0,
+        brokenForwardGuids: [],
+        cycles: [],
+        reverseDependencies: [],
+        reverseCount: 0,
+        detail,
+        truncated: 0,
+        _source: "offline",
+    };
+}
+/** Forward-cycle detection via DFS over the transitive forward closure of the
+ *  queried asset. Bounded by maxDepth to stay cheap on large graphs; a cycle
+ *  is reported when the DFS revisits the queried asset's path. This mirrors
+ *  the C# Dependencies.Scanner.DetectCycles shape (each cycle is a path list).
+ *
+ *  unity-scanner has no cycle detector — this is authored net-new. */
+async function detectCyclesOffline(startPath, startEdges, projectRoot, maxDepth) {
+    const cycles = [];
+    // Build a small forward-edge cache so repeated visits of the same asset
+    // parse once. Keyed by asset path.
+    const edgeCache = new Map();
+    edgeCache.set(startPath, startEdges);
+    async function edgesOf(path) {
+        const cached = edgeCache.get(path);
+        if (cached)
+            return cached;
+        try {
+            const data = await readFile(join(projectRoot, path), "utf-8");
+            const parsed = parseAsset(data);
+            const edges = collectForwardEdges(parsed);
+            // Best-effort resolve so the DFS walks resolved paths only.
+            const idx = await buildGUIDIndex(projectRoot, new Set(edges.map((e) => e.guid)));
+            resolveForwardEdges(edges, idx);
+            edgeCache.set(path, edges);
+            return edges;
+        }
+        catch {
+            edgeCache.set(path, []);
+            return [];
+        }
+    }
+    // DFS from each resolved forward neighbor of the start asset, looking for a
+    // path back to startPath. visited guards against re-descending the same node
+    // within one root-neighbor walk (the cycle itself is the back-edge to start).
+    const visiting = new Set();
+    async function dfs(current, trail) {
+        if (trail.length > maxDepth)
+            return;
+        const edges = await edgesOf(current);
+        for (const edge of edges) {
+            if (!edge.resolved || edge.assetPath === "")
+                continue;
+            if (edge.assetPath === startPath) {
+                cycles.push([...trail, startPath]);
+                continue;
+            }
+            if (visiting.has(edge.assetPath))
+                continue;
+            visiting.add(edge.assetPath);
+            await dfs(edge.assetPath, [...trail, edge.assetPath]);
+            visiting.delete(edge.assetPath);
+        }
+    }
+    for (const edge of startEdges) {
+        if (!edge.resolved || edge.assetPath === "" || edge.assetPath === startPath)
+            continue;
+        visiting.clear();
+        visiting.add(edge.assetPath);
+        await dfs(edge.assetPath, [startPath, edge.assetPath]);
+    }
+    return cycles;
+}
+/** Transitive impact closure via BFS over reverse edges. Starting from the
+ *  queried asset's direct referencers, walk one hop out at a time, accumulating
+ *  every asset that (transitively) depends on the queried asset. Bounded by
+ *  maxDepth. This is the "what breaks if I delete/move this?" answer — neither
+ *  the offline nor the live path did multi-hop reverse before T24.2. */
+async function computeTransitiveImpact(startGuid, startPath, projectRoot, maxDepth) {
+    const affected = [];
+    const seen = new Set([startPath]);
+    let frontier = [];
+    let truncated = false;
+    // Seed: direct reverse edges of the queried asset.
+    const seed = await findReferencesOffline({
+        assetPath: startPath || undefined,
+        guid: startGuid,
+        detail: "normal",
+        projectRoot,
+    });
+    for (const e of seed.referencedBy) {
+        if (seen.has(e.assetPath))
+            continue;
+        seen.add(e.assetPath);
+        frontier.push(e.assetPath);
+        affected.push({ assetPath: e.assetPath, depth: 1 });
+    }
+    // BFS: for each level, resolve the reverse edges of every frontier asset.
+    for (let depth = 2; depth <= maxDepth; depth++) {
+        if (frontier.length === 0)
+            break;
+        const next = [];
+        for (const nodePath of frontier) {
+            const nodeGuid = await safeReadMetaGUID(join(projectRoot, nodePath + ".meta"));
+            if (nodeGuid === "")
+                continue;
+            const res = await findReferencesOffline({
+                guid: nodeGuid,
+                detail: "normal",
+                projectRoot,
+            });
+            for (const e of res.referencedBy) {
+                if (seen.has(e.assetPath))
+                    continue;
+                seen.add(e.assetPath);
+                next.push(e.assetPath);
+                affected.push({ assetPath: e.assetPath, depth });
+            }
+        }
+        frontier = next;
+        if (depth === maxDepth && frontier.length > 0) {
+            // The next level exists but we stop here — the closure is a prefix.
+            truncated = true;
+        }
+    }
+    return {
+        affected,
+        affectedCount: affected.length,
+        maxDepth,
+        truncated,
+    };
+}
+/** Scan the whole Assets/ tree for project-wide integrity issues that the
+ *  per-read checks cannot surface (orphaned .meta, duplicate GUIDs) plus the
+ *  aggregated missing-reference set. Offline counterpart of a full verify
+ *  scan_paths run for these three rule families. */
+export async function scanIntegrityOffline(opts) {
+    const issues = [];
+    const assetsDir = join(opts.projectRoot, "Assets");
+    // ---- Walk every .meta + every asset file in one pass ----
+    // We collect: guidByPath (path -> guid), pathByGuid (guid -> paths[]), and
+    // the set of asset files (companions for the orphan-meta check). Skipping a
+    // dir uses the same skipDirs policy as every other offline walk.
+    const guidByPath = new Map();
+    const allAssetPaths = new Set();
+    const assetFiles = await collectFiles(assetsDir);
+    for (const absPath of assetFiles) {
+        const assetPath = toAssetPath(opts.projectRoot, absPath);
+        allAssetPaths.add(assetPath);
+        const metaGuid = await safeReadMetaGUID(absPath + ".meta");
+        if (metaGuid !== "") {
+            guidByPath.set(assetPath, metaGuid);
+        }
+    }
+    // Also index .meta-only paths (files whose companion was deleted show up
+    // here but not in allAssetPaths — those are the orphans). walkMeta gives us
+    // every .meta under Assets/.
+    const metaOnlyPaths = new Set();
+    await walkMeta(assetsDir, async (metaPath) => {
+        const assetPath = toAssetPath(opts.projectRoot, metaPath.slice(0, -5));
+        if (!allAssetPaths.has(assetPath)) {
+            metaOnlyPaths.add(assetPath);
+        }
+    });
+    // ---- orphan_meta: .meta whose companion asset is gone ----
+    for (const path of metaOnlyPaths) {
+        issues.push({
+            path: path + ".meta",
+            code: "orphan_meta",
+            severity: "warning",
+            detail: `meta file has no companion asset at ${path}`,
+        });
+    }
+    // ---- duplicate_guid: GUID shared by 2+ assets ----
+    const pathsByGuid = new Map();
+    for (const [assetPath, guid] of guidByPath) {
+        const list = pathsByGuid.get(guid);
+        if (list)
+            list.push(assetPath);
+        else
+            pathsByGuid.set(guid, [assetPath]);
+    }
+    for (const [guid, paths] of pathsByGuid) {
+        if (paths.length < 2)
+            continue;
+        for (const p of paths) {
+            issues.push({
+                path: p,
+                code: "duplicate_guid",
+                severity: "error",
+                detail: `guid ${guid} shared by ${paths.length} assets`,
+                relatedPaths: paths.filter((other) => other !== p),
+            });
+        }
+    }
+    // ---- aggregated missing references (the per-read check, project-wide) ----
+    // Re-uses the full GUID index so unresolved field GUIDs are detected once
+    // per asset across the whole tree. This is the offline seed for the
+    // missing_references verify rule (M25 consumes these primitives).
+    const fullGuidIndex = await buildGUIDIndex(opts.projectRoot);
+    for (const absPath of assetFiles) {
+        const ext = extname(absPath).toLowerCase();
+        if (!OFFLINE_PARSEABLE_EXTENSIONS.has(ext))
+            continue;
+        const assetPath = toAssetPath(opts.projectRoot, absPath);
+        let data;
+        try {
+            data = await readFile(absPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!data.includes("guid:"))
+            continue; // fast filter: no refs at all
+        try {
+            const parsed = parseAsset(data);
+            parsed.path = assetPath;
+            // Run the per-asset YAML integrity check against the FULL index (not a
+            // scoped one) so a ref resolves even if its target lives far away.
+            const perAsset = runYamlIntegrityChecks(parsed, fullGuidIndex);
+            for (const issue of perAsset) {
+                issues.push({
+                    path: assetPath,
+                    code: issue.code,
+                    severity: issue.severity,
+                    detail: issue.detail,
+                });
+            }
+        }
+        catch {
+            // Not parseable as YAML — skip. JSON integrity is per-read only; a
+            // project-wide JSON scan is out of scope for the verify-engine seed.
+        }
+    }
+    // ---- group by code ----
+    const byCode = {};
+    for (const issue of issues) {
+        byCode[issue.code] = (byCode[issue.code] ?? 0) + 1;
+    }
+    return {
+        issues,
+        byCode,
+        totalIssues: issues.length,
+        assetsScanned: allAssetPaths.size,
+        _source: "offline",
+    };
+}
 //# sourceMappingURL=offline.js.map