@archivist-gg/dnd5e 0.2.0 → 0.3.1

package/dist/pc/pc.recalc.js

@@ -1,32 +1,35 @@
 import {
   computeConditionEffects
 } from "../chunk-R2ZV233X.js";
-import {
-  computeAppliedBonuses,
-  computeSlotsAndAttacks,
-  emptyAppliedBonuses
-} from "../chunk-TQZB4OCJ.js";
-import {
-  computeFeatureEffects
-} from "../chunk-V6SOFUJW.js";
 import {
   collectChosenAbilityPoints,
   collectChosenProficiencies
-} from "../chunk-R5SQHP2X.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-UC4FE5X3.js";
+} from "../chunk-TNUFPIXI.js";
+import "../chunk-7TEK5KK7.js";
 import {
   computeSpellLimits,
   deriveSpellSlots,
+  effectiveSpellcastingAbility,
   resolveSpellcasting
-} from "../chunk-IXZXFFFW.js";
+} from "../chunk-6IRYTM5V.js";
 import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
+import {
+  computeAppliedBonuses,
+  computeSlotsAndAttacks,
+  emptyAppliedBonuses
+} from "../chunk-D3CLOBE3.js";
+import "../chunk-353WXS6S.js";
+import "../chunk-O5EYMKFH.js";
+import "../chunk-N6N74K6X.js";
+import {
+  computeFeatureEffects
+} 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 +120,7 @@ function abilityBonusBreakdown(resolved) {
   }
   return out;
 }
