@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/pc/pc.slotting.js

@@ -6,9 +6,9 @@ import {
   isShieldArmor,
   isWeaponEntity,
   resolveEntityForEntry
-} from "../chunk-N6N74K6X.js";
-import "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
+} from "../chunk-UBBKSYBY.js";
+import "../chunk-WXWPK3LI.js";
+import "../chunk-6X4KUDMU.js";
 export {
   defaultSlotForType,
   effectiveArmor,

package/dist/pc/pc.spellcasting.d.ts

@@ -1,3 +1,4 @@
+import type { EntityRegistry } from "@archivist-gg/core";
 import type { Ability } from "@archivist-gg/dnd5e";
 import type { CharacterOverrides, KnownSpellEntry, ResolvedClass } from "./pc.types.js";
 import type { CasterType } from "@archivist-gg/dnd5e/class/class.types";
@@ -5,17 +6,19 @@ export interface SpellcastingProfile {
     ability: Ability;
     casterType: CasterType;
     preparation: "known" | "prepared";
-    spellList: string;
+    /** null when neither block names a list (the converter's EK/AT). Read by the known-spell attribution guard
+     *  (`attributeUnclassedSpell`, guard (i)) and carried to `SpellcastingClassInfo.spellList`. */
+    spellList: string | null;
     table: Record<number, {
         columns?: Record<string, string | number>;
     }>;
 }
 /**
- * Data-driven spellcasting profile for a resolved class. Reads the subclass
- * block if the subclass grants casting (e.g. Architect of Ruin), else the class
- * block. Known/cantrip columns come from whichever entity grants casting
- * (subclass table preferred, falling back to the class table). Returns null for
- * non-casters. No hardcoded class knowledge — everything comes from the data.
+ * Data-driven spellcasting profile for a resolved class, composed FIELD BY FIELD (R4-G1a D7): the caster type comes
+ * from the subclass block, else the class block, and without one the entity is not a caster (null: a subclass that
+ * only names a save ability grants no Spells tab). The table is the SUBCLASS table when the subclass block supplies
+ * the caster type, else the class table, else {}. Preparation is explicit, else inferred from a Prepared Spells /
+ * Spells Prepared column in the resolved table, else known. No hardcoded class knowledge.
  */
 export declare function resolveSpellcasting(rc: ResolvedClass): SpellcastingProfile | null;
 /** The ability a class actually casts with: a per-class override wins, else the
@@ -30,6 +33,44 @@ export interface NormalizedKnownSpell {
     alwaysPrepared: boolean;
 }
 export declare function normalizeKnownSpell(entry: KnownSpellEntry): NormalizedKnownSpell;
+/** One caster class as the attribution rule reads it: a class slug and its profile's `spellList` (null when none is named).
+ *  The slug is compared through `baseClassName` and also looks up the registered `class` document for its compendium, so it
+ *  must be a registered class slug: the resolver passes the class-ref slug its own lookup used, the add drawer the resolved
+ *  entity's `slug` (equal to the registered slug on every bundle and converter class document, and backfilled from it when a
+ *  custom body omits it). */
+export interface AttributionCaster {
+    classSlug: string;
+    spellList: string | null;
+}
+/** Every base class name a spell of ONE compendium lists in its `classes`, the compendium read off the registered spell
+ *  document (`RegisteredEntity.compendium`). ONE walk of the spell bucket per registry fills every compendium's set at once,
+ *  so each compendium is computed once; the walk repeats only when `registry.count()` changes (an entity registered under a
+ *  new slug, or one removed). The core registry exposes no change generation, version or event, so the count is the only
+ *  key. Known gap: re-registering an existing spell in place (same slug, same count; the plugin's `updateEntity` does this)
+ *  with a different `classes` list is not seen until the count next moves. A compendium with no spells gets the empty set. */
+export declare function listedSpellClassNames(registry: EntityRegistry, compendium: string): ReadonlySet<string>;
+/**
+ * R4-G7 T8 RIDER-19 (F-PACT) and its fix rounds 1 and 2 (review C-1): the caster class an UN-CLASSED known spell belongs to.
+ * The ONE rule, read by the resolver (an entry with no `class:`) and by the Spells tab's add drawer (the `class:` it writes).
+ * The spell stays with the FIRST caster class (class-entry order) unless the first caster's own list is OBSERVABLE and does
+ * not name the spell, in which case it goes to the first LATER caster whose base class name the spell's `classes` names.
+ * Observable means (i) the first caster's profile names a list (`spellList` non-null; the converter's Arcane Trickster and
+ * Eldritch Knight name none, and their spells say `wizard`, never `rogue` / `fighter`) AND (ii) its base class name is
+ * listed on at least one spell of the first class document's OWN compendium (`RegisteredEntity.compendium` of the registered
+ * `class` document and of each spell document): the SRD 5e bundle lists `paladin` on no spell (DATA-SRD) while a real vault
+ * also holds SRD 2024 and converted books that do, so only the class's own book can speak for its list. A class document the
+ * registry does not hold, or a compendium with no spells, is unobservable. So a single caster, a spell the first caster's list
+ * names (Detect Magic on a Paladin / Warlock), a spell no caster names, and every spell of an unobservable first caster
+ * resolve exactly as before RIDER-19; Armor of Agathys (`classes: [warlock]`) on a Player's Handbook Paladin-first Paladin /
+ * Warlock goes to the Warlock. Null only when there is no caster class.
+ * Consequences a move carries: the spell's DC / attack become the new class's, it follows that class's Pact Magic routing,
+ * and a plain entry (no prepared flag) moved from a `known` caster to a `prepared` one is not castable until prepared.
+ * Known limit: a list EXTENSION on an observable first caster (a 2014 Fiend Warlock's patron-granted Burning Hands, Bard
+ * Magical Secrets, Divine Soul) is not visible in the spell's base-list `classes`, so such a spell moves to a later caster
+ * that names it; an explicit `class:` is the override. The class lookup and the registry walk for (ii) run only when a move
+ * is in question.
+ */
+export declare function attributeUnclassedSpell(spellClasses: readonly unknown[] | undefined, casters: readonly AttributionCaster[], registry: EntityRegistry): string | null;
 export interface CasterClassInput {
     casterType: CasterType;
     level: number;
@@ -43,6 +84,16 @@ export interface DerivedSpellSlots {
         total: number;
     } | null;
 }
+type SlotCaster = Exclude<CasterType, "pact">;
+/** The single-class slot table for a progression. Exhaustive by construction: an unhandled member is a COMPILE
+ *  error at the `never` assignment (a bare switch statement would fall through silently). */
+export declare function slotTableFor(caster: SlotCaster): number[][];
+/**
+ * Standard spell slots plus Pact Magic for a character's casting classes. A SINGLE regular caster reads its own
+ * progression table through `slotTableFor` (the artificer row included: level-1 slots, then the half-caster rows).
+ * TWO OR MORE pool into a multiclass caster level, `full + floor(half/2) + floor(third/3) + ceil(artificer/2)` on
+ * the SUMS, read off FULL_CASTER_SLOTS. Warlock levels never join that pool: they produce a separate pact entry.
+ */
 export declare function deriveSpellSlots(classes: CasterClassInput[]): DerivedSpellSlots;
 export interface LimitClassInput {
     classSlug: string;
@@ -57,4 +108,22 @@ export interface SpellLimit {
     cantripsKnown: number | null;
     preparedOrKnown: number | null;
 }
+/** The converter spells the 2024 column two ways; the bundle uses the first. Serves the PREPARED branch of
+ *  `computeSpellLimits` and `resolveSpellcasting`'s preparation inference (`hasPreparedColumn`). The KNOWN branch
+ *  keeps its own candidates (the XPHB Sorcerer and Warlock are known casters whose count sits under
+ *  "Prepared Spells"). */
+export declare const PREPARED_COLUMNS: string[];
+/** The level term of the prepared-count FALLBACK (used only when no table column supplies the count). Slots round
+ *  the artificer progression UP; its prepared count rounds DOWN (TCE: "half your artificer level, rounded down").
+ *  `third` is a DELTA from the shipped `else` arm, which used the whole `level`: reachable in principle now that
+ *  `resolveSpellcasting` infers `prepared` for the XPHB Arcane Trickster, whose table supplies the count, so no
+ *  shipped number moves (spec D6c, §8). */
+export declare function preparedLevelTerm(caster: CasterType, level: number): number;
+/**
+ * Cantrip and prepared/known counts per casting class. The PREPARED count is TABLE-FIRST (R4-G1a D6c): a
+ * PREPARED_COLUMNS cell on the class table row wins outright, and only a row without one falls back to the formula
+ * `max(1, abilityMod + preparedLevelTerm(casterType, level))`. The KNOWN count is read from the table alone and is
+ * null when the row carries no candidate column.
+ */
 export declare function computeSpellLimits(inputs: LimitClassInput[]): SpellLimit[];
+export {};

package/dist/pc/pc.spellcasting.js

@@ -1,18 +1,28 @@
 import {
+  PREPARED_COLUMNS,
+  attributeUnclassedSpell,
   computeSpellLimits,
   deriveSpellSlots,
   effectiveSpellcastingAbility,
+  listedSpellClassNames,
   normalizeKnownSpell,
-  resolveSpellcasting
-} from "../chunk-6IRYTM5V.js";
-import "../chunk-5XUXXAQJ.js";
+  preparedLevelTerm,
+  resolveSpellcasting,
+  slotTableFor
+} from "../chunk-DPUJDOKV.js";
+import "../chunk-IUAAXXNO.js";
 import "../chunk-VTTA2ALZ.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
+  PREPARED_COLUMNS,
+  attributeUnclassedSpell,
   computeSpellLimits,
   deriveSpellSlots,
   effectiveSpellcastingAbility,
+  listedSpellClassNames,
   normalizeKnownSpell,
-  resolveSpellcasting
+  preparedLevelTerm,
+  resolveSpellcasting,
+  slotTableFor
 };

