@alpaca-software/40kdc-data 0.1.0

package/README.md

@@ -0,0 +1,78 @@
+# @alpaca-software/40kdc-data
+
+The [40kdc](https://tabletop-developer-consortium.github.io) Warhammer 40,000
+dataset behind a **linked, typed API**. Find a unit, then walk straight to its
+weapons, abilities, the game phases those abilities act in, and its faction —
+all strongly typed, all resolved for you.
+
+The full dataset is embedded in the package, so there is no network call, no
+database, and no filesystem access at runtime. It works the same in Node,
+bundlers, and the browser.
+
+```ts
+import { units } from "@alpaca-software/40kdc-data";
+
+units.find("Kharn")!.abilities
+  .filter(a => a.phases.includes("shooting"))
+  .map(a => a.id); // ["berzerker-frenzy"]
+```
+
+## Install
+
+```bash
+npm install @alpaca-software/40kdc-data
+```
+
+## The shape
+
+Top-level collections (`units`, `weapons`, `factions`, `abilities`,
+`detachments`, `stratagems`, …) are accessors over a single embedded
+[`Dataset`](docs/api/data/classes/Dataset.md). Each collection is iterable and
+offers:
+
+| Method | Returns |
+| --- | --- |
+| `.all` | every record (deduplicated) |
+| `.get(id)` | one record by exact id |
+| `.find(nameOrId)` | first match by id or name |
+| `.findAll(nameOrId)` | every match (surfaces names shared across factions) |
+| `.byFaction(id)` | records belonging to a faction |
+
+Records resolve their links lazily:
+
+- `unit.faction`, `unit.weapons`, `unit.abilities`
+- `ability.phases` (joined from `phase-mappings`), `ability.units`
+- `weapon.units`
+- `faction.units`, `faction.abilities`, `faction.weapons`
+
+The full underlying record is always available via `.raw`.
+
+### Name matching is built for a global player base
+
+Warhammer 40,000 is played worldwide, and many names carry diacritics or
+punctuation — "Khârn the Betrayer", "T'au", "Be'lakor". `find`/`findAll` are
+diacritic- and punctuation-insensitive, so `find("Kharn")` resolves "Khârn the
+Betrayer" and `find("Belakor")` resolves "Be'lakor". The exact rule is exported
+as `normalizeName` so you can reproduce it in your own search UI.
+
+## API reference
+
+Auto-generated from the source: [`docs/api/`](docs/api/README.md).
+
+## Also: schema validation
+
+This package also ships the canonical JSON Schemas and an AJV-based validator
+(`createValidator`, `listSchemaIds`, and the `40kdc-validate` CLI) for checking
+data against them. See the repository root for schema details.
+
+## Licensing & attribution
+
+- Code (`tools/`): **MIT**.
+- Embedded enrichment data (`data/enrichment/`): **CC BY 4.0** —
+  attribution: *40kdc community contributors*
+  (<https://github.com/Tabletop-Developer-Consortium/40kdc-data>).
+- JSON Schemas: **CC0**.
+
+Stat lines and points are numerical facts. Ability and rules text are never
+stored — abilities are community-authored structured mechanics (the Ability
+DSL), not reproductions of copyrighted text.

package/dist/bundle-schemas.d.ts

@@ -0,0 +1,3 @@
+type JsonObject = Record<string, unknown>;
+export declare function bundle(): JsonObject;
+export {};

package/dist/bundle-schemas.js

@@ -0,0 +1,137 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { findSchemaFiles, SCHEMAS_ROOT } from "./schema-loader.js";
+/**
+ * Flattens the multi-file schema set into a single self-contained
+ * draft-2020-12 document, written to crates/wh40kdc/schemas/bundled.schema.json.
+ *
+ * Why a bespoke flattener rather than a ref-parser bundle: the Rust codegen
+ * (typify) wants one document where every type lives in a single flat `$defs`
+ * map — it resolves `$ref`s as `#/$defs/<name>` and does NOT traverse nested
+ * `$defs` paths. Generic bundlers also anchor a reused subschema to its first-use
+ * location (e.g. `#/$defs/faction/properties/id`), yielding junk Rust type names.
+ *
+ * So this pass hoists EVERY definition — `common.schema.json`'s shared defs, each
+ * entity schema (keyed by its filename stem), and every entity's local `$defs` —
+ * flat into one top-level `$defs`. All such names are globally unique across the
+ * schema set (asserted at build time), so no prefixing is needed and type names
+ * track the names authors actually chose.
+ *
+ * Refs are resolved against each schema's `$id` URL — not its filesystem path —
+ * because that is how the refs are authored (e.g. `../defs/common.schema.json`
+ * targets the `$id` `.../schemas/defs/...`, while the file lives in `$defs/`).
+ */
+const COMMON_ID = "https://40kdc.dev/schemas/defs/common.schema.json";
+const OUTPUT_PATH = resolve(SCHEMAS_ROOT, "../crates/wh40kdc/schemas/bundled.schema.json");
+const BUNDLE_ID = "https://40kdc.dev/schemas/bundled.schema.json";
+function stemOfId(id) {
+    return basename(new URL(id).pathname).replace(/\.schema\.json$/, "");
+}
+/**
+ * Rewrite a single `$ref` (resolved against the `$id` of the file it appears in)
+ * to a flat pointer into the bundle's top-level `$defs`.
+ *
+ * - any `#/$defs/<name>` pointer (file-local, common, or cross-file into a hoisted
+ *   local def) stays `#/$defs/<name>` — every such name is now top-level.
+ * - a whole-file ref (`effect.schema.json`) maps to that file's stem: `#/$defs/effect`.
+ */
+function rewriteRef(ref, sourceId) {
+    const hashIndex = ref.indexOf("#");
+    const filePart = hashIndex === -1 ? ref : ref.slice(0, hashIndex);
+    const pointer = hashIndex === -1 ? "" : ref.slice(hashIndex + 1); // e.g. "/$defs/entity-id"
+    if (pointer) {
+        if (!pointer.startsWith("/$defs/")) {
+            throw new Error(`unexpected non-$defs JSON pointer in $ref ${JSON.stringify(ref)} (source ${sourceId})`);
+        }
+        return `#${pointer}`;
+    }
+    // Whole-file ref: resolve to the target's $id and key by its stem.
+    const targetId = filePart ? new URL(filePart, sourceId).href : sourceId;
+    return `#/$defs/${stemOfId(targetId)}`;
+}
+/**
+ * Strip JSON Schema conditional applicators (`if`/`then`/`else`) from the codegen
+ * bundle. typify cannot model them — they express "field X is required when field
+ * Y has value Z", which has no Rust-type representation. The constraints are still
+ * enforced at data-validation time by ajv against the real (un-stripped) schemas;
+ * dropping them here only makes the affected fields optional in the generated Rust
+ * types, which is correct for deserializing any valid document.
+ */
+function stripConditionals(node) {
+    if (Array.isArray(node)) {
+        return node.map(stripConditionals);
+    }
+    if (node && typeof node === "object") {
+        const out = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "if" || key === "then" || key === "else")
+                continue;
+            out[key] = stripConditionals(value);
+        }
+        return out;
+    }
+    return node;
+}
+/** Recursively rewrite every `$ref` in `node`, knowing the source schema's `$id`. */
+function rewriteRefs(node, sourceId) {
+    if (Array.isArray(node)) {
+        return node.map((item) => rewriteRefs(item, sourceId));
+    }
+    if (node && typeof node === "object") {
+        const out = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "$ref" && typeof value === "string") {
+                out[key] = rewriteRef(value, sourceId);
+            }
+            else {
+                out[key] = rewriteRefs(value, sourceId);
+            }
+        }
+        return out;
+    }
+    return node;
+}
+export function bundle() {
+    const files = findSchemaFiles(SCHEMAS_ROOT).sort();
+    const defs = {};
+    const place = (name, def, sourceId) => {
+        if (name in defs) {
+            throw new Error(`definition name collision: ${name} (from ${sourceId})`);
+        }
+        defs[name] = stripConditionals(rewriteRefs(def, sourceId));
+    };
+    for (const file of files) {
+        const raw = JSON.parse(readFileSync(file, "utf-8"));
+        const id = raw.$id;
+        if (!id)
+            throw new Error(`schema missing $id: ${file}`);
+        const { $id: _id, $schema: _schema, $defs: localDefs, ...body } = raw;
+        // Hoist this file's local $defs flat to the top level (names are globally
+        // unique across the schema set; collisions throw above).
+        for (const [name, def] of Object.entries((localDefs ?? {}))) {
+            place(name, def, id);
+        }
+        // common is purely a $defs bag — it contributes no stem-keyed entity.
+        if (id !== COMMON_ID) {
+            place(stemOfId(id), body, id);
+        }
+    }
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        $id: BUNDLE_ID,
+        title: "40kdc Bundled Schemas",
+        description: "Auto-generated by tools/src/bundle-schemas.ts. Single self-contained schema for Rust codegen — do not edit by hand.",
+        $defs: defs,
+    };
+}
+function main() {
+    const result = bundle();
+    mkdirSync(dirname(OUTPUT_PATH), { recursive: true });
+    writeFileSync(OUTPUT_PATH, JSON.stringify(result, null, 2) + "\n", "utf-8");
+    const count = Object.keys(result.$defs).length;
+    console.log(`Bundled ${count} definitions → ${OUTPUT_PATH}`);
+}
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main();
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { validateCoreCommand } from "./commands/validate-core.js";
+import { validateEnrichmentCommand } from "./commands/validate-enrichment.js";
+import { validateAllCommand } from "./commands/validate-all.js";
+import { translateCommand } from "./commands/translate.js";
+const program = new Command();
+program
+    .name("40kdc-validate")
+    .description("Validate 40kdc data files against schemas")
+    .version("0.1.0");
+program
+    .command("validate-core")
+    .description("Validate core data files")
+    .option("--reporter <mode>", "Output format: pretty or json", "pretty")
+    .action(validateCoreCommand);
+program
+    .command("validate-enrichment")
+    .description("Validate enrichment data files")
+    .option("--reporter <mode>", "Output format: pretty or json", "pretty")
+    .action(validateEnrichmentCommand);
+program
+    .command("validate-all")
+    .description("Validate all data files")
+    .option("--reporter <mode>", "Output format: pretty or json", "pretty")
+    .action(validateAllCommand);
+program
+    .command("translate")
+    .description("Translate ability DSL to plain English")
+    .argument("[path]", "Path to abilities.json file")
+    .action(translateCommand);
+program.parse();

