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

package/dist/export/roster-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roster-json.d.ts","sourceRoot":"","sources":["../../src/export/roster-json.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,eAAO,MAAM,oBAAoB,EAAE,gBAKlC,CAAC"}

package/dist/export/roster-json.js

@@ -0,0 +1,8 @@
+import { prettyJson } from "./helpers.js";
+export const rosterJsonSerializer = {
+    id: "roster-json",
+    serialize(roster) {
+        return prettyJson(roster);
+    },
+};
+//# sourceMappingURL=roster-json.js.map

package/dist/export/roster-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roster-json.js","sourceRoot":"","sources":["../../src/export/roster-json.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACpD,EAAE,EAAE,aAAa;IACjB,SAAS,CAAC,MAAc;QACtB,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;CACF,CAAC","sourcesContent":["/**\n * Canonical Roster JSON serializer — emits the {@link Roster} as 2-space JSON,\n * the same shape the importers consume. This is the lossless pivot, so the\n * pretty-printed text is exactly `roster.schema.json` shape.\n *\n * @packageDocumentation\n */\nimport type { Roster } from \"../import/types.js\";\nimport { prettyJson } from \"./helpers.js\";\nimport type { RosterSerializer } from \"./serializer.js\";\n\nexport const rosterJsonSerializer: RosterSerializer = {\n  id: \"roster-json\",\n  serialize(roster: Roster): string {\n    return prettyJson(roster);\n  },\n};\n"]}

package/dist/export/rosterizer.d.ts

@@ -0,0 +1,3 @@
+import type { RosterSerializer } from "./serializer.js";
+export declare const rosterizerSerializer: RosterSerializer;
+//# sourceMappingURL=rosterizer.d.ts.map

package/dist/export/rosterizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rosterizer.d.ts","sourceRoot":"","sources":["../../src/export/rosterizer.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAqIxD,eAAO,MAAM,oBAAoB,EAAE,gBAuClC,CAAC"}

package/dist/export/rosterizer.js

