modwright 0.1.0

package/dist/surfaces/nivalisnights/compat.js

@@ -0,0 +1,229 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { readPeFileVersion } from "../../core/compat/pe.js";
+import { pathExists, readTextIfExists } from "../../core/fsutil.js";
+export const STEAM_APP_ID = "1488490";
+export const GAME_EXE = "Nivalis Nights.exe";
+async function peVersionOf(file) {
+    if (!(await pathExists(file)))
+        return undefined;
+    try {
+        return await readPeFileVersion(file);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function mtimeMs(file) {
+    try {
+        return (await fs.stat(file)).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseAppManifestBuildId(vdf) {
+    return /"buildid"\s+"(\d+)"/i.exec(vdf)?.[1];
+}
+export async function readSteamBuildId(root) {
+    const manifest = path.resolve(root, "..", "..", `appmanifest_${STEAM_APP_ID}.acf`);
+    const text = await readTextIfExists(manifest);
+    return text === undefined ? undefined : parseAppManifestBuildId(text);
+}
+export function findBleedingEdgeBuild(bytes) {
+    const text = bytes.toString("latin1");
+    const anchored = /\x01\x00([\s\S])(\d+\.\d+\.\d+-be\.\d+(?:\+[0-9a-f]{7,40})?)/g;
+    for (let m = anchored.exec(text); m; m = anchored.exec(text)) {
+        if (m[1].charCodeAt(0) === m[2].length)
+            return m[2];
+    }
+    return /\d\.\d+\.\d+-be\.\d+(?:\+[0-9a-f]{7,40})?/.exec(text)?.[0];
+}
+async function bepinexBuildOf(dll) {
+    try {
+        return findBleedingEdgeBuild(await fs.readFile(dll));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function detectComponents(install) {
+    const root = install.root;
+    const components = [];
+    const exe = path.join(root, GAME_EXE);
+    const buildId = await readSteamBuildId(root);
+    const exeVersion = await peVersionOf(exe);
+    const gameVersion = install.version ?? buildId ?? exeVersion;
+    components.push({
+        id: "game",
+        label: "Nivalis Nights",
+        kind: "game",
+        installed: await pathExists(exe),
+        ...(gameVersion !== undefined ? { version: gameVersion } : {}),
+        source: install.version
+            ? "install record"
+            : buildId
+                ? `steamapps/appmanifest_${STEAM_APP_ID}.acf buildid (the Steam build; changes with every game update)`
+                : `${GAME_EXE} PE file version (the Unity player version; does not change between game updates)`,
+        path: exe,
+    });
+    const core = path.join(root, "BepInEx", "core");
+    const coreDll6 = path.join(core, "BepInEx.Core.dll");
+    const coreDll5 = path.join(core, "BepInEx.dll");
+    const il2cppDll = path.join(core, "BepInEx.Unity.IL2CPP.dll");
+    const has6 = await pathExists(coreDll6);
+    const has5 = await pathExists(coreDll5);
+    const bepinexInstalled = has6 || has5;
+    const bepinexDll = has6 ? coreDll6 : coreDll5;
+    const bepinexVersion = bepinexInstalled ? ((has6 ? await bepinexBuildOf(coreDll6) : undefined) ?? (await peVersionOf(bepinexDll))) : undefined;
+    components.push({
+        id: "bepinex",
+        label: "BepInEx",
+        kind: "loader",
+        installed: bepinexInstalled,
+        ...(bepinexVersion !== undefined ? { version: bepinexVersion } : {}),
+        source: has6 ? "BepInEx/core/BepInEx.Core.dll informational version (else its PE file version)" : "BepInEx/core/BepInEx.dll PE file version (BepInEx 5)",
+        path: bepinexDll,
+    });
+    const il2cpp = await pathExists(il2cppDll);
+    const il2cppVersion = il2cpp ? ((await bepinexBuildOf(il2cppDll)) ?? (await peVersionOf(il2cppDll))) : undefined;
+    components.push({
+        id: "bepinex-il2cpp",
+        label: "BepInEx Unity IL2CPP runtime",
+        kind: "loader",
+        installed: il2cpp,
+        ...(il2cppVersion !== undefined ? { version: il2cppVersion } : {}),
+        source: "BepInEx/core/BepInEx.Unity.IL2CPP.dll informational version (else its PE file version)",
+        path: il2cppDll,
+    });
+    components.push({
+        id: "bepinex-wrong-build",
+        label: "BepInEx that is not the Unity IL2CPP build",
+        kind: "loader",
+        installed: bepinexInstalled && !il2cpp,
+        source: "BepInEx core present without BepInEx.Unity.IL2CPP.dll (BepInEx 5, or a 6.x Unity.Mono / NET build)",
+    });
+    const doorstopText = await readTextIfExists(path.join(root, ".doorstop_version"));
+    const doorstopVersion = doorstopText?.trim().split(/\s+/)[0];
+    const winhttp = path.join(root, "winhttp.dll");
+    const doorstopInstalled = (await pathExists(winhttp)) || doorstopText !== undefined;
+    components.push({
+        id: "doorstop",
+        label: "UnityDoorstop (BepInEx's entry point)",
+        kind: "loader",
+        installed: doorstopInstalled,
+        ...(doorstopVersion ? { version: doorstopVersion } : {}),
+        source: ".doorstop_version beside the executable",
+        path: winhttp,
+    });
+    const interopProbe = path.join(root, "BepInEx", "interop", "Assembly-CSharp.dll");
+    const interopAt = await mtimeMs(interopProbe);
+    const gameAssemblyAt = await mtimeMs(path.join(root, "GameAssembly.dll"));
+    components.push({ id: "bepinex-interop", label: "BepInEx interop assemblies", kind: "framework", installed: interopAt !== undefined, source: "BepInEx/interop/Assembly-CSharp.dll", path: interopProbe });
+    components.push({
+        id: "bepinex-interop-missing",
+        label: "BepInEx IL2CPP installed but never launched (no interop yet)",
+        kind: "framework",
+        installed: il2cpp && interopAt === undefined,
+        source: "BepInEx.Unity.IL2CPP.dll present, BepInEx/interop/Assembly-CSharp.dll absent",
+    });
+    components.push({
+        id: "bepinex-interop-stale",
+        label: "Interop older than GameAssembly.dll (the game updated since BepInEx last ran)",
+        kind: "framework",
+        installed: interopAt !== undefined && gameAssemblyAt !== undefined && interopAt < gameAssemblyAt,
+        source: "mtime of BepInEx/interop/Assembly-CSharp.dll against GameAssembly.dll",
+    });
+    for (const [id, label, file] of [
+        ["harmony", "HarmonyX", "0Harmony.dll"],
+        ["il2cppinterop", "Il2CppInterop", "Il2CppInterop.Runtime.dll"],
+    ]) {
+        const dll = path.join(core, file);
+        const version = await peVersionOf(dll);
+        components.push({ id, label, kind: "framework", installed: await pathExists(dll), ...(version !== undefined ? { version } : {}), source: `BepInEx/core/${file} PE file version`, path: dll });
+    }
+    const melonDir = path.join(root, "MelonLoader");
+    const melonInstalled = (await pathExists(path.join(root, "version.dll"))) && (await pathExists(melonDir));
+    let melonVersion;
+    let melonDll;
+    if (melonInstalled) {
+        for (const candidate of [path.join(melonDir, "net6", "MelonLoader.dll"), path.join(melonDir, "MelonLoader.dll")]) {
+            if (await pathExists(candidate)) {
+                melonDll = candidate;
+                melonVersion = await peVersionOf(candidate);
+                break;
+            }
+        }
+    }
+    components.push({
+        id: "melonloader",
+        label: "MelonLoader",
+        kind: "loader",
+        installed: melonInstalled,
+        ...(melonVersion !== undefined ? { version: melonVersion } : {}),
+        source: "version.dll and MelonLoader/ beside the executable; version from MelonLoader/net6/MelonLoader.dll (layout from MelonLoader's docs, not yet seen on this machine)",
+        ...(melonDll ? { path: melonDll } : {}),
+    });
+    components.push({
+        id: "both-loaders",
+        label: "BepInEx and MelonLoader both installed",
+        kind: "loader",
+        installed: (doorstopInstalled || bepinexInstalled) && melonInstalled,
+        source: "BepInEx's doorstop or core, and MelonLoader's version.dll and folder",
+    });
+    return components;
+}
+export const RULES = [
+    {
+        id: "nn-bepinex-must-be-il2cpp",
+        game: "nivalisnights",
+        component: "bepinex-wrong-build",
+        requires: [],
+        advisory: true,
+        severity: "block",
+        note: "Nivalis Nights is a Unity IL2CPP game. BepInEx 5.x and the 6.x Unity.Mono and NET builds load nothing on it. The working build is BepInEx 6 bleeding-edge, Unity.IL2CPP (be.788 is the one the community and ModWright tested).",
+        source: "Nexus mod 2 'Nivalis - FIFO' requirements, read 2026-10-03",
+    },
+    {
+        id: "nn-one-loader",
+        game: "nivalisnights",
+        component: "both-loaders",
+        requires: [],
+        advisory: true,
+        severity: "warn",
+        note: "BepInEx and MelonLoader are both installed. Mods for this game ship separate builds per loader and say to choose only one; what breaks when both are present has not been observed.",
+        source: "Nexus mod 3 'Nivalis Nights Trainer' install notes, read 2026-10-03",
+    },
+    {
+        id: "nn-interop-missing",
+        game: "nivalisnights",
+        component: "bepinex-interop-missing",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "BepInEx IL2CPP is installed but has not run yet. The first launch downloads Unity base libraries (network needed) and generates interop, about 25 s at a black screen; close the game at the main menu, then install plugins.",
+        source: "observed in game 2026-10-03",
+        verifiedOn: "25680465",
+    },
+    {
+        id: "nn-interop-stale",
+        game: "nivalisnights",
+        component: "bepinex-interop-stale",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "The game updated since BepInEx last generated interop. The next launch regenerates it automatically; plugins compiled against the previous build may then fail to load or patch.",
+        source: "Il2CppInteropManager.cs at BepInEx be.788 ('Detected outdated interop assemblies')",
+    },
+    {
+        id: "nn-game-updates-often",
+        game: "nivalisnights",
+        component: "game",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "The game patches often: two updates in its first four days, one of which made a mod obsolete by fixing the bug it addressed. After an update, check each plugin's page for a matching build before blaming load errors on anything else.",
+        source: "ModWright research",
+    },
+];
+export const nivalisCompat = { detectComponents, rules: RULES };

package/dist/surfaces/nivalisnights/index/build.js

@@ -0,0 +1,310 @@
+import { existsSync, promises as fs } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defaultCacheDir, indexFile, IndexStore } from "../../../core/knowledge/store.js";
+import { assertAbsolute, locateTool, runTool, toNativePath, TOOL_SPECS } from "../../../core/toolchain/index.js";
+import { readSteamBuildId } from "../compat.js";
+export const GAME = "nivalisnights";
+export const DEFAULT_FOLDERS = [
+    "itemtypes",
+    "recipes",
+    "vendors",
+    "locations",
+    "venues",
+    "objecttags",
+    "apartments",
+    "greenhouses",
+    "processors",
+    "achievementseries",
+    "variables",
+    "actions",
+    "worldobjs",
+    "sosingletons",
+    "peopledatabase",
+];
+export const FOLLOW_FOLDERS = ["peopledatabase"];
+export const FOLDER_ALIASES = { "peopledatabase.refs": "people", "peopledatabase.refs2": "people-links" };
+export const SKIPPED_FOLDERS = {
+    quests: "SerializeReference graphs (onStart/onComplete GameActions, SubQuests): the type-tree generator runs away on them (past 12 GB when tried)",
+    skills: "SerializeReference level data: the type-tree generator fails ('Failed to get ref type node')",
+    ghosts: "SerializeReference fields: the type-tree generator fails ('Failed to get ref type node')",
+    backgroundnpcconversations: "SerializeReference dialogue graphs: decoding exhausted memory when tried",
+    newsarticles: "a consistent 44-byte layout mismatch between the generated type tree and the data",
+};
+export function createSchema(store) {
+    store.exec(`
+    CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS definition (
+      id INTEGER PRIMARY KEY,
+      key TEXT NOT NULL UNIQUE,
+      folder TEXT NOT NULL,
+      path TEXT NOT NULL,
+      script TEXT NOT NULL,
+      name TEXT COLLATE NOCASE,
+      guid TEXT COLLATE NOCASE,
+      data_json TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS link (
+      from_key TEXT NOT NULL,
+      field TEXT NOT NULL,
+      to_key TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_def_folder_name ON definition(folder, name);
+    CREATE INDEX IF NOT EXISTS idx_def_name ON definition(name);
+    CREATE INDEX IF NOT EXISTS idx_def_guid ON definition(guid);
+    CREATE INDEX IF NOT EXISTS idx_link_to ON link(to_key);
+    CREATE INDEX IF NOT EXISTS idx_link_from ON link(from_key);
+  `);
+}
+export function isBuilt(store) {
+    const row = store.get("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'definition'");
+    return row !== undefined && store.get("SELECT COUNT(*) AS n FROM definition")?.n > 0;
+}
+export function guidOf(data) {
+    const g = data.guid;
+    if (typeof g === "string" && g.length > 0)
+        return g;
+    if (g && typeof g === "object" && typeof g.guid === "string" && g.guid.length > 0)
+        return g.guid;
+    return undefined;
+}
+export function resolveRefs(value, targets, field, out) {
+    if (Array.isArray(value))
+        return value.map((v, i) => resolveRefs(v, targets, `${field}[${i}]`, out));
+    if (value && typeof value === "object") {
+        const obj = value;
+        if (typeof obj.$ref === "string" && Object.keys(obj).length === 1) {
+            out.push({ field, key: obj.$ref });
+            const t = targets.get(obj.$ref);
+            return t ? { $ref: obj.$ref, folder: t.folder, ...(t.name !== undefined ? { name: t.name } : {}), ...(t.guid !== undefined ? { guid: t.guid } : {}) } : obj;
+        }
+        const result = {};
+        for (const [k, v] of Object.entries(obj))
+            result[k] = resolveRefs(v, targets, field ? `${field}.${k}` : k, out);
+        return result;
+    }
+    return value;
+}
+export async function importExtraction(store, outDir) {
+    createSchema(store);
+    store.exec("DELETE FROM definition; DELETE FROM link;");
+    const summary = JSON.parse(await fs.readFile(path.join(outDir, "summary.json"), "utf8"));
+    const records = [];
+    const byKey = new Map();
+    const otherPaths = new Map();
+    let badLines = 0;
+    for (const folder of Object.keys(summary.folders)) {
+        const file = path.join(outDir, `${folder}.jsonl`);
+        if (!existsSync(file))
+            continue;
+        for (const line of (await fs.readFile(file, "utf8")).split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            let r;
+            try {
+                r = JSON.parse(line);
+            }
+            catch {
+                badLines++;
+                continue;
+            }
+            if (byKey.has(r.key)) {
+                otherPaths.set(r.key, [...(otherPaths.get(r.key) ?? []), r.path]);
+                continue;
+            }
+            const rec = { ...r, folder: FOLDER_ALIASES[r.folder] ?? r.folder };
+            byKey.set(r.key, rec);
+            records.push(rec);
+        }
+    }
+    for (const [key, paths] of otherPaths) {
+        const rec = byKey.get(key);
+        rec.data = { ...rec.data, $otherResourcePaths: paths };
+    }
+    const targets = new Map();
+    for (const r of records) {
+        const name = typeof r.data.m_Name === "string" && r.data.m_Name.length > 0 ? r.data.m_Name : undefined;
+        const guid = guidOf(r.data);
+        targets.set(r.key, { folder: r.folder, ...(name !== undefined ? { name } : {}), ...(guid !== undefined ? { guid } : {}) });
+    }
+    const defs = [];
+    const links = [];
+    const perFolder = {};
+    let resolved = 0;
+    for (const r of records) {
+        const refs = [];
+        const data = resolveRefs(r.data, targets, "", refs);
+        const t = targets.get(r.key);
+        defs.push([r.key, r.folder, r.path, r.script, t.name ?? null, t.guid ?? null, JSON.stringify(data)]);
+        for (const ref of refs) {
+            links.push([r.key, ref.field, ref.key]);
+            if (targets.has(ref.key))
+                resolved++;
+        }
+        perFolder[r.folder] = (perFolder[r.folder] ?? 0) + 1;
+    }
+    if (defs.length > 0)
+        store.insertMany("definition", ["key", "folder", "path", "script", "name", "guid", "data_json"], defs);
+    if (links.length > 0)
+        store.insertMany("link", ["from_key", "field", "to_key"], links);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('extraction', ?)", [JSON.stringify(summary)]);
+    return { definitions: defs.length, links: links.length, resolvedLinks: resolved, folders: perFolder, badLines, duplicatePaths: [...otherPaths.values()].reduce((n, p) => n + p.length, 0) };
+}
+function findPackageRoot(startDir) {
+    let dir = startDir;
+    for (;;) {
+        if (existsSync(path.join(dir, "package.json")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            throw new Error(`nivalisnights index: could not find package.json above ${startDir}`);
+        dir = parent;
+    }
+}
+export function extractorScript() {
+    return path.join(findPackageRoot(path.dirname(fileURLToPath(import.meta.url))), "assets", "nivalisnights", "extract_resources.py");
+}
+async function locate(toolId, options) {
+    if (options.locate)
+        return options.locate(toolId);
+    const spec = TOOL_SPECS.find((s) => s.id === toolId);
+    if (!spec)
+        throw new Error(`No toolchain spec registered for '${toolId}'.`);
+    return locateTool(spec, { projectOverrides: options.toolOverrides });
+}
+function summarize(store, sources) {
+    const builtAt = store.get("SELECT value FROM meta WHERE key = 'builtAt'")?.value;
+    const gameVersion = store.get("SELECT value FROM meta WHERE key = 'gameVersion'")?.value;
+    return {
+        game: GAME,
+        file: indexFile(defaultCacheDir(), GAME),
+        exists: true,
+        ...(builtAt !== undefined ? { builtAt: String(builtAt) } : {}),
+        ...(gameVersion !== undefined ? { gameVersion: String(gameVersion) } : {}),
+        tables: store.tableCounts(),
+        sources,
+    };
+}
+export async function buildIndex(install, store, options = {}) {
+    const sources = [];
+    createSchema(store);
+    if (isBuilt(store) && !options.force) {
+        sources.push("(Nivalis Nights index already built — pass { force: true } to rebuild)");
+        return summarize(store, sources);
+    }
+    const root = path.resolve(install.root);
+    const data = path.join(root, "Nivalis Nights_Data");
+    if (!existsSync(path.join(data, "globalgamemanagers"))) {
+        throw new Error(`Cannot build the Nivalis Nights index: ${data} has no globalgamemanagers, so ${root} is not a Nivalis Nights install.`);
+    }
+    const buildId = (await readSteamBuildId(root)) ?? "unknown";
+    const work = path.resolve(options.workDir ?? path.join(defaultCacheDir(), GAME, `work-${buildId}`));
+    const dlls = path.join(work, "dummydll");
+    const out = path.join(work, "resources");
+    assertAbsolute([root, work, dlls, out]);
+    await fs.mkdir(work, { recursive: true });
+    const requested = options.only && options.only.length > 0 ? options.only.map((f) => f.toLowerCase()) : [...DEFAULT_FOLDERS];
+    const skippedAsked = requested.filter((f) => f in SKIPPED_FOLDERS);
+    const folders = requested.filter((f) => !(f in SKIPPED_FOLDERS));
+    for (const f of skippedAsked)
+        sources.push(`${f}: not decoded — ${SKIPPED_FOLDERS[f]}.`);
+    if (folders.length === 0)
+        throw new Error("Cannot build the Nivalis Nights index: every folder asked for is one the decoder skips (see the reasons above).");
+    if (!existsSync(path.join(dlls, "Assembly-CSharp.dll"))) {
+        const cpp2il = await locate("cpp2il", options);
+        if (!cpp2il.found || !cpp2il.path) {
+            throw new Error(`Cannot build the Nivalis Nights index: ${cpp2il.hint ?? "Cpp2IL was not found"}. Install Cpp2IL (pre-release.21 is tested), then point ModWright at it once: check_toolchain action=remember tool=cpp2il toolPath=<path to Cpp2IL.exe> mode=apply.`);
+        }
+        options.progress?.({ step: "cpp2il", note: `dummy assemblies for build ${buildId}` });
+        const result = await runTool(cpp2il, {
+            args: ["--game-path", toNativePath(root), "--exe-name", "Nivalis Nights", "--use-processor", "attributeanalyzer,attributeinjector", "--output-as", "dummydll", "--output-to", toNativePath(dlls)],
+            cwd: work,
+            timeoutMs: 15 * 60_000,
+            expectOutputs: [path.join(dlls, "Assembly-CSharp.dll")],
+        });
+        if (!result.ok)
+            throw new Error(`Cpp2IL failed: ${result.error?.message ?? `exit ${result.exitCode}`}\n${result.stderr.slice(-2000)}`);
+        sources.push(`Cpp2IL dummy assemblies for build ${buildId} (${toNativePath(dlls)})`);
+    }
+    else {
+        sources.push(`reused Cpp2IL dummy assemblies for build ${buildId} (${toNativePath(dlls)})`);
+    }
+    const python = await locate("unitypy-python", options);
+    if (!python.found || !python.path) {
+        throw new Error(`Cannot build the Nivalis Nights index: ${python.hint ?? "no Python was found"}. Install Python 3 with \`pip install UnityPy TypeTreeGeneratorAPI\` (a venv is cleanest), then: check_toolchain action=remember tool=unitypy-python toolPath=<that python.exe> mode=apply.`);
+    }
+    const script = extractorScript();
+    const follow = FOLLOW_FOLDERS.filter((f) => folders.includes(f));
+    options.progress?.({ step: "decode", note: folders.join(", ") });
+    const decoded = await runTool(python, {
+        args: [toNativePath(script), "--data", toNativePath(data), "--dlls", toNativePath(dlls), "--out", toNativePath(out), "--folders", folders.join(","), ...(follow.length > 0 ? ["--follow", follow.join(",")] : [])],
+        cwd: work,
+        timeoutMs: 30 * 60_000,
+        expectOutputs: [path.join(out, "summary.json")],
+        requireFreshOutputs: true,
+        maxCaptureBytes: 4_000_000,
+    });
+    if (!decoded.ok) {
+        const missingModule = /No module named '?(UnityPy|TypeTreeGeneratorAPI)/.exec(decoded.stderr);
+        const hint = missingModule ? ` The Python at ${python.path} lacks ${missingModule[1]}: \`pip install UnityPy TypeTreeGeneratorAPI\` there, or remember one that has them (check_toolchain action=remember tool=unitypy-python).` : "";
+        throw new Error(`The resource decoder failed: ${decoded.error?.message ?? `exit ${decoded.exitCode}`}.${hint}\n${decoded.stderr.slice(-2000)}`);
+    }
+    options.progress?.({ step: "import" });
+    const imported = await importExtraction(store, out);
+    const extraction = JSON.parse(await fs.readFile(path.join(out, "summary.json"), "utf8"));
+    for (const [folder, s] of Object.entries(extraction.folders)) {
+        const errors = Object.entries(s.errors ?? {});
+        const shown = FOLDER_ALIASES[folder] ?? folder;
+        sources.push(`${shown}: ${s.decoded}/${s.entries} decoded${errors.length > 0 ? `; ${errors.reduce((n, [, c]) => n + c, 0)} failed (${errors.slice(0, 2).map(([m]) => m).join("; ")})` : ""}`);
+    }
+    for (const f of Object.keys(SKIPPED_FOLDERS))
+        if (!skippedAsked.includes(f))
+            sources.push(`${f}: not decoded — ${SKIPPED_FOLDERS[f]}.`);
+    if (imported.duplicatePaths > 0)
+        sources.push(`${imported.duplicatePaths} Resources path(s) named an object already indexed under another path; kept as $otherResourcePaths on that definition.`);
+    if (imported.badLines > 0)
+        sources.push(`${imported.badLines} decoder output line(s) were not valid JSON and were skipped.`);
+    sources.push(`${imported.definitions} definitions, ${imported.links} references (${imported.resolvedLinks} to indexed definitions).`);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('gameVersion', ?)", [buildId]);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('unity', ?)", [extraction.unity ?? "unknown"]);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('skipped', ?)", [JSON.stringify(SKIPPED_FOLDERS)]);
+    return summarize(store, sources);
+}
+export async function info(install) {
+    const file = indexFile(defaultCacheDir(), GAME);
+    const result = { game: GAME, file, exists: false };
+    let stat;
+    try {
+        stat = await fs.stat(file);
+    }
+    catch {
+        return result;
+    }
+    result.exists = true;
+    result.sizeBytes = stat.size;
+    let store;
+    try {
+        store = await IndexStore.open(file);
+        const builtAt = store.get("SELECT value FROM meta WHERE key = 'builtAt'")?.value;
+        const gameVersion = store.get("SELECT value FROM meta WHERE key = 'gameVersion'")?.value;
+        if (builtAt !== undefined)
+            result.builtAt = String(builtAt);
+        if (gameVersion !== undefined)
+            result.gameVersion = String(gameVersion);
+        result.tables = store.tableCounts();
+        const rows = store.all("SELECT folder, COUNT(*) AS n FROM definition GROUP BY folder ORDER BY folder");
+        if (rows.length > 0)
+            result.sources = rows.map((r) => `${r.folder}: ${r.n} definitions`);
+        const current = await readSteamBuildId(path.resolve(install.root));
+        if (current && gameVersion !== undefined && String(gameVersion) !== current) {
+            result.stale = `built from Steam build ${String(gameVersion)}; the install is now on build ${current}. Rebuild with force to pick up the update.`;
+        }
+    }
+    catch {
+    }
+    finally {
+        store?.close();
+    }
+    return result;
+}

package/dist/surfaces/nivalisnights/index/index.js

@@ -0,0 +1,5 @@
+import { buildIndex, info } from "./build.js";
+import { query, queryKinds } from "./queries.js";
+export const nivalisIndex = { info, build: buildIndex, queryKinds, query };
+export { buildIndex, info, importExtraction, resolveRefs, guidOf, createSchema, isBuilt, extractorScript, DEFAULT_FOLDERS, SKIPPED_FOLDERS, FOLLOW_FOLDERS } from "./build.js";
+export { query, queryKinds } from "./queries.js";