@creeperhost/modlens-mcp 1.6.0

package/dist/tools/mod-data.js

@@ -0,0 +1,630 @@
+/**
+ * Tools for reading data/asset files directly from mod JARs.
+ *
+ * Provides feature parity with the vanilla data tools (recipes, loot tables,
+ * advancements, blockstates, models, biomes, sounds, lang, structures) but
+ * for any mod in the DB.
+ *
+ * All functions resolve the mod's JAR path from the DB then use
+ * extractEntry / listEntries from jar.ts to read the ZIP/JAR contents.
+ * No decompilation is required.
+ */
+import { extractEntry, listEntries } from "../jar.js";
+import { resolveModRef, findModById, listModsSlim } from "../repositories/mod.js";
+import { writeFile, mkdir } from "fs/promises";
+import { join, extname, dirname, resolve } from "path";
+import { CACHE_ROOT } from "../cache.js";
+// ── Internal helpers ──────────────────────────────────────────────────────────
+async function resolveMod(modId) {
+    if (typeof modId === "number") {
+        return findModById(modId);
+    }
+    const numeric = parseInt(modId, 10);
+    if (!isNaN(numeric)) {
+        const byNum = await findModById(numeric);
+        if (byNum)
+            return byNum;
+    }
+    return resolveModRef(String(modId));
+}
+/**
+ * Detect all namespaces present under a prefix (data/ or assets/) in a JAR.
+ * E.g. data/mymod/ → "mymod", data/minecraft/ → "minecraft"
+ */
+function detectNamespaces(jarPath, prefix) {
+    const entries = listEntries(jarPath, `${prefix}/`);
+    const ns = new Set();
+    for (const e of entries) {
+        const parts = e.split("/");
+        if (parts.length >= 2 && parts[1])
+            ns.add(parts[1]);
+    }
+    return [...ns].filter(n => n !== "META-INF" && !n.includes("."));
+}
+function readJson(jarPath, entryPath) {
+    const buf = extractEntry(jarPath, entryPath);
+    if (!buf)
+        return null;
+    try {
+        return JSON.parse(buf.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function listJsonEntries(jarPath, prefix) {
+    return listEntries(jarPath, prefix).filter(e => e.endsWith(".json") && !e.endsWith("/"));
+}
+const DATA_TYPES = [
+    { type: "recipe", root: "data", subPath: "recipe/", altSubPaths: ["recipes/"], idPattern: /^data\/([^/]+)\/recipes?\/(.*?)\.json$/, resultKey: "recipes" },
+    { type: "loot_table", root: "data", subPath: "loot_tables/", altSubPaths: ["loot_table/"], idPattern: /^data\/([^/]+)\/loot_tables?\/(.*?)\.json$/, resultKey: "lootTables" },
+    { type: "advancement", root: "data", subPath: "advancement/", altSubPaths: ["advancements/"], idPattern: /^data\/([^/]+)\/advancements?\/(.*?)\.json$/, resultKey: "advancements" },
+    { type: "blockstate", root: "assets", subPath: "blockstates/", idPattern: /^assets\/([^/]+)\/blockstates\/(.*?)\.json$/, resultKey: "blockstates" },
+    { type: "model", root: "assets", subPath: "models/", idPattern: /^assets\/([^/]+)\/models\/(.*?)\.json$/, resultKey: "models" },
+    { type: "biome", root: "data", subPath: "worldgen/biome/", idPattern: /^data\/([^/]+)\/worldgen\/biome\/(.*?)\.json$/, resultKey: "biomes" },
+    { type: "structure", root: "data", subPath: "worldgen/structure/", idPattern: /^data\/([^/]+)\/worldgen\/structure\/(.*?)\.json$/, resultKey: "structures" },
+    { type: "particle", root: "assets", subPath: "particles/", idPattern: /^assets\/([^/]+)\/particles\/(.*?)\.json$/, resultKey: "particles" },
+    { type: "damage_type", root: "data", subPath: "damage_type/", idPattern: /^data\/([^/]+)\/damage_type\/(.*?)\.json$/, resultKey: "damageTypes" },
+    { type: "enchantment", root: "data", subPath: "enchantment/", idPattern: /^data\/([^/]+)\/enchantment\/(.*?)\.json$/, resultKey: "enchantments" },
+];
+function getDescriptor(type) {
+    return DATA_TYPES.find(d => d.type === type);
+}
+/**
+ * List all entries of a registered data type in a mod JAR.
+ * type: one of the keys in DATA_TYPES (recipe, loot_table, advancement, blockstate, model, biome, structure, particle, damage_type, enchantment)
+ */
+export async function listModData(modId, type, opts) {
+    const descriptor = getDescriptor(type);
+    if (!descriptor)
+        return { error: `Unknown data type: "${type}". Known types: ${DATA_TYPES.map(d => d.type).join(", ")}` };
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const { root, subPath, altSubPaths = [], idPattern, resultKey } = descriptor;
+    const ns = opts?.namespace ?? mod.modId;
+    let entries = listJsonEntries(mod.jarPath, `${root}/${ns}/${subPath}`);
+    for (const alt of altSubPaths) {
+        if (entries.length === 0)
+            entries = listJsonEntries(mod.jarPath, `${root}/${ns}/${alt}`);
+    }
+    if (entries.length === 0) {
+        const allNs = detectNamespaces(mod.jarPath, root);
+        for (const n of allNs) {
+            for (const sp of [subPath, ...altSubPaths]) {
+                entries.push(...listJsonEntries(mod.jarPath, `${root}/${n}/${sp}`));
+            }
+        }
+    }
+    if (opts?.filter) {
+        const f = opts.filter.toLowerCase();
+        entries = entries.filter(e => e.toLowerCase().includes(f));
+    }
+    const ids = entries.map(e => { const m = e.match(idPattern); return m ? `${m[1]}:${m[2]}` : e; });
+    return { mod: mod.modId, type, count: ids.length, [resultKey]: ids };
+}
+/**
+ * Get a single data entry by resource location from a mod JAR.
+ * type: one of the keys in DATA_TYPES
+ * id: resource location string, e.g. "mymod:iron_sword" or "iron_sword"
+ */
+export async function getModData(modId, type, id, opts) {
+    const descriptor = getDescriptor(type);
+    if (!descriptor)
+        return getModGenericDataType(modId, type, id, opts?.namespace);
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const { root, subPath, altSubPaths = [] } = descriptor;
+    const ns = opts?.namespace ?? (id.includes(":") ? id.split(":")[0] : mod.modId);
+    const path = id.includes(":") ? id.split(":")[1] : id;
+    for (const sp of [subPath, ...altSubPaths]) {
+        const data = readJson(mod.jarPath, `${root}/${ns}/${sp}${path}.json`);
+        if (data)
+            return { mod: mod.modId, type, id: `${ns}:${path}`, data };
+    }
+    return { mod: mod.modId, type, id, found: false };
+}
+// ── Generic JAR file access ───────────────────────────────────────────────────
+/**
+ * List all files inside a mod JAR under an optional path prefix.
+ * prefix: e.g. "data/mymod/recipe/", "assets/mymod/blockstates/"
+ */
+export async function listModJarFiles(modId, prefix = "") {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const entries = listEntries(mod.jarPath, prefix)
+        .filter(e => !e.endsWith("/"))
+        .sort();
+    return { mod: mod.modId, prefix: prefix || "(root)", count: entries.length, entries };
+}
+const BINARY_EXTS = new Set([".png", ".ogg", ".gif", ".wav", ".nbt", ".dat", ".mca", ".jar", ".class", ".ttf", ".otf", ".ico", ".webp", ".jpg", ".jpeg", ".bmp"]);
+/**
+ * Read any file from a mod JAR by its internal path.
+ * Returns parsed JSON for .json files, cached file path for binary files, raw text for others.
+ * path: e.g. "data/mymod/recipe/iron_sword.json", "assets/mymod/sounds.json"
+ */
+export async function getModJarFile(modId, path) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const buf = extractEntry(mod.jarPath, path);
+    if (!buf)
+        return { mod: mod.modId, path, found: false };
+    const ext = extname(path).toLowerCase();
+    if (BINARY_EXTS.has(ext)) {
+        const jarExtractRoot = resolve(CACHE_ROOT, "jar-extract");
+        const cachePath = resolve(join(CACHE_ROOT, "jar-extract", mod.modId, path));
+        if (!cachePath.startsWith(jarExtractRoot + require("path").sep)) {
+            return { error: `Path traversal rejected: ${path}` };
+        }
+        await mkdir(dirname(cachePath), { recursive: true });
+        await writeFile(cachePath, buf);
+        return { mod: mod.modId, path, cachedAt: cachePath, encoding: "binary", sizeBytes: buf.length };
+    }
+    if (path.endsWith(".json")) {
+        try {
+            const data = JSON.parse(buf.toString("utf8"));
+            return { mod: mod.modId, path, data };
+        }
+        catch {
+            return { mod: mod.modId, path, raw: buf.toString("utf8") };
+        }
+    }
+    return { mod: mod.modId, path, raw: buf.toString("utf8").slice(0, 4096) };
+}
+// ── Models ────────────────────────────────────────────────────────────────────
+export async function getModModel(modId, modelPath, namespace) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const ns = namespace ?? (modelPath.includes(":") ? modelPath.split(":")[0] : mod.modId);
+    const path = modelPath.includes(":") ? modelPath.split(":")[1] : modelPath;
+    const fullPath = path.includes("/") ? path : `item/${path}`;
+    const data = readJson(mod.jarPath, `assets/${ns}/models/${fullPath}.json`);
+    if (data)
+        return { mod: mod.modId, model: `${ns}:${fullPath}`, data };
+    return { mod: mod.modId, model: modelPath, found: false };
+}
+// ── Lang ──────────────────────────────────────────────────────────────────────
+export async function getModLang(modId, filter, limit = 200) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    // Try all namespaces
+    const allNs = detectNamespaces(mod.jarPath, "assets");
+    let lang = null;
+    let usedNs = "";
+    for (const ns of allNs) {
+        for (const name of ["en_us.json", "en_US.json"]) {
+            const buf = extractEntry(mod.jarPath, `assets/${ns}/lang/${name}`);
+            if (buf) {
+                try {
+                    lang = JSON.parse(buf.toString("utf8"));
+                    usedNs = ns;
+                    break;
+                }
+                catch { /* skip */ }
+            }
+        }
+        if (lang)
+            break;
+    }
+    if (!lang)
+        return { mod: mod.modId, found: false, note: "No en_us.json lang file found." };
+    let entries = Object.entries(lang);
+    if (filter) {
+        const f = filter.toLowerCase();
+        entries = entries.filter(([k, v]) => k.toLowerCase().includes(f) || v.toLowerCase().includes(f));
+    }
+    return {
+        mod: mod.modId,
+        namespace: usedNs,
+        total: Object.keys(lang).length,
+        shown: Math.min(entries.length, limit),
+        filter: filter ?? "(none)",
+        entries: Object.fromEntries(entries.slice(0, limit)),
+    };
+}
+// ── Sounds ────────────────────────────────────────────────────────────────────
+export async function getModSounds(modId, namespace) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const ns = namespace ?? mod.modId;
+    let data = readJson(mod.jarPath, `assets/${ns}/sounds.json`);
+    if (!data) {
+        const allNs = detectNamespaces(mod.jarPath, "assets");
+        for (const n of allNs.filter(n => n !== "minecraft")) {
+            data = readJson(mod.jarPath, `assets/${n}/sounds.json`);
+            if (data) {
+                break;
+            }
+        }
+    }
+    if (!data)
+        return { mod: mod.modId, found: false };
+    return { mod: mod.modId, data };
+}
+// ── Tags (data pack) ──────────────────────────────────────────────────────────
+export async function listModDataTags(modId, registry, namespace, filter) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const ns = namespace ?? mod.modId;
+    const regPath = registry ? `data/${ns}/tags/${registry}/` : `data/${ns}/tags/`;
+    let entries = listJsonEntries(mod.jarPath, regPath);
+    if (entries.length === 0 && !namespace) {
+        const allNs = detectNamespaces(mod.jarPath, "data");
+        for (const n of allNs) {
+            const base = registry ? `data/${n}/tags/${registry}/` : `data/${n}/tags/`;
+            entries.push(...listJsonEntries(mod.jarPath, base));
+        }
+    }
+    if (filter) {
+        const f = filter.toLowerCase();
+        entries = entries.filter(e => e.toLowerCase().includes(f));
+    }
+    const ids = entries.map(e => {
+        const m = e.match(/^data\/([^/]+)\/tags\/([^/]+)\/(.*?)\.json$/);
+        return m ? { registry: m[2], tag: `${m[1]}:${m[3]}`, path: e } : { registry: "unknown", tag: e, path: e };
+    });
+    return { mod: mod.modId, count: ids.length, tags: ids };
+}
+export async function getModDataTag(modId, registry, id, namespace) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const ns = namespace ?? (id.includes(":") ? id.split(":")[0] : mod.modId);
+    const path = id.includes(":") ? id.split(":")[1] : id;
+    const data = readJson(mod.jarPath, `data/${ns}/tags/${registry}/${path}.json`);
+    if (data)
+        return { mod: mod.modId, registry, tag: `${ns}:${path}`, data };
+    return { mod: mod.modId, registry, tag: id, found: false };
+}
+// ── Atlas ─────────────────────────────────────────────────────────────────────
+export async function getModAtlas(modId, atlas = "blocks", namespace) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const ns = namespace ?? mod.modId;
+    const name = atlas.replace(".json", "");
+    let data = readJson(mod.jarPath, `assets/${ns}/atlases/${name}.json`);
+    if (!data && !namespace) {
+        const allNs = detectNamespaces(mod.jarPath, "assets");
+        for (const n of allNs.filter(n => n !== "minecraft")) {
+            data = readJson(mod.jarPath, `assets/${n}/atlases/${name}.json`);
+            if (data)
+                break;
+        }
+    }
+    if (data)
+        return { mod: mod.modId, atlas: name, data };
+    return { mod: mod.modId, atlas: name, found: false };
+}
+// ── Generic data-path helpers (worldgen, dimension, variants, etc.) ───────────
+/**
+ * Maps mod_data type names → list of candidate subdirectory paths under data/<ns>/.
+ * Some types have alternate folder names for compatibility across MC versions.
+ */
+export const GENERIC_DATA_DIRS = {
+    configured_feature: ["worldgen/configured_feature"],
+    placed_feature: ["worldgen/placed_feature"],
+    structure_set: ["worldgen/structure_set"],
+    noise: ["worldgen/noise"],
+    density_function: ["worldgen/density_function"],
+    processor_list: ["worldgen/processor_list"],
+    template_pool: ["worldgen/template_pool"],
+    dimension_type: ["dimension_type"],
+    dimension: ["dimension"],
+    trim_material: ["trim_material"],
+    trim_pattern: ["trim_pattern"],
+    painting_variant: ["painting_variant"],
+    wolf_variant: ["wolf_variant"],
+    cat_variant: ["cat_variant"],
+    chat_type: ["chat_type"],
+};
+export async function listModGenericDataType(modId, typeKey, namespace, filter) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const dirs = GENERIC_DATA_DIRS[typeKey];
+    if (!dirs)
+        return { error: `Unknown data type: ${typeKey}` };
+    let entries = [];
+    if (namespace) {
+        for (const dir of dirs) {
+            entries.push(...listJsonEntries(mod.jarPath, `data/${namespace}/${dir}/`));
+        }
+    }
+    if (entries.length === 0) {
+        const allNs = detectNamespaces(mod.jarPath, "data");
+        for (const ns of allNs) {
+            for (const dir of dirs) {
+                entries.push(...listJsonEntries(mod.jarPath, `data/${ns}/${dir}/`));
+            }
+        }
+    }
+    if (filter) {
+        const f = filter.toLowerCase();
+        entries = entries.filter(e => e.toLowerCase().includes(f));
+    }
+    const ids = entries.map(e => {
+        // data/<ns>/<dir>/[sub/]name.json → ns:dir/[sub/]name
+        const m = e.match(/^data\/([^/]+)\/(.+?)\.json$/);
+        if (!m)
+            return e;
+        // Strip the type dir prefix to get just the resource path
+        const fullPath = m[2]; // e.g. worldgen/configured_feature/my_feature
+        // Find which dir prefix applies
+        for (const dir of dirs) {
+            if (fullPath.startsWith(dir + "/")) {
+                return `${m[1]}:${fullPath.slice(dir.length + 1)}`;
+            }
+        }
+        return `${m[1]}:${fullPath}`;
+    });
+    return { mod: mod.modId, type: typeKey, count: ids.length, entries: ids };
+}
+export async function getModGenericDataType(modId, typeKey, id, namespace) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const dirs = GENERIC_DATA_DIRS[typeKey];
+    if (!dirs)
+        return { error: `Unknown data type: ${typeKey}` };
+    const ns = namespace ?? (id.includes(":") ? id.split(":")[0] : mod.modId);
+    const path = id.includes(":") ? id.split(":")[1] : id;
+    for (const dir of dirs) {
+        const data = readJson(mod.jarPath, `data/${ns}/${dir}/${path}.json`);
+        if (data)
+            return { mod: mod.modId, type: typeKey, id: `${ns}:${path}`, data };
+    }
+    return { mod: mod.modId, type: typeKey, id, found: false };
+}
+// ── Mod manifest reader ───────────────────────────────────────────────────────
+/**
+ * Read and parse the mod's loader manifest file:
+ *   NeoForge/Forge → META-INF/neoforge.mods.toml or META-INF/mods.toml
+ *   Fabric          → fabric.mod.json
+ *   Quilt           → quilt.mod.json
+ *
+ * Returns raw text (TOML) or parsed JSON depending on format.
+ */
+export async function getModManifest(modId) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const candidates = [
+        { path: "META-INF/neoforge.mods.toml", format: "toml" },
+        { path: "META-INF/mods.toml", format: "toml" },
+        { path: "fabric.mod.json", format: "json" },
+        { path: "quilt.mod.json", format: "json" },
+        { path: "mcmod.info", format: "json" },
+    ];
+    for (const { path, format } of candidates) {
+        const buf = extractEntry(mod.jarPath, path);
+        if (!buf)
+            continue;
+        const raw = buf.toString("utf8");
+        if (format === "json") {
+            try {
+                return { mod: mod.modId, manifestPath: path, format, data: JSON.parse(raw) };
+            }
+            catch {
+                return { mod: mod.modId, manifestPath: path, format, raw };
+            }
+        }
+        // TOML — return raw text (TOML parsing requires a dep we don't have)
+        return { mod: mod.modId, manifestPath: path, format, raw };
+    }
+    return { mod: mod.modId, error: "No manifest file found (neoforge.mods.toml, mods.toml, fabric.mod.json, quilt.mod.json, mcmod.info)" };
+}
+// ── Config file browser ───────────────────────────────────────────────────────
+/**
+ * List default config files shipped inside the JAR under defaultconfigs/ or config/.
+ * These are the starter configs a mod ships; they get copied to the instance config dir on first run.
+ */
+export async function listModConfigs(modId) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const prefixes = ["defaultconfigs/", "config/"];
+    const files = [];
+    for (const prefix of prefixes) {
+        files.push(...listEntries(mod.jarPath, prefix).filter(e => !e.endsWith("/")));
+    }
+    return { mod: mod.modId, count: files.length, configs: files };
+}
+export async function getModConfig(modId, path) {
+    const mod = await resolveMod(modId);
+    if (!mod)
+        return { error: `Mod not found: ${modId}` };
+    const buf = extractEntry(mod.jarPath, path);
+    if (!buf)
+        return { mod: mod.modId, path, found: false };
+    const raw = buf.toString("utf8");
+    if (path.endsWith(".json")) {
+        try {
+            return { mod: mod.modId, path, data: JSON.parse(raw) };
+        }
+        catch { /* fall through */ }
+    }
+    return { mod: mod.modId, path, raw: raw.slice(0, 8192) };
+}
+// ── Data diff between mod versions ────────────────────────────────────────────
+/**
+ * Compare data files between two mod versions (by DB id).
+ * Returns: files only in A (removed), only in B (added), and files in both whose
+ * JSON content changed. Use type filter to scope to a specific category.
+ */
+export async function diffModData(dbIdA, dbIdB, dataType) {
+    const [modA, modB] = await Promise.all([
+        findModById(dbIdA),
+        findModById(dbIdB),
+    ]);
+    if (!modA)
+        return { error: `Mod #${dbIdA} not found` };
+    if (!modB)
+        return { error: `Mod #${dbIdB} not found` };
+    const getDataEntries = (jarPath) => {
+        let entries = listJsonEntries(jarPath, "data/");
+        if (dataType) {
+            const f = dataType.toLowerCase();
+            entries = entries.filter(e => e.toLowerCase().includes(f));
+        }
+        const map = new Map();
+        for (const e of entries) {
+            const buf = extractEntry(jarPath, e);
+            map.set(e, buf ? buf.toString("utf8") : "");
+        }
+        return map;
+    };
+    const [filesA, filesB] = await Promise.all([
+        Promise.resolve(getDataEntries(modA.jarPath)),
+        Promise.resolve(getDataEntries(modB.jarPath)),
+    ]);
+    const keysA = new Set(filesA.keys());
+    const keysB = new Set(filesB.keys());
+    const added = [...keysB].filter(k => !keysA.has(k));
+    const removed = [...keysA].filter(k => !keysB.has(k));
+    const changed = [];
+    for (const k of keysA) {
+        if (!keysB.has(k))
+            continue;
+        const contentA = filesA.get(k).trim();
+        const contentB = filesB.get(k).trim();
+        if (contentA !== contentB) {
+            // Try to summarise the change at JSON key level
+            let note = "content changed";
+            try {
+                const a = JSON.parse(contentA);
+                const b = JSON.parse(contentB);
+                const changedKeys = [...new Set([...Object.keys(a), ...Object.keys(b)])]
+                    .filter(key => JSON.stringify(a[key]) !== JSON.stringify(b[key]));
+                if (changedKeys.length > 0)
+                    note = `changed keys: ${changedKeys.join(", ")}`;
+            }
+            catch { /* not JSON or nested — keep note as-is */ }
+            changed.push({ path: k, note });
+        }
+    }
+    return {
+        modA: { id: dbIdA, modId: modA.modId, version: modA.version },
+        modB: { id: dbIdB, modId: modB.modId, version: modB.version },
+        dataType: dataType ?? "(all)",
+        summary: { added: added.length, removed: removed.length, changed: changed.length },
+        added,
+        removed,
+        changed,
+    };
+}
+function extractIngredients(recipe) {
+    const items = [];
+    const push = (v) => {
+        if (!v)
+            return;
+        if (typeof v === "string") {
+            items.push(v);
+            return;
+        }
+        if (typeof v === "object" && v !== null) {
+            const o = v;
+            if (o.item)
+                items.push(o.item);
+            else if (o.tag)
+                items.push(`#${o.tag}`);
+        }
+    };
+    // shaped/shapeless via ingredients array or key map
+    if (Array.isArray(recipe.ingredients))
+        recipe.ingredients.forEach(push);
+    if (recipe.ingredient)
+        push(recipe.ingredient);
+    if (recipe.base)
+        push(recipe.base);
+    if (recipe.addition)
+        push(recipe.addition);
+    if (recipe.input)
+        push(recipe.input);
+    if (recipe.key)
+        Object.values(recipe.key).forEach(push);
+    return items;
+}
+function extractResult(recipe) {
+    if (!recipe.result)
+        return null;
+    if (typeof recipe.result === "string")
+        return recipe.result;
+    return recipe.result.id ?? recipe.result.item ?? null;
+}
+/**
+ * Trace the full crafting dependency tree for an item.
+ * Recursively resolves all recipes that produce it across all mods in the DB,
+ * and for each ingredient finds its recipes too.
+ *
+ * itemId: resource id of the target item, e.g. "mekanism:steel_ingot"
+ * maxDepth: recursion guard (default 6)
+ * Returns a tree structure with recipes and their ingredients' sub-trees.
+ */
+export async function traceRecipeChain(itemId, maxDepth = 6) {
+    // Build a recipe index: resultId → [{modId, recipeId, type, ingredients, raw}]
+    const allMods = await listModsSlim();
+    // Index all recipes from all mods (lazy — cache by modId)
+    const recipeIndex = new Map();
+    for (const mod of allMods) {
+        const entries = listEntries(mod.jarPath, "data/").filter(e => e.includes("/recipes/") && e.endsWith(".json"));
+        for (const entry of entries) {
+            const buf = extractEntry(mod.jarPath, entry);
+            if (!buf)
+                continue;
+            try {
+                const recipe = JSON.parse(buf.toString("utf8"));
+                const result = extractResult(recipe);
+                if (!result)
+                    continue;
+                const normalId = result.includes(":") ? result : `minecraft:${result}`;
+                if (!recipeIndex.has(normalId))
+                    recipeIndex.set(normalId, []);
+                recipeIndex.get(normalId).push({
+                    mod: mod.modId,
+                    recipeId: entry,
+                    type: recipe.type ?? "unknown",
+                    ingredients: extractIngredients(recipe),
+                    resultCount: typeof recipe.result === "object" && recipe.result !== null
+                        ? recipe.result.count ?? 1
+                        : 1,
+                });
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    const visited = new Set();
+    const buildTree = (id, depth) => {
+        if (depth > maxDepth || visited.has(id)) {
+            return { item: id, note: depth > maxDepth ? "maxDepth reached" : "circular ref skipped", recipes: [] };
+        }
+        visited.add(id);
+        const normal = id.includes(":") ? id : `minecraft:${id}`;
+        const recipes = recipeIndex.get(normal) ?? [];
+        const recipeNodes = recipes.map(r => ({
+            mod: r.mod,
+            recipeId: r.recipeId,
+            type: r.type,
+            resultCount: r.resultCount,
+            ingredients: r.ingredients.map(ing => buildTree(ing, depth + 1)),
+        }));
+        visited.delete(id); // allow same item via different paths at different depths
+        return { item: normal, recipeCount: recipes.length, recipes: recipeNodes };
+    };
+    const tree = buildTree(itemId, 0);
+    return {
+        target: itemId,
+        maxDepth,
+        modsScanned: allMods.length,
+        totalRecipesIndexed: [...recipeIndex.values()].reduce((s, v) => s + v.length, 0),
+        tree,
+    };
+}
+//# sourceMappingURL=mod-data.js.map