@archivist-gg/dnd5e 0.1.0 → 0.2.0

package/dist/pc/pc.resolver.d.ts

@@ -2,12 +2,28 @@ import type { EntityRegistry } from "@archivist-gg/core";
 import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
 import type { BackgroundEntity } from "@archivist-gg/dnd5e/background/background.types";
 import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
-import type { Character, ResolvedCharacter, ResolvedClass, ResolvedFeature } from "./pc.types.js";
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { Character, ChoiceValue, ResolvedCharacter, ResolvedClass, ResolvedFeature, ResolvedSpell } from "./pc.types.js";
 export interface ResolveResult {
     character: ResolvedCharacter;
     warnings: string[];
 }
 export declare function stripSlug(ref: string | null): string | null;
+/**
+ * Resolve a background's `origin_feat` wikilink into a real FeatEntity + a display
+ * name, using ONLY the EntityRegistry (no DOM). Lifted from the builder's
+ * background-step so the resolver pipeline and the builder share ONE resolution
+ * (R2-m7, [[always-retire-shims-edit-all]]). Handles both path-style refs
+ * ("[[SRD 2024/Feats/Alert]]") and bare-slug refs ("[[my-feat]]"), plus the 2024
+ * parenthetical-variant refs ("[[SRD 2024/Feats/Magic Initiate (Cleric)]]") that
+ * resolve to the BASE feat ("magic-initiate") while keeping the full variant
+ * string as the display name. Returns null when the ref is empty or resolves to no
+ * feat (an unresolvable ref folds nothing into the pipeline).
+ */
+export declare function resolveOriginFeat(entities: EntityRegistry, originFeatRef: string | null): {
+    feat: FeatEntity;
+    display: string;
+} | null;
 export declare class PCResolver {
     private readonly entities;
     constructor(entities: EntityRegistry);
@@ -15,11 +31,65 @@ export declare class PCResolver {
     get registry(): EntityRegistry;
     resolve(character: Character): ResolveResult;
 }
+/**
+ * 2024 Weapon Mastery: unions the persisted `weapon-mastery` picks across every
+ * class/level `ClassEntry.choices[level]["weapon-mastery"]`. Returns both the
+ * ORIGINAL full picked slugs (`full` — used for exact-match display-name lookup)
+ * and their BARE-normalized form (`bare` — e.g. "srd-2024_greatsword" →
+ * "greatsword"), each de-duplicated in first-seen order. Bare-authored picks
+ * normalize to themselves. Non-string / non-array picks are ignored.
+ */
+export declare function collectChosenWeaponMasteries(character: Character): {
+    bare: string[];
+    full: string[];
+};
 /**
  * Walks class.choices for `feat` entries and adds background feat slugs.
  * Returns bare slugs (no `[[ ]]`).
  */
 export declare function collectFeatSlugs(character: Character): string[];
+/**
+ * Feat→spell application (3d). Walks a feat's OWN `choices` to find its spell
+ * picks and turns each into a ResolvedSpell. A feat's spells sit behind a
+ * `spell-list` select-inline whose CHOSEN branch nests `select-entity{spell}`
+ * picks; the chosen spellcasting ability comes from the feat's
+ * `spellcasting-ability` select-inline. `read(childId)` yields the persisted pick
+ * for a child choice id (origin feat: `origin_choices["background:feat:<id>"]`;
+ * class-slot feat: `choices[lvl]["feat:<id>"]`). Unresolvable spell slugs warn and
+ * are skipped, mirroring the known-spell loop. classSlug stays null: a feat spell
+ * is not owned by a class for DC/ability; the carried `ability` drives its casting.
+ */
+export declare function collectFeatGrantedSpells(feat: FeatEntity, read: (childId: string) => ChoiceValue | undefined, entities: EntityRegistry, warnings: string[]): ResolvedSpell[];
+/**
+ * Item→spell application (P4-T3). Walks the character's equipment for entries whose
+ * resolved item is a spell scroll (carries the T1 `scroll_level` marker) AND names a
+ * chosen spell via `overrides.spell`, turning each into a
+ * ResolvedSpell{ source:"item", classSlug:null, prepared:true, alwaysPrepared:true }.
+ * The casting `ability` is the character's OWN spellcasting ability when they have
+ * one (`ownAbility`, the first caster class's ability), else the per-instance
+ * `overrides.spell_ability`, else undefined (a no-ability scroll is left ability-less:
+ * the plugin surfaces it without a DC; an ability is NEVER fabricated here).
+ * `entryIndex` records the originating equipment index so the segmented dedupe keeps
+ * two scrolls of one spell (and a scroll of a class-known spell) as their own rows.
+ * Unresolvable spell slugs warn and are skipped, mirroring the known-spell + feat loops.
+ * In-memory only: no KnownSpellObject{source:"item"} is injected (its strict schema
+ * omits `ability`).
+ */
+export declare function collectItemGrantedSpells(character: Character, ownAbility: Ability | null, entities: EntityRegistry, warnings: string[]): ResolvedSpell[];
+/**
+ * Collapses duplicate resolved spells (3d Minor #2 carry-forward + P4-T3 segmented
+ * dedupe). A spell can be emitted more than once: it may be BOTH in
+ * `character.spells.known` AND a feat pick, or a feat may be taken as both origin +
+ * class-slot. A class-sourced copy owns a real DC via its `classSlug`, so it always
+ * wins over a feat copy of the same slug; otherwise first-seen wins. Insertion order
+ * is preserved (a later class copy replaces an earlier feat copy in place), so the
+ * Spells section never renders duplicate rows while a legitimately class-known copy is
+ * never lost. Item-source spells carry INSTANCE identity: they key by
+ * `slug + "#" + entryIndex`, so two scrolls of one spell stay two rows and a scroll of
+ * a class-known spell keeps its OWN item row, never collapsing into / being collapsed
+ * by a class/feat copy. The class/feat slug-only merge is unchanged.
+ */
+export declare function dedupeResolvedSpells(spells: ResolvedSpell[]): ResolvedSpell[];
 /** Selected select-entity values (optional-features) and selected inline
  *  options carrying effects[] become synthesized resolved features (SP2 Plan 3 §9).
  *  The actions/resources engines consume these synthesized features, and the

package/dist/pc/pc.resolver.js

@@ -1,267 +1,34 @@
 import {
-  resolveAllPools
-} from "../chunk-6PXE7T7C.js";
-import {
-  normalizeKnownSpell,
-  resolveSpellcasting
-} from "../chunk-IXZXFFFW.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-TJCNX6UZ.js";
+  PCResolver,
+  collectChosenGrantedFeatures,
+  collectChosenWeaponMasteries,
+  collectFeatGrantedSpells,
+  collectFeatSlugs,
+  collectItemGrantedSpells,
+  collectResolvedFeatures,
+  dedupeResolvedSpells,
+  resolveOriginFeat,
+  stripSlug
+} from "../chunk-R5SQHP2X.js";
 import "../chunk-BH6AMZVY.js";
+import "../chunk-UC4FE5X3.js";
+import "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
 import "../chunk-J2RYSZMQ.js";
 import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
-
-// src/pc/pc.resolver.ts
-var SLUG_RE = /^\[\[(.+?)\]\]$/;
-function stripSlug(ref) {
-  if (!ref) return null;
-  const m = ref.match(SLUG_RE);
-  return m ? m[1] : ref;
-}
-var PCResolver = class {
-  constructor(entities) {
-    this.entities = entities;
-  }
-  /** Exposed so recalc() can apply equipment bonuses (Pass A / Pass B). */
-  get registry() {
-    return this.entities;
-  }
-  resolve(character) {
-    var _a, _b, _c, _d, _e;
-    const warnings = [];
-    const lookup = (rawRef, type) => {
-      const slug = stripSlug(rawRef);
-      if (!slug) return null;
-      const reg = this.entities.getByTypeAndSlug(type, slug);
-      if (!reg) {
-        warnings.push(`Slug [[${slug}]] not found in compendium as ${type}.`);
-        return null;
-      }
-      const data = reg.data;
-      return data.slug == null ? { ...data, slug: reg.slug } : data;
-    };
-    const race = lookup(character.race, "race");
-    const background = lookup(character.background, "background");
-    const classes = character.class.map((c) => ({
-      entity: lookup(c.name, "class"),
-      level: c.level,
-      subclass: lookup(c.subclass, "subclass"),
-      choices: c.choices
-    }));
-    const featSlugs = collectFeatSlugs(character);
-    const feats = [];
-    for (const slug of featSlugs) {
-      const f = lookup(`[[${slug}]]`, "feat");
-      if (f) feats.push(f);
-    }
-    const totalLevel = classes.reduce((sum, c) => sum + c.level, 0);
-    const features = collectResolvedFeatures(race, classes, background, feats);
-    const extraFeatures = collectChosenGrantedFeatures(character, classes, this.entities, race, background);
-    features.push(...extraFeatures);
-    const primaryCasterSlug = (_a = classes.map((c, i) => c.entity && resolveSpellcasting(c) ? stripSlug(character.class[i].name) : null).find((slug) => slug != null)) != null ? _a : null;
-    const spells = [];
-    for (const raw of (_b = character.spells.known) != null ? _b : []) {
-      const n = normalizeKnownSpell(raw);
-      const reg = this.entities.getByTypeAndSlug("spell", n.slug);
-      if (!reg) {
-        warnings.push(`Spell [[${n.slug}]] not found in compendium.`);
-        continue;
-      }
-      const entity = reg.data;
-      const isCantrip = ((_c = entity.level) != null ? _c : 0) === 0;
-      const classSlug = (_d = n.classSlug) != null ? _d : primaryCasterSlug;
-      const prep = isCantrip || n.alwaysPrepared ? true : (_e = n.preparedFlag) != null ? _e : false;
-      spells.push({ entity, slug: n.slug, classSlug, source: n.source, prepared: prep, alwaysPrepared: n.alwaysPrepared });
-    }
-    const resolvedCharacter = {
-      definition: character,
-      race,
-      classes,
-      background,
-      feats,
-      totalLevel,
-      features,
-      spells,
-      pools: [],
-      state: character.state
-    };
-    resolvedCharacter.pools = resolveAllPools(resolvedCharacter, this.entities);
-    return { character: resolvedCharacter, warnings };
-  }
-};
-function collectFeatSlugs(character) {
-  const slugs = /* @__PURE__ */ new Set();
-  for (const c of character.class) {
-    for (const [, choiceBlock] of Object.entries(c.choices)) {
-      const feat = choiceBlock == null ? void 0 : choiceBlock.feat;
-      if (typeof feat === "string") {
-        const s = stripSlug(feat);
-        if (s) slugs.add(s);
-      }
-    }
-  }
-  return [...slugs];
-}
-function collectChosenGrantedFeatures(character, classes, registry, race = null, background = null) {
-  var _a, _b;
-  const out = [];
-  classes.forEach((c, i) => {
-    var _a2, _b2, _c, _d;
-    if (!c.entity) return;
-    const entity = c.entity;
-    const entry = character.class[i];
-    if (!entry) return;
-    for (const [lvlStr, atLevel] of Object.entries(entry.choices)) {
-      const lvl = Number(lvlStr);
-      if (!Number.isFinite(lvl) || lvl > entry.level) continue;
-      const features = (_b2 = ((_a2 = entity.features_by_level) != null ? _a2 : {})[lvl]) != null ? _b2 : [];
-      const subFeatures = c.subclass ? (_d = ((_c = c.subclass.features_by_level) != null ? _c : {})[lvl]) != null ? _d : [] : [];
-      for (const feature of [...features, ...subFeatures]) {
-        walkChoiceGrants(feature.choices, atLevel, (granted) => {
-          out.push({ feature: granted, source: { kind: "class", slug: entity.slug, level: lvl } });
-        }, registry);
-      }
-    }
-  });
-  const oc = (_a = character.origin_choices) != null ? _a : {};
-  const originAt = (ns) => {
-    const at = {};
-    for (const [key, val] of Object.entries(oc)) {
-      if (key.startsWith(`${ns}:`)) at[key.slice(ns.length + 1)] = val;
-    }
-    return at;
-  };
-  if (race) {
-    const atRace = originAt("race");
-    const emitRace = (granted) => {
-      out.push({ feature: granted, source: { kind: "race", slug: race.slug } });
-    };
-    walkChoiceGrants(race.choices, atRace, emitRace, registry);
-    for (const trait of (_b = race.traits) != null ? _b : []) {
-      walkChoiceGrants(trait.choices, atRace, emitRace, registry);
-    }
-  }
-  if (background) {
-    const atBg = originAt("background");
-    const emitBg = (granted) => {
-      out.push({ feature: granted, source: { kind: "background", slug: background.slug } });
-    };
-    walkChoiceGrants(background.choices, atBg, emitBg, registry);
-    if (background.feature) {
-      walkChoiceGrants(background.feature.choices, atBg, emitBg, registry);
-    }
-  }
-  return out;
-}
-function walkChoiceGrants(choices, atLevel, emit, registry) {
-  var _a, _b, _c, _d;
-  for (const ch of choices != null ? choices : []) {
-    const sel = atLevel[ch.id];
-    if (ch.kind === "select-entity" && ch.entity_type === "optional-feature") {
-      const slugs = Array.isArray(sel) ? sel : typeof sel === "string" ? [sel] : [];
-      for (const slug of slugs) {
-        const reg = registry.getByTypeAndSlug("optional-feature", (_a = stripSlug(String(slug))) != null ? _a : String(slug));
-        if (!reg) continue;
-        const d = reg.data;
-        emit({
-          id: (_b = d.slug) != null ? _b : String(slug),
-          name: (_c = d.name) != null ? _c : String(slug),
-          description: d.description,
-          effects: d.effects,
-          ...d.action_cost ? { action: d.action_cost } : {}
-        });
-      }
-    }
-    if (ch.kind === "select-inline") {
-      const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
-      if ((_d = branch == null ? void 0 : branch.effects) == null ? void 0 : _d.length) {
-        emit({ id: `${ch.id}-${branch.value}`, name: branch.label, description: branch.description, effects: branch.effects });
-      }
-      if (branch == null ? void 0 : branch.choices) walkChoiceGrants(branch.choices, atLevel, emit, registry);
-    }
-  }
-}
-function collectResolvedFeatures(race, classes, background, feats) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const out = [];
-  for (const c of classes) {
-    if (!c.entity) continue;
-    const slug = c.entity.slug;
-    const byLevel = (_a = c.entity.features_by_level) != null ? _a : {};
-    for (const [lvlStr, feats0] of Object.entries(byLevel)) {
-      const lvl = parseInt(lvlStr, 10);
-      if (Number.isNaN(lvl) || lvl > c.level) continue;
-      for (const feat of feats0) {
-        out.push({ feature: feat, source: { kind: "class", slug, level: lvl } });
-      }
-    }
-    if ((_b = c.entity.resources) == null ? void 0 : _b.length) {
-      out.push({
-        feature: { name: c.entity.name, resources: c.entity.resources },
-        source: { kind: "class", slug, level: 1 }
-      });
-    }
-    if (c.subclass) {
-      const sSlug = c.subclass.slug;
-      const sByLevel = (_c = c.subclass.features_by_level) != null ? _c : {};
-      for (const [lvlStr, feats0] of Object.entries(sByLevel)) {
-        const lvl = parseInt(lvlStr, 10);
-        if (Number.isNaN(lvl) || lvl > c.level) continue;
-        for (const feat of feats0) {
-          out.push({ feature: feat, source: { kind: "subclass", slug: sSlug, level: lvl } });
-        }
-      }
-      if ((_d = c.subclass.resources) == null ? void 0 : _d.length) {
-        out.push({
-          feature: { name: c.subclass.name, resources: c.subclass.resources },
-          source: { kind: "subclass", slug: sSlug, level: 1 }
-        });
-      }
-    }
-  }
-  if (race) {
-    const traits = (_e = race.traits) != null ? _e : [];
-    for (const feat of traits) {
-      out.push({ feature: feat, source: { kind: "race", slug: race.slug } });
-    }
-  }
-  if (background) {
-    const bgFeature = background.feature;
-    if (bgFeature) {
-      out.push({ feature: bgFeature, source: { kind: "background", slug: background.slug } });
-    }
-  }
-  for (const feat of feats) {
-    const bundled = (_f = feat.features) != null ? _f : [];
-    const entityEffects = (_g = feat.effects) != null ? _g : [];
-    if (bundled.length > 0) {
-      bundled.forEach((f, i) => {
-        var _a2;
-        const feature = i === 0 && entityEffects.length > 0 ? { ...f, effects: [...(_a2 = f.effects) != null ? _a2 : [], ...entityEffects] } : f;
-        out.push({ feature, source: { kind: "feat", slug: feat.slug } });
-      });
-    } else {
-      const name = (_h = feat.name) != null ? _h : feat.slug;
-      const description = (_i = feat.description) != null ? _i : "";
-      out.push({
-        feature: {
-          name,
-          description,
-          ...feat.resources ? { resources: feat.resources } : {},
-          ...entityEffects.length > 0 ? { effects: entityEffects } : {}
-        },
-        source: { kind: "feat", slug: feat.slug }
-      });
-    }
-  }
-  return out;
-}
 export {
   PCResolver,
   collectChosenGrantedFeatures,
+  collectChosenWeaponMasteries,
+  collectFeatGrantedSpells,
   collectFeatSlugs,
+  collectItemGrantedSpells,
   collectResolvedFeatures,
+  dedupeResolvedSpells,
+  resolveOriginFeat,
   stripSlug
 };

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

