@alpaca-software/40kdc-data 0.1.1 → 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/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The eligible-abilities resolver: given a unit (plus optional detachment,
+ * leader, supporting units), enumerate every ability that could apply to it
+ * in a chosen phase, tagged by source so the SPA can group them in the UI.
+ *
+ * @packageDocumentation
+ */
+export { resolveEligibleAbilities, type EligibilityInput, type EligibleAbility, type EligibleAbilitySource, } from "./resolver.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/abilities-resolver/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,wBAAwB,EACxB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,GAC3B,MAAM,eAAe,CAAC"}

package/dist/abilities-resolver/index.js

@@ -0,0 +1,9 @@
+/**
+ * The eligible-abilities resolver: given a unit (plus optional detachment,
+ * leader, supporting units), enumerate every ability that could apply to it
+ * in a chosen phase, tagged by source so the SPA can group them in the UI.
+ *
+ * @packageDocumentation
+ */
+export { resolveEligibleAbilities, } from "./resolver.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/abilities-resolver/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,wBAAwB,GAIzB,MAAM,eAAe,CAAC","sourcesContent":["/**\n * The eligible-abilities resolver: given a unit (plus optional detachment,\n * leader, supporting units), enumerate every ability that could apply to it\n * in a chosen phase, tagged by source so the SPA can group them in the UI.\n *\n * @packageDocumentation\n */\nexport {\n  resolveEligibleAbilities,\n  type EligibilityInput,\n  type EligibleAbility,\n  type EligibleAbilitySource,\n} from \"./resolver.js\";\n"]}

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

@@ -0,0 +1,73 @@
+/**
+ * Walks the dataset for every ability that could apply to a chosen unit in a
+ * chosen phase. The SPA passes the result through to the buff layer (each
+ * {@link EligibleAbility} carries `.getBuffs()`, the source is pre-tagged).
+ *
+ * Resolution order — stable for snapshot tests:
+ *
+ * 1. **army** — faction-scoped abilities whose `ability_type` is `"faction"`
+ *    and whose `faction_id` matches the input.
+ * 2. **detachment** — abilities authored against the detachment
+ *    (`ability_type` is `"detachment"`, `detachment_id` matches).
+ * 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. **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`).
+ *
+ * Each step phase-filters via the existing `Dataset.phasesFor` index. The
+ * resolver collects abilities first, *then* filters by phase, so the SPA can
+ * also ask "what abilities are eligible across all phases?" by passing every
+ * phase (today the API requires a single phase; if the SPA wants the wide
+ * view it can call the resolver once per phase).
+ */
+import type { Phase } from "../generated.js";
+import type { Dataset } from "../data/dataset.js";
+import type { AbilityView } from "../data/entities.js";
+export type EligibleAbilitySource = {
+    kind: "army";
+} | {
+    kind: "detachment";
+    detachmentId: string;
+} | {
+    kind: "detachment-stratagem";
+    stratagemId: string;
+    cpCost: number;
+} | {
+    kind: "unit";
+    unitId: string;
+} | {
+    kind: "attached";
+    unitId: string;
+} | {
+    kind: "support";
+    sourceUnitId: string;
+};
+export type EligibilityInput = {
+    unitId: string;
+    /** Overrides the unit's own `faction_id` when given (for inheritance cases). */
+    factionId?: string;
+    detachmentId?: 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[];
+};
+export type EligibleAbility = {
+    ability: AbilityView;
+    source: EligibleAbilitySource;
+    /** The subset of `ability.phases` that intersect the requested phase. */
+    phases: Phase[];
+};
+/** Compute the sorted-by-source eligible-ability list for one (unit, phase). */
+export declare function resolveEligibleAbilities(dataset: Dataset, input: EligibilityInput, phase: Phase): EligibleAbility[];
+//# sourceMappingURL=resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,142 @@
+/** Compute the sorted-by-source eligible-ability list for one (unit, phase). */
+export function resolveEligibleAbilities(dataset, input, phase) {
+    // 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;
+    const seen = new Set();
+    const out = [];
+    // 1. Army — faction-scoped abilities (faction rule + any other faction-typed).
+    for (const ability of dataset.abilities.byFaction(factionId)) {
+        if (ability.raw.ability_type !== "faction")
+            continue;
+        if (!phaseMatches(ability, phase))
+            continue;
+        pushUnique(out, seen, { ability, source: { kind: "army" }, phases: intersect(ability.phases, phase) });
+    }
+    // 2. Detachment abilities — abilities whose detachment_id matches.
+    if (input.detachmentId) {
+        for (const ability of dataset.abilities) {
+            if (ability.raw.ability_type !== "detachment")
+                continue;
+            if (ability.raw.detachment_id !== input.detachmentId)
+                continue;
+            if (!phaseMatches(ability, phase))
+                continue;
+            pushUnique(out, seen, {
+                ability,
+                source: { kind: "detachment", detachmentId: input.detachmentId },
+                phases: intersect(ability.phases, phase),
+            });
+        }
+        // 3. Detachment stratagems.
+        const detachment = dataset.detachments.get(input.detachmentId);
+        if (detachment) {
+            for (const stratId of detachment.stratagem_ids ?? []) {
+                const stratagem = dataset.stratagems.get(stratId);
+                if (!stratagem)
+                    continue;
+                if (!stratagemPhaseMatches(stratagem, phase))
+                    continue;
+                const ability = stratagem.ability_id !== null && stratagem.ability_id !== undefined
+                    ? dataset.abilities.get(stratagem.ability_id)
+                    : undefined;
+                if (!ability)
+                    continue;
+                pushUnique(out, seen, {
+                    ability,
+                    source: {
+                        kind: "detachment-stratagem",
+                        stratagemId: stratagem.id,
+                        cpCost: stratagem.cp_cost,
+                    },
+                    phases: [phase], // the stratagem's printed phase governs eligibility.
+                });
+            }
+        }
+    }
+    // 4. Unit's own abilities.
+    for (const ability of unit.abilities) {
+        if (!phaseMatches(ability, phase))
+            continue;
+        pushUnique(out, seen, {
+            ability,
+            source: { kind: "unit", unitId: input.unitId },
+            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 = resolveUnit(supportId, factionId);
+        if (!supporter)
+            continue;
+        for (const ability of supporter.abilities) {
+            if (!phaseMatches(ability, phase))
+                continue;
+            if (!isAuraScope(ability.raw.scope?.range))
+                continue;
+            pushUnique(out, seen, {
+                ability,
+                source: { kind: "support", sourceUnitId: supportId },
+                phases: intersect(ability.phases, phase),
+            });
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function phaseMatches(ability, phase) {
+    const phases = ability.phases;
+    // An ability with no phase-mapping is permissive — surface it everywhere so
+    // the SPA can decide. M2's translator already gates conditional-on-phase
+    // effects internally, so this stays generous on purpose.
+    if (phases.length === 0)
+        return true;
+    return phases.includes(phase);
+}
+function stratagemPhaseMatches(stratagem, phase) {
+    if (!stratagem.phases || stratagem.phases.length === 0)
+        return false;
+    return stratagem.phases.includes(phase);
+}
+function intersect(phases, phase) {
+    return phases.includes(phase) ? [phase] : phases;
+}
+function isAuraScope(range) {
+    if (typeof range !== "string")
+        return false;
+    return range.startsWith("aura-") || range === "any-on-battlefield" || range === "any-visible";
+}
+function pushUnique(out, seen, entry) {
+    const key = `${entry.source.kind}::${entry.ability.id}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    out.push(entry);
+}
+//# sourceMappingURL=resolver.js.map

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

@@ -0,0 +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. **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"}