@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/optional-feature/optional-feature.schema.d.ts

@@ -12,6 +12,16 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
     prerequisites: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"level">;
         min: z.ZodNumber;
+        class: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodOptional<z.ZodString>;
+            visible_stats: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        subclass: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodOptional<z.ZodString>;
+            visible_stats: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"spell-known">;
         spell: z.ZodString;
@@ -40,21 +50,36 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         detail: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"optionalfeature">;
+        optionalfeature: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"spell-choose">;
+        choose: z.ZodString;
+        entry: z.ZodOptional<z.ZodString>;
+        entry_summary: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "kind">>;
     available_to: z.ZodArray<z.ZodString>;
     effects: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"initiative-bonus">;
         value: z.ZodNumber;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"immune-condition">;
         condition: z.ZodString;
         while: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"resistance">;
         damage_type: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"hp-per-level-bonus">;
         value: z.ZodNumber;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"speed-bonus">;
         mode: z.ZodEnum<{
@@ -66,6 +91,21 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
         }>;
         value: z.ZodNumber;
         set: z.ZodOptional<z.ZodBoolean>;
+        scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            value: z.ZodNumber;
+        }, z.core.$strip>>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"attunement-limit">;
+        value: z.ZodNumber;
+        scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            value: z.ZodNumber;
+        }, z.core.$strip>>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"sense">;
         type: z.ZodEnum<{
@@ -75,6 +115,8 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             truesight: "truesight";
         }>;
         range: z.ZodNumber;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"apply-condition">;
         condition: z.ZodString;
@@ -84,6 +126,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             ability: z.ZodString;
             timing: z.ZodString;
         }, z.core.$strip>>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"damage-bonus">;
         damage_type: z.ZodString;
@@ -94,6 +137,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             all: "all";
         }>>;
         condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"proficiency">;
         proficiency_type: z.ZodEnum<{
@@ -105,10 +149,15 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             armor: "armor";
         }>;
         value: z.ZodString;
+        expertise: z.ZodOptional<z.ZodBoolean>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"ac-bonus">;
         value: z.ZodNumber;
         requires_armor: z.ZodOptional<z.ZodBoolean>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"unarmored-ac">;
         abilities: z.ZodArray<z.ZodEnum<{
@@ -121,6 +170,23 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
         }>>;
         base: z.ZodOptional<z.ZodNumber>;
         allow_shield: z.ZodOptional<z.ZodBoolean>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unarmed-strike">;
+        dice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+        }, z.core.$strip>]>>;
+        abilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"weapon-ability">;
         ability: z.ZodUnion<readonly [z.ZodEnum<{
@@ -132,22 +198,34 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             cha: "cha";
         }>, z.ZodLiteral<"spellcasting">]>;
         weapons: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chosen">, z.ZodString, z.ZodArray<z.ZodString>]>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"roll-modifier">;
         mode: z.ZodEnum<{
             advantage: "advantage";
             disadvantage: "disadvantage";
+            reroll: "reroll";
+            "add-d4": "add-d4";
         }>;
         roll: z.ZodEnum<{
             "saving-throw": "saving-throw";
             "ability-check": "ability-check";
             attack: "attack";
+            any: "any";
         }>;
         scope: z.ZodOptional<z.ZodString>;
         condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"extra-attack">;
         count: z.ZodNumber;
+        scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strip>>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"crit-range">;
         min_roll: z.ZodNumber;
@@ -157,6 +235,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             all: "all";
         }>>;
         condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"reroll-damage">;
         max_reroll: z.ZodNumber;
@@ -166,11 +245,83 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             all: "all";
         }>>;
         once_per_die: z.ZodOptional<z.ZodBoolean>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"attack-rule">;
         flag: z.ZodEnum<{
             "no-ranged-in-melee-disadvantage": "no-ranged-in-melee-disadvantage";
         }>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"immunity">;
