@archivist-gg/dnd5e 0.1.1 → 0.3.0

package/dist/item/item.actions-map.d.ts

@@ -21,21 +21,29 @@ export declare const ITEM_ACTIONS: Record<string, ItemAction>;
  * (`srd-5e_wand-of-fireballs`, `srd-2024_wand-of-fireballs`,
  * `homebrew_wand-of-fireballs`).
  *
- * Compendium-prefixed slugs follow the shape `<prefix>_<name-slug>` where
- * both prefix and name-slug are kebab-case (slugify strips underscores).
- * The first underscore is therefore the unambiguous prefix separator: we
- * try the bare slug after the first underscore first, then fall back to
- * the original slug for legacy bare-slug callers.
+ * Type-namespaced slugs follow the shape `<prefix>_<entity_type>_<name-slug>`
+ * (all kebab-case; slugify never emits `_`), so a slug splits on `_` into
+ * exactly 3 parts and the bare name is `parts.slice(2).join("_")`. This is
+ * arity-robust: it also recovers the bare name from a legacy 2-part
+ * `<prefix>_<name>` slug and an already-bare name. `ITEM_ACTIONS` is keyed by
+ * bare name.
  *
- * Returns `undefined` if no map entry matches either form. Does not crash
- * on slugs without an underscore — those are treated as already-bare.
+ * Returns `undefined` if no map entry matches. Does not crash on slugs
+ * without an underscore — those are treated as already-bare.
  */
 export declare function findItemAction(slug: string): ItemAction | undefined;
 /**
  * Resolve the ItemAction for an equipped entry.
- * Priority: entry.overrides (action + range) merged onto curated map.
- * Returns null when neither source supplies an action cost.
+ * Priority: per-instance override > curated map > `itemType==="potion"`
+ * bonus-action default > null.
+ *
+ * `itemType` is the entity's `data.type` (from the registry, statically
+ * `unknown`); per the 2024 SRD, drinking/administering a potion is a Bonus
+ * Action, so an uncurated `type==="potion"` item still surfaces (curated oils
+ * mis-typed `"potion"` are pinned to "action" so this default cannot mislabel
+ * them). Returns null when no source supplies a cost (non-potion uncurated with
+ * no override).
  *
  * Accepts both bare and compendium-prefixed slugs (see `findItemAction`).
  */
-export declare function resolveItemAction(slug: string, entry: EquipmentEntry): ItemAction | null;
+export declare function resolveItemAction(slug: string, entry: EquipmentEntry, itemType?: unknown): ItemAction | null;

package/dist/item/item.actions-map.js

@@ -46,30 +46,34 @@ var ITEM_ACTIONS = {
   // Magic weapons with activation actions (surface in items table only via override; weapons table is primary)
   "sun-blade": { cost: "free", range: "self" },
   // Potions / consumables
-  "potion-of-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
-  "potion-of-greater-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
-  "potion-of-superior-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
-  "potion-of-supreme-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  // 2024 healing potions are a Bonus Action to drink/administer (curation still
+  // carries range/max_charges/recovery; the type=potion default covers uncurated ones).
+  "potion-of-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "potion-of-greater-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "potion-of-superior-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "potion-of-supreme-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
   "alchemists-fire": { cost: "action", range: "20 ft.", max_charges: 1, recovery: { amount: "0", reset: "special" } },
   "holy-water": { cost: "action", range: "20 ft.", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  // Oils are APPLIED (minutes), not drunk: curated to "action" so the blanket
+  // type=potion → bonus-action default never mislabels these mis-typed items.
   "oil-of-sharpness": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "oil-of-etherealness": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "oil-of-slipperiness": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
   "dust-of-disappearance": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } }
 };
 function findItemAction(slug) {
   if (slug in ITEM_ACTIONS) return ITEM_ACTIONS[slug];
-  const underscore = slug.indexOf("_");
-  if (underscore < 0) return void 0;
-  const bare = slug.slice(underscore + 1);
-  return ITEM_ACTIONS[bare];
+  const p = slug.split("_");
+  const bare = p.length >= 3 ? p.slice(2).join("_") : p[p.length - 1];
+  return bare === slug ? void 0 : ITEM_ACTIONS[bare];
 }
