@alpaca-software/40kdc-data 0.1.0

package/dist/generated.js

@@ -0,0 +1,2 @@
+/* Generated from crates/wh40kdc/schemas/bundled.schema.json by 'npm run codegen:types'. DO NOT EDIT BY HAND. */
+export {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./data/index.js";
+export * from "./generated.js";
+export { createValidator, findSchemaFiles, listSchemaIds, SCHEMAS_ROOT, } from "./schema-loader.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+// The linked, typed dataset — the primary entry point.
+export * from "./data/index.js";
+// Generated types for every entity in the dataset.
+export * from "./generated.js";
+// Schema access + AJV validation (secondary: this package also validates data
+// against the canonical JSON Schemas).
+export { createValidator, findSchemaFiles, listSchemaIds, SCHEMAS_ROOT, } from "./schema-loader.js";

package/dist/known-support-10e.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Canonical registry of 10e units carrying the "additional leader" / "second
+ * leader" attachment rule — characters that can attach to a unit even when
+ * another Leader (e.g. Captain, Chapter Master, Lieutenant) is already
+ * attached. In 11e this is formalised as `attachment_role: "support"`.
+ *
+ * The registry has two layers:
+ *
+ *   1. **`FROM_UPSTREAM_SCRAPE`** — derived deterministically from army-assist
+ *      `Datasheets.json` by scanning `leader_head` for the canonical phrasing
+ *      (/already been attached|additional leader|attach this model.*even if/i)
+ *      and resolving each datasheet name to our kebab-case unit id via the
+ *      10e-archive's `data/core/<faction>/units.json` name table.
+ *      shadowboxing's `assets/Datasheets.json` yields the same 40 names.
+ *
+ *   2. **`MANUAL_OVERLAY`** — units whose 10e "additional leader" rule is
+ *      *not* captured by either upstream scraper (data-gap entries) plus
+ *      non-character special cases. Each entry needs a one-line comment
+ *      naming the SME source so the gap is auditable. This layer is the
+ *      reason 40kdc-data exists as a canonical upstream.
+ *
+ * The exported `KNOWN_SUPPORT_10E` is the merged view. To refresh layer 1,
+ * re-run the scan recipe documented above. To add a missing unit (layer 2),
+ * edit `MANUAL_OVERLAY` with a comment justifying the entry.
+ *
+ * Treat every entry as a **proposal** until human review confirms. The port
+ * emits a warning if a registry entry doesn't match an archive unit.
+ */
+export declare const KNOWN_SUPPORT_10E: Record<string, readonly string[]>;
+/** Flatten the registry to faction-prefixed ids for set membership tests. */
+export declare function knownSupportSet(): Set<string>;

package/dist/known-support-10e.js

@@ -0,0 +1,113 @@
+/**
+ * Canonical registry of 10e units carrying the "additional leader" / "second
+ * leader" attachment rule — characters that can attach to a unit even when
+ * another Leader (e.g. Captain, Chapter Master, Lieutenant) is already
+ * attached. In 11e this is formalised as `attachment_role: "support"`.
+ *
+ * The registry has two layers:
+ *
+ *   1. **`FROM_UPSTREAM_SCRAPE`** — derived deterministically from army-assist
+ *      `Datasheets.json` by scanning `leader_head` for the canonical phrasing
+ *      (/already been attached|additional leader|attach this model.*even if/i)
+ *      and resolving each datasheet name to our kebab-case unit id via the
+ *      10e-archive's `data/core/<faction>/units.json` name table.
+ *      shadowboxing's `assets/Datasheets.json` yields the same 40 names.
+ *
+ *   2. **`MANUAL_OVERLAY`** — units whose 10e "additional leader" rule is
+ *      *not* captured by either upstream scraper (data-gap entries) plus
+ *      non-character special cases. Each entry needs a one-line comment
+ *      naming the SME source so the gap is auditable. This layer is the
+ *      reason 40kdc-data exists as a canonical upstream.
+ *
+ * The exported `KNOWN_SUPPORT_10E` is the merged view. To refresh layer 1,
+ * re-run the scan recipe documented above. To add a missing unit (layer 2),
+ * edit `MANUAL_OVERLAY` with a comment justifying the entry.
+ *
+ * Treat every entry as a **proposal** until human review confirms. The port
+ * emits a warning if a registry entry doesn't match an archive unit.
+ */
+/** Layer 1 — derived from army-assist (and confirmed against shadowboxing). */
+const FROM_UPSTREAM_SCRAPE = {
+    "adepta-sororitas": ["dialogus", "dogmata", "hospitaller", "imagifier", "ministorum-priest"],
+    // Successor chapters share these units via `parent_faction_id`, so
+    // chapter-specific variants like `crusade-ancient` (Black Templars) live
+    // under adeptus-astartes.
+    "adeptus-astartes": [
+        "ancient",
+        "ancient-in-terminator-armour",
+        "apothecary",
+        "apothecary-biologis",
+        "bladeguard-ancient",
+        "castellan",
+        "cato-sicarius",
+        "crusade-ancient",
+        "imperial-space-marine",
+        "lieutenant",
+        "lieutenant-in-phobos-armour",
+        "lieutenant-in-reiver-armour",
+        "sanguinary-priest",
+    ],
+    "adeptus-mechanicus": ["cybernetica-datasmith"],
+    "aeldari": ["eldrad-ulthran", "the-visarch", "warlock"],
+    "agents-of-the-imperium": ["ministorum-priest"],
+    "astra-militarum": ["death-rider-commissar", "ministorum-priest"],
+    "chaos-space-marines": ["master-of-executions"],
+    "death-guard": [
+        "biologus-putrifier",
+        "foul-blightspawn",
+        "icon-bearer",
+        "noxious-blightbringer",
+        "plague-surgeon",
+        "tallyman",
+    ],
+    "genestealer-cults": ["biophagus", "clamavus", "locus", "nexos"],
+    "necrons": [
+        "chronomancer",
+        "geomancer",
+        "orikan-the-diviner",
+        "plasmancer",
+        "psychomancer",
+        "technomancer",
+    ],
+    "world-eaters": ["master-of-executions"],
+};
+/** Layer 2 — units the upstream scrape misses, plus non-character special cases. */
+const MANUAL_OVERLAY = {
+    // All three Kroot Shapers carry the additional-leader rule in the GW
+    // datasheet, but their `leader_head` in both army-assist and shadowboxing
+    // contains only the basic attachment list — the co-attach phrasing was
+    // dropped by both community scrapes. (Ethereal is *not* a co-attach Leader;
+    // confirmed not missing from the scrape.)
+    "tau-empire": ["kroot-flesh-shaper", "kroot-trail-shaper", "kroot-war-shaper"],
+    // Cryptothralls is a non-character bodyguard unit that joins a Cryptek-led
+    // unit. In 10e the co-attach Leader rule sits on the Cryptek datasheets
+    // (covered by layer 1); cryptothralls is included here for the 11e
+    // Support-pattern review since it's the "joiner" entity. May need a
+    // non-character Support encoding in 11e (`attachment_role` semantically
+    // expects a character).
+    "necrons": ["cryptothralls"],
+};
+/** Merge layers 1 and 2 into the public registry. */
+function mergeLayers() {
+    const merged = {};
+    for (const [faction, ids] of Object.entries(FROM_UPSTREAM_SCRAPE)) {
+        merged[faction] = [...ids];
+    }
+    for (const [faction, ids] of Object.entries(MANUAL_OVERLAY)) {
+        merged[faction] = [...(merged[faction] ?? []), ...ids];
+    }
+    // Sort each list so output order is stable across re-runs.
+    for (const faction of Object.keys(merged))
+        merged[faction].sort();
+    return merged;
+}
+export const KNOWN_SUPPORT_10E = mergeLayers();
+/** Flatten the registry to faction-prefixed ids for set membership tests. */
+export function knownSupportSet() {
+    const set = new Set();
+    for (const [faction, ids] of Object.entries(KNOWN_SUPPORT_10E)) {
+        for (const id of ids)
+            set.add(`${faction}:${id}`);
+    }
+    return set;
+}

package/dist/port-10e-faction.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Port 10e archive faction data forward as an 11e provisional seed (Section 6).
+ *
+ * Usage:
+ *   npx tsx tools/src/port-10e-faction.ts <faction-id>
+ *   npx tsx tools/src/port-10e-faction.ts --all
+ *
+ * Reads data/{core,enrichment}/<faction>/*.json from the `10e-archive` ref,
+ * applies the per-entity 11e transforms, writes the result into the working
+ * tree, emits a per-faction audit under data/_port-audit/, and validates the
+ * output against the (bumped) schemas. Exits non-zero on validation failure.
+ *
+ * Distinct from convert-faction.ts (the army-assist bootstrap); this script is
+ * purpose-built for the archive→11e port and reads only from the git archive.
+ */
+/** The provisional 11e dataslate every ported entity is stamped with. */
+export declare const TARGET_GAME_VERSION: {
+    edition: string;
+    dataslate: string;
+};
+type Json = any;
+export interface AuditItem {
+    category: string;
+    entity_type: string;
+    entity_id: string;
+    detail: string;
+}
+/** Faction directory names present under data/core/ on the archive ref. */
+export declare function archiveFactions(): string[];
+/** Ability ids granted via `ability-grant` whose id mentions cover. */
+export declare function coverGrants(effect: Json): string[];
+/** Charge/Fights-First effect types 11e may make redundant. */
+export declare function chargeTimingTypes(effect: Json): string[];
+/** True if any string value equals the 10e engagement-range constant (1"). */
+export declare function referencesOneInch(entity: Json): boolean;
+/** Stamp the provisional 11e game_version onto an entity. */
+export declare function bump(entity: Json): Json;
+/**
+ * units.json: bump, mark points provisional, set attachment_role.
+ *
+ * Precedence: a unit in `supportIds` (curated registry) becomes `"support"`,
+ * even if it isn't a leader_id (the cryptothralls case — non-character joiner).
+ * Otherwise, a `leader_id` becomes `"leader"`. Non-attaching units get no role.
+ */
+export declare function portUnit(unit: Json, leaderIds: Set<string>, supportIds: Set<string>): Json;
+/** enhancements.json: bump, mark provisional, default-fill upgrade_tag/max_targets. */
+export declare function portEnhancement(enh: Json): Json;
+/** detachments.json: bump, default-fill detachment_points/force_dispositions. */
+export declare function portDetachment(det: Json): Json;
+/** leader-attachments.json: drop the retired max_leaders_per_unit, then bump. */
+export declare function portLeaderAttachment(la: Json): Json;
+export {};

package/dist/port-10e-faction.js

@@ -0,0 +1,413 @@
+/**
+ * Port 10e archive faction data forward as an 11e provisional seed (Section 6).
+ *
+ * Usage:
+ *   npx tsx tools/src/port-10e-faction.ts <faction-id>
+ *   npx tsx tools/src/port-10e-faction.ts --all
+ *
+ * Reads data/{core,enrichment}/<faction>/*.json from the `10e-archive` ref,
+ * applies the per-entity 11e transforms, writes the result into the working
+ * tree, emits a per-faction audit under data/_port-audit/, and validates the
+ * output against the (bumped) schemas. Exits non-zero on validation failure.
+ *
+ * Distinct from convert-faction.ts (the army-assist bootstrap); this script is
+ * purpose-built for the archive→11e port and reads only from the git archive.
+ */
+import { execFileSync } from "node:child_process";
+import { writeFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { resolve, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createValidator } from "./schema-loader.js";
+import { validateFiles } from "./validate.js";
+import { KNOWN_SUPPORT_10E } from "./known-support-10e.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "../..");
+const ARCHIVE_REF = "10e-archive";
+const AUDIT_DIR = "data/_port-audit";
+/** The provisional 11e dataslate every ported entity is stamped with. */
+export const TARGET_GAME_VERSION = { edition: "11th", dataslate: "pre-launch-provisional" };
+const ENTITY_ID_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+// ─── git archive access ──────────────────────────────────────────────
+function git(args) {
+    return execFileSync("git", args, {
+        cwd: ROOT,
+        encoding: "utf-8",
+        maxBuffer: 256 * 1024 * 1024,
+    });
+}
+/** Faction directory names present under data/core/ on the archive ref. */
+export function archiveFactions() {
+    const out = git(["ls-tree", "-d", "--name-only", ARCHIVE_REF, "data/core/"]);
+    return out
+        .split("\n")
+        .map((l) => basename(l.trim()))
+        .filter((f) => f && f !== "_example")
+        .sort();
+}
+/** JSON files present for a faction in a data area on the archive ref. */
+function archiveFiles(area, faction) {
+    let out;
+    try {
+        out = git(["ls-tree", "-r", "--name-only", ARCHIVE_REF, `data/${area}/${faction}`]);
+    }
+    catch {
+        return [];
+    }
+    return out
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((p) => p.endsWith(".json"));
+}
+function readArchiveJSON(path) {
+    return JSON.parse(git(["show", `${ARCHIVE_REF}:${path}`]));
+}
+function archiveSha() {
+    return git(["rev-parse", ARCHIVE_REF]).trim();
+}
+// ─── DSL inspection helpers ──────────────────────────────────────────
+/** Collect every `type` string found anywhere in a DSL subtree. */
+function collectTypes(node, acc) {
+    if (Array.isArray(node)) {
+        for (const v of node)
+            collectTypes(v, acc);
+    }
+    else if (node && typeof node === "object") {
+        if (typeof node.type === "string")
+            acc.push(node.type);
+        for (const v of Object.values(node))
+            collectTypes(v, acc);
+    }
+}
+/** Ability ids granted via `ability-grant` whose id mentions cover. */
+export function coverGrants(effect) {
+    const hits = [];
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            for (const v of node)
+                walk(v);
+        }
+        else if (node && typeof node === "object") {
+            if (node.type === "ability-grant") {
+                const aid = String(node.modifier?.ability_id ?? "");
+                if (aid.toLowerCase().includes("cover"))
+                    hits.push(aid);
+            }
+            for (const v of Object.values(node))
+                walk(v);
+        }
+    };
+    walk(effect);
+    return [...new Set(hits)];
+}
+/** Charge/Fights-First effect types 11e may make redundant. */
+export function chargeTimingTypes(effect) {
+    const types = [];
+    collectTypes(effect, types);
+    return [...new Set(types.filter((t) => t === "fight-first" || t === "charged-this-turn"))];
+}
+/** True if any string value equals the 10e engagement-range constant (1"). */
+export function referencesOneInch(entity) {
+    let found = false;
+    const walk = (node) => {
+        if (found)
+            return;
+        if (Array.isArray(node)) {
+            for (const v of node)
+                walk(v);
+        }
+        else if (node && typeof node === "object") {
+            for (const v of Object.values(node))
+                walk(v);
+        }
+        else if (typeof node === "string" && node.trim() === '1"') {
+            found = true;
+        }
+    };
+    walk(entity);
+    return found;
+}
+// ─── per-entity transforms (pure) ────────────────────────────────────
+/** Stamp the provisional 11e game_version onto an entity. */
+export function bump(entity) {
+    return { ...entity, game_version: { ...TARGET_GAME_VERSION } };
+}
+/**
+ * units.json: bump, mark points provisional, set attachment_role.
+ *
+ * Precedence: a unit in `supportIds` (curated registry) becomes `"support"`,
+ * even if it isn't a leader_id (the cryptothralls case — non-character joiner).
+ * Otherwise, a `leader_id` becomes `"leader"`. Non-attaching units get no role.
+ */
+export function portUnit(unit, leaderIds, supportIds) {
+    const out = bump(unit);
+    out.points_provisional = true;
+    if (supportIds.has(unit.id)) {
+        out.attachment_role = "support";
+    }
+    else if (leaderIds.has(unit.id)) {
+        out.attachment_role = "leader";
+    }
+    return out;
+}
+/** enhancements.json: bump, mark provisional, default-fill upgrade_tag/max_targets. */
+export function portEnhancement(enh) {
+    const out = bump(enh);
+    out.points_provisional = true;
+    if (out.upgrade_tag === undefined)
+        out.upgrade_tag = false;
+    if (out.max_targets === undefined)
+        out.max_targets = 1;
+    return out;
+}
+/** detachments.json: bump, default-fill detachment_points/force_dispositions. */
+export function portDetachment(det) {
+    const out = bump(det);
+    if (out.detachment_points === undefined)
+        out.detachment_points = null;
+    if (out.force_dispositions === undefined)
+        out.force_dispositions = [];
+    return out;
+}
+/** leader-attachments.json: drop the retired max_leaders_per_unit, then bump. */
+export function portLeaderAttachment(la) {
+    const { max_leaders_per_unit: _drop, ...rest } = la;
+    void _drop;
+    return bump(rest);
+}
+function transformCore(name, entities, leaderIds, supportIds) {
+    switch (name) {
+        case "units.json":
+            return entities.map((u) => portUnit(u, leaderIds, supportIds));
+        case "enhancements.json":
+            return entities.map(portEnhancement);
+        case "detachments.json":
+            return entities.map(portDetachment);
+        case "leader-attachments.json":
+            return entities.map(portLeaderAttachment);
+        default:
+            // factions, weapons, unit-compositions, stratagems — bump only
+            return entities.map(bump);
+    }
+}
+function writeJSON(rel, data) {
+    const out = resolve(ROOT, rel);
+    mkdirSync(dirname(out), { recursive: true });
+    writeFileSync(out, JSON.stringify(data, null, 2) + "\n");
+}
+function portFaction(faction) {
+    if (!ENTITY_ID_RE.test(faction)) {
+        throw new Error(`Invalid faction id: ${JSON.stringify(faction)}`);
+    }
+    const core = {};
+    for (const path of archiveFiles("core", faction))
+        core[basename(path)] = readArchiveJSON(path);
+    if (Object.keys(core).length === 0) {
+        throw new Error(`No core data for faction '${faction}' on ${ARCHIVE_REF}`);
+    }
+    const enrichment = {};
+    for (const path of archiveFiles("enrichment", faction)) {
+        enrichment[basename(path)] = readArchiveJSON(path);
+    }
+    const leaderIds = new Set((core["leader-attachments.json"] ?? []).map((e) => e.leader_id));
+    const supportIds = new Set(KNOWN_SUPPORT_10E[faction] ?? []);
+    const items = [];
+    const written = [];
+    // Warn before the port runs if a registry entry doesn't match an archive
+    // unit — silent typos would otherwise mean the role is never applied.
+    const unitIds = new Set((core["units.json"] ?? []).map((u) => u.id));
+    for (const candidateId of supportIds) {
+        if (!unitIds.has(candidateId)) {
+            console.warn(`  ⚠ ${faction}: support registry lists '${candidateId}' but no such unit in archive`);
+        }
+    }
+    // Core files.
+    for (const [name, entities] of Object.entries(core)) {
+        const out = transformCore(name, entities, leaderIds, supportIds);
+        const rel = `data/core/${faction}/${name}`;
+        writeJSON(rel, out);
+        written.push(rel);
+    }
+    // Record an audit entry per unit the registry assigned `attachment_role:
+    // "support"` to — both as a visible roster of the call and so summary.md
+    // surfaces the list for review.
+    for (const candidateId of supportIds) {
+        if (!unitIds.has(candidateId))
+            continue;
+        items.push({
+            category: "support-assigned",
+            entity_type: "unit",
+            entity_id: candidateId,
+            detail: `Assigned attachment_role: "support" from the curated registry. To revert, remove from tools/src/known-support-10e.ts and re-run the port.`,
+        });
+    }
+    // Enrichment files + ability audits.
+    for (const [name, entities] of Object.entries(enrichment)) {
+        if (name === "abilities.json") {
+            for (const a of entities) {
+                const cover = coverGrants(a.effect ?? {});
+                if (cover.length) {
+                    items.push({
+                        category: "cover-ability",
+                        entity_type: "ability",
+                        entity_id: a.ability_id,
+                        detail: `Grants ${cover.join(", ")}; 11e cover is −1 BS (not +1 Sv) — re-check the granted ability's definition.`,
+                    });
+                }
+                const charge = chargeTimingTypes(a.effect ?? {});
+                if (charge.length) {
+                    items.push({
+                        category: "charge-timing",
+                        entity_type: "ability",
+                        entity_id: a.ability_id,
+                        detail: `Uses ${charge.join(", ")}; 11e charging grants Fights First by default — check for redundancy.`,
+                    });
+                }
+                if (referencesOneInch(a)) {
+                    items.push({
+                        category: "engagement-range",
+                        entity_type: "ability",
+                        entity_id: a.ability_id,
+                        detail: `References 1"; 11e engagement range is 2" — confirm intent.`,
+                    });
+                }
+            }
+        }
+        const rel = `data/enrichment/${faction}/${name}`;
+        writeJSON(rel, entities.map(bump));
+        written.push(rel);
+    }
+    // Bulk-review categories: every detachment / stratagem needs human work later.
+    const bulkReview = {};
+    if (core["detachments.json"]) {
+        bulkReview["detachment-disposition"] = core["detachments.json"].map((d) => d.id);
+    }
+    if (core["stratagems.json"]) {
+        bulkReview["stratagem-type"] = core["stratagems.json"].length;
+    }
+    const summary = {};
+    for (const it of items)
+        summary[it.category] = (summary[it.category] ?? 0) + 1;
+    writeJSON(`${AUDIT_DIR}/${faction}.json`, {
+        faction,
+        ported_from_ref: archiveSha(),
+        summary,
+        items,
+        bulk_review: bulkReview,
+    });
+    return { faction, written, summary };
+}
+/** Rebuild summary.md from every per-faction audit json currently on disk. */
+function regenerateSummary() {
+    const dir = resolve(ROOT, AUDIT_DIR);
+    const audits = readdirSync(dir)
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => JSON.parse(readFileSync(resolve(dir, f), "utf-8")))
+        .sort((a, b) => a.faction.localeCompare(b.faction));
+    const itemsOf = (a, category) => a.items.filter((i) => i.category === category);
+    const lines = [
+        "# 10e → 11e port — audit queue",
+        "",
+        "Generated by `tools/src/port-10e-faction.ts`. Each item below needs human",
+        "review before the provisional seed is treated as confirmed 11e data.",
+        "",
+    ];
+    // Flat roster of units the port assigned attachment_role: "support".
+    lines.push("## Support — assigned by the port");
+    lines.push("");
+    lines.push("The units below were written with `attachment_role: \"support\"` by the port,", "sourced from the curated 10e \"additional leader\" registry", "(`tools/src/known-support-10e.ts`).", "", "To **revert** any entry: remove the id from the registry and re-run", "`npx tsx tools/src/port-10e-faction.ts --all`. The port is the durable", "source of truth — don't hand-edit `attachment_role` in faction units.json.", "");
+    const assigned = audits.flatMap((a) => itemsOf(a, "support-assigned").map((i) => ({ faction: a.faction, id: i.entity_id })));
+    for (const c of assigned) {
+        lines.push(`- \`${c.faction}\` / **${c.id}**`);
+    }
+    lines.push("", `_${assigned.length} units assigned._`, "");
+    // Per-faction detail with names for the other discretionary flags.
+    lines.push("## Per-faction detail", "");
+    for (const a of audits) {
+        const cover = itemsOf(a, "cover-ability").map((i) => i.entity_id);
+        const charge = itemsOf(a, "charge-timing").map((i) => i.entity_id);
+        const engage = itemsOf(a, "engagement-range").map((i) => i.entity_id);
+        const support = itemsOf(a, "support-assigned").map((i) => i.entity_id);
+        const dets = a.bulk_review["detachment-disposition"] ?? [];
+        const strats = a.bulk_review["stratagem-type"] ?? 0;
+        if (!cover.length && !charge.length && !engage.length && !support.length && !dets.length && !strats) {
+            continue;
+        }
+        lines.push(`### ${a.faction}`, "");
+        if (support.length)
+            lines.push(`- Support candidates: ${fmtIds(support)}`);
+        if (cover.length)
+            lines.push(`- Cover abilities (rework \`benefit-of-cover\` → −1 BS): ${fmtIds(cover)}`);
+        if (charge.length)
+            lines.push(`- Charge-timing / Fights First (check redundancy): ${fmtIds(charge)}`);
+        if (engage.length)
+            lines.push(`- Engagement-range (1" → 2"): ${fmtIds(engage)}`);
+        if (dets.length)
+            lines.push(`- Detachments needing DP + Force Disposition assignment (${dets.length}): ${fmtIds(dets)}`);
+        if (strats)
+            lines.push(`- Stratagems pending 11e type-enum reconciliation: ${strats}`);
+        lines.push("");
+    }
+    const out = resolve(ROOT, `${AUDIT_DIR}/summary.md`);
+    mkdirSync(dirname(out), { recursive: true });
+    writeFileSync(out, lines.join("\n") + "\n");
+}
+/** Render a list of ids as inline-code, comma-separated. */
+function fmtIds(ids) {
+    return ids.map((i) => `\`${i}\``).join(", ");
+}
+async function validateFaction(faction) {
+    const ajv = createValidator();
+    const core = await validateFiles(ajv, `core/${faction}/**/*.json`);
+    const enrich = await validateFiles(ajv, `enrichment/${faction}/**/*.json`);
+    const failed = core.failed + enrich.failed;
+    if (failed) {
+        for (const e of [...core.errors, ...enrich.errors]) {
+            const where = e.index >= 0 ? `[${e.index}]` : "";
+            console.error(`    ✗ ${basename(e.file)}${where}: ${e.errors.map((x) => `${x.path} ${x.message}`).join("; ")}`);
+        }
+    }
+    return failed;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === "--help") {
+        console.log("Usage: npx tsx tools/src/port-10e-faction.ts <faction-id>");
+        console.log("       npx tsx tools/src/port-10e-faction.ts --all");
+        console.log("       npx tsx tools/src/port-10e-faction.ts --summary  (rebuild audit summary only)");
+        process.exit(args[0] === "--help" ? 0 : 1);
+    }
+    if (args[0] === "--summary") {
+        regenerateSummary();
+        console.log(`Rebuilt ${AUDIT_DIR}/summary.md`);
+        return;
+    }
+    const factions = args[0] === "--all" ? archiveFactions() : [args[0]];
+    let totalFailed = 0;
+    for (const faction of factions) {
+        console.log(`\n▶ porting ${faction}`);
+        const res = portFaction(faction);
+        for (const w of res.written)
+            console.log(`  ✓ ${w}`);
+        const failed = await validateFaction(faction);
+        if (failed) {
+            console.error(`  ✗ ${faction}: ${failed} validation failure(s)`);
+            totalFailed += failed;
+        }
+        else {
+            const cats = Object.entries(res.summary).map(([k, v]) => `${k}=${v}`).join(", ");
+            console.log(`  ✓ ${faction} validates (audit: ${cats || "none"})`);
+        }
+    }
+    regenerateSummary();
+    console.log(`\n${factions.length} faction(s) ported. Audit queue: ${AUDIT_DIR}/summary.md`);
+    if (totalFailed)
+        process.exit(1);
+}
+const isMain = process.argv[1] &&
+    resolve(process.argv[1]).replace(/\.\w+$/, "") === fileURLToPath(import.meta.url).replace(/\.\w+$/, "");
+if (isMain) {
+    main().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/report.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationResult } from "./validate.js";
+export type ReporterMode = "pretty" | "json";
+export declare function formatReport(result: ValidationResult, mode: ReporterMode): string;

package/dist/report.js

@@ -0,0 +1,31 @@
+import chalk from "chalk";
+export function formatReport(result, mode) {
+    if (mode === "json") {
+        return JSON.stringify(result, null, 2);
+    }
+    const lines = [];
+    lines.push("");
+    lines.push(chalk.bold("40kdc Data Validation Report"));
+    lines.push(chalk.gray("─".repeat(40)));
+    lines.push(`Files scanned:  ${result.totalFiles}`);
+    lines.push(`Items validated: ${result.totalItems}`);
+    lines.push(chalk.green(`Passed: ${result.passed}`));
+    if (result.failed > 0) {
+        lines.push(chalk.red(`Failed: ${result.failed}`));
+        lines.push("");
+        for (const err of result.errors) {
+            const loc = err.index >= 0 ? `[${err.index}]` : "";
+            lines.push(chalk.red(`  ✗ ${err.file}${loc}`));
+            for (const e of err.errors) {
+                lines.push(chalk.yellow(`    ${e.path}: ${e.message}`));
+            }
+        }
+    }
+    else {
+        lines.push(chalk.green(`Failed: 0`));
+        lines.push("");
+        lines.push(chalk.green("All validations passed."));
+    }
+    lines.push("");
+    return lines.join("\n");
+}