@alpaca-software/40kdc-data 0.1.1 → 0.1.3

package/dist/rube-goldberg.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env tsx
+/**
+ * Rube Goldberg machine — round-trips a NewRecruit list through every
+ * supported format and walks the linked Dataset API at each end.
+ *
+ * Loop:
+ * ```
+ *  seed (newrecruit-json) → import → Roster₀
+ *    → export wtc-compact → import
+ *    → export wtc-full    → import
+ *    → export simple      → import
+ *    → export newrecruit-json → import → Rosterₙ
+ * ```
+ *
+ * Asserts `Roster₀ == Rosterₙ` at the Roster level (after stripping
+ * `source` + `diagnostics`, which legitimately change across hops). Exits
+ * non-zero on divergence. Walks `unit.faction.units` / `weapon.units` /
+ * `ability.phases` at each end to demonstrate the cross-reference loops.
+ *
+ * Strict IP rule: only ids, names, and counts may be printed. No ability
+ * description text, no rules text — none of that is stored in the
+ * dataset, so we can't accidentally leak it, but be careful adding fields.
+ *
+ * @packageDocumentation
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Dataset } from "./data/dataset.js";
+import { exportRoster } from "./export/index.js";
+import { importRoster } from "./import/import-roster.js";
+const SEED_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "conformance", "roster", "chaos-knights-houndpack", "input.newrecruit-json.json");
+const HOPS = [
+    "newrecruit-wtc-compact",
+    "newrecruit-wtc-full",
+    "newrecruit-simple",
+    "newrecruit-json",
+];
+/** Strip the fields that legitimately change across format hops so the
+ *  fixed-point comparison can focus on the structural Roster shape. */
+function stable(r) {
+    const x = JSON.parse(JSON.stringify(r));
+    delete x.source;
+    delete x.diagnostics;
+    return x;
+}
+function rule(title) {
+    console.log(`\n── ${title} ${"─".repeat(Math.max(0, 60 - title.length))}`);
+}
+function walkLinkedApi(label, roster, ds) {
+    rule(`${label}: walking the linked Dataset API`);
+    console.log(`Roster: ${roster.name} (${roster.units.length} units)`);
+    console.log(`  faction_id     = ${roster.faction_id ?? "—"}`);
+    console.log(`  detachment_id  = ${roster.detachment_id ?? "—"}`);
+    console.log(`  total_computed = ${roster.points.total_computed}`);
+    for (const u of roster.units) {
+        if (!u.ref.id) {
+            console.log(`  · ${u.ref.raw_name}  [unresolved]`);
+            continue;
+        }
+        const unit = ds.units.get(u.ref.id);
+        if (!unit) {
+            console.log(`  · ${u.ref.id}  [not in dataset]`);
+            continue;
+        }
+        const fac = unit.faction;
+        const facUnits = fac?.units.length ?? 0;
+        console.log(`  · ${unit.id}  →  faction=${fac?.id ?? "—"} (faction has ${facUnits} units)`);
+        for (const w of unit.weapons) {
+            const carriers = w.units.length;
+            console.log(`      weapon=${w.id}  carried by ${carriers} units`);
+        }
+        for (const a of unit.abilities) {
+            const phaseIds = a.phases.join(",") || "—";
+            const carriers = a.units.length;
+            console.log(`      ability=${a.id}  phases=[${phaseIds}]  on ${carriers} units`);
+        }
+    }
+}
+function main() {
+    const ds = Dataset.embedded();
+    const seedJson = JSON.parse(readFileSync(SEED_PATH, "utf8"));
+    rule("seed");
+    console.log(`Loading: conformance/roster/chaos-knights-houndpack/input.newrecruit-json.json`);
+    const roster0 = importRoster(seedJson, { dataset: ds });
+    walkLinkedApi("Roster₀", roster0, ds);
+    let current = roster0;
+    for (const [i, fmt] of HOPS.entries()) {
+        const text = exportRoster(current, fmt);
+        const bytes = Buffer.byteLength(text, "utf8");
+        const isJson = fmt === "newrecruit-json";
+        const reimported = importRoster(isJson ? JSON.parse(text) : text, { dataset: ds });
+        console.log(`[hop ${i + 1}/${HOPS.length}] ${fmt}  →  ${bytes.toLocaleString()} bytes  →  reimport: ${reimported.units.length} units (computed ${reimported.points.total_computed} pts)`);
+        current = reimported;
+    }
+    walkLinkedApi("Rosterₙ", current, ds);
+    rule("fixed-point check");
+    const before = stable(roster0);
+    const after = stable(current);
+    const equal = JSON.stringify(before) === JSON.stringify(after);
+    if (equal) {
+        console.log(`Roster₀ == Rosterₙ after ${HOPS.length} format hops (source/diagnostics excluded).`);
+        return 0;
+    }
+    console.error(`Roster₀ ≠ Rosterₙ — round-trip diverged.`);
+    return 1;
+}
+process.exit(main());
+//# sourceMappingURL=rube-goldberg.js.map