+        damage_type: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"vulnerability">;
+        damage_type: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"temp-hp">;
+        amount: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"heal">;
+        amount: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"ability-score-increase">;
+        abilities: z.ZodUnion<readonly [z.ZodLiteral<"chosen">, z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>]>;
+        amount: z.ZodNumber;
+        choose: z.ZodNullable<z.ZodNumber>;
+        max: z.ZodNullable<z.ZodNumber>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"extra-action">;
+        count: z.ZodNumber;
+        action_type: z.ZodEnum<{
+            action: "action";
+            "bonus-action": "bonus-action";
+            reaction: "reaction";
+        }>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"save-outcome">;
+        ability: z.ZodUnion<readonly [z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>, z.ZodLiteral<"any">]>;
+        on_success: z.ZodEnum<{
+            none: "none";
+            half: "half";
+            full: "full";
+        }>;
+        on_failure: z.ZodEnum<{
+            none: "none";
+            half: "half";
+            full: "full";
+        }>;
+        applies_to: z.ZodNullable<z.ZodString>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "kind">>;
     action_cost: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         action: "action";
@@ -184,6 +335,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
         recharge: z.ZodEnum<{
             "short-rest": "short-rest";
             "long-rest": "long-rest";
+            either: "either";
             dawn: "dawn";
             dusk: "dusk";
             turn: "turn";
@@ -200,6 +352,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
         resource: z.ZodOptional<z.ZodString>;
         column: z.ZodOptional<z.ZodString>;
         amount: z.ZodNumber;
+        amount_max: z.ZodOptional<z.ZodNumber>;
         expend_condition: z.ZodOptional<z.ZodEnum<{
             roll_succeeds: "roll_succeeds";
             roll_fails: "roll_fails";
@@ -211,6 +364,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             reset: z.ZodEnum<{
                 "short-rest": "short-rest";
                 "long-rest": "long-rest";
+                either: "either";
                 dawn: "dawn";
                 dusk: "dusk";
                 turn: "turn";
@@ -231,6 +385,37 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
     }, z.core.$strict>]>>>;
     passive: z.ZodOptional<z.ZodBoolean>;
     activatable: z.ZodOptional<z.ZodBoolean>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    additional_spells: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            choose: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>]>>;
+        known: z.ZodOptional<z.ZodUnknown>;
+        innate: z.ZodOptional<z.ZodUnknown>;
+        prepared: z.ZodOptional<z.ZodUnknown>;
+        expanded: z.ZodOptional<z.ZodUnknown>;
+        resourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    is_class_feature_variant: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    feat_progression: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+        feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    optionalfeature_progression: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+        feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strip>;
 export type OptionalFeatureSchemaInput = z.input<typeof optionalFeatureEntitySchema>;
 export type OptionalFeatureSchemaOutput = z.output<typeof optionalFeatureEntitySchema>;

package/dist/optional-feature/optional-feature.schema.js

@@ -1,9 +1,10 @@
 import {
   optionalFeatureEntitySchema
-} from "../chunk-MDEJHMKK.js";
+} from "../chunk-WHVLNFTG.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-X3D6LXUU.js";
+import "../chunk-UA5KS2PL.js";
 export {
   optionalFeatureEntitySchema
 };

package/dist/pack.d.ts

@@ -5,7 +5,7 @@ import type { SystemPack } from "@archivist-gg/core";
  * (renderer/edit/modal) stays in the obsidian package. It is the only pack the
  * kernel registers.
  *
- * All 11 authored types are ported, plus the two generate-only types (npc and
+ * All 12 authored types are ported, plus the two generate-only types (npc and
  * encounter); a new entity type joins by appending its EntityType here.
  */
 export declare const dnd5ePack: SystemPack;

package/dist/pc/conditions.constants.d.ts

@@ -1,3 +1,2 @@
 export type ConditionSlug = "blinded" | "charmed" | "deafened" | "frightened" | "grappled" | "incapacitated" | "invisible" | "paralyzed" | "petrified" | "poisoned" | "prone" | "restrained" | "stunned" | "unconscious";
 export declare const CONDITION_SLUGS: readonly ["blinded", "charmed", "deafened", "frightened", "grappled", "incapacitated", "invisible", "paralyzed", "petrified", "poisoned", "prone", "restrained", "stunned", "unconscious"];
-export declare const CONDITION_DISPLAY_NAMES: Record<ConditionSlug, string>;

package/dist/pc/conditions.constants.js

@@ -1,8 +1,6 @@
 import {
-  CONDITION_DISPLAY_NAMES,
   CONDITION_SLUGS
-} from "../chunk-TZK36BU7.js";
+} from "../chunk-S7REMWW4.js";
 export {
-  CONDITION_DISPLAY_NAMES,
   CONDITION_SLUGS
 };

