@archivist-gg/dnd5e 0.3.19 → 0.3.26

package/dist/pc/pc.amount-bindings.d.ts

@@ -1,41 +1,16 @@
-/**
- * D2b-A · the numbers an amount resolves against (design §1.2 A). The modifier and the save DC are those of the class
- * that OWNS the feature or grants the spell (multiclass: the granting class, user ruling 2026-09-27).
- */
 import type { Ability } from "@archivist-gg/dnd5e/types/choice";
 import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
 import { type AmountBindings } from "@archivist-gg/dnd5e/dnd/amount-text";
 import type { DerivedStats, FeatureSource, ResolvedCharacter, ResolvedSpell, SpellDamageRider } from "./pc.types.js";
-/** The derived fields the bindings read (recalc builds them before its return; the sheet passes `ctx.derived`). */
 export type AmountDerived = Pick<DerivedStats, "proficiencyBonus" | "mods" | "spellcastingClasses"> & Partial<Pick<DerivedStats, "abilitySpellcasting">>;
-/** The class slug that owns `source`: a class by its slug, a subclass by the class that holds it, a feat through the
- *  slot it was taken at (`via`), a pool member through its pool's class. Null for race, background and campaign. */
 export declare function ownerClassSlug(source: FeatureSource | undefined, resolved: Pick<ResolvedCharacter, "classes">): string | null;