package/dist/rube-goldberg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rube-goldberg.js","sourceRoot":"","sources":["../src/rube-goldberg.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env tsx\n/**\n * Rube Goldberg machine — round-trips a NewRecruit list through every\n * supported format and walks the linked Dataset API at each end.\n *\n * Loop:\n * ```\n *  seed (newrecruit-json) → import → Roster₀\n *    → export wtc-compact → import\n *    → export wtc-full    → import\n *    → export simple      → import\n *    → export newrecruit-json → import → Rosterₙ\n * ```\n *\n * Asserts `Roster₀ == Rosterₙ` at the Roster level (after stripping\n * `source` + `diagnostics`, which legitimately change across hops). Exits\n * non-zero on divergence. Walks `unit.faction.units` / `weapon.units` /\n * `ability.phases` at each end to demonstrate the cross-reference loops.\n *\n * Strict IP rule: only ids, names, and counts may be printed. No ability\n * description text, no rules text — none of that is stored in the\n * dataset, so we can't accidentally leak it, but be careful adding fields.\n *\n * @packageDocumentation\n */\nimport { readFileSync } from \"node:fs\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nimport { Dataset } from \"./data/dataset.js\";\nimport { exportRoster, type ExportFormat } from \"./export/index.js\";\nimport { importRoster } from \"./import/import-roster.js\";\nimport type { Roster } from \"./import/types.js\";\n\nconst SEED_PATH = join(\n  dirname(fileURLToPath(import.meta.url)),\n  \"..\",\n  \"..\",\n  \"conformance\",\n  \"roster\",\n  \"chaos-knights-houndpack\",\n  \"input.newrecruit-json.json\",\n);\n\nconst HOPS: ExportFormat[] = [\n  \"newrecruit-wtc-compact\",\n  \"newrecruit-wtc-full\",\n  \"newrecruit-simple\",\n  \"newrecruit-json\",\n];\n\n/** Strip the fields that legitimately change across format hops so the\n *  fixed-point comparison can focus on the structural Roster shape. */\nfunction stable(r: Roster): Record<string, unknown> {\n  const x = JSON.parse(JSON.stringify(r)) as Record<string, unknown>;\n  delete x.source;\n  delete x.diagnostics;\n  return x;\n}\n\nfunction rule(title: string): void {\n  console.log(`\\n── ${title} ${\"─\".repeat(Math.max(0, 60 - title.length))}`);\n}\n\nfunction walkLinkedApi(label: string, roster: Roster, ds: Dataset): void {\n  rule(`${label}: walking the linked Dataset API`);\n  console.log(`Roster: ${roster.name} (${roster.units.length} units)`);\n  console.log(`  faction_id     = ${roster.faction_id ?? \"—\"}`);\n  console.log(`  detachment_id  = ${roster.detachment_id ?? \"—\"}`);\n  console.log(`  total_computed = ${roster.points.total_computed}`);\n\n  for (const u of roster.units) {\n    if (!u.ref.id) {\n      console.log(`  · ${u.ref.raw_name}  [unresolved]`);\n      continue;\n    }\n    const unit = ds.units.get(u.ref.id);\n    if (!unit) {\n      console.log(`  · ${u.ref.id}  [not in dataset]`);\n      continue;\n    }\n    const fac = unit.faction;\n    const facUnits = fac?.units.length ?? 0;\n    console.log(`  · ${unit.id}  →  faction=${fac?.id ?? \"—\"} (faction has ${facUnits} units)`);\n\n    for (const w of unit.weapons) {\n      const carriers = w.units.length;\n      console.log(`      weapon=${w.id}  carried by ${carriers} units`);\n    }\n    for (const a of unit.abilities) {\n      const phaseIds = a.phases.join(\",\") || \"—\";\n      const carriers = a.units.length;\n      console.log(`      ability=${a.id}  phases=[${phaseIds}]  on ${carriers} units`);\n    }\n  }\n}\n\nfunction main(): number {\n  const ds = Dataset.embedded();\n  const seedJson = JSON.parse(readFileSync(SEED_PATH, \"utf8\"));\n\n  rule(\"seed\");\n  console.log(`Loading: conformance/roster/chaos-knights-houndpack/input.newrecruit-json.json`);\n\n  const roster0 = importRoster(seedJson, { dataset: ds });\n  walkLinkedApi(\"Roster₀\", roster0, ds);\n\n  let current: Roster = roster0;\n  for (const [i, fmt] of HOPS.entries()) {\n    const text = exportRoster(current, fmt);\n    const bytes = Buffer.byteLength(text, \"utf8\");\n    const isJson = fmt === \"newrecruit-json\";\n    const reimported = importRoster(isJson ? JSON.parse(text) : text, { dataset: ds });\n    console.log(\n      `[hop ${i + 1}/${HOPS.length}] ${fmt}  →  ${bytes.toLocaleString()} bytes  →  reimport: ${reimported.units.length} units (computed ${reimported.points.total_computed} pts)`,\n    );\n    current = reimported;\n  }\n\n  walkLinkedApi(\"Rosterₙ\", current, ds);\n\n  rule(\"fixed-point check\");\n  const before = stable(roster0);\n  const after = stable(current);\n  const equal = JSON.stringify(before) === JSON.stringify(after);\n  if (equal) {\n    console.log(`Roster₀ == Rosterₙ after ${HOPS.length} format hops (source/diagnostics excluded).`);\n    return 0;\n  }\n  console.error(`Roster₀ ≠ Rosterₙ — round-trip diverged.`);\n  return 1;\n}\n\nprocess.exit(main());\n"]}

