modwright 0.1.0

package/dist/surfaces/eldenring/surface.js

@@ -0,0 +1,121 @@
+import * as path from "node:path";
+import { pathExists } from "../../core/fsutil.js";
+import { findInSteam } from "../../core/steam.js";
+import { dedupeByRoot, logs, roots } from "../../core/surfaceutil.js";
+import { MODENGINE2_CONFIG, gameDir, me3ProfilesDir, modengine2ModDir, readModEngine2LoadOrder } from "./loaders.js";
+import { SIGNATURES } from "./logs.js";
+import { eldenringCompat } from "./compat.js";
+import { BINDER_VALIDATORS } from "./validators/binders.js";
+import { PACKAGE_VALIDATORS } from "./validators/packages.js";
+import { PARAM_VALIDATORS } from "./validators/params.js";
+import { PROFILE_VALIDATORS } from "./validators/profiles.js";
+export const eldenring = {
+    id: "eldenring",
+    name: "Elden Ring",
+    aliases: ["elden", "er", "eldenring"],
+    summary: "FromSoftware. Packed archives under Game/, regulation.bin loose beside them, mods as a " +
+        "loose-file overlay through me3 or Mod Engine 2, which launch the game without EAC.",
+    async detect() {
+        const installs = [];
+        const override = process.env.MODWRIGHT_ELDENRING_ROOT;
+        if (override && (await pathExists(override))) {
+            installs.push({ gameId: "eldenring", root: override, source: "env" });
+        }
+        for (const root of await findInSteam(["ELDEN RING"])) {
+            if (await pathExists(path.join(root, "Game", "eldenring.exe"))) {
+                installs.push({ gameId: "eldenring", root, source: "steam" });
+            }
+        }
+        return dedupeByRoot(installs);
+    },
+    modRoots(install) {
+        const game = gameDir(install);
+        return roots([
+            {
+                id: "me3-profiles",
+                label: "me3 profiles",
+                path: me3ProfilesDir(),
+                layout: "file",
+                extensions: [".me3"],
+                conflictScope: "isolated",
+                notes: "One .me3 TOML profile per setup; its [[packages]] and [[natives]] paths are relative " +
+                    "to the profile file. Profiles never contend with each other. The packages a profile " +
+                    "names are an overlay in which identical relative paths genuinely conflict; which " +
+                    "profile is active is known only at launch (me3 launch -p).",
+            },
+            {
+                id: "modengine2",
+                label: "Mod Engine 2 mods",
+                path: modengine2ModDir(install),
+                layout: "directory",
+                ordered: true,
+                conflictScope: "merged",
+                notes: "Legacy loader (archived 2024-07-19; me3 is the maintained one). Each subdirectory is " +
+                    "a mod, all overlaying one namespace: Mod Engine 2 has no way to resolve conflicting " +
+                    "files including regulation.bin, so the first enabled entry in config_eldenring.toml's " +
+                    "mods list wins a conflict outright.",
+            },
+            {
+                id: "modengine2-dlls",
+                label: "Mod Engine 2 native DLLs",
+                path: path.join(game, "mods"),
+                layout: "file",
+                extensions: [".dll"],
+                conflictScope: "isolated",
+                notes: "DLL mods named in config_eldenring.toml's external_dlls; the Vortex layout keeps them " +
+                    "here. A DLL that fails to load is reported only in modengine2/logs.",
+            },
+            {
+                id: "uxm-loose",
+                label: "Loose game files (UXM unpack)",
+                path: game,
+                layout: "flat",
+                conflictScope: "merged",
+                notes: "Only meaningful after UXM has unpacked the archives and patched the executable to " +
+                    "read loose files; then Game/ itself is the overlay. Patching without unpacking " +
+                    "crashes the game.",
+            },
+        ]);
+    },
+    async loadOrder(install) {
+        return (await readModEngine2LoadOrder(install)).entries;
+    },
+    loadOrderFile(install) {
+        return path.join(gameDir(install), MODENGINE2_CONFIG);
+    },
+    logs(install) {
+        return logs([
+            {
+                id: "modengine2",
+                label: "Mod Engine 2 log",
+                candidates: [path.join(gameDir(install), "modengine2", "logs", "modengine_*.log")],
+                rootId: "modengine2",
+                notes: "A daily-rotating spdlog file: the version banner, which configs loaded, one " +
+                    "'Installing mod location' per enabled mod in priority order, 'Failed to load DLL' " +
+                    "for a native mod that did not load, and 'Applied N hooks' when the injection took. " +
+                    "The game writes no log of its own.",
+            },
+        ]);
+    },
+    async explainMissing(install) {
+        const launcher = path.join(gameDir(install), "modengine2_launcher.exe");
+        if (!(await pathExists(launcher))) {
+            return { modengine2: `${launcher} was not found: Mod Engine 2 is not installed here, so no modengine log exists. A me3 setup logs instead, to <me3 data dir>/logs/<profile>/; 'me3 info' prints that folder as its "Logs directory" line (the Windows default is not sourced from disk yet).` };
+        }
+        return { modengine2: "Mod Engine 2 is installed but has not been launched since its logs directory was created, or the log rotated out (five are kept)." };
+    },
+    logSignatures: SIGNATURES,
+    validators: [...PARAM_VALIDATORS, ...PROFILE_VALIDATORS, ...PACKAGE_VALIDATORS, ...BINDER_VALIDATORS],
+    compat: eldenringCompat,
+    processNames: ["eldenring.exe", "start_protected_game.exe"],
+    guidance: "Mods run only through a loader (me3, or the legacy Mod Engine 2) that launches " +
+        "Game/eldenring.exe directly so Easy Anti-Cheat never loads; modded play is offline, and " +
+        "'Inappropriate Activity Detected' after a modded launch means the injection failed. Two " +
+        "mods both shipping regulation.bin is the normal case and resolves by priority with no " +
+        "merge, so a file-level conflict report here is true but shallow: the real question is " +
+        "which params differ, which needs Smithbox or DSMSPortable. Param edits are checked as text " +
+        "(DSMapStudio CSV or WitchyBND XML under a 'params' source) against a Paramdex checkout: a " +
+        "'paramdex' source, MODWRIGHT_ELDENRING_PARAMDEX, or WitchyBND's bundled copy. There is no in-game bridge and " +
+        "none is planned. Only a Steam install with Game/eldenring.exe present, or " +
+        "MODWRIGHT_ELDENRING_ROOT, is detected. Nothing here has run against an installed game.",
+};

