@alpaca-software/40kdc-data 0.5.14 → 0.5.15

package/dist/gen-conformance.js

@@ -28,6 +28,7 @@ import { describeScoringCard, describeAbility } from "./translate/index.js";
 import { awardsOf } from "./scoring/index.js";
 import { createRunnerState, dispatch } from "./runner.js";
 import { exportRoster } from "./export/index.js";
+import { decodeShareToken, encodeShareToken, shareRegistryVersion, } from "./share/index.js";
 import { importRoster, REGISTERED_ADAPTERS } from "./import/import-roster.js";
 import { selectAdapter } from "./import/adapter.js";
 import { encodeBase } from "./runner.js";
@@ -235,6 +236,18 @@ const LINKED_API_QUERIES = [
     { name: "base_size_of windriders (draft flying base)", query: "base_size_of", args: { unitId: "windriders" }, comparison: "scalar" },
     // model_bases_of(unit): ordered per-model bases; jakhals mixes 28.5mm bodies with a 40mm Dishonoured.
     { name: "model_bases_of jakhals (mixed)", query: "model_bases_of", args: { unitId: "jakhals" }, comparison: "ordered" },
+    // units_with_keyword: case-insensitive over keywords ∪ faction_keywords; compared as set.
+    { name: "units_with_keyword Khorne", query: "units_with_keyword", args: { keyword: "Khorne" }, comparison: "set" },
+    { name: "units_with_keyword damned (lowercase)", query: "units_with_keyword", args: { keyword: "damned" }, comparison: "set" },
+    // allies_for: two-gate offer; ordered (allied-rules data-file order, locale-independent).
+    { name: "allies_for chaos-knights (no detachment)", query: "allies_for", args: { factionId: "chaos-knights" }, comparison: "ordered" },
+    { name: "allies_for chaos-knights with iconoclast-fiefdom", query: "allies_for", args: { factionId: "chaos-knights", detachmentIds: ["iconoclast-fiefdom"] }, comparison: "ordered" },
+    { name: "allies_for world-eaters (two pools)", query: "allies_for", args: { factionId: "world-eaters" }, comparison: "ordered" },
+    { name: "allies_for genestealer-cults with final-day", query: "allies_for", args: { factionId: "genestealer-cults", detachmentIds: ["final-day"] }, comparison: "ordered" },
+    // ally_units_for: resolved pool; compared as set (accessor sorts by name, locale-dependent).
+    { name: "ally_units_for iconoclast-fiefdom-damned", query: "ally_units_for", args: { ruleId: "iconoclast-fiefdom-damned" }, comparison: "set" },
+    { name: "ally_units_for world-eaters-khorne-daemons", query: "ally_units_for", args: { ruleId: "world-eaters-khorne-daemons" }, comparison: "set" },
+    { name: "ally_units_for star-childrens-blessings (excludes broodlord/genestealers)", query: "ally_units_for", args: { ruleId: "star-childrens-blessings" }, comparison: "set" },
 ];
 function genLinkedApi() {
     const ds = Dataset.embedded();
@@ -304,6 +317,13 @@ function runLinkedQuery(ds, q) {
             const comp = ds.unitCompositions.find((c) => c.unit_id === q.args.unitId);
             return (comp?.models ?? []).map((m) => `${m.name}=${encodeBase(m.base_size_mm) ?? "none"}`);
         }
+        case "units_with_keyword":
+            return ds.unitsWithKeyword(q.args.keyword).map((u) => u.id).sort();
+        case "allies_for":
+            // Ordered: allied-rules data-file order (deterministic across impls).
+            return ds.alliesFor(q.args.factionId, q.args.detachmentIds ?? []).map((r) => r.id);
+        case "ally_units_for":
+            return ds.allyUnitsFor(q.args.ruleId).map((u) => u.id).sort();
     }
 }
 /**
@@ -971,6 +991,147 @@ function genEffectTranslation() {
     writeJson(join(CONFORMANCE, "effect-translation", "cases.json"), cases);
     console.log(`effect-translation/cases.json: ${cases.length} cases (${seen.size} node types)`);
 }
+/** Unsigned LEB128 of a small non-negative integer (for hand-built tokens). */
+function leb128(value) {
+    const out = [];
+    let v = value;
+    while (v >= 0x80) {
+        out.push((v & 0x7f) | 0x80);
+        v = Math.floor(v / 0x80);
+    }
+    out.push(v);
+    return out;
+}
+/** base64url (no padding) of a raw byte array — for negative decode goldens. */
+function bytesToBase64url(bytes) {
+    return Buffer.from(bytes)
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+/**
+ * The share-token corpus. Each positive case pins `encodeShareToken(list)` to an
+ * exact `token` and asserts `decodeShareToken(token)` round-trips to `list`;
+ * negative cases pin the decoder's `malformed` / `stale-registry` verdicts. The
+ * input lists are derived from the embedded dataset deterministically (sorted,
+ * first-N) so the goldens are stable and self-maintaining. Rust and Python must
+ * reproduce every `token` byte-for-byte and every decode verdict.
+ */
+function genShare() {
+    mkdirSync(join(CONFORMANCE, "share"), { recursive: true });
+    const ds = Dataset.embedded();
+    const f = "adeptus-astartes";
+    const dets = ds.detachments.all
+        .filter((d) => d.faction_id === f)
+        .map((d) => d.id)
+        .sort();
+    const units = ds.units
+        .byFaction(f)
+        .map((u) => u.id)
+        .sort();
+    const weapons = ds.weapons.all.map((w) => w.id).sort();
+    const enhancement = ds.enhancements.all.map((e) => e.id).sort()[0];
+    const disposition = ds.forceDispositions.all.map((d) => d.id).sort()[0];
+    const allyFactionId = "chaos-daemons";
+    const allyRuleId = ds.alliedRules.all.map((r) => r.id).sort()[0];
+    const plainUnit = (id) => ({
+        datasheetId: id,
+        modelCount: 1,
+        isWarlord: false,
+        enhancementId: null,
+        allyFactionId: null,
+        allyRuleId: null,
+        attachedToOrdinal: null,
+        grants: [],
+        loadout: [],
+    });
+    const lists = [
+        {
+            name: "minimal",
+            list: {
+                name: "",
+                factionId: f,
+                detachmentIds: [],
+                battleSize: "strike-force",
+                disposition: null,
+                units: [],
+            },
+        },
+        {
+            name: "warlord-enhancement-grants",
+            list: {
+                name: "Strîke Force 🔨",
+                factionId: f,
+                detachmentIds: [dets[0]],
+                battleSize: "strike-force",
+                disposition,
+                units: [
+                    {
+                        ...plainUnit(units[0]),
+                        modelCount: 5,
+                        isWarlord: true,
+                        enhancementId: enhancement,
+                        grants: ["Character"],
+                        loadout: [
+                            [weapons[0], 2],
+                            [weapons[1], 1],
+                        ],
+                    },
+                    { ...plainUnit(units[1]), modelCount: 10, loadout: [[weapons[2], 10]] },
+                ],
+            },
+        },
+        {
+            name: "allies-attachment",
+            list: {
+                name: "Soup",
+                factionId: f,
+                detachmentIds: [dets[0], dets[1]],
+                battleSize: "incursion",
+                disposition,
+                units: [
+                    { ...plainUnit(units[0]), isWarlord: true, attachedToOrdinal: 1 }, // leader → bodyguard
+                    { ...plainUnit(units[1]), modelCount: 5 },
+                    {
+                        ...plainUnit(units[2]),
+                        allyFactionId,
+                        allyRuleId,
+                        grants: ["Battleline"],
+                        loadout: [[weapons[3], 1]],
+                    },
+                ],
+            },
+        },
+    ];
+    const cases = lists.map(({ name, list }) => {
+        const token = encodeShareToken(list);
+        const decoded = decodeShareToken(token);
+        if (!decoded.ok)
+            throw new Error(`share case ${name} failed to round-trip: ${decoded.reason}`);
+        // Sanity: the generator's own round-trip must reproduce the input exactly.
+        if (JSON.stringify(decoded.list) !== JSON.stringify(list)) {
+            throw new Error(`share case ${name} did not round-trip losslessly`);
+        }
+        return { name, list, token };
+    });
+    // Negative decode cases (deterministic hand-built tokens).
+    cases.push({
+        name: "malformed-bad-format-byte",
+        decode_token: bytesToBase64url([0x00]),
+        expected_decode: { ok: false, reason: "malformed" },
+    });
+    cases.push({
+        name: "stale-future-index",
+        // Valid header (format 1, registry version, empty name) then a faction
+        // index no committed registry will ever hold → stale-registry.
+        decode_token: bytesToBase64url([0x01, ...leb128(shareRegistryVersion), 0x00, ...leb128(2_000_000)]),
+        expected_decode: { ok: false, reason: "stale-registry" },
+    });
+    writeJson(join(CONFORMANCE, "share", "cases.json"), cases);
+    console.log(`share/cases.json: ${cases.length} cases (registry v${shareRegistryVersion}, ` +
+        `${cases.filter((c) => c.token).length} round-trip + ${cases.filter((c) => c.decode_token).length} negative)`);
+}
 genNormalize();
 genRosters();
 genLinkedApi();
@@ -980,4 +1141,5 @@ genEffectTranslation();
 genScoring();
 genTerrainResolver();
 genTerrainKeystones();
+genShare();
 //# sourceMappingURL=gen-conformance.js.map