-function resolveItemAction(slug, entry) {
-  var _a;
+function resolveItemAction(slug, entry, itemType) {
+  var _a, _b;
   const curated = (_a = findItemAction(slug)) != null ? _a : null;
   const override = entry.overrides;
   const overrideCost = override == null ? void 0 : override.action;
   const overrideRange = override == null ? void 0 : override.range;
-  if (!curated && !overrideCost) return null;
-  const cost = overrideCost != null ? overrideCost : curated == null ? void 0 : curated.cost;
+  const cost = (_b = overrideCost != null ? overrideCost : curated == null ? void 0 : curated.cost) != null ? _b : itemType === "potion" ? "bonus-action" : void 0;
   if (!cost) return null;
   return {
     cost,

package/dist/item/item.codec.js

@@ -1,8 +1,8 @@
 import {
   itemCodec
-} from "../chunk-TPZSPU4L.js";
-import "../chunk-YDPWD2T7.js";
-import "../chunk-VLKIB33F.js";
+} from "../chunk-4JHOHWBI.js";
+import "../chunk-7VJ6BOA5.js";
+import "../chunk-K6Q5OUGK.js";
 export {
   itemCodec
 };

package/dist/item/item.parser.js

@@ -1,7 +1,7 @@
 import {
   parseItem
-} from "../chunk-YDPWD2T7.js";
-import "../chunk-VLKIB33F.js";
+} from "../chunk-7VJ6BOA5.js";
+import "../chunk-K6Q5OUGK.js";
 export {
   parseItem
 };

package/dist/item/item.schema.d.ts

@@ -175,6 +175,9 @@ export declare const itemEntitySchema: z.ZodObject<{
         }>>;
         condition: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    scroll_level: z.ZodOptional<z.ZodNumber>;
+    unidentified: z.ZodOptional<z.ZodBoolean>;
+    masked_category: z.ZodOptional<z.ZodString>;
     raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     damage_dice: z.ZodOptional<z.ZodString>;
     damage_type: z.ZodOptional<z.ZodString>;

package/dist/item/item.schema.js

@@ -1,7 +1,7 @@
 import {
   conditionSchema,
   itemEntitySchema
-} from "../chunk-VLKIB33F.js";
+} from "../chunk-K6Q5OUGK.js";
 export {
   conditionSchema,
   itemEntitySchema

package/dist/item/item.types.d.ts

@@ -106,6 +106,14 @@ export interface ItemEntity {
         applies_to?: "weapon" | "spell" | "all";
         condition?: string;
     }>;
+    /** Spell-scroll casting level (e.g. 3 for a "Spell Scroll (3rd Level)"). */
+    scroll_level?: number;
+    /** Marks an item the player has not yet identified: the sheet shows the
+     *  masked_category label instead of the item's true identity. */
+    unidentified?: boolean;
+    /** Generic category label shown for an unidentified item (e.g. "potion",
+     *  "scroll", "wand") in place of its real name. */
+    masked_category?: string;
     raw?: Record<string, unknown>;
     damage_dice?: string;
     damage_type?: string;

package/dist/pc/pc.decision-engine.d.ts

@@ -68,9 +68,6 @@ export interface DecisionContext {
 }
 /** "[[SRD 2024/Classes/Fighter]]" → "fighter" (tail segment, slugified). */
 export declare function wikilinkTailSlug(link: string): string;
-/** "srd-2024_fighter" → "fighter". Tolerates a nullish slug (degrades to "") so a
- *  malformed entity can't hard-crash the builder; the resolver backfills real slugs. */
-export declare function bareEntitySlug(slug: string | null | undefined): string;
 declare function matchesFilter(e: RegisteredEntity, where: EntityFilter, ownerBare: string): boolean;
 /** Test-only export of {@link matchesFilter} (Task B2). */
 export declare const __matchesFilterForTest: typeof matchesFilter;

package/dist/pc/pc.decision-engine.js

@@ -1,17 +1,22 @@
 import {
   __matchesFilterForTest,
-  bareEntitySlug,
   buildDecisionLedger,
   collectChosenAbilityPoints,
   collectChosenProficiencies,
   wikilinkTailSlug
-} from "../chunk-TJCNX6UZ.js";
+} from "../chunk-5MZSB6OM.js";
 import "../chunk-BH6AMZVY.js";