@@ -0,0 +1,144 @@
+import { prettyJson, titleCaseId, totalArmyPoints } from "./helpers.js";
+// Mirror the importer's constants (kept inline rather than imported so the
+// exporter stays decoupled — the seams are the `item` keys themselves).
+const CLS_ROSTER = "Roster";
+const CLS_FACTION = "Faction";
+const CLS_DETACHMENT = "Detachment";
+const CLS_UNIT = "Unit";
+const CLS_WEAPON = "Weapon";
+const CLS_ENHANCEMENT = "Enhancement";
+const CLS_BATTLE_SIZE = "Battle Size";
+const CLS_TRAIT = "Trait";
+const DSG_WARLORD = "Warlord";
+const RULEBOOK_NAME = "40kdc";
+const RULEBOOK_GAME = "Warhammer 40,000";
+const RULEBOOK_PUBLISHER = "Tabletop Developer Consortium";
+const RULEBOOK_URL = "https://40kdc.dev";
+const RULEBOOK_GENRE = "wargame";
+function key(classification, designation) {
+    return `${classification}§${designation}`; // §
+}
+function pointsStat(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    return { Points: { value } };
+}
+function wargearAsset(w) {
+    return {
+        item: key(CLS_WEAPON, w.ref.raw_name),
+        name: w.ref.raw_name,
+        quantity: w.count,
+    };
+}
+function enhancementAsset(u) {
+    if (!u.enhancement)
+        return null;
+    return {
+        item: key(CLS_ENHANCEMENT, u.enhancement.raw_name),
+        name: u.enhancement.raw_name,
+        quantity: 1,
+        ...(u.enhancement_points !== null
+            ? { stats: pointsStat(u.enhancement_points) }
+            : {}),
+    };
+}
+function warlordTraitAsset() {
+    return {
+        item: key(CLS_TRAIT, DSG_WARLORD),
+        name: DSG_WARLORD,
+        quantity: 1,
+    };
+}
+function unitAsset(u) {
+    const included = [];
+    const enh = enhancementAsset(u);
+    if (enh !== null)
+        included.push(enh);
+    for (const w of u.wargear)
+        included.push(wargearAsset(w));
+    const traits = [];
+    if (u.is_warlord)
+        traits.push(warlordTraitAsset());
+    const asset = {
+        item: key(CLS_UNIT, u.ref.raw_name),
+        name: u.ref.raw_name,
+        quantity: u.model_count,
+    };
+    const stats = pointsStat(u.points);
+    if (stats !== undefined)
+        asset.stats = stats;
+    if (included.length > 0 || traits.length > 0) {
+        asset.assets = {};
+        if (included.length > 0)
+            asset.assets.included = included;
+        if (traits.length > 0)
+            asset.assets.traits = traits;
+    }
+    return asset;
+}
+function factionAsset(roster) {
+    const display = titleCaseId(roster.faction_id);
+    if (display === null)
+        return null;
+    return { item: key(CLS_FACTION, display), name: display, quantity: 1 };
+}
+function detachmentAsset(roster) {
+    const display = titleCaseId(roster.detachment_id);
+    if (display === null)
+        return null;
+    return { item: key(CLS_DETACHMENT, display), name: display, quantity: 1 };
+}
+function battleSizeAsset(roster) {
+    if (roster.battle_size === "strike-force") {
+        const limit = roster.points.declared_limit ?? 2000;
+        const label = `Strike Force (${limit} Point limit)`;
+        return { item: key(CLS_BATTLE_SIZE, label), name: label, quantity: 1 };
+    }
+    if (roster.battle_size === "incursion") {
+        const limit = roster.points.declared_limit ?? 1000;
+        const label = `Incursion (${limit} Point limit)`;
+        return { item: key(CLS_BATTLE_SIZE, label), name: label, quantity: 1 };
+    }
+    return null;
+}
+export const rosterizerSerializer = {
+    id: "rosterizer",
+    serialize(roster) {
+        const included = [];
+        const faction = factionAsset(roster);
+        if (faction)
+            included.push(faction);
+        const detachment = detachmentAsset(roster);
+        if (detachment)
+            included.push(detachment);
+        const battleSize = battleSizeAsset(roster);
+        if (battleSize)
+            included.push(battleSize);
+        for (const u of roster.units)
+            included.push(unitAsset(u));
+        const total = totalArmyPoints(roster);
+        const snapshot = {
+            item: key(CLS_ROSTER, CLS_ROSTER),
+            name: roster.name,
+            quantity: 1,
+            ...(total > 0 ? { stats: pointsStat(total) } : {}),
+            assets: { included },
+        };
+        const envelope = {
+            slug: "",
+            key: "",
+            visible: "hidden",
+            locked: false,
+            rulebook: {
+                name: RULEBOOK_NAME,
+                game: RULEBOOK_GAME,
+                publisher: RULEBOOK_PUBLISHER,
+                url: RULEBOOK_URL,
+                genre: RULEBOOK_GENRE,
+            },
+            snapshot,
+        };
+        return prettyJson(envelope);
+    },
+};
+//# sourceMappingURL=rosterizer.js.map

