modwright 0.1.0

package/dist/surfaces/stardewvalley/validators/content.js

@@ -0,0 +1,321 @@
+import * as path from "node:path";
+import { walk } from "../../../core/fsutil.js";
+import { ACTIONS, conditionTokenName, CURRENT_FORMAT, FORMAT_EDITDATA_FROMFILE_REMOVED, FORMAT_ENABLED_OBSOLETE, FORMAT_SCHEMA_MESSAGE, formatOlderThan, formatState, hasTokens, isKnownToken, parseContentJson, patchesOf, pick, splitLexically, tokenNames, tokenPathToRegExp, } from "../contentpatcher.js";
+const EVIDENCE = ["stardewvalley.contentpatcher.format.what-a-pack-is", "stardewvalley.contentpatcher.format.published-json-schema"];
+const APPLIES = "every content.json under a project source";
+function isWithin(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!(rel === ".." || rel.startsWith(`..${path.sep}`)) && !path.isAbsolute(rel));
+}
+function isContentJson(target, project) {
+    if (target.kind !== "file" || path.basename(target.path).toLowerCase() !== "content.json")
+        return false;
+    return project.sources.some((s) => s.exists && isWithin(s.absPath, target.path));
+}
+async function load(ctx, id, file) {
+    let text;
+    try {
+        text = await ctx.readText(file);
+    }
+    catch (err) {
+        return { validatorId: id, severity: "block", file, message: `content.json could not be read: ${err.message}`, evidence: EVIDENCE };
+    }
+    try {
+        return parseContentJson(text);
+    }
+    catch (err) {
+        return { validatorId: id, severity: "block", file, message: `content.json is not a JSON object: ${err.message}; Content Patcher logs "Error preloading content pack" and loads nothing from it.`, fix: "Check it at smapi.io/json with the Content Patcher format.", evidence: EVIDENCE };
+    }
+}
+const isFinding = (v) => v.validatorId !== undefined;
+const has = (p, name) => {
+    const v = pick(p.raw, name)?.value;
+    if (v === undefined || v === null)
+        return false;
+    if (typeof v === "string")
+        return v.trim().length > 0;
+    if (Array.isArray(v))
+        return v.length > 0;
+    if (typeof v === "object")
+        return Object.keys(v).length > 0;
+    return true;
+};
+const actionOf = (p) => ACTIONS.find((a) => a.toLowerCase() === (p.action ?? "").trim().toLowerCase());
+function rule(id, summary, severity, evidence, run) {
+    return {
+        id: `stardewvalley.content.${id}`,
+        game: "stardewvalley",
+        groups: ["content"],
+        modTypes: ["content-pack"],
+        summary,
+        appliesTo: isContentJson,
+        appliesToDescription: APPLIES,
+        needs: { project: true },
+        cost: "edit",
+        severity,
+        evidence,
+        async run(ctx) {
+            if (ctx.target.kind !== "file")
+                return [];
+            const cfg = await load(ctx, this.id, ctx.target.path);
+            if (isFinding(cfg))
+                return id === "parses" ? [cfg] : [];
+            return run(ctx, cfg, ctx.target.path, this.id);
+        },
+    };
+}
+const parses = rule("parses", "content.json parses as a JSON object (comments and trailing commas allowed, as SMAPI's reader allows); anything else fails the whole pack.", "block", EVIDENCE, (_ctx, cfg, file, rid) => {
+    const findings = [];
+    for (const { key, expected } of cfg.miscased) {
+        findings.push({ validatorId: rid, severity: "info", file, message: `top-level field "${key}" is read as "${expected}" (Content Patcher's JSON reader matches names case-insensitively), but the published schema and smapi.io/json reject the spelling.`, evidence: EVIDENCE });
+    }
+    if (cfg.extraFields.length > 0)
+        findings.push({ validatorId: rid, severity: "info", file, message: `content.json has top-level fields Content Patcher does not define (${cfg.extraFields.join(", ")}); they are ignored, and smapi.io/json's schema rejects them.`, evidence: [...EVIDENCE, "stardewvalley.contentpatcher.format.top-level-fields"] });
+    return findings;
+});
+const format = rule("format", `Format is present and a version; below the current ${CURRENT_FORMAT} it still loads through Content Patcher's migrations (warn, never block, though the schema would reject it).`, "block", [...EVIDENCE, "stardewvalley.contentpatcher.format.format-field-is-a-cp-version", "stardewvalley.contentpatcher.format.schema-pins-the-current-version", "stardewvalley.contentpatcher.format.whole-pack-rejection-messages"], (_ctx, cfg, file, rid) => {
+    switch (formatState(cfg.format)) {
+        case "missing":
+            return [{ validatorId: rid, severity: "block", file, message: "content pack doesn't specify the required Format field. (Content Patcher's own rejection; nothing in the pack loads.)", fix: `Add "Format": "${CURRENT_FORMAT}".`, evidence: EVIDENCE }];
+        case "invalid":
+            return [{ validatorId: rid, severity: "block", file, message: `Format ${JSON.stringify(cfg.format)} is not a version; Content Patcher cannot read the pack.`, fix: `Set "Format": "${CURRENT_FORMAT}".`, evidence: EVIDENCE }];
+        case "older":
+            return [{ validatorId: rid, severity: "warn", file, message: `Format "${cfg.format}" is older than the current ${CURRENT_FORMAT}: the pack still loads (Content Patcher migrates it), but the published schema rejects it with "${FORMAT_SCHEMA_MESSAGE}"`, fix: `Update to "Format": "${CURRENT_FORMAT}" and check the release notes for behaviour that changed in between.`, evidence: EVIDENCE }];
+        case "newer":
+            return [{ validatorId: rid, severity: "warn", file, message: `Format "${cfg.format}" is newer than ${CURRENT_FORMAT}, the current version when this rule was written; Content Patcher rejects a Format newer than itself.`, evidence: EVIDENCE }];
+        default:
+            return [];
+    }
+});
+const changesPresent = rule("changes-present", "Changes (a list of patch objects) or CustomLocations is present and non-empty; otherwise Content Patcher rejects the whole pack.", "block", [...EVIDENCE, "stardewvalley.contentpatcher.format.whole-pack-rejection-messages", "stardewvalley.contentpatcher.format.top-level-fields"], (_ctx, cfg, file, rid) => {
+    const findings = [];
+    const changes = cfg.changes;
+    const locations = cfg.customLocations;
+    if (changes !== undefined && changes !== null && !Array.isArray(changes))
+        findings.push({ validatorId: rid, severity: "block", file, message: `Changes is ${Array.isArray(changes) ? "a list" : typeof changes}, not a list of patches.`, evidence: EVIDENCE });
+    if (locations !== undefined && locations !== null && !Array.isArray(locations))
+        findings.push({ validatorId: rid, severity: "block", file, message: `CustomLocations is ${typeof locations}, not a list.`, evidence: EVIDENCE });
+    const entries = Array.isArray(changes) ? changes : [];
+    const anyChanges = entries.some((e) => e !== null);
+    const anyLocations = Array.isArray(locations) && locations.length > 0;
+    if (!anyChanges && !anyLocations && findings.length === 0) {
+        findings.push({ validatorId: rid, severity: "block", file, message: "content pack must specify the Changes or CustomLocations fields. (Content Patcher's own rejection; nothing in the pack loads.)", fix: 'Add a "Changes": [ ... ] list with at least one patch.', evidence: EVIDENCE });
+    }
+    for (const i of patchesOf(cfg).invalid) {
+        if (entries[i] === null)
+            findings.push({ validatorId: rid, severity: "info", file, message: `Changes entry #${i + 1} is null; Content Patcher drops it and loads the rest of the list, so it is a patch that quietly does not exist.`, fix: "Remove the null, or write the patch it was meant to be.", evidence: EVIDENCE });
+        else
+            findings.push({ validatorId: rid, severity: "block", file, message: `Changes entry #${i + 1} is not an object; Content Patcher cannot read the pack.`, evidence: EVIDENCE });
+    }
+    return findings;
+});
+const patchAction = rule("patch-action", "Every patch sets Action to one of Load, EditData, EditImage, EditMap or Include (case-insensitively); otherwise Content Patcher skips it with the reason quoted here.", "block", [...EVIDENCE, "stardewvalley.contentpatcher.format.five-actions", "stardewvalley.contentpatcher.format.patch-skip-reasons"], (_ctx, cfg, file, rid) => {
+    const findings = [];
+    for (const p of patchesOf(cfg).patches) {
+        const raw = pick(p.raw, "Action")?.value;
+        if (raw === undefined || raw === null || (typeof raw === "string" && raw.trim() === "")) {
+            findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must set the Action field.`, evidence: EVIDENCE });
+        }
+        else if (typeof raw !== "string" || !actionOf(p)) {
+            findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: invalid Action value '${typeof raw === "string" ? raw : JSON.stringify(raw)}', expected one of: ${ACTIONS.join(", ")}.`, evidence: EVIDENCE });
+        }
+    }
+    return findings;
+});
+const patchTarget = rule("patch-target", "Every patch except an Include sets Target, and an Include does not; a Target is an asset name with no Content/ prefix and no extension.", "block", [...EVIDENCE, "stardewvalley.contentpatcher.format.patch-skip-reasons", "stardewvalley.contentpatcher.format.asset-names-have-no-extension"], (_ctx, cfg, file, rid) => {
+    const findings = [];
+    for (const p of patchesOf(cfg).patches) {
+        const action = actionOf(p);
+        if (!action)
+            continue;
+        const target = has(p, "Target") ? p.target : undefined;
+        if (action === "Include") {
+            if (target !== undefined)
+                findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: can't use the Target field with an Include patch.`, evidence: EVIDENCE });
+            continue;
+        }
+        if (target === undefined) {
+            findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must set the Target field.`, fix: 'Target is the asset name, e.g. "Portraits/Abigail".', evidence: EVIDENCE });
+            continue;
+        }
+        for (const t of splitLexically(target)) {
+            const norm = t.replace(/\\/g, "/");
+            if (/^content\//i.test(norm))
+                findings.push({ validatorId: rid, severity: "warn", file, message: `${p.label}: Target "${t}" starts with Content/; the asset name never includes the Content folder (Content/Maps/spring_beach.xnb is the asset Maps/spring_beach), so this names nothing the game loads.`, evidence: EVIDENCE });
+            if (/\.xnb$/i.test(norm))
+                findings.push({ validatorId: rid, severity: "warn", file, message: `${p.label}: Target "${t}" ends in a file extension; the asset name never includes the extension or the language code. Content Patcher strips a trailing .xnb (ParseAssetName, "maintain legacy behavior"), so this one still resolves, but write the asset name.`, evidence: EVIDENCE });
+            else if (/\.(?:png|json|tbin|tmx)$/i.test(norm))
+                findings.push({ validatorId: rid, severity: "warn", file, message: `${p.label}: Target "${t}" ends in a file extension; the asset name never includes the extension or the language code, and only a trailing .xnb is stripped, so this names nothing the game loads.`, evidence: EVIDENCE });
+        }
+    }
+    return findings;
+});
+const patchFields = rule("patch-fields", "Each action has the fields Content Patcher requires of it (FromFile for Load, EditImage and Include; Entries/Fields/MoveEntries/TextOperations for EditData; one of six for EditMap), and no field it forbids; unknown patch fields are noted.", "block", [...EVIDENCE, "stardewvalley.contentpatcher.format.patch-fields", "stardewvalley.contentpatcher.format.patch-skip-reasons"], (_ctx, cfg, file, rid) => {
+    const findings = [];
+    const editDataFromFileAllowed = formatOlderThan(cfg.format, FORMAT_EDITDATA_FROMFILE_REMOVED);
+    for (const p of patchesOf(cfg).patches) {
+        if (p.extraFields.length > 0)
+            findings.push({ validatorId: rid, severity: "info", file, message: `${p.label} has fields Content Patcher does not define (${p.extraFields.join(", ")}); they are ignored, which usually means a misspelled field is doing nothing.`, evidence: EVIDENCE });
+        const action = actionOf(p);
+        if (!action)
+            continue;
+        const fromFileRaw = pick(p.raw, "FromFile")?.value;
+        if (typeof fromFileRaw === "string" && fromFileRaw.trim().length === 0) {
+            findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must set the FromFile field for this action type.`, fix: "Give FromFile a path relative to the pack folder, or remove the field.", evidence: EVIDENCE });
+            continue;
+        }
+        const fromFile = has(p, "FromFile");
+        const dataFields = ["Entries", "Fields", "MoveEntries", "TextOperations"].filter((f) => has(p, f));
+        const exclusive = ["Entries", "Fields", "MoveEntries"].some((f) => has(p, f));
+        const text = JSON.stringify(p.raw);
+        switch (action) {
+            case "Load":
+                if (!fromFile)
+                    findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must set the FromFile field for a Load patch.`, evidence: EVIDENCE });
+                break;
+            case "EditImage":
+                if (!fromFile)
+                    findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must set the FromFile field for a Load patch. (Content Patcher's wording for an EditImage patch without FromFile.)`, evidence: EVIDENCE });
+                break;
+            case "Include":
+                if (!fromFile)
+                    findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must set the FromFile field for an Include patch.`, evidence: EVIDENCE });
+                break;
+            case "EditData":
+                if (editDataFromFileAllowed) {
+                    if (dataFields.length === 0 && !fromFile)
+                        findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: one of Entries, Fields, MoveEntries, TextOperations, or FromFile must be specified for an 'EditData' change.`, evidence: EVIDENCE });
+                    if (fromFile && exclusive)
+                        findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: FromFile is mutually exclusive with Entries, Fields, and MoveEntries.`, evidence: EVIDENCE });
+                }
+                else {
+                    if (fromFile)
+                        findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: the FromFile field can't be used with an 'EditData' patch. (Allowed only below Format ${FORMAT_EDITDATA_FROMFILE_REMOVED}.)`, fix: "Put the entries in an Entries block, or use an Include patch for a separate file.", evidence: EVIDENCE });
+                    if (dataFields.length === 0)
+                        findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: one of Entries, Fields, MoveEntries, or TextOperations must be specified for an 'EditData' change.`, evidence: EVIDENCE });
+                }
+                break;
+            case "EditMap":
+                if (!["AddNpcWarps", "AddWarps", "FromFile", "MapProperties", "MapTiles", "TextOperations"].some((f) => has(p, f)))
+                    findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: must specify at least one of AddNpcWarps, AddWarps, FromFile, MapProperties, MapTiles, or TextOperations.`, evidence: EVIDENCE });
+                break;
+        }
+        if (!fromFile && /\{\{\s*FromFile\s*\}\}/i.test(text))
+            findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: can't use the {{FromFile}} token because the patch has no FromFile field.`, evidence: EVIDENCE });
+        if (!has(p, "Target")) {
+            const used = ["Target", "TargetPathOnly", "TargetWithoutPath"].find((t) => new RegExp(`\\{\\{\\s*${t}\\s*\\}\\}`, "i").test(text));
+            if (used !== undefined)
+                findings.push({ validatorId: rid, severity: "block", file, message: `Ignored ${p.label}: can't use the {{${used}}} token because the patch has no Target field.`, evidence: EVIDENCE });
+        }
+    }
+    return findings;
+});
+async function packFiles(dir) {
+    try {
+        return (await walk(dir)).files;
+    }
+    catch {
+        return [];
+    }
+}
+const fromFileExists = rule("fromfile-exists", "Every FromFile names a file in the pack: a tokenless path must exist (a case-only mismatch warns, since Linux and macOS are case-sensitive), and a tokenised path must match at least one file. A missing file is a silent no-op Content Patcher reports only at Warn, at apply time.", "block", [...EVIDENCE, "stardewvalley.contentpatcher.format.patch-fields", "stardewvalley.contentpatcher.format.tokens-and-conditions"], async (ctx, cfg, file, rid) => {
+    const findings = [];
+    const packDir = path.dirname(file);
+    let listing;
+    const files = async () => (listing ??= await packFiles(packDir));
+    for (const p of patchesOf(cfg).patches) {
+        if (!has(p, "FromFile") || !p.fromFile)
+            continue;
+        for (const raw of splitLexically(p.fromFile)) {
+            const rel = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+            if (!hasTokens(rel)) {
+                if (path.isAbsolute(rel) || rel.split("/").includes("..")) {
+                    findings.push({ validatorId: rid, severity: "block", file, message: `${p.label}: FromFile "${raw}" leaves the pack folder; Content Patcher resolves FromFile relative to the pack and refuses paths outside it.`, evidence: EVIDENCE });
+                    continue;
+                }
+                const abs = path.join(packDir, rel);
+                const listed = await files();
+                if (listed.includes(rel))
+                    continue;
+                const actual = listed.find((f) => f.toLowerCase() === rel.toLowerCase());
+                if (actual !== undefined) {
+                    findings.push({ validatorId: rid, severity: "warn", file, message: `${p.label}: FromFile "${raw}" is on disk as "${actual}"; the case differs, which loads on Windows and fails on Linux and macOS unless SMAPI's UseCaseInsensitivePaths is on.`, fix: `Rename one to match the other exactly.`, evidence: EVIDENCE, related: [path.join(packDir, actual)] });
+                    continue;
+                }
+                if (await ctx.exists(abs))
+                    continue;
+                findings.push({ validatorId: rid, severity: "block", file, message: `${p.label}: FromFile "${raw}" does not exist in the pack (${abs}); the patch applies nothing, and Content Patcher reports it only as one Warn line when the asset is requested.`, fix: "Add the file, or correct FromFile (paths are relative to the folder holding content.json, assets/ by convention).", evidence: EVIDENCE, related: [abs] });
+                continue;
+            }
+            const re = tokenPathToRegExp(rel);
+            const matches = (await files()).filter((f) => re.test(f));
+            if (matches.length === 0) {
+                findings.push({ validatorId: rid, severity: "warn", file, message: `${p.label}: FromFile "${raw}" uses tokens and no file in the pack matches the shape it can produce (${re.source}); unless every value is provided elsewhere, the patch applies nothing.`, fix: "Add at least one file the tokens can resolve to, or check the path.", evidence: EVIDENCE });
+            }
+        }
+    }
+    return findings;
+});
+const patchEnabled = rule("patch-enabled", `A patch's Enabled field: obsolete from Format ${FORMAT_ENABLED_OBSOLETE} on (Content Patcher skips the patch unless the value is literally true), and below that a false value skips the patch with no log line at all.`, "warn", [...EVIDENCE, "stardewvalley.contentpatcher.format.disabled-patch-logs-nothing", "stardewvalley.contentpatcher.format.patch-skip-reasons"], (_ctx, cfg, file, rid) => {
+    const findings = [];
+    const obsolete = !formatOlderThan(cfg.format, FORMAT_ENABLED_OBSOLETE);
+    for (const p of patchesOf(cfg).patches) {
+        const hit = pick(p.raw, "Enabled");
+        if (!hit || hit.value === undefined || hit.value === null)
+            continue;
+        const v = hit.value;
+        const literalTrue = v === true || (typeof v === "string" && v.trim().toLowerCase() === "true");
+        const literalFalse = v === false || (typeof v === "string" && v.trim().toLowerCase() === "false");
+        if (obsolete) {
+            if (literalTrue)
+                findings.push({ validatorId: rid, severity: "info", file, message: `${p.label} sets Enabled: true, which Content Patcher ignores from Format ${FORMAT_ENABLED_OBSOLETE} on; remove it.`, evidence: EVIDENCE });
+            else
+                findings.push({ validatorId: rid, severity: "warn", file, message: `Ignored ${p.label}: the Enabled field is obsolete and should be removed. (From Format ${FORMAT_ENABLED_OBSOLETE} on, any value but true skips the patch.)`, fix: "Delete the Enabled field; use a When condition to switch the patch off.", evidence: EVIDENCE });
+        }
+        else if (literalFalse) {
+            findings.push({ validatorId: rid, severity: "info", file, message: `${p.label} is disabled (Enabled: false) and Content Patcher logs nothing about it; the classic "my patch does nothing and the log is clean" cause.`, evidence: EVIDENCE });
+        }
+    }
+    return findings;
+});
+const whenTokens = rule("when-tokens", "Every When key names a token Content Patcher provides or the pack declares (ConfigSchema, DynamicTokens, AliasTokenNames); a mod-provided ModId/Name token is not checked. Content Patcher skips the patch with the reason quoted here.", "warn", [...EVIDENCE, "stardewvalley.contentpatcher.format.tokens-and-conditions", "stardewvalley.contentpatcher.format.patch-skip-reasons"], (_ctx, cfg, file, rid) => {
+    const findings = [];
+    for (const p of patchesOf(cfg).patches) {
+        const when = pick(p.raw, "When")?.value;
+        if (!when || typeof when !== "object" || Array.isArray(when))
+            continue;
+        for (const key of Object.keys(when)) {
+            const name = conditionTokenName(key);
+            if (name === undefined || isKnownToken(name, cfg))
+                continue;
+            findings.push({ validatorId: rid, severity: "warn", file, message: `Ignored ${p.label}: the When field is invalid: '${name}' can't be used as a token because that token could not be found.`, fix: "Check the spelling against the tokens guide, or declare it in ConfigSchema or DynamicTokens.", evidence: EVIDENCE });
+        }
+    }
+    return findings;
+});
+const configSchema = rule("config-schema", "Each ConfigSchema key is used somewhere in content.json (as a {{token}} or a When key); an unused one is a config.json option that changes nothing, and an entry that is not an object stops the whole pack from loading.", "warn", [...EVIDENCE, "stardewvalley.contentpatcher.format.config-json-and-schema"], (_ctx, cfg, file, rid) => {
+    if (!cfg.configSchema)
+        return [];
+    const findings = [];
+    const used = new Set();
+    const text = JSON.stringify(cfg.changes ?? []) + JSON.stringify(cfg.dynamicTokens ?? []) + JSON.stringify(cfg.customLocations ?? []);
+    for (const t of tokenNames(text))
+        used.add(t.toLowerCase());
+    for (const p of patchesOf(cfg).patches) {
+        const when = pick(p.raw, "When")?.value;
+        if (when && typeof when === "object" && !Array.isArray(when))
+            for (const k of Object.keys(when)) {
+                const name = conditionTokenName(k);
+                if (name)
+                    used.add(name.toLowerCase());
+            }
+    }
+    for (const [key, value] of Object.entries(cfg.configSchema)) {
+        if (!value || typeof value !== "object")
+            findings.push({ validatorId: rid, severity: "warn", file, message: `ConfigSchema "${key}" is not an object (each entry describes one config.json field: AllowValues, Default, ...); Content Patcher cannot read the file at all and logs "Error preloading content pack".`, evidence: EVIDENCE });
+        if (!used.has(key.toLowerCase()))
+            findings.push({ validatorId: rid, severity: "info", file, message: `ConfigSchema "${key}" is never used as {{${key}}} or as a When key, so the config.json option it creates changes nothing.`, evidence: EVIDENCE });
+    }
+    return findings;
+});
+export const CONTENT_VALIDATORS = [parses, format, changesPresent, patchAction, patchTarget, patchFields, fromFileExists, patchEnabled, whenTokens, configSchema];

