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

package/README.md

@@ -1,5 +1,7 @@
 # @alpaca-software/40kdc-data
 
+Published by [Alpaca Software](https://alpacasoft.dev).
+
 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 —

package/dist/abilities-resolver/resolver.d.ts

@@ -12,7 +12,10 @@
  * 3. **detachment-stratagem** — stratagems on the detachment, each yielding
  *    the ability referenced by `stratagem.ability_id` (if any).
  * 4. **unit** — abilities listed in `unit.ability_ids`.
- * 5. **leader** — abilities listed in the attached leader's `ability_ids`.
+ * 5. **attached** — abilities of each attached member. A leader + bodyguard
+ *    (and, in 11th, support) form one combined unit, so every member's
+ *    abilities apply to the whole unit — pulled in full (not aura-filtered),
+ *    whichever member is the selected/firing unit.
  * 6. **support** — abilities on supporting units whose scope range is an
  *    aura (not `self` / `unit`).
  *
@@ -38,8 +41,8 @@ export type EligibleAbilitySource = {
     kind: "unit";
     unitId: string;
 } | {
-    kind: "leader";
-    leaderId: string;
+    kind: "attached";
+    unitId: string;
 } | {
     kind: "support";
     sourceUnitId: string;
@@ -49,7 +52,13 @@ export type EligibilityInput = {
     /** Overrides the unit's own `faction_id` when given (for inheritance cases). */
     factionId?: string;
     detachmentId?: string;
-    attachedLeaderId?: string;
+    /**
+     * Other members of the combined ("attached") unit — the attached leader, its
+     * bodyguard, or (11th) support attachments — whichever is *not* the selected
+     * `unitId`. Their abilities are pooled onto the combined unit. A list so
+     * multi-member attachments need no shape change; order is preserved.
+     */
+    attachedUnitIds?: string[];
     /** Friendly units whose auras could apply (M2 walks only their aura-ranged abilities). */
     supportingUnitIds?: string[];
 };

package/dist/abilities-resolver/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/abilities-resolver/resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,MAAM,qBAAqB,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0FAA0F;IAC1F,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,yEAAyE;IACzE,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF,gFAAgF;AAChF,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,KAAK,GACX,eAAe,EAAE,CA8FnB"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/abilities-resolver/resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,MAAM,qBAAqB,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,0FAA0F;IAC1F,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,yEAAyE;IACzE,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF,gFAAgF;AAChF,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,KAAK,GACX,eAAe,EAAE,CAsGnB"}

package/dist/abilities-resolver/resolver.js

@@ -1,6 +1,11 @@
 /** Compute the sorted-by-source eligible-ability list for one (unit, phase). */
 export function resolveEligibleAbilities(dataset, input, phase) {
-    const unit = dataset.units.get(input.unitId);
+    // Resolve units within the faction when one is known. Unit ids are shared
+    // across factions (a shared chassis like `chaos-land-raider` lives under
+    // several Chaos factions), so a faction-blind `get` can return the wrong
+    // faction's copy — and with it the wrong intrinsic abilities/keywords.
+    const resolveUnit = (id, fid) => (fid ? dataset.units.getInFaction(id, fid) : undefined) ?? dataset.units.get(id);
+    const unit = resolveUnit(input.unitId, input.factionId);
     if (!unit)
         return [];
     const factionId = input.factionId ?? unit.raw.faction_id;
@@ -65,25 +70,27 @@ export function resolveEligibleAbilities(dataset, input, phase) {
             phases: intersect(ability.phases, phase),
         });
     }
