modwright 0.1.0

package/dist/surfaces/valheim/compat.js

@@ -0,0 +1,171 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { readPeFileVersion } from "../../core/compat/pe.js";
+import { parseVersion } from "../../core/compat/version.js";
+import { pathExists, readTextIfExists } from "../../core/fsutil.js";
+async function exeKind(root) {
+    return (await pathExists(path.join(root, "valheim_server.exe"))) ? "server" : "client";
+}
+export function doorstopIniGeneration(iniText) {
+    const sections = new Set();
+    for (const raw of iniText.split(/\r?\n/)) {
+        const m = /^\s*\[(.+?)\]\s*$/.exec(raw);
+        if (m)
+            sections.add(m[1].trim().toLowerCase());
+    }
+    if (sections.has("unitydoorstop"))
+        return "legacy";
+    if (sections.has("general"))
+        return "modern";
+    return "unknown";
+}
+async function peVersionOf(file) {
+    if (!(await pathExists(file)))
+        return undefined;
+    try {
+        return await readPeFileVersion(file);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function findJotunn(pluginsDir) {
+    const direct = path.join(pluginsDir, "Jotunn.dll");
+    if (await pathExists(direct))
+        return direct;
+    let entries;
+    try {
+        entries = await fs.readdir(pluginsDir);
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries.sort()) {
+        const candidate = path.join(pluginsDir, entry, "Jotunn.dll");
+        if (await pathExists(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export async function detectComponents(install) {
+    const root = install.root;
+    const kind = await exeKind(root);
+    const exe = path.join(root, kind === "server" ? "valheim_server.exe" : "valheim.exe");
+    const exeExists = await pathExists(exe);
+    const gameVersion = install.version ?? (await peVersionOf(exe));
+    const components = [];
+    components.push({
+        id: "game",
+        label: kind === "server" ? "Valheim dedicated server" : "Valheim",
+        kind: "game",
+        installed: exeExists,
+        ...(gameVersion !== undefined ? { version: gameVersion } : {}),
+        source: install.version ? "install record" : `${path.basename(exe)} PE file version (the Unity player version, not Iron Gate's patch number)`,
+        path: exe,
+    });
+    const bepinexDir = path.join(root, "BepInEx");
+    const bepinexDll = path.join(bepinexDir, "core", "BepInEx.dll");
+    const bepinexVersion = await peVersionOf(bepinexDll);
+    const bepinexInstalled = await pathExists(bepinexDll);
+    components.push({ id: "bepinex", label: "BepInEx 5", kind: "loader", installed: bepinexInstalled, ...(bepinexVersion !== undefined ? { version: bepinexVersion } : {}), source: "BepInEx/core/BepInEx.dll PE file version", path: bepinexDll });
+    const packMarkers = ["start_game_bepinex.sh", "start_server_bepinex.sh", "doorstop_libs"].map((m) => path.join(root, m));
+    let packMarker;
+    for (const m of packMarkers)
+        if (await pathExists(m)) {
+            packMarker = m;
+            break;
+        }
+    components.push({
+        id: "bepinexpack",
+        label: "BepInExPack_Valheim",
+        kind: "loader",
+        installed: packMarker !== undefined,
+        source: packMarker ? `${path.basename(packMarker)} beside the executable (the pack's own file; its version is not on disk)` : "the pack's run scripts or doorstop_libs folder, not found",
+        ...(packMarker ? { path: packMarker } : {}),
+    });
+    components.push({ id: "bepinexpack-missing", label: "BepInEx without the Valheim pack", kind: "loader", installed: bepinexInstalled && packMarker === undefined, source: "BepInEx.dll present, no pack marker" });
+    const doorstopVersionFile = path.join(root, ".doorstop_version");
+    const doorstopText = await readTextIfExists(doorstopVersionFile);
+    const doorstopVersion = doorstopText?.trim().split(/\s+/)[0];
+    const ini = await readTextIfExists(path.join(root, "doorstop_config.ini"));
+    const doorstopInstalled = (await pathExists(path.join(root, "winhttp.dll"))) || doorstopText !== undefined || ini !== undefined;
+    components.push({
+        id: "doorstop",
+        label: "UnityDoorstop",
+        kind: "loader",
+        installed: doorstopInstalled,
+        ...(doorstopVersion && parseVersion(doorstopVersion) ? { version: doorstopVersion } : {}),
+        source: ".doorstop_version beside the executable",
+        path: doorstopVersionFile,
+    });
+    const generation = ini === undefined ? "unknown" : doorstopIniGeneration(ini);
+    components.push({ id: "doorstop-ini-legacy", label: "doorstop_config.ini in the [UnityDoorstop] shape (BepInEx <= 5.4.22)", kind: "loader", installed: generation === "legacy", source: "doorstop_config.ini section names" });
+    components.push({ id: "doorstop-ini-modern", label: "doorstop_config.ini in the [General]/[UnityMono] shape (BepInEx >= 5.4.23)", kind: "loader", installed: generation === "modern", source: "doorstop_config.ini section names" });
+    const harmonyDll = path.join(bepinexDir, "core", "0Harmony.dll");
+    const harmonyVersion = await peVersionOf(harmonyDll);
+    components.push({ id: "harmony", label: "HarmonyX", kind: "framework", installed: await pathExists(harmonyDll), ...(harmonyVersion !== undefined ? { version: harmonyVersion } : {}), source: "BepInEx/core/0Harmony.dll PE file version", path: harmonyDll });
+    const jotunnDll = await findJotunn(path.join(bepinexDir, "plugins"));
+    const jotunnVersion = jotunnDll ? await peVersionOf(jotunnDll) : undefined;
+    components.push({ id: "jotunn", label: "Jötunn", kind: "framework", installed: jotunnDll !== undefined, ...(jotunnVersion !== undefined ? { version: jotunnVersion } : {}), source: "BepInEx/plugins/**/Jotunn.dll PE file version", ...(jotunnDll ? { path: jotunnDll } : {}) });
+    return components;
+}
+const BEPINEX_5_MAX = "5.99.99.99";
+const DOORSTOP_4 = "4.0.0";
+export const RULES = [
+    {
+        id: "vh-bepinex-5-only",
+        game: "valheim",
+        component: "bepinex",
+        requires: [{ component: "bepinex", max: BEPINEX_5_MAX }],
+        undeterminedSeverity: "info",
+        note: "Valheim plugins are BepInEx 5 assemblies; BepInEx 6's own release notes say BepInEx 5 plugins will not work with it and tell BepInEx 5 users to stay on 5.",
+        source: "https://github.com/BepInEx/BepInEx/releases/tag/v6.0.0-pre.2",
+    },
+    {
+        id: "vh-bepinex-without-pack",
+        game: "valheim",
+        component: "bepinexpack-missing",
+        requires: [],
+        advisory: true,
+        severity: "warn",
+        note: "BepInEx is installed without the Valheim pack's files: Jötunn and most Valheim mods depend on denikson's BepInExPack_Valheim, which differs from stock (SemVer plugin versions accepted, console on, isModded forced true). Stock or outdated BepInEx is the wiki's first client failure mode.",
+        source: "https://thunderstore.io/c/valheim/p/denikson/BepInExPack_Valheim/; https://github.com/Valheim-Modding/Wiki/wiki/Client-Troubleshooting",
+    },
+    {
+        id: "vh-jotunn-needs-pack",
+        game: "valheim",
+        component: "jotunn",
+        requires: [{ component: "bepinexpack-missing" }],
+        advisory: true,
+        severity: "block",
+        note: "Jötunn is installed on a BepInEx that is not the Valheim pack; Jötunn's manifest depends on denikson-BepInExPack_Valheim and its guide says a GitHub BepInEx release may not work properly.",
+        source: "https://valheim-modding.github.io/Jotunn/guides/guide.html; Jötunn's Thunderstore manifest",
+    },
+    {
+        id: "vh-doorstop-ini-legacy-under-doorstop-4",
+        game: "valheim",
+        component: "doorstop-ini-legacy",
+        requires: [{ component: "doorstop", max: "3.99.99" }],
+        note: "doorstop_config.ini is in the [UnityDoorstop] shape while the installed Doorstop is 4.x (BepInEx 5.4.23+ renamed every key); the loader reads nothing and the game starts unmodded.",
+        source: "https://github.com/BepInEx/BepInEx/releases/tag/v5.4.23.2",
+    },
+    {
+        id: "vh-doorstop-ini-modern-under-doorstop-3",
+        game: "valheim",
+        component: "doorstop-ini-modern",
+        requires: [{ component: "doorstop", min: DOORSTOP_4 }],
+        note: "doorstop_config.ini is in the [General]/[UnityMono] shape while the installed Doorstop is older than 4; the pre-5.4.23 loader reads [UnityDoorstop] and loads nothing.",
+        source: "https://github.com/BepInEx/BepInEx/releases/tag/v5.4.23.2",
+    },
+    {
+        id: "vh-game-update-invalidates-plugins",
+        game: "valheim",
+        component: "game",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "A Valheim update invalidates compiled plugins (Valheim 1.0 broke most of them); the MissingMethodException a stale plugin throws is logged at Debug or to Player.log, so LogOutput.log can look clean while the game is broken.",
+        source: "BepInEx v5-lts TypeLoader.cs and Chainloader.cs",
+    },
+];
+export const valheimCompat = { detectComponents, rules: RULES };

package/dist/surfaces/valheim/index/index.js

@@ -0,0 +1,301 @@
+import { promises as fs } from "node:fs";
+import { defaultCacheDir, indexFile, IndexStore } from "../../../core/knowledge/store.js";
+import { resolveDataDir } from "../../../core/userconfig.js";
+import { cellName, findJotunnDataDir, listJotunnDataFiles, parseJotunnMarkdown, plainText } from "./tables.js";
+export const JOTUNN_DATA_ENV = "MODWRIGHT_VALHEIM_JOTUNN_DATA";
+export const JOTUNN_DATA_ID = "valheim.jotunn";
+const GAME = "valheim";
+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 source (
+      id INTEGER PRIMARY KEY,
+      kind TEXT NOT NULL,
+      path TEXT NOT NULL,
+      mtime TEXT
+    );
+    CREATE TABLE IF NOT EXISTS jotunn_table (
+      id INTEGER PRIMARY KEY,
+      kind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      game_version TEXT,
+      section TEXT,
+      columns_json TEXT NOT NULL,
+      row_count INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS entry (
+      id INTEGER PRIMARY KEY,
+      kind TEXT NOT NULL,
+      name TEXT NOT NULL COLLATE NOCASE,
+      asset_id TEXT COLLATE NOCASE,
+      token TEXT COLLATE NOCASE,
+      english_name TEXT COLLATE NOCASE,
+      section TEXT,
+      table_id INTEGER NOT NULL REFERENCES jotunn_table(id),
+      data_json TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_entry_kind_name ON entry(kind, name);
+    CREATE INDEX IF NOT EXISTS idx_entry_asset ON entry(asset_id);
+    CREATE INDEX IF NOT EXISTS idx_entry_token ON entry(token);
+    CREATE INDEX IF NOT EXISTS idx_entry_english ON entry(english_name);
+  `);
+}
+export function isBuilt(store) {
+    const row = store.get("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'entry'");
+    return row !== undefined && store.get("SELECT COUNT(*) AS n FROM entry")?.n > 0;
+}
+function columnIndex(columns, ...names) {
+    const lower = columns.map((c) => c.toLowerCase());
+    for (const n of names) {
+        const i = lower.indexOf(n.toLowerCase());
+        if (i >= 0)
+            return i;
+    }
+    return -1;
+}
+export async function importJotunnFile(store, dataFile) {
+    const text = await fs.readFile(dataFile.file, "utf8");
+    const parsed = parseJotunnMarkdown(text);
+    const stat = await fs.stat(dataFile.file);
+    store.run("INSERT INTO source (kind, path, mtime) VALUES (?, ?, ?)", ["jotunn", dataFile.relative, stat.mtime.toISOString()]);
+    let rows = 0;
+    for (const table of parsed.tables) {
+        store.run("INSERT INTO jotunn_table (kind, file, game_version, section, columns_json, row_count) VALUES (?, ?, ?, ?, ?, ?)", [
+            dataFile.kind,
+            dataFile.relative,
+            parsed.gameVersion ?? null,
+            table.section ?? null,
+            JSON.stringify(table.columns),
+            table.rows.length,
+        ]);
+        const tableId = store.get("SELECT last_insert_rowid() AS id")?.id;
+        const assetCol = columnIndex(table.columns, "AssetID", "Asset ID");
+        const tokenCol = columnIndex(table.columns, "Token");
+        const englishCol = columnIndex(table.columns, "English Name");
+        const cell = (r, i) => (i >= 0 ? plainText(r[i] ?? "") || null : null);
+        const batch = [];
+        for (const r of table.rows) {
+            const name = cellName(r[0] ?? "");
+            if (name.length === 0)
+                continue;
+            const data = {};
+            table.columns.forEach((c, i) => {
+                data[c] = plainText(r[i] ?? "");
+            });
+            batch.push([dataFile.kind, name, cell(r, assetCol), cell(r, tokenCol), cell(r, englishCol), table.section ?? null, tableId, JSON.stringify(data)]);
+        }
+        if (batch.length > 0)
+            store.insertMany("entry", ["kind", "name", "asset_id", "token", "english_name", "section", "table_id", "data_json"], batch);
+        rows += batch.length;
+    }
+    return { file: dataFile.relative, kind: dataFile.kind, ...(parsed.gameVersion !== undefined ? { gameVersion: parsed.gameVersion } : {}), tables: parsed.tables.length, rows };
+}
+function summarize(store, sources) {
+    const file = indexFile(defaultCacheDir(), GAME);
+    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,
+        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("(Jötunn index already built — pass { force: true } to rebuild)");
+        return summarize(store, sources);
+    }
+    store.exec("DELETE FROM entry; DELETE FROM jotunn_table; DELETE FROM source; DELETE FROM meta;");
+    const requested = options.dataDir ?? (await resolveDataDir(JOTUNN_DATA_ID, JOTUNN_DATA_ENV))?.path;
+    if (!requested) {
+        sources.push(`no Jötunn data: set ${JOTUNN_DATA_ENV}, or remember the folder once with check_toolchain action=remember data=${JOTUNN_DATA_ID} dataPath=<folder>, pointing at a Valheim-Modding/Jotunn checkout (or its JotunnLib/Documentation/data folder); nothing was indexed.`);
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+        return summarize(store, sources);
+    }
+    const dataDir = await findJotunnDataDir(requested);
+    if (!dataDir) {
+        sources.push(`${requested} is not a Jötunn checkout or data directory (no prefabs/ or objects/ folder found under it or JotunnLib/Documentation/data); nothing was indexed.`);
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+        return summarize(store, sources);
+    }
+    let files = await listJotunnDataFiles(dataDir);
+    if (options.only && options.only.length > 0) {
+        const wanted = new Set(options.only.map((k) => k.toLowerCase().replace(/-/g, "_")));
+        files = files.filter((f) => wanted.has(f.kind));
+    }
+    const versions = new Map();
+    const errors = [];
+    let index = 0;
+    for (const f of files) {
+        options.progress?.({ step: `jotunn:${f.kind}`, done: index++, total: files.length, note: f.relative });
+        try {
+            const summary = await importJotunnFile(store, f);
+            sources.push(`${f.relative} (${summary.kind}, Valheim ${summary.gameVersion ?? "version not stated"}, ${summary.rows} rows in ${summary.tables} table${summary.tables === 1 ? "" : "s"})`);
+            if (summary.gameVersion)
+                versions.set(f.kind, summary.gameVersion);
+        }
+        catch (err) {
+            errors.push(`${f.relative}: ${err.message}`);
+        }
+    }
+    const distinct = new Set(versions.values());
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('dataDir', ?)", [dataDir]);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('gameVersions', ?)", [JSON.stringify(Object.fromEntries(versions))]);
+    if (distinct.size === 1) {
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('gameVersion', ?)", [[...distinct][0]]);
+    }
+    else if (distinct.size > 1) {
+        sources.push(`the dumps state ${distinct.size} different game versions (${[...distinct].sort().join(", ")}); no single index version is recorded, each table carries its own.`);
+    }
+    if (errors.length > 0) {
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('buildErrors', ?)", [JSON.stringify(errors.slice(0, 200))]);
+        sources.push(`${errors.length} file(s) failed to parse — see meta.buildErrors.`);
+    }
+    if (files.length === 0)
+        sources.push(`${dataDir}: no *-list.md files found.`);
+    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 kind, file, game_version, row_count FROM jotunn_table ORDER BY id");
+        if (rows.length > 0)
+            result.sources = rows.map((r) => `${r.file} (${r.kind}, Valheim ${r.game_version ?? "version not stated"}, ${r.row_count} rows)`);
+    }
+    catch {
+    }
+    finally {
+        store?.close();
+    }
+    return result;
+}
+const DEFAULT_LIMIT = 50;
+function str(v) {
+    if (v === undefined)
+        return undefined;
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+}
+function limitOf(params) {
+    const n = Number(params.limit);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_LIMIT;
+}
+export function queryKinds() {
+    return [
+        { kind: "kinds", description: "The JotunnDoc tables in the index, each with its stated Valheim version and row count.", params: [] },
+        { kind: "entry", description: "Objects of one kind (prefab, item, piece, recipe, status_effect, location, vegetation, rpc, character, material, mesh, shader, sprite, piece_table, ...) by exact name, or by `contains` substring; every column of the dump comes back in `data`.", params: ["kind", "name", "contains", "limit"] },
+        { kind: "prefab", description: "A prefab by name (exact, case-insensitive) or `contains`: its AssetID, localization token, English name and components.", params: ["name", "contains", "limit"] },
+        { kind: "item", description: "An item by name or `contains`: AssetID, token, English name, item type, description.", params: ["name", "contains", "limit"] },
+        { kind: "piece", description: "A buildable piece by name or `contains`, with the piece table it belongs to.", params: ["name", "contains", "limit"] },
+        { kind: "recipe", description: "A recipe by name or `contains`: the item it makes, amount, resources.", params: ["name", "contains", "limit"] },
+        { kind: "asset", description: "Whatever carries a given AssetID, across every kind (Iron Gate's stable key across renames); the mesh list's `Asset ID` column counts.", params: ["id", "limit"] },
+        { kind: "token", description: "Whatever carries a given localization token ($item_..., $piece_...), across every kind, or the English name it resolves to.", params: ["token", "english", "limit"] },
+    ];
+}
+function rowsOut(rows) {
+    return rows.map((r) => {
+        const { data_json, ...rest } = r;
+        return { ...rest, data: typeof data_json === "string" ? JSON.parse(data_json) : undefined };
+    });
+}
+const ENTRY_COLUMNS = "e.kind, e.name, e.asset_id AS assetId, e.token, e.english_name AS englishName, e.section, t.game_version AS gameVersion, t.file, e.data_json";
+function likeEscape(text) {
+    return text.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+function byName(store, kind, params) {
+    const limit = limitOf(params);
+    const name = str(params.name);
+    const contains = str(params.contains);
+    const where = [];
+    const args = [];
+    if (kind) {
+        where.push("e.kind = ?");
+        args.push(kind);
+    }
+    if (name) {
+        where.push("e.name = ? COLLATE NOCASE");
+        args.push(name);
+    }
+    else if (contains) {
+        where.push("e.name LIKE ? ESCAPE '\\'");
+        args.push(`%${likeEscape(contains)}%`);
+    }
+    const sql = `SELECT ${ENTRY_COLUMNS} FROM entry e JOIN jotunn_table t ON t.id = e.table_id${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY e.name LIMIT ?`;
+    const rows = store.all(sql, [...args, limit + 1]);
+    const truncated = rows.length > limit;
+    const out = rowsOut(rows.slice(0, limit));
+    const what = kind ?? "any kind";
+    const note = name ? `${what} named "${name}" (exact, case-insensitive)` : contains ? `${what} whose name contains "${contains}"` : `every ${what} entry, first ${limit}`;
+    return { kind: kind ?? "entry", params, count: out.length, ...(truncated ? { truncated: true } : {}), rows: out, note: `${note}; each row's gameVersion is the version its JotunnDoc dump states.` };
+}
+export async function query(store, kind, params) {
+    if (!isBuilt(store)) {
+        return { kind, params, count: 0, rows: [], note: `No Valheim index has been built: run build_index once a Jötunn checkout is set (${JOTUNN_DATA_ENV}) or remembered (check_toolchain action=remember data=${JOTUNN_DATA_ID}).` };
+    }
+    switch (kind) {
+        case "kinds": {
+            const rows = store.all("SELECT kind, file, game_version AS gameVersion, section, row_count AS rows FROM jotunn_table ORDER BY kind, id");
+            return { kind, params, count: rows.length, rows, note: "One row per table imported from the JotunnDoc dumps, with the Valheim version each file states." };
+        }
+        case "entry": {
+            const k = str(params.kind);
+            return byName(store, k, params);
+        }
+        case "prefab":
+        case "item":
+        case "piece":
+        case "recipe":
+            return byName(store, kind, params);
+        case "asset": {
+            const id = str(params.id);
+            if (!id)
+                return { kind, params, count: 0, rows: [], note: "asset needs `id`, a 32-hex AssetID." };
+            const limit = limitOf(params);
+            const rows = store.all(`SELECT ${ENTRY_COLUMNS} FROM entry e JOIN jotunn_table t ON t.id = e.table_id WHERE e.asset_id = ? COLLATE NOCASE ORDER BY e.kind, e.name LIMIT ?`, [id, limit + 1]);
+            const truncated = rows.length > limit;
+            return { kind, params, count: Math.min(rows.length, limit), ...(truncated ? { truncated: true } : {}), rows: rowsOut(rows.slice(0, limit)), note: `entries of every kind carrying AssetID ${id}.` };
+        }
+        case "token": {
+            const token = str(params.token);
+            const english = str(params.english);
+            const limit = limitOf(params);
+            if (!token && !english)
+                return { kind, params, count: 0, rows: [], note: "token needs `token` (e.g. $item_sword_bronze) or `english` (the displayed name)." };
+            const rows = token
+                ? store.all(`SELECT ${ENTRY_COLUMNS} FROM entry e JOIN jotunn_table t ON t.id = e.table_id WHERE e.token = ? COLLATE NOCASE ORDER BY e.kind, e.name LIMIT ?`, [token, limit + 1])
+                : store.all(`SELECT ${ENTRY_COLUMNS} FROM entry e JOIN jotunn_table t ON t.id = e.table_id WHERE e.english_name = ? COLLATE NOCASE ORDER BY e.kind, e.name LIMIT ?`, [english, limit + 1]);
+            const truncated = rows.length > limit;
+            return { kind, params, count: Math.min(rows.length, limit), ...(truncated ? { truncated: true } : {}), rows: rowsOut(rows.slice(0, limit)), note: token ? `entries whose localization token is ${token}.` : `entries whose English name is "${english}".` };
+        }
+        default:
+            return { kind, params, count: 0, rows: [], note: `Unknown kind "${kind}"; call kind "kinds" or see queryKinds().` };
+    }
+}
+export const valheimIndex = { info, build: buildIndex, queryKinds, query };
+export { parseJotunnMarkdown, plainText, cellName, kindOfFile, findJotunnDataDir, listJotunnDataFiles } from "./tables.js";

package/dist/surfaces/valheim/index/tables.js

@@ -0,0 +1,103 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+const VERSION_RE = /generated from Valheim (\S+?) using/i;
+function splitRow(line) {
+    let body = line.trim();
+    if (body.startsWith("|"))
+        body = body.slice(1);
+    if (body.endsWith("|"))
+        body = body.slice(0, -1);
+    return body.split("|").map((c) => c.trim());
+}
+const isSeparator = (cells) => cells.length > 0 && cells.every((c) => /^:?-{3,}:?$/.test(c));
+export function parseJotunnMarkdown(text) {
+    const lines = text.split(/\r?\n/);
+    const out = { tables: [] };
+    let section;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (out.gameVersion === undefined) {
+            const m = VERSION_RE.exec(line);
+            if (m)
+                out.gameVersion = m[1];
+        }
+        if (/^#\s+/.test(line) && out.title === undefined)
+            out.title = line.replace(/^#\s+/, "").trim();
+        const heading = /^##\s+(.+)$/.exec(line);
+        if (heading) {
+            section = heading[1].trim();
+            i++;
+            continue;
+        }
+        if (line.trim().startsWith("|") && i + 1 < lines.length && isSeparator(splitRow(lines[i + 1]))) {
+            const columns = splitRow(line);
+            const table = { ...(section !== undefined ? { section } : {}), columns, rows: [], line: i + 1 };
+            i += 2;
+            while (i < lines.length && lines[i].trim().startsWith("|")) {
+                const cells = splitRow(lines[i]);
+                if (cells.length > columns.length) {
+                    const head = cells.slice(0, columns.length - 1);
+                    head.push(cells.slice(columns.length - 1).join("|"));
+                    table.rows.push(head);
+                }
+                else {
+                    while (cells.length < columns.length)
+                        cells.push("");
+                    table.rows.push(cells);
+                }
+                i++;
+            }
+            out.tables.push(table);
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+export function plainText(cell) {
+    return cell
+        .replace(/<\/(?:li|dd|dt)>\s*<(?:li|dd|dt)\b[^>]*>/g, "; ")
+        .replace(/<br\s*\/?>/gi, " ")
+        .replace(/<[^>]*>/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function cellName(cell) {
+    const tag = cell.indexOf("<");
+    const head = tag > 0 ? plainText(cell.slice(0, tag)) : "";
+    return head.length > 0 ? head : plainText(cell);
+}
+export function kindOfFile(fileName) {
+    const m = /^([a-z0-9-]+)-list\.md$/i.exec(fileName);
+    return m ? m[1].toLowerCase().replace(/-/g, "_") : undefined;
+}
+export async function findJotunnDataDir(dir) {
+    for (const candidate of [dir, path.join(dir, "JotunnLib", "Documentation", "data"), path.join(dir, "Documentation", "data"), path.join(dir, "data")]) {
+        try {
+            const entries = await fs.readdir(candidate, { withFileTypes: true });
+            if (entries.some((e) => e.isDirectory() && (e.name === "prefabs" || e.name === "objects")))
+                return candidate;
+        }
+        catch {
+        }
+    }
+    return undefined;
+}
+export async function listJotunnDataFiles(dataDir) {
+    const out = [];
+    const visit = async (dir, rel) => {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            if (e.isDirectory()) {
+                await visit(path.join(dir, e.name), [...rel, e.name]);
+                continue;
+            }
+            const kind = kindOfFile(e.name);
+            if (kind)
+                out.push({ kind, file: path.join(dir, e.name), relative: [...rel, e.name].join("/") });
+        }
+    };
+    await visit(dataDir, []);
+    return out;
+}

package/dist/surfaces/valheim/index.js

@@ -0,0 +1,11 @@
+export { valheim, installKind, diskLoggingDisabled } from "./surface.js";
+export { valheimCompat, doorstopIniGeneration } from "./compat.js";
+export { valheimIndex, buildIndex as buildValheimIndex, JOTUNN_DATA_ENV, JOTUNN_DATA_ID } from "./index/index.js";
+export { parseJotunnMarkdown, kindOfFile, findJotunnDataDir, listJotunnDataFiles } from "./index/tables.js";
+export { parseThunderstoreManifest, parseDependencyString, readPngDimensions, routeOf, checkThunderstoreToml, PACKAGE_ROUTES } from "./packaging.js";
+export { scanPluginSource, scanCfg, packageNameMatchesGuid, BEPINPLUGIN_GUID_RE } from "./plugins.js";
+export { PACKAGING_VALIDATORS, GAME_ASSEMBLY_RE } from "./validators/packaging.js";
+export { PLUGIN_VALIDATORS } from "./validators/plugins.js";
+export { REFERENCE_VALIDATORS } from "./validators/references.js";
+export { scanReferences, translationKeys } from "./references.js";
+export { SIGNATURES } from "./logs.js";