@archivist-gg/dnd5e 0.3.11 → 0.3.17

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

@@ -275,6 +275,20 @@ export declare const characterSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strict>>;
         granted_by: z.ZodOptional<z.ZodString>;
+        id: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        in: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        infusion: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                infused: "infused";
+                created: "created";
+            }>;
+            by: z.ZodString;
+            seq: z.ZodNumber;
+            choice: z.ZodOptional<z.ZodString>;
+            charges: z.ZodOptional<z.ZodObject<{
+                current: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     overrides: z.ZodDefault<z.ZodObject<{
         scores: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
@@ -397,6 +411,33 @@ 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";
+            }>>>;
+        }, 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;
@@ -418,19 +459,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-PZCE7DJM.js";
+} from "../chunk-T6QIF5XR.js";
 import "../chunk-S7REMWW4.js";
 export {
   characterOverridesShape,

package/dist/pc/pc.slotting.d.ts

@@ -2,7 +2,7 @@ import type { EntityRegistry } from "@archivist-gg/core";
 import type { ItemEntity } from "@archivist-gg/dnd5e/item/item.types";
 import type { ArmorEntity } from "@archivist-gg/dnd5e/armor/armor.types";
 import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
-import type { SlotKey } from "./pc.types.js";
+import type { EquipmentEntry, SlotKey } from "./pc.types.js";
 export declare function isItemEntity(e: unknown): e is ItemEntity;
 export declare function isWeaponEntity(e: unknown): e is WeaponEntity;
 export declare function isArmorEntity(e: unknown): e is ArmorEntity;
@@ -13,10 +13,43 @@ export declare function resolveEntityForEntry(item: string, registry: EntityRegi
     entity: ArmorEntity | WeaponEntity | ItemEntity | null;
     entityType: string | null;
 };
-/** Is this armor a shield? Robust to SRD-2024 data where the Shield entity
- *  carries `category: "heavy"` rather than `"shield"`. */
+/** Is this armor a shield? By category, slug or name: the SRD Shield is category "shield" (dnd5e 0.3.13), but
+ *  imported or hand-authored data (and the SRD bundle before 0.3.13) may carry category "heavy". */
 export declare function isShieldArmor(armor: ArmorEntity): boolean;
 /** The ArmorEntity whose `ac` block governs a slot: the entity itself when armor,
  *  or — for a magic item whose `base_item` points at armor — the resolved base. */
 export declare function effectiveArmor(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry: EntityRegistry): ArmorEntity | null;
+/** The WeaponEntity whose attack and two-handed rules govern a slot (H234 H2, spec §3.2): the entity itself when it is a
+ *  weapon, or, for a magic item whose `base_item` resolves to a weapon, that base. ONE hop, exactly like
+ *  {@link effectiveArmor}: a base that is itself an item is not followed (measured at Gate 0: 108 item-to-item bases, 0
+ *  cycles, 0 ending at a two-handed weapon; a later multi-hop needs a visited set). Null for armor, a wondrous item, an
+ *  unresolved slug, or a base that does not resolve to a weapon. */
+export declare function effectiveWeapon(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry: EntityRegistry): WeaponEntity | null;
+/** THE two-handed rule (H234 H2, spec §3.2), read by `computeAC`'s shield gate, the `wielding_two_handed` condition and
+ *  the plugin's equip conflicts:
+ *  1-2. an entity whose OWN `properties` is a non-empty list: that list decides, whatever its base (resolved, unresolved or
+ *       absent). The same precedence as the attack row, whose magic `propertiesOverride` replaces the base list, so the
+ *       Weapons table's property chips and the two-handed rules cannot disagree;
+ *  3.   an item with no own properties: its base weapon's, through {@link effectiveWeapon} (needs a registry);
+ *  4-6. anything else (no base, an unresolved or non-weapon base, no registry, null): not two-handed, as before.
+ *  A property entry may be a conditional object; the test is the literal "two_handed". */
+export declare function isTwoHandedWeapon(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry?: EntityRegistry | null): boolean;
+/** An armour's own Armor Class term: its `base` plus its `flat` (raw vault data omits `flat`, so it reads 0). ONE rule
+ *  for the armour and shield terms `computeAC` adds (pc.equipment.ts) and for the AC an entry shows
+ *  (`effectiveItemArmorClass`, pc.entry-overrides.ts), both read through {@link slotAcTerms}. */
+export declare function armorAcTerm(armor: ArmorEntity): number;
+/** The Armor Class ONE worn armour or shield entry adds by itself, as the two terms a breakdown lists apart: its armour's
+ *  own term ({@link armorAcTerm}; null when the entry resolves to no armour) and the entry's `overrides.ac_bonus` (0 when
+ *  absent, or not a number in raw vault data). ONE rule for `computeAC`'s armour and shield slots (pc.equipment.ts) and
+ *  the AC an entry shows (`effectiveItemArmorClass`, pc.entry-overrides.ts), which wrote "armour term + entry ac_bonus"
+ *  three times, held equal only by a test (T17, carried from rider EF's review). The item's own `bonuses.ac` is not a
+ *  slot term: the engine reads it attunement-gated and per condition, so it stays with each consumer. */
+export declare function slotAcTerms(armor: ArmorEntity, entry: EquipmentEntry | undefined): {
+    armor: number;
+    override: number;
+};
+export declare function slotAcTerms(armor: ArmorEntity | null, entry: EquipmentEntry | undefined): {
+    armor: number | null;
+    override: number;
+};
 export declare function defaultSlotForType(entityType: string | null, entity: ArmorEntity | WeaponEntity | ItemEntity | null, registry: EntityRegistry): SlotKey | null;

package/dist/pc/pc.slotting.js

@@ -1,20 +1,28 @@
 import {
+  armorAcTerm,
   defaultSlotForType,
   effectiveArmor,
+  effectiveWeapon,
   isArmorEntity,
   isItemEntity,
   isShieldArmor,
+  isTwoHandedWeapon,
   isWeaponEntity,
-  resolveEntityForEntry
-} from "../chunk-UBBKSYBY.js";
-import "../chunk-WXWPK3LI.js";
-import "../chunk-6X4KUDMU.js";
+  resolveEntityForEntry,
+  slotAcTerms
+} from "../chunk-LHZXYFBU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
 export {
+  armorAcTerm,
   defaultSlotForType,
   effectiveArmor,
+  effectiveWeapon,
   isArmorEntity,
   isItemEntity,
   isShieldArmor,
+  isTwoHandedWeapon,
   isWeaponEntity,
-  resolveEntityForEntry
+  resolveEntityForEntry,
+  slotAcTerms
 };