package/dist/codegen-data.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codegen-data.js

@@ -0,0 +1,128 @@
+/**
+ * Bundles every authored data file under `data/` into a single embedded module,
+ * `src/data/bundle.generated.ts`.
+ *
+ * The bundle is inlined as an escaped JSON *string* that is `JSON.parse`d at load
+ * time (mirroring the Rust crate's `include_str!`): tsc typechecks it instantly
+ * (it is just a string), it parses once at import, and it compiles into `dist`
+ * with no runtime filesystem access — so the published package works in Node,
+ * bundlers, and browsers alike, where `data/` is not shipped.
+ *
+ * Run via `npm run codegen:data`. The output is gitignored and regenerated on
+ * build/test/pack.
+ */
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { emptyRawData } from "./data/types.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, "../..");
+const DATA_ROOTS = [join(REPO_ROOT, "data", "core"), join(REPO_ROOT, "data", "enrichment")];
+const OUT_FILE = join(__dirname, "data", "bundle.generated.ts");
+/** Directory names that hold examples/scratch data and must never be bundled. */
+const EXCLUDED_DIRS = new Set(["_example", "_port-audit"]);
+/** Map a data file's base name (sans `.json`) to its `RawData` collection key. */
+const FILE_TO_COLLECTION = {
+    units: "units",
+    weapons: "weapons",
+    factions: "factions",
+    abilities: "abilities",
+    "phase-mappings": "phaseMappings",
+    detachments: "detachments",
+    stratagems: "stratagems",
+    enhancements: "enhancements",
+    "leader-attachments": "leaderAttachments",
+    "unit-compositions": "unitCompositions",
+    "wargear-options": "wargearOptions",
+    "game-versions": "gameVersions",
+    missions: "missions",
+    "mission-matchups": "missionMatchups",
+    "secondary-cards": "secondaryCards",
+    "deployment-patterns": "deploymentPatterns",
+    "force-dispositions": "forceDispositions",
+    "resource-pools": "resourcePools",
+    "timing-flags": "timingFlags",
+    "interaction-flags": "interactionFlags",
+};
+/** The id-bearing key for a collection, used only for duplicate-id reporting. */
+const ID_KEY = {
+    abilities: "ability_id",
+};
+/** Recursively collect bundleable `.json` files, skipping excluded dirs/examples. */
+function collectFiles(dir) {
+    const out = [];
+    for (const entry of readdirSync(dir)) {
+        if (EXCLUDED_DIRS.has(entry))
+            continue;
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            out.push(...collectFiles(full));
+        }
+        else if (entry.endsWith(".json") && !entry.endsWith(".example.json")) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+function baseName(file) {
+    return file.slice(file.lastIndexOf("/") + 1, -".json".length);
+}
+function build() {
+    const data = emptyRawData();
+    for (const root of DATA_ROOTS) {
+        for (const file of collectFiles(root)) {
+            const collection = FILE_TO_COLLECTION[baseName(file)];
+            if (!collection)
+                continue; // schema/scratch json we don't bundle
+            const parsed = JSON.parse(readFileSync(file, "utf-8"));
+            if (!Array.isArray(parsed)) {
+                throw new Error(`expected a JSON array in ${file}`);
+            }
+            data[collection].push(...parsed);
+        }
+    }
+    return data;
+}
+/** Warn (do not fail) on duplicate primary ids — a data-hygiene signal. */
+function reportDuplicateIds(data) {
+    for (const [collection, key] of Object.entries(ID_KEY)) {
+        const seen = new Set();
+        const dupes = new Set();
+        for (const item of data[collection]) {
+            const id = item[key];
+            if (id === undefined)
+                continue;
+            if (seen.has(id))
+                dupes.add(id);
+            else
+                seen.add(id);
+        }
+        if (dupes.size > 0) {
+            console.warn(`  ⚠ ${collection}: ${dupes.size} duplicate ${key}(s), e.g. ${[...dupes].slice(0, 3).join(", ")}`);
+        }
+    }
+}
+function emit(data) {
+    // JSON.stringify of the JSON text yields a valid, fully-escaped JS string
+    // literal — safe to drop straight into the generated source.
+    const jsonText = JSON.stringify(data);
+    const literal = JSON.stringify(jsonText);
+    return `/* GENERATED by 'npm run codegen:data' from the repository's data/ tree. DO NOT EDIT BY HAND. */
+import type { RawData } from "./types.js";
+
+const JSON_TEXT = ${literal};
+
+/** The full 40kdc dataset, embedded at build time and parsed once at load. */
+export const RAW_DATA: RawData = JSON.parse(JSON_TEXT) as RawData;
+`;
+}
+function main() {
+    const data = build();
+    reportDuplicateIds(data);
+    writeFileSync(OUT_FILE, emit(data));
+    const counts = Object.keys(data)
+        .map((k) => `${k}=${data[k].length}`)
+        .join(", ");
+    console.log(`Wrote ${OUT_FILE}\n  ${counts}`);
+}
+main();

package/dist/commands/translate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Translates ability DSL entries into plain English descriptions.
+ *
+ * Recursively walks the effect/condition tree and produces human-readable
+ * text purely from the structured data — no external text sources needed.
+ */
+export declare function translateCommand(path?: string): Promise<void>;

package/dist/commands/translate.js

@@ -0,0 +1,238 @@
+/**
+ * Translates ability DSL entries into plain English descriptions.
+ *
+ * Recursively walks the effect/condition tree and produces human-readable
+ * text purely from the structured data — no external text sources needed.
+ */
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+// ─── Condition translator ────────────────────────────────────────────
+function translateCondition(c) {
+    const negate = c.negated ? "not " : "";
+    // Compound conditions
+    if (c.operator === "and" && c.operands) {
+        const parts = c.operands.map(translateCondition);
+        return parts.join(" AND ");
+    }
+    if (c.operator === "or" && c.operands) {
+        const parts = c.operands.map(translateCondition);
+        return parts.join(" OR ");
+    }
+    if (c.operator === "not" && c.operands) {
+        return `NOT (${c.operands.map(translateCondition).join(", ")})`;
+    }
+    const p = c.parameters ?? {};
+    switch (c.type) {
+        case "phase-is":
+            return `${negate}during the ${p.phase} phase`;
+        case "timing-is":
+            return `${negate}at ${formatTiming(p.timing)}`;
+        case "player-turn-is":
+            return `${negate}in ${p.turn === "your-turn" ? "your" : p.turn === "opponent-turn" ? "opponent's" : "either player's"} turn`;
+        case "charged-this-turn":
+            return `${negate}unit charged this turn`;
+        case "advanced-this-turn":
+            return `${negate}unit advanced this turn`;
+        case "remained-stationary":
+            return `${negate}unit remained stationary`;
+        case "unit-below-starting-strength":
+            return `${negate}target is below starting strength`;
+        case "unit-below-half-strength":
+            return `${negate}target is below half strength`;
+        case "unit-has-keyword":
+            return `${negate}unit has "${p.keyword}"`;
+        case "target-has-keyword":
+            return `${negate}target has "${p.keyword}"`;
+        case "model-is-leader":
+            return `${negate}model is leading a unit`;
+        case "is-attached":
+            return `${negate}attached to a ${p.keyword ?? ""} unit`;
+        case "attack-is-type":
+            return `${negate}for ${p.attack_type} attacks`;
+        case "is-battle-shocked":
+            return `${negate}unit is battle-shocked`;
+        case "has-lost-wounds":
+            return `${negate}model has lost wounds`;
+        case "opponent-unit-within-range":
+            return `${negate}enemy unit within ${p.range === "engagement" ? "engagement range" : p.range + '"'}`;
+        case "unit-within-range-of":
+            return `${negate}within ${p.range}" of ${p.target_type ?? "target"}${p.keyword ? ` (${p.keyword})` : ""}`;
+        case "within-range-of-objective":
+            return `${negate}within range of an objective`;
+        case "controls-objective":
+            return `${negate}controlling an objective`;
+        case "has-fought-this-phase":
+            return `${negate}has fought this phase`;
+        case "destroyed-by-attack-type":
+            return `${negate}destroyed by ${p.attack_type} attack`;
+        default:
+            return `${negate}[${c.type ?? "unknown"}]`;
+    }
+}
+function formatTiming(t) {
+    return t.replace(/-/g, " ");
+}
+// ─── Effect translator ───────────────────────────────────────────────
+function translateEffect(e, depth = 0) {
+    const indent = "  ".repeat(depth);
+    const arrow = depth > 0 ? "→ " : "";
+    switch (e.type) {
+        case "conditional":
+            return (`${indent}If ${translateCondition(e.condition)}:\n` +
+                translateEffect(e.effect, depth + 1));
+        case "sequence":
+            return e
+                .steps.map((s) => translateEffect(s, depth))
+                .join("\n");
+        case "choice":
+            return (`${indent}${arrow}Choose one${e.choice_label ? ` (${e.choice_label})` : ""}:\n` +
+                e
+                    .options.map((o, i) => `${indent}  ${i + 1}. ${translateEffectInline(o)}`)
+                    .join("\n"));
+        case "dice-gated": {
+            const comp = formatComparison(e.comparison ?? "gte", e.threshold);
+            const success = e.on_success
+                ? translateEffectInline(e.on_success)
+                : "nothing";
+            const fail = e.on_fail
+                ? `, otherwise ${translateEffectInline(e.on_fail)}`
+                : "";
+            return `${indent}${arrow}Roll ${e.dice}: on ${comp}, ${success}${fail}`;
+        }
+        case "dice-pool-allocation": {
+            const poolStr = `${e.pool.count}${e.pool.die}`;
+            const lines = [`${indent}${arrow}Roll ${poolStr} (max ${e.max_activations} activations):`];
+            for (const opt of e.options) {
+                const req = opt.requirement;
+                lines.push(`${indent}  - ${opt.name}: need ${req.type} of ${req.min_value}+ → ${translateEffectInline(opt.effect)}`);
+            }
+            return lines.join("\n");
+        }
+        default:
+            return `${indent}${arrow}${translateEffectInline(e)}`;
+    }
+}
+/** Single-line translation for leaf effects. */
+function translateEffectInline(e) {
+    const m = e.modifier ?? {};
+    const target = formatTarget(e.target);
+    switch (e.type) {
+        case "stat-modifier": {
+            const op = m.operation === "add" ? "+" : m.operation === "subtract" ? "-" : `${m.operation} `;
+            const scope = m.attack_type ? ` (${m.attack_type})` : "";
+            return `${op}${m.value} ${m.stat}${scope} for ${target}`;
+        }
+        case "roll-modifier": {
+            const op = m.operation === "add" ? "+" : "-";
+            return `${op}${m.value} to ${m.roll} rolls for ${target}`;
+        }
+        case "re-roll":
+            return `re-roll ${m.roll}${m.value ? ` (${m.value}s)` : ""} for ${target}`;
+        case "mortal-wounds":
+            return `deal ${m.amount ?? m.amount_table ? "variable" : "?"} mortal wounds to ${target}`;
+        case "feel-no-pain":
+            return `${target} gains Feel No Pain ${m.threshold}+`;
+        case "keyword-grant":
+            return `${target}'s ${m.weapon_type ?? "all"} weapons gain ${m.keyword}`;
+        case "ability-grant":
+            return `${target} gains ${formatGrantType(m.grant_type)}`;
+        case "movement-modifier":
+            return `${target} gains ${m.move_type}${m.value ? ` ${m.value}"` : ""}`;
+        case "damage-reduction":
+            return `reduce incoming damage to ${target} by ${m.amount}`;
+        case "resurrection":
+            return `return ${m.count ?? 1} model(s) to ${target} with ${m.wounds_remaining ?? "full"} wounds`;
+        case "model-destruction":
+            return `destroy ${m.count} non-leader model(s) from ${target}`;
+        case "cp-gain":
+            return `gain ${m.amount} CP`;
+        case "cp-refund":
+            return `refund ${m.amount} CP`;
+        case "resource-gain":
+            return `gain ${m.amount} to ${m.pool_id}`;
+        case "resource-spend":
+            return `spend ${m.amount} from ${m.pool_id}`;
+        case "invulnerable-save":
+            return `${target} gains ${m.value}+ invulnerable save`;
+        case "leadership-modifier":
+            return `force battle-shock test on ${target}`;
+        case "fight-on-death":
+            return `${target} fights on death`;
+        case "shoot-on-death":
+            return `${target} shoots on death`;
+        case "fight-first":
+            return `${target} fights first`;
+        case "fight-last":
+            return `${target} fights last`;
+        case "deep-strike":
+            return `${target} can deep strike`;
+        case "fallback-and-act":
+            return `${target} can fall back and act`;
+        case "attack-restriction":
+            return `${target}: ${m.restriction_type ?? "restriction"} (max ${m.max_models ?? "?"} models)`;
+        case "objective-control-modifier":
+            return `modify OC of ${target} by ${m.value}`;
+        // Container types — recurse
+        case "conditional":
+            return `if ${translateCondition(e.condition)}: ${translateEffectInline(e.effect)}`;
+        case "sequence":
+            return e.steps.map(translateEffectInline).join("; ");
+        case "dice-gated": {
+            const comp = formatComparison(e.comparison ?? "gte", e.threshold);
+            return `roll ${e.dice} (${comp}): ${e.on_success ? translateEffectInline(e.on_success) : "nothing"}`;
+        }
+        default:
+            return `[${e.type}]`;
+    }
+}
+function formatTarget(t) {
+    if (!t)
+        return "target";
+    return t.replace(/-/g, " ");
+}
+function formatGrantType(g) {
+    return g.replace(/-/g, " ");
+}
+function formatComparison(comp, threshold) {
+    const thStr = typeof threshold === "string" ? threshold : `${threshold}`;
+    switch (comp) {
+        case "gte": return `${thStr}+`;
+        case "lte": return `${thStr} or less`;
+        case "gt": return `greater than ${thStr}`;
+        case "lt": return `less than ${thStr}`;
+        case "eq": return `exactly ${thStr}`;
+        default: return `${thStr}+`;
+    }
+}
+// ─── Scope translator ────────────────────────────────────────────────
+function translateScope(s) {
+    if (!s)
+        return "";
+    const range = s.range.replace(/-/g, " ");
+    const duration = s.duration.replace(/-/g, " ");
+    return `Scope: ${range}${s.range_inches ? ` (${s.range_inches}")` : ""}. Duration: ${duration}.`;
+}
+// ─── Main command ────────────────────────────────────────────────────
+export async function translateCommand(path) {
+    const filePath = resolve(process.cwd(), path ?? "../data/enrichment/world-eaters/abilities.json");
+    const abilities = JSON.parse(readFileSync(filePath, "utf-8"));
+    for (const a of abilities) {
+        const meta = [];
+        if (a.ability_type)
+            meta.push(a.ability_type);
+        if (a.behavior)
+            meta.push(a.behavior);
+        if (a.detachment_id)
+            meta.push(`detachment: ${a.detachment_id}`);
+        if (a.unit_ids?.length)
+            meta.push(`units: ${a.unit_ids.join(", ")}`);
+        console.log(`\n═══ ${a.name} [${a.ability_id}] ═══`);
+        if (meta.length)
+            console.log(`    ${meta.join(" | ")}`);
+        console.log(translateEffect(a.effect));
+        const scope = translateScope(a.scope);
+        if (scope)
+            console.log(scope);
+    }
+    console.log(`\n── ${abilities.length} abilities translated ──`);
+}

package/dist/commands/validate-all.d.ts

@@ -0,0 +1,3 @@
+export declare function validateAllCommand(opts: {
+    reporter: string;
+}): Promise<void>;

package/dist/commands/validate-all.js

@@ -0,0 +1,20 @@
+import { createValidator } from "../schema-loader.js";
+import { validateFiles } from "../validate.js";
+import { formatReport } from "../report.js";
+export async function validateAllCommand(opts) {
+    const ajv = createValidator();
+    const coreResult = await validateFiles(ajv, "core/**/*.json");
+    const enrichmentResult = await validateFiles(ajv, "enrichment/**/*.json");
+    const combined = {
+        totalFiles: coreResult.totalFiles + enrichmentResult.totalFiles,
+        totalItems: coreResult.totalItems + enrichmentResult.totalItems,
+        passed: coreResult.passed + enrichmentResult.passed,
+        failed: coreResult.failed + enrichmentResult.failed,
+        errors: [...coreResult.errors, ...enrichmentResult.errors],
+    };
+    const output = formatReport(combined, opts.reporter);
+    console.log(output);
+    if (combined.failed > 0) {
+        process.exit(1);
+    }
+}

package/dist/commands/validate-core.d.ts

@@ -0,0 +1,3 @@
+export declare function validateCoreCommand(opts: {
+    reporter: string;
+}): Promise<void>;