@archivist-gg/dnd5e 0.3.19 → 0.3.26

package/dist/pc/pc.types.d.ts

@@ -15,9 +15,6 @@ import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-f
 import type { PoolLayout, PoolActive } from "../types/selection-pool.js";
 import type { ConditionSlug } from "./conditions.constants.js";
 import type { ResourceIndex } from "./pc.resources.js";
-/** A persisted decision value: entity slug / inline value (string), multi-select
- *  slugs (string[]), or an ability-points allocation. Stale/odd legacy values
- *  survive parsing (schema is permissive); readers narrow defensively. */
 export type ChoiceValue = string | string[] | Partial<Record<Ability, number>>;
 export type LevelChoices = Record<string, ChoiceValue>;
 export interface ClassEntry {
@@ -39,9 +36,7 @@ export interface EquipmentEntryOverrides {
     immune?: string[];
     vulnerable?: string[];
     condition_immune?: string[];
-    /** Per-instance spell payload (e.g. the spell a Spell Scroll casts). */
     spell?: string;
-    /** Ability governing this instance's spell save DC / attack when cast. */
     spell_ability?: Ability;
 }
 export interface EquipmentEntryState {
@@ -60,7 +55,6 @@ export interface EquipmentEntryState {
         effect: string;
     };
 }
-/** ART-a (spec §4.3): the infusion marker on an equipment entry; see `infusionMarkerSchema` in pc.schema.ts. */
 export interface InfusionMarker {
     kind: "infused" | "created";
     by: string;
@@ -79,17 +73,9 @@ export type EquipmentEntry = {
     slot?: SlotKey | null;
     overrides?: EquipmentEntryOverrides;
     state?: EquipmentEntryState;
-    /** Build-only provenance tag for gear the Builder's Equipment step seeded
-     *  on the character's behalf (e.g. `"builder:starting"`, `"builder:gold-buy"`).
-     *  Lets the step reconcile its own grants on re-pick / mode-switch without
-     *  touching hand-managed entries. Stripped by finishBuild — absent on every
-     *  finished file. */
     granted_by?: string;
-    /** I2a · this entry's stable identity; minted only when something is moved INTO it. */
     id?: string;
-    /** I2a · the `id` of the container entry holding this one; ignored while the entry is equipped (C7). */
     in?: string;
-    /** ART-a · the infusion marker (spec §4.3): a top-level key, never under `state` or `overrides` (both strict). */
     infusion?: InfusionMarker;
 };
 export interface ResolvedEquipped {
@@ -116,17 +102,10 @@ export interface KnownSpellObject {
     source?: "class" | "feat" | "item" | "race" | "domain";
     prepared?: boolean;
     always_prepared?: boolean;
-    /** The spell's own spellcasting ability (e.g. WIS for a Magic Initiate (Cleric)
-     *  pick). Belongs on the persisted shape for symmetry with ResolvedSpell.ability;
-     *  feat spells arrive via origin_choices, but a known-spell entry may carry it. */
     ability?: Ability;
 }
 export type KnownSpellEntry = string | KnownSpellObject;
 export type PassiveKind = "perception" | "investigation" | "insight";
-/** The manual proficiency tri, in ONE place. The runtime twin is `proficiencyTri`
- *  (pc.schema.ts); `pc.recalc.ts` imports this name for the skills tri, and the plugin's
- *  `CharacterEditState` imports it for the tools tri its writers keep (R4-G4 §9.3, UR1;
- *  `setToolExpertise` since D4 A), so no consumer re-spells the union. */
 export type ProficiencyTri = "none" | "proficient" | "expertise";
 export interface CharacterOverrides {
     scores?: Partial<Record<Ability, number>>;
@@ -152,26 +131,9 @@ export interface CharacterOverrides {
     speed?: number;
     initiative?: number;
     spellcasting_ability_by_class?: Partial<Record<string, Ability>>;
-    /** Character-level spellcasting ability for spells that carry no ability of
-     *  their own (e.g. a Spell Scroll cast by a non-caster): the DC-ability fallback
-     *  after a per-instance override and the character's own class ability. */
     spellcasting_ability?: Ability;
     spell_slots?: Record<number, number>;
     attunement_limit?: number;
-    /** Manual proficiency edits, mirroring `characterOverridesShape` (pc.schema.ts). `remove`
-     *  SUPPRESSES a rules-granted entry ("a dwarf who doesn't know dwarvish"). Both keys and EVERY
-     *  leaf are optional with no defaults, so an untouched note stays byte-identical: every reader
-     *  uses `?? []` (`?? {}` for the tools tri).
-     *
-     *  `tools.proficiency` is the per-tool manual tri (R4-G4 §9.3, UR1); `languages` deliberately
-     *  gets none. This line is the ONLY thing keeping the interface honest about it, and what it
-     *  buys is TYPE VISIBILITY, not survival: the `NoOverridesKeyDrift` pair below compares
-     *  TOP-LEVEL keys only, so a sibling added to the schema and not here ROUND-TRIPS at runtime
-     *  (the plugin's `characterToYaml` deep-clones and dumps the RUNTIME object, and `parsePC`
-     *  runs `characterSchema.safeParse`, which keeps a key the schema declares) while staying
-     *  UNTYPED, so no consumer can read or write it without a cast. That is the same direction the
-     *  parity block below states; the STRIPPED case is the other one, a key here that the schema
-     *  lacks. */
     languages?: {
         add?: string[];
         remove?: string[];
@@ -181,10 +143,6 @@ export interface CharacterOverrides {
         remove?: string[];
         proficiency?: Record<string, ProficiencyTri>;
     };
-    /** D4 A: the same add / remove pair for WEAPON and ARMOR proficiencies. A weapon value is a category (`simple`,
-     *  `martial`) or one weapon (`longsword`, `hand-crossbow`); an armor value is `light`, `medium`, `heavy` or `shield`.
-     *  Read through `proficiencyKey` (pc.proficiency-normalize.ts), so any spelling of a grant matches. No defaults, like
-     *  `languages`/`tools`: an untouched note stays byte-identical. */
     weapons?: {
         add?: string[];
         remove?: string[];
@@ -193,13 +151,6 @@ export interface CharacterOverrides {
         add?: string[];
         remove?: string[];
     };
-    /** Manual defense edits, mirroring `characterOverridesShape` (pc.schema.ts). SUPPRESSION-ONLY:
-     *  the absent `add` channel is a DELIBERATE asymmetry with `languages`/`tools` above, not an
-     *  oversight · do not "complete the pattern". The additive store is `character.defenses.*`,
-     *  which already exists; a second additive channel would recreate the two-writers divergence
-     *  R4-P5 exists to remove. Every level is optional with no defaults, so an untouched note stays
-     *  byte-identical. The store has NO consumer as of this commit · Task 5 writes the first, and
-     *  should read every level as possibly absent (`?? []`) and match with `toDefenseSlug`. */
     defenses?: {
         resistances?: {
             remove?: string[];
@@ -246,13 +197,8 @@ export interface CharacterState {
         used: number;
         max: number;
     }>;
-    /** R4-G5 G8: banked prerolled dice, keyed by the SAME resource id as feature_uses.
-     *  SIGN IS STATE: negative = spent, positive = live; positions never move. */
     feature_rolls: Record<string, number[]>;
-    /** Phase 3 activatable buffs: ids/slugs of activatable features/boons currently
-     *  toggled on. Their effects fold into recalc only while listed here. */
     active_buffs?: string[];
-    /** @deprecated SP5: moved to Character.currency. Tolerated until Task 4 parser migration strips it. */
     currency?: {
         cp: number;
         sp: number;
@@ -260,22 +206,18 @@ export interface CharacterState {
         gp: number;
         pp: number;
     };
-    /** @deprecated SP5: removed; per-entry attuned flag is canonical. Tolerated until Task 4 parser migration strips it. */
     attuned_items?: string[];
 }
-/** Per-character sheet state (phases AF and SL): layout and Actions/Passive view choices. Mirrors `sheetStateSchema`. */
 export interface SheetViewFilter {
     show?: string[];
     hide?: string[];
 }
-/** PT (spec §7): one pool tab's view: what Show keeps, the facet values un-ticked (by facet id), the folded groups. */
 export interface SheetPoolView {
     show?: "known" | "granted" | "not-known";
     off?: Record<string, string[]>;
     folded?: string[];
 }
 export interface CharacterSheetState {
-    /** `saves: section` (SL) draws the saves as a sidebar section; `body: wide` (D13) is the wide three-column sheet. */
     layout?: {
         saves?: "section";
         body?: "wide";
@@ -290,36 +232,22 @@ export interface CharacterSheetState {
 export interface Character {
     name: string;
     edition: Edition;
-    /** Present and `true` only while the file is a Builder draft (autosaved,
-     *  resumable). Removed by the Builder's Finish action, which flips the file
-     *  to the full character sheet. Absent on every pre-Builder/finished file. */
     builder?: boolean;
     alignment?: string;
-    /** Optional free-text age ("26", "Ageless") — Details step. */
     age?: string;
     race: string | null;
     subrace: string | null;
     background: string | null;
     class: ClassEntry[];
-    /** Race/background decision selections, keyed `race:<choice-id>` /
-     *  `background:<choice-id>` (SP2 Plan 3). */
     origin_choices?: Record<string, ChoiceValue>;
     abilities: Record<Ability, number>;
     ability_method: AbilityMethod;
-    /** Persisted Roll-method ability pool (six 4d6-drop-lowest totals) while the
-     *  file is a Builder draft. Present only in `rolled` mode during a build so
-     *  the rolled pool survives view close / Obsidian restart (UI state cannot);
-     *  the Abilities step + Base popover read their pool from here. Removed by the
-     *  Builder's Finish action (see finishBuild) — a finished file carries none. */
     builder_rolls?: number[];
-    /** Persisted Equipment-step mode while the file is a Builder draft: "starting"
-     *  takes the class/background starting-gear grants, "gold" buys with rolled
-     *  starting gold, "empty" begins with nothing. Present only during a build;
-     *  removed by the Builder's Finish action (see finishBuild). */
     builder_equipment_mode?: "starting" | "gold" | "empty";
     skills: {
         proficient: SkillSlug[];
         expertise: SkillSlug[];
+        half?: SkillSlug[];
     };
     spells: {
         known: KnownSpellEntry[];
@@ -335,8 +263,6 @@ export interface Character {
         gp: number;
         pp: number;
     };
-    /** DM grants: optional-feature slugs resolved onto the character with no class, level or pool behind
-     *  them. Placement is the declaring note's `surface`, never a flag here. */
     additional_features?: string[];
     notes?: string;
     defenses?: {
@@ -348,9 +274,6 @@ export interface Character {
     sheet?: CharacterSheetState;
     state: CharacterState;
 }
-/** R4-G7 T8 RIDER-23 (F-FEATSRC) · the slot that granted a feat: a class's `choices[<level>].feat` pick, or a 2024
- *  background's origin feat. Its two members ARE the `class` and `background` sources below, so a renderer formats `via`
- *  through the arms it already has ("Fighter 4", "Background: Soldier"). */
 export type FeatVia = {
     kind: "class";
     slug: string;
@@ -358,15 +281,10 @@ export type FeatVia = {
 } | {
     kind: "background";
     slug: string;
-}
-/** SRD-G T4 (audit §3b): a feat picked through a species trait (the SRD 5.2 Human's Versatile origin feat). */
- | {
+} | {
     kind: "race";
     slug: string;
-}
-/** D2b-A (design §2.2 step 6): a feat a POOL MEMBER grants (Lessons of the First Ones' Origin feat). `slug` is the
- *  member's note slug and `name` its display name; `classSlug` / `level` are the pool's class and anchor level. */
- | {
+} | {
     kind: "pool";
     slug: string;
     name: string;
@@ -391,53 +309,24 @@ export type FeatureSource = {
     kind: "feat";
     slug: string;
     via?: FeatVia;
-}
-/** A DM grant listed in `character.additional_features`. No class, no level, no pool behind it. */
- | {
+} | {
     kind: "campaign";
     slug: string;
+} | {
+    kind: "item";
+    slug: string;
+    index: number;
 };
 export interface ResolvedFeature {
     feature: Feature;
     source: FeatureSource;
-    /** #3: chosen select-inline option prose, folded onto the PARENT feature for
-     *  render (a shallow-copy wrapper field — the shared registry entity is never
-     *  mutated). One entry per select-inline choice with a recorded pick. */
     chosenInline?: {
         label: string;
         description?: string;
     }[];
-    /** #3: marks a synthesized chosen-option feature the renderer must SKIP (its
-     *  prose shows on the parent via chosenInline). A wrapper-only flag —
-     *  computeFeatureEffects ignores it, so the synthetic's effects still fold. */
     renderSuppressed?: boolean;
-    /** The feat's entire substance is a full ability-score improvement (a pure ASI). The DISPLAY layer hides these. */
     buildOnly?: boolean;
-    /** The spells this feature's spell-scoped damage riders reach, as its data names them (`memberSpellTargets`): set by
-     *  `assembleEffectFeatures` on a pool member (Agonizing Blast's cantrip pick, the 2014 invocation's `spell-known`
-     *  prerequisite). A wrapper-only field; absent on every other feature, whose spell riders then reach no spell. */
     spellTargets?: SpellTargets;
-    /** R4-G7 §7.1: EVERY LOWER copy the resolve-time fold collapsed into this wrapper, ASCENDING by level, with
-     *  that copy's own card identity (`name`, and `description` = its `description` else its `entries` joined) and
-     *  its `choices` when it carries any. A wrapper-only field, the `chosenInline` precedent: the shared registry
-     *  `Feature` is never touched.
-     *
-     *  The invariant every walker relies on: the TOP copy's own name, prose and choices stay on `feature` and are
-     *  NEVER repeated here, so visiting `foldedFrom` (each entry at its own `level`) and then `feature` (at
-     *  `source.level`) visits every folded copy EXACTLY ONCE, in ascending level order · the order the un-folded
-     *  list had. That is what keeps "a level-N decision on a repeated feature stays a decision at level N" true,
-     *  and what keeps the builder's per-level strip complete, while the sheet renders ONE row.
-     *
-     *  Both readers live in `pc.decision-engine.ts`: `visitProficiencyChoices` (through
-     *  `collectChosenProficiencies`) walks the entries that carry `choices` and nothing else, and
-     *  `buildDecisionLedger` runs each entry at its own level through the SAME branch it runs the wrapper through
-     *  (`emitCopy`): its authored choices when it has them, else `recognizeDecision`'s synthesized decision under
-     *  the suppression filter, else the informational card, else nothing. Per-copy `name` and `description` are
-     *  load-bearing, not decoration: they decide what the recognizer sees and what the row prints. MEASURED over
-     *  both corpora, 63 of the 131 repeated-id families have a copy whose description differs from the top copy's
-     *  and 1 has a differing name (an UPPER BOUND: it counts `ability-score-improvement` families, which are
-     *  `buildOnly` and never fold; the non-ASI carriers are `artificer-specialist-feature`, `path-feature`,
-     *  `bard-college-feature`, `expertise` and their siblings). Absent on an unfolded wrapper. */
     foldedFrom?: {
         level: number;
         name: string;
@@ -452,20 +341,14 @@ export interface ResolvedSpell {
     source: "class" | "feat" | "item" | "race" | "domain";
     prepared: boolean;
     alwaysPrepared: boolean;
-    /** The spell's OWN spellcasting ability. For a feat spell this carries the
-     *  chosen ability (e.g. WIS for Magic Initiate (Cleric)) while classSlug stays
-     *  null (a feat spell is not owned by a class for DC/ability). Absent/undefined
-     *  for class spells, which derive their ability from classSlug. */
     ability?: Ability | null;
-    /** Index of the originating equipment entry when this spell was granted by a
-     *  per-instance item (e.g. a Spell Scroll). Absent for class/feat/race spells. */
     entryIndex?: number;
-    /** True ONLY for a row from character.spells.known (removable / toggleable);
-     *  absent on every grant · R4-G3b §5.2.7. */
     persisted?: boolean;
-    /** True for a spell cast at will without a spell slot: a pool member's `innate` at-will grant (Armor of Shadows'
-     *  Mage Armor). The Spells tab gives it the At Will chip, never a slot's CAST. Absent on every other row. */
     atWill?: boolean;
+    itemCasting?: {
+        saveDC?: number;
+        attackBonus?: number;
+    };
 }
 export interface ResolvedClass {
     entity: ClassEntity | null;
@@ -473,63 +356,28 @@ export interface ResolvedClass {
     subclass: SubclassEntity | null;
     choices: Record<number, LevelChoices>;
 }
-/** One pool member as resolved for a character: a stored PICK (`selected`), a candidate (`available`) or a subclass
- *  grant (`grants`). `slug` is always the NOTE's registry slug. A pick is KEYED (ART-a, spec §4.4, §5.1): a COPY of a
- *  repeatable note is keyed by its stored `<note slug>#<param>`, so two copies of one note are two entries with one `slug`;
- *  a plain pick's `key` is its resolved `slug` (the stored string, or the survivor of a stored twin), unless it was stored
- *  with a '#', which is kept; candidates and grants carry `key === slug` and `param: null`. */
 export interface ResolvedPoolEntry {
     slug: string;
     entity: OptionalFeatureEntity;
-    /** ART-a (spec §4.6): the pick key the writers compare (see above); the slug for candidates and grants. */
     key: string;
-    /** ART-a: a copy's parameter (a full item slug for `learn`, a row key for `create`); null for any other entry, and for a
-     *  repeatable note stored without `#` (a copy whose option is `needs-choice`). */
     param: string | null;
-    /** ART-a (spec §4.1, §5.2): derived by `isItemBound`. Its subject is an item: no character tracker, no boon fold. */
     itemBound: boolean;
-    /** ART-a (spec §5.8): present on every selected copy of a repeatable note. */
     option?: import("./pc.infusions.js").CopyOption;
-    /** The compendium NAME the REGISTERED entity carries (R4-G5 §9.2.1), stamped at resolve time because `entity` is
-     *  `e.data` (an H3-rebound member's is a copy of it), which carries none: MEASURED 2026-09-07 over the WHOLE
-     *  converter output (226 documents under its `OptionalFeatures` folders) and the 7 bundle ones, 0 of 226 and 0 of 7
-     *  declare a `compendium` key INSIDE the fenced entity body, while 226 of 226 and 7 of 7 declare one in the note's
-     *  FRONTMATTER, which core keeps on `RegisteredEntity`.
-     *  The plugin's ONE visibility predicate reads it on BOTH surfaces (§3.2.2). Absent when the registry entry
-     *  carries none, which in practice means a test double. The COLLAPSE does not read it: its identity is the
-     *  slug PREFIX (§9.2.2). */
     compendium?: string;
 }
-/** A materialized selection pool: count from the table column, prereq-filtered
- *  candidates, player picks (from the choices ledger), and subclass auto-grants. */
 export interface ResolvedPool {
     id: string;
     label: string;
-    /** Which resolved class declared this pool (for ledger anchoring + writes). */
     classIndex: number;
-    /** Picks allowed at the current level (table column value). */
     count: number;
-    /** Lowest class level where count >= 1 — the stable persistence key level. */
     anchorLevel: number;
     selected: ResolvedPoolEntry[];
     available: ResolvedPoolEntry[];
     grants: ResolvedPoolEntry[];
-    /** Derived at resolve time from the members' `rendering_hint` (pool-layout.ts),
-     *  unconditionally: an authored `TabDecl.renders.layout` does not suppress the
-     *  derivation, it OUTRANKS this field at the tab (§4.2.5). R4-G4 T5 LANDED that precedence in the
-     *  plugin: `TabsContainer`'s dynamic-pool-tab loop is the ONE reader of this field (measured
-     *  2026-09-05 with `grep -rn "pool\.layout" packages/obsidian/src`, one line) and reads
-     *  authored-then-derived-then-default before handing the string to the `PoolTab` constructor. */
     layout?: PoolLayout;
-    /** The OWNED resource id the members spend: the majority of the members' PAYERS (H3b `payingResourceId`: the named id
-     *  when owned, else its owned declared equivalent, the pool's class first); undefined when no member has an owned payer
-     *  (R4-G4 §4.2.3, Gate 0 B1; H3b spec §4). */
     resource?: string;
-    /** ART-a (spec §4.5): the declaration's `count.label`, copied raw; read through `poolCountLabel` (absent reads "Known"). */
     countLabel?: string;
-    /** ART-a (spec §4.5): the declaration's `active`, copied raw; read through `poolActiveWords`. */
     active?: PoolActive;
-    /** ART-a (spec §4.5): the declaration's `head_resource`. */
     headResource?: string;
 }
 export interface ResolvedCharacter {
@@ -538,51 +386,17 @@ export interface ResolvedCharacter {
     classes: ResolvedClass[];
     background: BackgroundEntity | null;
     feats: FeatEntity[];
-    /** The bare/full slug of the background's resolved origin feat (R4-G3b §8): stamped by the resolver OUTSIDE the
-     *  feats de-dup guard, so it is set even when the same feat is ALSO a class-slot pick. Read by
-     *  visitProficiencyChoices' origin arm; `resolved.feats` itself carries no provenance. */
     originFeatSlug?: string;
     totalLevel: number;
     features: ResolvedFeature[];
     spells: ResolvedSpell[];
     pools: ResolvedPool[];
-    /** Every `resources[]` entry of every resolved feature, keyed by id, with the DECLARING feature
-     *  stamped as owner, PLUS every pool pick's own `uses` with the POOL stamped as owner
-     *  (R4-G4 §3.2.1 and §12). REQUIRED: the resolver's own literal sets it like `pools` and
-     *  reassigns it after pools resolve. Cast test fixtures omit it. Its readers outside the
-     *  resolver landed with R4-G4 T3, T4, T5 and T7b. Re-measured 2026-09-06 on the SHIPPED plugin
-     *  tree: `grep -rn "resolved\.resources" packages/obsidian/src` returns TEN lines, of
-     *  which SIX are read EXPRESSIONS and four are comment prose. The six expressions sit in six
-     *  functions across five files: the module-private `resourceLevel`
-     *  helper of `components/actions/feature-rows.ts` (T3, reading `?.owner`), `renderSpendControl`
-     *  (`components/actions/spend-control.ts`, reading the entry for its `name` and `die`),
-     *  `consumeCost` (`components/pool-tab.ts`, reading `?.name` for the Cost label), both T4,
-     *  `renderPoolHead` (`components/pool-tab.ts`, T5, reading the entry for the tab head's `name`,
-     *  `die`, `reset` and owner: §4.2.6), and T7b's two: `renderPickTracker`
-     *  (`components/actions/pick-tracker.ts`, reading the entry for a pick's `reset` and `name`) and
-     *  `seedFeatureUses` (`pc.resource-seed.ts`), which is the ONE expression that is not a
-     *  `?.get(...)`: it walks `?.values()` for the entries whose `owner.kind` is `pool`, because a
-     *  pick's `uses` reaches the seed through no other route. §3.2.1 names its consumers: T3's
-     *  `resourceLevel(id, ctx)`
-     *  die helper (§6.2.4), T4's spend control and Cost label (§3.2.2 / §3.2.4), T5's pool-tab
-     *  head and T7b's tracker and seed (§12.2), all LANDED. T7's restore affordance has LANDED too and
-     *  reads NOTHING here: its rest arm
-     *  walks the index `computeRestPlan` re-derives and its card arm routes on `resolveRecovery(rec)`
-     *  over the RAW `recovery[0]`.
-     *  Every one of the six reaches it through `?.`, because the plugin's card / row / rest fixtures
-     *  cast a `ResolvedCharacter` with no index. `computeRestPlan` never reads it at all, it re-derives
-     *  the index. */
     resources: ResourceIndex;
-    /** 2024 Weapon Mastery: bare-normalized slugs of the weapons the character has
-     *  chosen mastery of, unioned across every class/level `weapon-mastery` pick
-     *  (e.g. "srd-2024_greatsword" → "greatsword"). Empty when the character has no
-     *  such pick. Populated by the resolver's collectChosenWeaponMasteries pass. */
     weaponMasteries: string[];
+    pactWeapon?: string;
     state: CharacterState;
-    /** ART-a (spec §4.6, §5.4): the entry views, counters and flags `buildInfusionContext` derives after the resource
-     *  index. Absent (no cost) for a character with no item-bound pool and no marker; every fold reads it through
-     *  `resolveEntryEntity`. */
     infusions?: import("./pc.infusions.js").InfusionContext;
+    itemFeatures?: ResolvedFeature[];
 }
 export interface ProficiencySet {
     categories: string[];
@@ -592,12 +406,31 @@ export interface ACTerm {
     source: string;
     amount: number;
     kind: "armor" | "shield" | "item" | "unarmored" | "override" | "dex" | "ability" | "feature";
-    /** Situational qualifier carried verbatim from the granting `ac-bonus` effect's `condition`
-     *  (R4-G3a §3.2.5), e.g. "While wearing heavy armor". Absent = unconditional. Rendered as the
-     *  AC-tooltip row's `title`; NEVER evaluated. */
     condition?: string;
 }
-/** Structured max-HP math for the Max HP modal. Spec: P5 2026-07-21. */
+export type SpeedMode = "walk" | "fly" | "swim" | "climb" | "burrow";
+export interface SpeedTerm {
+    source: string;
+    amount: number;
+    condition?: string;
+}
+export interface SpeedLine {
+    mode: SpeedMode;
+    value: number;
+    equalsWalk?: true;
+    hover?: true;
+    terms: SpeedTerm[];
+}
+export interface ItemSpeedTerm {
+    mode: SpeedMode;
+    kind: "bonus" | "grant" | "walk";
+    source: string;
+    amount: number;
+}
+export interface DefenseItemSource {
+    index: number;
+    name: string;
+}
 export interface HPBreakdown {
     diceSum: number;
     diceSource: "rolled" | "average";
@@ -618,82 +451,45 @@ export interface HPBreakdown {
     override: number | null;
     final: number;
 }
-/** An additive on-hit damage rider (dice or flat) applied to an attack, from a
- *  feature (global — all weapon attacks) or a magic item (that weapon only).
- *  `amount` is a dice/flat string ("2d6", "1d8", "2"); `damage_type` optional
- *  (a bare manual override string carries its type inline, and the schema's
- *  `chosen` sentinel is kept, never replaced by the row's type, RIDER-13); `source`
- *  is a human label for the expand/tooltip. `condition` is the source's own
- *  qualifier ("for a 1st-level spell slot"), CARRIED verbatim and never evaluated,
- *  from a feature effect (R4-G7 T8 RIDER-12) and from an item's `damage_riders`
- *  entry alike; absent when the source authors none. `scope` is a feature effect's
- *  structured weapon scope (its `applies_to` words, ART-c1 Task 9b): the merge in
- *  `pc.recalc.ts` keeps the rider only on the rows it reaches (`riderReachesRow`);
- *  absent = every row. How the sheet prints a rider (always inside the DAMAGE cell,
- *  controller ruling 8) is the plugin renderer's policy, stated once at
- *  `weapons-table.ts` `renderWeaponRow`. */
 export interface DamageRider {
     amount: string;
     damage_type?: string;
     source?: string;
     condition?: string;
     scope?: WeaponScope[];
-    /** D2b-A: the source of the feature the rider comes from, so its amount resolves against the OWNING class's level
-     *  and spellcasting modifier (a multiclass character's Guided Precision reads the Artificer's INT). Set by
-     *  `computeFeatureEffects`; consumed and DROPPED by recalc's rider resolution (an attack row never carries it). */
     owner?: FeatureSource;
 }
-/** The spells a feature's spell-scoped damage rider reaches, as the member's DATA names them (`memberSpellTargets`):
- *  `refs` are the answers of its target picks (`target: true`, Agonizing Blast's cantrip) and its `spell-known`
- *  prerequisites (the 2014 invocation's Eldritch Blast); `open` holds the filter of each target pick left unanswered,
- *  which reaches a spell only when the character has exactly one legal answer (`spellsReached`). */
+export interface ConditionalCrit {
+    minRoll: number;
+    condition: string;
+    source: string;
+}
 export interface SpellTargets {
     refs: string[];
     open: EntityFilter[];
 }
-/** A `damage-bonus` effect with `applies_to: spell` (Agonizing Blast's "your Charisma modifier") or `all` (Hexblade's
- *  Curse). The fold carries the authored amount with its `owner`, `targets` and `scope`; recalc resolves the amount against
- *  the owning class, reads the targets and the scope against the character's spells into `spells` and drops `owner`,
- *  `targets` and `scope`, keeping only riders that reach a spell. `damage_type` survives only when it is a canonical type
- *  (a `chosen` or prose type is the spell's own). How the sheet prints it is `addSpellDamageRiders` (inside the roll: an
- *  unconditional rider of the spell's own type) and `spellDamageRiderLines` (its own line: a `condition`, like a
- *  conditional weapon rider, or another damage type). */
 export interface SpellDamageRider {
     amount: string;
     damage_type?: string;
     source?: string;
     condition?: string;
-    /** The scope's `once`: the rider adds to one damage roll of the casting ("one damage roll of that spell"). */
     once?: boolean;
-    /** The slugs of the character's resolved spells this rider reaches (recalc). */
     spells?: string[];
-    /** Fold only: see {@link DamageRider.owner}. */
     owner?: FeatureSource;
-    /** Fold only: the feature's {@link SpellTargets} (a pool member's named spells). */
     targets?: SpellTargets;
-    /** Fold only: the effect's `spell_scope` ({} for an unscoped `applies_to: all`: every damaging spell). Absent (and no
-     *  `targets`) reaches no spell. */
     scope?: SpellScope;
 }
 export interface AttackRow {
     id: string;
     name: string;
     range?: string;
-    /** Secondary thrown-mode range ("20/60 ft.") for a throwable melee weapon.
-     *  Display-only; rendered as a stacked muted second line in the Range cell.
-     *  Absent otherwise. */
     thrownRange?: string;
     toHit: number;
     damageDice: string;
     damageType: string;
-    /** Accumulated additive on-hit damage riders (feature-global + item-local +
-     *  the migrated manual override), rendered as extra damage chips. Absent when
-     *  none apply (so untouched rows are unchanged). */
     damageRiders?: DamageRider[];
-    /** The weapon's CATEGORY as the attack modes read it (`classifyWeaponRange`): `melee` for a weapon with a melee
-     *  mode (a thrown melee weapon stays melee), `ranged` for a pure ranged one. A rider's `melee` / `ranged` scope
-     *  reads it (ART-c1 Task 9b). Absent on the unarmed row. */
     weaponCategory?: "melee" | "ranged";
+    attacksPerAction?: number;
     properties: string[];
     proficient: boolean;
     breakdown: {
@@ -701,45 +497,16 @@ export interface AttackRow {
         damage: ACTerm[];
     };
     informational?: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
-    /** Hand slot the attack came from. Absent on an equipped weapon that holds no hand slot (H234 H5: both hands full, an
-     *  explicit-slot conflict loser, a non-hand slot) and on the unarmed row. The Actions tab finds the originating
-     *  equipment entry by the index in the row's `id` (`<index>:standard`), never by this field. */
     slotKey?: "mainhand" | "offhand";
-    /** Short caption under the weapon name in the Actions tab table.
-     *  e.g. "martial · versatile". Display-only. */
     subLabel?: string;
-    /** Action-economy cost for the Cost badge. Defaults to "action" at
-     *  render time when absent. Settable via entry.overrides.action. */
     actionCost?: "action" | "bonus-action" | "reaction" | "free" | "special";
-    /** The engine's always-present unarmed row (R4-G6b §5): never an equipment entry, never `equipped`, no `slotKey`.
-     *  The weapons table gates its expand on this flag BEFORE the equipment lookup. Absent on every weapon row. */
     unarmed?: true;
-    /** When set, the weapon is being wielded one-handed but has a versatile
-     *  two-handed option. The Actions tab renders both lines stacked in the
-     *  damage cell instead of emitting a second row. */
     versatile?: {
         damageDice: string;
     };
-    /** Lowest natural-roll threshold that scores a critical hit on this attack,
-     *  from `crit-range` feature effects (e.g. 19 = "crit on 19–20"). Display-only
-     *  metadata mapped on in recalc; absent (undefined) for the normal 20-only
-     *  crit so untouched attack rows are unchanged. The weapons table renders a
-     *  "crit X–20" caption whenever it is set and < 20. */
     critRange?: number;
-    /** Order-preserving display-only captions from `reroll-damage` / `attack-rule`
-     *  feature effects (e.g. ["Reroll 2s", "No disadvantage firing in melee"]).
-     *  Mapped on in recalc; absent (undefined) when no such effect is present so
-     *  untouched attack rows are unchanged. The weapons table renders these joined
-     *  with " · " as a muted caption under the weapon name. */
+    conditionalCrits?: ConditionalCrit[];
     attackNotes?: string[];
-    /** 2024 Weapon Mastery for this attack, present only when the character has
-     *  chosen mastery of this weapon AND is proficient with it AND the weapon
-     *  declares a mastery property. `slug`/`label`/`description`/`gist` come from
-     *  the mastery glossary (`gist` = a one-line effect summary for the Actions-tab
-     *  mastery column, e.g. "on fail: Prone"); `derived` carries the computed
-     *  number for the two numeric masteries (topple → Save DC, graze → On-miss
-     *  damage) and is absent for the rest. Additive + display-only, absent
-     *  (undefined) on untouched rows so nothing else changes. */
     mastery?: {
         slug: string;
         label: string;
@@ -750,13 +517,13 @@ export interface AttackRow {
             value: number;
         };
     };
+    grantedBy?: string;
+    pactWeapon?: true;
 }
 export interface AppliedBonuses {
     ability_bonuses: Partial<Record<Ability, number>>;
     ability_statics: Partial<Record<Ability, number>>;
     save_bonus: number;
-    /** SL (spec §11.3): `save_bonus` term by term, one per item, each named by the entry's display name (`overrides.name`, else
-     *  the item's). The saves breakdown lists these, never a lumped "Equipment" term. */
     save_terms: {
         source: string;
         amount: number;
@@ -767,13 +534,19 @@ export interface AppliedBonuses {
         swim: number;
         climb: number;
     };
+    speed_walk_set: number;
+    speed_walk_set_terms: {
+        source: string;
+        amount: number;
+    }[];
+    speed_terms: ItemSpeedTerm[];
     spell_attack: number;
     spell_save_dc: number;
     defenses: {
-        resistances: string[];
-        immunities: string[];
-        vulnerabilities: string[];
-        condition_immunities: string[];
+        resistances: DefenseGrant[];
+        immunities: DefenseGrant[];
+        vulnerabilities: DefenseGrant[];
+        condition_immunities: DefenseGrant[];
     };
     informational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
     senses: Record<import("@archivist-gg/dnd5e/types/feature-effect").SenseType, number>;
@@ -788,13 +561,6 @@ export interface DerivedEquipment {
     attunementUsed: number;
     attunementLimit: number;
 }
-/**
- * A structured advantage/disadvantage entry surfaced from a `roll-modifier`
- * feature effect. Order-preserving pass-through list on DerivedStats (no
- * dedupe/merge) — each entry carries the owning feature's name as `label`
- * for tooltips. `scope` absent = applies to all rolls of that `roll` type;
- * `condition` absent = always-on (not situational).
- */
 export interface RollModifierEntry {
     mode: "advantage" | "disadvantage" | "reroll" | "add-d4";
     roll: "ability-check" | "saving-throw" | "attack";
@@ -802,28 +568,9 @@ export interface RollModifierEntry {
     condition?: string;
     label: string;
 }
-/**
- * The two members' aliases, extracted from the entry's inline unions (R4-G3a §5.2). They are
- * declared HERE and nowhere else: `pc/roll-tag-labels.ts`'s `Record<RollModifierMode, string>`
- * tables and `pc/roll-scope.ts` import them, so widening the entry above is a COMPILE error in
- * every label table that has not been extended (§14 row 8i).
- */
 export type RollModifierMode = RollModifierEntry["mode"];
 export type RollKind = RollModifierEntry["roll"];
-/** The closed `save-outcome` result vocabulary, extracted the same way (R4-G3a §5.3): how much
- *  of the effect still lands. `pc/roll-tag-labels.ts` types its OUTCOME glyph table
- *  `Record<SaveOutcome, string>`, so the union is spelled ONCE and a widened member is a compile
- *  error in the table rather than a silent missing glyph. */
 export type SaveOutcome = SaveOutcomeEntry["on_success"];
-/**
- * A `save-outcome` effect as it leaves the fold (R4-G3a §5.3) · Evasion and its shape-mates
- * ("on a failed save you take half damage, on a success none").
- *
- * `ability` ABSENT means every save, which is the save chip's existing "absent scope = every
- * chip" idiom: the effect schema's `ability: "any"` maps to `undefined` at the fold rather than
- * duplicating the entry six times. `appliesTo` is the effect's `applies_to` prose ("a spell"),
- * carried for the tooltip only; `condition` is the situational qualifier, never evaluated.
- */
 export interface SaveOutcomeEntry {
     ability?: Ability;
     on_success: "none" | "half" | "full";
@@ -832,47 +579,20 @@ export interface SaveOutcomeEntry {
     condition?: string;
     label: string;
 }
-/** Where a defense came from. Ordered weakest to strongest for the precedence rule in recalc. */
 export type DefenseOrigin = "manual" | "equipment" | "grant";
-/**
- * One defense a feature effect grants, as it leaves the fold (R4-G3a §3.2.1).
- *
- * The four defense totals on FeatureEffectTotals are lists of these. `value` is the AUTHORED
- * spelling, trimmed and never slugified · `toDefenseSlug` runs later, in pc.recalc.ts, which is
- * why the fold's dedupe is a case-insensitive comparison rather than a slug lookup. `sources`
- * holds the granting FEATURE NAMES, merged per value at the fold (two features granting the same
- * immunity yield ONE grant with TWO sources · dropping the second would lose it before
- * composeDefenseEntries ever saw it). `condition` is the first qualifier seen for that value,
- * carried verbatim and NEVER evaluated.
- */
 export interface DefenseGrant {
     value: string;
     sources: string[];
     condition?: string;
+    items?: DefenseItemSource[];
 }
-/**
- * One entry in a derived defense bucket.
- *
- * `value` is ALWAYS `toDefenseSlug(raw)` · it is what every comparison keys on.
- * `label` is the first-spelling-wins display string, which is what preserves an authored "Psychic".
- * `origin` is the STRONGEST contributing source, not the first list to supply it.
- *
- * `sources` is GRANT-ORIGIN attribution only (R4-G3a §3.2.3): the names of the features whose
- * effects granted this value, copied from the DefenseGrant. EQUIPMENT-origin attribution (the
- * `pc.equipment.ts` half of R4-P5 §10.1 · archivist-obsidian/docs/superpowers/specs/
- * 2026-08-05-r4-p5-defenses-design.md, the spec lives in the PLUGIN repo, not this one) stays
- * DEFERRED, so an equipment-only entry carries no `sources` at all and the plugin's chip host
- * must guard on emptiness rather than on origin alone.
- *
- * `condition` is the situational qualifier from the granting effect, carried verbatim for the
- * chip tooltip and NEVER evaluated. Both fields are optional: a manual entry has neither.
- */
 export interface DefenseEntry {
     value: string;
     label: string;
     origin: DefenseOrigin;
     condition?: string;
     sources?: string[];
+    items?: DefenseItemSource[];
 }
 export interface DerivedStats {
     totalLevel: number;
@@ -894,16 +614,11 @@ export interface DerivedStats {
         bonus: number;
         proficiency: "none" | "proficient" | "expertise";
         ability: Ability;
-        /** The winning half-proficiency term (Jack of All Trades, Remarkable Athlete) on a skill whose tri is `none`;
-         *  absent otherwise. Additive: the tri never gains a half value, it is also the `overrides.skills.*.proficiency`
-         *  enum. Set under an `overrides.skills.<s>.bonus` too (the marker states the rule, the bonus is the number).
-         *  `source` is the owning feature's name. */
         halfProficiency?: {
             source: string;
             amount: number;
         };
     }>;
-    /** Numeric terms behind the sheet's skill, save, speed and initiative hovers. */
     statBreakdowns?: {
         skills: Partial<Record<SkillSlug, {
             source: string;
@@ -927,7 +642,6 @@ export interface DerivedStats {
         investigation: number;
         insight: number;
     };
-    /** Computed senses: max of race vision and feature-effect sense ranges. 0 = none per type. */
     senses: Record<import("@archivist-gg/dnd5e/types/feature-effect").SenseType, number>;
     hp: {
         max: number;
@@ -936,6 +650,7 @@ export interface DerivedStats {
     };
     ac: number;
     speed: number;
+    speeds?: SpeedLine[];
     initiative: number;
     spellcasting: {
         ability: Ability;
@@ -943,26 +658,16 @@ export interface DerivedStats {
         attackBonus: number;
         preparedCount?: number;
     } | null;
-    /** One entry per casting class (multiclass-aware). Empty for non-casters. */
     spellcastingClasses: SpellcastingClassInfo[];
-    /** Save DC / attack bonus for spells that carry their OWN spellcasting
-     *  ability rather than a class (feat-granted spells, e.g. Magic Initiate).
-     *  Keyed by that ability; populated for every ability a feat spell uses.
-     *  Computed independently of class casters, so a NON-caster (empty
-     *  spellcastingClasses / null spellcasting) still gets a real DC/attack.
-     *  Empty object when the character has no such spell. */
     abilitySpellcasting: Partial<Record<Ability, {
         saveDC: number;
         attackBonus: number;
     }>>;
-    /** Derived standard slot totals by spell level (before user override). */
     derivedSpellSlots: Record<number, number>;
-    /** Warlock Pact Magic, or null. */
     pactMagic: {
         level: number;
         total: number;
     } | null;
-    /** Per-class known/prepared + cantrip limits (advisory). */
     spellLimits: SpellLimitInfo[];
     warnings: string[];
     defenses: {
@@ -974,35 +679,18 @@ export interface DerivedStats {
     acBreakdown: ACTerm[];
     hpBreakdown: HPBreakdown;
     acInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
-    /** Situational saving-throw bonuses (e.g. +1 vs spells) for save tooltips. */
     savesInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
-    /** Situational spell attack / save-DC bonuses for spellcasting tooltips. */
     spellcastingInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
-    /** Situational speed bonuses (e.g. swim while underwater) for speed tooltips. */
     speedInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
-    /**
-     * Attacks per Attack action = 1 + max `extra-attack` effect count. Always ≥ 1
-     * (everyone gets one attack). The Actions "Attacks" heading shows `(×N)` when > 1.
-     */
     attacksPerAction: number;
     attacks: AttackRow[];
-    /** Spell-scoped damage riders that reach at least one of the character's spells, amounts resolved (Agonizing Blast's
-     *  "3" on Eldritch Blast). Absent when none does. The Spells tab adds them into the spell's roll. */
     spellDamageRiders?: SpellDamageRider[];
     equippedSlots: EquippedSlots;
     carriedWeight: number;
     attunementUsed: number;
     attunementLimit: number;
     conditionEffects: ConditionEffects;
-    /**
-     * Structured `roll-modifier` entries: four `mode` members since R4-G3a §6, not only advantage/disadvantage.
-     * Order-preserving pass-through (no dedupe/merge); rendered as ADV/DIS/RR/+D4 chips.
-     */
     rollModifiers: RollModifierEntry[];
-    /**
-     * `save-outcome` entries (R4-G3a §5.3). Order-preserving pass-through; rendered as an outcome
-     * tag ("0/½") on the matching save chip, or on every save chip when `ability` is absent.
-     */
     saveOutcomes: SaveOutcomeEntry[];
 }
 export interface SpellcastingClassInfo {
@@ -1012,11 +700,8 @@ export interface SpellcastingClassInfo {
     defaultAbility: Ability;
     saveDC: number;
     attackBonus: number;
-    /** The shared caster-type vocabulary; see schemas/caster-type-schema.ts (never spell the members out again). */
     casterType: CasterType;
     preparation: "known" | "prepared";
-    /** The profile's `spellList` (null when neither block names one), so the add drawer can call the same
-     *  `attributeUnclassedSpell` the resolver does. recalc always sets it; optional so hand-built rows read as unobservable. */
     spellList?: string | null;
 }
 export interface SpellLimitInfo {