package/dist/pc/pc.tool-picks.d.ts

@@ -0,0 +1,51 @@
+import type { Choice } from "@archivist-gg/dnd5e/types/choice";
+/** The three tool CATEGORIES the rules name ("one type of Artisan's Tools", "a Musical Instrument", "a Gaming
+ *  Set"). The key is the category token the data writes. */
+export type ToolCategory = "musical-instrument" | "artisan's-tools" | "gaming-set";
+interface ToolCategoryDef {
+    /** The category's members in the ONE tool list (`types/choice.ts`), never a second copy. */
+    pool: readonly string[];
+    /** The item entity `type` its members carry (SRD 5e, SRD 2024, PHB 2024 and XGE item notes all write these). */
+    itemType: string;
+    /** The noun phrase a pick label reads ("Choose a musical instrument"). */
+    label: string;
+}
+export declare const TOOL_CATEGORIES: Readonly<Record<ToolCategory, ToolCategoryDef>>;
+/** A category token read as WORDS: camelCase split (`weaponSimple`), lower-cased, apostrophes dropped (ASCII,
+ *  U+2019 and U+02BC), any run of space, hyphen or underscore a separator, and each word singularised by ONE
+ *  trailing "s". So `artisan's-tools`, `Artisans Tools` and `artisan-tool` all read `["artisan", "tool"]`, and
+ *  `Musical Instruments` reads `["musical", "instrument"]`. Used for category tokens and item `type` values alike. */
+export declare function categoryWords(token: string): string[];
+/** The tool categories a token names: one (`gaming-set`), or several for an `X-or-Y` union
+ *  (`musical-instrument-or-artisan's-tools`, the PHB 2024 Monk's kit). `undefined` unless EVERY part of the token
+ *  is a tool category, so a slug (`dice-set`, `smith's-tools`) or a weapon class is never read as one. */
+export declare function toolCategoriesOf(token: string): ToolCategory[] | undefined;
+/** A tool pool with every category token expanded to its members, in authored order, deduplicated on the
+ *  canonical slug (first spelling wins). A plain tool slug passes through verbatim: the pick canonicalises it
+ *  downstream exactly as before. */
+export declare function expandToolPool(from: readonly string[]): string[];
+/** What a tool pick authored OUTSIDE `choices` becomes. A pick whose count covers its whole pool AND that names its
+ *  tools outright ({@link namesToolsOutright}) has no alternatives, so it is a GRANT (the importer writes the PHB 2024
+ *  Druid's Herbalism Kit, the Rogue's Thieves' Tools and the TCE/EFA Artificer's two granted tools this way); any
+ *  other pick is a `select-proficiency` decision over the expanded pool. */
+export interface ToolPicks {
+    decisions: Choice[];
+    grants: string[];
+}
+/** A CLASS's `proficiencies.tools.choice` (`{count, from}`, admitted by `ToolProficiency`, written by the importer
+ *  and by hand, e.g. the Captain Lugen Bard's three instruments). The decision is a level-1 class pick with id
+ *  `tool`, the id the SRD overlay gives the same pick in `choices`, so a later re-import into `choices` keeps a
+ *  persisted pick. An AUTHORED tool `select-proficiency` in the class's own `choices` wins: no second decision. */
+export declare function classToolPicks(entity: {
+    choices?: unknown;
+    proficiencies?: unknown;
+} | null | undefined): ToolPicks;
+/** A BACKGROUND's `tool_proficiencies` entries of `kind: "choice"` (`{count, from}`, admitted by
+ *  `BackgroundToolProficiency`; the PHB 2024, EFA and FRHoF imports carry a category token, e.g. `[gaming-set]`).
+ *  Ids `tool`, then `tool-2`, `tool-3`: `tool` is the SRD overlay's id for the Soldier's authored pick. An AUTHORED
+ *  tool `select-proficiency` in the background's `choices` wins, as on the class. */
+export declare function backgroundToolPicks(bg: {
+    choices?: unknown;
+    tool_proficiencies?: unknown;
+} | null | undefined): ToolPicks;
+export {};

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

