modwright 0.1.0

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

@@ -0,0 +1,734 @@
+import { attr, children, collectAllStatEntries, collectProjectLsx, detectPartialTree, GAME, isProjectTarget, nodesOf, skipFinding, } from "./items.js";
+function listOwners(idx) {
+    return { classes: nodesOf(idx, "ClassDescription"), races: nodesOf(idx, "Race") };
+}
+function findOwnerByName(idx, name) {
+    const { classes, races } = listOwners(idx);
+    const race = races.find((r) => attr(r.node, "Name") === name);
+    if (race)
+        return { node: race.node, kind: "race" };
+    const cls = classes.find((c) => attr(c.node, "Name") === name);
+    if (cls)
+        return { node: cls.node, kind: attr(cls.node, "ParentGuid") ? "subclass" : "class" };
+    return undefined;
+}
+async function isVanillaTableInjection(ctx, name, tableUUID) {
+    if (!ctx.store || !name)
+        return false;
+    let res;
+    try {
+        res = await ctx.lookup("guid", { name });
+    }
+    catch {
+        return false;
+    }
+    for (const row of res.rows) {
+        const r = row;
+        if (r.kind === "ClassDescription" && r.attributes?.ProgressionTableUUID?.value === tableUUID)
+            return true;
+    }
+    return false;
+}
+const SEMI = (v) => (v ?? "").split(";").map((s) => s.trim()).filter(Boolean);
+function selectorCalls(selectors, kinds) {
+    if (!selectors)
+        return [];
+    const pattern = new RegExp(`(${kinds.join("|")})\\(([^)]*)\\)`, "g");
+    const out = [];
+    for (const m of selectors.matchAll(pattern)) {
+        out.push({ kind: m[1], args: m[2].split(",").map((a) => a.trim()) });
+    }
+    return out;
+}
+const tableuuidMatchesOwner = {
+    id: "bg3.progression.tableuuid-matches-owner",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass"],
+    summary: "A Progression node's TableUUID must equal its owner's ProgressionTableUUID, and differ from its own UUID.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every Progression node whose owner is authored in this project",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: [
+        "bg3.races.progression.uuid-vs-tableuuid",
+        "bg3.races.progression.race-links-via-progressiontableuuid",
+        "bg3.feats.classes.subclass-is-classdescription-with-parentguid",
+    ],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const findings = [];
+        for (const ref of nodesOf(idx, "Progression")) {
+            const name = attr(ref.node, "Name");
+            const tableUUID = attr(ref.node, "TableUUID");
+            const uuid = attr(ref.node, "UUID");
+            if (!name || !tableUUID)
+                continue;
+            if (uuid && tableUUID === uuid) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file: ref.file,
+                    message: `Progression node "${name}" (UUID=${uuid}) has TableUUID equal to its own UUID — TableUUID must identify the whole table, not this one node.`,
+                    fix: `Set TableUUID to the value shared by every Progression node of this table (usually the Level 1 node's own value), distinct from this node's UUID.`,
+                    evidence: this.evidence,
+                });
+            }
+            const owner = findOwnerByName(idx, name);
+            if (!owner)
+                continue;
+            const ownerTableUUID = attr(owner.node, "ProgressionTableUUID");
+            if (!ownerTableUUID)
+                continue;
+            if (ownerTableUUID !== tableUUID) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file: ref.file,
+                    message: `Progression node "${name}" has TableUUID "${tableUUID}", but its owning ${owner.kind} "${name}" declares ` +
+                        `ProgressionTableUUID "${ownerTableUUID}" — the two must match or this node's boosts never apply.`,
+                    fix: `Set TableUUID to "${ownerTableUUID}" (or fix the owner's ProgressionTableUUID, whichever is the typo).`,
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const level1NodePresent = {
+    id: "bg3.progression.level1-node-present",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass"],
+    summary: "Every ProgressionTableUUID this mod defines nodes for has a Level 1 node (class tables only — " +
+        "subclasses legitimately start at whatever level the class allows).",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, grouping this mod's own Progression nodes by TableUUID",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.feats.classes.level1-progression-required-for-cc"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const byTable = new Map();
+        for (const ref of nodesOf(idx, "Progression")) {
+            const tableUUID = attr(ref.node, "TableUUID");
+            if (!tableUUID)
+                continue;
+            const list = byTable.get(tableUUID);
+            if (list)
+                list.push(ref);
+            else
+                byTable.set(tableUUID, [ref]);
+        }
+        const findings = [];
+        for (const [tableUUID, refs] of byTable) {
+            const ownerName = attr(refs[0].node, "Name");
+            if (await isVanillaTableInjection(ctx, ownerName, tableUUID))
+                continue;
+            const declaredType = refs.find((r) => attr(r.node, "ProgressionType") != null);
+            const progressionType = declaredType ? attr(declaredType.node, "ProgressionType") : undefined;
+            if (progressionType !== undefined && progressionType !== "0")
+                continue;
+            const hasLevel1 = refs.some((r) => Number(attr(r.node, "Level")) === 1);
+            if (!hasLevel1) {
+                const name = ownerName ?? "?";
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file: refs[0].file,
+                    message: `Table "${tableUUID}" (Progression nodes named "${name}") has no Level 1 node — the class/race cannot progress past character creation.`,
+                    fix: `Add a Level="1" Progression node with TableUUID="${tableUUID}".`,
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const OWNER_KIND_TYPE = { class: "0", subclass: "1", race: "2" };
+const typeMatchesOwner = {
+    id: "bg3.progression.type-matches-owner",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass"],
+    summary: "ProgressionType is 0 for a class, 1 for a subclass, 2 for a race, matching the owner.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over Progression nodes whose owner is authored in this project",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: [
+        "bg3.races.progression.progressiontype-numeric-values",
+        "bg3.feats.classes.subclass-listed-under-parent-progression",
+    ],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const findings = [];
+        for (const ref of nodesOf(idx, "Progression")) {
+            const name = attr(ref.node, "Name");
+            const type = attr(ref.node, "ProgressionType");
+            if (!name || type === undefined)
+                continue;
+            const owner = findOwnerByName(idx, name);
+            if (!owner)
+                continue;
+            const expected = OWNER_KIND_TYPE[owner.kind];
+            if (type !== expected) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file: ref.file,
+                    message: `Progression node "${name}" has ProgressionType="${type}", but its owner is a ${owner.kind} (expected ProgressionType="${expected}").`,
+                    fix: `Set ProgressionType="${expected}".`,
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const subclassRegisteredInParent = {
+    id: "bg3.progression.subclass-registered-in-parent",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["subclass"],
+    summary: "A subclass ClassDescription must appear as a SubClasses/SubClass child on its parent's Progression node.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over subclass ClassDescription nodes whose parent class is also authored in this project",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.feats.classes.subclass-listed-under-parent-progression"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const classes = nodesOf(idx, "ClassDescription");
+        const progressions = nodesOf(idx, "Progression");
+        const findings = [];
+        for (const sub of classes) {
+            const parentGuid = attr(sub.node, "ParentGuid");
+            const subUuid = attr(sub.node, "UUID");
+            const subName = attr(sub.node, "Name") ?? "?";
+            if (!parentGuid || !subUuid)
+                continue;
+            const parent = classes.find((c) => attr(c.node, "UUID") === parentGuid);
+            if (!parent) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "info",
+                    file: sub.file,
+                    message: `Subclass "${subName}"'s ParentGuid "${parentGuid}" is not a ClassDescription authored in this project — ` +
+                        `its registration as a SubClasses/SubClass entry must exist in the parent mod, or be added via the ` +
+                        `Compatibility Framework.`,
+                    evidence: this.evidence,
+                });
+                continue;
+            }
+            const parentName = attr(parent.node, "Name");
+            const registered = progressions.some((p) => attr(p.node, "Name") === parentName &&
+                children(p.node, "SubClasses").some((sc) => children(sc, "SubClass").some((s) => attr(s, "Object") === subUuid)));
+            if (!registered) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file: sub.file,
+                    message: `Subclass "${subName}" (UUID=${subUuid}) is not registered as a SubClasses/SubClass entry on any of "${parentName}"'s Progression nodes.`,
+                    fix: `Add a <node id="SubClasses"><children><node id="SubClass"><attribute id="Object" type="guid" value="${subUuid}"/></node></children></node> to the Progression node for the level this subclass unlocks.`,
+                    related: [parent.file],
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const INDEX_BACKED_SELECTOR_KINDS = ["SelectSpells", "AddSpells"];
+const spelllistSelectorResolves = {
+    id: "bg3.progression.spelllist-selector-resolves",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass", "feat"],
+    summary: "The first argument of SelectSpells/AddSpells must resolve to a SpellList UUID (see below for SelectPassives/SelectSkills).",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every SelectSpells/AddSpells call in a Progression node",
+    needs: { project: true, index: true },
+    cost: "edit",
+    severity: "block",
+    evidence: [
+        "bg3.crash.dangling-spelllist-reference",
+        "bg3.practice.reference-checker-invaluable",
+        "bg3.spells.addspells-autogrant-pattern",
+    ],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const projectLists = new Set(nodesOf(idx, "SpellList")
+            .map((ref) => attr(ref.node, "UUID"))
+            .filter((v) => !!v));
+        const findings = [];
+        for (const ref of nodesOf(idx, "Progression")) {
+            const selectors = attr(ref.node, "Selectors");
+            for (const call of selectorCalls(selectors, INDEX_BACKED_SELECTOR_KINDS)) {
+                const uuid = call.args[0];
+                if (!uuid || !/^[0-9a-fA-F-]{36}$/.test(uuid))
+                    continue;
+                if (projectLists.has(uuid))
+                    continue;
+                let resolved = false;
+                if (ctx.store) {
+                    const res = await ctx.lookup("list", { uuid });
+                    resolved = res.count > 0;
+                }
+                if (!resolved) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "block",
+                        file: ref.file,
+                        message: `Progression "${attr(ref.node, "Name") ?? "?"}"'s ${call.kind}(${uuid},...) does not resolve to any list UUID in this mod or the vanilla index.`,
+                        fix: `Define a SpellList with UUID="${uuid}", or fix the selector argument.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+const spelllistMembersExist = {
+    id: "bg3.progression.spelllist-members-exist",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass", "feat"],
+    summary: "Every spell named in a SpellList this mod defines resolves to a Spells.txt entry.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every SpellList's Spells this mod defines — refuses to run on a partial tree",
+    needs: { project: true, index: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.crash.dangling-spelllist-reference", "bg3.practice.reference-checker-invaluable"],
+    async run(ctx) {
+        const partial = await detectPartialTree(ctx);
+        if (partial)
+            return skipFinding(this.id, ctx.project, partial, this.evidence);
+        const idx = await collectProjectLsx(ctx);
+        const byName = await collectAllStatEntries(ctx);
+        const findings = [];
+        for (const ref of nodesOf(idx, "SpellList")) {
+            const listName = attr(ref.node, "Name") ?? attr(ref.node, "UUID") ?? "?";
+            for (const spell of SEMI(attr(ref.node, "Spells"))) {
+                const own = byName.get(spell);
+                let resolved = own !== undefined;
+                if (!resolved && ctx.store) {
+                    const res = await ctx.lookup("stat", { name: spell });
+                    resolved = res.count > 0;
+                }
+                if (!resolved) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "block",
+                        file: ref.file,
+                        message: `SpellList "${listName}" names spell "${spell}", which is not a defined stats entry in this mod or vanilla.`,
+                        fix: `Define "${spell}" as a SpellData entry, or remove it from the list.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+const passivesExist = {
+    id: "bg3.progression.passives-exist",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass", "feat"],
+    summary: "Every name in PassivesAdded/PassivesRemoved resolves to a Passive.txt entry.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every Progression node's PassivesAdded/PassivesRemoved — refuses to run on a partial tree",
+    needs: { project: true, index: true },
+    cost: "edit",
+    severity: "block",
+    evidence: [
+        "bg3.feats.classes.boosts-vs-passivesadded-distinction",
+        "bg3.feats.classes.passivesadded-vs-selectpassives-selector",
+        "bg3.practice.reference-checker-invaluable",
+    ],
+    async run(ctx) {
+        const partial = await detectPartialTree(ctx);
+        if (partial)
+            return skipFinding(this.id, ctx.project, partial, this.evidence);
+        const idx = await collectProjectLsx(ctx);
+        const byName = await collectAllStatEntries(ctx);
+        const findings = [];
+        for (const ref of nodesOf(idx, "Progression")) {
+            const name = attr(ref.node, "Name") ?? "?";
+            for (const field of ["PassivesAdded", "PassivesRemoved"]) {
+                for (const passive of SEMI(attr(ref.node, field))) {
+                    const own = byName.get(passive);
+                    let resolved = own !== undefined;
+                    if (!resolved && ctx.store) {
+                        const res = await ctx.lookup("stat", { name: passive });
+                        resolved = res.count > 0;
+                    }
+                    if (!resolved) {
+                        findings.push({
+                            validatorId: this.id,
+                            severity: "block",
+                            file: ref.file,
+                            message: `Progression "${name}"'s ${field} names "${passive}", which is not a defined stats entry in this mod or vanilla.`,
+                            fix: `Define "${passive}" as a PassiveData entry, or remove it from ${field}.`,
+                            evidence: this.evidence,
+                        });
+                    }
+                }
+            }
+        }
+        return findings;
+    },
+};
+const addspellsArgSlots = {
+    id: "bg3.progression.addspells-arg-slots",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass", "feat"],
+    summary: "AddSpells argument positions are respected: AlwaysPrepared in slot 5, UntilRest in slot 6.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every AddSpells(...) call in a Progression node's Selectors",
+    needs: { project: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: ["bg3.spells.untilrest-free-cast-pattern", "bg3.spells.addspells-autogrant-pattern"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const findings = [];
+        for (const ref of nodesOf(idx, "Progression")) {
+            for (const call of selectorCalls(attr(ref.node, "Selectors"), ["AddSpells"])) {
+                const args = call.args;
+                const alwaysPreparedAt = args.findIndex((a) => a === "AlwaysPrepared");
+                if (alwaysPreparedAt !== -1 && alwaysPreparedAt !== 4) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: ref.file,
+                        message: `AddSpells(${args.join(",")}) has "AlwaysPrepared" in argument slot ${alwaysPreparedAt + 1}, but it must be slot 5 (prepareType).`,
+                        fix: `AddSpells(list, selectorId, ability, cooldown, prepareType, replenishType) — move AlwaysPrepared to slot 5.`,
+                        evidence: this.evidence,
+                    });
+                }
+                const untilRestAt = args.findIndex((a) => a === "UntilRest");
+                if (untilRestAt !== -1 && untilRestAt !== 5) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: ref.file,
+                        message: `AddSpells(${args.join(",")}) has "UntilRest" in argument slot ${untilRestAt + 1}, but it must be slot 6 (replenishType).`,
+                        fix: `AddSpells(list, selectorId, ability, cooldown, prepareType, replenishType) — move UntilRest to slot 6.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+const classAnchorDescription = {
+    id: "bg3.progression.class-anchor-description",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["class", "subclass"],
+    summary: "Every class/subclass table this mod owns needs a class-name-anchor ProgressionDescription.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every ClassDescription this mod authors",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.progressions.class-anchor-description", "bg3.progressions.subclass-anchor-description"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const anchors = nodesOf(idx, "ProgressionDescription");
+        const findings = [];
+        for (const ref of nodesOf(idx, "ClassDescription")) {
+            const name = attr(ref.node, "Name");
+            const tableUUID = attr(ref.node, "ProgressionTableUUID");
+            if (!name || !tableUUID)
+                continue;
+            const found = anchors.some((a) => {
+                const exactMatch = attr(a.node, "ExactMatch");
+                const hidden = (attr(a.node, "Hidden") ?? "false").toLowerCase();
+                const scopedTable = attr(a.node, "TableUUID") ?? attr(a.node, "ProgressionTableUUID");
+                return exactMatch === name && hidden === "false" && (scopedTable === undefined || scopedTable === tableUUID);
+            });
+            if (!found) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "block",
+                    file: ref.file,
+                    message: `ClassDescription "${name}" has no anchor ProgressionDescription (ExactMatch="${name}", Hidden=false, ` +
+                        `scoped to table "${tableUUID}") — without it the CC/level-up viewmodel never creates the feature ` +
+                        `group and nothing boost-derived renders, not even proficiencies.`,
+                    fix: `Add a ProgressionDescription with ExactMatch="${name}", Hidden="False", TableUUID="${tableUUID}".`,
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const BUILTIN_ACTION_RESOURCES = new Set([
+    "SpellSlot",
+    "ActionPoint",
+    "BonusActionPoint",
+    "Movement",
+    "KiPoint",
+    "SorceryPoint",
+    "SuperiorityDie",
+    "ChannelDivinity",
+    "ChannelOath",
+    "WildShape",
+    "LayOnHandsCharge",
+    "HitDice",
+    "Rage",
+    "ArcaneRecoveryPoint",
+]);
+const actionresourceDefined = {
+    id: "bg3.progression.actionresource-defined",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["class", "subclass", "feat"],
+    summary: "ActionResource(...) boosts must name a resource this mod (or vanilla) defines; defined resources must be granted.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over Boosts strings and ActionResourceDefinitions this mod authors",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: [
+        "bg3.feats.classes.actionresourcedefinition-required-fields",
+        "bg3.feats.classes.actionresource-granted-via-boosts",
+    ],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const defined = new Set(nodesOf(idx, "ActionResourceDefinition").map((r) => attr(r.node, "Name")).filter((v) => !!v));
+        const findings = [];
+        if (defined.size === 0)
+            return findings;
+        const used = new Map();
+        for (const ref of nodesOf(idx, "Progression")) {
+            const nodeTable = attr(ref.node, "TableUUID");
+            const isInjection = nodeTable !== undefined && (await isVanillaTableInjection(ctx, attr(ref.node, "Name"), nodeTable));
+            const boosts = attr(ref.node, "Boosts") ?? "";
+            for (const m of boosts.matchAll(/ActionResource\(([^,)]+)/g)) {
+                const resourceName = m[1].trim();
+                const list = used.get(resourceName) ?? [];
+                list.push(attr(ref.node, "Name") ?? "?");
+                used.set(resourceName, list);
+                if (isInjection)
+                    continue;
+                if (!defined.has(resourceName) && !BUILTIN_ACTION_RESOURCES.has(resourceName)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "block",
+                        file: ref.file,
+                        message: `Progression's Boosts grants ActionResource(${resourceName},...), which is not defined in this mod's ActionResourceDefinitions.lsx.`,
+                        fix: `Define an ActionResourceDefinition named "${resourceName}", or fix the boost.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        for (const ref of nodesOf(idx, "ActionResourceDefinition")) {
+            const name = attr(ref.node, "Name");
+            if (name && !used.has(name)) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "warn",
+                    file: ref.file,
+                    message: `ActionResourceDefinition "${name}" is defined but never granted via ActionResource(${name},...) in any Boosts — it is just floating around.`,
+                    fix: `Grant it from a Progression's Boosts, or remove the definition.`,
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const RACE_BLOCK_FIELDS = ["ProgressionTableUUID", "UUID"];
+const RACE_WARN_FIELDS = ["Description", "DisplayName", "DisplayTypeUUID", "Name", "ParentGuid", "RaceSoundSwitch"];
+const raceRequiredFields = {
+    id: "bg3.progression.race-required-fields",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race"],
+    summary: "A Races.lsx Race node carries its required fields; RootTemplates with a Race attribute must match one.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every Race node this mod authors",
+    needs: { project: true },
+    cost: "edit",
+    severity: "block",
+    evidence: ["bg3.races.progression.race-root-required-fields", "bg3.races.progression.roottemplate-race-attribute-must-match"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const races = nodesOf(idx, "Race");
+        const findings = [];
+        const raceUuids = new Set(races.map((r) => attr(r.node, "UUID")).filter((v) => !!v));
+        for (const ref of races) {
+            const name = attr(ref.node, "Name") ?? "?";
+            for (const field of RACE_BLOCK_FIELDS) {
+                if (!attr(ref.node, field)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "block",
+                        file: ref.file,
+                        message: `Race "${name}" is missing required field "${field}".`,
+                        fix: `Add ${field} to the Race node.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+            for (const field of RACE_WARN_FIELDS) {
+                if (!attr(ref.node, field)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: ref.file,
+                        message: `Race "${name}" is missing recommended field "${field}".`,
+                        fix: `Add ${field} to the Race node.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        if (raceUuids.size > 0) {
+            for (const ref of nodesOf(idx, "GameObjects")) {
+                const race = attr(ref.node, "Race");
+                if (!race)
+                    continue;
+                if (!raceUuids.has(race)) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "block",
+                        file: ref.file,
+                        message: `RootTemplate "${attr(ref.node, "MapKey") ?? "?"}"'s Race attribute "${race}" does not match any Race UUID this mod defines.`,
+                        fix: `Set Race to one of this mod's Race UUIDs, or remove the attribute if this template inherits its race via ParentTemplateId.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+function decodeVersion64(raw) {
+    let v;
+    try {
+        v = BigInt(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (v < 0n)
+        return undefined;
+    return { major: v >> 55n, minor: (v >> 47n) & 0xffn, revision: (v >> 31n) & 0xffffn, build: v & 0x7fffffffn };
+}
+const metaVersion64 = {
+    id: "bg3.progression.meta-version64",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["class", "subclass", "race", "feat", "packaging"],
+    summary: "meta.lsx's Version64 decodes to a plausible tuple and agrees with modwright.json's version.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over meta.lsx's ModuleInfo/Version64",
+    needs: { project: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: ["bg3.encoding.version64-format"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const findings = [];
+        const declaredVersion = ctx.project.project.version;
+        for (const ref of nodesOf(idx, "ModuleInfo")) {
+            const raw = attr(ref.node, "Version64");
+            if (!raw)
+                continue;
+            const decoded = decodeVersion64(raw);
+            if (!decoded) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "warn",
+                    file: ref.file,
+                    message: `meta.lsx Version64="${raw}" does not decode to a plausible (major,minor,revision,build) tuple.`,
+                    fix: `Encode Version64 as (major<<55)|(minor<<47)|(revision<<31)|build.`,
+                    evidence: this.evidence,
+                });
+                continue;
+            }
+            if (!declaredVersion)
+                continue;
+            const parts = declaredVersion.split(".").map((p) => Number(p));
+            if (parts.length < 3 || parts.slice(0, 3).some((p) => Number.isNaN(p)))
+                continue;
+            const [major, minor, revision] = parts;
+            if (BigInt(major) !== decoded.major || BigInt(minor) !== decoded.minor || BigInt(revision) !== decoded.revision) {
+                findings.push({
+                    validatorId: this.id,
+                    severity: "warn",
+                    file: ref.file,
+                    message: `meta.lsx Version64="${raw}" decodes to ${decoded.major}.${decoded.minor}.${decoded.revision}.${decoded.build}, ` +
+                        `which disagrees with modwright.json's version "${declaredVersion}" in major/minor/revision.`,
+                    fix: `Re-encode Version64 for ${major}.${minor}.${revision}.<build>, or update modwright.json's version.`,
+                    evidence: this.evidence,
+                });
+            }
+        }
+        return findings;
+    },
+};
+const noRemovespells = {
+    id: "bg3.progression.no-removespells",
+    game: GAME,
+    groups: ["progression"],
+    modTypes: ["race", "class", "subclass", "feat"],
+    summary: "RemoveSpells has no vanilla precedent; flag it rather than assume it works.",
+    appliesTo: (target) => isProjectTarget(target),
+    appliesToDescription: "once per project, over every Progression node's Selectors/Boosts",
+    needs: { project: true },
+    cost: "edit",
+    severity: "warn",
+    evidence: ["bg3.progressions.no-spell-replacement-idiom"],
+    async run(ctx) {
+        const idx = await collectProjectLsx(ctx);
+        const findings = [];
+        for (const ref of nodesOf(idx, "Progression")) {
+            for (const field of ["Selectors", "Boosts"]) {
+                const value = attr(ref.node, field);
+                if (value?.includes("RemoveSpells(")) {
+                    findings.push({
+                        validatorId: this.id,
+                        severity: "warn",
+                        file: ref.file,
+                        message: `Progression "${attr(ref.node, "Name") ?? "?"}"'s ${field} uses RemoveSpells(...), which has zero ` +
+                            `occurrences across the vanilla stats + progressions extract — there is no in-progression spell-` +
+                            `replacement idiom; ship the upgrade additively instead.`,
+                        fix: `Grant the replacement additively (keep the original spell) instead of using RemoveSpells.`,
+                        evidence: this.evidence,
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+export const PROGRESSION_VALIDATORS = [
+    tableuuidMatchesOwner,
+    level1NodePresent,
+    typeMatchesOwner,
+    subclassRegisteredInParent,
+    spelllistSelectorResolves,
+    spelllistMembersExist,
+    passivesExist,
+    addspellsArgSlots,
+    classAnchorDescription,
+    actionresourceDefined,
+    raceRequiredFields,
+    metaVersion64,
+    noRemovespells,
+];