modwright 0.1.0

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

@@ -0,0 +1,190 @@
+export const WIKI_BASE = "https://stardewvalleywiki.com/Modding:";
+export const WIKI_PAGES = [
+    { page: "Object_data", asset: "Data/Objects", shape: "model" },
+    { page: "Big_craftables", asset: "Data/BigCraftables", shape: "model" },
+    { page: "Pants", asset: "Data/Pants", shape: "model" },
+    { page: "Shirts", asset: "Data/Shirts", shape: "model" },
+    { page: "Tools", asset: "Data/Tools", shape: "model" },
+    { page: "Trinkets", asset: "Data/Trinkets", shape: "model" },
+    { page: "Mannequins", asset: "Data/Mannequins", shape: "model" },
+    { page: "Weapons", asset: "Data/Weapons", shape: "model" },
+    { page: "Wallpaper_and_flooring", asset: "Data/AdditionalWallpaperFlooring", shape: "model" },
+    { page: "Boots", asset: "Data/Boots", shape: "delimited" },
+    { page: "Hats", asset: "Data/Hats", shape: "delimited" },
+    { page: "Furniture", asset: "Data/Furniture", shape: "delimited" },
+    { page: "Crop_data", asset: "Data/Crops", shape: "model" },
+    { page: "Fruit_trees", asset: "Data/FruitTrees", shape: "model" },
+    { page: "Giant_crops", asset: "Data/GiantCrops", shape: "model" },
+    { page: "Wild_trees", asset: "Data/WildTrees", shape: "model" },
+    { page: "Machines", asset: "Data/Machines", shape: "model" },
+    { page: "Farm_data", asset: "Data/AdditionalFarms", shape: "model" },
+    { page: "Location_contexts", asset: "Data/LocationContexts", shape: "model" },
+    { page: "Location_data", asset: "Data/Locations", shape: "model" },
+    { page: "Museum", asset: "Data/MuseumRewards", shape: "model" },
+    { page: "Passive_Festival_data", asset: "Data/PassiveFestivals", shape: "model" },
+    { page: "Buffs", asset: "Data/Buffs", shape: "model" },
+    { page: "Buildings", asset: "Data/Buildings", shape: "model" },
+    { page: "Bundles", asset: "Data/Bundles", shape: "delimited" },
+    { page: "Fences", asset: "Data/Fences", shape: "model" },
+    { page: "Floors_and_Paths", asset: "Data/FloorsAndPaths", shape: "model" },
+    { page: "Fish_ponds", asset: "Data/FishPondData", shape: "model" },
+    { page: "Garbage_cans", asset: "Data/GarbageCans", shape: "model" },
+    { page: "Jukebox_tracks", asset: "Data/JukeboxTracks", shape: "model" },
+    { page: "Lost_items_shop", asset: "Data/LostItemsShop", shape: "model" },
+    { page: "Minecarts", asset: "Data/Minecarts", shape: "model" },
+    { page: "Monster_eradication_goals", asset: "Data/MonsterSlayerQuests", shape: "model" },
+    { page: "Phone_calls", asset: "Data/IncomingPhoneCalls", shape: "model" },
+    { page: "Shops", asset: "Data/Shops", shape: "model" },
+    { page: "Powers", asset: "Data/Powers", shape: "model" },
+    { page: "Special_orders", asset: "Data/SpecialOrders", shape: "model" },
+    { page: "Tailoring", asset: "Data/TailoringRecipes", shape: "model" },
+    { page: "Animal_data", asset: "Data/FarmAnimals", shape: "model" },
+    { page: "Monster_data", asset: "Data/Monsters", shape: "delimited" },
+    { page: "Pets", asset: "Data/Pets", shape: "model" },
+    { page: "NPC_data", asset: "Data/Characters", shape: "model" },
+    { page: "Achievement_data", asset: "Data/Achievements", shape: "delimited" },
+];
+export const WIKI_FETCH = {
+    source: "the Stardew Valley Wiki's Modding: data pages (stardewvalleywiki.com)",
+    license: "The wiki's text is CC BY-NC-SA. The pages are saved on your machine for build_index to read, and ModWright never redistributes them.",
+    files: WIKI_PAGES.map((p) => ({ url: pageUrl(p.page), file: pageFileName(p.page) })),
+    delayMs: 1000,
+    userAgent: "Mozilla/5.0 (compatible; ModWright wiki fetch; +https://www.npmjs.com/package/modwright)",
+    robotsToken: "ModWright",
+};
+export function pageFileName(page) {
+    return `${page}.html`;
+}
+export function pageUrl(page) {
+    return `${WIKI_BASE}${page}`;
+}
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", "#39": "'", "#160": " " };
+export function plainText(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, " ")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&(#\d+|#x[0-9a-f]+|[a-z]+);/gi, (m, e) => {
+        const key = e.toLowerCase();
+        if (key in ENTITIES)
+            return ENTITIES[key];
+        if (key.startsWith("#x"))
+            return String.fromCodePoint(parseInt(key.slice(2), 16));
+        if (key.startsWith("#"))
+            return String.fromCodePoint(parseInt(key.slice(1), 10));
+        return m;
+    })
+        .replace(/\s+/g, " ")
+        .trim();
+}
+const TOKEN_RE = /<span class="mw-headline" id="[^"]*">([\s\S]*?)<\/span>|<table[^>]*class="[^"]*\bwikitable\b[^"]*"[^>]*>/g;
+const ANY_TABLE_RE = /<table[^>]*>|<\/table>/g;
+const OPEN_TABLE_RE = /<table[^>]*>/g;
+const ROW_RE = /<tr[^>]*>([\s\S]*?)<\/tr>/g;
+const CELL_RE = /<(t[hd])[^>]*>([\s\S]*?)<\/\1>/g;
+function tableAt(html, from) {
+    ANY_TABLE_RE.lastIndex = from;
+    let depth = 1;
+    let m;
+    while ((m = ANY_TABLE_RE.exec(html)) !== null) {
+        if (m[0].startsWith("</")) {
+            depth--;
+            if (depth === 0)
+                return { inner: html.slice(from, m.index), after: m.index + m[0].length };
+        }
+        else
+            depth++;
+    }
+    return { inner: html.slice(from), after: html.length };
+}
+function withoutNestedTables(inner) {
+    let out = "";
+    let i = 0;
+    let m;
+    OPEN_TABLE_RE.lastIndex = 0;
+    while ((m = OPEN_TABLE_RE.exec(inner)) !== null) {
+        out += inner.slice(i, m.index) + " ";
+        const { after } = tableAt(inner, m.index + m[0].length);
+        i = after;
+        OPEN_TABLE_RE.lastIndex = after;
+    }
+    return out + inner.slice(i);
+}
+export function parseWikiPage(html) {
+    const bodyStart = html.indexOf('id="mw-content-text"');
+    const body = bodyStart >= 0 ? html.slice(bodyStart) : html;
+    const titleMatch = /<h1[^>]*id="firstHeading"[^>]*>([\s\S]*?)<\/h1>/.exec(html);
+    const modMatch = /id="footer-info-lastmod">([^<]+)</.exec(html);
+    const page = { tables: [], text: plainText(body), ...(titleMatch ? { title: plainText(titleMatch[1]) } : {}), ...(modMatch ? { lastModified: plainText(modMatch[1]) } : {}) };
+    let section;
+    let m;
+    TOKEN_RE.lastIndex = 0;
+    while ((m = TOKEN_RE.exec(body)) !== null) {
+        if (m[1] !== undefined) {
+            section = plainText(m[1]);
+            continue;
+        }
+        const { inner } = tableAt(body, m.index + m[0].length);
+        const rows = [];
+        let columns = [];
+        for (const r of withoutNestedTables(inner).matchAll(ROW_RE)) {
+            const cells = [];
+            for (const c of r[1].matchAll(CELL_RE))
+                cells.push({ tag: c[1], html: c[2] });
+            if (cells.length === 0)
+                continue;
+            if (cells.every((c) => c.tag === "th")) {
+                if (columns.length === 0)
+                    columns = cells.map((c) => plainText(c.html).toLowerCase());
+                continue;
+            }
+            rows.push(cells.map((c) => c.html));
+        }
+        page.tables.push({ ...(section !== undefined ? { section } : {}), columns, rows });
+    }
+    return page;
+}
+const FIELD_COLUMNS = new Set(["field", "field name", "field key"]);
+const DELIMITED_NAME_COLUMNS = new Set([...FIELD_COLUMNS, "syntax"]);
+const NAME_RE = /^[A-Za-z][A-Za-z0-9_.]*$/;
+const OPTIONAL_SUFFIX_RE = /\s*\(optional\)\s*$/i;
+const LABEL_MAX = 60;
+function isName(name, shape) {
+    if (name.length === 0)
+        return false;
+    return shape === "model" ? NAME_RE.test(name) : name.length <= LABEL_MAX && !name.endsWith(".");
+}
+export function fieldNames(cellHtml, shape = "model") {
+    return cellHtml
+        .split(/<br\s*\/?>/i)
+        .map((part) => plainText(part).replace(OPTIONAL_SUFFIX_RE, ""))
+        .filter((name) => isName(name, shape));
+}
+export function documentedFields(page, shape) {
+    const out = [];
+    for (const table of page.tables) {
+        if (shape === "model") {
+            if (table.columns.length < 2 || !FIELD_COLUMNS.has(table.columns[0]))
+                continue;
+            for (const row of table.rows) {
+                const purpose = plainText(row[1] ?? "");
+                const optional = /^\(optional\)/i.test(purpose) || OPTIONAL_SUFFIX_RE.test(plainText(row[0] ?? ""));
+                for (const name of fieldNames(row[0] ?? "", "model"))
+                    out.push({ name, ...(table.section !== undefined ? { section: table.section } : {}), optional, purpose });
+            }
+        }
+        else {
+            if (table.columns.length < 2 || table.columns[0] !== "index" || !DELIMITED_NAME_COLUMNS.has(table.columns[1]))
+                continue;
+            for (const row of table.rows) {
+                const position = /^\d+/.exec(plainText(row[0] ?? ""));
+                if (!position)
+                    continue;
+                const purpose = plainText(row[2] ?? "");
+                const optional = /^\(optional\)/i.test(purpose) || OPTIONAL_SUFFIX_RE.test(plainText(row[1] ?? ""));
+                for (const name of fieldNames(row[1] ?? "", "delimited"))
+                    out.push({ name, ...(table.section !== undefined ? { section: table.section } : {}), optional, position: Number(position[0]), purpose });
+            }
+        }
+    }
+    return out;
+}

