modwright 0.1.0

package/dist/surfaces/baldursgate3/validators/templates.js

@@ -0,0 +1,7 @@
+import { vanillaExtractNeverShipValidator } from "../../../core/text/validate.js";
+export const vanillaExtractNeverShipsValidator = vanillaExtractNeverShipValidator({
+    id: "bg3.history.vanilla-extract-never-ships",
+    game: "baldursgate3",
+    evidence: ["ModWright research"],
+});
+export const TEMPLATE_VALIDATORS = [vanillaExtractNeverShipsValidator];

package/dist/surfaces/cyberpunk2077/compat.js

@@ -0,0 +1,223 @@
+import * as path from "node:path";
+import { readPeFileVersion } from "../../core/compat/pe.js";
+import { head, pathExists, readTextIfExists, resolveCandidate } from "../../core/fsutil.js";
+import { red4extLogCandidates } from "./paths.js";
+const RED4EXT_INIT_RE = /RED4ext\s*\(v([\d.]+)\)\s+is initializing/i;
+const RED4EXT_PRODUCT_VERSION_RE = /Product version:\s*([\d.]+)/i;
+function pluginLoadedPattern(name) {
+    return new RegExp(`${name}\\s*\\(version:\\s*([\\d.]+).*\\)\\s*has been loaded`, "i");
+}
+const RED4EXT_PLUGINS = [
+    { id: "archivexl", label: "ArchiveXL", dir: "ArchiveXL" },
+    { id: "tweakxl", label: "TweakXL", dir: "TweakXL" },
+    { id: "codeware", label: "Codeware", dir: "Codeware" },
+];
+async function detectComponents(install) {
+    const at = (...segments) => path.join(install.root, ...segments);
+    const components = [];
+    const red4extLogHit = await resolveCandidate(red4extLogCandidates(install));
+    const red4extLog = red4extLogHit ? await readTextIfExists(red4extLogHit.path) : undefined;
+    const gameExe = at("bin", "x64", "Cyberpunk2077.exe");
+    const gameInstalled = await pathExists(gameExe);
+    let gameVersion = await readPeFileVersion(gameExe);
+    let gameSource = gameVersion ? "bin/x64/Cyberpunk2077.exe (PE FileVersion)" : undefined;
+    const productVersionMatch = red4extLog?.match(RED4EXT_PRODUCT_VERSION_RE);
+    const marketingVersion = productVersionMatch?.[1];
+    if (!gameVersion && marketingVersion) {
+        gameVersion = marketingVersion;
+        gameSource = 'red4ext/logs/red4ext.log ("Product version:" header line)';
+    }
+    components.push({
+        id: "game",
+        label: "Cyberpunk 2077",
+        kind: "game",
+        installed: gameInstalled || gameVersion !== undefined,
+        version: gameVersion,
+        marketingVersion,
+        source: gameSource,
+        path: gameExe,
+    });
+    const red4extDll = at("red4ext", "RED4ext.dll");
+    const red4extInstalled = await pathExists(red4extDll);
+    let red4extVersion = await readPeFileVersion(red4extDll);
+    let red4extSource = red4extVersion ? "red4ext/RED4ext.dll (PE FileVersion)" : undefined;
+    if (!red4extVersion) {
+        const match = red4extLog?.match(RED4EXT_INIT_RE);
+        if (match?.[1]) {
+            red4extVersion = match[1];
+            red4extSource = 'red4ext/logs/red4ext.log ("is initializing" header line)';
+        }
+    }
+    components.push({
+        id: "red4ext",
+        label: "RED4ext",
+        kind: "loader",
+        installed: red4extInstalled || red4extVersion !== undefined,
+        version: red4extVersion,
+        source: red4extSource,
+        path: red4extDll,
+    });
+    for (const plugin of RED4EXT_PLUGINS) {
+        const dllPath = at("red4ext", "plugins", plugin.dir, `${plugin.dir}.dll`);
+        const dllExists = await pathExists(dllPath);
+        let version = await readPeFileVersion(dllPath);
+        let source = version
+            ? `red4ext/plugins/${plugin.dir}/${plugin.dir}.dll (PE FileVersion)`
+            : undefined;
+        if (!version) {
+            const match = red4extLog?.match(pluginLoadedPattern(plugin.dir));
+            if (match?.[1]) {
+                version = match[1];
+                source = 'red4ext/logs/red4ext.log ("has been loaded" line)';
+            }
+        }
+        components.push({
+            id: plugin.id,
+            label: plugin.label,
+            kind: "framework",
+            installed: dllExists || version !== undefined,
+            version,
+            source,
+            path: dllPath,
+        });
+    }
+    const sccExe = at("engine", "tools", "scc.exe");
+    const sccLib = at("engine", "tools", "scc_lib.dll");
+    const sccExeExists = await pathExists(sccExe);
+    const sccLibExists = await pathExists(sccLib);
+    let redscriptVersion = sccExeExists ? await readPeFileVersion(sccExe) : undefined;
+    let redscriptSource = redscriptVersion
+        ? "engine/tools/scc.exe (PE FileVersion, candidate)"
+        : undefined;
+    if (!redscriptVersion && sccLibExists) {
+        redscriptVersion = await readPeFileVersion(sccLib);
+        if (redscriptVersion)
+            redscriptSource = "engine/tools/scc_lib.dll (PE FileVersion, candidate)";
+    }
+    const redscriptLog = at("r6", "logs", "redscript_rCURRENT.log");
+    const redscriptLogExists = await pathExists(redscriptLog);
+    if (!redscriptVersion && redscriptLogExists) {
+        const banner = /Running REDscript (\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.]+)?)/.exec(await head(redscriptLog));
+        if (banner) {
+            redscriptVersion = banner[1];
+            redscriptSource = 'r6/logs/redscript_rCURRENT.log ("Running REDscript" banner)';
+        }
+    }
+    components.push({
+        id: "redscript",
+        label: "redscript",
+        kind: "tool",
+        installed: sccExeExists || sccLibExists || redscriptLogExists,
+        version: redscriptVersion,
+        source: redscriptSource,
+        path: sccExeExists ? sccExe : sccLibExists ? sccLib : redscriptLogExists ? redscriptLog : sccExe,
+    });
+    const cetAsi = at("bin", "x64", "plugins", "cyber_engine_tweaks.asi");
+    const cetLogPath = at("bin", "x64", "plugins", "cyber_engine_tweaks", "cyber_engine_tweaks.log");
+    const cetInstalled = await pathExists(cetAsi);
+    let cetVersion = await readPeFileVersion(cetAsi);
+    let cetSource = cetVersion
+        ? "bin/x64/plugins/cyber_engine_tweaks.asi (PE FileVersion)"
+        : undefined;
+    if (!cetVersion) {
+        const cetLog = await readTextIfExists(cetLogPath);
+        const firstLine = cetLog?.split(/\r?\n/, 1)[0];
+        const match = firstLine?.match(/(\d+\.\d+(?:\.\d+)*)/);
+        if (match?.[1]) {
+            cetVersion = match[1];
+            cetSource = "bin/x64/plugins/cyber_engine_tweaks/cyber_engine_tweaks.log (first line, heuristic — unverified format)";
+        }
+    }
+    components.push({
+        id: "cet",
+        label: "Cyber Engine Tweaks",
+        kind: "framework",
+        installed: cetInstalled,
+        version: cetVersion,
+        source: cetSource,
+        path: cetAsi,
+    });
+    const redHotToolsDir = at("red4ext", "plugins", "RedHotTools");
+    const redHotToolsDll = path.join(redHotToolsDir, "RedHotTools.dll");
+    const redHotToolsVersion = await readPeFileVersion(redHotToolsDll);
+    components.push({
+        id: "redhottools",
+        label: "Red Hot Tools",
+        kind: "framework",
+        installed: await pathExists(redHotToolsDir),
+        version: redHotToolsVersion,
+        source: redHotToolsVersion ? "red4ext/plugins/RedHotTools/RedHotTools.dll (PE FileVersion)" : undefined,
+        path: redHotToolsDir,
+    });
+    return components;
+}
+const RULES = [
+    {
+        id: "cp2077-redhottools-floor",
+        game: "cyberpunk2077",
+        component: "redhottools",
+        requires: [
+            { component: "game", min: "2.21" },
+            { component: "archivexl", min: "1.21.0" },
+            { component: "cet", min: "1.35.0" },
+            { component: "redscript", min: "0.5.25" },
+            { component: "red4ext", min: "1.27.0" },
+        ],
+        note: "Red Hot Tools needs at least these versions to hot reload archives, scripts and tweaks.",
+        source: "https://github.com/psiberx/cp2077-red-hot-tools (README, Compatibility)",
+    },
+    {
+        id: "cp2077-archivexl-floor",
+        game: "cyberpunk2077",
+        component: "archivexl",
+        requires: [
+            { component: "game", min: "2.31" },
+            { component: "redscript", min: "0.5.31" },
+            { component: "red4ext", min: "1.29.0" },
+        ],
+        note: "ArchiveXL states these as its minimum compatible versions.",
+        source: "cp2077-archive-xl README.md, Getting Started > Compatibility (mirrors psiberx/cp2077-archive-xl)",
+    },
+    {
+        id: "cp2077-tweakxl-floor",
+        game: "cyberpunk2077",
+        component: "tweakxl",
+        requires: [
+            { component: "game", min: "2.3" },
+            { component: "redscript", min: "0.5.27" },
+            { component: "red4ext", min: "1.28.0" },
+        ],
+        note: "TweakXL states these as its minimum compatible versions.",
+        source: "https://github.com/psiberx/cp2077-tweak-xl (README, Compatibility)",
+    },
+    {
+        id: "cp2077-codeware-floor",
+        game: "cyberpunk2077",
+        component: "codeware",
+        requires: [
+            { component: "game", min: "2.31" },
+            { component: "redscript", min: "0.5.31" },
+            { component: "cet", min: "1.37.0" },
+            { component: "red4ext", min: "1.29.0" },
+        ],
+        note: "Codeware states these as its minimum compatible versions.",
+        source: "https://github.com/psiberx/cp2077-codeware (README, Compatibility and Installation)",
+    },
+    {
+        id: "cp2077-red4ext-locked-to-build",
+        game: "cyberpunk2077",
+        component: "red4ext",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "RED4ext plugins are locked to the game build. After a game patch, wait for RED4ext and its " +
+            "plugins to publish updated releases before assuming a mod is broken.",
+        source: "https://wiki.redmodding.org/cyberpunk-2077-modding/for-mod-users/user-guide-troubleshooting " +
+            "(\"prone to breaking with every update\"); RED4ext itself refuses to run against a game patch " +
+            "it does not recognize (WopsS/RED4ext#33).",
+    },
+];
+export const cyberpunk2077Compat = {
+    detectComponents,
+    rules: RULES,
+};

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

