modwright 0.1.0

package/dist/surfaces/baldursgate3/compat.js

@@ -0,0 +1,164 @@
+import * as path from "node:path";
+import { readPeFileVersion } from "../../core/compat/pe.js";
+import { isDirectory, localAppData, pathExists, readTextIfExists, resolveCandidate } from "../../core/fsutil.js";
+import { promises as fs } from "node:fs";
+import { scriptExtenderLogDirs } from "./settings.js";
+function larianDir() {
+    return localAppData("Larian Studios", "Baldur's Gate 3");
+}
+const SE_BUILD_RE = /BG3Ext\s+v(\d+)/i;
+const SE_GAME_VERSION_RE = /Game version\s+v?([\d.]+)/i;
+async function detectComponents(install) {
+    const gameExe = path.join(install.root, "bin", "bg3_dx11.exe");
+    const gameInstalled = await pathExists(gameExe);
+    let gameVersion = await readPeFileVersion(gameExe);
+    let gameSource = gameVersion ? "bin/bg3_dx11.exe (PE FileVersion)" : undefined;
+    const dwrite = path.join(install.root, "bin", "DWrite.dll");
+    const dwriteInstalled = await pathExists(dwrite);
+    const larian = larianDir();
+    const seLogCandidates = scriptExtenderLogDirs(install).map((dir) => path.join(dir, "Extender Runtime *.log"));
+    const seLogHit = await resolveCandidate(seLogCandidates);
+    const seLog = seLogHit ? await readTextIfExists(seLogHit.path) : undefined;
+    let extenderVersion;
+    let extenderSource;
+    if (seLog) {
+        const buildMatch = seLog.match(SE_BUILD_RE);
+        if (buildMatch?.[1]) {
+            extenderVersion = buildMatch[1];
+            extenderSource = `${path.basename(seLogHit.path)} ("BG3Ext vNN" startup line, heuristic — format confirmed on one sample, see module comment)`;
+        }
+        if (!gameVersion) {
+            const gameMatch = seLog.match(SE_GAME_VERSION_RE);
+            if (gameMatch?.[1]) {
+                gameVersion = gameMatch[1];
+                gameSource = `${path.basename(seLogHit.path)} ("Game version" startup line, heuristic)`;
+            }
+        }
+    }
+    if (!extenderVersion && dwriteInstalled) {
+        const cached = await newestCachedExtenderBuild(updaterCacheDir());
+        if (cached) {
+            const dllVersion = await readPeFileVersion(cached.dll);
+            const major = dllVersion?.split(".")[0];
+            if (major && major !== "0") {
+                extenderVersion = major;
+                extenderSource =
+                    `BG3ScriptExtender updater cache, newest cached build ${cached.folder} ` +
+                        "(BG3ScriptExtender.dll PE FileVersion; heuristic — the loader uses the newest build " +
+                        "the game version accepts, which is normally this one)";
+            }
+        }
+    }
+    const components = [
+        {
+            id: "game",
+            label: "Baldur's Gate 3",
+            kind: "game",
+            installed: gameInstalled,
+            version: gameVersion,
+            source: gameSource,
+            path: gameExe,
+        },
+        {
+            id: "scriptextender",
+            label: "Script Extender (BG3SE)",
+            kind: "loader",
+            installed: dwriteInstalled,
+            version: extenderVersion,
+            source: extenderSource,
+            path: dwrite,
+        },
+    ];
+    const nativeModsDir = path.join(install.root, "bin", "NativeMods");
+    components.push({
+        id: "nativemodloader",
+        label: "Native Mod Loader",
+        kind: "loader",
+        installed: await isDirectory(nativeModsDir),
+        path: nativeModsDir,
+    });
+    const modsDir = path.join(larian, "Mods");
+    const pakNames = await listPakBasenames(modsDir);
+    components.push({
+        id: "mcm",
+        label: "Mod Configuration Menu",
+        kind: "framework",
+        installed: pakNames.some((n) => /\b(mod configuration menu|bg3[\s_-]?mcm|\bmcm\b)/i.test(n)),
+        source: "Mods/*.pak filename match only — no manifest is read, so this can miss a renamed file or false-positive on an unrelated name.",
+        path: modsDir,
+    });
+    components.push({
+        id: "compatibilityframework",
+        label: "Compatibility Framework",
+        kind: "framework",
+        installed: pakNames.some((n) => /compatibility framework/i.test(n)),
+        source: "Mods/*.pak filename match only — no manifest is read, so this can miss a renamed file or false-positive on an unrelated name.",
+        path: modsDir,
+    });
+    return components;
+}
+function updaterCacheDir() {
+    return localAppData("BG3ScriptExtender", "ScriptExtender");
+}
+const CACHED_BUILD_RE = /^(\d+)\.\d+\.\d+\.\d+_[0-9a-f]{16,}$/i;
+export async function newestCachedExtenderBuild(cacheDir) {
+    let entries;
+    try {
+        entries = (await fs.readdir(cacheDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return undefined;
+    }
+    const builds = entries
+        .map((folder) => ({ folder, major: Number(CACHED_BUILD_RE.exec(folder)?.[1] ?? NaN) }))
+        .filter((b) => Number.isFinite(b.major))
+        .sort((a, b) => b.major - a.major);
+    for (const build of builds) {
+        const dll = path.join(cacheDir, build.folder, "BG3ScriptExtender.dll");
+        if (await pathExists(dll))
+            return { ...build, dll };
+    }
+    return undefined;
+}
+async function listPakBasenames(dir) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && e.name.toLowerCase().endsWith(".pak"))
+            .map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+const RULES = [
+    {
+        id: "bg3-se-latest-patch-only",
+        game: "baldursgate3",
+        component: "scriptextender",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "Script Extender only officially supports the game's current patch. After a BG3 update, " +
+            "check the latest bg3se Updater Release notes before assuming a mod (rather than a stale SE) broke.",
+        source: "https://github.com/Norbyte/bg3se/blob/master/TROUBLESHOOTING.md",
+    },
+    {
+        id: "bg3-se-mcm-patch7-interop",
+        game: "baldursgate3",
+        component: "scriptextender",
+        requires: [{ component: "mcm" }, { component: "game" }],
+        advisory: true,
+        versionGate: "game",
+        severity: "warn",
+        undeterminedSeverity: "info",
+        note: "Script Extender and the Mod Configuration Menu are known to interfere with each other as of " +
+            "BG3 Patch 7, with no fixed timeline from either project. If MCM's window will not open, this " +
+            "is the first thing to check rather than the mod itself.",
+        source: "https://github.com/Norbyte/bg3se/issues/462",
+    },
+];
+export const baldursgate3Compat = {
+    detectComponents,
+    rules: RULES,
+};

package/dist/surfaces/baldursgate3/identity.js

@@ -0,0 +1,110 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { readTextIfExists } from "../../core/fsutil.js";
+import { parseMetaLsxModuleInfo } from "../../core/lsx.js";
+import { readPakModuleInfos } from "./pak.js";
+const pakInfoCache = new Map();
+function cachedPakModuleInfos(pakPath, size, mtimeMs) {
+    const key = JSON.stringify([pakPath, size, mtimeMs]);
+    let cached = pakInfoCache.get(key);
+    if (!cached) {
+        cached = readPakModuleInfos(pakPath);
+        pakInfoCache.set(key, cached);
+        cached.catch(() => pakInfoCache.delete(key));
+    }
+    return cached;
+}
+export async function scanPaksIdentities(paksRootPath) {
+    const copies = [];
+    const unreadable = [];
+    let entries;
+    try {
+        entries = await fs.readdir(paksRootPath);
+    }
+    catch {
+        return { copies, unreadable };
+    }
+    for (const entryName of entries) {
+        if (path.extname(entryName).toLowerCase() !== ".pak")
+            continue;
+        const pakPath = path.join(paksRootPath, entryName);
+        let mtime;
+        let stat;
+        try {
+            stat = await fs.stat(pakPath);
+            mtime = stat.mtime.toISOString();
+        }
+        catch {
+            continue;
+        }
+        let infos;
+        try {
+            infos = await cachedPakModuleInfos(pakPath, stat.size, stat.mtimeMs);
+        }
+        catch (error) {
+            unreadable.push({ path: pakPath, error: error.message });
+            continue;
+        }
+        for (const info of infos) {
+            if (!info.folder && !info.uuid)
+                continue;
+            copies.push({
+                path: pakPath,
+                rootId: "paks",
+                folder: info.folder ?? path.basename(pakPath, path.extname(pakPath)),
+                name: info.name,
+                uuid: info.uuid,
+                modifiedAt: mtime,
+            });
+        }
+    }
+    return { copies, unreadable };
+}
+export async function scanLooseIdentities(looseRootPath) {
+    const copies = [];
+    const unreadable = [];
+    const modsDir = path.join(looseRootPath, "Mods");
+    let entries;
+    try {
+        entries = await fs.readdir(modsDir, { withFileTypes: true });
+    }
+    catch {
+        return { copies, unreadable };
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const metaPath = path.join(modsDir, entry.name, "meta.lsx");
+        let stat;
+        try {
+            stat = await fs.stat(metaPath);
+        }
+        catch {
+            continue;
+        }
+        const text = await readTextIfExists(metaPath);
+        if (!text) {
+            unreadable.push({ path: metaPath, error: "could not read meta.lsx" });
+            continue;
+        }
+        const info = parseMetaLsxModuleInfo(text);
+        if (!info || (!info.folder && !info.uuid))
+            continue;
+        copies.push({
+            path: metaPath,
+            rootId: "loose",
+            folder: info.folder ?? entry.name,
+            name: info.name,
+            uuid: info.uuid,
+            modifiedAt: stat.mtime.toISOString(),
+        });
+    }
+    return { copies, unreadable };
+}
+export async function scanModIdentities(paksRootPath, looseRootPath) {
+    const [paks, loose] = await Promise.all([scanPaksIdentities(paksRootPath), scanLooseIdentities(looseRootPath)]);
+    return {
+        copies: [...paks.copies, ...loose.copies],
+        unreadable: [...paks.unreadable, ...loose.unreadable],
+    };
+}

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

@@ -0,0 +1,331 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { pathExists, walk } from "../../../core/fsutil.js";
+import { defaultCacheDir } from "../../../core/knowledge/store.js";
+import { assertAbsolute, locateTool, runTool, toNativePath, TOOL_SPECS } from "../../../core/toolchain/index.js";
+import { info } from "./info.js";
+import { parseLoca } from "./parsers/loca.js";
+import { parseLsx, walkLsxNodes } from "./parsers/lsx.js";
+import { parseStats } from "./parsers/stats.js";
+import { parseTreasureTable } from "./parsers/treasuretable.js";
+import { createSchema } from "./schema.js";
+export const VANILLA_PAKS = ["Shared.pak", "Gustav.pak", "GustavX.pak", "Localization/English.pak"];
+const STATS_PATTERN = /\/Stats\/Generated\/Data\/[^/]+\.txt$/i;
+const TREASURE_PATTERN = /\/Stats\/Generated\/TreasureTable\.txt$/i;
+const LSX_PATTERNS = [
+    /\/Lists\/[^/]+\.lsx$/i,
+    /\/Progressions\/[^/]+\.lsx$/i,
+    /\/ClassDescriptions\/[^/]+\.lsx$/i,
+    /\/Tags\/[^/]+\.lsx$/i,
+    /\/RootTemplates\/[^/]+\.lsx$/i,
+    /\/GUI\/[^/]+\.lsx$/i,
+    /\/ActionResourceDefinitions\/[^/]+\.lsx$/i,
+    /\/(Content\/)?Assets\/.*\.lsx$/i,
+];
+const LOCA_XML_PATTERN = /(?:^|\/)Localization\/[^/]+\/[^/]+\.xml$/i;
+const EXTRACT_EXPRESSION = "^(Public/[^/]+/(Stats/Generated|Lists|Progressions|ClassDescriptions|Tags|RootTemplates|GUI|ActionResourceDefinitions)/.*" +
+    "|Public/[^/]+/(Content/)?Assets/.*\\.lsf" +
+    "|(.*/)?Localization/.*)$";
+const INDEXED_NODE_IDS = new Set([
+    "SpellList",
+    "Progression",
+    "ClassDescription",
+    "Tag",
+    "Tags",
+    "GameObjects",
+    "IconUV",
+    "TextureAtlasPath",
+    "ActionResourceDefinition",
+    "Resource",
+]);
+function uuidFor(node) {
+    return node.attributes.UUID?.value ?? node.attributes.ClassUUID?.value ??
+        (node.id === "GameObjects" ? node.attributes.MapKey?.value : undefined) ??
+        (node.id === "Resource" ? node.attributes.ID?.value : undefined);
+}
+function nameFor(node) {
+    return node.attributes.Name?.value ?? (node.id === "IconUV" ? node.attributes.MapKey?.value : undefined);
+}
+async function collectFiles(root, patterns) {
+    if (!(await pathExists(root)))
+        return [];
+    const walked = await walk(root, { limit: 500_000 });
+    return walked.files.filter((f) => patterns.some((p) => p.test(f))).map((rel) => ({ abs: path.join(root, rel), rel }));
+}
+async function collectLsxFiles(extractDir, convertedDir) {
+    const [native, converted] = await Promise.all([
+        collectFiles(extractDir, LSX_PATTERNS),
+        collectFiles(convertedDir, LSX_PATTERNS),
+    ]);
+    const byRel = new Map();
+    for (const file of native)
+        byRel.set(file.rel, file);
+    for (const file of converted)
+        byRel.set(file.rel, file);
+    return [...byRel.values()];
+}
+function insertInBatches(store, table, columns, rows, step, progress, batchSize = 5000) {
+    if (rows.length === 0) {
+        progress?.({ step, done: 0, total: 0 });
+        return;
+    }
+    for (let i = 0; i < rows.length; i += batchSize) {
+        const batch = rows.slice(i, i + batchSize);
+        store.transaction(() => {
+            store.insertMany(table, columns, batch);
+        });
+        progress?.({ step, done: Math.min(i + batchSize, rows.length), total: rows.length });
+    }
+}
+async function insertParsedFiles(store, sourceId, files, progress) {
+    let nextStatId = (Number(store.get(`SELECT COALESCE(MAX(id), 0) AS m FROM stat`)?.m) || 0) + 1;
+    const statRows = [];
+    const fieldRows = [];
+    const ftsRows = [];
+    progress?.({ step: "parse-stats", total: files.statFiles.length, note: sourceId });
+    for (const { abs, rel } of files.statFiles) {
+        const text = await fs.readFile(abs, "utf8");
+        for (const entry of parseStats(text, rel)) {
+            const id = nextStatId++;
+            statRows.push([id, entry.name, entry.type, entry.using ?? null, sourceId, entry.file, entry.line]);
+            for (const [field, value] of Object.entries(entry.fields)) {
+                fieldRows.push([id, field, value]);
+                ftsRows.push([entry.name, field, value]);
+            }
+        }
+    }
+    insertInBatches(store, "stat", ["id", "name", "type", '"using"', "source_id", "file", "line"], statRows, "insert-stat", progress);
+    insertInBatches(store, "stat_field", ["stat_id", "field", "value"], fieldRows, "insert-stat-field", progress);
+    insertInBatches(store, "stat_field_fts", ["name", "field", "value"], ftsRows, "insert-stat-field-fts", progress);
+    const nodeRows = [];
+    progress?.({ step: "parse-lsx", total: files.lsxFiles.length, note: sourceId });
+    for (const { abs, rel } of files.lsxFiles) {
+        const text = await fs.readFile(abs, "utf8");
+        let doc;
+        try {
+            doc = parseLsx(text, rel);
+        }
+        catch (err) {
+            progress?.({ step: "parse-lsx-error", note: `${rel}: ${err instanceof Error ? err.message : String(err)}` });
+            continue;
+        }
+        for (const region of doc.regions) {
+            walkLsxNodes(region.root, (node, breadcrumb) => {
+                if (!INDEXED_NODE_IDS.has(node.id))
+                    return;
+                nodeRows.push([
+                    sourceId,
+                    rel,
+                    region.id,
+                    node.id,
+                    breadcrumb,
+                    uuidFor(node) ?? null,
+                    nameFor(node) ?? null,
+                    JSON.stringify(node.attributes),
+                ]);
+            });
+        }
+    }
+    progress?.({ step: "parse-treasure", total: files.treasureFiles.length, note: sourceId });
+    for (const { abs, rel } of files.treasureFiles) {
+        const text = await fs.readFile(abs, "utf8");
+        for (const entry of parseTreasureTable(text, rel)) {
+            nodeRows.push([
+                sourceId,
+                rel,
+                entry.treasuretable,
+                "TreasureCategory",
+                `TreasureTable/${entry.treasuretable}/subtable-${entry.subtableIndex}`,
+                null,
+                entry.category,
+                JSON.stringify({
+                    Category: { type: "LSString", value: entry.category },
+                    Args: { type: "LSString", value: entry.args },
+                    CanMerge: { type: "bool", value: entry.canMerge ? "True" : "False" },
+                    SubtableIndex: { type: "int32", value: String(entry.subtableIndex) },
+                }),
+            ]);
+        }
+    }
+    insertInBatches(store, "node", ["source_id", "file", "region", "node_id", "path", "uuid", "name", "attrs_json"], nodeRows, "insert-node", progress);
+    const locaByHandle = new Map();
+    progress?.({ step: "parse-loca", total: files.locaFiles.length, note: sourceId });
+    for (const { abs, rel } of files.locaFiles) {
+        const text = await fs.readFile(abs, "utf8");
+        let entries;
+        try {
+            entries = parseLoca(text, rel);
+        }
+        catch (err) {
+            progress?.({ step: "parse-loca-error", note: `${rel}: ${err instanceof Error ? err.message : String(err)}` });
+            continue;
+        }
+        for (const entry of entries)
+            locaByHandle.set(entry.handle, { version: entry.version, text: entry.text });
+    }
+    const locaRows = [];
+    const locaFtsRows = [];
+    for (const [handle, { version, text }] of locaByHandle) {
+        locaRows.push([handle, version, text]);
+        locaFtsRows.push([handle, text]);
+    }
+    insertInBatches(store, "loca", ["handle", "version", "text"], locaRows, "insert-loca", progress);
+    insertInBatches(store, "loca_fts", ["handle", "text"], locaFtsRows, "insert-loca-fts", progress);
+    return { statCount: statRows.length, nodeCount: nodeRows.length, locaCount: locaRows.length };
+}
+export async function indexFromDirectory(dir, store, progress) {
+    createSchema(store);
+    const absDir = path.resolve(dir);
+    const sourceId = `dir:${absDir}`;
+    store.run(`INSERT OR REPLACE INTO source (id, kind, path, mtime) VALUES (?, ?, ?, ?)`, [
+        sourceId,
+        "directory",
+        absDir,
+        new Date().toISOString(),
+    ]);
+    progress?.({ step: "walk", note: absDir });
+    const files = {
+        statFiles: await collectFiles(absDir, [STATS_PATTERN]),
+        lsxFiles: await collectFiles(absDir, LSX_PATTERNS),
+        locaFiles: await collectFiles(absDir, [LOCA_XML_PATTERN]),
+        treasureFiles: await collectFiles(absDir, [TREASURE_PATTERN]),
+    };
+    const counts = await insertParsedFiles(store, sourceId, files, progress);
+    return { sourceId, ...counts };
+}
+export async function buildIndex(install, store, options = {}) {
+    createSchema(store);
+    const progress = options.progress;
+    const divineSpec = TOOL_SPECS.find((spec) => spec.id === "divine");
+    if (!divineSpec)
+        throw new Error("No toolchain spec registered for 'divine'.");
+    const divine = options.locate
+        ? await options.locate("divine")
+        : await locateTool(divineSpec, { projectOverrides: options.toolOverrides });
+    if (!divine.found || !divine.path) {
+        throw new Error(`Cannot build the BG3 vanilla index: ${divine.hint ?? "divine.exe (LSLib) was not found."}`);
+    }
+    const cacheDir = defaultCacheDir();
+    const only = options.only;
+    const paks = VANILLA_PAKS.filter((pakName) => {
+        if (!only || only.length === 0)
+            return true;
+        const base = pakName.replace(/\.pak$/i, "");
+        return only.some((o) => o.toLowerCase() === base.toLowerCase());
+    });
+    const sources = [];
+    let statTotal = 0;
+    let nodeTotal = 0;
+    let locaTotal = 0;
+    for (const pakName of paks) {
+        const pakBase = pakName.replace(/\.pak$/i, "");
+        const pakPath = path.join(install.root, "Data", pakName);
+        if (!(await pathExists(pakPath))) {
+            progress?.({ step: "pak-missing", note: pakPath });
+            continue;
+        }
+        const extractDir = path.join(cacheDir, "baldursgate3", "extract", pakBase);
+        if (options.force || !(await pathExists(extractDir))) {
+            const pakAbs = path.resolve(pakPath);
+            const extractAbs = path.resolve(extractDir);
+            assertAbsolute([pakAbs, extractAbs]);
+            progress?.({ step: "extract", note: pakName });
+            const result = await runTool(divine, {
+                args: [
+                    "-g", "bg3", "-a", "extract-package",
+                    "-s", toNativePath(pakAbs), "-d", toNativePath(extractAbs),
+                    "-x", EXTRACT_EXPRESSION, "--use-regex",
+                ],
+                expectOutputs: [extractAbs],
+                timeoutMs: 10 * 60_000,
+            });
+            if (!result.ok) {
+                throw new Error(`divine extract-package failed for ${pakName}: ${result.error?.message ?? "unknown error"}` +
+                    (result.error?.hint ? ` (${result.error.hint})` : ""));
+            }
+        }
+        else {
+            progress?.({ step: "extract-cached", note: extractDir });
+        }
+        const convertedDir = path.join(cacheDir, "baldursgate3", "converted", pakBase);
+        if (options.force || !(await pathExists(convertedDir))) {
+            const extractAbs = path.resolve(extractDir);
+            const convertedAbs = path.resolve(convertedDir);
+            assertAbsolute([extractAbs, convertedAbs]);
+            const extractWalk = await walk(extractAbs, { limit: 200_000 });
+            const hasLsf = extractWalk.files.some((f) => /\.lsf$/i.test(f));
+            await fs.mkdir(convertedAbs, { recursive: true });
+            progress?.({ step: hasLsf ? "convert-resources" : "convert-resources-skipped", note: pakName });
+            const converted = hasLsf ? await runTool(divine, {
+                args: [
+                    "-g",
+                    "bg3",
+                    "-a",
+                    "convert-resources",
+                    "-i",
+                    "lsf",
+                    "-o",
+                    "lsx",
+                    "-s",
+                    toNativePath(extractAbs),
+                    "-d",
+                    toNativePath(convertedAbs),
+                ],
+                expectOutputs: [convertedAbs],
+                timeoutMs: 20 * 60_000,
+            }) : { ok: true, error: undefined };
+            if (!converted.ok) {
+                throw new Error(`divine convert-resources failed for ${pakName}: ${converted.error?.message ?? "unknown error"}`);
+            }
+            const locaWalk = await walk(extractAbs, { limit: 200_000 });
+            const locaFiles = locaWalk.files.filter((f) => /\.loca$/i.test(f));
+            for (const rel of locaFiles) {
+                const src = path.resolve(extractAbs, rel);
+                const dst = path.resolve(convertedAbs, rel.replace(/\.loca$/i, ".xml"));
+                assertAbsolute([src, dst]);
+                progress?.({ step: "convert-loca", note: rel });
+                const locaResult = await runTool(divine, {
+                    args: ["-g", "bg3", "-a", "convert-loca", "-s", toNativePath(src), "-d", toNativePath(dst)],
+                    expectOutputs: [dst],
+                    timeoutMs: 60_000,
+                });
+                if (!locaResult.ok) {
+                    throw new Error(`divine convert-loca failed for ${rel}: ${locaResult.error?.message ?? "unknown error"}`);
+                }
+            }
+        }
+        else {
+            progress?.({ step: "convert-cached", note: convertedDir });
+        }
+        const files = {
+            statFiles: await collectFiles(extractDir, [STATS_PATTERN]),
+            lsxFiles: await collectLsxFiles(extractDir, convertedDir),
+            locaFiles: await collectFiles(convertedDir, [LOCA_XML_PATTERN]),
+            treasureFiles: await collectFiles(extractDir, [TREASURE_PATTERN]),
+        };
+        const sourceId = `pak:${pakName}`;
+        const mtime = (await fs.stat(pakPath)).mtime.toISOString();
+        store.run(`INSERT OR REPLACE INTO source (id, kind, path, mtime) VALUES (?, ?, ?, ?)`, [
+            sourceId,
+            "pak",
+            path.resolve(pakPath),
+            mtime,
+        ]);
+        sources.push(pakName);
+        const counts = await insertParsedFiles(store, sourceId, files, progress);
+        statTotal += counts.statCount;
+        nodeTotal += counts.nodeCount;
+        locaTotal += counts.locaCount;
+    }
+    store.transaction(() => {
+        store.run(`INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)`, [new Date().toISOString()]);
+        if (install.version) {
+            store.run(`INSERT OR REPLACE INTO meta (key, value) VALUES ('gameVersion', ?)`, [install.version]);
+        }
+        store.run(`INSERT OR REPLACE INTO meta (key, value) VALUES ('sources', ?)`, [JSON.stringify(sources)]);
+    });
+    if (store.file)
+        await store.save();
+    progress?.({ step: "done", note: `${statTotal} stats, ${nodeTotal} nodes, ${locaTotal} loca entries` });
+    return info(install);
+}

package/dist/surfaces/baldursgate3/index/index.js

@@ -0,0 +1,17 @@
+import { buildIndex } from "./build.js";
+import { info } from "./info.js";
+import { query, queryKinds } from "./queries.js";
+export const bg3Index = {
+    info,
+    build: buildIndex,
+    queryKinds,
+    query,
+};
+export { buildIndex, indexFromDirectory, VANILLA_PAKS } from "./build.js";
+export { info } from "./info.js";
+export { query, queryKinds } from "./queries.js";
+export { createSchema } from "./schema.js";
+export { parseStats } from "./parsers/stats.js";
+export { parseLsx, walkLsxNodes } from "./parsers/lsx.js";
+export { parseLoca } from "./parsers/loca.js";
+export { parseTreasureTable } from "./parsers/treasuretable.js";

package/dist/surfaces/baldursgate3/index/info.js

@@ -0,0 +1,40 @@
+import { promises as fs } from "node:fs";
+import { defaultCacheDir, indexFile, IndexStore } from "../../../core/knowledge/store.js";
+export async function info(_install) {
+    const file = indexFile(defaultCacheDir(), "baldursgate3");
+    const result = { game: "baldursgate3", 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;
+        const sourcesRaw = store.get(`SELECT value FROM meta WHERE key = 'sources'`)?.value;
+        if (builtAt !== undefined)
+            result.builtAt = String(builtAt);
+        if (gameVersion !== undefined)
+            result.gameVersion = String(gameVersion);
+        if (sourcesRaw !== undefined) {
+            try {
+                result.sources = JSON.parse(String(sourcesRaw));
+            }
+            catch {
+            }
+        }
+        result.tables = store.tableCounts();
+    }
+    catch {
+    }
+    finally {
+        store?.close();
+    }
+    return result;
+}