package/dist/surfaces/stardewvalley/index.js

@@ -0,0 +1,12 @@
+export { stardewvalley, gameFolderType, targetsFileGamePath, readLoadOrderOverrides, configCandidates, scanInstallMods, dataDir, STEAM_APP_ID } from "./surface.js";
+export { SIGNATURES, PREFIX } from "./logs.js";
+export { parseManifest, relaxJson, manifestType, scanMods, displayName, SLUG_RE, SEMANTIC_VERSION_RE, ENTRY_DLL_RE, UPDATE_KEY_RE, MANIFEST_FIELDS } from "./mods.js";
+export { MANIFEST_VALIDATORS } from "./validators/manifest.js";
+export { CONTENT_VALIDATORS } from "./validators/content.js";
+export { LOADORDER_VALIDATORS } from "./validators/loadorder.js";
+export { stardewvalleyCompat, detectComponents, RULES as COMPAT_RULES, readModMetadata, metadataFor } from "./compat.js";
+export { readSmapiConfig, smapiConfigFiles, stringList, boolSetting } from "./config.js";
+export { parseContentJson, patchesOf, formatState, splitLexically, tokenNames, conditionTokenName, isKnownToken, tokenPathToRegExp, CURRENT_FORMAT, ACTIONS, BUILTIN_TOKENS } from "./contentpatcher.js";
+export { FIELDS_VALIDATORS } from "./validators/fields.js";
+export { stardewvalleyIndex, buildIndex as buildStardewIndex, query as queryStardewIndex, queryKinds as stardewQueryKinds, importWikiPage, normalizeAsset, WIKI_DATA_ENV, WIKI_DATA_ID } from "./index/index.js";
+export { WIKI_PAGES, WIKI_BASE, parseWikiPage, documentedFields, fieldNames, pageFileName, pageUrl } from "./index/wiki.js";

