modwright 0.1.0

package/dist/surfaces/skyrimse/surface.js

@@ -0,0 +1,240 @@
+import * as path from "node:path";
+import { documents, localAppData, pathExists, readTextIfExists } from "../../core/fsutil.js";
+import { readRegistryValue } from "../../core/registry.js";
+import { findInEpic } from "../../core/epic.js";
+import { findInSteam } from "../../core/steam.js";
+import { dedupeByRoot, logs, roots } from "../../core/surfaceutil.js";
+import { SIGNATURES } from "./logs.js";
+import { STOREFRONT_FOLDER, readLoadOrder, resolvePluginsTxt, storefrontOfSync, userDataDirs } from "./loadorder.js";
+import { pluginExtension, readPluginHeader } from "./plugins.js";
+import { PLUGIN_VALIDATORS } from "./validators/plugins.js";
+import { RECORD_VALIDATORS } from "./validators/records.js";
+import { ARCHIVE_RECORD_VALIDATORS } from "./validators/archive-records.js";
+import { ARCHIVE_VALIDATORS } from "./validators/archives.js";
+import { skyrimseCompat } from "./compat.js";
+export const SKYRIM_EPIC_APP_NAMES = ["ac82db5035584c7f8a2c548d98c86b2c", "5d600e4f59974aeba0259c7734134e27"];
+export const skyrimse = {
+    id: "skyrimse",
+    name: "Skyrim Special Edition",
+    aliases: ["skyrim", "skyrimspecialedition", "sse", "skse"],
+    summary: "Creation Engine. Plugins (.esp/.esm/.esl) and archives (.bsa) in Data/, " +
+        "with load order in Plugins.txt and native extensions via SKSE64.",
+    async detect() {
+        const installs = [];
+        const override = process.env.MODWRIGHT_SKYRIMSE_ROOT;
+        if (override && (await pathExists(override))) {
+            installs.push({ gameId: "skyrimse", root: override, source: "env" });
+        }
+        for (const root of await findInSteam(["Skyrim Special Edition"])) {
+            if (await pathExists(path.join(root, "SkyrimSE.exe"))) {
+                installs.push({ gameId: "skyrimse", root, source: "steam" });
+            }
+        }
+        for (const { keys, value, source } of REGISTRY_INSTALL_KEYS) {
+            const hit = await readRegistryValue(keys, value);
+            if (hit && (await pathExists(path.join(hit.value, "SkyrimSE.exe")))) {
+                installs.push({ gameId: "skyrimse", root: hit.value, source });
+            }
+        }
+        for (const root of await findInEpic(SKYRIM_EPIC_APP_NAMES)) {
+            if (await pathExists(path.join(root, "SkyrimSE.exe"))) {
+                installs.push({ gameId: "skyrimse", root, source: "epic" });
+            }
+        }
+        return dedupeByRoot(installs);
+    },
+    modRoots(install) {
+        const data = path.join(install.root, "Data");
+        return roots([
+            {
+                id: "plugins",
+                label: "Plugins",
+                path: data,
+                layout: "file",
+                extensions: [".esp", ".esm", ".esl"],
+                ordered: true,
+                conflictScope: "opaque",
+                notes: "Load order comes from Plugins.txt, not the filesystem. Whether a plugin is light " +
+                    "(ESL) is a header flag (0x200), which the .esl extension forces; light plugins " +
+                    "are active only when Plugins.txt marks them, load at their listed position, and " +
+                    "take their FormIDs from the FE index space, which costs one full slot collectively " +
+                    "(254 full plugins once any light one is active; 4096 light).",
+            },
+            {
+                id: "archives",
+                label: "BSA archives",
+                path: data,
+                layout: "file",
+                extensions: [".bsa"],
+                conflictScope: "opaque",
+                notes: "A .bsa loads if a plugin of the same base name is active, or if it is listed under " +
+                    "[Archive] in Skyrim.ini as SResourceArchiveList or SResourceArchiveList2 (the second " +
+                    "key holds the tail of a list longer than 255 characters). Skyrim SE archives are " +
+                    "version 105 (LZ4); a Legendary Edition version-104 archive is a different format.",
+            },
+            {
+                id: "skse",
+                label: "SKSE plugins",
+                path: path.join(data, "SKSE", "Plugins"),
+                layout: "file",
+                extensions: [".dll"],
+                conflictScope: "isolated",
+                notes: "Native SKSE64 plugins, version-locked to the game runtime unless built against the " +
+                    "Address Library, whose versionlib-<runtime>.bin files also live here and are data, " +
+                    "not plugins.",
+            },
+            {
+                id: "loosefiles",
+                label: "Loose files (meshes/textures/scripts)",
+                path: data,
+                layout: "flat",
+                conflictScope: "merged",
+                notes: "Loose files always beat .bsa content, regardless of plugin order. Plugins and " +
+                    "archives are the other roots' business, not loose-file conflicts.",
+            },
+        ]);
+    },
+    async readManifest(modPath, root) {
+        if (root.id !== "plugins" || pluginExtension(modPath) === undefined)
+            return undefined;
+        try {
+            const header = await readPluginHeader(modPath);
+            return {
+                format: "tes4-header",
+                ...(header.author ? { author: header.author } : {}),
+                ...(header.description ? { description: header.description } : {}),
+                dependencies: header.masters,
+                raw: {
+                    flags: header.flags,
+                    isMaster: header.isMaster,
+                    isLight: header.isLight,
+                    isLocalized: header.isLocalized,
+                    formVersion: header.formVersion,
+                    headerVersion: header.headerVersion,
+                    recordCount: header.recordCount,
+                    nextObjectId: header.nextObjectId,
+                    masters: header.masters,
+                },
+            };
+        }
+        catch {
+            return undefined;
+        }
+    },
+    async loadOrder(install) {
+        return (await readLoadOrder(install)).entries;
+    },
+    loadOrderFile(install) {
+        return localAppData(STOREFRONT_FOLDER[storefrontOfSync(install)], "Plugins.txt");
+    },
+    logs(_install) {
+        const folders = Object.values(STOREFRONT_FOLDER);
+        const myGames = (folder, ...segments) => documents("My Games", folder, ...segments);
+        return logs([
+            {
+                id: "skse-loader",
+                label: "SKSE64 loader log",
+                candidates: folders.map((f) => myGames(f, "SKSE", "skse64_loader.log")),
+                rootId: "skse",
+                notes: "Written by skse64_loader.exe, so it exists even when the game fails to start. " +
+                    "Names the SKSE build and the runtime it launched. No timestamps, no level prefixes.",
+            },
+            {
+                id: "skse",
+                label: "SKSE64 plugin log",
+                candidates: folders.map((f) => myGames(f, "SKSE", "skse64.log")),
+                rootId: "skse",
+                notes: "The plugin roll-call: one 'plugin <dll> (...) loaded correctly (handle n)' per " +
+                    "plugin, or the reason it was disabled. No timestamps, no level prefixes.",
+            },
+            {
+                id: "papyrus",
+                label: "Papyrus script log",
+                candidates: folders.map((f) => myGames(f, "Logs", "Script", "Papyrus.0.log")),
+                notes: "Only written when [Papyrus] bEnableLogging=1 in Skyrim.ini. Papyrus.0 is the " +
+                    "newest of four; a new session replaces it. Noisy by design, and most lines " +
+                    "describe some mod's scripts, not the engine.",
+            },
+            {
+                id: "crash",
+                label: "Crash log (CrashLoggerSSE or Trainwreck)",
+                candidates: folders.map((f) => myGames(f, "SKSE", "crash-*.log")),
+                rootId: "skse",
+                notes: "CrashLoggerSSE writes crash-<timestamp>.log here by default; Trainwreck's directory " +
+                    "is configurable. The plugin-section header (SKSE PLUGINS: vs SCRIPT EXTENDER " +
+                    "PLUGINS:) tells the two formats apart.",
+            },
+        ]);
+    },
+    async explainMissing(install) {
+        const reasons = {};
+        const dirs = await userDataDirs(install);
+        const ini = await readTextIfExists(path.join(dirs.myGames, "Skyrim.ini"));
+        if (ini === undefined) {
+            reasons.papyrus = `${path.join(dirs.myGames, "Skyrim.ini")} was not found, so whether [Papyrus] bEnableLogging is on cannot be read; the game writes Skyrim.ini on first launch.`;
+        }
+        else {
+            const enabled = papyrusLoggingEnabled(ini);
+            if (enabled === false || enabled === undefined) {
+                reasons.papyrus =
+                    `[Papyrus] bEnableLogging is ${enabled === undefined ? "not set (default 0)" : "0"} in ${path.join(dirs.myGames, "Skyrim.ini")}, ` +
+                        "so the game never writes Papyrus.0.log; set it to 1 to get one.";
+            }
+        }
+        const loaderLog = path.join(dirs.myGames, "SKSE", "skse64_loader.log");
+        const pluginLog = path.join(dirs.myGames, "SKSE", "skse64.log");
+        if ((await pathExists(loaderLog)) && !(await pathExists(pluginLog))) {
+            reasons.skse = `${loaderLog} exists but ${pluginLog} does not: the loader ran, the game did not reach plugin loading, or the game was launched without skse64_loader.exe.`;
+        }
+        else if (!(await pathExists(loaderLog))) {
+            reasons["skse-loader"] = `${loaderLog} was not found: SKSE64 has not been run for this install (launch through skse64_loader.exe), or the install is a different storefront's (${dirs.storefront} was assumed).`;
+            reasons.skse = reasons["skse-loader"];
+        }
+        reasons.crash = "A crash log exists only after a crash, and only with CrashLoggerSSE or Trainwreck installed.";
+        return reasons;
+    },
+    logSignatures: SIGNATURES,
+    validators: [...PLUGIN_VALIDATORS, ...RECORD_VALIDATORS, ...ARCHIVE_VALIDATORS, ...ARCHIVE_RECORD_VALIDATORS],
+    compat: skyrimseCompat,
+    processNames: ["SkyrimSE.exe"],
+    guidance: "Plugin order is authoritative and file-level conflict detection under Data/ will be " +
+        "noisy — most real conflicts here are record-level between plugins, which needs xEdit " +
+        "rather than a directory diff. Treat ModWright's Data/ conflicts as a hint about loose " +
+        "files, and read the load order for anything about ordering. Only Steam installs and " +
+        "MODWRIGHT_SKYRIMSE_ROOT are auto-detected, plus the game's own and GOG's registry keys; " +
+        "Epic and Microsoft Store installs are not found without the override, and the user-data " +
+        "folders differ per storefront (Skyrim Special Edition GOG / EPIC / MS under LocalAppData " +
+        "and My Games). Under Mod Organizer 2 the load " +
+        "order read is the active profile's plugins.txt, not the LocalAppData copy the game sees " +
+        "only inside MO2. None of this has yet been checked against a running game.",
+};
+const REGISTRY_INSTALL_KEYS = [
+    {
+        keys: ["HKLM\\SOFTWARE\\Bethesda Softworks\\Skyrim Special Edition", "HKLM\\SOFTWARE\\WOW6432Node\\Bethesda Softworks\\Skyrim Special Edition"],
+        value: "Installed Path",
+        source: "config",
+    },
+    {
+        keys: ["HKLM\\SOFTWARE\\GOG.com\\Games\\1162721350", "HKLM\\SOFTWARE\\WOW6432Node\\GOG.com\\Games\\1162721350", "HKLM\\SOFTWARE\\GOG.com\\Games\\1711230643", "HKLM\\SOFTWARE\\WOW6432Node\\GOG.com\\Games\\1711230643"],
+        value: "path",
+        source: "gog",
+    },
+];
+export function papyrusLoggingEnabled(iniText) {
+    let section = "";
+    for (const raw of iniText.split(/\r?\n/)) {
+        const line = raw.trim();
+        const sec = /^\[(.+)\]$/.exec(line);
+        if (sec) {
+            section = sec[1].trim().toLowerCase();
+            continue;
+        }
+        if (section !== "papyrus")
+            continue;
+        const m = /^benablelogging\s*=\s*(\d+)/i.exec(line);
+        if (m)
+            return m[1] !== "0";
+    }
+    return undefined;
+}
+export { resolvePluginsTxt };