@@ -130,6 +130,19 @@ export declare const characterSchema: z.ZodObject<{
                 special: "special";
             }>>;
             range: z.ZodOptional<z.ZodString>;
+            resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            vulnerable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            condition_immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            spell: z.ZodOptional<z.ZodString>;
+            spell_ability: z.ZodOptional<z.ZodEnum<{
+                str: "str";
+                dex: "dex";
+                con: "con";
+                int: "int";
+                wis: "wis";
+                cha: "cha";
+            }>>;
         }, z.core.$strict>>;
         state: z.ZodOptional<z.ZodObject<{
             charges: z.ZodOptional<z.ZodObject<{
@@ -216,6 +229,14 @@ export declare const characterSchema: z.ZodObject<{
             saveDC: z.ZodOptional<z.ZodNumber>;
             attackBonus: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        spellcasting_ability: z.ZodOptional<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>;
         spell_slots: z.ZodOptional<z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodNumber>>;
         attunement_limit: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;

package/dist/pc/pc.schema.js

@@ -1,6 +1,6 @@
 import {
   characterSchema
-} from "../chunk-ZLG6FQFB.js";
+} from "../chunk-5WQD3WNZ.js";
 import "../chunk-TZK36BU7.js";
 export {
   characterSchema

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

@@ -35,6 +35,10 @@ export interface EquipmentEntryOverrides {
     immune?: string[];
     vulnerable?: string[];
     condition_immune?: string[];
+    /** Per-instance spell payload (e.g. the spell a Spell Scroll casts). */
+    spell?: string;
+    /** Ability governing this instance's spell save DC / attack when cast. */
+    spell_ability?: Ability;
 }
 export interface EquipmentEntryState {
     charges?: {
@@ -92,6 +96,10 @@ export interface KnownSpellObject {
     source?: "class" | "feat" | "item" | "race" | "domain";
     prepared?: boolean;
     always_prepared?: boolean;
+    /** The spell's own spellcasting ability (e.g. WIS for a Magic Initiate (Cleric)
+     *  pick). Belongs on the persisted shape for symmetry with ResolvedSpell.ability;
+     *  feat spells arrive via origin_choices, but a known-spell entry may carry it. */
+    ability?: Ability;
 }
 export type KnownSpellEntry = string | KnownSpellObject;
 export type PassiveKind = "perception" | "investigation" | "insight";
@@ -120,6 +128,10 @@ export interface CharacterOverrides {
         saveDC?: number;
         attackBonus?: number;
     };
+    /** Character-level spellcasting ability for spells that carry no ability of
+     *  their own (e.g. a Spell Scroll cast by a non-caster): the DC-ability fallback
+     *  after a per-instance override and the character's own class ability. */
+    spellcasting_ability?: Ability;
     spell_slots?: Record<number, number>;
     attunement_limit?: number;
 }
@@ -246,6 +258,19 @@ export type FeatureSource = {
 export interface ResolvedFeature {
     feature: Feature;
     source: FeatureSource;
+    /** #3: chosen select-inline option prose, folded onto the PARENT feature for
+     *  render (a shallow-copy wrapper field — the shared registry entity is never
+     *  mutated). One entry per select-inline choice with a recorded pick. */
+    chosenInline?: {
+        label: string;
+        description?: string;
+    }[];
+    /** #3: marks a synthesized chosen-option feature the renderer must SKIP (its
+     *  prose shows on the parent via chosenInline). A wrapper-only flag —
+     *  computeFeatureEffects ignores it, so the synthetic's effects still fold. */
+    renderSuppressed?: boolean;
+    /** The feat's entire substance is a full ability-score improvement (a pure ASI). The DISPLAY layer hides these. */
+    buildOnly?: boolean;
 }
 export interface ResolvedSpell {
     entity: Spell;
@@ -254,6 +279,14 @@ export interface ResolvedSpell {
     source: "class" | "feat" | "item" | "race" | "domain";
     prepared: boolean;
     alwaysPrepared: boolean;
+    /** The spell's OWN spellcasting ability. For a feat spell this carries the
+     *  chosen ability (e.g. WIS for Magic Initiate (Cleric)) while classSlug stays
+     *  null (a feat spell is not owned by a class for DC/ability). Absent/undefined
+     *  for class spells, which derive their ability from classSlug. */
+    ability?: Ability | null;
+    /** Index of the originating equipment entry when this spell was granted by a
+     *  per-instance item (e.g. a Spell Scroll). Absent for class/feat/race spells. */
+    entryIndex?: number;
 }
 export interface ResolvedClass {
     entity: ClassEntity | null;
@@ -290,6 +323,11 @@ export interface ResolvedCharacter {
     features: ResolvedFeature[];
     spells: ResolvedSpell[];
     pools: ResolvedPool[];
+    /** 2024 Weapon Mastery: bare-normalized slugs of the weapons the character has
+     *  chosen mastery of, unioned across every class/level `weapon-mastery` pick
+     *  (e.g. "srd-2024_greatsword" → "greatsword"). Empty when the character has no
+     *  such pick. Populated by the resolver's collectChosenWeaponMasteries pass. */
+    weaponMasteries: string[];
     state: CharacterState;
 }
 export interface ProficiencySet {
@@ -301,6 +339,16 @@ export interface ACTerm {
     amount: number;
     kind: "armor" | "shield" | "item" | "unarmored" | "override" | "dex" | "ability" | "feature";
 }
+/** An additive on-hit damage rider (dice or flat) applied to an attack, from a
+ *  feature (global — all weapon attacks) or a magic item (that weapon only).
+ *  `amount` is a dice/flat string ("2d6", "1d8", "2"); `damage_type` optional
+ *  (a bare manual override string carries its type inline); `source` is a human
+ *  label for the expand/tooltip. Rendered as its own damage chip on the row. */
+export interface DamageRider {
+    amount: string;
+    damage_type?: string;
+    source?: string;
+}
 export interface AttackRow {
     id: string;
     name: string;
@@ -308,7 +356,10 @@ export interface AttackRow {
     toHit: number;
     damageDice: string;
     damageType: string;
-    extraDamage?: string;
+    /** Accumulated additive on-hit damage riders (feature-global + item-local +
+     *  the migrated manual override), rendered as extra damage chips. Absent when
+     *  none apply (so untouched rows are unchanged). */
+    damageRiders?: DamageRider[];
     properties: string[];
     proficient: boolean;
     breakdown: {
@@ -343,6 +394,24 @@ export interface AttackRow {
      *  untouched attack rows are unchanged. The weapons table renders these joined
      *  with " · " as a muted caption under the weapon name. */
     attackNotes?: string[];
+    /** 2024 Weapon Mastery for this attack, present only when the character has
+     *  chosen mastery of this weapon AND is proficient with it AND the weapon
+     *  declares a mastery property. `slug`/`label`/`description`/`gist` come from
+     *  the mastery glossary (`gist` = a one-line effect summary for the Actions-tab
+     *  mastery column, e.g. "on fail: Prone"); `derived` carries the computed
+     *  number for the two numeric masteries (topple → Save DC, graze → On-miss
+     *  damage) and is absent for the rest. Additive + display-only, absent
+     *  (undefined) on untouched rows so nothing else changes. */
+    mastery?: {
+        slug: string;
+        label: string;
+        description: string;
+        gist?: string;
+        derived?: {
+            label: string;
+            value: number;
+        };
+    };
 }
 export interface AppliedBonuses {
     ability_bonuses: Partial<Record<Ability, number>>;
@@ -433,6 +502,16 @@ export interface DerivedStats {
     } | null;
     /** One entry per casting class (multiclass-aware). Empty for non-casters. */
     spellcastingClasses: SpellcastingClassInfo[];
+    /** Save DC / attack bonus for spells that carry their OWN spellcasting
+     *  ability rather than a class (feat-granted spells, e.g. Magic Initiate).
+     *  Keyed by that ability; populated for every ability a feat spell uses.
+     *  Computed independently of class casters, so a NON-caster (empty
+     *  spellcastingClasses / null spellcasting) still gets a real DC/attack.
+     *  Empty object when the character has no such spell. */
+    abilitySpellcasting: Partial<Record<Ability, {
+        saveDC: number;
+        attackBonus: number;
+    }>>;
     /** Derived standard slot totals by spell level (before user override). */
     derivedSpellSlots: Record<number, number>;
     /** Warlock Pact Magic, or null. */

package/dist/race/race.codec.js

@@ -1,12 +1,12 @@
 import {
   raceCodec
-} from "../chunk-PKC77VZP.js";
-import "../chunk-IDTDACM6.js";
-import "../chunk-FFULAF2P.js";
-import "../chunk-DABBCYTT.js";
+} from "../chunk-ZZGEVJKX.js";
+import "../chunk-PHQRGDRQ.js";
+import "../chunk-2BWAID3Y.js";
+import "../chunk-CZPMTQOY.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-PZOWBI3B.js";
-import "../chunk-CDW7R2QT.js";
+import "../chunk-NXSWH3AE.js";
 import "../chunk-NXR3BD2V.js";
 export {
   raceCodec

package/dist/race/race.parser.js

@@ -1,11 +1,11 @@
 import {
   parseRace
-} from "../chunk-IDTDACM6.js";
-import "../chunk-FFULAF2P.js";
-import "../chunk-DABBCYTT.js";
+} from "../chunk-PHQRGDRQ.js";
+import "../chunk-2BWAID3Y.js";
+import "../chunk-CZPMTQOY.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-PZOWBI3B.js";
-import "../chunk-CDW7R2QT.js";
+import "../chunk-NXSWH3AE.js";
 import "../chunk-NXR3BD2V.js";
 export {
   parseRace

package/dist/race/race.schema.js

@@ -1,10 +1,10 @@
 import {
   raceEntitySchema
-} from "../chunk-FFULAF2P.js";
-import "../chunk-DABBCYTT.js";
+} from "../chunk-2BWAID3Y.js";
+import "../chunk-CZPMTQOY.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-PZOWBI3B.js";
-import "../chunk-CDW7R2QT.js";
+import "../chunk-NXSWH3AE.js";
 import "../chunk-NXR3BD2V.js";
 export {
   raceEntitySchema

package/dist/schemas/choice-schema.js

@@ -1,6 +1,6 @@
 import {
   choiceSchema
-} from "../chunk-CDW7R2QT.js";
+} from "../chunk-NXSWH3AE.js";
 import "../chunk-NXR3BD2V.js";
 export {
   choiceSchema

package/dist/schemas/feature-schema.js

@@ -1,9 +1,9 @@
 import {
   featureSchema
-} from "../chunk-DABBCYTT.js";
+} from "../chunk-CZPMTQOY.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-PZOWBI3B.js";
-import "../chunk-CDW7R2QT.js";
+import "../chunk-NXSWH3AE.js";
 import "../chunk-NXR3BD2V.js";
 export {
   featureSchema

package/dist/subclass/subclass.codec.js

@@ -1,13 +1,13 @@
 import {
   subclassCodec
-} from "../chunk-SSXBYF3P.js";
-import "../chunk-PMADYMUI.js";
-import "../chunk-B7UXKNLD.js";
+} from "../chunk-XLSVNUTK.js";
+import "../chunk-L7E2UT5A.js";
+import "../chunk-W7HWMMBF.js";
 import "../chunk-4TIJKN6O.js";
-import "../chunk-DABBCYTT.js";
+import "../chunk-CZPMTQOY.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-PZOWBI3B.js";
-import "../chunk-CDW7R2QT.js";
+import "../chunk-NXSWH3AE.js";
 import "../chunk-NXR3BD2V.js";
 export {
   subclassCodec