@archivist-gg/dnd5e 0.3.10 → 0.3.13

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;
@@ -398,14 +415,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). */
@@ -435,6 +466,12 @@ export interface ResolvedPool {
     /** 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;
+    /** 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 +520,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 +567,24 @@ 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[];
 }
 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 +595,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 +606,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. */
@@ -743,6 +793,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/pool-layout.d.ts

@@ -17,6 +17,20 @@ 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}. */
+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

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

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-MC5YJ4PB.js";
+import "../chunk-R2V5LN3I.js";
+import "../chunk-X7VZY4ON.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 import "../chunk-UA5KS2PL.js";
 export {
   raceCodec

package/dist/race/race.parser.js

@@ -1,13 +1,13 @@
 import {
   parseRace
-} from "../chunk-BL3VELKP.js";
-import "../chunk-V6LJFP4R.js";
+} from "../chunk-R2V5LN3I.js";
+import "../chunk-X7VZY4ON.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseRace

package/dist/race/race.schema.js

@@ -1,12 +1,12 @@
 import {
   fixedAsiSchema,
   raceEntitySchema
-} from "../chunk-V6LJFP4R.js";
-import "../chunk-PI4LLJG4.js";
+} from "../chunk-X7VZY4ON.js";
+import "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 import "../chunk-UA5KS2PL.js";
 export {
   fixedAsiSchema,

package/dist/schemas/attack-schema.d.ts

@@ -2,9 +2,9 @@ import { z } from "zod";
 export declare const attackSchema: z.ZodObject<{
     name: z.ZodString;
     type: z.ZodEnum<{
-        spell: "spell";
         melee: "melee";
         ranged: "ranged";
+        spell: "spell";
     }>;
     ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         str: "str";

package/dist/schemas/choice-schema.js

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

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

@@ -93,11 +93,24 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"damage-bonus">;
     damage_type: z.ZodString;
     amount: z.ZodString;
-    applies_to: z.ZodOptional<z.ZodEnum<{
-        weapon: "weapon";
+    applies_to: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         spell: "spell";
         all: "all";
-    }>>;
+    }>, z.ZodEnum<{
+        weapon: "weapon";
+        melee: "melee";
+        ranged: "ranged";
+        unarmed: "unarmed";
+        finesse: "finesse";
+        thrown: "thrown";
+    }>, z.ZodArray<z.ZodEnum<{
+        weapon: "weapon";
+        melee: "melee";
+        ranged: "ranged";
+        unarmed: "unarmed";
+        finesse: "finesse";
+        thrown: "thrown";
+    }>>]>>;
     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-XTRDCSJB.js";
+} from "../chunk-ZMJQUZQH.js";
 export {
   featureEffectSchema
 };

package/dist/schemas/feature-schema.js

@@ -1,11 +1,11 @@
 import {
   featureObjectSchema,
   featureSchema
-} from "../chunk-PI4LLJG4.js";
+} from "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 export {
   featureObjectSchema,
   featureSchema

package/dist/schemas/selection-pool-schema.d.ts

@@ -11,8 +11,18 @@ export declare const selectionPoolSchema: z.ZodObject<{
     }, z.core.$strip>;
     count: z.ZodObject<{
         column: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     replaceable: z.ZodOptional<z.ZodBoolean>;
+    active: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        label: z.ZodString;
+        verb: z.ZodString;
+        counter_label: z.ZodOptional<z.ZodString>;
+        create_label: z.ZodOptional<z.ZodString>;
+        create_verb: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    head_resource: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const poolGrantSchema: z.ZodObject<{
     pool: z.ZodString;

package/dist/schemas/selection-pool-schema.js

@@ -2,7 +2,7 @@ import {
   poolGrantSchema,
   selectionPoolSchema,
   tabDeclSchema
-} from "../chunk-23LZLBJK.js";
+} from "../chunk-G6MHJDVT.js";
 export {
   poolGrantSchema,
   selectionPoolSchema,

package/dist/spell/spell.codec.js

@@ -1,8 +1,8 @@
 import {
   spellCodec
-} from "../chunk-JSZ4H6AQ.js";
-import "../chunk-OZP6JFGT.js";
-import "../chunk-VQAXTIBW.js";
+} from "../chunk-MWCCGPG3.js";
+import "../chunk-XY6X2APM.js";
+import "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {
   spellCodec

package/dist/spell/spell.parser.js

@@ -3,8 +3,8 @@ import {
   normalizeSpellComponents,
   normalizeSpellDuration,
   parseSpell
-} from "../chunk-OZP6JFGT.js";
-import "../chunk-VQAXTIBW.js";
+} from "../chunk-XY6X2APM.js";
+import "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {
   mirrorSpellShapes,

package/dist/spell/spell.scaling.d.ts

@@ -9,16 +9,39 @@ export interface SpellEffectParts {
     /** As printed: the roll, `"<N> targets"`, the duration, or the authored sentence verbatim. */
     value: string;
 }