package/dist/surfaces/eldenring/tools.js

@@ -0,0 +1,52 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+export const DSMSPORTABLE_EXIT_CODES = {
+    0: "success",
+    1: "Unhandled Exception",
+    2: "Unhandled Exception processing arguments",
+    3: "No gamepath specified",
+    4: "Could not resolve output path",
+    5: "Unrecognized argument switch",
+    6: "Failed to read TAE file",
+    7: "Timed out loading param files",
+    8: "Failed to save/overwrite file",
+    9: "Failed to save param file",
+    10: "Failed to generate temporary files",
+    11: "Invalid FMG file specified",
+    12: "XML parsing error",
+    13: "Invalid in-line FMG entry",
+    14: "Invalid sblytbnd file specified",
+    15: "Invalid TPF file specified",
+    16: "Invalid BND file specified",
+    17: "Invalid HKS/Lua file specified",
+    18: "Invalid msgbnd file specified",
+    19: "Invalid anibnd file specified",
+    20: "Massedit parse error",
+};
+export function explainDsmsPortableExit(code) {
+    if (code === null || code === undefined)
+        return "DSMSPortable ended without an exit code (killed or timed out).";
+    if (code < 0)
+        return `DSMSPortable exit ${code}: .NET not installed (it needs the .NET 6 Desktop Runtime).`;
+    const meaning = DSMSPORTABLE_EXIT_CODES[code];
+    return meaning ? `DSMSPortable exit ${code}: ${meaning}.` : `DSMSPortable exit ${code}: not in its documented table (0..20).`;
+}
+export const WITCHYBND_PARAMDEX_DIR = path.join("Assets", "Paramdex", "ER");
+export const WITCHYBND_PARAMDEX_VERSION_FILE = path.join(WITCHYBND_PARAMDEX_DIR, "Upgrader", "version.txt");
+export function witchyBndParamdexDir(exePath) {
+    return path.join(path.dirname(exePath), WITCHYBND_PARAMDEX_DIR);
+}
+export async function readWitchyBndParamdexVersion(exePath) {
+    try {
+        const text = await fs.readFile(path.join(path.dirname(exePath), WITCHYBND_PARAMDEX_VERSION_FILE), "utf8");
+        const line = text
+            .replace(/^/, "")
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .find((l) => l.length > 0);
+        return line;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/surfaces/eldenring/validators/binders.js

@@ -0,0 +1,193 @@
+import * as path from "node:path";
+import { walk } from "../../../core/fsutil.js";
+import { Bnd4HeaderError, isBareBinderName, looksLikeBinderUnpackDir, parseWitchySidecar, readBnd4Header, SIDECAR_RE, sidecarEntryPath } from "../binders.js";
+import { PACKAGE_SOURCE_KIND } from "./packages.js";
+const SIDECAR_EVIDENCE = ["eldenring.toolchain.witchybnd-xml-is-the-text-converter", "eldenring.toolchain.witchybnd-sidecar-shape"];
+const HEADER_EVIDENCE = ["eldenring.formats.bnd4-header-is-fully-published", "eldenring.formats.bnd4-header-byte-offsets"];
+const NAMED_EXTRAS = 5;
+const PLAIN_BINDER_TAGS = new Set(["bnd4", "bnd3", "bxf4", "bxf3"]);
+function isWithin(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!(rel === ".." || rel.startsWith(`..${path.sep}`)) && !path.isAbsolute(rel));
+}
+const packageSources = (project) => project.sources.filter((s) => s.exists && s.kind === PACKAGE_SOURCE_KIND);
+const sidecarPresent = {
+    id: "eldenring.binders.unpacked-in-package",
+    game: "eldenring",
+    groups: ["packaging"],
+    modTypes: ["packaging"],
+    summary: "A WitchyBND unpack folder inside a package is reported: the game reads the packed binder, not the folder, and a folder that has lost its _witchy-*.xml sidecar cannot be repacked at all.",
+    appliesTo: (target, project) => target.kind === "project" && packageSources(project).length > 0,
+    appliesToDescription: `the project, when it has a source of kind "${PACKAGE_SOURCE_KIND}"`,
+    needs: { project: true },
+    cost: "build",
+    severity: "warn",
+    evidence: SIDECAR_EVIDENCE,
+    async run(ctx) {
+        const findings = [];
+        for (const source of packageSources(ctx.project)) {
+            const { files, truncated } = await walk(source.absPath);
+            if (truncated)
+                findings.push({ validatorId: this.id, severity: "info", file: source.absPath, message: `Package "${source.id}" has more files than this scan's limit; the unpack-folder check may be incomplete.`, evidence: SIDECAR_EVIDENCE });
+            const dirsWithSidecar = new Set();
+            const dirs = new Set();
+            for (const rel of files) {
+                const parent = path.posix.dirname(rel);
+                for (let dir = parent; dir !== "." && !dirs.has(dir); dir = path.posix.dirname(dir))
+                    dirs.add(dir);
+                if (SIDECAR_RE.test(path.posix.basename(rel)))
+                    dirsWithSidecar.add(parent);
+            }
+            for (const rel of [...dirs].sort()) {
+                const name = path.posix.basename(rel);
+                const full = path.join(source.absPath, ...rel.split("/"));
+                if (dirsWithSidecar.has(rel)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: full,
+                        message: `${rel}/ in package "${source.id}" is a WitchyBND unpack folder (it holds a _witchy-*.xml sidecar); the game reads the packed binder at that path, so the folder as staged delivers nothing.`,
+                        fix: "Repack it (WitchyBND -r on the folder) and ship the packed file; keep the unpacked folder out of the package.",
+                        evidence: SIDECAR_EVIDENCE,
+                    });
+                }
+                else if (looksLikeBinderUnpackDir(name)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: full,
+                        message: `${rel}/ in package "${source.id}" is named like a WitchyBND unpack folder but holds no _witchy-*.xml sidecar; without the sidecar it cannot be repacked, and as a folder the game does not read it.`,
+                        fix: "Unpack the original binder again with WitchyBND to regenerate the sidecar, or rename the folder if it is not an unpacked binder.",
+                        evidence: SIDECAR_EVIDENCE,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+function isSidecarInPackage(target, project) {
+    if (target.kind !== "file" || !SIDECAR_RE.test(path.basename(target.path)))
+        return false;
+    return packageSources(project).some((s) => isWithin(s.absPath, target.path));
+}
+const sidecarEntries = {
+    id: "eldenring.binders.sidecar-entries",
+    game: "eldenring",
+    groups: ["packaging"],
+    modTypes: ["packaging"],
+    summary: "Every <file><path> a _witchy-*.xml sidecar names exists beside it (with WitchyBND's duplicate suffix applied), a bnd4 sidecar carries its <version>, and for a plain bnd/bxf sidecar the files it does not name are noted, since repack drops them.",
+    appliesTo: isSidecarInPackage,
+    appliesToDescription: `every _witchy-*.xml under a source of kind "${PACKAGE_SOURCE_KIND}"`,
+    needs: { project: true },
+    cost: "build",
+    severity: "block",
+    evidence: SIDECAR_EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const file = ctx.target.path;
+        const dir = path.dirname(file);
+        const name = path.basename(file);
+        let sidecar;
+        try {
+            sidecar = parseWitchySidecar(await ctx.readText(file));
+        }
+        catch (err) {
+            return [{ validatorId: this.id, severity: "block", file, message: `${name} could not be read as XML: ${err.message}`, evidence: SIDECAR_EVIDENCE }];
+        }
+        const findings = [];
+        const tag = SIDECAR_RE.exec(name)[1].toLowerCase();
+        if (sidecar.tag.toLowerCase() !== tag) {
+            findings.push({ validatorId: this.id, severity: "block", file, message: `${name} has root element <${sidecar.tag}>, but WitchyBND expects <${tag}> in a file of that name (it checks the root tag before repacking).`, evidence: SIDECAR_EVIDENCE });
+        }
+        if (PLAIN_BINDER_TAGS.has(tag) && sidecar.version === undefined) {
+            findings.push({ validatorId: this.id, severity: "block", file, message: `${name} has no <version> element; WitchyBND's repack reads it unconditionally and fails without it.`, fix: "Restore the sidecar from the original unpack; the version is the binder's own eight-character tag.", evidence: SIDECAR_EVIDENCE });
+        }
+        const named = new Set();
+        for (const entry of sidecar.files) {
+            const expected = sidecarEntryPath(dir, entry);
+            named.add(path.relative(dir, expected).replace(/\\/g, "/").toLowerCase());
+            if (!(await ctx.exists(expected))) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file,
+                    message: `${name} names ${entry.path}${entry.suffix ? ` (suffix "${entry.suffix}")` : ""}, and ${path.relative(dir, expected)} is not in the folder; WitchyBND's repack stops with "File not found" on it.`,
+                    fix: "Restore the file, or remove its <file> element from the sidecar if the entry was meant to go (the binder then loses that entry).",
+                    evidence: SIDECAR_EVIDENCE,
+                    related: [expected],
+                });
+            }
+        }
+        if (sidecar.hasFilesElement && PLAIN_BINDER_TAGS.has(tag)) {
+            const { files } = await walk(dir);
+            const extras = files.filter((rel) => {
+                const base = path.posix.basename(rel);
+                if (SIDECAR_RE.test(base))
+                    return false;
+                if (/\.bak$/i.test(base))
+                    return false;
+                if (rel.includes("/") && files.some((other) => other !== rel && SIDECAR_RE.test(path.posix.basename(other)) && rel.startsWith(path.posix.dirname(other) + "/")))
+                    return false;
+                return !named.has(rel.toLowerCase());
+            });
+            if (extras.length > 0) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "info",
+                    file,
+                    message: `${extras.length} file${extras.length === 1 ? "" : "s"} beside ${name} ${extras.length === 1 ? "is" : "are"} not named in it (${extras.slice(0, NAMED_EXTRAS).join(", ")}${extras.length > NAMED_EXTRAS ? ", ..." : ""}); repack packs only the sidecar's entries, so ${extras.length === 1 ? "it stays" : "they stay"} out of the binder.`,
+                    fix: "Add a <file> element for each file that belongs in the binder, or delete the strays.",
+                    evidence: SIDECAR_EVIDENCE,
+                });
+            }
+        }
+        return findings;
+    },
+};
+function isBareBinderInPackage(target, project) {
+    if (target.kind !== "file" || !isBareBinderName(target.path))
+        return false;
+    return packageSources(project).some((s) => isWithin(s.absPath, target.path));
+}
+const bnd4Header = {
+    id: "eldenring.binders.bnd4-header",
+    game: "eldenring",
+    groups: ["packaging"],
+    modTypes: ["packaging"],
+    summary: "A bare (un-DCX'd) binder file starts with the BND4 magic and the 0x40-byte header SoulsFormats asserts: header size 0x40, a known extended byte, a non-negative file count.",
+    appliesTo: isBareBinderInPackage,
+    appliesToDescription: `every .bnd or *bnd file (not .dcx) under a source of kind "${PACKAGE_SOURCE_KIND}"`,
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: HEADER_EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const file = ctx.target.path;
+        const name = path.basename(file);
+        try {
+            const h = await readBnd4Header(file);
+            if (h.fileCount === 0)
+                return [{ validatorId: this.id, severity: "warn", file, message: `${name} is a BND4 (version ${JSON.stringify(h.version)}) with no entries.`, evidence: HEADER_EVIDENCE }];
+            return [];
+        }
+        catch (err) {
+            const reason = err instanceof Bnd4HeaderError ? err.reason : "unreadable";
+            const bnd3 = reason === "bad-signature" && /"BND3"/.test(err.message);
+            return [
+                {
+                    validatorId: this.id,
+                    severity: "block",
+                    file,
+                    message: bnd3 ? `${name} is a BND3, the pre-Dark Souls II binder; Elden Ring's binders are BND4.` : `${name} has no readable BND4 header (${reason}): ${err.message}.`,
+                    fix: "Repack with WitchyBND from the unpacked folder; a file the game shipped as .dcx must keep its DCX wrapper, and this rule does not read through one.",
+                    evidence: HEADER_EVIDENCE,
+                },
+            ];
+        }
+    },
+};
+export const BINDER_VALIDATORS = [sidecarPresent, sidecarEntries, bnd4Header];