@@ -0,0 +1,18 @@
+import {
+  TOOL_CATEGORIES,
+  backgroundToolPicks,
+  categoryWords,
+  classToolPicks,
+  expandToolPool,
+  toolCategoriesOf
+} from "../chunk-H5PTKYXL.js";
+import "../chunk-KU3YLF6D.js";
+import "../chunk-RLGQ5PZZ.js";
+export {
+  TOOL_CATEGORIES,
+  backgroundToolPicks,
+  categoryWords,
+  classToolPicks,
+  expandToolPool,
+  toolCategoriesOf
+};

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

@@ -1,6 +1,7 @@
 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 { 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";
@@ -11,7 +12,7 @@ import type { BackgroundEntity } from "@archivist-gg/dnd5e/background/background
 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 { 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
@@ -59,6 +60,16 @@ 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;
+    seq: number;
+    choice?: string;
+    charges?: {
+        current: number;
+    };
+}
 export type EquipmentEntry = {
     item: string;
     equipped?: boolean;
@@ -74,6 +85,12 @@ export type EquipmentEntry = {
      *  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 {
     index: number;
@@ -234,6 +251,28 @@ 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 {
+    layout?: {
+        saves?: "section";
+    };
+    favorites?: string[];
+    filters?: {
+        actions?: SheetViewFilter;
+        passive?: SheetViewFilter;
+    };
+    pools?: Record<string, SheetPoolView>;
+}
 export interface Character {
     name: string;
     edition: Edition;
@@ -292,6 +331,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
@@ -304,6 +344,15 @@ export type FeatVia = {
 } | {
     kind: "background";
     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";
@@ -398,14 +447,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;
-    /** 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`.
+    /** 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). */
@@ -432,9 +495,16 @@ 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;
+    /** 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 {
     definition: Character;
@@ -483,6 +553,10 @@ export interface ResolvedCharacter {
      *  such pick. Populated by the resolver's collectChosenWeaponMasteries pass. */
     weaponMasteries: 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;
 }
 export interface ProficiencySet {
     categories: string[];
@@ -526,20 +600,28 @@ export interface HPBreakdown {
  *  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`. */
+ *  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;
 }
 export interface AttackRow {
     id: string;
     name: string;
     range?: string;
-    /** Secondary thrown-mode range ("20/60 ft") for a throwable melee weapon.
+    /** 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;
@@ -550,6 +632,10 @@ export interface AttackRow {
      *  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";
     properties: string[];
     proficient: boolean;
     breakdown: {
@@ -557,8 +643,9 @@ export interface AttackRow {
         damage: ACTerm[];
     };
     informational?: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
-    /** Hand slot the attack came from. Used by Actions tab to find the
-     *  originating equipment entry for the row-expand panel. */
+    /** 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. */
@@ -610,6 +697,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;
@@ -743,6 +836,14 @@ 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?: {

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,6 +17,14 @@ 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;
+export type PoolHead = "dice" | "points";
+export interface PoolPresentation {
+    head: PoolHead;
+}
+/** 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
  *  (Commander's Strike x2, Rally x2) are field-identical to the other 39 maneuvers except that hint, so a

package/dist/pc/pool-layout.js

@@ -4,13 +4,15 @@ import {
   RENDERING_HINT_LAYOUT,
   deriveEntryAffordance,
   derivePoolLayout,
-  formatAffordanceCaption
-} from "../chunk-PP2UHLBA.js";
+  formatAffordanceCaption,
+  poolPresentation
+} from "../chunk-B3DP42OM.js";
 export {
   AFFORDANCE_CAPTIONS,
   RENDERING_HINT_AFFORDANCE,
   RENDERING_HINT_LAYOUT,
   deriveEntryAffordance,
   derivePoolLayout,
-  formatAffordanceCaption
+  formatAffordanceCaption,
+  poolPresentation
 };

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-7YU4NPKR.js";
-import "../chunk-BL3VELKP.js";
-import "../chunk-V6LJFP4R.js";
+} from "../chunk-AZRGFUSR.js";
+import "../chunk-Y5VVP73C.js";
+import "../chunk-FANQVQ3D.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   raceCodec