@@ -0,0 +1,231 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { pathExists, walk } from "../../../core/fsutil.js";
+import { parseTweakFile } from "./parsers/tweak.js";
+import { parseTweakXLYaml } from "./parsers/tweakxl-yaml.js";
+import { buildResourceListing } from "./resource.js";
+import { createSchema, isBuilt, TWEAKDB_PARSE_VERSION, tweakdbParseCurrent } from "./schema.js";
+const TWEAK_EXT = [".tweak"];
+const YAML_EXT = [".yaml", ".yml"];
+function derivePackage(name) {
+    const dot = name.indexOf(".");
+    return dot === -1 ? null : name.slice(0, dot);
+}
+function loadIdState(store) {
+    const recordId = Number(store.get("SELECT COALESCE(MAX(id), 0) AS m FROM record")?.m ?? 0);
+    const flatId = Number(store.get("SELECT COALESCE(MAX(id), 0) AS m FROM flat")?.m ?? 0);
+    const sourceId = Number(store.get("SELECT COALESCE(MAX(id), 0) AS m FROM source")?.m ?? 0);
+    return { recordId, flatId, sourceId };
+}
+async function readDirectoryFiles(dir, extensions, errors) {
+    const walked = await walk(dir, { limit: 20_000 });
+    const files = walked.files.filter((f) => extensions.some((ext) => f.toLowerCase().endsWith(ext)));
+    const out = [];
+    for (const rel of files) {
+        const abs = path.join(dir, rel);
+        try {
+            const text = await fs.readFile(abs, "utf8");
+            let mtime;
+            try {
+                mtime = (await fs.stat(abs)).mtime.toISOString();
+            }
+            catch {
+                mtime = undefined;
+            }
+            out.push({ abs, rel, text, mtime });
+        }
+        catch (err) {
+            errors.push(`${abs}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return out;
+}
+function parseFile(file) {
+    const isYaml = YAML_EXT.some((ext) => file.rel.toLowerCase().endsWith(ext));
+    return isYaml ? parseTweakXLYaml(file.text, file.abs) : parseTweakFile(file.text, file.abs);
+}
+function insertRecords(store, records, sourceId, ids) {
+    let recordRows = 0;
+    let flatRows = 0;
+    for (const rec of records) {
+        ids.recordId += 1;
+        const recordId = ids.recordId;
+        store.run("INSERT INTO record (id, name, package, base, type, source_id, file, line) VALUES (?,?,?,?,?,?,?,?)", [
+            recordId,
+            rec.name,
+            derivePackage(rec.name),
+            rec.base ?? null,
+            rec.type ?? null,
+            sourceId,
+            rec.file,
+            rec.line,
+        ]);
+        recordRows++;
+        const ftsParts = [];
+        if (rec.base)
+            ftsParts.push(rec.base);
+        if (rec.type)
+            ftsParts.push(rec.type);
+        for (const flat of rec.flats) {
+            ids.flatId += 1;
+            const valueJson = JSON.stringify(flat.value ?? null);
+            store.run("INSERT INTO flat (id, record_id, name, kind, value_json, op) VALUES (?,?,?,?,?,?)", [
+                ids.flatId,
+                recordId,
+                flat.name,
+                flat.kind,
+                valueJson,
+                flat.op,
+            ]);
+            flatRows++;
+            ftsParts.push(flat.name, valueJson);
+        }
+        store.run("INSERT INTO record_fts (docid, name, flats_text) VALUES (?,?,?)", [recordId, rec.name, ftsParts.join(" ")]);
+    }
+    return { records: recordRows, flats: flatRows };
+}
+function ingest(store, files, kind, ids, progress, step, errors) {
+    let recordTotal = 0;
+    let flatTotal = 0;
+    let done = 0;
+    for (const file of files) {
+        let records;
+        try {
+            records = parseFile(file);
+        }
+        catch (err) {
+            errors.push(err instanceof Error ? err.message : String(err));
+            done++;
+            continue;
+        }
+        ids.sourceId += 1;
+        const sourceId = ids.sourceId;
+        store.run("INSERT INTO source (id, kind, path, mtime) VALUES (?,?,?,?)", [sourceId, kind, file.abs, file.mtime ?? null]);
+        const { records: rCount, flats: fCount } = insertRecords(store, records, sourceId, ids);
+        recordTotal += rCount;
+        flatTotal += fCount;
+        done++;
+        if (done === files.length || done % 100 === 0) {
+            progress?.({ step, done, total: files.length });
+        }
+    }
+    return { records: recordTotal, flats: flatTotal };
+}
+function summarize(store, install, sources) {
+    const tables = store.tableCounts();
+    const builtAtRow = store.get("SELECT value FROM meta WHERE key = 'builtAt'");
+    return {
+        game: "cyberpunk2077",
+        file: store.file ?? "",
+        exists: true,
+        builtAt: builtAtRow ? String(builtAtRow.value) : undefined,
+        gameVersion: install?.version,
+        tables,
+        sources,
+    };
+}
+export async function buildIndex(install, store, options = {}) {
+    createSchema(store);
+    const sources = [];
+    const only = options.only;
+    const includesTweakDB = !only || only.includes("vanilla") || only.includes("mods");
+    const staleParse = includesTweakDB && isBuilt(store) && !tweakdbParseCurrent(store);
+    if (!includesTweakDB) {
+        sources.push(`(TweakDB tables kept — only: ${only?.join(", ")})`);
+    }
+    else if (!options.force && !staleParse && isBuilt(store)) {
+        sources.push("(TweakDB index already built — pass { force: true } to rebuild)");
+    }
+    else {
+        if (staleParse && !options.force) {
+            sources.push(`(TweakDB index built by an older parse — rebuilt at parse version ${TWEAKDB_PARSE_VERSION})`);
+        }
+        if (options.force) {
+            store.exec("DROP TABLE IF EXISTS flat; DROP TABLE IF EXISTS record_fts; DROP TABLE IF EXISTS record; DROP TABLE IF EXISTS source; DROP TABLE IF EXISTS meta;");
+            createSchema(store);
+        }
+        else if (staleParse) {
+            store.exec("DROP TABLE IF EXISTS flat; DROP TABLE IF EXISTS record_fts; DROP TABLE IF EXISTS record; DROP TABLE IF EXISTS source; " +
+                "DELETE FROM meta WHERE key NOT LIKE 'resource%';");
+            createSchema(store);
+        }
+        const includeVanilla = !only || only.includes("vanilla");
+        const includeMods = !!only && only.includes("mods");
+        const errors = [];
+        const ids = loadIdState(store);
+        if (includeVanilla) {
+            const vanillaDir = path.join(install.root, "tools", "redmod", "tweaks");
+            if (await pathExists(vanillaDir)) {
+                const files = await readDirectoryFiles(vanillaDir, TWEAK_EXT, errors);
+                options.progress?.({ step: "scan:vanilla", total: files.length, note: `${files.length} .tweak files under ${vanillaDir}` });
+                const { records, flats } = store.transaction(() => ingest(store, files, "vanilla", ids, options.progress, "parse:vanilla", errors));
+                sources.push(`${vanillaDir} (${files.length} files, ${records} records, ${flats} flats)`);
+            }
+            else {
+                sources.push(`${vanillaDir}: not found — REDmod tools are an optional install component ` +
+                    "(installed via the game's REDmod feature or Steam/GOG verify); vanilla TweakDB records cannot be indexed without it.");
+                options.progress?.({ step: "scan:vanilla", note: sources[sources.length - 1] });
+            }
+        }
+        if (includeMods) {
+            const modsDir = path.join(install.root, "r6", "tweaks");
+            if (await pathExists(modsDir)) {
+                const files = await readDirectoryFiles(modsDir, YAML_EXT, errors);
+                options.progress?.({ step: "scan:mods", total: files.length, note: `${files.length} .yaml files under ${modsDir}` });
+                const { records, flats } = store.transaction(() => ingest(store, files, "mod", ids, options.progress, "parse:mods", errors));
+                sources.push(`${modsDir} (${files.length} files, ${records} records, ${flats} flats)`);
+            }
+            else {
+                sources.push(`${modsDir}: not found — no TweakXL mods installed.`);
+            }
+        }
+        const reclassified = store.transaction(() => {
+            const before = Number(store.get("SELECT COUNT(*) AS n FROM record WHERE base IS NOT NULL")?.n ?? 0);
+            store.run(`UPDATE record SET base = package || '.' || type, type = NULL
+         WHERE type IS NOT NULL AND package IS NOT NULL
+           AND EXISTS (SELECT 1 FROM record b WHERE b.name = record.package || '.' || record.type)`);
+            const after = Number(store.get("SELECT COUNT(*) AS n FROM record WHERE base IS NOT NULL")?.n ?? 0);
+            return after - before;
+        });
+        if (reclassified > 0)
+            sources.push(`${reclassified} bare ': Target' declarations resolved to same-package base records across files.`);
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('tweakdbParseVersion', ?)", [TWEAKDB_PARSE_VERSION]);
+        if (install.version)
+            store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('gameVersion', ?)", [install.version]);
+        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.`);
+        }
+    }
+    const includeResource = !only || only.includes("resource");
+    if (includeResource) {
+        const resourceOptions = {
+            force: options.force,
+            progress: options.progress,
+            toolOverrides: options.toolOverrides,
+        };
+        const cpOptions = options;
+        if (cpOptions.resourceToolLocator)
+            resourceOptions.resourceToolLocator = cpOptions.resourceToolLocator;
+        const resourceSummary = await buildResourceListing(install, store, resourceOptions);
+        sources.push(...resourceSummary.notes);
+    }
+    return summarize(store, install, sources);
+}
+export async function indexFromDirectory(dir, store, progress, kind = "vanilla") {
+    createSchema(store);
+    const errors = [];
+    const files = await readDirectoryFiles(dir, [...TWEAK_EXT, ...YAML_EXT], errors);
+    progress?.({ step: "scan", total: files.length, note: `${files.length} files under ${dir}` });
+    const ids = loadIdState(store);
+    const { records, flats } = store.transaction(() => ingest(store, files, kind, ids, progress, "parse", errors));
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+    if (errors.length > 0) {
+        store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('buildErrors', ?)", [JSON.stringify(errors.slice(0, 200))]);
+    }
+    return summarize(store, undefined, [
+        `${dir} (${files.length} files, ${records} records, ${flats} flats)`,
+        ...(errors.length > 0 ? [`${errors.length} file(s) failed to parse — see meta.buildErrors.`] : []),
+    ]);
+}