+/** The spell's base roll (`damage_roll`), trimmed, or null when absent, empty or whitespace-only. The ONE base-roll
+ *  check: every reader of `damage_roll` (the scaling readers here, the spell card) goes through it. */
+export declare function spellBaseRoll(spell: Spell): string | null;
 /**
- * At-a-glance scaled effect for casting a LEVELLED `spell` with a slot of `slotLevel`,
- * read from structured `casting_options` (`type: "slot_level_<N>"`), WITH the field it
- * came from. Returns null when absent or untrustworthy. The FIRST present field wins, in
- * this order: `damage_roll`, `target_count`, `duration`, `desc` (so an option carrying a
- * roll AND a sentence yields the roll). A `target_count` that equals the slot level is
- * the known SRD-2014 bad encoding (e.g. Magic Missile 2nd->2 instead of 4) and is
- * suppressed. This errs toward showing nothing rather than a wrong number.
+ * At-a-glance effect for casting a LEVELLED `spell` with a slot of `slotLevel`, WITH the field
+ * it came from. Returns null when absent or untrustworthy.
+ *
+ * A structured `casting_options` entry for that slot (`type: "slot_level_<N>"`) wins: the FIRST
+ * present field, in this order: `damage_roll`, `target_count`, `duration`, `desc` (so an option
+ * carrying a roll AND a sentence yields the roll). A `target_count` that equals the slot level is
+ * the known SRD-2014 bad encoding (e.g. Magic Missile 2nd->2 instead of 4) and is suppressed.
+ *
+ * With no option for the slot, the spell's BASE roll (`damage_roll`) answers at the spell's OWN
+ * level only. Above it, whether the base roll is still the roll dealt is `spellBaseRollAtSlot`'s
+ * question (it is when the damage does not scale); a SCALING spell missing its option above base
+ * stays null here. A CANTRIP is never read by slot (null): its roll follows the character's level,
+ * `spellEffectAtCharacterLevel`, even when it is cast from a scroll. This errs toward showing
+ * nothing rather than a wrong number.
  */
 export declare function spellEffectPartsAtSlot(spell: Spell, slotLevel: number): SpellEffectParts | null;
+/**
+ * The spell's BASE roll at a slot of `slotLevel` when the data PROVES its damage does not scale, so every slot at or
+ * above the spell's level deals the base roll. Two proofs, and only these:
+ *   (a) it has `slot_level_<N>` options and every one carries only a `duration` and / or a `target_count` (plus the
+ *       `concentration` flag a duration carries): 2024 Hex and Hunter's Mark scale their duration, Magic Missile and
+ *       Scorching Ray their target count;
+ *   (b) it has no slot options AND no `at_higher_levels` text (Finger of Death).
+ * Anything else is NOT proof: prose-only scaling (2014 Cure Wounds' "increases by 1d8 for each slot level above
+ * 1st", with no options) would print the unscaled base on every upcast row, so it stays null there. The companion of
+ * `spellEffectPartsAtSlot`: a row prints this roll beside a target count, and the duration a slot option carries
+ * prints in its own cell. Null for a cantrip, below the spell's level, and when the spell has no base roll.
+ */
+export declare function spellBaseRollAtSlot(spell: Spell, slotLevel: number): string | null;
 /** The value of `spellEffectPartsAtSlot`, without its field. */
 export declare function spellEffectAtSlot(spell: Spell, slotLevel: number): string | null;
 /**
@@ -26,9 +49,10 @@ export declare function spellEffectAtSlot(spell: Spell, slotLevel: number): stri
  * `casting_options` (`type: "player_level_<N>"`). The roll of the HIGHEST `N <= characterLevel` wins: SRD 5e authors
  * one option per level from 5 to 20, SRD 2024 and the converter author only 5 / 11 / 17. An option with no roll or an
  * EMPTY one never qualifies (SRD 5e Acid Splash and Poison Spray open with `player_level_2..4` carrying
- * `damage_roll: ''`; Eldritch Blast 2024 authors `target_count` only). Null for a levelled spell, for a level that is
- * not a finite number (a fixture-built `derived` omits `totalLevel`), and when nothing qualifies: no corpus authors
- * `player_level_1`, so a cantrip's base roll below level 5 is not in the data and nothing is invented here.
+ * `damage_roll: ''`; Eldritch Blast 2024 authors `target_count` only). When no tier qualifies (below the first tier,
+ * or tiers that carry no roll) the spell's BASE roll `damage_roll` answers: the tier-1 roll (Fire Bolt `1d10` at 4,
+ * Eldritch Blast's per-beam `1d10` at any level). Null for a levelled spell, for a level that is not a finite number
+ * (a fixture-built `derived` omits `totalLevel`), and when neither a tier nor a non-empty base roll exists.
  */
 export declare function spellEffectAtCharacterLevel(spell: Spell, characterLevel: number): string | null;
 /** Owned slot levels strictly above the spell's base level (scaling spells only). */