package/dist/surfaces/eldenring/validators/packages.js

@@ -0,0 +1,159 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { DcxHeaderError, readDcxHeader } from "../dcx.js";
+export const PACKAGE_SOURCE_KIND = "package";
+export const PACKAGE_DIRECTORY_VOCABULARY = new Set([
+    "action",
+    "asset",
+    "chr",
+    "cutscene",
+    "event",
+    "expression",
+    "facegen",
+    "font",
+    "map",
+    "material",
+    "menu",
+    "movie",
+    "msg",
+    "mtd",
+    "other",
+    "param",
+    "parts",
+    "script",
+    "sfx",
+    "shader",
+    "sound",
+]);
+export const PACKAGE_ROOT_FILES = new Set(["regulation.bin"]);
+const LAYOUT_EVIDENCE = ["eldenring.formats.the-unpacked-tree-is-a-fixed-directory-vocabulary", "eldenring.me3.package-mirrors-the-dvdbnd-hierarchy"];
+const DCX_EVIDENCE = [
+    "eldenring.formats.dcx-is-the-outer-compression-wrapper",
+    "eldenring.formats.dcx-header-byte-layout",
+    "eldenring.formats.zstd-dcx-arrived-with-the-dlc",
+];
+function isWithin(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!(rel === ".." || rel.startsWith(`..${path.sep}`)) && !path.isAbsolute(rel));
+}
+const layout = {
+    id: "eldenring.package.layout",
+    game: "eldenring",
+    groups: ["packaging"],
+    modTypes: ["packaging"],
+    summary: "A package's top-level entries are directories from the archives' vocabulary (chr, parts, map, msg, param, ...) or regulation.bin; anything else is served at no path the game asks for.",
+    appliesTo: (target, project) => target.kind === "project" && project.sources.some((s) => s.exists && s.kind === PACKAGE_SOURCE_KIND),
+    appliesToDescription: `the project, when it has a source of kind "${PACKAGE_SOURCE_KIND}"`,
+    needs: { project: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: LAYOUT_EVIDENCE,
+    async run(ctx) {
+        const findings = [];
+        for (const source of ctx.project.sources) {
+            if (!source.exists || source.kind !== PACKAGE_SOURCE_KIND)
+                continue;
+            const entries = await fs.readdir(source.absPath, { withFileTypes: true });
+            if (entries.length === 0) {
+                findings.push({ validatorId: this.id, severity: "info", file: source.absPath, message: `Package source "${source.id}" is empty.`, evidence: LAYOUT_EVIDENCE });
+                continue;
+            }
+            for (const entry of entries) {
+                const lower = entry.name.toLowerCase();
+                const full = path.join(source.absPath, entry.name);
+                if (entry.isDirectory()) {
+                    if (PACKAGE_DIRECTORY_VOCABULARY.has(lower))
+                        continue;
+                    const inner = await fs.readdir(full, { withFileTypes: true }).catch(() => []);
+                    const nested = inner.some((i) => (i.isDirectory() && PACKAGE_DIRECTORY_VOCABULARY.has(i.name.toLowerCase())) || (i.isFile() && PACKAGE_ROOT_FILES.has(i.name.toLowerCase())));
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: full,
+                        message: nested
+                            ? `${entry.name}/ in package "${source.id}" is not an archive directory, but it contains one (${inner.filter((i) => PACKAGE_DIRECTORY_VOCABULARY.has(i.name.toLowerCase()) || PACKAGE_ROOT_FILES.has(i.name.toLowerCase())).map((i) => i.name).join(", ")}): the mod is nested one level too deep and the loader serves none of it.`
+                            : `${entry.name}/ in package "${source.id}" is not a directory the game's archives use (${[...PACKAGE_DIRECTORY_VOCABULARY].join(", ")}); a loader serves a package file only at the path the archive uses, so everything under it is inert.`,
+                        fix: nested ? `Move the contents of ${entry.name}/ up into the package root.` : "Place files under the archive directory they override (regulation.bin at the root; parts/, chr/, msg/ ... as in the game), or drop the folder if it is documentation.",
+                        evidence: LAYOUT_EVIDENCE,
+                    });
+                }
+                else if (entry.isFile() && !PACKAGE_ROOT_FILES.has(lower)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: full,
+                        message: `${entry.name} sits at the root of package "${source.id}"; the archives keep only regulation.bin there, so the loader never serves it.`,
+                        fix: "Move it under the directory the game reads it from, or out of the package if it is a readme.",
+                        evidence: LAYOUT_EVIDENCE,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+function isDcxInPackage(target, project) {
+    if (target.kind !== "file" || path.extname(target.path).toLowerCase() !== ".dcx")
+        return false;
+    return project.sources.some((s) => s.exists && s.kind === PACKAGE_SOURCE_KIND && isWithin(s.absPath, target.path));
+}
+const codec = {
+    id: "eldenring.dcx.codec",
+    game: "eldenring",
+    groups: ["packaging"],
+    modTypes: ["packaging", "mesh", "texture"],
+    summary: "A .dcx carries a DCX header with a codec Elden Ring reads: KRAK (its own) or DFLT; ZSTD only on a DLC-era game; EDGE and the bare DCP shape belong to older games.",
+    appliesTo: isDcxInPackage,
+    appliesToDescription: `every .dcx under a project source of kind "${PACKAGE_SOURCE_KIND}"`,
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: DCX_EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const file = ctx.target.path;
+        const name = path.basename(file);
+        let header;
+        try {
+            header = await readDcxHeader(file);
+        }
+        catch (err) {
+            const reason = err instanceof DcxHeaderError ? err.reason : "unreadable";
+            return [
+                {
+                    validatorId: this.id,
+                    severity: "block",
+                    file,
+                    message: `${name} has no readable DCX header (${reason}): ${err.message}.`,
+                    fix: "Repack it with WitchyBND (-r), which writes the game's own KRAK wrapper; a file that was never compressed should not carry the .dcx extension.",
+                    evidence: DCX_EVIDENCE,
+                },
+            ];
+        }
+        if (header.magic === "DCP") {
+            return [{ validatorId: this.id, severity: "warn", file, message: `${name} uses the bare DCP shape (codec ${JSON.stringify(header.codec)}), which SoulsFormats lists for Demon's Souls test maps and ACE:R textures, not Elden Ring.`, fix: "Repack with WitchyBND for Elden Ring.", evidence: DCX_EVIDENCE }];
+        }
+        switch (header.codec) {
+            case "KRAK":
+            case "DFLT":
+                return [];
+            case "ZSTD":
+                return [
+                    {
+                        validatorId: this.id,
+                        severity: "info",
+                        file,
+                        message: `${name} is ZSTD-compressed (level ${header.level}); Elden Ring reads ZSTD since the DLC release, so a game older than that cannot open it.`,
+                        fix: "Fine on a current game. For a pre-DLC build, repack with WitchyBND as KRAK.",
+                        evidence: DCX_EVIDENCE,
+                    },
+                ];
+            case "EDGE":
+                return [{ validatorId: this.id, severity: "warn", file, message: `${name} is EDGE-compressed, the chunked-deflate codec SoulsFormats lists for Demon's Souls; Elden Ring's files are KRAK, DFLT or ZSTD.`, fix: "Repack with WitchyBND for Elden Ring.", evidence: DCX_EVIDENCE }];
+            default:
+                return [{ validatorId: this.id, severity: "block", file, message: `${name} names codec ${JSON.stringify(header.codec)} at offset 0x28; the known tags are DFLT, EDGE, KRAK and ZSTD.`, fix: "The file is damaged or not a DCX; repack it from the source with WitchyBND.", evidence: DCX_EVIDENCE }];
+        }
+    },
+};
+export const PACKAGE_VALIDATORS = [layout, codec];