package/dist/pc/pc.table-column.d.ts

@@ -10,3 +10,26 @@ export declare function readTableColumn(table: Record<number, {
 export declare function numericColumnsAt(table: Record<number, {
     columns?: Record<string, string | number>;
 }> | undefined, level: number): Record<string, number>;
+/** Class-table COLUMN names per `select-entity` choice id (R4-G5 §6.2, invariant 3): the DATA route that makes a
+ *  levelled pick count GROW. MEASURED 2026-09-07 on both corpora: the Fighter 2024's `weapon-mastery` choice
+ *  authors `count: 3` at levels 1 / 4 / 10 / 16 while the class table's "Weapon Mastery" column reads
+ *  3 / 4 / 5 / 6 (byte-identical between the converter document and the SRD 2024 bundle record); the Barbarian
+ *  2024's column reads 2 / 3 / 4 against an authored 2; Paladin / Ranger / Rogue 2024 carry `count: 2` and NO
+ *  column, which is the correct RAW count. Read only INSIDE dnd5e (`buildDecisionLedger`). G7 handoff: the
+ *  converter emits `count.column` on the choice itself and this table retires. */
+export declare const COUNT_COLUMNS: Readonly<Record<string, string[]>>;
+/** The column keys for a choice id, by OWN-property lookup (`derivePoolLayout`'s precedent, invariant 3). The
+ *  guard is LOAD-BEARING, not defensive: `readTableColumn` above iterates its `keys` with `for ... of`, so a
+ *  plain index on a choice id of `constructor` hands it the Object constructor FUNCTION and THROWS while the
+ *  ledger is being built. Returns undefined for every id the table does not own. */
+export declare function countColumnsFor(choiceId: string): string[] | undefined;
+/** A DICE cell (`1d6`) of a (sub)class table column at `level`, or null when absent, non-string or not dice-shaped.
+ *  `readTableColumn` / `numericColumnsAt` parse INTEGERS and would read `1d6` as 1 (R4-G6b §5.3). Own-property
+ *  reads only: a key of `constructor` hands back the prototype's function otherwise. */
+export declare function diceColumnAt(table: Record<number, {
+    columns?: Record<string, string | number>;
+}> | undefined, level: number, key: string): string | null;
+/** The class-table COLUMN that scales an unarmed strike's die, per FEATURE id slug (R4-G6b §5.4's synthetic; the
+ *  `COUNT_COLUMNS` shape). Mirrors the G7 overlay entry this synthetic retires for SRD data; kept for homebrew. */
+export declare const UNARMED_DIE_COLUMNS: Readonly<Record<string, string>>;
+export declare function unarmedDieColumnFor(featureSlug: string): string | undefined;

package/dist/pc/pc.table-column.js

@@ -1,8 +1,18 @@
 import {
+  COUNT_COLUMNS,
+  UNARMED_DIE_COLUMNS,
+  countColumnsFor,
+  diceColumnAt,
   numericColumnsAt,
-  readTableColumn
-} from "../chunk-5XUXXAQJ.js";
+  readTableColumn,
+  unarmedDieColumnFor
+} from "../chunk-IUAAXXNO.js";
 export {
+  COUNT_COLUMNS,
+  UNARMED_DIE_COLUMNS,
+  countColumnsFor,
+  diceColumnAt,
   numericColumnsAt,
-  readTableColumn
+  readTableColumn,
+  unarmedDieColumnFor
 };

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

@@ -2,15 +2,18 @@ import type { Ability } from "../types/choice.js";
 import type { ArmorEntity } from "../armor/armor.types.js";
 import type { WeaponEntity } from "../weapon/weapon.types.js";
 import type { ItemEntity } from "../item/item.types.js";
-import type { SkillSlug, Feature } from "@archivist-gg/dnd5e";
+import type { SkillSlug, Feature, Choice } from "@archivist-gg/dnd5e";
 import type { ClassEntity } from "@archivist-gg/dnd5e/class/class.types";
+import type { CasterType } from "@archivist-gg/dnd5e/schemas/caster-type-schema";
 import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
 import type { SubclassEntity } from "@archivist-gg/dnd5e/subclass/subclass.types";
 import type { BackgroundEntity } from "@archivist-gg/dnd5e/background/background.types";
 import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
 import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
 import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
+import type { PoolLayout } 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. */
@@ -103,6 +106,11 @@ export interface KnownSpellObject {
 }
 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.setToolProficiency` and `ProficiencyEditModal` import it for the
+ *  tools tri (R4-G4 §9.3, UR1), so no consumer re-spells the union. */
+export type ProficiencyTri = "none" | "proficient" | "expertise";
 export interface CharacterOverrides {
     scores?: Partial<Record<Ability, number>>;
     saves?: Partial<Record<Ability, {
@@ -111,7 +119,7 @@ export interface CharacterOverrides {
     }>>;
     skills?: Partial<Record<SkillSlug, {
         bonus: number;
-        proficiency?: "none" | "proficient" | "expertise";
+        proficiency?: ProficiencyTri;
     }>>;
     passives?: Partial<{
         perception: number;
@@ -133,6 +141,50 @@ export interface CharacterOverrides {
     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[];
+    };
+    tools?: {
+        add?: string[];
+        remove?: string[];
+        proficiency?: Record<string, ProficiencyTri>;
+    };
+    /** 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[];
+        };
+        immunities?: {
+            remove?: string[];
+        };
+        vulnerabilities?: {
+            remove?: string[];
+        };
+        condition_immunities?: {
+            remove?: string[];
+        };
+    };
 }
 export interface CharacterState {
     hp: {
@@ -236,6 +288,17 @@ export interface Character {
     };
     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;
+    level: number;
+} | {
+    kind: "background";
+    slug: string;
+};
 export type FeatureSource = {
     kind: "class";
     slug: string;
@@ -253,6 +316,7 @@ export type FeatureSource = {
 } | {
     kind: "feat";
     slug: string;
+    via?: FeatVia;
 };
 export interface ResolvedFeature {
     feature: Feature;
@@ -270,6 +334,33 @@ export interface ResolvedFeature {
     renderSuppressed?: boolean;
     /** The feat's entire substance is a full ability-score improvement (a pure ASI). The DISPLAY layer hides these. */
     buildOnly?: boolean;
+    /** 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;
+        description?: string;
+        choices?: Choice[];
+    }[];
 }
 export interface ResolvedSpell {
     entity: Spell;
@@ -286,6 +377,9 @@ export interface ResolvedSpell {
     /** 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;
 }
 export interface ResolvedClass {
     entity: ClassEntity | null;
@@ -296,6 +390,15 @@ export interface ResolvedClass {
 export interface ResolvedPoolEntry {
     slug: string;
     entity: OptionalFeatureEntity;
+    /** The compendium NAME the REGISTERED entity carries (R4-G5 §9.2.1), stamped at resolve time because `entity`
+     *  is `e.data`, 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. */
@@ -311,6 +414,16 @@ export interface ResolvedPool {
     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 (majority of `consumes.resource` among the ids the
+     *  character owns); undefined when no member consumes an owned id (R4-G4 §4.2.3, Gate 0 B1). */
+    resource?: string;
 }
 export interface ResolvedCharacter {
     definition: Character;
@@ -318,10 +431,41 @@ 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
@@ -337,6 +481,10 @@ 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 interface HPBreakdown {
@@ -362,12 +510,19 @@ export interface HPBreakdown {
 /** 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); `source` is a human
- *  label for the expand/tooltip. Rendered as its own damage chip on the row. */
+ *  (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. How the sheet prints a rider
+ *  (a damage chip, or the row's caption) 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;
 }
 export interface AttackRow {
     id: string;
@@ -400,6 +555,9 @@ export interface AttackRow {
     /** 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. */
@@ -476,12 +634,84 @@ export interface DerivedEquipment {
  * `condition` absent = always-on (not situational).
  */
 export interface RollModifierEntry {
-    mode: "advantage" | "disadvantage";
+    mode: "advantage" | "disadvantage" | "reroll" | "add-d4";
     roll: "ability-check" | "saving-throw" | "attack";
     scope?: string;
     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";
+    on_failure: SaveOutcomeEntry["on_success"];
+    appliesTo?: string;
+    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;
+}
+/**
+ * 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[];
+}
 export interface DerivedStats {
     totalLevel: number;
     proficiencyBonus: number;
@@ -547,10 +777,10 @@ export interface DerivedStats {
     spellLimits: SpellLimitInfo[];
     warnings: string[];
     defenses: {
-        resistances: string[];
-        immunities: string[];
-        vulnerabilities: string[];
-        condition_immunities: string[];
+        resistances: DefenseEntry[];
+        immunities: DefenseEntry[];
+        vulnerabilities: DefenseEntry[];
+        condition_immunities: DefenseEntry[];
     };
     acBreakdown: ACTerm[];
     hpBreakdown: HPBreakdown;
@@ -573,10 +803,15 @@ export interface DerivedStats {
     attunementLimit: number;
     conditionEffects: ConditionEffects;
     /**
-     * Structured advantage/disadvantage entries from `roll-modifier` effects.
-     * Order-preserving pass-through (no dedupe/merge); rendered as ADV/DIS chips.
+     * 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 {
     classSlug: string;
@@ -585,8 +820,12 @@ export interface SpellcastingClassInfo {
     defaultAbility: Ability;
     saveDC: number;
     attackBonus: number;
-    casterType: "full" | "half" | "third" | "pact";
+    /** 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 {
     classSlug: string;