package/dist/surfaces/cyberpunk2077/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 cp2077Index = {
+    info,
+    build: buildIndex,
+    queryKinds,
+    query,
+};
+export { buildIndex, indexFromDirectory } from "./build.js";
+export { info } from "./info.js";
+export { query, queryKinds } from "./queries.js";
+export { createSchema, isBuilt, ensureResourceSchema, RESOURCE_SCHEMA_VERSION } from "./schema.js";
+export { parseTweakFile } from "./parsers/tweak.js";
+export { parseTweakXLYaml } from "./parsers/tweakxl-yaml.js";
+export { overlayFlats, TweakParseError } from "./model.js";
+export { buildResourceListing } from "./resource.js";

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

@@ -0,0 +1,51 @@
+import { promises as fs } from "node:fs";
+import { defaultCacheDir, indexFile, IndexStore } from "../../../core/knowledge/store.js";
+import { TWEAKDB_PARSE_VERSION, tweakdbParseCurrent } from "./schema.js";
+export async function info(_install) {
+    const file = indexFile(defaultCacheDir(), "cyberpunk2077");
+    const result = { game: "cyberpunk2077", 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);
+        if (builtAt !== undefined && !tweakdbParseCurrent(store)) {
+            result.stale = `TweakDB tables built by an older parse (before version ${TWEAKDB_PARSE_VERSION}: inline records named differently from the game); build_index rebuilds them without force`;
+        }
+        result.tables = store.tableCounts();
+        const sourceRows = store.all(`SELECT kind, path FROM source ORDER BY id`);
+        const sources = sourceRows.map((r) => `${r.kind}: ${r.path}`);
+        const foldersScannedRaw = store.get(`SELECT value FROM meta WHERE key = 'resourceFoldersScanned'`)?.value;
+        if (foldersScannedRaw !== undefined) {
+            try {
+                const folders = JSON.parse(String(foldersScannedRaw));
+                for (const f of folders) {
+                    sources.push(f.exists ? `resource folder: ${f.dir} (${f.archives} archive(s))` : `resource folder: ${f.dir} (not found)`);
+                }
+            }
+            catch {
+            }
+        }
+        if (sources.length > 0)
+            result.sources = sources;
+    }
+    catch {
+    }
+    finally {
+        store?.close();
+    }
+    return result;
+}

