modwright 0.1.0

package/dist/surfaces/cyberpunk2077/paths.js

@@ -0,0 +1,12 @@
+import * as path from "node:path";
+export function red4extLogCandidates(install) {
+    return [path.join(install.root, "red4ext", "logs", "red4ext-*.log")];
+}
+export function pluginLogCandidates(install, plugin) {
+    const dir = path.join(install.root, "red4ext", "plugins", plugin);
+    return [path.join(dir, `${plugin}.log`), path.join(dir, `${plugin}-*.log`)];
+}
+export function redscriptLogCandidates(install) {
+    const dir = path.join(install.root, "r6", "logs");
+    return [path.join(dir, "redscript_r*-*.log"), path.join(dir, "redscript_rCURRENT.log")];
+}

package/dist/surfaces/cyberpunk2077/surface.js

@@ -0,0 +1,218 @@
+import * as path from "node:path";
+import { cyberpunk2077Compat } from "./compat.js";
+import { pathExists, readTextIfExists } from "../../core/fsutil.js";
+import { findInSteam } from "../../core/steam.js";
+import { dedupeByRoot, logs, roots } from "../../core/surfaceutil.js";
+import { cp2077Index } from "./index/index.js";
+import { SIGNATURES } from "./logs.js";
+import { BRIDGE_VALIDATORS } from "./validators/bridge.js";
+import { GARMENT_VALIDATORS } from "./validators/garments.js";
+import { MESH_VALIDATORS } from "./validators/mesh.js";
+import { MODSETTINGS_VALIDATORS } from "./validators/modsettings.js";
+import { PACKAGING_VALIDATORS } from "./validators/packaging.js";
+import { RED4EXT_VALIDATORS } from "./validators/red4ext.js";
+import { REDSCRIPT_VALIDATORS } from "./validators/redscript.js";
+import { TEMPLATE_VALIDATORS } from "./validators/templates.js";
+import { TWEAK_VALIDATORS } from "./validators/tweaks.js";
+import { VEHICLE_VALIDATORS } from "./validators/vehicles.js";
+import { XL_VALIDATORS } from "./validators/xl.js";
+import { pluginLogCandidates, red4extLogCandidates, redscriptLogCandidates } from "./paths.js";
+const NON_STEAM_CANDIDATES = [
+    "C:/GOG Games/Cyberpunk 2077",
+    "C:/Program Files (x86)/GOG Galaxy/Games/Cyberpunk 2077",
+    "C:/Program Files/Epic Games/Cyberpunk 2077",
+];
+export const cyberpunk2077 = {
+    id: "cyberpunk2077",
+    name: "Cyberpunk 2077",
+    aliases: ["cp2077", "cyberpunk", "2077"],
+    summary: "REDengine 4. Mods split across archive/pc/mod (.archive), mods/ (REDmod), " +
+        "r6/scripts (redscript), r6/tweaks (TweakXL), red4ext/plugins and CET lua mods.",
+    async detect() {
+        const installs = [];
+        const override = process.env.MODWRIGHT_CP2077_ROOT;
+        if (override && (await pathExists(override))) {
+            installs.push({ gameId: "cyberpunk2077", root: override, source: "env" });
+        }
+        for (const root of await findInSteam(["Cyberpunk 2077"])) {
+            installs.push({ gameId: "cyberpunk2077", root, source: "steam" });
+        }
+        for (const candidate of NON_STEAM_CANDIDATES) {
+            if (await pathExists(candidate)) {
+                installs.push({
+                    gameId: "cyberpunk2077",
+                    root: candidate,
+                    source: candidate.includes("Epic") ? "epic" : "gog",
+                });
+            }
+        }
+        return dedupeByRoot(installs);
+    },
+    modRoots(install) {
+        const at = (...segments) => path.join(install.root, ...segments);
+        return roots([
+            {
+                id: "archive",
+                label: "Legacy archives",
+                path: at("archive", "pc", "mod"),
+                layout: "file",
+                extensions: [".archive", ".xl"],
+                ordered: true,
+                conflictScope: "opaque",
+                notes: "Loaded alphabetically; later names win on identical resource paths. " +
+                    "A .xl sidecar is ArchiveXL and must keep the same base name as its .archive.",
+            },
+            {
+                id: "redmod",
+                label: "REDmod",
+                path: at("mods"),
+                layout: "directory",
+                ordered: true,
+                conflictScope: "isolated",
+                notes: "Each subfolder needs info.json. REDmods only take effect after " +
+                    "`tools/redmod/bin/redMod.exe deploy` runs, or with -modded on the launcher.",
+            },
+            {
+                id: "redscript",
+                label: "redscript",
+                path: at("r6", "scripts"),
+                layout: "directory",
+                conflictScope: "isolated",
+                notes: "Compiled at launch. One broken .reds aborts the whole compile and the " +
+                    "game starts with no script mods at all — check r6/logs/redscript_rCURRENT.log.",
+            },
+            {
+                id: "tweaks",
+                label: "TweakXL",
+                path: at("r6", "tweaks"),
+                layout: "flat",
+                conflictScope: "merged",
+                notes: "YAML tweak records applied by TweakXL. Requires the TweakXL RED4ext plugin.",
+            },
+            {
+                id: "input",
+                label: "Input Loader",
+                path: at("r6", "input"),
+                layout: "flat",
+                conflictScope: "merged",
+                notes: "Input Loader XML: <bindings> that add actions to input contexts (append=\"true\") " +
+                    "and their key mappings. Read at launch; requires the input_loader RED4ext plugin.",
+            },
+            {
+                id: "red4ext",
+                label: "RED4ext plugins",
+                path: at("red4ext", "plugins"),
+                layout: "directory",
+                conflictScope: "isolated",
+                notes: "Native .dll plugins. Version-locked to the game build — the usual cause " +
+                    "of a silent failure to launch after a patch.",
+            },
+            {
+                id: "cet",
+                label: "Cyber Engine Tweaks mods",
+                path: at("bin", "x64", "plugins", "cyber_engine_tweaks", "mods"),
+                layout: "directory",
+                conflictScope: "isolated",
+                notes: "Lua mods, each with init.lua. Reloadable in-game from the CET console.",
+            },
+        ]);
+    },
+    async readManifest(modPath, root) {
+        if (root.id !== "redmod")
+            return undefined;
+        const text = await readTextIfExists(path.join(modPath, "info.json"));
+        if (!text)
+            return undefined;
+        const raw = JSON.parse(text);
+        return {
+            format: "info.json",
+            name: typeof raw.name === "string" ? raw.name : undefined,
+            description: typeof raw.description === "string" ? raw.description : undefined,
+            version: typeof raw.version === "string" ? raw.version : undefined,
+            raw,
+        };
+    },
+    logs(install) {
+        const at = (...segments) => path.join(install.root, ...segments);
+        return logs([
+            {
+                id: "redscript",
+                label: "redscript compiler",
+                candidates: redscriptLogCandidates(install),
+                rootId: "redscript",
+                notes: "First place to look when script mods silently stop working. Ends with " +
+                    "'Output successfully saved' on a good compile.",
+            },
+            {
+                id: "red4ext",
+                label: "RED4ext loader",
+                candidates: red4extLogCandidates(install),
+                rootId: "red4ext",
+                notes: "One '[info] <Plugin> (version: x) has been loaded' line per plugin and a final " +
+                    "'N plugin(s) loaded'; version mismatches after a game patch are reported here. " +
+                    "A zero-byte log means RED4ext never initialized.",
+            },
+            {
+                id: "cet",
+                label: "Cyber Engine Tweaks",
+                path: at("bin", "x64", "plugins", "cyber_engine_tweaks", "cyber_engine_tweaks.log"),
+                rootId: "cet",
+                notes: "CET's own startup and hook log, appended across launches (not re-created). Per-mod " +
+                    "Lua output goes to mods/<mod>/<mod>.log beside each mod, not here. The previous " +
+                    "run's last line is often cut mid-write, so a run's first line can start mid-line.",
+            },
+            {
+                id: "archivexl",
+                label: "ArchiveXL",
+                candidates: pluginLogCandidates(install, "ArchiveXL"),
+                rootId: "archive",
+                notes: "One 'Loading \"<file>.xl\"...' per manifest, then per-section [ResourcePatch] / " +
+                    "[Localization] / [Journal] / [WorldStreaming] lines; resolution failures are " +
+                    "[error] lines tagged with the section.",
+            },
+            {
+                id: "tweakxl",
+                label: "TweakXL",
+                candidates: pluginLogCandidates(install, "TweakXL"),
+                rootId: "tweaks",
+                notes: "One 'Reading \"<file>\"...' per tweak file, then 'Import completed.' and " +
+                    "'Execution completed.'; bad references are [warning] lines naming the record.flat.",
+            },
+            {
+                id: "codeware",
+                label: "Codeware",
+                candidates: pluginLogCandidates(install, "Codeware"),
+                rootId: "red4ext",
+                notes: "Codeware's own log: 'Codeware <version> is initializing...' then 'Codeware is " +
+                    "initialized.' A missing 'is initialized' line means every redscript mod that " +
+                    "depends on Codeware is running without it.",
+            },
+        ]);
+    },
+    logSignatures: SIGNATURES,
+    index: cp2077Index,
+    validators: [
+        ...TWEAK_VALIDATORS,
+        ...GARMENT_VALIDATORS,
+        ...VEHICLE_VALIDATORS,
+        ...MESH_VALIDATORS,
+        ...XL_VALIDATORS,
+        ...PACKAGING_VALIDATORS,
+        ...BRIDGE_VALIDATORS,
+        ...TEMPLATE_VALIDATORS,
+        ...MODSETTINGS_VALIDATORS,
+        ...REDSCRIPT_VALIDATORS,
+        ...RED4EXT_VALIDATORS,
+    ],
+    toolNeeds: [
+        { feature: "index", tools: ["wolvenkit-cli"], optional: true, note: "TweakDB records come from the REDmod tweak sources with no tool; WolvenKit CLI adds the archive resource listing (without it, that part is skipped)." },
+        { feature: "build", tools: ["wolvenkit-cli"], note: "wolvenkit-import and wolvenkit-pack steps, and verifying an .archive's listing." },
+        { feature: "build", tools: ["blender"], optional: true, note: "blender-export steps only." },
+    ],
+    processNames: ["Cyberpunk2077.exe"],
+    compat: cyberpunk2077Compat,
+    guidance: "Order of operations matters: RED4ext loads native plugins, which host ArchiveXL and " +
+        "TweakXL, which in turn make r6/tweaks and .xl files meaningful. A missing RED4ext " +
+        "explains an entire category of mods appearing to do nothing. REDmod (mods/) and legacy " +
+        "archives (archive/pc/mod) are separate systems and can both be present at once.",
+};