package/dist/surfaces/stardewvalley/validators/fields.js

@@ -0,0 +1,147 @@
+import * as path from "node:path";
+import { hasTokens, parseContentJson, patchesOf, pick, splitLexically } from "../contentpatcher.js";
+import { normalizeAsset } from "../index/index.js";
+const EVIDENCE = [
+    "stardewvalley.game.versions.data-asset-doc-index",
+    "stardewvalley.game.versions.1-6-moved-data-to-string-keyed-models",
+    "stardewvalley.wiki.dataformat.field-tables-are-the-schema",
+    "stardewvalley.wiki.dataformat.delimited-assets-use-index-tables",
+];
+const APPLIES = "every content.json under a project source";
+const MAX_PER_FILE = 30;
+function isWithin(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!(rel === ".." || rel.startsWith(`..${path.sep}`)) && !path.isAbsolute(rel));
+}
+function isContentJson(target, project) {
+    if (target.kind !== "file" || path.basename(target.path).toLowerCase() !== "content.json")
+        return false;
+    return project.sources.some((s) => s.exists && isWithin(s.absPath, target.path));
+}
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : undefined);
+function fieldNamesUsed(raw) {
+    const out = [];
+    const fields = obj(pick(raw, "Fields")?.value);
+    if (fields)
+        for (const [entry, value] of Object.entries(fields))
+            for (const name of Object.keys(obj(value) ?? {}))
+                out.push({ name, from: `Fields > ${entry}` });
+    const entries = obj(pick(raw, "Entries")?.value);
+    if (entries)
+        for (const [entry, value] of Object.entries(entries))
+            for (const name of Object.keys(obj(value) ?? {}))
+                out.push({ name, from: `Entries > ${entry}` });
+    return out;
+}
+const editDataFields = {
+    id: "stardewvalley.content.editdata-fields",
+    game: "stardewvalley",
+    groups: ["content"],
+    modTypes: ["content-pack"],
+    summary: "Every field an EditData patch sets on a documented Data/* asset (Fields keys, and the keys of object-valued Entries) is in the wiki's documented model for that asset; on a delimited-string asset the Fields keys are positions the format has. A case-only difference, a patch that sets TargetField, and an undocumented asset are noted, not guessed.",
+    appliesTo: isContentJson,
+    appliesToDescription: APPLIES,
+    needs: { project: true, index: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const file = ctx.target.path;
+        let text;
+        try {
+            text = await ctx.readText(file);
+        }
+        catch {
+            return [];
+        }
+        let patches;
+        try {
+            patches = patchesOf(parseContentJson(text)).patches;
+        }
+        catch {
+            return [];
+        }
+        const findings = [];
+        const assets = new Map();
+        const lookupAsset = async (asset) => {
+            if (assets.has(asset))
+                return assets.get(asset);
+            const result = await ctx.lookup("asset", { name: asset, limit: 2000 });
+            let doc;
+            if (result.count > 0) {
+                doc = { shape: String(result.rows[0].shape ?? "model"), names: new Map(), maxPosition: -1 };
+                for (const r of result.rows) {
+                    const name = String(r.name);
+                    doc.names.set(name.toLowerCase(), name);
+                    if (typeof r.position === "number" && r.position > doc.maxPosition)
+                        doc.maxPosition = r.position;
+                }
+            }
+            assets.set(asset, doc);
+            return doc;
+        };
+        const undocumented = new Set();
+        const reRooted = [];
+        for (const p of patches) {
+            if ((p.action ?? "").trim().toLowerCase() !== "editdata" || !p.target)
+                continue;
+            if (pick(p.raw, "TargetField") !== undefined) {
+                reRooted.push(p.label);
+                continue;
+            }
+            const used = fieldNamesUsed(p.raw);
+            for (const one of splitLexically(p.target)) {
+                if (hasTokens(one))
+                    continue;
+                const asset = normalizeAsset(one);
+                if (!/^data\//i.test(asset))
+                    continue;
+                const doc = await lookupAsset(asset);
+                if (!doc) {
+                    undocumented.add(asset);
+                    continue;
+                }
+                if (doc.shape === "delimited") {
+                    const entries = obj(pick(p.raw, "Entries")?.value);
+                    if (entries)
+                        for (const [entry, value] of Object.entries(entries)) {
+                            if (obj(value))
+                                findings.push({ validatorId: this.id, severity: "warn", file, message: `${p.label}: Entries > ${entry} is an object, but ${asset} is documented as a '/'-delimited string (${doc.maxPosition + 1} positions); the entry must be a string.`, evidence: EVIDENCE });
+                        }
+                    for (const { name, from } of used) {
+                        if (from.startsWith("Entries") || hasTokens(name))
+                            continue;
+                        if (!/^\d+$/.test(name))
+                            findings.push({ validatorId: this.id, severity: "warn", file, message: `${p.label}: ${from} > "${name}" is not a position; ${asset} is a '/'-delimited string, so Fields keys are the 0-based indexes the wiki documents (0 to ${doc.maxPosition}).`, evidence: EVIDENCE });
+                        else if (Number(name) > doc.maxPosition)
+                            findings.push({ validatorId: this.id, severity: "warn", file, message: `${p.label}: ${from} > position ${name} is beyond the documented format of ${asset} (positions 0 to ${doc.maxPosition}).`, evidence: EVIDENCE });
+                    }
+                    continue;
+                }
+                for (const { name, from } of used) {
+                    if (hasTokens(name))
+                        continue;
+                    const documented = doc.names.get(name.toLowerCase());
+                    if (documented === name)
+                        continue;
+                    if (documented !== undefined)
+                        findings.push({ validatorId: this.id, severity: "info", file, message: `${p.label}: ${from} > "${name}" is documented as "${documented}" on ${asset}; whether the game's JSON reader accepts the other casing is not established, so write the documented spelling.`, fix: `Use "${documented}".`, evidence: EVIDENCE });
+                    else
+                        findings.push({ validatorId: this.id, severity: "warn", file, message: `${p.label}: ${from} > "${name}" is not a field the wiki documents for ${asset} (${doc.names.size} documented); a misspelled field is silently ignored by the game.`, fix: `lookup asset name=${asset} lists the documented fields.`, evidence: EVIDENCE });
+                }
+            }
+        }
+        if (reRooted.length > 0)
+            findings.push({ validatorId: this.id, severity: "info", file, message: `Field names were not checked for the patches that set TargetField: ${reRooted.join(", ")}. TargetField re-roots Fields and Entries at a sub-block, so their keys are not the asset's own model fields.`, evidence: EVIDENCE });
+        if (undocumented.size > 0)
+            findings.push({ validatorId: this.id, severity: "info", file, message: `EditData targets not documented by the wiki pages this index covers, so their field names were not checked: ${[...undocumented].sort().join(", ")}.`, evidence: EVIDENCE });
+        if (findings.length > MAX_PER_FILE) {
+            const rest = findings.length - MAX_PER_FILE;
+            return [...findings.slice(0, MAX_PER_FILE), { validatorId: this.id, severity: "info", file, message: `${rest} more field finding(s) in this file not listed.`, evidence: EVIDENCE }];
+        }
+        return findings;
+    },
+};
+export const FIELDS_VALIDATORS = [editDataFields];

package/dist/surfaces/stardewvalley/validators/loadorder.js

@@ -0,0 +1,69 @@
+import * as path from "node:path";
+import { metadataFor, readModMetadata } from "../compat.js";
+import { readSmapiConfig, stringList } from "../config.js";
+import { scanMods } from "../mods.js";
+const EVIDENCE = ["stardewvalley.smapi.loader.load-order-override-lists", "stardewvalley.smapi.loader.load-order-override-warnings"];
+const overrideLists = {
+    id: "stardewvalley.loadorder.override-lists",
+    game: "stardewvalley",
+    groups: ["packaging"],
+    modTypes: ["packaging"],
+    summary: "The ModsToLoadEarly and ModsToLoadLate lists in SMAPI's merged config name installed mods and share no id (SMAPI's three startup warnings, checked before launch); an id SMAPI's own metadata.json marks broken is noted.",
+    appliesTo: (target) => target.kind === "project",
+    appliesToDescription: "the project once, against the located install's smapi-internal/config.json (with config.user.json and Mods/SMAPI-config.json merged over it)",
+    needs: { project: true, install: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "project" || !ctx.install)
+            return [];
+        const install = ctx.install;
+        const config = await readSmapiConfig(install);
+        const findings = [];
+        if (config.files.length === 0) {
+            return [{ validatorId: this.id, severity: "info", file: path.join(install.root, "smapi-internal", "config.json"), message: "No SMAPI config file exists (smapi-internal/config.json, config.user.json or Mods/SMAPI-config.json): either SMAPI is not installed here, or it has never been installed by its installer. Its shipped default leaves both override lists empty.", evidence: EVIDENCE }];
+        }
+        for (const f of config.unreadable)
+            findings.push({ validatorId: this.id, severity: "warn", file: f, message: `${path.basename(f)} is not valid JSON; SMAPI cannot read it and, for the base config, will not start.`, evidence: EVIDENCE });
+        const dedupe = (ids) => {
+            const seen = new Set();
+            return ids.filter((id) => (seen.has(id.toLowerCase()) ? false : (seen.add(id.toLowerCase()), true)));
+        };
+        const early = dedupe(stringList(config.settings, "ModsToLoadEarly"));
+        const late = dedupe(stringList(config.settings, "ModsToLoadLate"));
+        if (early.length === 0 && late.length === 0)
+            return findings;
+        const modsDir = path.join(install.root, "Mods");
+        const mods = (await ctx.exists(modsDir)) ? await scanMods(modsDir) : [];
+        const installed = new Set();
+        for (const m of mods)
+            if (typeof m.manifest?.UniqueID === "string")
+                installed.add(m.manifest.UniqueID.toLowerCase());
+        const sortIds = (ids) => [...ids].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        const missingEarly = sortIds(early.filter((id) => !installed.has(id.toLowerCase())));
+        const missingLate = sortIds(late.filter((id) => !installed.has(id.toLowerCase())));
+        const earlyIds = new Set(early.map((id) => id.toLowerCase()));
+        const duplicate = sortIds(late.filter((id) => earlyIds.has(id.toLowerCase())));
+        const quote = (ids) => `'${ids.join("', '")}'`;
+        const fileFor = (key) => config.sources[key] ?? config.files[config.files.length - 1];
+        if (missingEarly.length > 0)
+            findings.push({ validatorId: this.id, severity: "warn", file: fileFor("ModsToLoadEarly"), message: `The 'smapi-internal/config.json' file lists mod IDs in ModsToLoadEarly which aren't installed: ${quote(missingEarly)}. (SMAPI's startup warning; the entry is ignored.)`, fix: "Remove the id, or install the mod; ids are the manifests' UniqueID, matched case-insensitively.", evidence: EVIDENCE });
+        if (missingLate.length > 0)
+            findings.push({ validatorId: this.id, severity: "warn", file: fileFor("ModsToLoadLate"), message: `The 'smapi-internal/config.json' file lists mod IDs in ModsToLoadLate which aren't installed: ${quote(missingLate)}. (SMAPI's startup warning; the entry is ignored.)`, fix: "Remove the id, or install the mod; ids are the manifests' UniqueID, matched case-insensitively.", evidence: EVIDENCE });
+        if (duplicate.length > 0)
+            findings.push({ validatorId: this.id, severity: "warn", file: fileFor("ModsToLoadLate"), message: `The 'smapi-internal/config.json' file lists mod IDs which are in both ModsToLoadEarly and ModsToLoadLate: ${quote(duplicate)}. These will be loaded early. (SMAPI's startup warning.)`, fix: "Keep the id in one list.", evidence: EVIDENCE });
+        const metadata = await readModMetadata(install);
+        if (metadata !== undefined) {
+            for (const id of [...early, ...late]) {
+                for (const e of metadataFor(metadata, id)) {
+                    if (!/^(?:AssumeBroken|Obsolete)$/i.test(e.status))
+                        continue;
+                    findings.push({ validatorId: this.id, severity: "info", file: path.join(install.root, "smapi-internal", "metadata.json"), message: `${id} is in the override lists and SMAPI's own metadata.json marks "${e.name}" ${e.status}${e.range ? ` for versions ${e.range}` : ""}${e.reason ? `: ${e.reason}` : ""}; if the installed version is in that range SMAPI skips it regardless of order.`, evidence: [...EVIDENCE, "stardewvalley.smapi.loader.rewrites-mods-for-compatibility"] });
+                }
+            }
+        }
+        return findings;
+    },
+};
+export const LOADORDER_VALIDATORS = [overrideLists];