package/dist/surfaces/cyberpunk2077/index/model.js

@@ -0,0 +1,52 @@
+export class TweakParseError extends Error {
+    file;
+    line;
+    constructor(message, file, line) {
+        super(`${file}:${line}: ${message}`);
+        this.file = file;
+        this.line = line;
+        this.name = "TweakParseError";
+    }
+}
+export function overlayFlats(occurrences) {
+    const effective = new Map();
+    for (const occ of occurrences) {
+        for (const flat of occ.flats) {
+            const prior = effective.get(flat.name);
+            if (flat.op === "set") {
+                effective.set(flat.name, {
+                    name: flat.name,
+                    value: flat.value,
+                    kind: flat.kind,
+                    from: occ.recordLabel,
+                    contributors: prior ? [...prior.contributors, occ.recordLabel] : [occ.recordLabel],
+                });
+            }
+            else if (flat.op === "append") {
+                const base = Array.isArray(prior?.value) ? prior.value : [];
+                const added = Array.isArray(flat.value) ? flat.value : [flat.value];
+                effective.set(flat.name, {
+                    name: flat.name,
+                    value: [...base, ...added],
+                    kind: prior?.kind ?? flat.kind,
+                    from: occ.recordLabel,
+                    contributors: prior ? [...prior.contributors, occ.recordLabel] : [occ.recordLabel],
+                });
+            }
+            else {
+                const base = Array.isArray(prior?.value) ? prior.value : [];
+                const removed = Array.isArray(flat.value) ? flat.value : [flat.value];
+                const removedJson = removed.map((v) => JSON.stringify(v));
+                const kept = base.filter((v) => !removedJson.includes(JSON.stringify(v)));
+                effective.set(flat.name, {
+                    name: flat.name,
+                    value: kept,
+                    kind: prior?.kind ?? flat.kind,
+                    from: occ.recordLabel,
+                    contributors: prior ? [...prior.contributors, occ.recordLabel] : [occ.recordLabel],
+                });
+            }
+        }
+    }
+    return effective;
+}