package/dist/surfaces/skyrimse/validators/archive-records.js

@@ -0,0 +1,165 @@
+import * as path from "node:path";
+import { BsaHeaderError, readBsaTable, tesHash } from "../archives.js";
+const EVIDENCE = [
+    "sse.archives.bsa.folder-record-is-24-bytes-in-v105",
+    "sse.archives.bsa.file-record-blocks-and-name-block",
+    "sse.archives.bsa.name-hash-algorithm",
+];
+const APPLIES = "every .bsa file under a project source";
+const MAX_PER_FILE = 20;
+function isWithin(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!(rel === ".." || rel.startsWith(`..${path.sep}`)) && !path.isAbsolute(rel));
+}
+function isBsaUnderSource(target, project) {
+    if (target.kind !== "file" || path.extname(target.path).toLowerCase() !== ".bsa")
+        return false;
+    return project.sources.some((s) => s.exists && isWithin(s.absPath, target.path));
+}
+async function tableOrFinding(id, file) {
+    try {
+        return await readBsaTable(file);
+    }
+    catch (err) {
+        const reason = err instanceof BsaHeaderError ? err.reason : "unreadable";
+        return {
+            validatorId: id,
+            severity: "block",
+            file,
+            message: `${path.basename(file)}'s folder and file tables cannot be read (${reason}): ${err.message}`,
+            fix: "Repack the archive with BSArch or the Creation Kit's archive tool.",
+            evidence: EVIDENCE,
+        };
+    }
+}
+const isFinding = (v) => v.validatorId !== undefined;
+function cap(findings, id, file) {
+    if (findings.length <= MAX_PER_FILE)
+        return findings;
+    return [...findings.slice(0, MAX_PER_FILE), { validatorId: id, severity: "info", file, message: `${findings.length - MAX_PER_FILE} more finding(s) of this kind in the archive not listed.`, evidence: EVIDENCE }];
+}
+const hex = (h) => `0x${h.toString(16).padStart(16, "0")}`;
+const archiveRecords = {
+    id: "sse.archives.records",
+    game: "skyrimse",
+    groups: ["plugins"],
+    modTypes: ["packaging"],
+    summary: "A .bsa's folder records, file record blocks and file name block are consistent with its header (counts, name-block lengths, block offsets) and every file's data lies inside the archive.",
+    appliesTo: isBsaUnderSource,
+    appliesToDescription: APPLIES,
+    needs: { project: true },
+    cost: "build",
+    severity: "block",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const read = await tableOrFinding(this.id, ctx.target.path);
+        if (isFinding(read))
+            return [read];
+        const file = ctx.target.path;
+        const name = path.basename(file);
+        const findings = read.table.problems.map((p) => ({ validatorId: this.id, severity: "block", file, message: `${name}: ${p}`, fix: "Repack the archive; a table the game cannot walk loads nothing from it.", evidence: EVIDENCE }));
+        for (const f of read.table.files) {
+            const end = f.offset + f.size;
+            if (f.offset < read.table.tableLength || end > read.fileSize) {
+                const label = f.name !== undefined ? `"${f.name}"` : `file record ${f.index}`;
+                findings.push({ validatorId: this.id, severity: "block", file, message: `${name}: ${label} in folder ${read.table.folders[f.folder]?.name ?? f.folder} has its data at bytes ${f.offset} to ${end}, ${f.offset < read.table.tableLength ? "inside the tables" : `past the end of the ${read.fileSize}-byte archive`}.`, fix: "Repack the archive; the record cannot be read.", evidence: EVIDENCE });
+            }
+        }
+        return cap(findings, this.id, file);
+    },
+};
+const archiveHashOrder = {
+    id: "sse.archives.hash-order",
+    game: "skyrimse",
+    groups: ["plugins"],
+    modTypes: ["packaging"],
+    summary: "A .bsa's folder records, and the file records within each folder, are sorted by their 64-bit hash (UESP: 'Files and Dirs order'), and no two neighbours carry the same hash.",
+    appliesTo: isBsaUnderSource,
+    appliesToDescription: APPLIES,
+    needs: { project: true },
+    cost: "build",
+    severity: "warn",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const read = await tableOrFinding(this.id, ctx.target.path);
+        if (isFinding(read))
+            return [];
+        const file = ctx.target.path;
+        const name = path.basename(file);
+        const findings = [];
+        const { folders, files } = read.table;
+        for (let i = 1; i < folders.length; i++) {
+            const a = folders[i - 1];
+            const b = folders[i];
+            if (b.hash > a.hash)
+                continue;
+            const at = `folder record ${i} (${b.name ?? hex(b.hash)})`;
+            const before = `record ${i - 1} (${a.name ?? hex(a.hash)})`;
+            findings.push({ validatorId: this.id, severity: "warn", file, message: b.hash === a.hash ? `${name}: ${at} and ${before} carry the same hash ${hex(b.hash)}; folders are found by hash, so one of the two cannot be reached.` : `${name}: ${at} is not after ${before} in hash order; UESP says folders must be sorted by hash, and a lookup that assumes the order can miss the folder.`, fix: "Repack with BSArch or the Creation Kit, which write the records in hash order.", evidence: EVIDENCE });
+        }
+        for (let i = 1; i < files.length; i++) {
+            const a = files[i - 1];
+            const b = files[i];
+            if (a.folder !== b.folder)
+                continue;
+            if (b.hash > a.hash)
+                continue;
+            const where = `within folder ${folders[b.folder]?.name ?? b.folder}`;
+            const at = `file record ${b.index} (${b.name ?? hex(b.hash)})`;
+            const before = `record ${a.index} (${a.name ?? hex(a.hash)})`;
+            findings.push({ validatorId: this.id, severity: "warn", file, message: b.hash === a.hash ? `${name}: ${at} and ${before} carry the same hash ${hex(b.hash)} ${where}; files are found by hash, so one of the two cannot be reached.` : `${name}: ${at} is not after ${before} in hash order ${where}; UESP says files must be sorted by hash.`, fix: "Repack with BSArch or the Creation Kit.", evidence: EVIDENCE });
+        }
+        return cap(findings, this.id, file);
+    },
+};
+const archiveHashesMatch = {
+    id: "sse.archives.hashes-match-names",
+    game: "skyrimse",
+    groups: ["plugins"],
+    modTypes: ["packaging"],
+    summary: "Every folder and file record's hash is the Tes4/Tes5 hash of the name the archive carries for it (lower case, backslashes, the extension hashed separately); a record whose hash is not its name's cannot be found by name.",
+    appliesTo: isBsaUnderSource,
+    appliesToDescription: APPLIES,
+    needs: { project: true },
+    cost: "build",
+    severity: "block",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const read = await tableOrFinding(this.id, ctx.target.path);
+        if (isFinding(read))
+            return [];
+        const file = ctx.target.path;
+        const name = path.basename(file);
+        const { header, folders, files } = read.table;
+        if (!header.includesDirectoryNames && !header.includesFileNames) {
+            return [{ validatorId: this.id, severity: "info", file, message: `${name} carries no folder or file names (flags 0x1 and 0x2 unset), so its hashes cannot be checked against names; sse.archives.name-flags reports the flags themselves.`, evidence: EVIDENCE }];
+        }
+        const findings = [];
+        if (header.includesDirectoryNames) {
+            for (const folder of folders) {
+                if (folder.name === undefined)
+                    continue;
+                const expected = tesHash(folder.name, "folder");
+                if (expected !== folder.hash)
+                    findings.push({ validatorId: this.id, severity: "block", file, message: `${name}: folder "${folder.name}" is recorded with hash ${hex(folder.hash)}, but its name hashes to ${hex(expected)}; the game looks folders up by hash, so nothing in it can be found by name.`, fix: "Repack the archive; a tool that wrote the hash from a differently-cased or slash-separated name produces this.", evidence: EVIDENCE });
+            }
+        }
+        if (header.includesFileNames) {
+            for (const f of files) {
+                if (f.name === undefined)
+                    continue;
+                const expected = tesHash(f.name, "file");
+                if (expected !== f.hash)
+                    findings.push({ validatorId: this.id, severity: "block", file, message: `${name}: file "${f.name}" in folder ${folders[f.folder]?.name ?? f.folder} is recorded with hash ${hex(f.hash)}, but its name hashes to ${hex(expected)}; the game looks files up by hash, so it cannot be found by name.`, fix: "Repack the archive.", evidence: EVIDENCE });
+            }
+        }
+        return cap(findings, this.id, file);
+    },
+};
+export const ARCHIVE_RECORD_VALIDATORS = [archiveRecords, archiveHashOrder, archiveHashesMatch];