package/dist/surfaces/stardewvalley/logs.js

@@ -0,0 +1,307 @@
+const PARSER = "SMAPI src/SMAPI.Web/Framework/LogParsing/LogParser.cs";
+const RESOLVER = "SMAPI src/SMAPI/Framework/ModLoading/ModResolver.cs";
+const SCORE = "SMAPI src/SMAPI/Framework/SCore.cs";
+const LOGMANAGER = "SMAPI src/SMAPI/Framework/Logging/LogManager.cs";
+const CP = "Content Patcher ContentPatcher/ModEntry.cs and Framework/PatchLoader.cs";
+const PENDING = "pending a real sample";
+export const PREFIX = String.raw `^\[(?<time>\d\d[:.]\d\d[:.]\d\d) (?<level>[A-Za-z]+)(?: +screen_(?<screen>\d+))? +(?<source>[^\]]+)\] `;
+function re(body) {
+    return new RegExp(PREFIX + body);
+}
+const smapi = (id, rest) => ({ id: `stardewvalley.smapi.${id}`, game: "stardewvalley", sources: ["smapi", "smapi-crash"], ...rest });
+const cp = (id, rest) => ({ id: `stardewvalley.contentpatcher.${id}`, game: "stardewvalley", sources: ["smapi"], systemImpact: false, ...rest });
+export const SIGNATURES = [
+    smapi("banner", {
+        severity: "info",
+        category: "version",
+        pattern: re(String.raw `SMAPI (?<apiVersion>.+) with Stardew Valley (?<gameVersion>.+) on (?<os>.+)$`),
+        explain: "SMAPI started and named its own version, the game's and the platform; the anchor for the run.",
+        seenIn: [`${PARSER} InfoLinePattern`, PENDING],
+        extract: ["apiVersion", "gameVersion", "os"],
+    }),
+    smapi("mods-path", {
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `Mods go here: (?<path>.+)$`),
+        explain: "The Mods folder this run scanned; with --mods-path it is not the game's own.",
+        seenIn: [`${PARSER} ModPathPattern`, PENDING],
+        extract: ["path"],
+    }),
+    smapi("custom-mods-path", {
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `\(Using custom --mods-path argument\. Game folder: (?<path>.+)\.\)$`),
+        explain: "SMAPI was launched with --mods-path, so the mods it loaded are not the ones under the game folder's Mods/.",
+        seenIn: [`${PARSER} GamePathPattern`, PENDING],
+        extract: ["path"],
+    }),
+    smapi("log-started", {
+        severity: "info",
+        category: "version",
+        pattern: re(String.raw `Log started at (?<timestamp>.+) UTC$`),
+        explain: "The one absolute timestamp in the file; every other line carries only HH:mm:ss.",
+        seenIn: [`${PARSER} LogStartedAtPattern`, PENDING],
+        extract: ["timestamp"],
+    }),
+    smapi("loose-files-in-mods", {
+        severity: "error",
+        category: "load",
+        pattern: re(String.raw `Detected mod files directly inside the '(?<folder>[^']+)' folder\. These will be ignored\.`),
+        explain: "Files sit directly in Mods/ instead of in a mod's own subfolder; SMAPI ignores them, so that mod is not loaded.",
+        hint: "Each mod must have its own subfolder under Mods/ holding its manifest.json.",
+        seenIn: [`${SCORE}`, PENDING],
+        extract: ["folder"],
+    }),
+    smapi("load-order-override-missing", {
+        severity: "warn",
+        category: "order",
+        pattern: re(String.raw ` *The '(?<file>[^']+)' file lists mod IDs in (?<list>ModsToLoadEarly|ModsToLoadLate) which aren't installed: (?<ids>.+)$`),
+        explain: "smapi-internal/config.json's load-order override names a mod that is not installed; the entry does nothing.",
+        hint: "Remove the id from ModsToLoadEarly/ModsToLoadLate, or install the mod.",
+        seenIn: [`${SCORE}`, PENDING],
+        extract: ["file", "list", "ids"],
+    }),
+    smapi("mods-loaded", {
+        severity: "info",
+        category: "success",
+        pattern: re(String.raw `Loaded (?<count>\d+) mods[:.]$`),
+        explain: "The count of C# mods that loaded; the lines that follow list them alphabetically by display name, which is not the load order.",
+        seenIn: [`${PARSER} ModListStartPattern`, PENDING],
+        extract: ["count"],
+    }),
+    smapi("mod-entry", {
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `   (?<name>.+?) (?<version>[^\s]+)(?: by (?<author>[^|]+))?(?: \| (?<description>.+))?$`),
+        explain: "One loaded mod, by display name (not UniqueID), with its version and author.",
+        seenIn: [`${PARSER} ModListEntryPattern`, PENDING],
+        extract: ["name", "version", "author"],
+    }),
+    smapi("content-packs-loaded", {
+        severity: "info",
+        category: "success",
+        pattern: re(String.raw `Loaded (?<count>\d+) content packs:$`),
+        explain: "The count of content packs that loaded.",
+        seenIn: [`${PARSER} ContentPackListStartPattern`, PENDING],
+        extract: ["count"],
+    }),
+    smapi("content-pack-entry", {
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `   (?<name>.+?) (?<version>[^\s]+)(?: by (?<author>[^|]+))? \| for (?<for>[^|]*)(?: \| (?<description>.+))?$`),
+        explain: "One loaded content pack, by display name, with the mod it is for.",
+        seenIn: [`${PARSER} ContentPackListEntryPattern`, PENDING],
+        extract: ["name", "version", "for"],
+    }),
+    smapi("skipped-mods-header", {
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `   Skipped mods$`),
+        explain: "At least one mod could not be added to the game; the lines below name each with SMAPI's reason.",
+        seenIn: [`${PARSER} SkippedModListStartPattern`, PENDING],
+    }),
+    smapi("skipped-mod", {
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `      - (?<name>.+?) ?(?<version>[^\s]*) because (?<reason>.+)$`),
+        explain: "One skipped mod and SMAPI's reason, phrased as the tail of 'failed loading <mod> because ...'.",
+        seenIn: [`${LOGMANAGER} LogModWarnings`, PENDING],
+        extract: ["name", "version", "reason"],
+    }),
+    smapi("missing-dependencies", {
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because it requires mods which aren't installed \((?<mods>[^)]*)\)`),
+        explain: "The mod declares a required dependency that is not installed; the root cause of a dependency cascade.",
+        hint: "Install the named mod(s); the mod's manifest lists them under Dependencies.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "mods"],
+    }),
+    smapi("dependency-cascade", {
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because it needs the '(?<dep>[^']+)' mod, which couldn't be loaded`),
+        explain: "Collateral of another mod's failure: this mod's dependency was installed but did not load.",
+        hint: "Fix the named dependency first; this line clears with it.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "dep"],
+    }),
+    smapi("dependency-too-old", {
+        severity: "error",
+        category: "version",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because it needs newer versions of some mods: (?<detail>.+)$`),
+        explain: "A dependency is installed but older than the MinimumVersion the mod declares.",
+        hint: "Update the named dependency.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "detail"],
+    }),
+    smapi("circular-dependency", {
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because its dependencies have a circular reference: (?<chain>.+)$`),
+        explain: "Two or more mods require each other; SMAPI cannot order them and loads none of the cycle.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "chain"],
+    }),
+    smapi("needs-newer-smapi", {
+        severity: "error",
+        category: "version",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because it needs SMAPI (?<needed>\S+) or later`),
+        explain: "The mod's MinimumApiVersion is above the running SMAPI.",
+        hint: "Update SMAPI.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "needed"],
+    }),
+    smapi("needs-newer-game", {
+        severity: "error",
+        category: "version",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because it needs Stardew Valley (?<needed>\S+) or later`),
+        explain: "The mod's MinimumGameVersion is above the installed game.",
+        hint: "Update the game.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "needed"],
+    }),
+    smapi("missing-entry-dll", {
+        severity: "error",
+        category: "load",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because its DLL '(?<dll>[^']+)' doesn't exist`),
+        explain: "The manifest's EntryDll names a file that is not in the mod folder.",
+        hint: "The build did not copy the DLL, or the manifest's EntryDll is misspelt.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "dll"],
+    }),
+    smapi("duplicate-mod", {
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `      - (?<name>.+?) because you have multiple copies of this mod installed`),
+        explain: "Two folders carry the same UniqueID; SMAPI loads neither.",
+        hint: "Delete the duplicate folders and reinstall the mod once.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name"],
+    }),
+    smapi("known-broken", {
+        severity: "error",
+        category: "version",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because .*\. Please check for a (?:newer version|version newer than \S+) at `),
+        explain: "SMAPI's internal mod database (smapi-internal/metadata.json) marks this version as broken.",
+        hint: "Update the mod from the linked page.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name"],
+    }),
+    smapi("obsolete-mod", {
+        severity: "error",
+        category: "version",
+        pattern: re(String.raw `      - (?<name>.+?) (?<version>[^\s]+) because it's obsolete: (?<why>.+)$`),
+        explain: "SMAPI's internal mod database marks this mod obsolete.",
+        seenIn: [`${RESOLVER}`, PENDING],
+        extract: ["name", "why"],
+    }),
+    smapi("broken-mods-warning", {
+        severity: "error",
+        category: "load",
+        pattern: re(String.raw `   Broken mods$`),
+        explain: "SMAPI's 'Broken mods' warning group follows: mods that loaded but reference game code that no longer exists.",
+        seenIn: [`${LOGMANAGER} LogModWarningGroup`, PENDING],
+    }),
+    smapi("patches-game", {
+        severity: "info",
+        category: "script",
+        pattern: re(String.raw `   Patched game code$`),
+        explain: "The mods listed below patch game code with Harmony; SMAPI notes it, it is not an error.",
+        seenIn: [`${LOGMANAGER} LogModWarningGroup`, PENDING],
+    }),
+    smapi("patches-game-unfixed-harmony", {
+        severity: "warn",
+        category: "script",
+        pattern: re(String.raw `   Patched game code without Harmony fix$`),
+        explain: "The mods listed below patch game code through a Harmony SMAPI did not rewrite, which its own documentation calls a stability risk.",
+        seenIn: [`${LOGMANAGER} LogModWarningGroup`, PENDING],
+    }),
+    smapi("changes-save-serializer", {
+        severity: "warn",
+        category: "script",
+        pattern: re(String.raw `   Changed save serializer$`),
+        explain: "The mods listed below change how saves are serialized; a save written with them may not load without them.",
+        seenIn: [`${LOGMANAGER} LogModWarningGroup`, PENDING],
+    }),
+    smapi("malicious-mod", {
+        severity: "error",
+        category: "crash",
+        pattern: re(String.raw `Malicious mod detected\.$`),
+        explain: "SMAPI's blacklist matched an installed mod (logged at CRITICAL, whose level column overflows the usual width).",
+        hint: "Remove the mod SMAPI names; see https://smapi.io.",
+        seenIn: [`${LOGMANAGER} LogFatal`, PENDING],
+    }),
+    smapi("crashed-last-time", {
+        severity: "error",
+        category: "crash",
+        pattern: re(String.raw `The game crashed last time you played\.`),
+        explain: "SMAPI found its crash marker from the previous run; the previous SMAPI-crash.txt holds the details.",
+        seenIn: [`${LOGMANAGER} HandleMarkerFiles`, PENDING],
+    }),
+    smapi("failed-to-launch", {
+        severity: "error",
+        category: "crash",
+        pattern: re(String.raw `The game failed to launch: (?<summary>.+)$`),
+        explain: "The game threw during startup; the summary and the continuation lines carry the exception.",
+        seenIn: [`${SCORE}`, PENDING],
+        extract: ["summary"],
+    }),
+    smapi("init-failed", {
+        severity: "error",
+        category: "crash",
+        pattern: re(String.raw `SMAPI failed to initialize: (?<summary>.+)$`),
+        explain: "SMAPI itself failed before loading mods.",
+        seenIn: [`${SCORE}`, PENDING],
+        extract: ["summary"],
+    }),
+    smapi("update-available", {
+        severity: "info",
+        category: "version",
+        pattern: re(String.raw `You can update SMAPI to (?<version>\S+): (?<link>.+)$`),
+        explain: "A newer SMAPI exists.",
+        seenIn: [`${PARSER} SmapiUpdatePattern`, PENDING],
+        extract: ["version", "link"],
+    }),
+    smapi("mod-updates-available", {
+        severity: "info",
+        category: "version",
+        pattern: re(String.raw `You can update (?<count>\d+) mods?:$`),
+        explain: "Newer versions exist for the mods listed below.",
+        seenIn: [`${PARSER} ModUpdateListStartPattern`, PENDING],
+        extract: ["count"],
+    }),
+    smapi("ready", {
+        severity: "info",
+        category: "success",
+        pattern: re(String.raw `Mods loaded and ready!$`),
+        explain: "Every mod that was going to load has loaded; what follows is the game.",
+        seenIn: [`${SCORE}`, PENDING],
+    }),
+    cp("pack-rejected", {
+        severity: "error",
+        category: "resource",
+        pattern: re(String.raw `Could not load content pack '(?<pack>[^']+)': (?<reason>.+)\.$`),
+        explain: "Content Patcher refused a whole pack: no content.json, no Format field, or neither Changes nor CustomLocations.",
+        hint: "Fix the pack's content.json; the reason is Content Patcher's own sentence.",
+        seenIn: [`${CP}`, PENDING],
+        extract: ["pack", "reason"],
+    }),
+    cp("patch-ignored", {
+        severity: "warn",
+        category: "resource",
+        pattern: re(String.raw `Ignored (?<pack>.+?) > (?<label>.+?): (?<reason>.+)$`),
+        explain: "Content Patcher skipped one patch (`Ignored <pack> > <patch>: <reason>`, PatchLoader's TrackSkip sentence: a missing Action or Target, a FromFile with Entries, an invalid When) or rejected a config.json value against the pack's ConfigSchema (ConfigFileHandler's `Ignored <pack> > <field>: <reason>`); the two share a shape and the reason tells them apart.",
+        hint: "Fix the named field in content.json (or config.json); the pack still loads, the one patch or value is dropped.",
+        seenIn: [`${CP}`, PENDING],
+        extract: ["pack", "label", "reason"],
+    }),
+    cp("error-preloading", {
+        severity: "error",
+        category: "resource",
+        pattern: re(String.raw `Error (?:preloading|loading configuration for) content pack '(?<pack>[^']+)'\.`),
+        explain: "Content Patcher threw while reading a pack; the continuation lines carry the exception.",
+        seenIn: [`${CP}`, PENDING],
+        extract: ["pack"],
+    }),
+];