package/dist/surfaces/cyberpunk2077/validators/bridge.js

@@ -0,0 +1,7 @@
+import { bridgeNeverShipValidator } from "../../../core/bridge/index.js";
+export const bridgeNeverShipsValidator = bridgeNeverShipValidator({
+    id: "cp2077.history.bridge-never-ships",
+    game: "cyberpunk2077",
+    evidence: ["ModWright research"],
+});
+export const BRIDGE_VALIDATORS = [bridgeNeverShipsValidator];

package/dist/surfaces/cyberpunk2077/validators/cr2w.js

@@ -0,0 +1,349 @@
+export function isJsonObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+export function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function walkObjects(root, visit, jsonPath = "$") {
+    if (Array.isArray(root)) {
+        root.forEach((item, i) => walkObjects(item, visit, `${jsonPath}[${i}]`));
+        return;
+    }
+    if (isJsonObject(root)) {
+        visit(root, jsonPath);
+        for (const [key, value] of Object.entries(root)) {
+            walkObjects(value, visit, `${jsonPath}.${key}`);
+        }
+    }
+}
+export function collectKey(root, key) {
+    const hits = [];
+    walkObjects(root, (obj, jsonPath) => {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            hits.push({ value: obj[key], jsonPath: `${jsonPath}.${key}`, container: obj });
+        }
+    });
+    return hits;
+}
+export function cnameValue(v) {
+    if (typeof v === "string")
+        return v;
+    if (isJsonObject(v) && typeof v.$value === "string")
+        return v.$value;
+    return undefined;
+}
+export function resourcePathValue(v) {
+    if (!isJsonObject(v))
+        return undefined;
+    if (v.$type === "ResourcePath" && typeof v.$value === "string")
+        return v.$value;
+    if ("DepotPath" in v)
+        return resourcePathValue(v.DepotPath);
+    return undefined;
+}
+function isSentinelPath(p) {
+    return p.length === 0 || /^\d+$/.test(p);
+}
+export function collectResourcePaths(root) {
+    const out = [];
+    walkObjects(root, (obj, jsonPath) => {
+        if (obj.$type === "ResourcePath" && typeof obj.$value === "string" && !isSentinelPath(obj.$value)) {
+            out.push({ path: obj.$value, jsonPath: `${jsonPath}.$value` });
+        }
+    });
+    return out;
+}
+export function collectDollarValueStrings(root) {
+    const out = [];
+    walkObjects(root, (obj, jsonPath) => {
+        if (typeof obj.$value === "string")
+            out.push({ value: obj.$value, jsonPath: `${jsonPath}.$value` });
+    });
+    return out;
+}
+export function lineOfOccurrence(text, literal, occurrence = 0) {
+    let index = -1;
+    for (let i = 0; i <= occurrence; i++) {
+        index = text.indexOf(literal, index + 1);
+        if (index === -1)
+            return undefined;
+    }
+    return text.slice(0, index).split("\n").length;
+}
+export async function readCr2wJson(ctx, absPath) {
+    let text;
+    try {
+        text = await ctx.readText(absPath);
+    }
+    catch {
+        return undefined;
+    }
+    const root = tryParseJson(text);
+    if (root === undefined)
+        return undefined;
+    return { root, text };
+}
+export async function readStagedCr2wJson(ctx, absBase) {
+    for (const candidate of [absBase, `${absBase}.json`]) {
+        if (await ctx.exists(candidate)) {
+            const parsed = await readCr2wJson(ctx, candidate);
+            if (parsed)
+                return { ...parsed, absPath: candidate };
+        }
+    }
+    return undefined;
+}
+export async function existsStaged(ctx, absBase) {
+    if (await ctx.exists(absBase))
+        return true;
+    return ctx.exists(`${absBase}.json`);
+}
+export function normalizeDepotPath(depotPath) {
+    const stripped = depotPath.startsWith("*") ? depotPath.slice(1) : depotPath;
+    return stripped.replace(/\//g, "\\");
+}
+export async function existsInVanillaIndex(ctx, depotPath) {
+    if (!ctx.store)
+        return false;
+    const res = await ctx.lookup("resource", { path: normalizeDepotPath(depotPath) });
+    return res.count > 0;
+}
+const CR2W_RESOURCE_EXTENSIONS = new Set([
+    "ent",
+    "app",
+    "mesh",
+    "mi",
+    "mlsetup",
+    "phys",
+    "streamingsector",
+    "streamingblock",
+    "inkatlas",
+    "inkwidget",
+    "csv",
+    "json",
+    "effect",
+    "es",
+    "anims",
+    "rig",
+    "xbm",
+]);
+function hasKnownCr2wResourceExtension(filePath) {
+    const base = filePath.toLowerCase().split(/[/\\]/).pop() ?? "";
+    const m = /\.([a-z0-9]+)\.json$/.exec(base);
+    return m !== null && CR2W_RESOURCE_EXTENSIONS.has(m[1]);
+}
+function hasCr2wHeaderShape(root) {
+    if (!isJsonObject(root))
+        return false;
+    const header = root.Header;
+    if (!isJsonObject(header))
+        return false;
+    return header.DataType === "CR2W" || header.WKitJsonVersion !== undefined;
+}
+function isJsonUnderConsideration(filePath) {
+    const lower = filePath.toLowerCase();
+    if (!lower.endsWith(".json"))
+        return false;
+    if (lower.endsWith("modwright.json"))
+        return false;
+    if (lower.endsWith("suppressions.json"))
+        return false;
+    return true;
+}
+export function isCr2wCandidate(filePath, root) {
+    if (!isJsonUnderConsideration(filePath))
+        return false;
+    if (hasKnownCr2wResourceExtension(filePath))
+        return true;
+    return hasCr2wHeaderShape(root);
+}
+function fileTarget(t) {
+    return t.kind === "file" ? t.path : undefined;
+}
+const UNIQUE_IDS_EVIDENCE = [
+    "cp2077.sectors.sector-json-file-uniqueness",
+    "cp2077.toolchain.cli-convert-deserialize",
+];
+async function checkUniqueIds(text, root, file) {
+    const findings = [];
+    for (const key of ["HandleId", "BufferId"]) {
+        const hits = collectKey(root, key);
+        const byValue = new Map();
+        for (const hit of hits) {
+            if (typeof hit.value !== "string")
+                continue;
+            const list = byValue.get(hit.value) ?? [];
+            list.push(hit);
+            byValue.set(hit.value, list);
+        }
+        for (const [value, list] of byValue) {
+            if (list.length < 2)
+                continue;
+            const lines = list.map((_, i) => lineOfOccurrence(text, `"${key}": "${value}"`, i)).filter((l) => l !== undefined);
+            findings.push({
+                validatorId: "cp2077.vehicles.cr2w-unique-ids",
+                severity: "block",
+                file,
+                line: lines[0],
+                message: `${key} "${value}" appears ${list.length} times in this CR2W json file (at ${list.map((h) => h.jsonPath).join(", ")}); ` +
+                    `${key}s must be unique across the whole file, not per node. WolvenKit's convert deserialize fails on the duplicate with ` +
+                    `only "a useless generic JsonException at the buffer's closing brace" — assign a fresh, unused ${key} to every occurrence but one.`,
+                fix: `Change all but one of these ${key} values to a number not used anywhere else in the file.`,
+                evidence: UNIQUE_IDS_EVIDENCE,
+            });
+        }
+    }
+    return findings;
+}
+const PLAIN_ENUM_FIELDS = ["category", "lootQuality", "containerType", "cookingPlatform"];
+const ENUM_EVIDENCE = ["cp2077.toolchain.cr2w-enums-are-strings"];
+function checkEnumsAreStrings(text, root, file) {
+    const findings = [];
+    walkObjects(root, (obj, jsonPath) => {
+        for (const key of PLAIN_ENUM_FIELDS) {
+            const v = obj[key];
+            if (typeof v === "number") {
+                findings.push(enumFinding(text, file, key, v, `${jsonPath}.${key}`));
+            }
+        }
+        if ("Flags" in obj && "DepotPath" in obj && typeof obj.Flags === "number") {
+            findings.push(enumFinding(text, file, "Flags", obj.Flags, `${jsonPath}.Flags`));
+        }
+    });
+    return findings;
+}
+function enumFinding(text, file, key, value, jsonPath) {
+    const line = lineOfOccurrence(text, `"${key}": ${value}`);
+    return {
+        validatorId: "cp2077.vehicles.cr2w-enums-are-strings",
+        severity: "block",
+        file,
+        line,
+        message: `"${key}": ${value} at ${jsonPath} is a bare number; CR2W json enums are quoted strings (e.g. "Always"), ` +
+            "never bare numbers or unquoted names — a bare enum value is invalid json for this format.",
+        fix: `Replace the numeric ${value} with the enum's string name (check a known-good CR2W json for the same $type to find it).`,
+        evidence: ENUM_EVIDENCE,
+    };
+}
+const RESOURCE_PATH_EVIDENCE = ["cp2077.toolchain.resource-path-shape", "cp2077.archivexl.factory-csv-appearance-mapping"];
+function checkResourcePathShape(root, file) {
+    const findings = [];
+    for (const { path: p, jsonPath } of collectResourcePaths(root)) {
+        const problems = [];
+        if (p.includes("/"))
+            problems.push("uses a forward slash instead of a backslash");
+        if (p.startsWith("\\") || p.startsWith("/"))
+            problems.push("has a leading slash");
+        if (p !== p.toLowerCase())
+            problems.push("has uppercase characters");
+        if (problems.length === 0)
+            continue;
+        findings.push({
+            validatorId: "cp2077.vehicles.cr2w-resource-path-shape",
+            severity: "warn",
+            file,
+            message: `Resource path "${p}" at ${jsonPath} ${problems.join(", ")}. Shipping CR2W depot paths are backslash-separated, ` +
+                `no leading slash, all lowercase (e.g. "mod\\\\mymod\\\\cache_case.ent").`,
+            fix: "Rewrite the path with backslashes, no leading slash, and lowercase.",
+            evidence: RESOURCE_PATH_EVIDENCE,
+        });
+    }
+    return findings;
+}
+const GAMEVERSION_EVIDENCE = [
+    "cp2077.toolchain.gameversion-header",
+    "cp2077.packaging.game-version-compatibility",
+    "observed: a WolvenKit 8.20.0 en-us.source.json header carries GameVersion 2310",
+];
+function expectedGameVersion(marketingVersion) {
+    const m = /^(\d+)\.(\d{1,2})$/.exec(marketingVersion.trim());
+    if (!m)
+        return undefined;
+    const major = m[1];
+    const minor = m[2].padStart(2, "0");
+    return Number(`${major}${minor}0`);
+}
+function checkGameVersionHeader(root, file, installVersion) {
+    if (!isJsonObject(root))
+        return [];
+    const header = isJsonObject(root.Header) ? root.Header : undefined;
+    const gameVersion = header?.GameVersion;
+    if (gameVersion === undefined) {
+        return [
+            {
+                validatorId: "cp2077.vehicles.cr2w-gameversion-header",
+                severity: "warn",
+                file,
+                message: "This CR2W json has no Header.GameVersion. WolvenKit writes one on every serialize/extract " +
+                    '(e.g. a mod\'s en-us.source.json: WolvenKitVersion "8.20.0", GameVersion 2310); ' +
+                    "a hand-edited or hand-assembled json missing it cannot be confirmed to target the intended engine build.",
+                fix: 'Add a Header with GameVersion set to the value WolvenKit writes for the game version you are building against (e.g. 2310 for game 2.31).',
+                evidence: GAMEVERSION_EVIDENCE,
+            },
+        ];
+    }
+    if (typeof gameVersion !== "number" || !installVersion)
+        return [];
+    const expected = expectedGameVersion(installVersion);
+    if (expected === undefined)
+        return [];
+    if (expected !== gameVersion) {
+        return [
+            {
+                validatorId: "cp2077.vehicles.cr2w-gameversion-header",
+                severity: "warn",
+                file,
+                message: `Header.GameVersion is ${gameVersion}, but the located install reports game version ${installVersion} ` +
+                    `(expected GameVersion ${expected} on that build family). A mod's CR2W assets built for one game version ` +
+                    "may not load correctly on another.",
+                fix: "Re-serialize this asset with a WolvenKit CLI matching the target game version, or confirm the install version.",
+                evidence: GAMEVERSION_EVIDENCE,
+            },
+        ];
+    }
+    return [];
+}
+function makeCr2wValidator(id, summary, severity, evidence, needsInstall, check) {
+    return {
+        id,
+        game: "cyberpunk2077",
+        groups: ["vehicles"],
+        modTypes: ["vehicle", "garment", "world-sector", "ui"],
+        summary,
+        appliesTo: (target) => {
+            const file = fileTarget(target);
+            return file !== undefined && isJsonUnderConsideration(file);
+        },
+        appliesToDescription: "every .json file in the project except modwright.json and .modwright/suppressions.json, narrowed at run time to genuine CR2W resource json (a known resource extension, or a Header with DataType \"CR2W\"/WKitJsonVersion)",
+        needs: { project: true, ...(needsInstall ? { install: true } : {}) },
+        cost: "edit",
+        severity,
+        evidence,
+        async run(ctx) {
+            const file = fileTarget(ctx.target);
+            if (!file)
+                return [];
+            const parsed = await readCr2wJson(ctx, file);
+            if (!parsed)
+                return [];
+            if (!isCr2wCandidate(file, parsed.root))
+                return [];
+            return check({ text: parsed.text, root: parsed.root, file, project: ctx.project, install: ctx.install });
+        },
+    };
+}
+export const CR2W_UNIQUE_IDS = makeCr2wValidator("cp2077.vehicles.cr2w-unique-ids", "Every HandleId and every BufferId is unique across the whole CR2W json file.", "block", UNIQUE_IDS_EVIDENCE, false, ({ text, root, file }) => checkUniqueIds(text, root, file));
+export const CR2W_ENUMS_ARE_STRINGS = makeCr2wValidator("cp2077.vehicles.cr2w-enums-are-strings", "Enum-valued fields (category, lootQuality, containerType, cookingPlatform, and resource-reference Flags) are quoted strings, never bare numbers.", "block", ENUM_EVIDENCE, false, ({ text, root, file }) => checkEnumsAreStrings(text, root, file));
+export const CR2W_RESOURCE_PATH_SHAPE = makeCr2wValidator("cp2077.vehicles.cr2w-resource-path-shape", "DepotPath/resource-path values use backslashes, no leading slash, and lowercase.", "warn", RESOURCE_PATH_EVIDENCE, false, ({ root, file }) => checkResourcePathShape(root, file));
+export const CR2W_GAMEVERSION_HEADER = makeCr2wValidator("cp2077.vehicles.cr2w-gameversion-header", "The CR2W json Header carries GameVersion, compared against the installed game's version when known.", "warn", GAMEVERSION_EVIDENCE, true, ({ root, file, install }) => checkGameVersionHeader(root, file, install?.version));
+export const CR2W_VALIDATORS = [
+    CR2W_UNIQUE_IDS,
+    CR2W_ENUMS_ARE_STRINGS,
+    CR2W_RESOURCE_PATH_SHAPE,
+    CR2W_GAMEVERSION_HEADER,
+];