package/dist/export/rosterizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rosterizer.js","sourceRoot":"","sources":["../../src/export/rosterizer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Rosterizer serializer — emits a Rosterizer-shaped roster JSON skeleton that\n * round-trips through {@link rosterizerAdapter}.\n *\n * The shape carries only fields the importer reads: `rulebook` (envelope),\n * `snapshot` (an `Asset` tree rooted at `Roster§Roster`), and per-unit\n * `item`/`name`/`quantity`/`stats.Points.value`/`assets.included`/`assets.traits`.\n * No `text`, `description`, `rules`, `lineage`, `_layers`, `classIdentity`,\n * `processed`, or `bareResourceKey` ever appear — they aren't stored in the\n * Roster and emitting them could leak prose.\n *\n * Faction and detachment display names come from {@link titleCaseId} — the\n * Roster doesn't carry the source's raw faction name, so we reconstruct it\n * from the kebab-case id. Same lossy hop as the NewRecruit JSON serializer.\n *\n * @packageDocumentation\n */\nimport type { Roster, RosterUnit, RosterWargear } from \"../import/types.js\";\nimport { prettyJson, titleCaseId, totalArmyPoints } from \"./helpers.js\";\nimport type { RosterSerializer } from \"./serializer.js\";\n\n// Mirror the importer's constants (kept inline rather than imported so the\n// exporter stays decoupled — the seams are the `item` keys themselves).\nconst CLS_ROSTER = \"Roster\";\nconst CLS_FACTION = \"Faction\";\nconst CLS_DETACHMENT = \"Detachment\";\nconst CLS_UNIT = \"Unit\";\nconst CLS_WEAPON = \"Weapon\";\nconst CLS_ENHANCEMENT = \"Enhancement\";\nconst CLS_BATTLE_SIZE = \"Battle Size\";\nconst CLS_TRAIT = \"Trait\";\nconst DSG_WARLORD = \"Warlord\";\n\nconst RULEBOOK_NAME = \"40kdc\";\nconst RULEBOOK_GAME = \"Warhammer 40,000\";\nconst RULEBOOK_PUBLISHER = \"Tabletop Developer Consortium\";\nconst RULEBOOK_URL = \"https://40kdc.dev\";\nconst RULEBOOK_GENRE = \"wargame\";\n\ninterface Asset {\n  item: string;\n  name?: string;\n  quantity?: number;\n  stats?: Record<string, { value: number }>;\n  assets?: {\n    included?: Asset[];\n    traits?: Asset[];\n  };\n}\n\ninterface Envelope {\n  slug: string;\n  key: string;\n  visible: \"hidden\" | \"public\" | \"friends\";\n  locked: boolean;\n  rulebook: {\n    name: string;\n    game: string;\n    publisher: string;\n    url: string;\n    genre: string;\n  };\n  snapshot: Asset;\n}\n\nfunction key(classification: string, designation: string): string {\n  return `${classification}§${designation}`; // §\n}\n\nfunction pointsStat(value: number | null | undefined): Record<string, { value: number }> | undefined {\n  if (value === null || value === undefined) return undefined;\n  return { Points: { value } };\n}\n\nfunction wargearAsset(w: RosterWargear): Asset {\n  return {\n    item: key(CLS_WEAPON, w.ref.raw_name),\n    name: w.ref.raw_name,\n    quantity: w.count,\n  };\n}\n\nfunction enhancementAsset(u: RosterUnit): Asset | null {\n  if (!u.enhancement) return null;\n  return {\n    item: key(CLS_ENHANCEMENT, u.enhancement.raw_name),\n    name: u.enhancement.raw_name,\n    quantity: 1,\n    ...(u.enhancement_points !== null\n      ? { stats: pointsStat(u.enhancement_points) }\n      : {}),\n  };\n}\n\nfunction warlordTraitAsset(): Asset {\n  return {\n    item: key(CLS_TRAIT, DSG_WARLORD),\n    name: DSG_WARLORD,\n    quantity: 1,\n  };\n}\n\nfunction unitAsset(u: RosterUnit): Asset {\n  const included: Asset[] = [];\n  const enh = enhancementAsset(u);\n  if (enh !== null) included.push(enh);\n  for (const w of u.wargear) included.push(wargearAsset(w));\n\n  const traits: Asset[] = [];\n  if (u.is_warlord) traits.push(warlordTraitAsset());\n\n  const asset: Asset = {\n    item: key(CLS_UNIT, u.ref.raw_name),\n    name: u.ref.raw_name,\n    quantity: u.model_count,\n  };\n  const stats = pointsStat(u.points);\n  if (stats !== undefined) asset.stats = stats;\n  if (included.length > 0 || traits.length > 0) {\n    asset.assets = {};\n    if (included.length > 0) asset.assets.included = included;\n    if (traits.length > 0) asset.assets.traits = traits;\n  }\n  return asset;\n}\n\nfunction factionAsset(roster: Roster): Asset | null {\n  const display = titleCaseId(roster.faction_id);\n  if (display === null) return null;\n  return { item: key(CLS_FACTION, display), name: display, quantity: 1 };\n}\n\nfunction detachmentAsset(roster: Roster): Asset | null {\n  const display = titleCaseId(roster.detachment_id);\n  if (display === null) return null;\n  return { item: key(CLS_DETACHMENT, display), name: display, quantity: 1 };\n}\n\nfunction battleSizeAsset(roster: Roster): Asset | null {\n  if (roster.battle_size === \"strike-force\") {\n    const limit = roster.points.declared_limit ?? 2000;\n    const label = `Strike Force (${limit} Point limit)`;\n    return { item: key(CLS_BATTLE_SIZE, label), name: label, quantity: 1 };\n  }\n  if (roster.battle_size === \"incursion\") {\n    const limit = roster.points.declared_limit ?? 1000;\n    const label = `Incursion (${limit} Point limit)`;\n    return { item: key(CLS_BATTLE_SIZE, label), name: label, quantity: 1 };\n  }\n  return null;\n}\n\nexport const rosterizerSerializer: RosterSerializer = {\n  id: \"rosterizer\",\n\n  serialize(roster: Roster): string {\n    const included: Asset[] = [];\n    const faction = factionAsset(roster);\n    if (faction) included.push(faction);\n    const detachment = detachmentAsset(roster);\n    if (detachment) included.push(detachment);\n    const battleSize = battleSizeAsset(roster);\n    if (battleSize) included.push(battleSize);\n    for (const u of roster.units) included.push(unitAsset(u));\n\n    const total = totalArmyPoints(roster);\n    const snapshot: Asset = {\n      item: key(CLS_ROSTER, CLS_ROSTER),\n      name: roster.name,\n      quantity: 1,\n      ...(total > 0 ? { stats: pointsStat(total) } : {}),\n      assets: { included },\n    };\n\n    const envelope: Envelope = {\n      slug: \"\",\n      key: \"\",\n      visible: \"hidden\",\n      locked: false,\n      rulebook: {\n        name: RULEBOOK_NAME,\n        game: RULEBOOK_GAME,\n        publisher: RULEBOOK_PUBLISHER,\n        url: RULEBOOK_URL,\n        genre: RULEBOOK_GENRE,\n      },\n      snapshot,\n    };\n\n    return prettyJson(envelope);\n  },\n};\n"]}

package/dist/export/serializer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The roster-serializer seam — symmetric counterpart to the
+ * {@link FormatAdapter} import seam.
+ *
+ * Each supported export target implements {@link RosterSerializer}: it takes a
+ * fully-resolved {@link Roster} and produces a deterministic string in that
+ * format. The seam stays Dataset-free so the TS and Rust mirrors can produce
+ * byte-identical output for conformance.
+ *
+ * Five targets are registered:
+ * - `newrecruit-json`         — NewRecruit-shaped JSON skeleton (rules-free).
+ * - `newrecruit-wtc-compact`  — tournament-friendly one-line-per-unit text.
+ * - `newrecruit-wtc-full`     — tournament-friendly section-and-wargear text.
+ * - `newrecruit-simple`       — markdown-ish text.
+ * - `roster-json`             — canonical Roster JSON (the lossless pivot).
+ *
+ * @packageDocumentation
+ */
+import type { Roster } from "../import/types.js";
+/** Stable id for an export target. */
+export type ExportFormat = "newrecruit-json" | "newrecruit-wtc-compact" | "newrecruit-wtc-full" | "newrecruit-simple" | "roster-json" | "rosterizer";
+/** Serializes a {@link Roster} into one specific format. */
+export interface RosterSerializer {
+    id: ExportFormat;
+    serialize(roster: Roster): string;
+}
+//# sourceMappingURL=serializer.d.ts.map

package/dist/export/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/export/serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,sCAAsC;AACtC,MAAM,MAAM,YAAY,GACpB,iBAAiB,GACjB,wBAAwB,GACxB,qBAAqB,GACrB,mBAAmB,GACnB,aAAa,GACb,YAAY,CAAC;AAEjB,4DAA4D;AAC5D,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,YAAY,CAAC;IACjB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACnC"}

package/dist/export/serializer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serializer.js.map

package/dist/export/serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","sourceRoot":"","sources":["../../src/export/serializer.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The roster-serializer seam — symmetric counterpart to the\n * {@link FormatAdapter} import seam.\n *\n * Each supported export target implements {@link RosterSerializer}: it takes a\n * fully-resolved {@link Roster} and produces a deterministic string in that\n * format. The seam stays Dataset-free so the TS and Rust mirrors can produce\n * byte-identical output for conformance.\n *\n * Five targets are registered:\n * - `newrecruit-json`         — NewRecruit-shaped JSON skeleton (rules-free).\n * - `newrecruit-wtc-compact`  — tournament-friendly one-line-per-unit text.\n * - `newrecruit-wtc-full`     — tournament-friendly section-and-wargear text.\n * - `newrecruit-simple`       — markdown-ish text.\n * - `roster-json`             — canonical Roster JSON (the lossless pivot).\n *\n * @packageDocumentation\n */\nimport type { Roster } from \"../import/types.js\";\n\n/** Stable id for an export target. */\nexport type ExportFormat =\n  | \"newrecruit-json\"\n  | \"newrecruit-wtc-compact\"\n  | \"newrecruit-wtc-full\"\n  | \"newrecruit-simple\"\n  | \"roster-json\"\n  | \"rosterizer\";\n\n/** Serializes a {@link Roster} into one specific format. */\nexport interface RosterSerializer {\n  id: ExportFormat;\n  serialize(roster: Roster): string;\n}\n"]}