+import "../chunk-M2EMFD6S.js";
+import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
+import "../chunk-N6N74K6X.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
+import "../chunk-VTTA2ALZ.js";
+import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   __matchesFilterForTest,
-  bareEntitySlug,
   buildDecisionLedger,
   collectChosenAbilityPoints,
   collectChosenProficiencies,

package/dist/pc/pc.equipment.js

@@ -2,16 +2,13 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-ADLTSHOR.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-TJCNX6UZ.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-JEYQU3JT.js";
+} from "../chunk-EMOORSQ7.js";
+import "../chunk-353WXS6S.js";
+import "../chunk-N6N74K6X.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-WP2CX2JO.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
 export {
   computeAppliedBonuses,
   computeSlotsAndAttacks,

package/dist/pc/pc.feature-effects.d.ts

@@ -24,6 +24,11 @@ export interface WeaponAbilityOverride {
 export interface FeatureEffectTotals {
     initiative_bonus: number;
     hp_per_level_bonus: number;
+    /** One term per hp-per-level-bonus effect, labeled with the owning feature's name. */
+    hp_per_level_terms: {
+        label: string;
+        value: number;
+    }[];
     speed_walk_bonus: number;
     /**
      * Absolute walk-speed FLOOR from `speed-bonus` effects with `set:true` (e.g.

package/dist/pc/pc.feature-effects.js

@@ -1,10 +1,8 @@
 import {
   computeFeatureEffects,
   emptyFeatureEffectTotals
-} from "../chunk-GEJSJP6E.js";
-import "../chunk-TJCNX6UZ.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-JEYQU3JT.js";
+} from "../chunk-AIRFC5NQ.js";
+import "../chunk-LV4SNWZQ.js";
 import "../chunk-WP2CX2JO.js";
 export {
   computeFeatureEffects,

package/dist/pc/pc.parser.js

@@ -1,6 +1,6 @@
 import {
   characterSchema
-} from "../chunk-ZLG6FQFB.js";
+} from "../chunk-A4WENOUQ.js";
 import "../chunk-TZK36BU7.js";
 
 // src/pc/pc.parser.ts

package/dist/pc/pc.pools.js

@@ -2,11 +2,16 @@ import {
   levelPrereqMax,
   resolveAllPools,
   resolvePool
-} from "../chunk-6PXE7T7C.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-TJCNX6UZ.js";
+} from "../chunk-5MZSB6OM.js";
 import "../chunk-BH6AMZVY.js";
+import "../chunk-M2EMFD6S.js";
+import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
+import "../chunk-N6N74K6X.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
+import "../chunk-VTTA2ALZ.js";
+import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   levelPrereqMax,

package/dist/pc/pc.recalc.d.ts

@@ -45,11 +45,18 @@ export declare function abilityBonusBreakdown(resolved: ResolvedCharacter): Reco
     class: number;
     feat: number;
 }>;
+/** Dice-only portion of PC max HP: first VALID level anywhere = max(die),
+ *  every later valid level = PHB average. Skip rule identical to hpLevelCount. */
+export declare function hitDiceAverageSum(classes: ResolvedClass[]): number;
+/** Count of levels that contribute to HP (valid class entries only). */
+export declare function hpLevelCount(classes: ResolvedClass[]): number;
 /**
  * PC-oriented multiclass HP.
  * - First class's first level: max(hit_die) + conMod.
  * - Every subsequent level (in any class): phbAverageForDie(thatLevel'sClass) + conMod.
  * CON mod contributes once per total level.
+ * Decomposed (P5 T2) into hitDiceAverageSum (dice-only) + hpLevelCount (level count),
+ * so a later popup can render the two components separately.
  */
 export declare function multiclassMaxHP(classes: ResolvedClass[], conMod: number): number;
 /**

package/dist/pc/pc.recalc.js

@@ -1,32 +1,33 @@
+import {
+  computeConditionEffects
+} from "../chunk-R2ZV233X.js";
+import {
+  collectChosenAbilityPoints,
+  collectChosenProficiencies
+} from "../chunk-5MZSB6OM.js";
+import "../chunk-BH6AMZVY.js";
 import {
   computeSpellLimits,
   deriveSpellSlots,
   resolveSpellcasting
-} from "../chunk-IXZXFFFW.js";
+} from "../chunk-M2EMFD6S.js";
 import "../chunk-5XUXXAQJ.js";
-import {
-  computeConditionEffects
-} from "../chunk-R2ZV233X.js";
+import "../chunk-JEYQU3JT.js";
 import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-ADLTSHOR.js";
-import "../chunk-UC4FE5X3.js";
+} from "../chunk-EMOORSQ7.js";
+import "../chunk-353WXS6S.js";
+import "../chunk-N6N74K6X.js";
 import {
   computeFeatureEffects
-} from "../chunk-GEJSJP6E.js";
-import {
-  collectChosenAbilityPoints,
-  collectChosenProficiencies
-} from "../chunk-TJCNX6UZ.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-JEYQU3JT.js";
+} from "../chunk-AIRFC5NQ.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-J2RYSZMQ.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
+import "../chunk-VTTA2ALZ.js";
 import {
   abilityModifier,
   attackBonus,
@@ -117,7 +118,7 @@ function abilityBonusBreakdown(resolved) {
   }
   return out;
 }
-function multiclassMaxHP(classes, conMod) {
+function hitDiceAverageSum(classes) {
   var _a;
   let total = 0;
   let firstLevelCounted = false;
@@ -126,14 +127,27 @@ function multiclassMaxHP(classes, conMod) {
     if (!c.entity || die == null || c.level < 1) continue;
     for (let lvl = 1; lvl <= c.level; lvl++) {
       if (!firstLevelCounted) {
-        total += die + conMod;
+        total += die;
         firstLevelCounted = true;
       } else {
-        total += Math.floor(die / 2) + 1 + conMod;
+        total += Math.floor(die / 2) + 1;
       }
     }
   }
-  return Math.max(1, total);
+  return total;
+}
+function hpLevelCount(classes) {
+  var _a;
+  let count = 0;
+  for (const c of classes) {
+    const die = parseDieSize((_a = c.entity) == null ? void 0 : _a.hit_die);
+    if (!c.entity || die == null || c.level < 1) continue;
+    count += c.level;
+  }
+  return count;
+}
+function multiclassMaxHP(classes, conMod) {
+  return Math.max(1, hitDiceAverageSum(classes) + conMod * hpLevelCount(classes));
 }
 function unarmoredAC(resolved, mods, warnings) {
   return unarmoredACBreakdown(resolved, mods, warnings).total;
@@ -362,7 +376,7 @@ function computeProficiencies(resolved) {
   };
 }
 function recalc(resolved, registry) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa;
   const warnings = [];
   const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
   const chosenProfs = collectChosenProficiencies(resolved);
@@ -484,9 +498,36 @@ function recalc(resolved, registry) {
     investigation: (_t = (_s = overrides.passives) == null ? void 0 : _s.investigation) != null ? _t : passive(scores.int, investigationTri, proficiencyBonus),
     insight: (_v = (_u = overrides.passives) == null ? void 0 : _u.insight) != null ? _v : passive(scores.wis, insightTri, proficiencyBonus)
   };
-  const hpMaxDerived = multiclassMaxHP(resolved.classes, mods.con) + featureEffects.hp_per_level_bonus * totalLevel;
-  const hpMaxAfterConditions = Math.floor(hpMaxDerived * conditionEffects.hp_max_multiplier);
-  const hpMax = (_x = (_w = overrides.hp) == null ? void 0 : _w.max) != null ? _x : hpMaxAfterConditions;
+  const hpRolled = (_x = (_w = overrides.hp) == null ? void 0 : _w.rolled) != null ? _x : null;
+  const hpModifier = (_z = (_y = overrides.hp) == null ? void 0 : _y.modifier) != null ? _z : null;
+  const averageDiceSum = hitDiceAverageSum(resolved.classes);
+  const conLevels = hpLevelCount(resolved.classes);
+  const diceSum = hpRolled != null ? hpRolled : averageDiceSum;
+  const diceConRaw = diceSum + mods.con * conLevels;
+  const diceConClamped = Math.max(1, diceConRaw);
+  const hpMaxDerived = diceConClamped + featureEffects.hp_per_level_bonus * totalLevel + (hpModifier != null ? hpModifier : 0);
+  const hpMaxAfterConditions = Math.max(0, Math.floor(hpMaxDerived * conditionEffects.hp_max_multiplier));
+  const hpMax = (_B = (_A = overrides.hp) == null ? void 0 : _A.max) != null ? _B : hpMaxAfterConditions;
+  const hpBreakdown = {
+    diceSum,
+    diceSource: hpRolled != null ? "rolled" : "average",
+    averageDiceSum,
+    conMod: mods.con,
+    conLevels,
+    clampApplied: diceConClamped !== diceConRaw,
+    perLevelTerms: featureEffects.hp_per_level_terms.map((t) => ({
+      label: t.label,
+      perLevel: t.value,
+      levels: totalLevel,
+      total: t.value * totalLevel
+    })),
+    modifier: hpModifier,
+    exhaustionMultiplier: conditionEffects.hp_max_multiplier,
+    exhaustionLevel: conditionEffects.exhaustion_level,
+    derivedMax: hpMaxAfterConditions,
+    override: (_D = (_C = overrides.hp) == null ? void 0 : _C.max) != null ? _D : null,
+    final: hpMax
+  };
   const featureAcTermsFor = (hasArmor) => featureEffects.ac_terms.filter((t) => !t.requires_armor || hasArmor).map((t) => ({ source: t.label, amount: t.value, kind: "feature" }));
   const sumTerms = (terms) => terms.reduce((s, t) => s + t.amount, 0);
   const weaponAbilities = [...featureEffects.weaponAbilities];
@@ -511,7 +552,7 @@ function recalc(resolved, registry) {
   let acBreakdownDerived = [];
   let acInformationalDerived = [];
   if (registry) {
-    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_y = resolved.weaponMasteries) != null ? _y : []);
+    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_E = resolved.weaponMasteries) != null ? _E : []);
     if (derivedEquipment.equippedSlots.armor) {
       const featTerms = featureAcTermsFor(true);
       acDerived = derivedEquipment.ac + sumTerms(featTerms);
@@ -534,16 +575,16 @@ function recalc(resolved, registry) {
     acDerived = total + sumTerms(featTerms);
     acBreakdownDerived = [...terms, ...featTerms];
   }
-  const ac = (_z = overrides.ac) != null ? _z : acDerived;
+  const ac = (_F = overrides.ac) != null ? _F : acDerived;
   const additiveSpeed = speedFromRace(resolved) + applied.speed_bonuses.walk + featureEffects.speed_walk_bonus;
   const baseSpeed = Math.max(featureEffects.speed_walk_set, additiveSpeed);
   const adjustedSpeed = baseSpeed * conditionEffects.speed_multiplier - conditionEffects.speed_reduction_ft;
   const conditionSpeed = conditionEffects.speed_floor_zero ? 0 : Math.max(0, Math.floor(adjustedSpeed));
-  const speed = (_A = overrides.speed) != null ? _A : conditionSpeed;
+  const speed = (_G = overrides.speed) != null ? _G : conditionSpeed;
   if (!resolved.race) warnings.push("No race resolved; speed defaulted to 30.");
-  const init = (_B = overrides.initiative) != null ? _B : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
+  const init = (_H = overrides.initiative) != null ? _H : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
   const senses = {
-    darkvision: Math.max((_E = (_D = (_C = resolved.race) == null ? void 0 : _C.vision) == null ? void 0 : _D.darkvision) != null ? _E : 0, featureEffects.senses.darkvision, applied.senses.darkvision),
+    darkvision: Math.max((_K = (_J = (_I = resolved.race) == null ? void 0 : _I.vision) == null ? void 0 : _J.darkvision) != null ? _K : 0, featureEffects.senses.darkvision, applied.senses.darkvision),
     blindsight: Math.max(featureEffects.senses.blindsight, applied.senses.blindsight),
     tremorsense: Math.max(featureEffects.senses.tremorsense, applied.senses.tremorsense),
     truesight: Math.max(featureEffects.senses.truesight, applied.senses.truesight)
@@ -561,8 +602,8 @@ function recalc(resolved, registry) {
       classSlug: c.entity.slug,
       className: c.entity.name,
       ability: profile.ability,
-      saveDC: (_G = (_F = overrides.spellcasting) == null ? void 0 : _F.saveDC) != null ? _G : dc,
-      attackBonus: (_I = (_H = overrides.spellcasting) == null ? void 0 : _H.attackBonus) != null ? _I : atk,
+      saveDC: (_M = (_L = overrides.spellcasting) == null ? void 0 : _L.saveDC) != null ? _M : dc,
+      attackBonus: (_O = (_N = overrides.spellcasting) == null ? void 0 : _N.attackBonus) != null ? _O : atk,
       casterType: profile.casterType,
       preparation: profile.preparation
     });
@@ -574,24 +615,33 @@ function recalc(resolved, registry) {
     saveDC: spellcastingClasses[0].saveDC,
     attackBonus: spellcastingClasses[0].attackBonus
   } : null;
+  const abilitySpellcasting = {};
+  for (const s of resolved.spells) {
+    const ab = s.ability;
+    if (!ab || abilitySpellcasting[ab]) continue;
+    abilitySpellcasting[ab] = {
+      saveDC: saveDC(scores[ab], proficiencyBonus) + applied.spell_save_dc,
+      attackBonus: attackBonus(scores[ab], proficiencyBonus) + applied.spell_attack
+    };
+  }
   const derivedSlots = deriveSpellSlots(slotInputs);
   const spellLimits = computeSpellLimits(limitInputs);
   const defenses = {
     resistances: dedupeDefenseList([
-      (_K = (_J = resolved.definition.defenses) == null ? void 0 : _J.resistances) != null ? _K : [],
+      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.resistances) != null ? _Q : [],
       applied.defenses.resistances,
       featureEffects.resistances
     ]),
     immunities: dedupeDefenseList([
-      (_M = (_L = resolved.definition.defenses) == null ? void 0 : _L.immunities) != null ? _M : [],
+      (_S = (_R = resolved.definition.defenses) == null ? void 0 : _R.immunities) != null ? _S : [],
       applied.defenses.immunities
     ]),
     vulnerabilities: dedupeDefenseList([
-      (_O = (_N = resolved.definition.defenses) == null ? void 0 : _N.vulnerabilities) != null ? _O : [],
+      (_U = (_T = resolved.definition.defenses) == null ? void 0 : _T.vulnerabilities) != null ? _U : [],
       applied.defenses.vulnerabilities
     ]),
     condition_immunities: dedupeDefenseList([
-      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.condition_immunities) != null ? _Q : [],
+      (_W = (_V = resolved.definition.defenses) == null ? void 0 : _V.condition_immunities) != null ? _W : [],
       applied.defenses.condition_immunities,
       featureEffects.condition_immunities
     ])
@@ -611,11 +661,13 @@ function recalc(resolved, registry) {
       current: resolved.state.hp.current,
       temp: resolved.state.hp.temp
     },
+    hpBreakdown,
     ac,
     speed,
     initiative: init,
     spellcasting,
     spellcastingClasses,
+    abilitySpellcasting,
     derivedSpellSlots: derivedSlots.standard,
     pactMagic: derivedSlots.pact,
     spellLimits,
@@ -633,7 +685,7 @@ function recalc(resolved, registry) {
     // untouched rows keep `critRange`/`attackNotes` ABSENT (not 20 / not []).
     // crit-range: folded weapon crit threshold, only when an effect lowered it.
     // attackNotes: reroll-damage / attack-rule captions, only when non-empty.
-    attacks: ((_R = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _R : []).map((a) => {
+    attacks: ((_X = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _X : []).map((a) => {
       var _a2;
       const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses];
       return {
@@ -644,10 +696,10 @@ function recalc(resolved, registry) {
         ...riders.length ? { damageRiders: riders } : {}
       };
     }),
-    equippedSlots: (_S = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _S : {},
-    carriedWeight: (_T = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _T : 0,
-    attunementUsed: (_U = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _U : 0,
-    attunementLimit: (_W = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _W : (_V = overrides.attunement_limit) != null ? _V : 3,
+    equippedSlots: (_Y = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _Y : {},
+    carriedWeight: (_Z = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _Z : 0,
+    attunementUsed: (__ = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? __ : 0,
+    attunementLimit: (_aa = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _aa : (_$ = overrides.attunement_limit) != null ? _$ : 3,
     conditionEffects,
     rollModifiers: featureEffects.rollModifiers
   };
@@ -659,6 +711,8 @@ export {
   computeAbilityScores,
   computeProficiencies,
   flattenRaceAsi,
+  hitDiceAverageSum,
+  hpLevelCount,
   initiativeBonus,
   multiclassMaxHP,
   parseDieSize,

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);
@@ -32,6 +48,48 @@ export declare function collectChosenWeaponMasteries(character: Character): {
  * 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