-function multiclassMaxHP(classes, conMod) {
+function hitDiceAverageSum(classes) {
   var _a;
   let total = 0;
   let firstLevelCounted = false;
@@ -126,14 +129,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;
@@ -294,12 +310,18 @@ function computeAbilityScores(resolved, overrides) {
   }
   return out;
 }
-function normalizeProfList(input) {
+function normalizeArmorProf(input) {
   var _a, _b;
   if (!input) return { categories: [], specific: [] };
-  if (Array.isArray(input)) return { categories: [], specific: input };
+  if (Array.isArray(input)) return { categories: input, specific: [] };
   return { categories: (_a = input.categories) != null ? _a : [], specific: (_b = input.specific) != null ? _b : [] };
 }
+function normalizeWeaponToolProf(input) {
+  var _a, _b, _c;
+  if (!input) return { categories: [], specific: [] };
+  if (Array.isArray(input)) return { categories: [], specific: input };
+  return { categories: (_a = input.categories) != null ? _a : [], specific: ((_b = input.fixed) != null ? _b : []).concat((_c = input.specific) != null ? _c : []) };
+}
 function mergeInto(target, source) {
   for (const c of source.categories) if (!target.categories.includes(c)) target.categories.push(c);
   for (const s of source.specific) if (!target.specific.includes(s)) target.specific.push(s);
@@ -326,31 +348,31 @@ function computeProficiencies(resolved) {
   for (const c of resolved.classes) {
     const p = (_a = c.entity) == null ? void 0 : _a.proficiencies;
     if (!p) continue;
-    mergeInto(armor, normalizeProfList(p.armor));
-    mergeInto(weapons, normalizeProfList(p.weapons));
-    mergeInto(tools, normalizeProfList(p.tools));
+    mergeInto(armor, normalizeArmorProf(p.armor));
+    mergeInto(weapons, normalizeWeaponToolProf(p.weapons));
+    mergeInto(tools, normalizeWeaponToolProf(p.tools));
     (_b = p.languages) == null ? void 0 : _b.forEach((l) => languages.add(l));
   }
   const racePr = (_c = resolved.race) == null ? void 0 : _c.proficiencies;
   if (racePr) {
-    mergeInto(armor, normalizeProfList(racePr.armor));
-    mergeInto(weapons, normalizeProfList(racePr.weapons));
-    mergeInto(tools, normalizeProfList(racePr.tools));
+    mergeInto(armor, normalizeArmorProf(racePr.armor));
+    mergeInto(weapons, normalizeWeaponToolProf(racePr.weapons));
+    mergeInto(tools, normalizeWeaponToolProf(racePr.tools));
     (_d = racePr.languages) == null ? void 0 : _d.forEach((l) => languages.add(l));
   }
   const bgPr = (_e = resolved.background) == null ? void 0 : _e.proficiencies;
   if (bgPr) {
-    mergeInto(armor, normalizeProfList(bgPr.armor));
-    mergeInto(weapons, normalizeProfList(bgPr.weapons));
-    mergeInto(tools, normalizeProfList(bgPr.tools));
+    mergeInto(armor, normalizeArmorProf(bgPr.armor));
+    mergeInto(weapons, normalizeWeaponToolProf(bgPr.weapons));
+    mergeInto(tools, normalizeWeaponToolProf(bgPr.tools));
     (_f = bgPr.languages) == null ? void 0 : _f.forEach((l) => languages.add(l));
   }
   for (const f of resolved.feats) {
     const grants = f.grants_proficiency;
     if (!grants) continue;
-    mergeInto(armor, normalizeProfList(grants.armor));
-    mergeInto(weapons, normalizeProfList(grants.weapons));
-    mergeInto(tools, normalizeProfList(grants.tools));
+    mergeInto(armor, normalizeArmorProf(grants.armor));
+    mergeInto(weapons, normalizeWeaponToolProf(grants.weapons));
+    mergeInto(tools, normalizeWeaponToolProf(grants.tools));
     (_g = grants.languages) == null ? void 0 : _g.forEach((l) => languages.add(l));
   }
   return {
@@ -362,7 +384,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;
   const warnings = [];
   const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
   const chosenProfs = collectChosenProficiencies(resolved);
@@ -484,9 +506,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];
@@ -500,7 +549,7 @@ function recalc(resolved, registry) {
       if (!c.entity) continue;
       const profile = resolveSpellcasting(c);
       if (profile) {
-        primaryCasterAbility = profile.ability;
+        primaryCasterAbility = effectiveSpellcastingAbility(c.entity.slug, profile.ability, overrides);
         break;
       }
     }
@@ -511,7 +560,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 +583,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)
@@ -555,19 +604,21 @@ function recalc(resolved, registry) {
     if (!c.entity) continue;
     const profile = resolveSpellcasting(c);
     if (!profile) continue;
-    const dc = saveDC(scores[profile.ability], proficiencyBonus) + applied.spell_save_dc;
-    const atk = attackBonus(scores[profile.ability], proficiencyBonus) + applied.spell_attack;
+    const ab = effectiveSpellcastingAbility(c.entity.slug, profile.ability, overrides);
+    const dc = saveDC(scores[ab], proficiencyBonus) + applied.spell_save_dc;
+    const atk = attackBonus(scores[ab], proficiencyBonus) + applied.spell_attack;
     spellcastingClasses.push({
       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,
+      ability: ab,
+      defaultAbility: profile.ability,
+      saveDC: dc,
+      attackBonus: atk,
       casterType: profile.casterType,
       preparation: profile.preparation
     });
     slotInputs.push({ casterType: profile.casterType, level: c.level });
-    limitInputs.push({ classSlug: c.entity.slug, level: c.level, profile, abilityScore: scores[profile.ability] });
+    limitInputs.push({ classSlug: c.entity.slug, level: c.level, profile, abilityScore: scores[ab] });
   }
   const spellcasting = spellcastingClasses.length > 0 ? {
     ability: spellcastingClasses[0].ability,
@@ -587,20 +638,20 @@ function recalc(resolved, registry) {
   const spellLimits = computeSpellLimits(limitInputs);
   const defenses = {
     resistances: dedupeDefenseList([
-      (_K = (_J = resolved.definition.defenses) == null ? void 0 : _J.resistances) != null ? _K : [],
+      (_M = (_L = resolved.definition.defenses) == null ? void 0 : _L.resistances) != null ? _M : [],
       applied.defenses.resistances,
       featureEffects.resistances
     ]),
     immunities: dedupeDefenseList([
-      (_M = (_L = resolved.definition.defenses) == null ? void 0 : _L.immunities) != null ? _M : [],
+      (_O = (_N = resolved.definition.defenses) == null ? void 0 : _N.immunities) != null ? _O : [],
       applied.defenses.immunities
     ]),
     vulnerabilities: dedupeDefenseList([
-      (_O = (_N = resolved.definition.defenses) == null ? void 0 : _N.vulnerabilities) != null ? _O : [],
+      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.vulnerabilities) != null ? _Q : [],
       applied.defenses.vulnerabilities
     ]),
     condition_immunities: dedupeDefenseList([
-      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.condition_immunities) != null ? _Q : [],
+      (_S = (_R = resolved.definition.defenses) == null ? void 0 : _R.condition_immunities) != null ? _S : [],
       applied.defenses.condition_immunities,
       featureEffects.condition_immunities
     ])
@@ -620,6 +671,7 @@ function recalc(resolved, registry) {
       current: resolved.state.hp.current,
       temp: resolved.state.hp.temp
     },
+    hpBreakdown,
     ac,
     speed,
     initiative: init,
@@ -643,7 +695,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: ((_T = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _T : []).map((a) => {
       var _a2;
       const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses];
       return {
@@ -654,10 +706,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: (_U = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _U : {},
+    carriedWeight: (_V = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _V : 0,
+    attunementUsed: (_W = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _W : 0,
+    attunementLimit: (_Y = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _Y : (_X = overrides.attunement_limit) != null ? _X : 3,
     conditionEffects,
     rollModifiers: featureEffects.rollModifiers
   };
@@ -669,6 +721,8 @@ export {
   computeAbilityScores,
   computeProficiencies,
   flattenRaceAsi,
+  hitDiceAverageSum,
+  hpLevelCount,
   initiativeBonus,
   multiclassMaxHP,
   parseDieSize,

package/dist/pc/pc.resolver.js

@@ -9,15 +9,15 @@ import {
   dedupeResolvedSpells,
   resolveOriginFeat,
   stripSlug
-} from "../chunk-R5SQHP2X.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-IXZXFFFW.js";
+} from "../chunk-TNUFPIXI.js";
+import "../chunk-7TEK5KK7.js";
+import "../chunk-6IRYTM5V.js";
 import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-J2RYSZMQ.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 {

package/dist/pc/pc.rest.d.ts

@@ -1,7 +1,7 @@
 import type { EntityRegistry } from "@archivist-gg/core";
 import type { Character, DerivedStats, ResolvedCharacter } from "./pc.types.js";
 export type RestType = "short" | "long";
-export type RestCategoryId = "hp-to-max" | "hd-regain" | "spell-slots" | "pact-slots" | "exhaustion" | `feature:${string}` | `item:${number}`;
+export type RestCategoryId = "hp-to-max" | "hd-regain" | "spell-slots" | "pact-slots" | "exhaustion" | "hp-modifier-reset" | `feature:${string}` | `item:${number}`;
 export interface RestCategory {
     id: RestCategoryId;
     label: string;

package/dist/pc/pc.rest.js

@@ -16,7 +16,7 @@ function findResourceById(resolved, id) {
   return void 0;
 }
 function computeRestPlan(character, resolved, derived, registry, type) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
   const cats = [];
   let hdRegainDist;
   const pact = character.state.spell_slots_pact;
@@ -38,16 +38,25 @@ function computeRestPlan(character, resolved, derived, registry, type) {
         preview: `${character.state.exhaustion} \u2192 ${character.state.exhaustion - 1}`
       });
     }
-    const slotsUsed = Object.values((_a = character.state.spell_slots) != null ? _a : {}).reduce((s, slot) => {
+    const hpModifier = (_b = (_a = character.overrides) == null ? void 0 : _a.hp) == null ? void 0 : _b.modifier;
+    if (hpModifier !== void 0) {
+      const signed = hpModifier > 0 ? `+${hpModifier}` : `${hpModifier}`;
+      cats.push({
+        id: "hp-modifier-reset",
+        label: "Max HP Modifier",
+        preview: `${signed} \u2192 cleared`
+      });
+    }
+    const slotsUsed = Object.values((_c = character.state.spell_slots) != null ? _c : {}).reduce((s, slot) => {
       var _a2;
       return s + ((_a2 = slot.used) != null ? _a2 : 0);
     }, 0);
     if (slotsUsed > 0) {
       cats.push({ id: "spell-slots", label: "Spell Slots", preview: "all reset" });
     }
-    const totalLevel = (_b = resolved.totalLevel) != null ? _b : 0;
+    const totalLevel = (_d = resolved.totalLevel) != null ? _d : 0;
     const regainBudget = Math.max(1, Math.floor(totalLevel / 2));
-    const pools = Object.entries((_c = character.state.hit_dice) != null ? _c : {}).map(([die, hd]) => ({ die, used: hd.used, total: hd.total })).filter((p) => p.used > 0).sort((a, b) => b.used - a.used);
+    const pools = Object.entries((_e = character.state.hit_dice) != null ? _e : {}).map(([die, hd]) => ({ die, used: hd.used, total: hd.total })).filter((p) => p.used > 0).sort((a, b) => b.used - a.used);
     if (pools.length > 0) {
       let left = regainBudget;
       const dist = [];
@@ -68,14 +77,14 @@ function computeRestPlan(character, resolved, derived, registry, type) {
         hdRegainDist = dist.map((d) => ({ die: d.die, targetUsed: d.targetUsed }));
       }
     }
-    for (const [key, fu] of Object.entries((_d = character.state.feature_uses) != null ? _d : {})) {
+    for (const [key, fu] of Object.entries((_f = character.state.feature_uses) != null ? _f : {})) {
       if (fu.used <= 0) continue;
       const res = findResourceById(resolved, key);
-      const reset = (_e = res == null ? void 0 : res.reset) != null ? _e : "long-rest";
+      const reset = (_g = res == null ? void 0 : res.reset) != null ? _g : "long-rest";
       if (reset !== "short-rest" && reset !== "long-rest" && reset !== "dawn" && reset !== "dusk") continue;
       cats.push({
         id: `feature:${key}`,
-        label: (_f = res == null ? void 0 : res.label) != null ? _f : key,
+        label: (_h = res == null ? void 0 : res.label) != null ? _h : key,
         preview: `${fu.used}/${fu.max} restored`
       });
     }
@@ -95,13 +104,13 @@ function computeRestPlan(character, resolved, derived, registry, type) {
     });
   }
   if (type === "short") {
-    for (const [key, fu] of Object.entries((_g = character.state.feature_uses) != null ? _g : {})) {
+    for (const [key, fu] of Object.entries((_i = character.state.feature_uses) != null ? _i : {})) {
       if (fu.used <= 0) continue;
       const res = findResourceById(resolved, key);
-      if (((_h = res == null ? void 0 : res.reset) != null ? _h : "long-rest") !== "short-rest") continue;
+      if (((_j = res == null ? void 0 : res.reset) != null ? _j : "long-rest") !== "short-rest") continue;
       cats.push({
         id: `feature:${key}`,
-        label: (_i = res == null ? void 0 : res.label) != null ? _i : key,
+        label: (_k = res == null ? void 0 : res.label) != null ? _k : key,
         preview: `${fu.used}/${fu.max} restored`
       });
     }
@@ -120,7 +129,7 @@ function computeRestPlan(character, resolved, derived, registry, type) {
       });
     });
   }
-  const hdAvailable = type === "short" ? Object.entries((_j = character.state.hit_dice) != null ? _j : {}).filter(([, hd]) => hd.used < hd.total).map(([die, hd]) => ({ die, remaining: hd.total - hd.used })) : [];
+  const hdAvailable = type === "short" ? Object.entries((_l = character.state.hit_dice) != null ? _l : {}).filter(([, hd]) => hd.used < hd.total).map(([die, hd]) => ({ die, remaining: hd.total - hd.used })) : [];
   return { type, categories: cats, hdAvailable, hdRegainDist };
 }
 export {

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

@@ -221,14 +221,20 @@ export declare const characterSchema: z.ZodObject<{
         }, z.core.$strip>>;
         hp: z.ZodOptional<z.ZodObject<{
             max: z.ZodOptional<z.ZodNumber>;
+            rolled: z.ZodOptional<z.ZodNumber>;
+            modifier: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         ac: z.ZodOptional<z.ZodNumber>;
         speed: z.ZodOptional<z.ZodNumber>;
         initiative: z.ZodOptional<z.ZodNumber>;
-        spellcasting: z.ZodOptional<z.ZodObject<{
-            saveDC: z.ZodOptional<z.ZodNumber>;
-            attackBonus: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
+        spellcasting_ability_by_class: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>>;
         spellcasting_ability: z.ZodOptional<z.ZodEnum<{
             str: "str";
             dex: "dex";

package/dist/pc/pc.schema.js

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

package/dist/pc/pc.slotting.js

@@ -6,9 +6,9 @@ import {
   isShieldArmor,
   isWeaponEntity,
   resolveEntityForEntry
-} from "../chunk-UC4FE5X3.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
+} from "../chunk-N6N74K6X.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
 export {
   defaultSlotForType,
   effectiveArmor,

package/dist/pc/pc.spellcasting.d.ts

@@ -1,5 +1,5 @@
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { KnownSpellEntry, ResolvedClass } from "./pc.types.js";
+import type { CharacterOverrides, KnownSpellEntry, ResolvedClass } from "./pc.types.js";
 import type { CasterType } from "@archivist-gg/dnd5e/class/class.types";
 export interface SpellcastingProfile {
     ability: Ability;
@@ -18,6 +18,10 @@ export interface SpellcastingProfile {
  * non-casters. No hardcoded class knowledge — everything comes from the data.
  */
 export declare function resolveSpellcasting(rc: ResolvedClass): SpellcastingProfile | null;
+/** The ability a class actually casts with: a per-class override wins, else the
+ *  data ability from resolveSpellcasting. `dataAbility` is non-nullable by
+ *  contract: resolve caster-ness (a non-null SpellcastingProfile) BEFORE calling. */
+export declare function effectiveSpellcastingAbility(classSlug: string, dataAbility: Ability, overrides: CharacterOverrides): Ability;
 export interface NormalizedKnownSpell {
     slug: string;
     classSlug: string | null;

package/dist/pc/pc.spellcasting.js

@@ -1,16 +1,18 @@
 import {
   computeSpellLimits,
   deriveSpellSlots,
+  effectiveSpellcastingAbility,
   normalizeKnownSpell,
   resolveSpellcasting
-} from "../chunk-IXZXFFFW.js";
+} from "../chunk-6IRYTM5V.js";
 import "../chunk-5XUXXAQJ.js";
-import "../chunk-J2RYSZMQ.js";
+import "../chunk-VTTA2ALZ.js";
 import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   computeSpellLimits,
   deriveSpellSlots,
+  effectiveSpellcastingAbility,
   normalizeKnownSpell,
   resolveSpellcasting
 };

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

@@ -120,14 +120,13 @@ export interface CharacterOverrides {
     }>;
     hp?: {
         max?: number;
+        rolled?: number;
+        modifier?: number;
     };
     ac?: number;
     speed?: number;
     initiative?: number;
-    spellcasting?: {
-        saveDC?: number;
-        attackBonus?: number;
-    };
+    spellcasting_ability_by_class?: Partial<Record<string, Ability>>;
     /** 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. */
@@ -339,6 +338,27 @@ export interface ACTerm {
     amount: number;
     kind: "armor" | "shield" | "item" | "unarmored" | "override" | "dex" | "ability" | "feature";
 }
+/** Structured max-HP math for the Max HP modal. Spec: P5 2026-07-21. */
+export interface HPBreakdown {
+    diceSum: number;
+    diceSource: "rolled" | "average";
+    averageDiceSum: number;
+    conMod: number;
+    conLevels: number;
+    clampApplied: boolean;
+    perLevelTerms: {
+        label: string;
+        perLevel: number;
+        levels: number;
+        total: number;
+    }[];
+    modifier: number | null;
+    exhaustionMultiplier: number;
+    exhaustionLevel: number;
+    derivedMax: number;
+    override: number | null;
+    final: number;
+}
 /** 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
@@ -353,6 +373,10 @@ export interface AttackRow {
     id: string;
     name: string;
     range?: string;
+    /** 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;
     toHit: number;
     damageDice: string;
     damageType: string;
@@ -529,6 +553,7 @@ export interface DerivedStats {
         condition_immunities: string[];
     };
     acBreakdown: ACTerm[];
+    hpBreakdown: HPBreakdown;
     acInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
     /** Situational saving-throw bonuses (e.g. +1 vs spells) for save tooltips. */
     savesInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
@@ -557,6 +582,7 @@ export interface SpellcastingClassInfo {
     classSlug: string;
     className: string;
     ability: Ability;
+    defaultAbility: Ability;
     saveDC: number;
     attackBonus: number;
     casterType: "full" | "half" | "third" | "pact";

package/dist/spell/spell.access.js

@@ -1,6 +1,6 @@
 import {
   baseClassName
-} from "../chunk-J2RYSZMQ.js";
+} from "../chunk-VTTA2ALZ.js";
 
 // src/spell/spell.access.ts
 function classSpellCandidates(registry, classSlugs, maxLevel, knownSlugs, showAll = false, query = "") {

package/dist/types/choice.d.ts

@@ -3,6 +3,11 @@ import type { FeatureEffect } from "./feature-effect.js";
 export type Ability = keyof Abilities;
 export type SkillSlug = "acrobatics" | "animal-handling" | "arcana" | "athletics" | "deception" | "history" | "insight" | "intimidation" | "investigation" | "medicine" | "nature" | "perception" | "performance" | "persuasion" | "religion" | "sleight-of-hand" | "stealth" | "survival";
 export declare const ALL_SKILL_SLUGS: SkillSlug[];
+/** The SRD language set: 8 standard + 8 exotic. Authoritative and reused as
+ *  KNOWN_LANGUAGES by the proficiency aggregate; slugs are edition-agnostic. */
+export declare const STANDARD_LANGUAGES: string[];
+export declare const EXOTIC_LANGUAGES: string[];
+export declare const ALL_LANGUAGES: string[];
 export type FeatCategory = "origin" | "general" | "fighting-style" | "epic-boon";
 /** Closed, enumerated registry filter — YAML can never express a query the
  *  engine would apply unsafely. `"self"` resolves against the owning

package/dist/types/choice.js

@@ -1,6 +1,12 @@
 import {
-  ALL_SKILL_SLUGS
-} from "../chunk-BH6AMZVY.js";
+  ALL_LANGUAGES,
+  ALL_SKILL_SLUGS,
+  EXOTIC_LANGUAGES,
+  STANDARD_LANGUAGES
+} from "../chunk-7TEK5KK7.js";
 export {
-  ALL_SKILL_SLUGS
+  ALL_LANGUAGES,
+  ALL_SKILL_SLUGS,
+  EXOTIC_LANGUAGES,
+  STANDARD_LANGUAGES
 };