modwright 0.1.0

package/dist/surfaces/stardewvalley/compat.js

@@ -0,0 +1,190 @@
+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";
+import { boolSetting, readSmapiConfig } from "./config.js";
+import { relaxJson, scanMods } from "./mods.js";
+export const CONTENT_PATCHER_ID = "Pathoschild.ContentPatcher";
+export const SMAPI_MINIMUM_GAME_VERSION = "1.6.14";
+export const CONTENT_PATCHER_MINIMUM_SMAPI = "4.4.0";
+async function firstExisting(files) {
+    for (const f of files)
+        if (await pathExists(f))
+            return f;
+    return undefined;
+}
+async function peVersionOf(file) {
+    if (!file)
+        return undefined;
+    try {
+        return await readPeFileVersion(file);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function detectComponents(install) {
+    const root = install.root;
+    const components = [];
+    const gameFile = await firstExisting([path.join(root, "Stardew Valley.dll"), path.join(root, "Stardew Valley.exe"), path.join(root, "StardewValley.exe"), path.join(root, "StardewValley")]);
+    const gameVersion = install.version ?? (await peVersionOf(gameFile));
+    components.push({
+        id: "game",
+        label: "Stardew Valley",
+        kind: "game",
+        installed: gameFile !== undefined,
+        ...(gameVersion !== undefined ? { version: gameVersion } : {}),
+        source: install.version ? "install record" : gameFile ? `${path.basename(gameFile)} PE file version (the assembly version SMAPI reads for its legacy check; whether it equals the 1.6.x patch number is not established)` : "Stardew Valley.dll or the game executable, not found",
+        ...(gameFile ? { path: gameFile } : {}),
+    });
+    const smapiExe = await firstExisting([path.join(root, "StardewModdingAPI.exe"), path.join(root, "StardewModdingAPI")]);
+    const smapiDll = path.join(root, "StardewModdingAPI.dll");
+    const smapiDllExists = await pathExists(smapiDll);
+    const smapiInstalled = smapiExe !== undefined || smapiDllExists;
+    const smapiVersion = smapiDllExists ? await peVersionOf(smapiDll) : undefined;
+    components.push({
+        id: "smapi",
+        label: "SMAPI",
+        kind: "loader",
+        installed: smapiInstalled,
+        ...(smapiVersion !== undefined ? { version: smapiVersion } : {}),
+        source: "StardewModdingAPI.dll PE file version (the banner line 'SMAPI {v} with Stardew Valley {v}' once it has run)",
+        ...(smapiExe ? { path: smapiExe } : smapiDllExists ? { path: smapiDll } : {}),
+    });
+    const harmonyDll = path.join(root, "smapi-internal", "0Harmony.dll");
+    const harmonyVersion = await peVersionOf((await pathExists(harmonyDll)) ? harmonyDll : undefined);
+    components.push({ id: "harmony", label: "Harmony (bundled by SMAPI)", kind: "framework", installed: await pathExists(harmonyDll), ...(harmonyVersion !== undefined ? { version: harmonyVersion } : {}), source: "smapi-internal/0Harmony.dll PE file version", path: harmonyDll });
+    const modsDir = path.join(root, "Mods");
+    const mods = (await pathExists(modsDir)) ? await scanMods(modsDir) : [];
+    const cp = mods.find((m) => typeof m.manifest?.UniqueID === "string" && m.manifest.UniqueID.toLowerCase() === CONTENT_PATCHER_ID.toLowerCase());
+    const cpVersion = typeof cp?.manifest?.Version === "string" && parseVersion(cp.manifest.Version) ? cp.manifest.Version : undefined;
+    components.push({
+        id: "contentpatcher",
+        label: "Content Patcher",
+        kind: "mod",
+        installed: cp !== undefined,
+        ...(cpVersion !== undefined ? { version: cpVersion } : {}),
+        source: "Mods/**/manifest.json with UniqueID Pathoschild.ContentPatcher, its Version field",
+        ...(cp ? { path: cp.path } : {}),
+    });
+    const config = await readSmapiConfig(install);
+    const configSource = config.files.length > 0 ? `the merged SMAPI config (${config.files.map((f) => path.relative(root, f)).join(", ")})` : "no SMAPI config file found";
+    components.push({ id: "smapi-rewrite-off", label: "SMAPI with RewriteMods disabled", kind: "loader", installed: smapiInstalled && boolSetting(config.settings, "RewriteMods") === false, source: configSource, ...(config.sources.RewriteMods ? { path: config.sources.RewriteMods } : {}) });
+    components.push({ id: "smapi-fixharmony-off", label: "SMAPI with FixHarmony disabled", kind: "loader", installed: smapiInstalled && boolSetting(config.settings, "FixHarmony") === false, source: configSource, ...(config.sources.FixHarmony ? { path: config.sources.FixHarmony } : {}) });
+    return components;
+}
+export const RULES = [
+    {
+        id: "sdv-smapi-needs-game-1-6-14",
+        game: "stardewvalley",
+        component: "smapi",
+        requires: [{ component: "game", min: SMAPI_MINIMUM_GAME_VERSION }],
+        severity: "warn",
+        undeterminedSeverity: "info",
+        note: "SMAPI 4.5.x refuses to start on a game older than 1.6.14 (Constants.MinimumGameVersion, a literal in its source); there is no upper bound. Reported as warn rather than block because the game version read here is the assembly version, whose relationship to the 1.6.x patch number has not been checked against a real install.",
+        source: "https://github.com/Pathoschild/SMAPI/blob/develop/src/SMAPI/Constants.cs",
+    },
+    {
+        id: "sdv-contentpatcher-needs-smapi-4-4",
+        game: "stardewvalley",
+        component: "contentpatcher",
+        requires: [{ component: "smapi", min: CONTENT_PATCHER_MINIMUM_SMAPI }],
+        severity: "warn",
+        undeterminedSeverity: "info",
+        note: "Content Patcher 2.9.0 and 2.9.1 are released 'for SMAPI 4.4.0 or later', so an older SMAPI is an unsupported combination and every content pack is only as loadable as Content Patcher is. What SMAPI actually enforces is the installed copy's own MinimumApiVersion (4.1.10 in the develop manifest), which is the version its 'it needs SMAPI x or later' skip line quotes, so below 4.4.0 expect misbehaviour rather than necessarily a refusal.",
+        source: "https://github.com/Pathoschild/StardewMods/blob/develop/ContentPatcher/docs/release-notes.md ('Released 14 March 2026 for SMAPI 4.4.0 or later') and ContentPatcher/manifest.json's MinimumApiVersion",
+    },
+    {
+        id: "sdv-smapi-rewrites-mods",
+        game: "stardewvalley",
+        component: "smapi",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "SMAPI rewrites older mods for compatibility (RewriteMods, default true) and disables known-broken ones by name from smapi-internal/metadata.json. A mod that fails to load here is more often on that list than genuinely incompatible: read the skipped-mods reason text before assuming a version problem.",
+        source: "https://github.com/Pathoschild/SMAPI/blob/develop/src/SMAPI/Framework/ModLoading/Rewriters/; src/SMAPI.Web/wwwroot/SMAPI.metadata.json",
+    },
+    {
+        id: "sdv-game-unpatched-since-1-6-15",
+        game: "stardewvalley",
+        component: "game",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "Stardew Valley has not been patched since 1.6.15 (2024-12-20); 1.7 is announced with no date. Treat a game-version-mismatch hypothesis as unlikely until it ships.",
+        source: "https://stardewvalleywiki.com/Version_History",
+    },
+    {
+        id: "sdv-rewritemods-off",
+        game: "stardewvalley",
+        component: "smapi-rewrite-off",
+        requires: [],
+        advisory: true,
+        severity: "warn",
+        note: "RewriteMods is false in SMAPI's config: mods built for an older game are loaded unrewritten, and SMAPI's own config comment warns that they are then likely to crash. A crash in an older mod on this install is not evidence about the mod.",
+        source: "https://github.com/Pathoschild/SMAPI/blob/develop/src/SMAPI/SMAPI.config.json",
+    },
+    {
+        id: "sdv-fixharmony-off",
+        game: "stardewvalley",
+        component: "smapi-fixharmony-off",
+        requires: [],
+        advisory: true,
+        severity: "warn",
+        note: "FixHarmony is false in SMAPI's config: SMAPI's own comment says mods which use Harmony are then likely to cause game crashes. Any Harmony-using mod's crash on this install is suspect for that reason first.",
+        source: "https://github.com/Pathoschild/SMAPI/blob/develop/src/SMAPI/SMAPI.config.json",
+    },
+];
+export const stardewvalleyCompat = { detectComponents, rules: RULES };
+export async function readModMetadata(install) {
+    const text = await readTextIfExists(path.join(install.root, "smapi-internal", "metadata.json"));
+    if (text === undefined)
+        return undefined;
+    let doc;
+    try {
+        doc = JSON.parse(relaxJson(text));
+    }
+    catch {
+        return undefined;
+    }
+    const data = doc && typeof doc === "object" ? doc.ModData : undefined;
+    if (!data || typeof data !== "object")
+        return [];
+    const out = [];
+    for (const [name, rec] of Object.entries(data)) {
+        if (!rec || typeof rec !== "object")
+            continue;
+        const r = rec;
+        const field = (key) => key.split("|").map((p) => p.trim()).pop().toLowerCase();
+        const prefix = (key) => key.split("|").map((p) => p.trim()).slice(0, -1).filter((p) => p.toLowerCase() !== "default").join("|");
+        let id;
+        let formerIds = [];
+        const byRange = new Map();
+        for (const [key, value] of Object.entries(r)) {
+            const f = field(key);
+            if (f === "id" && typeof value === "string")
+                id = value;
+            else if (f === "formerids" && typeof value === "string")
+                formerIds = value.split("|").map((s) => s.trim()).filter(Boolean);
+            else if ((f === "status" || f === "statusreasonphrase") && typeof value === "string") {
+                const p = prefix(key);
+                const slot = byRange.get(p) ?? {};
+                if (f === "status")
+                    slot.status = value;
+                else
+                    slot.reason = value;
+                byRange.set(p, slot);
+            }
+        }
+        for (const [range, slot] of byRange) {
+            if (!slot.status)
+                continue;
+            out.push({ name, ...(id ? { id } : {}), formerIds, status: slot.status, ...(range ? { range } : {}), ...(slot.reason ? { reason: slot.reason } : {}) });
+        }
+    }
+    return out;
+}
+export function metadataFor(entries, modId) {
+    const lower = modId.toLowerCase();
+    return entries.filter((e) => e.id?.toLowerCase() === lower || e.formerIds.some((f) => f.toLowerCase() === lower));
+}

package/dist/surfaces/stardewvalley/config.js

@@ -0,0 +1,42 @@
+import * as path from "node:path";
+import { readTextIfExists } from "../../core/fsutil.js";
+import { relaxJson } from "./mods.js";
+export function smapiConfigFiles(root) {
+    return [path.join(root, "smapi-internal", "config.json"), path.join(root, "smapi-internal", "config.user.json"), path.join(root, "Mods", "SMAPI-config.json")];
+}
+export async function readSmapiConfig(install) {
+    const out = { files: [], unreadable: [], settings: {}, sources: {} };
+    for (const file of smapiConfigFiles(install.root)) {
+        const text = await readTextIfExists(file);
+        if (text === undefined)
+            continue;
+        out.files.push(file);
+        let doc;
+        try {
+            doc = JSON.parse(relaxJson(text));
+        }
+        catch {
+            out.unreadable.push(file);
+            continue;
+        }
+        if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+            out.unreadable.push(file);
+            continue;
+        }
+        for (const [k, v] of Object.entries(doc)) {
+            if (v === null)
+                continue;
+            out.settings[k] = v;
+            out.sources[k] = file;
+        }
+    }
+    return out;
+}
+export function stringList(settings, key) {
+    const v = settings[key];
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+}
+export function boolSetting(settings, key) {
+    const v = settings[key];
+    return typeof v === "boolean" ? v : undefined;
+}

package/dist/surfaces/stardewvalley/contentpatcher.js

@@ -0,0 +1,203 @@
+import { compareVersions, parseVersion } from "../../core/compat/version.js";
+import { relaxJson } from "./mods.js";
+export const CURRENT_FORMAT = "2.9.0";
+export const CURRENT_FORMAT_RE = /^2\.9\.[0-9]+$/;
+export const FORMAT_SCHEMA_MESSAGE = "You should always use the latest format version (currently 2.9.0) to enable the latest features, avoid obsolete behavior, and reduce load times.";
+export const FORMAT_ENABLED_OBSOLETE = "1.25.0";
+export const FORMAT_EDITDATA_FROMFILE_REMOVED = "1.18.0";
+export const ACTIONS = ["Load", "EditImage", "EditData", "EditMap", "Include"];
+export const TOP_LEVEL_FIELDS = ["Format", "Changes", "ConfigSchema", "CustomLocations", "DynamicTokens", "AliasTokenNames", "$schema"];
+export const PATCH_FIELDS = [
+    "LogName",
+    "Action",
+    "Target",
+    "TargetLocale",
+    "Update",
+    "FromFile",
+    "Enabled",
+    "When",
+    "Priority",
+    "LocalTokens",
+    "TextOperations",
+    "FromArea",
+    "ToArea",
+    "PatchMode",
+    "Entries",
+    "Fields",
+    "MoveEntries",
+    "TargetField",
+    "MapProperties",
+    "AddNpcWarps",
+    "AddWarps",
+    "MapTiles",
+];
+export const BUILTIN_TOKENS = new Set([
+    "Day", "DayEvent", "DayOfWeek", "DaysPlayed", "Season", "Year", "Weather",
+    "HasActiveQuest", "HasCaughtFish", "HasCookingRecipe", "HasCraftingRecipe", "HasConversationTopic", "HasFlag", "HasProfession", "HasReadLetter", "HasSeenEvent", "HasVisitedLocation",
+    "DailyLuck", "HasDialogueAnswer", "HasWalletItem", "IsMainPlayer", "IsOutdoors", "LocationContext", "LocationName", "LocationOwnerId", "LocationUniqueName", "PlayerGender", "PlayerName", "PreferredPet", "SkillLevel",
+    "ChildNames", "ChildGenders", "Hearts", "Relationship", "Roommate", "Spouse",
+    "FarmCave", "FarmhouseUpgrade", "FarmMapAsset", "FarmName", "FarmType", "IsCommunityCenterComplete", "IsJojaMartComplete", "HavingChild", "Pregnant", "Time",
+    "Count", "Query", "Range", "Round", "Lowercase", "Merge", "PathPart", "Random", "Render", "Uppercase",
+    "FirstValidFile", "HasMod", "HasFile", "HasValue", "I18n", "Language", "ModId",
+    "AbsoluteFilePath", "FormatAssetName", "InternalAssetKey",
+    "FromFile", "Target", "TargetWithoutPath", "TargetPathOnly",
+].map((t) => t.toLowerCase()));
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : undefined);
+export function pick(raw, name) {
+    if (Object.prototype.hasOwnProperty.call(raw, name))
+        return { key: name, value: raw[name] };
+    const lower = name.toLowerCase();
+    for (const k of Object.keys(raw))
+        if (k.toLowerCase() === lower)
+            return { key: k, value: raw[k] };
+    return undefined;
+}
+export function parseContentJson(text) {
+    const doc = JSON.parse(relaxJson(text));
+    if (!doc || typeof doc !== "object" || Array.isArray(doc))
+        throw new Error("content.json is not a JSON object");
+    const raw = doc;
+    const known = new Map(TOP_LEVEL_FIELDS.map((f) => [f.toLowerCase(), f]));
+    const extraFields = [];
+    const miscased = [];
+    for (const k of Object.keys(raw)) {
+        const expected = known.get(k.toLowerCase());
+        if (expected === undefined)
+            extraFields.push(k);
+        else if (expected !== k)
+            miscased.push({ key: k, expected });
+    }
+    return {
+        raw,
+        format: pick(raw, "Format")?.value,
+        changes: pick(raw, "Changes")?.value,
+        configSchema: obj(pick(raw, "ConfigSchema")?.value),
+        dynamicTokens: pick(raw, "DynamicTokens")?.value,
+        aliasTokenNames: obj(pick(raw, "AliasTokenNames")?.value),
+        customLocations: pick(raw, "CustomLocations")?.value,
+        extraFields,
+        miscased,
+    };
+}
+export function formatState(v) {
+    if (v === undefined || v === null || (typeof v === "string" && v.trim() === ""))
+        return "missing";
+    if (typeof v !== "string" || !parseVersion(v.trim()))
+        return "invalid";
+    const s = v.trim();
+    if (CURRENT_FORMAT_RE.test(s))
+        return "current";
+    return compareVersions(s, CURRENT_FORMAT) < 0 ? "older" : "newer";
+}
+export function formatOlderThan(v, than) {
+    if (typeof v !== "string" || !parseVersion(v.trim()))
+        return false;
+    return compareVersions(v.trim(), than) < 0;
+}
+export function patchesOf(cfg) {
+    const patches = [];
+    const invalid = [];
+    if (!Array.isArray(cfg.changes))
+        return { patches, invalid };
+    const known = new Set(PATCH_FIELDS.map((f) => f.toLowerCase()));
+    cfg.changes.forEach((entry, index) => {
+        const raw = obj(entry);
+        if (!raw) {
+            invalid.push(index);
+            return;
+        }
+        const s = (name) => {
+            const v = pick(raw, name)?.value;
+            return typeof v === "string" ? v : undefined;
+        };
+        const logName = s("LogName");
+        patches.push({
+            index,
+            raw,
+            label: `entry #${index + 1}${logName ? ` (${logName})` : ""}`,
+            action: s("Action"),
+            target: s("Target"),
+            fromFile: s("FromFile"),
+            extraFields: Object.keys(raw).filter((k) => !known.has(k.toLowerCase())),
+        });
+    });
+    return { patches, invalid };
+}
+const TOKEN_RE = /\{\{\s*([^{}\s:|]+)/g;
+export function tokenNames(s) {
+    const out = [];
+    for (const m of s.matchAll(TOKEN_RE))
+        out.push(m[1]);
+    return out;
+}
+export function hasTokens(s) {
+    return s.includes("{{");
+}
+export function splitLexically(s) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < s.length; i++) {
+        const two = s.slice(i, i + 2);
+        if (two === "{{") {
+            depth++;
+            current += two;
+            i++;
+            continue;
+        }
+        if (two === "}}" && depth > 0) {
+            depth--;
+            current += two;
+            i++;
+            continue;
+        }
+        if (s[i] === "," && depth === 0) {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += s[i];
+    }
+    parts.push(current);
+    const seen = new Set();
+    const out = [];
+    for (const p of parts) {
+        const t = p.trim();
+        if (!t || seen.has(t.toLowerCase()))
+            continue;
+        seen.add(t.toLowerCase());
+        out.push(t);
+    }
+    return out;
+}
+export function conditionTokenName(key) {
+    const k = key.trim();
+    if (k.startsWith("{{"))
+        return undefined;
+    const m = /^([^:|\s]+)/.exec(k);
+    return m ? m[1] : undefined;
+}
+export function isKnownToken(name, cfg) {
+    if (name.includes("/"))
+        return true;
+    const lower = name.toLowerCase();
+    if (BUILTIN_TOKENS.has(lower))
+        return true;
+    if (cfg.configSchema && Object.keys(cfg.configSchema).some((k) => k.toLowerCase() === lower))
+        return true;
+    if (Array.isArray(cfg.dynamicTokens) && cfg.dynamicTokens.some((t) => String(obj(t)?.Name ?? "").toLowerCase() === lower))
+        return true;
+    if (cfg.aliasTokenNames && Object.keys(cfg.aliasTokenNames).some((k) => k.toLowerCase() === lower))
+        return true;
+    return false;
+}
+export function tokenPathToRegExp(p) {
+    const norm = p.replace(/\\/g, "/").trim().replace(/^\.\//, "");
+    let out = "^";
+    for (const part of norm.split(/(\{\{[^}]*\}\})/)) {
+        if (!part)
+            continue;
+        out += part.startsWith("{{") ? "[^/]*" : part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(out + "$", "i");
+}

package/dist/surfaces/stardewvalley/index/index.js

@@ -0,0 +1,229 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { defaultCacheDir, indexFile, IndexStore } from "../../../core/knowledge/store.js";
+import { resolveDataDir } from "../../../core/userconfig.js";
+import { documentedFields, pageFileName, pageUrl, parseWikiPage, WIKI_PAGES } from "./wiki.js";
+export const WIKI_DATA_ENV = "MODWRIGHT_STARDEWVALLEY_WIKI_DATA";
+export const WIKI_DATA_ID = "stardewvalley.wiki";
+const GAME = "stardewvalley";
+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 page (
+      id INTEGER PRIMARY KEY,
+      page TEXT NOT NULL,
+      asset TEXT NOT NULL COLLATE NOCASE,
+      shape TEXT NOT NULL,
+      file TEXT NOT NULL,
+      url TEXT NOT NULL,
+      last_modified TEXT,
+      asset_on_page INTEGER NOT NULL,
+      field_count INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS field (
+      id INTEGER PRIMARY KEY,
+      page_id INTEGER NOT NULL REFERENCES page(id),
+      asset TEXT NOT NULL COLLATE NOCASE,
+      name TEXT NOT NULL COLLATE NOCASE,
+      section TEXT,
+      optional INTEGER NOT NULL,
+      position INTEGER,
+      purpose TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_field_asset_name ON field(asset, name);
+    CREATE INDEX IF NOT EXISTS idx_page_asset ON page(asset);
+  `);
+}
+export function isBuilt(store) {
+    const row = store.get("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'field'");
+    return row !== undefined && store.get("SELECT COUNT(*) AS n FROM field")?.n > 0;
+}
+export async function importWikiPage(store, dataDir, spec) {
+    const file = path.join(dataDir, pageFileName(spec.page));
+    const html = await fs.readFile(file, "utf8");
+    const parsed = parseWikiPage(html);
+    const fields = documentedFields(parsed, spec.shape);
+    const assetOnPage = parsed.text.replace(/\\/g, "/").toLowerCase().includes(spec.asset.toLowerCase());
+    store.run("INSERT INTO page (page, asset, shape, file, url, last_modified, asset_on_page, field_count) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
+        spec.page,
+        spec.asset,
+        spec.shape,
+        pageFileName(spec.page),
+        pageUrl(spec.page),
+        parsed.lastModified ?? null,
+        assetOnPage ? 1 : 0,
+        fields.length,
+    ]);
+    const pageId = store.get("SELECT last_insert_rowid() AS id")?.id;
+    if (fields.length > 0) {
+        store.insertMany("field", ["page_id", "asset", "name", "section", "optional", "position", "purpose"], fields.map((f) => [pageId, spec.asset, f.name, f.section ?? null, f.optional ? 1 : 0, f.position ?? null, f.purpose]));
+    }
+    return { page: spec.page, asset: spec.asset, shape: spec.shape, fields: fields.length, assetOnPage, ...(parsed.lastModified !== undefined ? { lastModified: parsed.lastModified } : {}) };
+}
+function summarize(store, sources) {
+    const file = indexFile(defaultCacheDir(), GAME);
+    const builtAt = store.get("SELECT value FROM meta WHERE key = 'builtAt'")?.value;
+    return { game: GAME, file, exists: true, ...(builtAt !== undefined ? { builtAt: String(builtAt) } : {}), tables: store.tableCounts(), sources };
+}
+export async function buildIndex(_install, store, options = {}) {
+    const sources = [];
+    createSchema(store);
+    if (isBuilt(store) && !options.force) {
+        sources.push("(schema index already built — pass { force: true } to rebuild)");
+        return summarize(store, sources);
+    }
+    store.exec("DELETE FROM field; DELETE FROM page; DELETE FROM meta;");
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('builtAt', ?)", [new Date().toISOString()]);
+    const dataDir = options.dataDir ?? (await resolveDataDir(WIKI_DATA_ID, WIKI_DATA_ENV))?.path;
+    if (!dataDir) {
+        sources.push(`no wiki pages: fetch them once with check_toolchain action=install data=${WIKI_DATA_ID} (dry-run first, then mode=apply; it remembers the folder), or point at a folder of saved pages (one <page>.html per documented asset) with check_toolchain action=remember data=${WIKI_DATA_ID} dataPath=<folder> or ${WIKI_DATA_ENV}; nothing was indexed.`);
+        return summarize(store, sources);
+    }
+    let specs = [...WIKI_PAGES];
+    if (options.only && options.only.length > 0) {
+        const wanted = new Set(options.only.map((k) => k.toLowerCase()));
+        specs = specs.filter((s) => wanted.has(s.page.toLowerCase()) || wanted.has(s.asset.toLowerCase()));
+    }
+    const missing = [];
+    const errors = [];
+    let index = 0;
+    for (const spec of specs) {
+        options.progress?.({ step: `wiki:${spec.page}`, done: index++, total: specs.length, note: spec.asset });
+        const file = path.join(dataDir, pageFileName(spec.page));
+        try {
+            await fs.access(file);
+        }
+        catch {
+            missing.push(spec.page);
+            continue;
+        }
+        try {
+            const s = await importWikiPage(store, dataDir, spec);
+            sources.push(`${s.page}.html (${s.asset}, ${s.shape}, ${s.fields} documented field${s.fields === 1 ? "" : "s"}${s.lastModified ? `, ${s.lastModified.replace(/^This page was /, "")}` : ""})${s.assetOnPage ? "" : " — the asset name does not appear on the page; check the curated mapping"}`);
+        }
+        catch (err) {
+            errors.push(`${spec.page}: ${err.message}`);
+        }
+    }
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('dataDir', ?)", [dataDir]);
+    store.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('pages', ?)", [String(specs.length - missing.length)]);
+    if (missing.length > 0)
+        sources.push(`${missing.length} page(s) not saved under ${dataDir} (${missing.join(", ")}); fetch them with check_toolchain action=install data=${WIKI_DATA_ID}.`);
+    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} page(s) failed to parse — see meta.buildErrors.`);
+    }
+    sources.push("The wiki states no game version; the pages describe 1.6's data models, each with its own last-edited date. Field lists only: whether a given entry exists needs a value index.");
+    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;
+        if (builtAt !== undefined)
+            result.builtAt = String(builtAt);
+        result.tables = store.tableCounts();
+        const rows = store.all("SELECT page, asset, shape, field_count, last_modified FROM page ORDER BY id");
+        if (rows.length > 0)
+            result.sources = rows.map((r) => `${r.page}.html (${r.asset}, ${r.shape}, ${r.field_count} fields${r.last_modified ? `, ${String(r.last_modified).replace(/^This page was /, "")}` : ""})`);
+    }
+    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 normalizeAsset(name) {
+    return name.replace(/\\/g, "/").replace(/\.xnb$/i, "").trim();
+}
+export function queryKinds() {
+    return [
+        { kind: "assets", description: "The data assets the index documents (from the wiki's per-asset pages), each with its shape (model or delimited string), documented field count and the page's last-edited date; `contains` filters by asset name.", params: ["contains", "limit"] },
+        { kind: "asset", description: "The documented fields of one asset (e.g. Data/Objects): name, section, whether optional, position for a delimited asset, and the wiki's one-line purpose.", params: ["name", "section", "limit"] },
+        { kind: "field", description: "A field by exact name or `contains` within one asset, or across every asset when `asset` is omitted.", params: ["asset", "name", "contains", "limit"] },
+    ];
+}
+function like(s) {
+    return `%${s.replace(/[%_\\]/g, (c) => `\\${c}`)}%`;
+}
+export async function query(store, kind, params) {
+    const limit = limitOf(params);
+    const finish = (rows, note) => {
+        const truncated = rows.length > limit;
+        const out = truncated ? rows.slice(0, limit) : rows;
+        return { kind, params, count: out.length, rows: out, ...(truncated ? { truncated: true } : {}), ...(note !== undefined ? { note } : {}) };
+    };
+    switch (kind) {
+        case "assets": {
+            const contains = str(params.contains);
+            const rows = contains
+                ? store.all("SELECT asset, shape, page, url, field_count AS fields, last_modified AS lastModified, asset_on_page AS assetOnPage FROM page WHERE asset LIKE ? ESCAPE '\\' ORDER BY asset LIMIT ?", [like(contains), limit + 1])
+                : store.all("SELECT asset, shape, page, url, field_count AS fields, last_modified AS lastModified, asset_on_page AS assetOnPage FROM page ORDER BY asset LIMIT ?", [limit + 1]);
+            return finish(rows);
+        }
+        case "asset": {
+            const name = str(params.name);
+            if (!name)
+                return { kind, params, count: 0, rows: [], note: "asset needs `name` (e.g. Data/Objects)." };
+            const section = str(params.section);
+            const asset = normalizeAsset(name);
+            const page = store.get("SELECT asset, shape, page, url, last_modified AS lastModified FROM page WHERE asset = ?", [asset]);
+            if (!page)
+                return { kind, params, count: 0, rows: [], note: `${asset} is not one of the assets the wiki pages in this index document (kind "assets" lists them); its field names cannot be checked.` };
+            const rows = section
+                ? store.all("SELECT f.asset, p.shape, f.name, f.section, f.optional, f.position, f.purpose FROM field f JOIN page p ON p.id = f.page_id WHERE f.asset = ? AND f.section = ? ORDER BY f.id LIMIT ?", [asset, section, limit + 1])
+                : store.all("SELECT f.asset, p.shape, f.name, f.section, f.optional, f.position, f.purpose FROM field f JOIN page p ON p.id = f.page_id WHERE f.asset = ? ORDER BY f.id LIMIT ?", [asset, limit + 1]);
+            return finish(rows.map((r) => ({ ...r, optional: r.optional === 1 })), `${page.asset}: ${page.shape} shape, documented at ${page.url}${page.lastModified ? ` (${String(page.lastModified).replace(/^This page was /, "")})` : ""}.`);
+        }
+        case "field": {
+            const asset = str(params.asset);
+            const name = str(params.name);
+            const contains = str(params.contains);
+            if (!name && !contains)
+                return { kind, params, count: 0, rows: [], note: "field needs `name` or `contains`." };
+            const where = [];
+            const args = [];
+            if (asset) {
+                where.push("f.asset = ?");
+                args.push(normalizeAsset(asset));
+            }
+            if (name) {
+                where.push("f.name = ?");
+                args.push(name);
+            }
+            else {
+                where.push("f.name LIKE ? ESCAPE '\\'");
+                args.push(like(contains));
+            }
+            const rows = store.all(`SELECT f.asset, p.shape, f.name, f.section, f.optional, f.position, f.purpose FROM field f JOIN page p ON p.id = f.page_id WHERE ${where.join(" AND ")} ORDER BY f.asset, f.id LIMIT ?`, [...args, limit + 1]);
+            return finish(rows.map((r) => ({ ...r, optional: r.optional === 1 })));
+        }
+        default:
+            return { kind, params, count: 0, rows: [], note: `Unknown kind "${kind}"; see queryKinds().` };
+    }
+}
+export const stardewvalleyIndex = { info, build: buildIndex, queryKinds, query };