-/** The bindings an amount owned by `owner` resolves against: `class_level` is the OWNING class's level (the total level
- *  for a race, background or unowned source), `spell_mod` / `spell_dc` come from that class's spellcasting row, else
- *  the first caster's, else they stay unbound (the amount prints its words or a label). */
 export declare function amountBindingsFor(owner: FeatureSource | undefined, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
-/** How a spell is cast: its ability, save DC and attack bonus. A grant that carries its OWN ability (a feat's chosen
- *  ability, a race grant, a class-less row) reads `abilitySpellcasting`; every other spell reads its class's row, else
- *  the first caster's. The one lookup the Spells tab's DC, attack and effect cells share. */
-export declare function spellcastingFor(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability">, derived: AmountDerived): {
-    ability: Ability;
+export declare function spellcastingFor(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability" | "itemCasting">, derived: AmountDerived): {
+    ability: Ability | null;
     saveDC: number;
     attackBonus: number;
 } | null;
-/** The bindings a spell's effect resolves against: its caster's modifier and save DC (see {@link spellcastingFor}). */
-export declare function spellAmountBindings(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability">, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
-/** What a spell adds to its base roll ONCE, in token form: `{spell_mod}` when its text reads "<the base roll> plus (or
- *  +) your spellcasting (ability) modifier" (35 vault notes: Healing Word, Cure Wounds, Spiritual Weapon, ...), else
- *  null. Read from the note's own words at read time; the roll must be the one the phrase follows, so a spell whose
- *  modifier rides a different roll (a heal beside a damage roll) adds nothing. */
+export declare function spellAmountBindings(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability" | "itemCasting">, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
 export declare function spellRollBonus(spell: Pick<Spell, "damage_roll" | "description">): string | null;
-/** The spell's printed roll with every spell damage rider that reaches it added INSIDE the one roll (bonus damage prints
- *  in the damage cell, user ruling): Agonizing Blast's Charisma on its cantrip reads "1d10+3" (found live 2026-09-28),
- *  Potent Spellcasting's Wisdom on Sacred Flame "1d8+3". A conditional rider, or one of another canonical damage type
- *  than the spell's own, is not added here: it is a line of its own (`spellDamageRiderLines`). */
 export declare function addSpellDamageRiders(roll: string, spell: Pick<ResolvedSpell, "slug" | "entity">, derived: Partial<Pick<DerivedStats, "spellDamageRiders">>): string;
-/** The spell damage riders that reach `spell` but do not fold into its roll, each its own line in the damage cell, the
- *  way a conditional weapon rider is (Power Surge's "+ 5 force" once a surge is spent; Arcane Firearm's "+ 1d8" through
- *  the firearm): a `condition`, or another canonical damage type. `spells` and `once` are the engine's, not the line's. */
 export declare function spellDamageRiderLines(spell: Pick<ResolvedSpell, "slug" | "entity">, derived: Partial<Pick<DerivedStats, "spellDamageRiders">>): Array<Pick<SpellDamageRider, "amount" | "damage_type" | "source" | "condition">>;

package/dist/pc/pc.amount-bindings.js

@@ -1,28 +1 @@
-import {
-  addSpellDamageRiders,
-  amountBindingsFor,
-  ownerClassSlug,
-  spellAmountBindings,
-  spellDamageRiderLines,
-  spellRollBonus,
-  spellcastingFor
-} from "../chunk-TRBGC4ZG.js";
-import "../chunk-KR6JF3BF.js";
-import "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-WOHX7YTH.js";
-import "../chunk-EVMUJYUD.js";
-import "../chunk-VTTA2ALZ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  addSpellDamageRiders,
-  amountBindingsFor,
-  ownerClassSlug,
-  spellAmountBindings,
-  spellDamageRiderLines,
-  spellRollBonus,
-  spellcastingFor
-};
+import{addSpellDamageRiders,amountBindingsFor,ownerClassSlug,spellAmountBindings,spellDamageRiderLines,spellRollBonus,spellcastingFor}from"../chunk-CCAVZANF.js";import"../chunk-PZ3ZZ5H5.js";import"../chunk-KEXSF3CH.js";import"../chunk-PFQPP77Q.js";import"../chunk-PKIMOVQG.js";import"../chunk-CMIEZQL4.js";import"../chunk-CSTAQQGX.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-VIP3FH2O.js";import"../chunk-EAARMPCW.js";import"../chunk-CAPYNIGK.js";import"../chunk-63YJPWTM.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{addSpellDamageRiders,amountBindingsFor,ownerClassSlug,spellAmountBindings,spellDamageRiderLines,spellRollBonus,spellcastingFor};

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

@@ -1,54 +1,11 @@
 import type { RegisteredEntity } from "@archivist-gg/core";
 import type { Choice, Ability } 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;
-/** The structural registry read `resolveLegacyAsiFeat` makes; the ledger's DecisionRegistry and core's EntityRegistry both
- *  satisfy it. */
 type FeatSearch = {
     search(query: string, entityType: string, limit: number): RegisteredEntity[];
 };
-/**
- * The legacy ASI-branch allocation a class level SAVED, or null (H234 H4(2), spec §5.2 item 1): the SHEET's predicate,
- * which `collectClassAsiBranch` (pc.recalc.ts) folds per level, and the base of the Builder's {@link convertibleLegacyAsi}.
- *
- * Non-null exactly when `block` is an object whose `feat` is NOT a string and whose `asi` is a non-array object with at
- * least one numeric ability entry; returns a FRESH object of those entries. It ignores `asi-or-feat`, so an explicit
- * `"feat"` branch with no feat picked still folds on the sheet, as it always has.
- *
- * A string `feat` beside an `asi` is R4-P4 Decision B's orphan (the level took the feat branch and the picker never cleared
- * the abandoned branch's child keys): null. Do NOT loosen the test to `"feat" in block` or a `startsWith("feat")` prefix
- * test: the first strands a non-string `feat` (a legacy hand edit) with no fold at all, the second skips every
- * correctly-flattened block. The `typeof … === "string"` test MIRRORS `collectClassFeatAbilityPoints`' own gate, so the two
- * can never both decline on this predicate (they can both decline when the feat slug resolves to no entity: an
- * unresolvable pick grants nothing, by design).
- */
 export declare function legacyAsiBranch(block: unknown): Partial<Record<Ability, number>> | null;
-/** The BUILDER's predicate (spec §5.2 item 2, Gate 1 M-9): {@link legacyAsiBranch} when `asi-or-feat` is absent or
- *  `"asi"`, else null. An explicit `"feat"` branch is a two-step pick in progress (a homebrew non-flattenable two-step keeps
- *  `asi-or-feat` as its own row's key), so the Builder neither aliases nor converts it and today's orphan rule applies.
- *  The ledger alias and {@link migrateLegacyAsiLevel} both use THIS predicate, so an aliased row never receives an inert
- *  write. The sheet's fold keeps the value-agnostic {@link legacyAsiBranch}. */
 export declare function convertibleLegacyAsi(block: unknown): Partial<Record<Ability, number>> | null;
-/** The ASI feat a class answers a legacy level with, deterministically (spec §5.3, Gate 0 M-7). Candidates: the registered
- *  feats whose bare slug is `ability-score-improvement` and which carry an `ability-points` choice with a string `id`.
- *  Rank: (1) the class entity's slug prefix (the pool collapse's identity rule), (2) the class entity's edition, (3)
- *  ascending slug in code-unit order. `childId` is that choice's own `id`, read from the data. Null with no candidate or no
- *  class entity. A pure function of (registry, class entity), so the ledger alias and the write path always agree. */
 export declare function resolveLegacyAsiFeat(registry: FeatSearch, classEntity: {
     slug: string;
     edition?: string;
@@ -56,22 +13,6 @@ export declare function resolveLegacyAsiFeat(registry: FeatSearch, classEntity:
     slug: string;
     childId: string;
 } | null;
-/**
- * The level block to store BEFORE a Builder edit applies, or null for "no conversion" (spec §5.2 item 4, §5.5). The plugin's
- * `setChoice` calls it for EVERY write with the edit's key and value (Gate 1 M-8), so the `feat` vocabulary stays here.
- *
- * Null when the key is neither `feat` nor `feat:`-prefixed, when the block is not a convertible legacy level
- * ({@link convertibleLegacyAsi}), or when the class has no ASI feat ({@link resolveLegacyAsiFeat}). Else a NEW object:
- * every key of `block` except `asi-or-feat`, `asi` and `feat:<childId>`, plus `feat: <the ASI slug>`, plus
- * `feat:<childId>: <the legacy allocation>` UNLESS the edit is a SWITCH: `key === "feat"` with any value other than the
- * ASI slug, so a pick of another feat (Gate 1 I-1, ruled option (a)) and the chip removal (null / undefined; final
- * review, Review 3 m6, ruled) both count. A switch writes no `feat:<childId>` at all, so the legacy points and any
- * stale child are dropped and the level's pick stays open (the new feat's own, or the removed ASI's), which is what
- * today's orphan rule does for a switch; a chip removal is therefore not reversible, and re-picking the ASI feat after
- * it starts open. The stepper and a re-pick of the ASI feat keep the full conversion, where the legacy allocation
- * overwrites a stale child. Other keys at the level are kept untouched; the input is never mutated. An over-allocated
- * legacy level is copied verbatim and then clamped by the feat's own rules when the sheet folds it (Gate 1 M-10).
- */
 export declare function migrateLegacyAsiLevel(block: unknown, key: string, value: unknown, registry: FeatSearch, classEntity: {
     slug: string;
     edition?: string;

package/dist/pc/pc.asi-flatten.js

@@ -1,16 +1 @@
-import {
-  convertibleLegacyAsi,
-  flattenAsiOrFeat,
-  legacyAsiBranch,
-  migrateLegacyAsiLevel,
-  resolveLegacyAsiFeat
-} from "../chunk-LBEXLN6I.js";
-import "../chunk-ZCTUYGNV.js";
-import "../chunk-WELIKLZF.js";
-export {
-  convertibleLegacyAsi,
-  flattenAsiOrFeat,
-  legacyAsiBranch,
-  migrateLegacyAsiLevel,
-  resolveLegacyAsiFeat
-};
+import{convertibleLegacyAsi,flattenAsiOrFeat,legacyAsiBranch,migrateLegacyAsiLevel,resolveLegacyAsiFeat}from"../chunk-QVWT67WA.js";import"../chunk-63YJPWTM.js";import"../chunk-EVT7MGAC.js";export{convertibleLegacyAsi,flattenAsiOrFeat,legacyAsiBranch,migrateLegacyAsiLevel,resolveLegacyAsiFeat};

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

@@ -1,3 +1,4 @@
 import type { CharacterState, Edition, ConditionEffects } from "./pc.types.js";
 import type { Ability } from "@archivist-gg/dnd5e";
 export declare function computeConditionEffects(state: CharacterState, edition: Edition, _scores: Record<Ability, number>): ConditionEffects;
+export declare function speedConditionNames(state: CharacterState, edition: Edition): string[];

package/dist/pc/pc.conditions.js

@@ -1,6 +1 @@
-import {
-  computeConditionEffects
-} from "../chunk-MYY2C5MB.js";
-export {
-  computeConditionEffects
-};
+import{computeConditionEffects,speedConditionNames}from"../chunk-VA3ZWV7C.js";export{computeConditionEffects,speedConditionNames};

package/dist/pc/pc.containment.d.ts

@@ -1,8 +1,5 @@
 import type { EntityRegistry } from "@archivist-gg/core";
 import type { EquipmentEntry } from "./pc.types.js";
-/** I2a · containment (spec 2026-09-24-inv-i2a-containment-data-design.md §4). The equipment array stays FLAT; an entry
- *  sits inside another through `in: <id>`. What counts as a container is the item's `container` data
- *  (isContainerItem), never a name list. */
 export type ContainmentBreak = "equipped" | "missing" | "self" | "unresolved" | "not-container" | "cycle";
 export interface ContainmentView {
     parentOf: ReadonlyArray<number | null>;
@@ -16,8 +13,6 @@ export interface ContainmentView {
     }>;
 }
 export declare function nonEmptyRef(v: unknown): string | null;
-/** `container.holds_items` decides when present; otherwise a weight or item capacity, or weightless contents, make a
- *  container. A pack_contents-only block (a pack) and a volume-only block (a liquid holder) are not containers. */
 export declare function isContainerItem(entity: unknown): boolean;
 export declare function idOwners(equipment: readonly EquipmentEntry[]): {
     ownerOfId: Map<string, number>;

package/dist/pc/pc.containment.js

@@ -1,24 +1 @@
-import {
-  canMoveInto,
-  ensureEntryId,
-  entityOfEntry,
-  idOwners,
-  isContainerItem,
-  moveInto,
-  nonEmptyRef,
-  repairContainment,
-  resolveContainment
-} from "../chunk-EJP263OP.js";
-import "../chunk-CM5CWO4K.js";
-import "../chunk-ZCTUYGNV.js";
-export {
-  canMoveInto,
-  ensureEntryId,
-  entityOfEntry,
-  idOwners,
-  isContainerItem,
-  moveInto,
-  nonEmptyRef,
-  repairContainment,
-  resolveContainment
-};
+import{canMoveInto,ensureEntryId,entityOfEntry,idOwners,isContainerItem,moveInto,nonEmptyRef,repairContainment,resolveContainment}from"../chunk-4E2GIWJE.js";import"../chunk-PZ4L2EEG.js";import"../chunk-63YJPWTM.js";export{canMoveInto,ensureEntryId,entityOfEntry,idOwners,isContainerItem,moveInto,nonEmptyRef,repairContainment,resolveContainment};

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

@@ -12,97 +12,28 @@ export interface ResolvedOption {
     value: string;
     label: string;
     entity?: RegisteredEntity;
-    /** The option's own prose (a select-inline InlineOption may supply one — e.g. each
-     *  Combat Mastery describes what it does). Surfaced by the strip near the chips. */
     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
- * never reports an error for too many picks; the picker UI owns cap enforcement.
- * A pick that FOLDS into proficiencies never over-selects, though: {@link capAtCount}
- * keeps its first `count` stored values, in the ledger and the fold alike.
- * Likewise for ability-points `max_per`: the engine only sums total points
- * allocated, so per-ability caps are picker-enforced, not reflected here.
- */
 export type DecisionStatus = "resolved" | "partial" | "unresolved" | "informational";
 export interface DecisionItem {
     key: string;
     source: FeatureSource;
     level: number;
     featureName: string;
-    /**
-     * The source feature/trait's own description (race trait, background feature,
-     * class feature) — threaded through from the walk that emits the item so the
-     * decision strip can render it as a quiet markdown block at the top of the
-     * row's nest (smoke r7). Top-level rows only; a child inherits NOTHING from
-     * its parent — it carries the sub-choice option's own `description` (when the
-     * authored InlineOption supplies one) or none.
-     */
     description?: string;
-    /**
-     * When `status === "informational"` this is a placeholder sentinel and MUST
-     * NOT be rendered — informational items render from `featureName` only
-     * (Task 16 contract). For every other status it is the real choice to render.
-     */
     choice: Choice;
     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;
     };
-    /** ART-a (spec §5.1, R20): present ONLY on a synthesized pool item whose pool offers a repeatable member: one entry per
-     *  such member, with its option rows resolved for the per-copy picker (visible candidates only, U-A). */
     repeatable?: RepeatableMember[];
-    /**
-     * Populated only for the selected branch of a select-inline (the
-     * revealed-on-selection rule): a child decision becomes visible once its
-     * parent option is chosen. An unresolved child downgrades the parent's
-     * status to "partial".
-     */
     children?: DecisionItem[];
-    /** D2b-A (design §2.2 step 7): on a child of a pool item, the name of the member the choice belongs to ("Lessons of the
-     *  First Ones"), so the strip reads "Lessons of the First Ones · Origin feat". Absent everywhere else. */
     parentLabel?: string;
 }
 export interface DecisionLedger {
@@ -117,48 +48,13 @@ 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;
 }
-/** `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 a plugin importer OF THIS SYMBOL (`components/builder/class-step.ts`, under
- *  `packages/obsidian/src/modules/pc/`; the two background surfaces moved to the plugin's `refLabel`, which reads
- *  `entities/slug` directly, on 2026-09-25) 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;
-/** Map a starting-equipment category grant to a nested select-entity child (vocabulary on
- *  {@link parseEquipmentCategory}). Weapons filter by weapon_category; armor by armor_category; `shield` is an armor
- *  entity in the shield class; a tool category is a MUNDANE item of the category's `type` (magic instruments carry
- *  `type: instrument` too).
- *
- *  An UNKNOWN category is never guessed. It used to fall through to `weapon_category: "simple"`, which is how the
- *  PHB 2024 Bard's "Choose a musical instrument" listed Club, Dagger and Dart. It now yields `from: []`, the
- *  engine's existing zero-option shape (an authored empty pool: the row stays open and the strip prints its
- *  "No options available" line), and warns ONCE per distinct category. */
 declare function categoryToEntitySelect(category: string, id: string): Choice;
-/** Test-only export of {@link categoryToEntitySelect}. */
 export declare const __categoryToEntitySelectForTest: typeof categoryToEntitySelect;
-/** Walk every decision definition + persisted selection and collect chosen
- *  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[];
@@ -167,46 +63,16 @@ export declare function collectChosenProficiencies(resolved: ResolvedCharacter):
     weapons: string[];
     saves: Ability[];
 };
-/** 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 interface RuleProficiencySources {
+    skills: Record<string, string[]>;
+    expertise: Record<string, string[]>;
+    saves: Partial<Record<Ability, string[]>>;
+}
+export declare function collectRuleProficiencySources(resolved: ResolvedCharacter): RuleProficiencySources;
 export declare function computeEffectiveProficiencies(resolved: ResolvedCharacter): {
     languages: ProficiencyEntry[];
     tools: ProficiencyEntry[];
 };
-/** D4 A: the complement of {@link computeEffectiveProficiencies}: every language and tool the character's grants, picks
- *  or adds would hold but `overrides.<domain>.remove` (or a `none` tools tri) suppresses, each entry keeping its
- *  `sources` and `origin`. The proficiency picker draws these struck through ("Dwarf · removed"). Both functions read
- *  ONE composer, so a row is kept or suppressed, never both and never neither. */
 export declare function computeSuppressedProficiencies(resolved: ResolvedCharacter): {
     languages: ProficiencyEntry[];
     tools: ProficiencyEntry[];
@@ -215,10 +81,5 @@ export interface OriginAbilityPoints {
     race: Partial<Record<Ability, number>>;
     background: Partial<Record<Ability, number>>;
 }
-/** Pure: folds ORIGIN (race/background) `ability-points` decisions out of
- *  origin_choices into per-namespace totals. Values are clamped picker-side
- *  already, but clamp again defensively: per-ability max_per, then stop at the
- *  points total walking ABILITY_KEYS order. Class-level ASI stays on the
- *  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;

package/dist/pc/pc.decision-engine.js

@@ -1,55 +1 @@
-import {
-  __categoryToEntitySelectForTest,
-  __matchesFilterForTest,
-  buildDecisionLedger,
-  collectChosenAbilityPoints,
-  collectChosenProficiencies,
-  computeEffectiveProficiencies,
-  computeSuppressedProficiencies
-} from "../chunk-EJD47JHL.js";
-import "../chunk-2LULMQTF.js";
-import "../chunk-QA3YCOML.js";
-import "../chunk-64VNLMSG.js";
-import "../chunk-TOM66P2P.js";
-import "../chunk-KU3YLF6D.js";
-import "../chunk-5JXFJ5AU.js";
-import "../chunk-RD2MID3M.js";
-import "../chunk-LICYHPI3.js";
-import "../chunk-PVCEA4HZ.js";
-import "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-LBEXLN6I.js";
-import "../chunk-NXUY5XQN.js";
-import "../chunk-W6GC6OKK.js";
-import "../chunk-B3DP42OM.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-YHYTW5QA.js";
-import "../chunk-ZUQW5VBZ.js";
-import "../chunk-IHE6KVC3.js";
-import "../chunk-LHZXYFBU.js";
-import "../chunk-YBLDE5CG.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-CM5CWO4K.js";
-import "../chunk-4J6DS3EJ.js";
-import "../chunk-EVMUJYUD.js";
-import "../chunk-VTTA2ALZ.js";
-import {
-  wikilinkTailSlug
-} from "../chunk-ZCTUYGNV.js";
-import "../chunk-7Q2VPKCD.js";
-import "../chunk-ZDAEGJH4.js";
-import "../chunk-3TM34RSJ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-import "../chunk-4U55VNC7.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  __categoryToEntitySelectForTest,
-  __matchesFilterForTest,
-  buildDecisionLedger,
-  collectChosenAbilityPoints,
-  collectChosenProficiencies,
-  computeEffectiveProficiencies,
-  computeSuppressedProficiencies,
-  wikilinkTailSlug
-};
+import{__categoryToEntitySelectForTest,__matchesFilterForTest,buildDecisionLedger,collectChosenAbilityPoints,collectChosenProficiencies,collectRuleProficiencySources,computeEffectiveProficiencies,computeSuppressedProficiencies}from"../chunk-J5GL6FLP.js";import"../chunk-2EOGK6R6.js";import"../chunk-RQZCGXUZ.js";import"../chunk-GD7WRCNH.js";import"../chunk-FOLHTMSC.js";import"../chunk-4JEF3CET.js";import"../chunk-VTQ4RWEG.js";import"../chunk-J3RP5C7L.js";import"../chunk-WAUNLUFQ.js";import"../chunk-CEHL7PPC.js";import"../chunk-UBUKCRZ3.js";import"../chunk-KEXSF3CH.js";import"../chunk-PFQPP77Q.js";import"../chunk-QVWT67WA.js";import"../chunk-PKIMOVQG.js";import"../chunk-CMIEZQL4.js";import"../chunk-CSTAQQGX.js";import"../chunk-O776WL7O.js";import"../chunk-3LWOVRLA.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.js";import"../chunk-3QQOATV3.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-EAARMPCW.js";import"../chunk-CAPYNIGK.js";import{wikilinkTailSlug}from"../chunk-63YJPWTM.js";import"../chunk-4KVVAENP.js";import"../chunk-7EL3GWWJ.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";import"../chunk-S5UCI27C.js";import"../chunk-ZVL5FXXO.js";import"../chunk-I26FHSI6.js";export{__categoryToEntitySelectForTest,__matchesFilterForTest,buildDecisionLedger,collectChosenAbilityPoints,collectChosenProficiencies,collectRuleProficiencySources,computeEffectiveProficiencies,computeSuppressedProficiencies,wikilinkTailSlug};

package/dist/pc/pc.defense-normalize.d.ts

@@ -1,11 +1 @@
-/**
- * Canonical key for a defense value (damage type or condition).
- *
- * Deliberately SIMPLER than `toProfSlug` (pc.proficiency-normalize.ts): damage types and conditions carry
- * no apostrophes and no hyphens, so there is no U+2019 fold and no space-to-hyphen step. Do NOT reuse
- * `normKey` · it token-sorts and singularizes for weapon display names and is actively wrong here.
- *
- * The whole point of this function is that ONE normalizer serves every reader and writer on the defenses
- * path. Adding a second is the bug R4-P5 exists to remove.
- */
 export declare function toDefenseSlug(s: string): string;

package/dist/pc/pc.defense-normalize.js

@@ -1,6 +1 @@
-import {
-  toDefenseSlug
-} from "../chunk-XJ2F2WO6.js";
-export {
-  toDefenseSlug
-};
+import{toDefenseSlug}from"../chunk-LR6UMA5V.js";export{toDefenseSlug};

package/dist/pc/pc.entry-overrides.d.ts

@@ -3,75 +3,36 @@ import type { ActionCost } from "../types/resource.js";
 import type { EquipmentEntry, EquipmentEntryState } from "./pc.types.js";
 import { type EntryView } from "./pc.infusions.js";
 export type CustomizableKey = "name" | "charges" | "recovery" | "action" | "range" | "bonus" | "damage_bonus" | "extra_damage" | "ac_bonus" | "resist";
-/** The attack row's cost when the entry stores no `overrides.action` (pc.equipment.ts). */
 export declare const WEAPON_DEFAULT_ACTION_COST: ActionCost;
-/** A weapon, or an item whose `base_item` resolves to a weapon: it fills the main hand and owns an
- *  attack row (pc.slotting.ts `defaultSlotForType`). With a view, its rule entity decides (an infused
- *  weapon's wrapper routes through its `base_item`). */
 export declare function isWeaponLikeEntry(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): boolean;
-/** The override keys some consumer reads for this entry's type. The Customize card adds every key the
- *  entry already STORES (so it can always be cleared); that union is the card's, not this rule's. */
 export declare function customizableOverrideKeys(entry: EquipmentEntry, registry: EntityRegistry | null): Set<CustomizableKey>;
-/** The action cost the sheet shows when no `overrides.action` is stored: the attack row's default for a
- *  weapon-like entry; the items row's cost (a view's `action`, the curated cost, or the potion or scroll
- *  default) otherwise; else null. With a view, its rule entity decides each read. */
 export declare function defaultActionCost(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): ActionCost | null;
-/** A spell scroll's spell's cost, the registry half of `resolveItemAction`'s scroll default (it has no registry; its
- *  two callers do, and pass this as `opts.spellCost`: `defaultActionCost` here and the plugin's Actions collector).
- *  The spell is the one the entry sets (`overrides.spell`: a `[[slug]]` wikilink or a bare slug), looked up as the
- *  Spells tab looks it up (`collectItemGrantedSpells`); its `casting_time` is read by the ONE casting-time reader. An
- *  action, bonus action or reaction is the cost; anything else (a minute or hour cast, no spell set, a spell not
- *  installed, no registry) is undefined, so the scroll default falls back to Action. */
 export declare function scrollSpellCost(entry: EquipmentEntry, registry: EntityRegistry | null): ActionCost | undefined;
-/** A charges field's maximum (spec §5.6, U-7 A): an object's `max`, or a positive number (the two item-note shapes,
- *  item.schema.ts); an infusion overlay's `charges` has the object shape. */
 export declare function itemChargesMax(entity: unknown): number | undefined;
-/** The recovery rule an item recharges by (spec §5.5, §5.6, U-7 A), in this order: none for an item consumed on use
- *  ({@link isConsumedOnUse}: it has no charges to recharge, even over a rule stored before that ruling) or an orphan
- *  created entry (its RULE entity is null, nothing folds); an INFUSED view's overlay `charges` (their `recharge`,
- *  `dawn` refilling on a long rest); the stored rule; the item note's own `charges.recharge`; else the curated rule
- *  for a wikilinked entry. A plain-text entry never picks up a curated rule the Actions row cannot show. */
 export declare function effectiveItemRecovery(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): NonNullable<EquipmentEntryState["recovery"]> | undefined;
-/** Consumed on use (T17 rider C fold, user ruling 2026-09-24): using one spends the entry's QUANTITY, never a charge
- *  (a potion, Holy Water, an oil, Alchemist's Fire, Dust of Disappearance, a scroll), so the item has no charges and
- *  no recovery anywhere and the sheet shows its quantity only. Data decides, in two places: the curated `consumed`
- *  flag of `ITEM_ACTIONS` (no registry needed), else the entity's own data, a `potion` or `scroll` type (the type the
- *  potion default of `resolveItemAction` already reads) or a `scroll_level` marker. A plain-text entry is never one:
- *  it resolves to no entity, as in every other rule here. */
 export declare function isConsumedOnUse(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): boolean;
-/** The ONE "is a spell scroll" rule (T17 rider GH, carried from rider C's close), by the entity's own data: its `scroll`
- *  type or its `scroll_level` marker. A scroll is consumed on use ({@link isConsumedOnUse}). Read value-based, with no
- *  rarity gate: null, a non-object or an entity with neither field is no scroll. An entry reaches it through its resolved
- *  entity, so with no registry, or for a plain-text entry, nothing is a scroll. */
 export declare function isScrollEntity(entity: unknown): boolean;
-/** A scroll the sheet can CAST: it carries the `scroll_level` marker, the level its spell is cast at (0 = cantrip). Its
- *  use is that cast (the Spells tab spends it), so the Actions row offers it no Use of its own. A scroll typed `scroll`
- *  with no marker (the 2014 SRD spell scrolls) names no level: it is not castable, and its Actions row keeps the plain
- *  Use every other item consumed on use has (T17 rider GH). */
 export declare function isCastableScroll(entity: unknown): boolean;
-/** The charge pair an item shows, the twin of {@link effectiveItemRecovery}. Its sources, in this order (spec §5.5,
- *  §5.6, U-7 A):
- *  1. none for an item consumed on use (its quantity is what it has, {@link isConsumedOnUse}, even over a pair stored
- *     before that ruling), and none for an orphan created entry (its view's RULE entity is null: nothing folds);
- *  2. an INFUSED view whose overlay has `charges`: they live in the MARKER, `infusion.charges.current` (absent = full,
- *     clamped to the overlay max), never in `state`;
- *  3. the stored pair as stored (a legacy `{0, 0}` included, so it can still be cleared);
- *  4. the item note's OWN `charges` (an object's `max`, or a number) as a FULL pair: every item reads its own data;
- *  5. the curated `max_charges` of a wikilinked entry as a FULL pair, the fallback for notes without data;
- *  else none. An item with no stored charges is full, the rest plan's own reading. Every surface that shows or spends
- *  an item's charges reads this (through `entryCharges` once it holds the view), and so does the rest plan, so a wand
- *  is listed wherever its charges are and a potion nowhere. */
+export declare function settableSpellLevel(entity: unknown): number | null;
+export declare function storesSpell(entity: unknown): boolean;
+export declare function storedSpellNumbers(entity: unknown): {
+    saveDC?: number;
+    attackBonus?: number;
+} | null;
+export type ItemSpellUse = {
+    kind: "consume";
+} | {
+    kind: "charges";
+    cost: number;
+    charges: {
+        current: number;
+        max: number;
+    };
+} | {
+    kind: "at-will";
+};
+export declare function itemSpellUse(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): ItemSpellUse | null;
 export declare function effectiveItemCharges(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): NonNullable<EquipmentEntryState["charges"]> | undefined;
-/** The Armor Class an armour or shield entry gives (T17 T-25), by the terms `computeAC` (pc.equipment.ts) adds for it:
- *  the slot's own terms ({@link slotAcTerms}: the armour's AC, through `base_item` for a magic armour, `effectiveArmor`,
- *  and the entry's `overrides.ac_bonus`), and the item's own unconditional `bonuses.ac` (a +2 armour's +2). A shield's `value` is what it
- *  ADDS; an armour's is the AC it sets, plus Dex where `addDex` says so. What the item gives WORN: the engine applies
- *  these only while it is equipped (the bonus only while attuned where attunement is required), and a conditional
- *  `bonuses.ac` is left out, its conditions being the character's. Every surface that shows an entry's AC reads this, so
- *  a magic armour never shows its base armour's AC; the consumer-agreement test holds it to the engine's own sum. Null
- *  for an entry that is neither (a weapon, a ring, an unresolved link, plain text) and without a registry. With the
- *  entry's view (ART-a, spec §5.3) the rule entity is read: an infused armor or shield gives its base's terms plus the
- *  wrapper's scaled `bonuses.ac`, the ONE slot term `computeAC` merges for it. */
 export declare function effectiveItemArmorClass(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): {
     value: number;
     shield: boolean;