-    // 5. Attached leader.
-    if (input.attachedLeaderId) {
-        const leader = dataset.units.get(input.attachedLeaderId);
-        if (leader) {
-            for (const ability of leader.abilities) {
-                if (!phaseMatches(ability, phase))
-                    continue;
-                pushUnique(out, seen, {
-                    ability,
-                    source: { kind: "leader", leaderId: input.attachedLeaderId },
-                    phases: intersect(ability.phases, phase),
-                });
-            }
+    // 5. Attached members — the combined unit pools every member's abilities,
+    // pulled in full (not aura-filtered like step 6), regardless of which member
+    // is the selected/firing unit.
+    for (const memberId of input.attachedUnitIds ?? []) {
+        const member = resolveUnit(memberId, factionId);
+        if (!member)
+            continue;
+        for (const ability of member.abilities) {
+            if (!phaseMatches(ability, phase))
+                continue;
+            pushUnique(out, seen, {
+                ability,
+                source: { kind: "attached", unitId: memberId },
+                phases: intersect(ability.phases, phase),
+            });
         }
     }
     // 6. Supporting units — only aura-scoped abilities (otherwise the buff
     // would describe a self-target effect that doesn't reach the input unit).
     for (const supportId of input.supportingUnitIds ?? []) {
-        const supporter = dataset.units.get(supportId);
+        const supporter = resolveUnit(supportId, factionId);
         if (!supporter)
             continue;
         for (const ability of supporter.abilities) {

package/dist/abilities-resolver/resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/abilities-resolver/resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Walks the dataset for every ability that could apply to a chosen unit in a\n * chosen phase. The SPA passes the result through to the buff layer (each\n * {@link EligibleAbility} carries `.getBuffs()`, the source is pre-tagged).\n *\n * Resolution order — stable for snapshot tests:\n *\n * 1. **army** — faction-scoped abilities whose `ability_type` is `\"faction\"`\n *    and whose `faction_id` matches the input.\n * 2. **detachment** — abilities authored against the detachment\n *    (`ability_type` is `\"detachment\"`, `detachment_id` matches).\n * 3. **detachment-stratagem** — stratagems on the detachment, each yielding\n *    the ability referenced by `stratagem.ability_id` (if any).\n * 4. **unit** — abilities listed in `unit.ability_ids`.\n * 5. **leader** — abilities listed in the attached leader's `ability_ids`.\n * 6. **support** — abilities on supporting units whose scope range is an\n *    aura (not `self` / `unit`).\n *\n * Each step phase-filters via the existing `Dataset.phasesFor` index. The\n * resolver collects abilities first, *then* filters by phase, so the SPA can\n * also ask \"what abilities are eligible across all phases?\" by passing every\n * phase (today the API requires a single phase; if the SPA wants the wide\n * view it can call the resolver once per phase).\n */\nimport type { Phase, Stratagem } from \"../generated.js\";\nimport type { Dataset } from \"../data/dataset.js\";\nimport type { AbilityView } from \"../data/entities.js\";\n\nexport type EligibleAbilitySource =\n  | { kind: \"army\" }\n  | { kind: \"detachment\"; detachmentId: string }\n  | { kind: \"detachment-stratagem\"; stratagemId: string; cpCost: number }\n  | { kind: \"unit\"; unitId: string }\n  | { kind: \"leader\"; leaderId: string }\n  | { kind: \"support\"; sourceUnitId: string };\n\nexport type EligibilityInput = {\n  unitId: string;\n  /** Overrides the unit's own `faction_id` when given (for inheritance cases). */\n  factionId?: string;\n  detachmentId?: string;\n  attachedLeaderId?: string;\n  /** Friendly units whose auras could apply (M2 walks only their aura-ranged abilities). */\n  supportingUnitIds?: string[];\n};\n\nexport type EligibleAbility = {\n  ability: AbilityView;\n  source: EligibleAbilitySource;\n  /** The subset of `ability.phases` that intersect the requested phase. */\n  phases: Phase[];\n};\n\n/** Compute the sorted-by-source eligible-ability list for one (unit, phase). */\nexport function resolveEligibleAbilities(\n  dataset: Dataset,\n  input: EligibilityInput,\n  phase: Phase,\n): EligibleAbility[] {\n  const unit = dataset.units.get(input.unitId);\n  if (!unit) return [];\n  const factionId = input.factionId ?? unit.raw.faction_id;\n  const seen = new Set<string>();\n  const out: EligibleAbility[] = [];\n\n  // 1. Army — faction-scoped abilities (faction rule + any other faction-typed).\n  for (const ability of dataset.abilities.byFaction(factionId)) {\n    if (ability.raw.ability_type !== \"faction\") continue;\n    if (!phaseMatches(ability, phase)) continue;\n    pushUnique(out, seen, { ability, source: { kind: \"army\" }, phases: intersect(ability.phases, phase) });\n  }\n\n  // 2. Detachment abilities — abilities whose detachment_id matches.\n  if (input.detachmentId) {\n    for (const ability of dataset.abilities) {\n      if (ability.raw.ability_type !== \"detachment\") continue;\n      if (ability.raw.detachment_id !== input.detachmentId) continue;\n      if (!phaseMatches(ability, phase)) continue;\n      pushUnique(out, seen, {\n        ability,\n        source: { kind: \"detachment\", detachmentId: input.detachmentId },\n        phases: intersect(ability.phases, phase),\n      });\n    }\n\n    // 3. Detachment stratagems.\n    const detachment = dataset.detachments.get(input.detachmentId);\n    if (detachment) {\n      for (const stratId of detachment.stratagem_ids ?? []) {\n        const stratagem = dataset.stratagems.get(stratId);\n        if (!stratagem) continue;\n        if (!stratagemPhaseMatches(stratagem, phase)) continue;\n        const ability =\n          stratagem.ability_id !== null && stratagem.ability_id !== undefined\n            ? dataset.abilities.get(stratagem.ability_id)\n            : undefined;\n        if (!ability) continue;\n        pushUnique(out, seen, {\n          ability,\n          source: {\n            kind: \"detachment-stratagem\",\n            stratagemId: stratagem.id,\n            cpCost: stratagem.cp_cost,\n          },\n          phases: [phase], // the stratagem's printed phase governs eligibility.\n        });\n      }\n    }\n  }\n\n  // 4. Unit's own abilities.\n  for (const ability of unit.abilities) {\n    if (!phaseMatches(ability, phase)) continue;\n    pushUnique(out, seen, {\n      ability,\n      source: { kind: \"unit\", unitId: input.unitId },\n      phases: intersect(ability.phases, phase),\n    });\n  }\n\n  // 5. Attached leader.\n  if (input.attachedLeaderId) {\n    const leader = dataset.units.get(input.attachedLeaderId);\n    if (leader) {\n      for (const ability of leader.abilities) {\n        if (!phaseMatches(ability, phase)) continue;\n        pushUnique(out, seen, {\n          ability,\n          source: { kind: \"leader\", leaderId: input.attachedLeaderId },\n          phases: intersect(ability.phases, phase),\n        });\n      }\n    }\n  }\n\n  // 6. Supporting units — only aura-scoped abilities (otherwise the buff\n  // would describe a self-target effect that doesn't reach the input unit).\n  for (const supportId of input.supportingUnitIds ?? []) {\n    const supporter = dataset.units.get(supportId);\n    if (!supporter) continue;\n    for (const ability of supporter.abilities) {\n      if (!phaseMatches(ability, phase)) continue;\n      if (!isAuraScope(ability.raw.scope?.range)) continue;\n      pushUnique(out, seen, {\n        ability,\n        source: { kind: \"support\", sourceUnitId: supportId },\n        phases: intersect(ability.phases, phase),\n      });\n    }\n  }\n\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nfunction phaseMatches(ability: AbilityView, phase: Phase): boolean {\n  const phases = ability.phases;\n  // An ability with no phase-mapping is permissive — surface it everywhere so\n  // the SPA can decide. M2's translator already gates conditional-on-phase\n  // effects internally, so this stays generous on purpose.\n  if (phases.length === 0) return true;\n  return phases.includes(phase);\n}\n\nfunction stratagemPhaseMatches(stratagem: Stratagem, phase: Phase): boolean {\n  if (!stratagem.phases || stratagem.phases.length === 0) return false;\n  return (stratagem.phases as Phase[]).includes(phase);\n}\n\nfunction intersect(phases: Phase[], phase: Phase): Phase[] {\n  return phases.includes(phase) ? [phase] : phases;\n}\n\nfunction isAuraScope(range: unknown): boolean {\n  if (typeof range !== \"string\") return false;\n  return range.startsWith(\"aura-\") || range === \"any-on-battlefield\" || range === \"any-visible\";\n}\n\nfunction pushUnique(\n  out: EligibleAbility[],\n  seen: Set<string>,\n  entry: EligibleAbility,\n): void {\n  const key = `${entry.source.kind}::${entry.ability.id}`;\n  if (seen.has(key)) return;\n  seen.add(key);\n  out.push(entry);\n}\n"]}
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/abilities-resolver/resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Walks the dataset for every ability that could apply to a chosen unit in a\n * chosen phase. The SPA passes the result through to the buff layer (each\n * {@link EligibleAbility} carries `.getBuffs()`, the source is pre-tagged).\n *\n * Resolution order — stable for snapshot tests:\n *\n * 1. **army** — faction-scoped abilities whose `ability_type` is `\"faction\"`\n *    and whose `faction_id` matches the input.\n * 2. **detachment** — abilities authored against the detachment\n *    (`ability_type` is `\"detachment\"`, `detachment_id` matches).\n * 3. **detachment-stratagem** — stratagems on the detachment, each yielding\n *    the ability referenced by `stratagem.ability_id` (if any).\n * 4. **unit** — abilities listed in `unit.ability_ids`.\n * 5. **attached** — abilities of each attached member. A leader + bodyguard\n *    (and, in 11th, support) form one combined unit, so every member's\n *    abilities apply to the whole unit — pulled in full (not aura-filtered),\n *    whichever member is the selected/firing unit.\n * 6. **support** — abilities on supporting units whose scope range is an\n *    aura (not `self` / `unit`).\n *\n * Each step phase-filters via the existing `Dataset.phasesFor` index. The\n * resolver collects abilities first, *then* filters by phase, so the SPA can\n * also ask \"what abilities are eligible across all phases?\" by passing every\n * phase (today the API requires a single phase; if the SPA wants the wide\n * view it can call the resolver once per phase).\n */\nimport type { Phase, Stratagem } from \"../generated.js\";\nimport type { Dataset } from \"../data/dataset.js\";\nimport type { AbilityView } from \"../data/entities.js\";\n\nexport type EligibleAbilitySource =\n  | { kind: \"army\" }\n  | { kind: \"detachment\"; detachmentId: string }\n  | { kind: \"detachment-stratagem\"; stratagemId: string; cpCost: number }\n  | { kind: \"unit\"; unitId: string }\n  | { kind: \"attached\"; unitId: string }\n  | { kind: \"support\"; sourceUnitId: string };\n\nexport type EligibilityInput = {\n  unitId: string;\n  /** Overrides the unit's own `faction_id` when given (for inheritance cases). */\n  factionId?: string;\n  detachmentId?: string;\n  /**\n   * Other members of the combined (\"attached\") unit — the attached leader, its\n   * bodyguard, or (11th) support attachments — whichever is *not* the selected\n   * `unitId`. Their abilities are pooled onto the combined unit. A list so\n   * multi-member attachments need no shape change; order is preserved.\n   */\n  attachedUnitIds?: string[];\n  /** Friendly units whose auras could apply (M2 walks only their aura-ranged abilities). */\n  supportingUnitIds?: string[];\n};\n\nexport type EligibleAbility = {\n  ability: AbilityView;\n  source: EligibleAbilitySource;\n  /** The subset of `ability.phases` that intersect the requested phase. */\n  phases: Phase[];\n};\n\n/** Compute the sorted-by-source eligible-ability list for one (unit, phase). */\nexport function resolveEligibleAbilities(\n  dataset: Dataset,\n  input: EligibilityInput,\n  phase: Phase,\n): EligibleAbility[] {\n  // Resolve units within the faction when one is known. Unit ids are shared\n  // across factions (a shared chassis like `chaos-land-raider` lives under\n  // several Chaos factions), so a faction-blind `get` can return the wrong\n  // faction's copy — and with it the wrong intrinsic abilities/keywords.\n  const resolveUnit = (id: string, fid: string | undefined) =>\n    (fid ? dataset.units.getInFaction(id, fid) : undefined) ?? dataset.units.get(id);\n\n  const unit = resolveUnit(input.unitId, input.factionId);\n  if (!unit) return [];\n  const factionId = input.factionId ?? unit.raw.faction_id;\n  const seen = new Set<string>();\n  const out: EligibleAbility[] = [];\n\n  // 1. Army — faction-scoped abilities (faction rule + any other faction-typed).\n  for (const ability of dataset.abilities.byFaction(factionId)) {\n    if (ability.raw.ability_type !== \"faction\") continue;\n    if (!phaseMatches(ability, phase)) continue;\n    pushUnique(out, seen, { ability, source: { kind: \"army\" }, phases: intersect(ability.phases, phase) });\n  }\n\n  // 2. Detachment abilities — abilities whose detachment_id matches.\n  if (input.detachmentId) {\n    for (const ability of dataset.abilities) {\n      if (ability.raw.ability_type !== \"detachment\") continue;\n      if (ability.raw.detachment_id !== input.detachmentId) continue;\n      if (!phaseMatches(ability, phase)) continue;\n      pushUnique(out, seen, {\n        ability,\n        source: { kind: \"detachment\", detachmentId: input.detachmentId },\n        phases: intersect(ability.phases, phase),\n      });\n    }\n\n    // 3. Detachment stratagems.\n    const detachment = dataset.detachments.get(input.detachmentId);\n    if (detachment) {\n      for (const stratId of detachment.stratagem_ids ?? []) {\n        const stratagem = dataset.stratagems.get(stratId);\n        if (!stratagem) continue;\n        if (!stratagemPhaseMatches(stratagem, phase)) continue;\n        const ability =\n          stratagem.ability_id !== null && stratagem.ability_id !== undefined\n            ? dataset.abilities.get(stratagem.ability_id)\n            : undefined;\n        if (!ability) continue;\n        pushUnique(out, seen, {\n          ability,\n          source: {\n            kind: \"detachment-stratagem\",\n            stratagemId: stratagem.id,\n            cpCost: stratagem.cp_cost,\n          },\n          phases: [phase], // the stratagem's printed phase governs eligibility.\n        });\n      }\n    }\n  }\n\n  // 4. Unit's own abilities.\n  for (const ability of unit.abilities) {\n    if (!phaseMatches(ability, phase)) continue;\n    pushUnique(out, seen, {\n      ability,\n      source: { kind: \"unit\", unitId: input.unitId },\n      phases: intersect(ability.phases, phase),\n    });\n  }\n\n  // 5. Attached members — the combined unit pools every member's abilities,\n  // pulled in full (not aura-filtered like step 6), regardless of which member\n  // is the selected/firing unit.\n  for (const memberId of input.attachedUnitIds ?? []) {\n    const member = resolveUnit(memberId, factionId);\n    if (!member) continue;\n    for (const ability of member.abilities) {\n      if (!phaseMatches(ability, phase)) continue;\n      pushUnique(out, seen, {\n        ability,\n        source: { kind: \"attached\", unitId: memberId },\n        phases: intersect(ability.phases, phase),\n      });\n    }\n  }\n\n  // 6. Supporting units — only aura-scoped abilities (otherwise the buff\n  // would describe a self-target effect that doesn't reach the input unit).\n  for (const supportId of input.supportingUnitIds ?? []) {\n    const supporter = resolveUnit(supportId, factionId);\n    if (!supporter) continue;\n    for (const ability of supporter.abilities) {\n      if (!phaseMatches(ability, phase)) continue;\n      if (!isAuraScope(ability.raw.scope?.range)) continue;\n      pushUnique(out, seen, {\n        ability,\n        source: { kind: \"support\", sourceUnitId: supportId },\n        phases: intersect(ability.phases, phase),\n      });\n    }\n  }\n\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nfunction phaseMatches(ability: AbilityView, phase: Phase): boolean {\n  const phases = ability.phases;\n  // An ability with no phase-mapping is permissive — surface it everywhere so\n  // the SPA can decide. M2's translator already gates conditional-on-phase\n  // effects internally, so this stays generous on purpose.\n  if (phases.length === 0) return true;\n  return phases.includes(phase);\n}\n\nfunction stratagemPhaseMatches(stratagem: Stratagem, phase: Phase): boolean {\n  if (!stratagem.phases || stratagem.phases.length === 0) return false;\n  return (stratagem.phases as Phase[]).includes(phase);\n}\n\nfunction intersect(phases: Phase[], phase: Phase): Phase[] {\n  return phases.includes(phase) ? [phase] : phases;\n}\n\nfunction isAuraScope(range: unknown): boolean {\n  if (typeof range !== \"string\") return false;\n  return range.startsWith(\"aura-\") || range === \"any-on-battlefield\" || range === \"any-visible\";\n}\n\nfunction pushUnique(\n  out: EligibleAbility[],\n  seen: Set<string>,\n  entry: EligibleAbility,\n): void {\n  const key = `${entry.source.kind}::${entry.ability.id}`;\n  if (seen.has(key)) return;\n  seen.add(key);\n  out.push(entry);\n}\n"]}

package/dist/audit-coverage.d.ts

@@ -0,0 +1,78 @@
+/** Shape of an authored ability entry (only the fields this audit reads). */
+interface AbilityEntry {
+    ability_id: string;
+    name?: string;
+    ability_type?: string;
+    community_notes?: string;
+    effect?: unknown;
+}
+export interface FactionCoverage {
+    faction: string;
+    total: number;
+    offensive: number;
+    defensive: number;
+    /** Produces neither an offensive nor a defensive buff. */
+    inert: number;
+    /** `community_notes` flags it an auto-generated stub / partial. */
+    stub: number;
+    /**
+     * Structurally a placeholder: the effect tree contains a modifier-bearing
+     * node with an empty `modifier: {}` (the original pass's untyped stub, e.g.
+     * `stat-modifier {}`). This — not `inert` — is the authoring worklist: an
+     * inert-but-correctly-typed ability (movement, objective control) is *done*;
+     * an empty-modifier node is a gap regardless of who consumes it.
+     */
+    stubStructural: number;
+    /** `community_notes` carries a verbatim GW `"Original:"` text dump (IP leak). */
+    gwTextLeak: number;
+    /** Explicitly tagged `"defensive ability (skipped for damage calc)"`. */
+    defensiveSkipped: number;
+}
+/**
+ * One named gap. Carries the ability's identity and current shape so the gap is
+ * self-describing on the consumer end (the fan-out joins the source rule; the
+ * editor / downstream tools can list "what's unauthored" without re-deriving).
+ */
+export interface WorklistEntry {
+    faction: string;
+    ability_id: string;
+    name: string;
+    /** Top-level effect type as authored today (the "shape"), or `null` if absent. */
+    shape: string | null;
+    /** Has an empty-modifier placeholder node somewhere in its effect tree. */
+    stub: boolean;
+    offensive: boolean;
+    defensive: boolean;
+    /** Most-informative unsupported reason from the attacker walk, if any. */
+    gap: string | null;
+}
+export interface CoverageReport {
+    factions: FactionCoverage[];
+    totals: Omit<FactionCoverage, "faction">;
+    /** `unsupported.reason` (normalized) → count, descending. */
+    unsupportedReasons: {
+        reason: string;
+        count: number;
+    }[];
+    /** Per-ability named gaps — the authoring worklist. */
+    worklist: WorklistEntry[];
+}
+/**
+ * True if any node in the effect tree is a *parameter-requiring* leaf left with
+ * an empty `modifier: {}` — the original pass's untyped placeholder. Pure-flag
+ * effects (see {@link PARAMETERLESS_EFFECTS}) are exempt.
+ */
+export declare function hasEmptyModifier(node: unknown): boolean;
+/** Compute coverage for a set of factions. Pure — IO lives in the command. */
+export declare function computeCoverage(input: {
+    faction: string;
+    abilities: AbilityEntry[];
+}[]): CoverageReport;
+export interface AuditCoverageOptions {
+    reporter?: "pretty" | "json";
+    write?: boolean;
+}
+/** Commander action: run the audit over the repo's enrichment data. */
+export declare function auditCoverageCommand(opts?: AuditCoverageOptions): void;
+export {};
+//# sourceMappingURL=audit-coverage.d.ts.map

package/dist/audit-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-coverage.d.ts","sourceRoot":"","sources":["../src/audit-coverage.ts"],"names":[],"mappings":"AA0CA,6EAA6E;AAC7E,UAAU,YAAY;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,2EAA2E;IAC3E,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;IACzC,6DAA6D;IAC7D,kBAAkB,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxD,uDAAuD;IACvD,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B;AAuFD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAiBvD;AAWD,8EAA8E;AAC9E,wBAAgB,eAAe,CAC7B,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,EAAE,GACtD,cAAc,CA2EhB;AA+GD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,uEAAuE;AACvE,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,oBAAyB,GAAG,IAAI,CAkB1E"}

package/dist/audit-coverage.js

@@ -0,0 +1,341 @@
+/**
+ * Ability-coverage audit: measure how much of the community-authored ability
+ * data actually translates into cruncher buffs, per faction.
+ *
+ * The buff layer only interprets a subset of the ability DSL (see
+ * `cruncher/from-dsl.ts`). An ability that doesn't translate is inert in Salvo —
+ * the projection silently falls back to raw-statline math. This tool runs the
+ * *real* translator (`effectToBuffs`) over every authored ability, under both
+ * the attacker and target perspectives and across every phase, and classifies
+ * each entry as:
+ *
+ *   - **offensive** — yields ≥1 attacker-side buff (auto-applied or activatable)
+ *   - **defensive** — yields ≥1 target-side buff
+ *   - **inert** — neither; the effect is `unsupported` and/or a stub
+ *
+ * It also tallies the verbatim-GW-text leak (`community_notes` carrying an
+ * `"Original:"` dump) and the explicit `"skipped for damage calc"` defensive
+ * entries, and histograms the `unsupported.reason` strings so the output is a
+ * directly-actionable authoring worklist.
+ *
+ * Usage:
+ *   npx tsx tools/src/audit-coverage.ts            (pretty report to stdout)
+ *   npx tsx tools/src/audit-coverage.ts --json     (machine-readable)
+ *   npx tsx tools/src/audit-coverage.ts --write     (also emit data/_audit/*)
+ *
+ * Wired as `40kdc-validate audit-coverage` and `npm run audit:coverage`.
+ */
+import { readdirSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { effectToBuffs } from "./cruncher/from-dsl.js";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const DATA_ROOT = resolve(__dirname, "../../data");
+const ENRICHMENT_ROOT = resolve(DATA_ROOT, "enrichment");
+const AUDIT_DIR = resolve(DATA_ROOT, "_audit");
+const PHASES = ["command", "movement", "shooting", "charge", "fight"];
+/**
+ * Build a permissive context for `phase` — every situational flag set so that
+ * conditionals gated on stationary/charged/half-range/attachment can fire. We
+ * want "could this ability *ever* produce a buff", not "does it fire right now".
+ * Keyword-specific conditions (`target-has-keyword`) still evaluate `"unknown"`
+ * since no concrete target exists; those surface in the reason histogram.
+ */
+function permissiveContext(phase) {
+    return {
+        phase,
+        attackerStationary: true,
+        attackerCharged: true,
+        withinHalfRange: true,
+        attackerInCover: true,
+        targetInCover: true,
+        attackerAttached: true,
+        attackerKeywords: [],
+        targetKeywords: [],
+    };
+}
+/** Map an `ability_type` to the buff-source kind (only labels; not load-bearing here). */
+function sourceKind(abilityType) {
+    const kind = abilityType === "faction"
+        ? "army"
+        : abilityType === "detachment"
+            ? "detachment"
+            : abilityType === "stratagem"
+                ? "detachment-stratagem"
+                : "unit";
+    return { kind: "ability", abilityId: "audit", abilityKind: kind };
+}
+/**
+ * Keep reasons verbatim — the quoted specifics (which effect type, which
+ * operation) ARE the worklist signal. We only collapse the `subset "…"` half of
+ * the re-roll reason, which is high-cardinality noise, while keeping the roll.
+ */
+function normalizeReason(reason) {
+    return reason.replace(/\(subset "[^"]*"\)/g, "(subset …)");
+}
+/**
+ * Translate one ability under one perspective across all phases; return whether
+ * it produced any buff, accumulating unsupported reasons into `reasonCounts`.
+ */
+function producesBuff(effect, source, perspective, reasonCounts) {
+    let produced = false;
+    for (const phase of PHASES) {
+        const t = effectToBuffs(effect, source, permissiveContext(phase), perspective);
+        if (t.applied.length > 0 || t.activatable.length > 0)
+            produced = true;
+        // Only attacker-perspective reasons feed the histogram — the target pass
+        // re-walks the same tree and would double-count every offensive-only branch
+        // as "unsupported on defense", which is noise for the worklist.
+        if (perspective === "attacker") {
+            for (const u of t.unsupported) {
+                const key = normalizeReason(u.reason);
+                reasonCounts.set(key, (reasonCounts.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    return produced;
+}
+/**
+ * Effect types that are pure flags — they carry no parameters, so an empty
+ * `modifier: {}` is *correct*, not a stub (per `translate.ts`, these read no
+ * modifier fields). Excluding them keeps the worklist from crying wolf on
+ * legitimately-authored abilities like Deep Strike.
+ */
+const PARAMETERLESS_EFFECTS = new Set([
+    "deep-strike",
+    "fallback-and-act",
+    "fight-first",
+    "fight-last",
+    "fight-on-death",
+    "shoot-on-death",
+]);
+/**
+ * True if any node in the effect tree is a *parameter-requiring* leaf left with
+ * an empty `modifier: {}` — the original pass's untyped placeholder. Pure-flag
+ * effects (see {@link PARAMETERLESS_EFFECTS}) are exempt.
+ */
+export function hasEmptyModifier(node) {
+    if (Array.isArray(node))
+        return node.some(hasEmptyModifier);
+    if (typeof node !== "object" || node === null)
+        return false;
+    const rec = node;
+    const mod = rec.modifier;
+    if (typeof rec.type === "string" &&
+        !PARAMETERLESS_EFFECTS.has(rec.type) &&
+        mod !== undefined &&
+        typeof mod === "object" &&
+        mod !== null &&
+        !Array.isArray(mod) &&
+        Object.keys(mod).length === 0) {
+        return true;
+    }
+    return Object.values(rec).some(hasEmptyModifier);
+}
+/** Top-level effect type (the "shape") as authored today. */
+function shapeOf(effect) {
+    if (typeof effect === "object" && effect !== null && !Array.isArray(effect)) {
+        const t = effect.type;
+        if (typeof t === "string")
+            return t;
+    }
+    return null;
+}
+/** Compute coverage for a set of factions. Pure — IO lives in the command. */
+export function computeCoverage(input) {
+    const reasonCounts = new Map();
+    const factions = [];
+    const worklist = [];
+    for (const { faction, abilities } of input) {
+        const fc = {
+            faction,
+            total: abilities.length,
+            offensive: 0,
+            defensive: 0,
+            inert: 0,
+            stub: 0,
+            stubStructural: 0,
+            gwTextLeak: 0,
+            defensiveSkipped: 0,
+        };
+        for (const a of abilities) {
+            const notes = a.community_notes ?? "";
+            if (/Original:/.test(notes))
+                fc.gwTextLeak++;
+            if (/stub|partial/i.test(notes))
+                fc.stub++;
+            if (/skipped for damage calc/i.test(notes))
+                fc.defensiveSkipped++;
+            const source = sourceKind(a.ability_type);
+            // De-dupe reasons within a single ability so a 5-phase walk doesn't count
+            // the same unsupported branch five times.
+            const perAbility = new Map();
+            const off = producesBuff(a.effect, source, "attacker", perAbility);
+            const def = producesBuff(a.effect, source, "target", new Map());
+            for (const [reason] of perAbility) {
+                reasonCounts.set(reason, (reasonCounts.get(reason) ?? 0) + 1);
+            }
+            if (off)
+                fc.offensive++;
+            if (def)
+                fc.defensive++;
+            if (!off && !def)
+                fc.inert++;
+            const isStub = hasEmptyModifier(a.effect);
+            if (isStub)
+                fc.stubStructural++;
+            worklist.push({
+                faction,
+                ability_id: a.ability_id,
+                name: a.name ?? a.ability_id,
+                shape: shapeOf(a.effect),
+                stub: isStub,
+                offensive: off,
+                defensive: def,
+                gap: perAbility.size > 0 ? [...perAbility.keys()][0] : null,
+            });
+        }
+        factions.push(fc);
+    }
+    factions.sort((a, b) => a.faction.localeCompare(b.faction));
+    const totals = factions.reduce((acc, f) => {
+        acc.total += f.total;
+        acc.offensive += f.offensive;
+        acc.defensive += f.defensive;
+        acc.inert += f.inert;
+        acc.stub += f.stub;
+        acc.stubStructural += f.stubStructural;
+        acc.gwTextLeak += f.gwTextLeak;
+        acc.defensiveSkipped += f.defensiveSkipped;
+        return acc;
+    }, { total: 0, offensive: 0, defensive: 0, inert: 0, stub: 0, stubStructural: 0, gwTextLeak: 0, defensiveSkipped: 0 });
+    const unsupportedReasons = [...reasonCounts.entries()]
+        .map(([reason, count]) => ({ reason, count }))
+        .sort((a, b) => b.count - a.count);
+    return { factions, totals, unsupportedReasons, worklist };
+}
+/** Read every `data/enrichment/<faction>/abilities.json` (skips `_example`). */
+function loadFactions() {
+    const out = [];
+    for (const entry of readdirSync(ENRICHMENT_ROOT, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name === "_example")
+            continue;
+        const file = resolve(ENRICHMENT_ROOT, entry.name, "abilities.json");
+        let abilities;
+        try {
+            abilities = JSON.parse(readFileSync(file, "utf-8"));
+        }
+        catch {
+            continue; // no abilities.json in this folder
+        }
+        if (!Array.isArray(abilities))
+            continue;
+        out.push({ faction: entry.name, abilities });
+    }
+    return out;
+}
+const pct = (n, d) => (d === 0 ? "—" : `${Math.round((100 * n) / d)}%`);
+function prettyReport(r) {
+    const lines = [];
+    lines.push("");
+    lines.push(chalk.bold("40kdc Ability Coverage Audit"));
+    lines.push(chalk.gray("─".repeat(78)));
+    lines.push(chalk.gray("faction".padEnd(24) +
+        "total".padStart(7) +
+        "off".padStart(7) +
+        "def".padStart(7) +
+        "inert".padStart(7) +
+        "stub".padStart(7) +
+        "leak".padStart(7)));
+    for (const f of r.factions) {
+        const stubWarn = f.stubStructural > 0;
+        const row = f.faction.padEnd(24) +
+            String(f.total).padStart(7) +
+            `${f.offensive}`.padStart(7) +
+            `${f.defensive}`.padStart(7) +
+            `${f.inert}`.padStart(7) +
+            `${f.stubStructural}`.padStart(7) +
+            `${f.gwTextLeak}`.padStart(7);
+        lines.push(stubWarn ? chalk.yellow(row) : row);
+    }
+    lines.push(chalk.gray("─".repeat(78)));
+    const t = r.totals;
+    lines.push(chalk.bold("TOTAL".padEnd(24) +
+        String(t.total).padStart(7) +
+        `${t.offensive}`.padStart(7) +
+        `${t.defensive}`.padStart(7) +
+        `${t.inert}`.padStart(7) +
+        `${t.stubStructural}`.padStart(7) +
+        `${t.gwTextLeak}`.padStart(7)));
+    lines.push("");
+    lines.push(`Offensive coverage: ${chalk.cyan(pct(t.offensive, t.total))}   ` +
+        `Defensive coverage: ${chalk.cyan(pct(t.defensive, t.total))}   ` +
+        `Inert: ${chalk.yellow(pct(t.inert, t.total))}`);
+    if (t.gwTextLeak > 0) {
+        lines.push(chalk.red(`⚠ ${t.gwTextLeak} entries leak verbatim GW text (community_notes "Original:") — IP scrub needed (#20).`));
+    }
+    lines.push(chalk.gray(`${t.defensiveSkipped} entries tagged "skipped for damage calc" (defensive worklist, #23).`));
+    lines.push("");
+    lines.push(chalk.bold("Top unsupported-effect reasons (offensive walk):"));
+    for (const { reason, count } of r.unsupportedReasons.slice(0, 15)) {
+        lines.push(`  ${String(count).padStart(5)}  ${chalk.gray(reason)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function markdownReport(r) {
+    const lines = [
+        "# Ability coverage audit",
+        "",
+        "Generated by `tools/src/audit-coverage.ts` (`npm run audit:coverage`). Counts",
+        "abilities that translate into cruncher buffs via the real `effectToBuffs`",
+        "(attacker + target perspective, all phases). `inert` = produces neither.",
+        "",
+        "| faction | total | offensive | defensive | inert | stub* | notes-stub | gw-leak | def-skipped |",
+        "|---|--:|--:|--:|--:|--:|--:|--:|--:|",
+    ];
+    for (const f of r.factions) {
+        lines.push(`| ${f.faction} | ${f.total} | ${f.offensive} | ${f.defensive} | ${f.inert} | ${f.stubStructural} | ${f.stub} | ${f.gwTextLeak} | ${f.defensiveSkipped} |`);
+    }
+    const t = r.totals;
+    lines.push(`| **TOTAL** | **${t.total}** | **${t.offensive}** | **${t.defensive}** | **${t.inert}** | **${t.stubStructural}** | **${t.stub}** | **${t.gwTextLeak}** | **${t.defensiveSkipped}** |`);
+    lines.push("", "`stub*` = structural (empty-modifier placeholder node) — the authoring worklist. `notes-stub` = flagged in community_notes.");
+    lines.push("", "## Unsupported-effect reasons (offensive walk)", "");
+    for (const { reason, count } of r.unsupportedReasons) {
+        lines.push(`- \`${count}\` — ${reason}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/** Commander action: run the audit over the repo's enrichment data. */
+export function auditCoverageCommand(opts = {}) {
+    const report = computeCoverage(loadFactions());
+    if (opts.write) {
+        mkdirSync(AUDIT_DIR, { recursive: true });
+        writeFileSync(resolve(AUDIT_DIR, "coverage.json"), JSON.stringify(report, null, 2) + "\n");
+        writeFileSync(resolve(AUDIT_DIR, "summary.md"), markdownReport(report));
+        // The named-gap worklist is the authoring artifact — split out so it's
+        // diffable on its own and consumable without the histograms.
+        writeFileSync(resolve(AUDIT_DIR, "worklist.json"), JSON.stringify(report.worklist, null, 2) + "\n");
+    }
+    if (opts.reporter === "json") {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(prettyReport(report));
+        if (opts.write)
+            console.log(chalk.gray(`Wrote ${basename(AUDIT_DIR)}/coverage.json + summary.md`));
+    }
+}
+// Direct-invocation entry point (`npx tsx tools/src/audit-coverage.ts [--json] [--write]`).
+const isMain = process.argv[1] &&
+    resolve(process.argv[1]).replace(/\.\w+$/, "") === fileURLToPath(import.meta.url).replace(/\.\w+$/, "");
+if (isMain) {
+    const argv = process.argv.slice(2);
+    auditCoverageCommand({
+        reporter: argv.includes("--json") ? "json" : "pretty",
+        write: argv.includes("--write"),
+    });
+}
+//# sourceMappingURL=audit-coverage.js.map