package/dist/runner.d.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { Dataset } from "./data/dataset.js";
+import type Ajv from "ajv";
+export type RunnerResponse = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error_kind: ErrorKind;
+    error_payload?: unknown;
+};
+declare const ERROR_KINDS: readonly ["INVALID_INPUT", "UNKNOWN_OP", "UNKNOWN_ENTITY", "IMPORT_FAILED", "EXPORT_FAILED", "VALIDATION_ERROR", "CRUNCH_ERROR", "INTERNAL_ERROR"];
+type ErrorKind = (typeof ERROR_KINDS)[number];
+export interface RunnerState {
+    initialized: boolean;
+    locale: string;
+    tz: string;
+    seed: number;
+    dataset?: Dataset;
+    validator?: Ajv;
+}
+export declare function createRunnerState(): RunnerState;
+/**
+ * Apply one decoded request to the runner state and return the response. Used
+ * directly by tests; the CLI loop wraps it with line parsing.
+ */
+export declare function dispatch(state: RunnerState, req: {
+    op: string;
+    args?: unknown;
+}): RunnerResponse;
+/**
+ * Process one line of stdin (one NDJSON request) and return the line that
+ * should be written to stdout (one NDJSON response). Returns `null` only on
+ * fully-empty input lines, which should be silently ignored.
+ */
+export declare function processRequest(state: RunnerState, line: string): string | null;
+export {};
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":";AAsBA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAO5C,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AA8C3B,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAElE,QAAA,MAAM,WAAW,oJASP,CAAC;AACX,KAAK,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAgB9C,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB;AAED,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C;AAoTD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,cAAc,CA4BhG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc9E"}

package/dist/runner.js