package/dist/surfaces/skyrimse/validators/archives.js

@@ -0,0 +1,110 @@
+import * as path from "node:path";
+import { BSA_VERSION_OBLIVION, BSA_VERSION_SKYRIM_LE, BSA_VERSION_SKYRIM_SE, BsaHeaderError, readBsaHeader } from "../archives.js";
+const EVIDENCE = ["ModWright research"];
+const APPLIES = "every .bsa file 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 isBsaUnderSource(target, project) {
+    if (target.kind !== "file" || path.extname(target.path).toLowerCase() !== ".bsa")
+        return false;
+    return project.sources.some((s) => s.exists && isWithin(s.absPath, target.path));
+}
+async function headerOrFinding(id, file) {
+    try {
+        return await readBsaHeader(file);
+    }
+    catch (err) {
+        const reason = err instanceof BsaHeaderError ? err.reason : "unreadable";
+        return {
+            validatorId: id,
+            severity: "block",
+            file,
+            message: `${path.basename(file)} has no readable BSA header (${reason}): ${err.message}`,
+            fix: "Repack the archive with BSArch or the Creation Kit's archive tool.",
+            evidence: EVIDENCE,
+        };
+    }
+}
+const isFinding = (v) => v.validatorId !== undefined;
+const archiveVersion = {
+    id: "sse.archives.version",
+    game: "skyrimse",
+    groups: ["plugins"],
+    modTypes: ["packaging"],
+    summary: "A .bsa carries version 105, the Skyrim SE format (LZ4, 24-byte folder records); 104 is Skyrim LE's and 103 Oblivion's.",
+    appliesTo: isBsaUnderSource,
+    appliesToDescription: APPLIES,
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const header = await headerOrFinding(this.id, ctx.target.path);
+        if (isFinding(header))
+            return [header];
+        if (header.version === BSA_VERSION_SKYRIM_SE)
+            return [];
+        const name = path.basename(ctx.target.path);
+        const known = header.version === BSA_VERSION_SKYRIM_LE ? "Skyrim Legendary Edition's (104, zlib, 16-byte folder records)" : header.version === BSA_VERSION_OBLIVION ? "Oblivion's (103)" : undefined;
+        return [
+            {
+                validatorId: this.id,
+                severity: "block",
+                file: ctx.target.path,
+                message: known
+                    ? `${name} is a version ${header.version} archive, ${known}; Skyrim SE reads version 105.`
+                    : `${name} has BSA version ${header.version}; Skyrim SE reads version 105.`,
+                fix: "Extract and repack the archive for Skyrim SE (BSArch with the SSE format, or the Creation Kit).",
+                evidence: EVIDENCE,
+            },
+        ];
+    },
+};
+const archiveNameFlags = {
+    id: "sse.archives.name-flags",
+    game: "skyrimse",
+    groups: ["plugins"],
+    modTypes: ["packaging"],
+    summary: "A .bsa sets both Include Directory Names (0x1) and Include File Names (0x2); every official archive does, and the game may not load one without them.",
+    appliesTo: isBsaUnderSource,
+    appliesToDescription: APPLIES,
+    needs: { project: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: EVIDENCE,
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const header = await headerOrFinding(this.id, ctx.target.path);
+        if (isFinding(header))
+            return [header];
+        const missing = [...(header.includesDirectoryNames ? [] : ["Include Directory Names (0x1)"]), ...(header.includesFileNames ? [] : ["Include File Names (0x2)"])];
+        const findings = [];
+        if (missing.length > 0) {
+            findings.push({
+                validatorId: this.id,
+                severity: "warn",
+                file: ctx.target.path,
+                message: `${path.basename(ctx.target.path)} lacks ${missing.join(" and ")} in its archive flags; UESP notes the game may not load a BSA without them, and every official archive sets both.`,
+                fix: "Repack with names included (BSArch's default).",
+                evidence: EVIDENCE,
+            });
+        }
+        if (header.xbox360) {
+            findings.push({
+                validatorId: this.id,
+                severity: "warn",
+                file: ctx.target.path,
+                message: `${path.basename(ctx.target.path)} has the Xbox 360 flag (0x40): big-endian numbers and hashes, which the PC game does not read.`,
+                fix: "Repack for PC.",
+                evidence: EVIDENCE,
+            });
+        }
+        return findings;
+    },
+};
+export const ARCHIVE_VALIDATORS = [archiveVersion, archiveNameFlags];