package/dist/gen-conformance.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=gen-conformance.d.ts.map

package/dist/gen-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen-conformance.d.ts","sourceRoot":"","sources":["../src/gen-conformance.ts"],"names":[],"mappings":""}

package/dist/gen-conformance.js

@@ -1,25 +1,36 @@
 /**
  * Generate the cross-implementation conformance corpus under repo-root
- * `conformance/`. The TypeScript package is the reference implementation, so the
- * goldens it emits are what the Rust crate must reproduce byte-for-byte
+ * `conformance/`. The TypeScript package is the reference implementation, so
+ * the goldens it emits are what the Rust crate must reproduce byte-for-byte
  * (structurally). Run via `npm run gen:conformance`; CI regenerates and asserts
  * `git diff --exit-code conformance/` is clean.
  *
  * Outputs:
  * - `conformance/normalize.json` — `[{ input, expected }]` for normalizeName.
- * - `conformance/roster/<case>/expected.roster.json` — the resolved Roster for
- *   the sibling `input.json` (the ListForge payload).
+ * - `conformance/roster/<case>/expected.roster.json` — the resolved Roster.
+ * - `conformance/roster/<case>/expected.<fmt>.{txt,json}` — every export
+ *   target's golden output. The TS exporter is the oracle; the Rust mirror
+ *   asserts byte-equal output for the same Roster.
+ * - `conformance/roster/<case>/input.newrecruit-{wtc-compact,wtc-full,simple}.txt`
+ *   — text inputs derived from the seed by the exporter, so a re-import
+ *   regression in either implementation surfaces immediately.
+ *
+ * Seeding: each `<case>/` carries one canonical input — either the legacy
+ * `input.json` (ListForge) or `input.newrecruit-json.json` (NewRecruit). Other
+ * inputs are derived.
  */
