@archivist-gg/dnd5e 0.3.13 → 0.3.19

package/dist/pc/pc.schema.d.ts

@@ -90,6 +90,14 @@ export declare const characterOverridesShape: z.ZodObject<{
             proficient: "proficient";
         }>>>;
     }, z.core.$strip>>;
+    weapons: z.ZodOptional<z.ZodObject<{
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    armor: z.ZodOptional<z.ZodObject<{
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
     defenses: z.ZodOptional<z.ZodObject<{
         resistances: z.ZodOptional<z.ZodObject<{
             remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -381,6 +389,14 @@ export declare const characterSchema: z.ZodObject<{
                 proficient: "proficient";
             }>>>;
         }, z.core.$strip>>;
+        weapons: z.ZodOptional<z.ZodObject<{
+            add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        armor: z.ZodOptional<z.ZodObject<{
+            add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
         defenses: z.ZodOptional<z.ZodObject<{
             resistances: z.ZodOptional<z.ZodObject<{
                 remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -411,6 +427,36 @@ export declare const characterSchema: z.ZodObject<{
         vulnerabilities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
         condition_immunities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>;
+    sheet: z.ZodOptional<z.ZodObject<{
+        layout: z.ZodOptional<z.ZodObject<{
+            saves: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                section: "section";
+            }>>>;
+            body: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                wide: "wide";
+            }>>>;
+        }, z.core.$strip>>;
+        favorites: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        filters: z.ZodOptional<z.ZodObject<{
+            actions: z.ZodOptional<z.ZodObject<{
+                show: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            passive: z.ZodOptional<z.ZodObject<{
+                show: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        pools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            show: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                known: "known";
+                granted: "granted";
+                "not-known": "not-known";
+            }>>>;
+            off: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+            folded: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
     state: z.ZodObject<{
         hp: z.ZodObject<{
             current: z.ZodNumber;
@@ -432,19 +478,19 @@ export declare const characterSchema: z.ZodObject<{
         }, z.core.$strip>>;
         concentration: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         conditions: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            incapacitated: "incapacitated";
+            unconscious: "unconscious";
             poisoned: "poisoned";
             grappled: "grappled";
             paralyzed: "paralyzed";
             petrified: "petrified";
             prone: "prone";
             restrained: "restrained";
-            unconscious: "unconscious";
             charmed: "charmed";
             frightened: "frightened";
             blinded: "blinded";
             deafened: "deafened";
             stunned: "stunned";
-            incapacitated: "incapacitated";
             invisible: "invisible";
         }>>>;
         exhaustion: z.ZodDefault<z.ZodNumber>;

package/dist/pc/pc.schema.js

@@ -1,7 +1,7 @@
 import {
   characterOverridesShape,
   characterSchema
-} from "../chunk-UE6LKRXQ.js";
+} from "../chunk-NTU2DXNG.js";
 import "../chunk-S7REMWW4.js";
 export {
   characterOverridesShape,

package/dist/pc/pc.spell-scope.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A spell damage rider's `spell_scope` read against the character's spells (found 2026-09-29: Potent Spellcasting,
+ * Empowered Evocation, Elemental Affinity, Radiant Soul and the Artificer riders said which spells they reach only in
+ * prose, so they reached none). Data, not per-feature code: every word of the scope is one test on the spell entity.
+ */
+import type { SpellScope } from "../types/feature-effect.js";
+import type { Spell } from "../spell/spell.types.js";
+import type { ResolvedCharacter, ResolvedSpell } from "./pc.types.js";
+/** Does `spell` deal damage? Its data names at least one damage type. */
+export declare function dealsDamage(spell: Pick<Spell, "damage">): boolean;
+/**
+ * The slugs of the character's `spells` a rider with `scope` reaches, unique, in `spells` order: every spell that DEALS
+ * DAMAGE and matches every word the scope carries (see `SpellScope`). `pickedTypes` answers `damage_type_pick` (the
+ * types the character's pick names; none reaches no spell). No scope reaches none; an empty scope every damaging spell.
+ */
+export declare function spellsInScope(scope: SpellScope | undefined, spells: ReadonlyArray<Pick<ResolvedSpell, "slug" | "entity">>, pickedTypes: (choiceId: string) => string[]): string[];
+/**
+ * The damage types the character chose at the `select-inline` `choiceId` of one of its class or subclass features (the
+ * 2014 Dragon Ancestor's "Red (Fire)", the 2024 Elemental Affinity's "fire"): the canonical types its answer's option
+ * names, in its value or its label. Empty when no feature offers that choice or it is unanswered.
+ */
+export declare function pickedDamageTypes(resolved: Pick<ResolvedCharacter, "classes">, choiceId: string): string[];

package/dist/pc/pc.tool-picks.js

@@ -5,9 +5,9 @@ import {
   classToolPicks,
   expandToolPool,
   toolCategoriesOf
-} from "../chunk-H5PTKYXL.js";
+} from "../chunk-QA3YCOML.js";
 import "../chunk-KU3YLF6D.js";
-import "../chunk-RLGQ5PZZ.js";
+import "../chunk-5JXFJ5AU.js";
 export {
   TOOL_CATEGORIES,
   backgroundToolPicks,

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

@@ -1,7 +1,7 @@
-import type { Ability } from "../types/choice.js";
+import type { Ability, EntityFilter } from "../types/choice.js";
 import type { ArmorEntity } from "../armor/armor.types.js";
 import type { WeaponEntity } from "../weapon/weapon.types.js";
-import type { WeaponScope } from "../types/feature-effect.js";
+import type { SpellScope, WeaponScope } from "../types/feature-effect.js";
 import type { ItemEntity } from "../item/item.types.js";
 import type { SkillSlug, Feature, Choice } from "@archivist-gg/dnd5e";
 import type { ClassEntity } from "@archivist-gg/dnd5e/class/class.types";
@@ -125,8 +125,8 @@ 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. */
+ *  `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>>;
@@ -181,6 +181,18 @@ 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[];
+    };
+    armor?: {
+        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.*`,
@@ -251,6 +263,30 @@ export interface CharacterState {
     /** @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";
+    };
+    favorites?: string[];
+    filters?: {
+        actions?: SheetViewFilter;
+        passive?: SheetViewFilter;
+    };
+    pools?: Record<string, SheetPoolView>;
+}
 export interface Character {
     name: string;
     edition: Edition;
@@ -309,6 +345,7 @@ export interface Character {
         vulnerabilities?: string[];
         condition_immunities?: string[];
     };
+    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
@@ -321,6 +358,20 @@ 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;
+    classSlug: string;
+    level: number;
 };
 export type FeatureSource = {
     kind: "class";
@@ -362,6 +413,10 @@ 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;
+    /** 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
@@ -408,6 +463,9 @@ export interface ResolvedSpell {
     /** 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;
 }
 export interface ResolvedClass {
     entity: ClassEntity | null;
@@ -463,8 +521,9 @@ export interface ResolvedPool {
      *  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). */
+    /** 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;
@@ -579,6 +638,42 @@ export interface DamageRider {
     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 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;
@@ -660,6 +755,12 @@ 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;
+    }[];
     speed_bonuses: {
         walk: number;
         fly: number | "walk" | null;
@@ -885,6 +986,9 @@ export interface DerivedStats {
      */
     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;

package/dist/pc/pc.weapon-grant.d.ts

@@ -0,0 +1,15 @@
+import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
+export interface QualifiedWeaponGrant {
+    category: "simple" | "martial";
+    /** Absent: melee and ranged alike. */
+    range?: "melee" | "ranged";
+    /** Weapon property keys as the weapon notes carry them (`two_handed`, `finesse`). */
+    properties: string[];
+    /** true: the weapon has NONE of `properties` ("that don't have"); false: it has ANY of them ("that have"). */
+    without: boolean;
+}
+/** The grant a phrase states, or null when it is not a property-qualified category phrase (a weapon name, "simple"). */
+export declare function parseQualifiedWeaponGrant(text: string): QualifiedWeaponGrant | null;
+/** Does the qualified grant `text` cover `weapon`? False for any text that is not such a grant. Melee / ranged is the attack
+ *  mode the classifier reconstructs, not the category suffix (a thrown melee weapon may be filed `*-ranged`). */
+export declare function qualifiedGrantCovers(text: string, weapon: Pick<WeaponEntity, "category" | "properties" | "range" | "slug">): boolean;

package/dist/pc/pool-layout.d.ts

@@ -17,19 +17,13 @@ export declare const RENDERING_HINT_LAYOUT: Readonly<Record<string, PoolLayout>>
  *  function as the layout, and one junk member beside genuine `dice-pool` members collapsed a
  *  correct majority into a phantom tie. */
 export declare function derivePoolLayout(entries: ReadonlyArray<ResolvedPoolEntry>): PoolLayout | undefined;
-/** ART-D (spec §7.2): the rows every pool tab draws unless its declaration authors `spell-like`. Applied AT READ by
- *  {@link poolPresentation}, never as a zod `.default()`, so a parsed note gains no key (the importer's round trip). */
-export declare const DEFAULT_POOL_ROWS: "blocks";
 export type PoolHead = "dice" | "points";
-export type PoolRows = "blocks" | "spell-like";
 export interface PoolPresentation {
     head: PoolHead;
-    rows: PoolRows;
 }
-/** ART-D (spec §7.2, Gate 1 C1): a pool tab's two data axes.
- *  - HEAD: an authored `dice-pool` / `point-pool` wins; otherwise the DERIVED layout decides (points for `point-pool`,
- *    dice for anything else).
- *  - ROWS: `spell-like` only when the declaration AUTHORS it; otherwise {@link DEFAULT_POOL_ROWS}. */
+/** A pool tab's ONE data axis (PT spec §9; ART-D's rows axis is retired: every pool tab draws the table).
+ *  HEAD: an authored `dice-pool` / `point-pool` wins; otherwise the DERIVED layout decides (points for `point-pool`,
+ *  dice for anything else). An authored `blocks` or `spell-like` still parses and is ignored. */
 export declare function poolPresentation(authored?: PoolLayout, derived?: PoolLayout): PoolPresentation;
 /** The ONE `rendering_hint` to `EntryAffordance` table (R4-G5 §4.2.1, invariant 3): the PER-ENTRY sibling of
  *  `RENDERING_HINT_LAYOUT`. `granted-die-to-ally` is its only key, and the four documents carrying it

package/dist/pc/pool-layout.js

@@ -1,16 +1,14 @@
 import {
   AFFORDANCE_CAPTIONS,
-  DEFAULT_POOL_ROWS,
   RENDERING_HINT_AFFORDANCE,
   RENDERING_HINT_LAYOUT,
   deriveEntryAffordance,
   derivePoolLayout,
   formatAffordanceCaption,
   poolPresentation
-} from "../chunk-HJQNK3J5.js";
+} from "../chunk-B3DP42OM.js";
 export {
   AFFORDANCE_CAPTIONS,
-  DEFAULT_POOL_ROWS,
   RENDERING_HINT_AFFORDANCE,
   RENDERING_HINT_LAYOUT,
   deriveEntryAffordance,

package/dist/pc/resource-equivalents.d.ts

@@ -0,0 +1,44 @@
+import type { ResourceIndex } from "./pc.resources.js";
+import type { FeatureSource, ResolvedClass, ResolvedFeature } from "./pc.types.js";
+/**
+ * H3b (spec `2026-09-28-h3b-resource-equivalents-design.md` §2): DECLARED equivalent resource ids. Each group says "these
+ * ids name ONE resource": the books and the SRD data mint different ids for the same pool (edition twins such as
+ * `fighter:superiority-dice` / `fighter-2024:superiority-dice`, book drift such as `monk:ki` / `monk:focus-point`,
+ * singular / plural such as `sorcerer:sorcery-point(s)`). Nothing is ever derived from an id's shape: an id in no group
+ * has no equivalent. The order inside a group is the fallback preference ({@link payingResourceId} step 4).
+ *
+ * The groups were measured over the installed vault (every class paired with every subclass of the same class, census in
+ * `.superpowers/sdd/h3b-evidence/`) and each checked against its declaring notes. The bare `channel-divinity` is the SRD
+ * 2024 id of BOTH the Cleric and the Paladin, so it sits in both Channel Divinity groups. Equivalence is read as "shares a
+ * group with", never transitively: `cleric:` / `cleric-2024:` never answer for `paladin:` / `paladin-2024:`. The bare id
+ * does answer for both, so a paladin consumer whose own class owns no Channel Divinity pays from a bare id another class
+ * (an SRD 2024 Cleric) declares: the one Channel Divinity pool of the 2014 multiclass rule (review m1, H3b).
+ */
+export interface ResourceEquivalentGroup {
+    readonly name: string;
+    readonly ids: readonly string[];
+}
+export declare const RESOURCE_EQUIVALENTS: readonly ResourceEquivalentGroup[];
+/** Every id that shares a group with `id`, in declared order (group order, then the order inside the group), `id` itself
+ *  excluded, each once. Empty for an id in no group. */
+export declare function equivalentResourceIds(id: string, groups?: readonly ResourceEquivalentGroup[]): string[];
+/**
+ * THE rule (spec §3): which OWNED resource pays for a consumption naming `id`.
+ *   1. the candidates are `id`, then its declared equivalents in declared order, kept only when the character owns them;
+ *   2. none: `undefined` (the caller keeps the raw id: no control, never a spend from nothing);
+ *   3. the first candidate the consumer's OWN class entry declares (`owner`, its class or subclass) pays, so a class's
+ *      feature or pool member spends its class's pool even when a feat owns a twin id (TCE Metamagic Adept on a 2014
+ *      Sorcerer declares `sorcerer-2024:sorcery-point`);
+ *   4. else the first candidate: the named id itself when it is owned.
+ * Exactly one id per consumer, so a spend writes one `feature_uses` key.
+ */
+export declare function payingResourceId(id: string, index: ResourceIndex, owner?: ResolvedClass | null, groups?: readonly ResourceEquivalentGroup[]): string | undefined;
+/** The class entry a feature belongs to: a class feature's class, a subclass feature's class; none for a race,
+ *  background, feat or campaign feature. */
+export declare function classOfSource(source: FeatureSource, classes: readonly ResolvedClass[]): ResolvedClass | null;
+/**
+ * Spec §4: every resolved feature whose `consumes.resource` has a different payer becomes a COPY (wrapper, feature and
+ * consumes; only `resource` changes). The registry `Feature` is shared by every open sheet and is never written; a
+ * feature with no `consumes.resource`, one paid by the id it names, or one with no owned candidate keeps its identity.
+ */
+export declare function bindFeatureConsumers(features: ResolvedFeature[], index: ResourceIndex, classes: readonly ResolvedClass[]): ResolvedFeature[];

package/dist/pc/spell-source.js

@@ -1,12 +1,7 @@
-// src/pc/spell-source.ts
-var SPELL_SOURCE = {
-  class: { ownAbility: false, section: "spellbook", freeCastWhenNoSlot: false, showInPrepare: true, countsAsGranted: false },
-  feat: { ownAbility: true, section: "spellbook", freeCastWhenNoSlot: true, showInPrepare: true, countsAsGranted: true },
-  item: { ownAbility: false, section: "consumable", freeCastWhenNoSlot: false, showInPrepare: false, countsAsGranted: true },
-  race: { ownAbility: true, section: "spellbook", freeCastWhenNoSlot: true, showInPrepare: true, countsAsGranted: true },
-  domain: { ownAbility: false, section: "spellbook", freeCastWhenNoSlot: false, showInPrepare: true, countsAsGranted: false }
-};
-var spellSource = (s) => SPELL_SOURCE[s.source];
+import {
+  SPELL_SOURCE,
+  spellSource
+} from "../chunk-KR6JF3BF.js";
 export {
   SPELL_SOURCE,
   spellSource

package/dist/race/race.codec.js

@@ -1,14 +1,14 @@
 import {
   raceCodec
-} from "../chunk-MC5YJ4PB.js";
-import "../chunk-R2V5LN3I.js";
-import "../chunk-X7VZY4ON.js";
+} from "../chunk-BJGOSM76.js";
+import "../chunk-HY2SRSVM.js";
+import "../chunk-FJYBLXV7.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-FPGXFD2M.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   raceCodec

package/dist/race/race.parser.js

@@ -1,13 +1,13 @@
 import {
   parseRace
-} from "../chunk-R2V5LN3I.js";
-import "../chunk-X7VZY4ON.js";
+} from "../chunk-HY2SRSVM.js";
+import "../chunk-FJYBLXV7.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-FPGXFD2M.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseRace

package/dist/race/race.schema.js

@@ -1,12 +1,12 @@
 import {
   fixedAsiSchema,
   raceEntitySchema
-} from "../chunk-X7VZY4ON.js";
-import "../chunk-FPGXFD2M.js";
+} from "../chunk-FJYBLXV7.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   fixedAsiSchema,

package/dist/schemas/choice-schema.js

@@ -1,7 +1,7 @@
 import {
   choiceSchema
-} from "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+} from "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 export {
   choiceSchema
 };

package/dist/schemas/feature-effect-schema.d.ts

@@ -18,6 +18,31 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     minimum: z.ZodOptional<z.ZodNumber>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"save-bonus">;
+    ability: z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>;
+    minimum: z.ZodOptional<z.ZodNumber>;
+    saves: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>>;
+    inactive_while: z.ZodOptional<z.ZodEnum<{
+        incapacitated: "incapacitated";
+        unconscious: "unconscious";
+    }>>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"half-proficiency">;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -111,6 +136,15 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         finesse: "finesse";
         thrown: "thrown";
     }>>]>>;
+    spell_scope: z.ZodOptional<z.ZodObject<{
+        list: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodNumber>;
+        school: z.ZodOptional<z.ZodString>;
+        damage_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        damage_type_pick: z.ZodOptional<z.ZodString>;
+        spells: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        once: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{

package/dist/schemas/feature-effect-schema.js

@@ -1,6 +1,6 @@
 import {
   featureEffectSchema
-} from "../chunk-ZMJQUZQH.js";
+} from "../chunk-JXWNXIIZ.js";
 export {
   featureEffectSchema
 };

package/dist/schemas/feature-schema.js

@@ -1,11 +1,11 @@
 import {
   featureObjectSchema,
   featureSchema
-} from "../chunk-FPGXFD2M.js";
+} from "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 export {
   featureObjectSchema,
   featureSchema

package/dist/spell/spell.codec.js

@@ -1,7 +1,7 @@
 import {
   spellCodec
-} from "../chunk-MWCCGPG3.js";
-import "../chunk-XY6X2APM.js";
+} from "../chunk-OOSRUJBI.js";
+import "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {

package/dist/spell/spell.parser.d.ts

@@ -1,4 +1,4 @@
-import { Spell } from "./spell.types.js";
+import { Spell, SpellMaterial } from "./spell.types.js";
 import { ParseResult } from "@archivist-gg/core";
 /**
  * §3.3 · collapse the converter's structured `components` object to the corpus's own string form
@@ -13,6 +13,11 @@ import { ParseResult } from "@archivist-gg/core";
  * the unreachable-shape fallback (the schema has already accepted the value by the time we run).
  */
 export declare function normalizeSpellComponents(value: unknown): string;
+/**
+ * D2b-B · the structured material component the string form cannot carry: `components.m` when it is an OBJECT (`text` with an
+ * optional `cost` and `consume`), copied field by field; `undefined` for every other shape. Structural narrowing, as above.
+ */
+export declare function spellMaterialOf(value: unknown): SpellMaterial | undefined;
 /**
  * §3.3 · collapse the converter's structured `duration` array to the corpus's own lowercase string
  * form (`until dispelled`, `up to 1 hour`), leaving a string input byte-unchanged. Concentration is

package/dist/spell/spell.parser.js

@@ -2,13 +2,15 @@ import {
   mirrorSpellShapes,
   normalizeSpellComponents,
   normalizeSpellDuration,
-  parseSpell
-} from "../chunk-XY6X2APM.js";
+  parseSpell,
+  spellMaterialOf
+} from "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {
   mirrorSpellShapes,
   normalizeSpellComponents,
   normalizeSpellDuration,
-  parseSpell
+  parseSpell,
+  spellMaterialOf
 };