modwright 0.1.0

package/dist/surfaces/baldursgate3/validators/files.js

@@ -0,0 +1,476 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { walk } from "../../../core/fsutil.js";
+import { globToRegExp } from "../../../core/validate/context.js";
+import { scanLooseIdentities, scanPaksIdentities } from "../identity.js";
+import { parseLsx, walkLsxNodes } from "../index/parsers/lsx.js";
+function posix(p) {
+    return p.split(path.sep).join("/");
+}
+function lower(p) {
+    return posix(p).toLowerCase();
+}
+export function ddsAssetStem(absPath) {
+    const p = absPath.replace(/\\/g, "/");
+    return path.posix.basename(p, path.posix.extname(p));
+}
+function fileTarget(match) {
+    return (target) => target.kind === "file" && match(lower(target.path));
+}
+function projectTarget(extra) {
+    return (target, project) => target.kind === "project" && (!extra || extra(project));
+}
+function finding(validatorId, severity, file, message, evidence, extra) {
+    return { validatorId, severity, file, message, evidence, ...extra };
+}
+async function projectFiles(project, match) {
+    const out = [];
+    for (const src of project.sources) {
+        if (!src.exists)
+            continue;
+        const { files } = await walk(src.absPath, { limit: 20000 });
+        for (const f of files) {
+            const abs = path.join(src.absPath, f);
+            if (match(lower(abs)))
+                out.push(abs);
+        }
+    }
+    return out;
+}
+function hasScriptExtenderDependency(project) {
+    return (project.project.dependencies ?? []).some((d) => /script.?extender/i.test(d.id) || /script.?extender/i.test(d.notes ?? ""));
+}
+const BOM_EXTENSIONS = [".txt", ".lsx", ".xml"];
+const noBom = {
+    id: "bg3.history.no-bom",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["dialogue"],
+    summary: "No UTF-8 BOM in .txt/.lsx/.xml files the game parses — PowerShell's default utf8 encoding silently corrupts them.",
+    appliesTo: fileTarget((p) => BOM_EXTENSIONS.includes(path.posix.extname(p)) && path.posix.basename(p) !== "meta.lsx"),
+    appliesToDescription: "every .txt/.lsx/.xml file in the project, except meta.lsx (Larian's own Toolkit writes that one with a BOM, and it loads fine)",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.encoding.utf8-bom-corruption"],
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const text = await ctx.readText(ctx.target.path);
+        if (text.charCodeAt(0) !== 0xfeff)
+            return [];
+        return [
+            finding(noBom.id, "block", ctx.target.path, `This file begins with a UTF-8 BOM. PowerShell's default 'utf8' encoding writes one; the game's parser for this file type does not tolerate it and the corruption is silent.`, noBom.evidence, { fix: "Re-save without a BOM (Python, or PowerShell's 'utf8NoBOM' / 'ASCII' encodings)." }),
+        ];
+    },
+};
+const iconuvRegionPlacement = {
+    id: "bg3.history.iconuv-region-placement",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["icon"],
+    summary: "IconUV entries sit in a sibling IconUVList region, not nested inside TextureAtlasInfo — nesting yields the blue fallback icon.",
+    appliesTo: fileTarget((p) => p.endsWith(".lsx")),
+    appliesToDescription: "every .lsx file, checked for an atlas descriptor's TextureAtlasInfo/IconUVList region shape",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.icons.iconuv-region-nesting-gotcha", "bg3.ui.icons-atlas.uv-coordinates-are-normalized-fractions-not-pixels"],
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const text = await ctx.readText(ctx.target.path);
+        let doc;
+        try {
+            doc = parseLsx(text, ctx.target.path);
+        }
+        catch {
+            return [];
+        }
+        const atlasInfo = doc.regions.find((r) => r.id === "TextureAtlasInfo");
+        if (!atlasInfo)
+            return [];
+        let nestedCount = 0;
+        walkLsxNodes(atlasInfo.root, (node) => {
+            if (node.id === "IconUV")
+                nestedCount++;
+        });
+        if (nestedCount === 0)
+            return [];
+        return [
+            finding(iconuvRegionPlacement.id, "block", ctx.target.path, `${nestedCount} IconUV node(s) are nested inside the TextureAtlasInfo region. IconUV must be a sibling region (IconUVList), not nested here — nesting produces the generic blue missing-icon fallback in-game.`, iconuvRegionPlacement.evidence, { fix: "Move the IconUV nodes into their own IconUVList region, as a sibling of TextureAtlasInfo." }),
+        ];
+    },
+};
+const guiMetadataPresent = {
+    id: "bg3.history.gui-metadata-present",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["icon"],
+    summary: "Hand-authored GUI DDS assets under Mods/<Mod>/GUI/Assets/** are registered in GUI/metadata.lsf.",
+    appliesTo: projectTarget(),
+    appliesToDescription: "the whole project: every DDS under a GUI/Assets/ tree (excluding AssetsLowRes/) against a GUI/metadata.lsx twin",
+    needs: { project: true, toolchain: ["divine"] },
+    cost: "build",
+    severity: "block",
+    evidence: ["bg3.icons.class-icon-metadata", "bg3.icons.tooltip-asset-system"],
+    async run(ctx) {
+        if (ctx.target.kind !== "project")
+            return [];
+        const ddsFiles = await projectFiles(ctx.project, (p) => p.includes("/gui/assets/") && !p.includes("/assetslowres/") && p.endsWith(".dds"));
+        if (ddsFiles.length === 0)
+            return [];
+        const metadataFiles = await projectFiles(ctx.project, (p) => path.posix.basename(p) === "metadata.lsx");
+        if (metadataFiles.length === 0) {
+            return [
+                finding(guiMetadataPresent.id, "info", ctx.project.root, `${ddsFiles.length} hand-authored GUI DDS asset(s) under GUI/Assets/ found, but no GUI/metadata.lsx (the divine-converted intermediate of metadata.lsf) exists to check registration against. ` +
+                    `ValidationContext has no toolchain-invocation hook, so this could not be verified — convert GUI/metadata.lsf to .lsx and re-run.`, ["bg3.toolchain.divine-core-tool"]),
+            ];
+        }
+        const findings = [];
+        for (const metaFile of metadataFiles) {
+            let metaText;
+            try {
+                metaText = await ctx.readText(metaFile);
+            }
+            catch {
+                continue;
+            }
+            for (const dds of ddsFiles) {
+                const stem = ddsAssetStem(dds);
+                const escapedStem = stem.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const needle = new RegExp(`["/]${escapedStem}\\.png"`, "i");
+                if (!needle.test(metaText)) {
+                    findings.push(finding(guiMetadataPresent.id, "block", dds, `No GUI/metadata.lsf entry registers '${stem}.png' for this DDS asset. Without it the game shows "Missing MetaData" and the icon is blank.`, guiMetadataPresent.evidence, { related: [metaFile] }));
+                }
+            }
+        }
+        return findings;
+    },
+};
+const locaNoXmlComments = {
+    id: "bg3.history.loca-no-xml-comments",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["dialogue"],
+    summary: "No <!-- --> comments in a Localization .xml — the loca parser CTDs the game whenever the owning module is ACTIVE.",
+    appliesTo: fileTarget((p) => p.endsWith(".xml") && p.includes("/localization/")),
+    appliesToDescription: "every Localization/**/*.xml file",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.crash.xml-comments-loca-parse"],
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const text = await ctx.readText(ctx.target.path);
+        const idx = text.indexOf("<!--");
+        if (idx === -1)
+            return [];
+        const line = text.slice(0, idx).split("\n").length;
+        return [
+            finding(locaNoXmlComments.id, "block", ctx.target.path, `This Localization XML contains an XML comment (<!-- -->). The loca parser crashes to desktop whenever the owning module is ACTIVE — module-inactive testing will not catch this.`, locaNoXmlComments.evidence, { line, fix: "Remove the comment; it never loads in-game anyway." }),
+        ];
+    },
+};
+const seConfigShape = {
+    id: "bg3.history.se-config-shape",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["dialogue"],
+    summary: "Mods/<Mod>/ScriptExtender/Config.json exists with a capital C and RequiredVersion, not the DOS2-era RequiredExtensionVersion.",
+    appliesTo: (target, project) => target.kind === "file" && lower(target.path).endsWith("/scriptextender/config.json") && hasScriptExtenderDependency(project),
+    appliesToDescription: "Mods/<Mod>/ScriptExtender/Config.json (any casing), only when the project declares a Script Extender dependency",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.se.config-required"],
+    async run(ctx) {
+        if (ctx.target.kind !== "file")
+            return [];
+        const findings = [];
+        const basename = path.basename(ctx.target.path);
+        if (basename !== "Config.json") {
+            findings.push(finding(seConfigShape.id, "block", ctx.target.path, `The Script Extender config file is named '${basename}'; it must be exactly 'Config.json' (capital C). Pak-internal paths are case-sensitive — a lowercase 'config.json' is tolerated loose but silently fails once packed.`, seConfigShape.evidence, { fix: "Rename the file to Config.json." }));
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(await ctx.readText(ctx.target.path));
+        }
+        catch {
+            return findings;
+        }
+        if (Object.prototype.hasOwnProperty.call(parsed, "RequiredExtensionVersion")) {
+            findings.push(finding(seConfigShape.id, "block", ctx.target.path, `Config.json uses the DOS2-era 'RequiredExtensionVersion' key. BG3's Script Extender expects 'RequiredVersion' instead.`, seConfigShape.evidence, { fix: 'Rename the key to "RequiredVersion".' }));
+        }
+        else if (!Object.prototype.hasOwnProperty.call(parsed, "RequiredVersion")) {
+            findings.push(finding(seConfigShape.id, "block", ctx.target.path, `Config.json has no 'RequiredVersion' key.`, seConfigShape.evidence, { fix: 'Add "RequiredVersion": <SE major version>.' }));
+        }
+        const modTable = parsed.ModTable;
+        const folder = ctx.project.project.identity?.folder;
+        if (typeof modTable === "string" && folder && modTable !== folder) {
+            findings.push(finding(seConfigShape.id, "warn", ctx.target.path, `Config.json's ModTable is '${modTable}', which does not match the module folder '${folder}'.`, seConfigShape.evidence));
+        }
+        return findings;
+    },
+};
+const staleSameUuidPak = {
+    id: "bg3.history.stale-same-uuid-pak",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["packaging"],
+    summary: "A pak for this project in the profile Mods/ folder is older than the project's own sources — it will silently win and shadow your loose edits.",
+    appliesTo: projectTarget(),
+    appliesToDescription: "the whole project, when an install is located (skipped otherwise) — compares the profile Mods/<Mod>.pak's mtime against the project's own source files",
+    needs: { project: true, install: true },
+    cost: "build",
+    severity: "block",
+    evidence: ["bg3.paks.same-uuid-precedence"],
+    async run(ctx) {
+        if (ctx.target.kind !== "project" || !ctx.install)
+            return [];
+        const paksRoot = ctx.surface.modRoots(ctx.install).find((r) => r.id === "paks");
+        if (!paksRoot)
+            return [];
+        const identityUuid = ctx.project.project.identity?.uuid;
+        const identityFolder = ctx.project.project.identity?.folder;
+        let pakPath;
+        let pakLabel;
+        let pakMtime;
+        if (identityUuid) {
+            const { copies } = await scanPaksIdentities(paksRoot.path);
+            const own = copies.find((c) => c.uuid?.toLowerCase() === identityUuid.toLowerCase() && (!identityFolder || c.folder === identityFolder));
+            if (!own)
+                return [];
+            pakPath = own.path;
+            pakLabel = path.basename(own.path);
+            pakMtime = new Date(own.modifiedAt);
+        }
+        else {
+            const deployTarget = ctx.project.project.deploy?.targets.find((t) => t.rootId === "paks");
+            const expectedName = deployTarget ? path.basename(deployTarget.from) : identityFolder ? `${identityFolder}.pak` : undefined;
+            if (!expectedName)
+                return [];
+            let entries;
+            try {
+                entries = await fs.readdir(paksRoot.path);
+            }
+            catch {
+                return [];
+            }
+            const match = entries.find((e) => e.toLowerCase() === expectedName.toLowerCase());
+            if (!match)
+                return [];
+            pakPath = path.join(paksRoot.path, match);
+            pakLabel = match;
+            try {
+                pakMtime = (await fs.stat(pakPath)).mtime;
+            }
+            catch {
+                return [];
+            }
+        }
+        let newestSource = new Date(0);
+        for (const src of ctx.project.sources) {
+            if (!src.exists)
+                continue;
+            const result = await walk(src.absPath, { limit: 20000 });
+            if (result.modifiedAt > newestSource)
+                newestSource = result.modifiedAt;
+        }
+        if (newestSource <= pakMtime)
+            return [];
+        return [
+            finding(staleSameUuidPak.id, "block", pakPath, `${pakLabel} in the profile Mods/ folder (modified ${pakMtime.toISOString()}) is older than this project's own sources (newest change ${newestSource.toISOString()}). ` +
+                `A packed mod of the same identity wins over a loose/junctioned copy — this pak will silently override your newer edits. Rebuild and redeploy the pak.`, staleSameUuidPak.evidence, { related: [ctx.project.root] }),
+        ];
+    },
+};
+const duplicateModuleUuid = {
+    id: "bg3.history.duplicate-module-uuid",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["packaging"],
+    summary: "No other installed pak or loose module carries this project's own module UUID under a different path — which copy the game loads is not predictable from outside, so content built into one copy can stop loading with no error.",
+    appliesTo: projectTarget((project) => Boolean(project.project.identity?.uuid)),
+    appliesToDescription: "the whole project, only when it declares identity.uuid and an install is located — scans every .pak in the profile Mods/ folder and every loose Data/Mods/*/meta.lsx for a copy of the same UUID whose module folder is not this project's own identity.folder (and, when the project declares no identity.folder to tell its own copy apart, only reports when two or more copies share the UUID)",
+    needs: { project: true, install: true },
+    cost: "build",
+    severity: "block",
+    evidence: ["bg3.paks.same-uuid-precedence", "observed in game (2026-09-10): the copy the Folder attribute named did not load"],
+    async run(ctx) {
+        if (ctx.target.kind !== "project" || !ctx.install)
+            return [];
+        const uuid = ctx.project.project.identity?.uuid;
+        if (!uuid)
+            return [];
+        const ownFolder = ctx.project.project.identity?.folder;
+        const target = uuid.toLowerCase();
+        const roots = ctx.surface.modRoots(ctx.install);
+        const paksRoot = roots.find((r) => r.id === "paks");
+        if (!paksRoot)
+            return [];
+        const looseRoot = roots.find((r) => r.id === "loose");
+        const { copies: pakCopies } = await scanPaksIdentities(paksRoot.path);
+        const looseCopies = looseRoot ? (await scanLooseIdentities(looseRoot.path)).copies : [];
+        const sameUuid = [...pakCopies, ...looseCopies].filter((copy) => copy.uuid?.toLowerCase() === target);
+        if (!ownFolder) {
+            if (sameUuid.length < 2)
+                return [];
+        }
+        const duplicates = ownFolder ? sameUuid.filter((copy) => copy.folder !== ownFolder) : sameUuid;
+        if (duplicates.length === 0)
+            return [];
+        let boundFolder;
+        if (ctx.surface.loadOrder) {
+            const order = await ctx.surface.loadOrder(ctx.install);
+            boundFolder = order.find((e) => e.uuid?.toLowerCase() === target)?.folder;
+        }
+        return duplicates.map((copy) => {
+            const boundNote = boundFolder === undefined
+                ? ""
+                : copy.folder === boundFolder
+                    ? ` modsettings.lsx currently names Folder="${boundFolder}" for this UUID, this copy's folder — the one the mod manager last bound, which is a hint only: the running game may load a different copy (observed in game). Ext.Mod.GetMod("${uuid}").Info.Directory at the Script Extender console says which.`
+                    : ` modsettings.lsx currently names Folder="${boundFolder}" for this UUID, not this copy's folder — a hint only: the running game may still load this copy (observed in game). Ext.Mod.GetMod("${uuid}").Info.Directory at the Script Extender console says which.`;
+            const removalNote = copy.rootId === "loose"
+                ? `Remove the duplicate: a loose module is registered by its Data/Mods/<Folder> directory, so deleting (or moving aside) the directory this meta.lsx sits in takes it out ` +
+                    `of consideration. A loose copy is usually left over from an earlier loose-mode deploy or a manual unpack.`
+                : `Rename or remove the duplicate: the game only scans files with a .pak extension, so renaming this one to .pak.bak (the same convention already used in the profile folder ` +
+                    `for retired copies) or deleting it takes it out of consideration. If it came from a mod.io subscription, unsubscribing and deleting it is safe — mod.io will re-download it ` +
+                    `if you resubscribe.`;
+            return finding(duplicateModuleUuid.id, "block", copy.path, `${copy.path} (module folder "${copy.folder}", modified ${copy.modifiedAt}) carries this project's module UUID (${uuid}) but is a different copy from this project's own ` +
+                `deploy target${ownFolder ? ` ("${ownFolder}")` : ""}. BG3 identifies a mod by this UUID, not by filename, and which of several copies it loads is not predictable ` +
+                `from outside (observed in game), which is how content built into one copy stops loading with no error anywhere. ` +
+                `${removalNote}${boundNote}`, duplicateModuleUuid.evidence, { related: [ctx.project.root] });
+        });
+    },
+};
+const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const externalGuidLoadOrder = {
+    id: "bg3.history.external-guid-load-order",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["dialogue", "origin", "packaging"],
+    summary: "A GUID referenced by the mod that resolves in neither the mod nor the vanilla index is an external dependency that must be declared, or a typo that must be fixed.",
+    appliesTo: projectTarget(),
+    appliesToDescription: "the whole project: every attribute value across .lsx files that looks like a GUID and is not a definition (a 'UUID' attribute, or a bank Resource node's 'ID'), excluding Progressions/RootTemplates/ClassDescriptions and the TableUUID/ParentGuid/VisualTemplate/RootTemplate/ParentTemplateId attributes, which the G2 (items) and G6 (progression) rule groups already own with their own, more specific injection-vs-typo narrowing",
+    needs: { project: true, index: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.loadorder.external-guid-dependencies"],
+    async run(ctx) {
+        if (ctx.target.kind !== "project")
+            return [];
+        const OWNED_ELSEWHERE_PATH = /\/(progressions|roottemplates|classdescriptions)\//;
+        const OWNED_ELSEWHERE_ATTR = new Set(["TableUUID", "ParentGuid", "VisualTemplate", "RootTemplate", "ParentTemplateId"]);
+        const lsxFiles = await projectFiles(ctx.project, (p) => p.endsWith(".lsx"));
+        const defined = new Set();
+        const references = [];
+        for (const f of lsxFiles) {
+            let doc;
+            try {
+                doc = parseLsx(await ctx.readText(f), f);
+            }
+            catch {
+                continue;
+            }
+            const skipReferences = OWNED_ELSEWHERE_PATH.test(lower(f));
+            for (const region of doc.regions) {
+                walkLsxNodes(region.root, (node) => {
+                    for (const [attrId, attr] of Object.entries(node.attributes)) {
+                        if (!UUID_RE.test(attr.value))
+                            continue;
+                        if (attrId === "UUID" || (attrId === "ID" && node.id === "Resource")) {
+                            defined.add(attr.value.toLowerCase());
+                        }
+                        else if (!skipReferences && !OWNED_ELSEWHERE_ATTR.has(attrId)) {
+                            references.push({ uuid: attr.value.toLowerCase(), file: f, attr: attrId });
+                        }
+                    }
+                });
+            }
+        }
+        if (references.length === 0)
+            return [];
+        const hasModDependency = (ctx.project.project.dependencies ?? []).some((d) => d.kind === "mod");
+        const findings = [];
+        const reported = new Set();
+        for (const ref of references) {
+            const key = `${ref.file}:${ref.attr}:${ref.uuid}`;
+            if (reported.has(key))
+                continue;
+            if (defined.has(ref.uuid))
+                continue;
+            const vanilla = await ctx.lookup("guid", { uuid: ref.uuid });
+            if (vanilla.count > 0)
+                continue;
+            reported.add(key);
+            findings.push(finding(externalGuidLoadOrder.id, "block", ref.file, `${ref.attr} references ${ref.uuid}, which is defined neither in this project nor in the vanilla index. ` +
+                `Either this is an external mod's GUID that must be declared as a "mod" dependency in modwright.json${hasModDependency ? " (one is already declared, but not one that defines this GUID)" : ""}, or it is a typo — both readings point at the same finding.`, externalGuidLoadOrder.evidence));
+        }
+        return findings;
+    },
+};
+function divineLsxToLsfGlobs(project) {
+    const steps = project.project.build?.steps ?? [];
+    const out = [];
+    for (const s of steps) {
+        if (typeof s === "string")
+            continue;
+        if (s.step !== "divine-lsx-to-lsf")
+            continue;
+        const glob = s.glob ?? "**/*.lsx";
+        out.push(globToRegExp(glob));
+    }
+    return out;
+}
+const roottemplateLsxWithoutLsf = {
+    id: "bg3.history.roottemplate-lsx-without-lsf",
+    game: "baldursgate3",
+    groups: ["history"],
+    modTypes: ["packaging"],
+    summary: "Every Public/*/RootTemplates/*.lsx either has a divine-lsx-to-lsf build step covering it or an .lsf twin beside it — a loose .lsx there is never loaded by the game.",
+    appliesTo: projectTarget(),
+    appliesToDescription: "the whole project: every Public/*/RootTemplates/*.lsx among its sources, checked against build.steps' own divine-lsx-to-lsf glob(s) and for an .lsf file of the same name beside it",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: [
+        "bg3.items.roottemplates.loose-lsx-in-roottemplates-is-not-loaded-a-separate-lsf-is",
+        "observed in game (2026-09-10): a loose .lsx MapKey resolved to nothing; the same node as .lsf loaded",
+    ],
+    async run(ctx) {
+        if (ctx.target.kind !== "project")
+            return [];
+        const lsxFiles = await projectFiles(ctx.project, (p) => p.includes("/roottemplates/") && p.endsWith(".lsx"));
+        if (lsxFiles.length === 0)
+            return [];
+        const conversionGlobs = divineLsxToLsfGlobs(ctx.project);
+        const findings = [];
+        for (const abs of lsxFiles) {
+            const relPosix = posix(path.relative(ctx.project.root, abs));
+            if (conversionGlobs.some((re) => re.test(relPosix)))
+                continue;
+            const lsfTwin = abs.replace(/\.lsx$/i, ".lsf");
+            if (await ctx.exists(lsfTwin))
+                continue;
+            findings.push(finding(roottemplateLsxWithoutLsf.id, "block", abs, `Baldur's Gate 3 does not load a loose .lsx under RootTemplates — Ext.Template.GetTemplate and Osi.CreateAt both return nothing for its MapKey; the same node reaches the ` +
+                `engine only as an .lsf. Fix it either way: add a "divine-lsx-to-lsf" build step whose glob covers ${relPosix} (so the build converts it before packing), or convert this file ` +
+                `by hand (divine -a convert-resource) into an .lsf of the same name beside it.`, roottemplateLsxWithoutLsf.evidence, {
+                fix: `Add a "divine-lsx-to-lsf" build step covering ${relPosix}, or convert it to an .lsf twin (${path.basename(lsfTwin)}) beside it.`,
+            }));
+        }
+        return findings;
+    },
+};
+export const FILE_VALIDATORS = [
+    noBom,
+    iconuvRegionPlacement,
+    guiMetadataPresent,
+    locaNoXmlComments,
+    seConfigShape,
+    staleSameUuidPak,
+    duplicateModuleUuid,
+    externalGuidLoadOrder,
+    roottemplateLsxWithoutLsf,
+];