-import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Dataset } from "./data/dataset.js";
 import { normalizeName } from "./data/normalize.js";
-import { importRoster } from "./import/import-listforge.js";
+import { exportRoster } from "./export/index.js";
+import { importRoster, REGISTERED_ADAPTERS } from "./import/import-roster.js";
+import { selectAdapter } from "./import/adapter.js";
+import { attributeStages } from "./cruncher/attribution.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = join(__dirname, "../..");
 const CONFORMANCE = join(REPO_ROOT, "conformance");
-/** Inputs for the normalize table — every rule, plus real accented/quoted names. */
 const NORMALIZE_INPUTS = [
     // NFD diacritic strip
     "Khârn the Betrayer",
@@ -43,16 +54,83 @@ const NORMALIZE_INPUTS = [
     // distinctness anchors (must NOT collapse together)
     "Khorne",
     "Khârn",
+    // Unicode whitespace beyond ASCII — every Unicode whitespace must collapse
+    // identically across implementations or `find("Khorne Lord")` and
+    // `find("Khorne Lord")` will silently disagree across ports.
+    "Khorne Lord",
+    "Khorne　Lord",
+    // Turkish dotted-I: NFD decomposes to `I` + combining dot above; the dot is
+    // stripped, then locale-independent lowercase yields `i`. The case pins that
+    // no implementation introduces locale-aware casefolding (which would map
+    // `I` → `ı` under Turkish locale and break ASCII-text search).
+    "İmperial Fists",
+    // Zero-width joiner: passes through every step today. Pinned so behavior
+    // does not silently change — if a future commit strips Cf-category chars,
+    // this golden updates in the same PR.
+    "Khorne‍Lord",
 ];
-/** Pretty JSON with a trailing newline (matches the repo's 2-space convention). */
 function writeJson(path, value) {
     writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
 }
+function writeText(path, value) {
+    writeFileSync(path, value);
+}
 function genNormalize() {
     const table = NORMALIZE_INPUTS.map((input) => ({ input, expected: normalizeName(input) }));
     writeJson(join(CONFORMANCE, "normalize.json"), table);
     console.log(`normalize.json: ${table.length} cases`);
 }
+/** Locate the canonical input for a fixture dir: prefer `input.json` (legacy
+ * ListForge), then `input.newrecruit-json.json` (NewRecruit), then the
+ * text-only `input.gw.txt` (GW app export — import-only, like ListForge). */
+function seedRoster(caseDir, ds) {
+    const decoded = decodeCanonicalSeed(caseDir);
+    return importRoster(decoded, { dataset: ds });
+}
+/** Return the decoded payload for the canonical seed — the same value the
+ * import pipeline would dispatch on. JSON seeds come back parsed; text seeds
+ * come back as the raw string. */
+function decodeCanonicalSeed(caseDir) {
+    const jsonSeed = join(caseDir, "input.json");
+    if (existsSync(jsonSeed)) {
+        return JSON.parse(readFileSync(jsonSeed, "utf8"));
+    }
+    const nrSeed = join(caseDir, "input.newrecruit-json.json");
+    if (existsSync(nrSeed)) {
+        return JSON.parse(readFileSync(nrSeed, "utf8"));
+    }
+    const gwSeed = join(caseDir, "input.gw.txt");
+    if (existsSync(gwSeed)) {
+        return readFileSync(gwSeed, "utf8");
+    }
+    throw new Error(`no canonical input found in ${caseDir}`);
+}
+/** Run a decoded payload through the adapter pipeline up to (but not past)
+ * resolution. The result is the format-agnostic ParsedRoster — the same
+ * intermediate the resolver consumes. Pinning this layer surfaces parser
+ * regressions even when resolution masks them. */
+function parsedFromCanonicalSeed(caseDir) {
+    const decoded = decodeCanonicalSeed(caseDir);
+    const adapter = selectAdapter(decoded, [...REGISTERED_ADAPTERS]);
+    return adapter.parse(decoded);
+}
+const TEXT_FORMATS = [
+    {
+        format: "newrecruit-wtc-compact",
+        inputName: "input.newrecruit-wtc-compact.txt",
+        goldenName: "expected.newrecruit-wtc-compact.txt",
+    },
+    {
+        format: "newrecruit-wtc-full",
+        inputName: "input.newrecruit-wtc-full.txt",
+        goldenName: "expected.newrecruit-wtc-full.txt",
+    },
+    {
+        format: "newrecruit-simple",
+        inputName: "input.newrecruit-simple.txt",
+        goldenName: "expected.newrecruit-simple.txt",
+    },
+];
 function genRosters() {
     const ds = Dataset.embedded();
     const rosterDir = join(CONFORMANCE, "roster");
@@ -60,11 +138,195 @@ function genRosters() {
         if (!entry.isDirectory())
             continue;
         const caseDir = join(rosterDir, entry.name);
-        const input = JSON.parse(readFileSync(join(caseDir, "input.json"), "utf8"));
-        const roster = importRoster(input, { dataset: ds });
-        writeJson(join(caseDir, "expected.roster.json"), roster);
-        console.log(`roster/${entry.name}: ${roster.units.length} units, ${roster.diagnostics.warnings.length} warnings`);
+        const seed = seedRoster(caseDir, ds);
+        writeJson(join(caseDir, "expected.roster.json"), seed);
+        // Parsed-stage golden — the intermediate ParsedRoster produced by the
+        // adapter for the canonical seed, before resolution. Catches parser bugs
+        // that resolution would otherwise mask (e.g. wrong unit count from a
+        // duplicate cost line that resolves to the same unit twice).
+        writeJson(join(caseDir, "expected.parsed.json"), parsedFromCanonicalSeed(caseDir));
+        // JSON export golden — NewRecruit-shaped skeleton.
+        const jsonOut = exportRoster(seed, "newrecruit-json");
+        writeJson(join(caseDir, "expected.newrecruit-json.json"), JSON.parse(jsonOut));
+        // Canonical Roster JSON export — should equal the resolved roster.
+        writeJson(join(caseDir, "expected.roster-json.json"), JSON.parse(exportRoster(seed, "roster-json")));
+        // Text exports: always write the export golden so every fixture exercises
+        // the cross-implementation byte-equality check. Only write the
+        // `input.*.txt` round-trip seed when the fixture was authored for the
+        // NewRecruit pipeline — legacy ListForge fixtures carry decoration
+        // (multi-force warnings, leader-attachment inference) that the simple/wtc
+        // exporters can't fully preserve, so the round-trip would fail
+        // structurally rather than uncover a parser bug.
+        const isNewRecruitSeed = existsSync(join(caseDir, "input.newrecruit-json.json"));
+        for (const { format, inputName, goldenName } of TEXT_FORMATS) {
+            const out = exportRoster(seed, format);
+            writeText(join(caseDir, goldenName), out);
+            if (isNewRecruitSeed) {
+                writeText(join(caseDir, inputName), out);
+            }
+        }
+        // Rosterizer JSON export + a derived round-trip input. The exporter is
+        // deterministic and round-trips through the adapter, so emitting it as
+        // both `expected.rosterizer.json` and `input.rosterizer.json` pins the
+        // cross-implementation goldens and the importer regression at the same
+        // time. Same NewRecruit-seed gate as the text formats — multi-force
+        // ListForge fixtures lose their provisional leader-attachment under
+        // round-trip, so they only get the export golden, not the derived input.
+        const rosterizerOut = exportRoster(seed, "rosterizer");
+        writeJson(join(caseDir, "expected.rosterizer.json"), JSON.parse(rosterizerOut));
+        if (isNewRecruitSeed) {
+            writeJson(join(caseDir, "input.rosterizer.json"), JSON.parse(rosterizerOut));
+        }
+        console.log(`roster/${entry.name}: ${seed.units.length} units, ${seed.diagnostics.warnings.length} warnings`);
+    }
+}
+const LINKED_API_QUERIES = [
+    // find_unit: diacritic-insensitive lookup, miss returns null.
+    { name: "find_unit by diacritic name", query: "find_unit", args: { query: "Kharn" }, comparison: "scalar" },
+    { name: "find_unit miss returns null", query: "find_unit", args: { query: "not-a-real-unit-xyz" }, comparison: "scalar" },
+    // find_weapon: hyphen + space tolerance.
+    { name: "find_weapon by name", query: "find_weapon", args: { query: "bolt rifle" }, comparison: "scalar" },
+    // find_faction: punctuation/diacritic tolerance.
+    { name: "find_faction by display name", query: "find_faction", args: { query: "World Eaters" }, comparison: "scalar" },
+    // find_ability: ability name lookup.
+    { name: "find_ability by name", query: "find_ability", args: { query: "Berzerker Frenzy" }, comparison: "scalar" },
+    // abilities_of(unit): ordered, iterates unit.ability_ids array.
+    { name: "abilities_of intercessor-squad", query: "abilities_of", args: { unitId: "intercessor-squad" }, comparison: "ordered" },
+    { name: "abilities_of kharn-the-betrayer", query: "abilities_of", args: { unitId: "kharn-the-betrayer" }, comparison: "ordered" },
+    // weapons_of(unit): ordered, iterates unit.weapon_ids array.
+    { name: "weapons_of intercessor-squad", query: "weapons_of", args: { unitId: "intercessor-squad" }, comparison: "ordered" },
+    { name: "weapons_of kharn-the-betrayer", query: "weapons_of", args: { unitId: "kharn-the-betrayer" }, comparison: "ordered" },
+    // phases_of(ability): compared as set (phase index iteration order is incidental).
+    { name: "phases_of berzerker-frenzy", query: "phases_of", args: { abilityId: "berzerker-frenzy" }, comparison: "set" },
+    // faction_of(unit): scalar id or null.
+    { name: "faction_of intercessor-squad", query: "faction_of", args: { unitId: "intercessor-squad" }, comparison: "scalar" },
+    // abilities_of_faction: compared as set (collection-index order is incidental).
+    { name: "abilities_of_faction world-eaters", query: "abilities_of_faction", args: { factionId: "world-eaters" }, comparison: "set" },
+    // weapons_of_faction: compared as set.
+    { name: "weapons_of_faction world-eaters", query: "weapons_of_faction", args: { factionId: "world-eaters" }, comparison: "set" },
+];
+function genLinkedApi() {
+    const ds = Dataset.embedded();
+    const cases = LINKED_API_QUERIES.map((q) => {
+        const expected = runLinkedQuery(ds, q);
+        return { ...q, expected };
+    });
+    writeJson(join(CONFORMANCE, "linked-api", "cases.json"), cases);
+    console.log(`linked-api/cases.json: ${cases.length} cases`);
+}
+function runLinkedQuery(ds, q) {
+    switch (q.query) {
+        case "find_unit":
+            return ds.units.find(q.args.query)?.id ?? null;
+        case "find_weapon":
+            return ds.weapons.find(q.args.query)?.id ?? null;
+        case "find_faction":
+            return ds.factions.find(q.args.query)?.id ?? null;
+        case "find_ability":
+            return ds.abilities.find(q.args.query)?.id ?? null;
+        case "abilities_of": {
+            const u = ds.units.get(q.args.unitId);
+            if (!u)
+                throw new Error(`abilities_of: unknown unit ${q.args.unitId}`);
+            return u.abilities.map((a) => a.id);
+        }
+        case "weapons_of": {
+            const u = ds.units.get(q.args.unitId);
+            if (!u)
+                throw new Error(`weapons_of: unknown unit ${q.args.unitId}`);
+            return u.weapons.map((w) => w.id);
+        }
+        case "phases_of": {
+            const a = ds.abilities.get(q.args.abilityId);
+            if (!a)
+                throw new Error(`phases_of: unknown ability ${q.args.abilityId}`);
+            return [...a.phases].sort();
+        }
+        case "faction_of": {
+            const u = ds.units.get(q.args.unitId);
+            if (!u)
+                throw new Error(`faction_of: unknown unit ${q.args.unitId}`);
+            return u.faction?.id ?? null;
+        }
+        case "abilities_of_faction":
+            return ds.abilities.byFaction(q.args.factionId).map((a) => a.id).sort();
+        case "weapons_of_faction": {
+            // Mirrors Rust `weapons_of_faction`: aggregate weapons across the
+            // faction's units and dedupe by id. The collection-level
+            // `weapons.byFaction()` is a different operation (it looks up weapons
+            // whose own `faction_id` is set, which is empty for most factions).
+            const f = ds.factions.get(q.args.factionId);
+            if (!f)
+                throw new Error(`weapons_of_faction: unknown faction ${q.args.factionId}`);
+            return f.weapons.map((w) => w.id).sort();
+        }
     }
 }
+/**
+ * Attribution corpus: reuses the existing cruncher inputs from the cases that
+ * carry at least one groupable buff (ability or manual). The expected shape
+ * is the AttributedStage array produced by attributeStages; both
+ * implementations of the leave-one-out decomposition must reproduce it
+ * within the per-stage float tolerance.
+ */
+const ATTRIBUTION_CASE_FILES = [
+    "05-anti-infantry-vs-cultist.json",
+    "07-twin-linked-heavy-stationary-vs-knight.json",
+];
+function loadAttributionInput(ds, filename) {
+    const path = join(CONFORMANCE, "cruncher", filename);
+    const c = JSON.parse(readFileSync(path, "utf8"));
+    const weapon = ds.weapons.get(c.attacker.weaponId);
+    const unit = ds.units.get(c.target.unitId);
+    if (!weapon)
+        throw new Error(`attribution: unknown weapon ${c.attacker.weaponId}`);
+    if (!unit)
+        throw new Error(`attribution: unknown unit ${c.target.unitId}`);
+    return {
+        name: c.name,
+        input: {
+            attacker: { weapon: weapon.raw, profileIndex: c.attacker.profileIndex },
+            target: {
+                unit: unit.raw,
+                profileIndex: c.target.profileIndex,
+                ...(c.target.modelCount !== undefined ? { modelCount: c.target.modelCount } : {}),
+            },
+            modelsFiring: c.modelsFiring,
+            buffs: c.buffs,
+            context: c.context,
+        },
+    };
+}
+function genAttribution() {
+    const ds = Dataset.embedded();
+    const cases = ATTRIBUTION_CASE_FILES.map((filename, idx) => {
+        const { name, input } = loadAttributionInput(ds, filename);
+        const stages = attributeStages(input, ds);
+        return {
+            // Persist the input by file reference so the corpus stays a single
+            // source of truth — the cruncher case file already pins the EngineInput.
+            name,
+            cruncher_case: filename,
+            expected: stages.map((s) => ({
+                name: s.name,
+                expected: s.expected,
+                baseline: s.baseline,
+                lifts: s.lifts.map((l) => ({ source: l.source, delta: l.delta })),
+                residual: s.residual,
+                intrinsics: s.intrinsics,
+            })),
+            // Stable ordering of cases in the corpus file.
+            _order: idx,
+        };
+    });
+    // Sort by _order and strip the helper before writing.
+    cases.sort((a, b) => a._order - b._order);
+    const serialised = cases.map(({ _order: _o, ...rest }) => rest);
+    writeJson(join(CONFORMANCE, "attribution", "cases.json"), serialised);
+    console.log(`attribution/cases.json: ${cases.length} cases`);
+}
 genNormalize();
 genRosters();
+genLinkedApi();
+genAttribution();
+//# sourceMappingURL=gen-conformance.js.map