@@ -0,0 +1,492 @@
+#!/usr/bin/env node
+/**
+ * NDJSON conformance runner — the TypeScript implementation of the wire
+ * protocol in `conformance/RUNNER_PROTOCOL.md`. Each line on stdin is a JSON
+ * request `{op, args?}`; each line on stdout is a JSON response
+ * `{ok: true, value}` or `{ok: false, error_kind, error_payload?}`.
+ *
+ * This file exports {@link processRequest} so vitest can drive the runner
+ * in-process without spawning a child; the bottom `if (isCliMain())` block
+ * wires the same dispatcher to real stdin/stdout for the cross-impl differ.
+ *
+ * The runner is a *thin* wrapper over the existing public API — it is not the
+ * canonical way to use the package. Library consumers should import the
+ * functions directly; the runner exists to give the cross-implementation
+ * differ a uniform interface across language ports.
+ */
+import { createInterface } from "node:readline";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+import { Dataset } from "./data/dataset.js";
+import { normalizeName } from "./data/normalize.js";
+import { exportRoster } from "./export/index.js";
+import { importRoster, tryImportRoster } from "./import/import-roster.js";
+import { createValidator } from "./schema-loader.js";
+import { crunch } from "./cruncher/index.js";
+// -----------------------------------------------------------------------------
+// Constants — spec version and implementation identity.
+// -----------------------------------------------------------------------------
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function loadSpecVersion() {
+    // The corpus lives at repo-root/conformance/. Walk up from tools/src/ until
+    // we find it so the runner works both from source (tsx) and from dist/.
+    for (const candidate of [
+        join(__dirname, "../../conformance/SPEC_VERSION"),
+        join(__dirname, "../../../conformance/SPEC_VERSION"),
+    ]) {
+        try {
+            return Number.parseInt(readFileSync(candidate, "utf8").trim(), 10);
+        }
+        catch {
+            // try next
+        }
+    }
+    throw new Error("could not locate conformance/SPEC_VERSION");
+}
+function loadImplVersion() {
+    for (const candidate of [
+        join(__dirname, "../package.json"),
+        join(__dirname, "../../package.json"),
+    ]) {
+        try {
+            return JSON.parse(readFileSync(candidate, "utf8")).version;
+        }
+        catch {
+            // try next
+        }
+    }
+    return "unknown";
+}
+const SPEC_VERSION = loadSpecVersion();
+const IMPL_VERSION = loadImplVersion();
+const IMPL_NAME = "ts";
+const ERROR_KINDS = [
+    "INVALID_INPUT",
+    "UNKNOWN_OP",
+    "UNKNOWN_ENTITY",
+    "IMPORT_FAILED",
+    "EXPORT_FAILED",
+    "VALIDATION_ERROR",
+    "CRUNCH_ERROR",
+    "INTERNAL_ERROR",
+];
+function ok(value) {
+    return { ok: true, value };
+}
+function err(kind, payload) {
+    return payload === undefined
+        ? { ok: false, error_kind: kind }
+        : { ok: false, error_kind: kind, error_payload: payload };
+}
+export function createRunnerState() {
+    return { initialized: false, locale: "C", tz: "UTC", seed: 0 };
+}
+function getDataset(state) {
+    if (!state.dataset)
+        state.dataset = Dataset.embedded();
+    return state.dataset;
+}
+function getValidator(state) {
+    if (!state.validator)
+        state.validator = createValidator();
+    return state.validator;
+}
+// -----------------------------------------------------------------------------
+// Op handlers.
+// -----------------------------------------------------------------------------
+function handleInit(state, args) {
+    if (state.initialized) {
+        return err("INVALID_INPUT", { detail: "init called twice" });
+    }
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "init args must be an object" });
+    }
+    const a = args;
+    if (a.spec_version !== SPEC_VERSION) {
+        return err("INVALID_INPUT", {
+            detail: `spec_version mismatch: runner=${SPEC_VERSION}, request=${String(a.spec_version)}`,
+        });
+    }
+    if (a.locale !== "C") {
+        return err("INVALID_INPUT", { detail: `unsupported locale: ${String(a.locale)} (only "C")` });
+    }
+    if (a.tz !== "UTC") {
+        return err("INVALID_INPUT", { detail: `unsupported tz: ${String(a.tz)} (only "UTC")` });
+    }
+    if (typeof a.seed !== "number") {
+        return err("INVALID_INPUT", { detail: "seed must be a number" });
+    }
+    state.initialized = true;
+    state.locale = a.locale;
+    state.tz = a.tz;
+    state.seed = a.seed;
+    return ok({ impl: IMPL_NAME, spec_version: SPEC_VERSION, impl_version: IMPL_VERSION });
+}
+function handleNormalize(args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "normalize args must be an object" });
+    }
+    const a = args;
+    if (typeof a.input !== "string") {
+        return err("INVALID_INPUT", { detail: "normalize.input must be a string" });
+    }
+    return ok(normalizeName(a.input));
+}
+function handleImport(state, args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "import args must be an object" });
+    }
+    const a = args;
+    if (typeof a.input !== "string") {
+        return err("INVALID_INPUT", { detail: "import.input must be a string" });
+    }
+    try {
+        // The wire protocol carries every input as a string: JSON payloads come
+        // through as the JSON text, text payloads come through as-is. The import
+        // pipeline decides which by attempting to parse JSON first.
+        const trimmed = a.input.trimStart();
+        let decoded;
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+            try {
+                decoded = JSON.parse(a.input);
+            }
+            catch {
+                decoded = a.input;
+            }
+        }
+        else {
+            decoded = a.input;
+        }
+        const roster = importRoster(decoded, { dataset: getDataset(state) });
+        return ok(roster);
+    }
+    catch (e) {
+        return err("IMPORT_FAILED", { detail: e.message, format: a.format ?? null });
+    }
+}
+function handleTryImport(state, args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "try_import args must be an object" });
+    }
+    const a = args;
+    if (typeof a.input !== "string") {
+        return err("INVALID_INPUT", { detail: "try_import.input must be a string" });
+    }
+    const result = tryImportRoster(a.input, { dataset: getDataset(state) });
+    if (!result.ok) {
+        return err("IMPORT_FAILED", { reason: result.reason, message: result.message });
+    }
+    return ok({ format: result.format, roster: result.roster });
+}
+const EXPORT_FORMATS = [
+    "newrecruit-json",
+    "newrecruit-wtc-compact",
+    "newrecruit-wtc-full",
+    "newrecruit-simple",
+    "roster-json",
+    "rosterizer",
+];
+function handleExport(args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "export args must be an object" });
+    }
+    const a = args;
+    if (typeof a.format !== "string" || !EXPORT_FORMATS.includes(a.format)) {
+        return err("INVALID_INPUT", { detail: `unknown export format: ${String(a.format)}` });
+    }
+    if (typeof a.roster !== "object" || a.roster === null) {
+        return err("INVALID_INPUT", { detail: "export.roster must be an object" });
+    }
+    try {
+        // We assume the caller passes the canonical resolved Roster shape; if they
+        // pass something the serializer can't handle, this throws.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return ok(exportRoster(a.roster, a.format));
+    }
+    catch (e) {
+        return err("EXPORT_FAILED", { detail: e.message });
+    }
+}
+function handleLinkedQuery(state, args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "linked_query args must be an object" });
+    }
+    const a = args;
+    if (typeof a.query !== "string") {
+        return err("INVALID_INPUT", { detail: "linked_query.query must be a string" });
+    }
+    const ds = getDataset(state);
+    const input = (a.input ?? {});
+    try {
+        switch (a.query) {
+            case "find_unit":
+                return ok(ds.units.find(input.query ?? "")?.id ?? null);
+            case "find_weapon":
+                return ok(ds.weapons.find(input.query ?? "")?.id ?? null);
+            case "find_faction":
+                return ok(ds.factions.find(input.query ?? "")?.id ?? null);
+            case "find_ability":
+                return ok(ds.abilities.find(input.query ?? "")?.id ?? null);
+            case "abilities_of": {
+                const u = ds.units.get(input.unitId);
+                if (!u)
+                    return err("UNKNOWN_ENTITY", { kind: "unit", id: input.unitId });
+                return ok(u.abilities.map((x) => x.id));
+            }
+            case "weapons_of": {
+                const u = ds.units.get(input.unitId);
+                if (!u)
+                    return err("UNKNOWN_ENTITY", { kind: "unit", id: input.unitId });
+                return ok(u.weapons.map((x) => x.id));
+            }
+            case "phases_of": {
+                const ab = ds.abilities.get(input.abilityId);
+                if (!ab)
+                    return err("UNKNOWN_ENTITY", { kind: "ability", id: input.abilityId });
+                return ok([...ab.phases]);
+            }
+            case "faction_of": {
+                const u = ds.units.get(input.unitId);
+                if (!u)
+                    return err("UNKNOWN_ENTITY", { kind: "unit", id: input.unitId });
+                return ok(u.faction?.id ?? null);
+            }
+            case "abilities_of_faction":
+                return ok(ds.abilities.byFaction(input.factionId).map((x) => x.id));
+            case "weapons_of_faction": {
+                const f = ds.factions.get(input.factionId);
+                if (!f)
+                    return err("UNKNOWN_ENTITY", { kind: "faction", id: input.factionId });
+                return ok(f.weapons.map((x) => x.id));
+            }
+            default:
+                return err("INVALID_INPUT", { detail: `unknown linked_query: ${a.query}` });
+        }
+    }
+    catch (e) {
+        return err("INTERNAL_ERROR", { detail: e.message });
+    }
+}
+const VALIDATOR_TARGETS = {
+    unit: "https://40kdc.dev/schemas/core/unit.schema.json",
+    weapon: "https://40kdc.dev/schemas/core/weapon.schema.json",
+    faction: "https://40kdc.dev/schemas/core/faction.schema.json",
+    ability: "https://40kdc.dev/schemas/enrichment/ability-dsl/ability.schema.json",
+};
+function ajvKeywordToCode(keyword) {
+    switch (keyword) {
+        case "required":
+            return "REQUIRED_MISSING";
+        case "type":
+            return "TYPE_MISMATCH";
+        case "enum":
+            return "ENUM_VIOLATION";
+        case "pattern":
+        case "format":
+            return "PATTERN_MISMATCH";
+        case "minimum":
+        case "maximum":
+        case "exclusiveMinimum":
+        case "exclusiveMaximum":
+        case "minLength":
+        case "maxLength":
+        case "minItems":
+        case "maxItems":
+            return "RANGE_VIOLATION";
+        case "additionalProperties":
+            return "ADDITIONAL_PROPERTY";
+        case "uniqueItems":
+            return "UNIQUE_VIOLATION";
+        default:
+            return `UNMAPPED:${keyword}`;
+    }
+}
+function handleValidate(state, args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "validate args must be an object" });
+    }
+    const a = args;
+    if (typeof a.target !== "string" || !(a.target in VALIDATOR_TARGETS)) {
+        return err("INVALID_INPUT", { detail: `unknown validator target: ${String(a.target)}` });
+    }
+    let validate;
+    try {
+        validate = getValidator(state).getSchema(VALIDATOR_TARGETS[a.target]);
+    }
+    catch (e) {
+        return err("VALIDATION_ERROR", { detail: e.message });
+    }
+    if (!validate) {
+        return err("VALIDATION_ERROR", { detail: `schema not loaded: ${a.target}` });
+    }
+    validate(a.value);
+    const raw = validate.errors ?? [];
+    const seen = new Set();
+    const out = [];
+    for (const e of raw) {
+        const code = ajvKeywordToCode(e.keyword);
+        if (code.startsWith("UNMAPPED:"))
+            continue;
+        const path = e.keyword === "required"
+            ? `${e.instancePath}/${e.params.missingProperty ?? ""}`
+            : e.instancePath;
+        const key = `${path}|${code}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ path, code });
+    }
+    return ok(out);
+}
+function handleCrunch(state, args) {
+    if (typeof args !== "object" || args === null) {
+        return err("INVALID_INPUT", { detail: "crunch args must be an object" });
+    }
+    const a = args;
+    if (!a.attacker?.weaponId || typeof a.attacker.profileIndex !== "number") {
+        return err("INVALID_INPUT", { detail: "crunch.attacker.weaponId/profileIndex required" });
+    }
+    if (!a.target?.unitId || typeof a.target.profileIndex !== "number") {
+        return err("INVALID_INPUT", { detail: "crunch.target.unitId/profileIndex required" });
+    }
+    if (typeof a.modelsFiring !== "number") {
+        return err("INVALID_INPUT", { detail: "crunch.modelsFiring required" });
+    }
+    if (!a.context) {
+        return err("INVALID_INPUT", { detail: "crunch.context required" });
+    }
+    const ds = getDataset(state);
+    const weapon = ds.weapons.get(a.attacker.weaponId);
+    if (!weapon)
+        return err("UNKNOWN_ENTITY", { kind: "weapon", id: a.attacker.weaponId });
+    const unit = ds.units.get(a.target.unitId);
+    if (!unit)
+        return err("UNKNOWN_ENTITY", { kind: "unit", id: a.target.unitId });
+    try {
+        const input = {
+            attacker: { weapon: weapon.raw, profileIndex: a.attacker.profileIndex },
+            target: {
+                unit: unit.raw,
+                profileIndex: a.target.profileIndex,
+                ...(a.target.modelCount !== undefined ? { modelCount: a.target.modelCount } : {}),
+            },
+            modelsFiring: a.modelsFiring,
+            buffs: a.buffs ?? [],
+            context: a.context,
+        };
+        return ok(crunch(input, ds));
+    }
+    catch (e) {
+        return err("CRUNCH_ERROR", { detail: e.message });
+    }
+}
+// -----------------------------------------------------------------------------
+// Dispatcher and per-line entry point.
+// -----------------------------------------------------------------------------
+/**
+ * Apply one decoded request to the runner state and return the response. Used
+ * directly by tests; the CLI loop wraps it with line parsing.
+ */
+export function dispatch(state, req) {
+    if (!state.initialized && req.op !== "init") {
+        return err("INVALID_INPUT", { detail: "must init before any other op" });
+    }
+    switch (req.op) {
+        case "init":
+            return handleInit(state, req.args);
+        case "version":
+            return ok({ impl: IMPL_NAME, spec_version: SPEC_VERSION, impl_version: IMPL_VERSION });
+        case "normalize":
+            return handleNormalize(req.args);
+        case "import":
+            return handleImport(state, req.args);
+        case "try_import":
+            return handleTryImport(state, req.args);
+        case "export":
+            return handleExport(req.args);
+        case "linked_query":
+            return handleLinkedQuery(state, req.args);
+        case "validate":
+            return handleValidate(state, req.args);
+        case "crunch":
+            return handleCrunch(state, req.args);
+        case "shutdown":
+            return ok(null);
+        default:
+            return err("UNKNOWN_OP", { op: req.op });
+    }
+}
+/**
+ * Process one line of stdin (one NDJSON request) and return the line that
+ * should be written to stdout (one NDJSON response). Returns `null` only on
+ * fully-empty input lines, which should be silently ignored.
+ */
+export function processRequest(state, line) {
+    const trimmed = line.trim();
+    if (trimmed === "")
+        return null;
+    let req;
+    try {
+        req = JSON.parse(trimmed);
+    }
+    catch (e) {
+        return JSON.stringify(err("INVALID_INPUT", { detail: `not valid JSON: ${e.message}` }));
+    }
+    if (typeof req.op !== "string") {
+        return JSON.stringify(err("INVALID_INPUT", { detail: "request must have a string `op` field" }));
+    }
+    const response = dispatch(state, { op: req.op, args: req.args });
+    return JSON.stringify(response);
+}
+// -----------------------------------------------------------------------------
+// CLI: wire stdin/stdout. Only runs when this file is the process entry point.
+// -----------------------------------------------------------------------------
+function isCliMain() {
+    // process.argv[1] is the path the runtime invoked. With tsx and node both,
+    // it points at this file (or its compiled .js form). Comparing absolute
+    // paths is the most robust portable check.
+    if (!process.argv[1])
+        return false;
+    const entry = process.argv[1];
+    const here = fileURLToPath(import.meta.url);
+    return entry === here || entry.endsWith("/runner.js") || entry.endsWith("/runner.ts");
+}
+async function runCli() {
+    const state = createRunnerState();
+    const rl = createInterface({ input: process.stdin });
+    // We must respond on the same tick the request arrives — the differ
+    // pipelines requests and expects responses in order. readline preserves
+    // line ordering, so processing inside `line` handler is sufficient.
+    for await (const line of rl) {
+        const out = processRequest(state, line);
+        if (out !== null) {
+            process.stdout.write(out + "\n");
+        }
+        // `shutdown` returns `ok(null)`; honor it by exiting after the response
+        // is flushed.
+        try {
+            const req = JSON.parse(line);
+            if (req && req.op === "shutdown") {
+                process.exit(0);
+            }
+        }
+        catch {
+            // already handled above; not a shutdown
+        }
+    }
+}
+if (isCliMain()) {
+    runCli().catch((e) => {
+        // Last-ditch INTERNAL_ERROR so the differ sees a typed failure rather
+        // than an opaque crash.
+        process.stdout.write(JSON.stringify({
+            ok: false,
+            error_kind: "INTERNAL_ERROR",
+            error_payload: { detail: e.message },
+        }) + "\n");
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=runner.js.map