package/dist/pc/decision-recognizer.js

@@ -1,7 +1,7 @@
 import {
   DECISION_SIGNAL,
   recognizeDecision
-} from "../chunk-JEYQU3JT.js";
+} from "../chunk-YHYTW5QA.js";
 export {
   DECISION_SIGNAL,
   recognizeDecision

package/dist/pc/pc.additional-spells.d.ts

@@ -0,0 +1,47 @@
+import type { EntityRegistry, RegisteredEntity } from "@archivist-gg/core";
+import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
+import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
+import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { ResolvedClass, ResolvedSpell } from "./pc.types.js";
+export declare const prefixOf: (slug: string) => string;
+/** §5.2.2 · a raw 5etools / bundle spell ref → the bare NAME slug. The path tail is taken ONLY for a wikilink; a bare
+ *  name may legally contain "/" ("blindness/deafness" → "blindnessdeafness", the converter's own slug tail · Gate 0 B1).
+ *  The "|source" token is DISCARDED (no abbreviation table exists anywhere); "#c"/"#2" are redundant with entity.level. */
+export declare function normalizeSpellRef(ref: unknown): string | null;
+export interface SpellNameIndex {
+    byName: Map<string, RegisteredEntity[]>;
+}
+/** At most ONE scan of the spell bucket per resolve(), keyed on slugify(entity name) · NEVER on the slug tail (Gate 0
+ *  B2: the generators hyphenate "/" where dnd5e's slugify deletes it, so three bundle spells differ). Built LAZILY by
+ *  its caller, on the first leaf that CALLS `resolveSpellByName` (the argument is evaluated whatever step then
+ *  resolves it), so a character with no `additional_spells` leaf pays nothing for it. */
+export declare function buildSpellNameIndex(entities: EntityRegistry): SpellNameIndex;
+/** §5.2.3 · deterministic, no minted vocabulary: (0) the character's own copy · (a) the carrier's compendium exactly ·
+ *  (b) same compendium → same edition (skipped when either side lacks one) → lowest full slug · (c) MISS → null + warnOnce ·
+ *  (d) ambiguity after (i)+(ii) → (iii) decides AND warnOnce (the decision-engine byBare precedent). */
+export declare function resolveSpellByName(opts: {
+    entities: EntityRegistry;
+    index: SpellNameIndex;
+    nameSlug: string;
+    carrierSlug: string;
+    carrierEdition?: string;
+    alreadyCollected: ResolvedSpell[];
+}): {
+    entity: Spell;
+    slug: string;
+} | null;
+/** §5.2.9 · fold a race's entries ONLY when no select-inline on race.choices[] / traits[].choices[] / nested option.choices[]
+ *  carries an id outside the structural set (nested: zero carriers, defensive). */
+export declare function raceIsUngated(race: RaceEntity): boolean;
+/** §5.2.1 · the reader. Every object it receives is the RAW registry entity; nothing is mutated. */
+export declare function collectAdditionalSpells(args: {
+    race: RaceEntity | null;
+    feats: FeatEntity[];
+    classes: ResolvedClass[];
+    totalLevel: number;
+    ownAbility: Ability | null;
+    alreadyCollected: ResolvedSpell[];
+    entities: EntityRegistry;
+    warnings: string[];
+}): ResolvedSpell[];

package/dist/pc/pc.additional-spells.js

@@ -0,0 +1,23 @@
+import {
+  buildSpellNameIndex,
+  collectAdditionalSpells,
+  normalizeSpellRef,
+  prefixOf,
+  raceIsUngated,
+  resolveSpellByName
+} from "../chunk-MI7P3NX3.js";
+import "../chunk-PVCEA4HZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-6X4KUDMU.js";
+import "../chunk-OZP6JFGT.js";
+import "../chunk-VQAXTIBW.js";
+import "../chunk-WELIKLZF.js";
+import "../chunk-UA5KS2PL.js";
+export {
+  buildSpellNameIndex,
+  collectAdditionalSpells,
+  normalizeSpellRef,
+  prefixOf,
+  raceIsUngated,
+  resolveSpellByName
+};

package/dist/pc/pc.asi-flatten.d.ts

@@ -0,0 +1,18 @@
+import type { Choice } from "../types/choice.js";
+/**
+ * Normalizes the authored two-step "Ability Score Increase or Feat" decision
+ * into the flat feat pick the product now uses.
+ *
+ * This is a PERMANENT compatibility layer, not a migration shim: hand-authored
+ * homebrew (e.g. `Compendium/MCDM/Classes/Illrigger.md`, which no bundle copy
+ * can ever overwrite) keeps emitting the two-step shape, and `choiceSchema`
+ * deliberately keeps accepting it.
+ *
+ * The lifted choice is the AUTHORED inner one, returned verbatim, so a homebrew
+ * variant carrying its own `where` / `count` / `label` survives. When the feat
+ * branch carries more than one child choice the whole choice is returned
+ * untouched, because lifting would silently drop the sibling.
+ *
+ * Pure: never mutates its input, never synthesizes a new object.
+ */
+export declare function flattenAsiOrFeat(choice: Choice): Choice;

package/dist/pc/pc.decision-engine.d.ts

@@ -1,6 +1,8 @@
 import type { Choice, EntityFilter, Ability } from "@archivist-gg/dnd5e/types/choice";
 import type { ResolvedCharacter, ChoiceValue, FeatureSource } from "./pc.types.js";
 import type { RegisteredEntity } from "@archivist-gg/core";
+import { type ProficiencyEntry } from "./pc.proficiency-grants.js";
+import { wikilinkTailSlug } from "../entities/slug.js";
 export interface DecisionRegistry {
     search(query: string, entityType: string, limit: number): RegisteredEntity[];
     getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
@@ -14,6 +16,13 @@ export interface ResolvedOption {
     description?: string;
     /** True when a `from` slug has no entity behind it — render visible-but-inert. */
     missing?: boolean;
+    /** True when this option is a STORED pick that no longer answers to the pool's collapsed candidate list
+     *  (R4-G5 §3.2.3): a genuine prerequisite-failing pick, since §9.2.3 already rewrote every collapsed twin to
+     *  its survivor. Stamped by the pool synth from `strandedPicks`, never by `enumerateOptions`, which stays pure
+     *  over `(choice, ctx, ownerBare)` and cannot see the character. Both builder arms dress such an option with
+     *  the unresolved (crimson req) marker and the sheet's "prerequisite unmet" wording; the picker modal still
+     *  lists it as an ordinary candidate. */
+    stranded?: boolean;
 }
 /**
  * Status contract: over-selection (n > need) reports `resolved` — the engine
@@ -45,6 +54,40 @@ export interface DecisionItem {
     options: ResolvedOption[];
     selected: ChoiceValue | undefined;
     status: DecisionStatus;
+    /**
+     * True when this choice has nothing left to grant: every proficiency it could
+     * have offered is one the character ALREADY holds (on an `expertise` skill row,
+     * already holds AT EXPERTISE), so the exclusion filter (spec §5, widened to
+     * those rows by R4-G3b §7 F4) emptied its pool. Such a row is complete, not an
+     * open obligation the user has no way to discharge.
+     *
+     * Deliberately NOT a bare `options.length === 0`. FOUR other shapes reach
+     * zero options and are genuinely still open: a from-LESS `domain:"save"`
+     * choice (no pool exists at all · the enumerator's `??` fallback has no save
+     * branch, and a save choice that authors `from` does enumerate it), a
+     * select-entity whose registry holds no candidates (an empty vault), an
+     * authored `from: []`, and a `from_proficient` skill row the R4-G3b §7 F1
+     * INCLUSION empties (a fresh L1 Rogue holds no skills yet). Emptied-BY-
+     * EXCLUSION is the only one where the character is already whole, so the flag
+     * is scoped to select-proficiency in the language and tool domains PLUS
+     * `expertise` skill rows (R4-G3b §7 F4; a plain skill row is never excluded
+     * and so never satisfied · §14, and saves have no set at all) AND requires the
+     * pool to have been non-empty AFTER the F1 INCLUSION ran, not before it ·
+     * that fourth shape is the one this clause keeps open, and the next render
+     * repopulates it.
+     *
+     * `false` for every other item, informational ones included.
+     */
+    satisfied: boolean;
+    /** Present ONLY on a synthesized selection-pool item (R4-G5 §3.2.3): that pool's id and anchor level. It is
+     *  the TYPED marker every writer keys the pool write canon on (the chips arm, the selection table,
+     *  `renderLongListBrowse` and `DecisionPickModal`): a pool item persists an ARRAY even at count 1, the shape
+     *  `PoolTab` writes, while a `feat` or any other pick keeps its string shape. Absent on every other item, so
+     *  a truthiness test on it IS the discriminator. */
+    pool?: {
+        id: string;
+        anchorLevel: number;
+    };
     /**
      * Populated only for the selected branch of a select-inline (the
      * revealed-on-selection rule): a child decision becomes visible once its
@@ -65,33 +108,79 @@ export interface DecisionLedger {
 }
 export interface DecisionContext {
     registry: DecisionRegistry;
+    /** OPTIONAL visibility predicate. When supplied, ambiguous bare-slug lookups
+     *  seed VISIBLE entities first, so a hidden compendium can never shadow a
+     *  visible one that shares a bare slug. Absent (the engine's own tests, any
+     *  caller that has no notion of hidden compendiums) means deterministic order
+     *  only — never a behaviour change, because the seeding is total-ordered
+     *  either way. Threaded plugin-side by the four builder ctx constructors. */
+    isEntityVisible?(e: RegisteredEntity): boolean;
 }
-/** "[[SRD 2024/Classes/Fighter]]" → "fighter" (tail segment, slugified). */
-export declare function wikilinkTailSlug(link: string): string;
+/** `wikilinkTailSlug` MOVED to `entities/slug.ts` in R4-G5 T1, beside `bareEntitySlug`, so `pc.pools.ts` can
+ *  import it without importing this module (this module imports `pc.pools` for `strandedPicks`; the old
+ *  direction would be a cycle). The re-export is KEPT because `@archivist-gg/dnd5e/pc/pc.decision-engine` is
+ *  a published subpath with three plugin importers OF THIS SYMBOL (`components/passive/background-block.ts`,
+ *  `components/builder/background-step.ts`, `components/builder/class-step.ts`, all under
+ *  `packages/obsidian/src/modules/pc/`) plus this repo's `pc.resolver.ts` and
+ *  `tests/wikilink-tail-slug.test.ts`: a public
+ *  surface, not a migration shim, so the standing "retire every shim" rule does not reach it (spec §17 names the
+ *  re-export explicitly). */
+export { wikilinkTailSlug };
 declare function matchesFilter(e: RegisteredEntity, where: EntityFilter, ownerBare: string): boolean;
 /** Test-only export of {@link matchesFilter} (Task B2). */
 export declare const __matchesFilterForTest: typeof matchesFilter;
 /** Walk every decision definition + persisted selection and collect chosen
- *  proficiencies. Pure; called by recalc. Values are validated against the
- *  decision's option pool — stale slugs (outside `from`) are ignored. */
+ *  proficiencies. Pure; called by recalc.
+ *
+ *  On the `select-proficiency` arms, values are validated against the decision's
+ *  option pool via filterToPool: slugs outside `from` are ignored, and a pick
+ *  matching under canon is kept in the POOL's spelling. The `weapons` arm is the
+ *  one exception · a `select-entity` pick carries ENTITY slugs, not proficiency
+ *  slugs, and its `from` is a list of entity slugs, so those values are
+ *  bare-slugged rather than pool-filtered (R4-G3b §7 F5). */
 export declare function collectChosenProficiencies(resolved: ResolvedCharacter): {
     skills: string[];
     expertise: string[];
     languages: string[];
     tools: string[];
+    weapons: string[];
+    saves: Ability[];
 };
-export interface ChoiceStatus {
-    id: string;
-    count: number;
-    selected: number;
-}
-/** Per-choice status for language/tool select-proficiency decisions, using the
- *  SAME walk as collectChosenProficiencies so required/selected counts cannot
- *  diverge from the picks. `selected` counts persisted picks validated against
- *  the choice's `from` pool (stale slugs ignored, mirroring the pick fold). */
-export declare function collectLanguageToolChoiceStatus(resolved: ResolvedCharacter): {
-    languages: ChoiceStatus[];
-    tools: ChoiceStatus[];
+/** The single primitive for "what languages/tools does this character actually
+ *  have": grants + picks + manual adds, MINUS suppressions (spec §4.1).
+ *
+ *  Suppressions are applied INSIDE this function precisely so that no reader can
+ *  forget them · the sheet panel's display, the builder picker's option
+ *  exclusion and the "already satisfied" test all read this one function and
+ *  therefore agree by construction.
+ *
+ *  Built on the grant walk, NEVER on computeProficiencies (spec §4.2): recalc's
+ *  proficiency fold is missing the race and background grants.
+ *
+ *  ONE argument. `Character.overrides` is non-optional with a schema default, so
+ *  a second parameter would be redundant and would force an optionality decision
+ *  at seventeen existing aggregateProficiencies call sites (spec §4.1).
+ *
+ *  SEVENTEEN is a PRE-R4-P3c SNAPSHOT (dnd5e 433cc72 · plugin 90394e9, which this
+ *  phase never touches), and that is what "existing" means above: the sites that
+ *  existed when the one-argument decision was taken. It is NOT today's count. Do
+ *  not re-"correct" it to today's · that number moves on every new test that
+ *  calls the function, while the cost this sentence is weighing does not.
+ *
+ *  Reproduce the snapshot with `git grep -c "aggregateProficiencies(" <rev>` over
+ *  *.ts/*.tsx, node_modules and dist excluded: 15 raw lines in dnd5e + 3 in the
+ *  plugin = 18, minus the DECLARATION in pc.proficiencies.ts = 17 · namely 2
+ *  production (the plugin's proficiencies-panel and proficiency-edit-modal) + 15
+ *  in tests (14 in dnd5e, 1 in the plugin's pc-proficiency-edit-modal counting
+ *  passthrough). Two traps in that census. The plugin's two mock bindings are NOT
+ *  a subtraction: `aggregateProficiencies:` has no paren, so the pattern never
+ *  matched them. THIS DOCBLOCK's own backticked mention above IS one, and only
+ *  from R4-P3c onward · immediately after that phase the same grep returns 20
+ *  raw, which is 18 call sites once the declaration AND this docblock come off,
+ *  not the 19 you get by subtracting the declaration alone. */
+export declare function computeEffectiveProficiencies(resolved: ResolvedCharacter): {
+    languages: ProficiencyEntry[];
+    tools: ProficiencyEntry[];
 };
 export interface OriginAbilityPoints {
     race: Partial<Record<Ability, number>>;
@@ -104,4 +193,3 @@ export interface OriginAbilityPoints {
  *  legacy choices[lvl].asi path recalc already folds — do not double-count. */
 export declare function collectChosenAbilityPoints(resolved: ResolvedCharacter): OriginAbilityPoints;
 export declare function buildDecisionLedger(resolved: ResolvedCharacter, ctx: DecisionContext): DecisionLedger;
-export {};