@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/pc/pc.recalc.js

@@ -4,47 +4,88 @@ import {
 import {
   collectChosenAbilityPoints,
   collectChosenProficiencies
-} from "../chunk-5MZSB6OM.js";
-import "../chunk-BH6AMZVY.js";
+} from "../chunk-XQCSGNXE.js";
+import {
+  resourceLevelFor
+} from "../chunk-UXPGW4TI.js";
 import {
   computeSpellLimits,
   deriveSpellSlots,
+  effectiveSpellcastingAbility,
   resolveSpellcasting
-} from "../chunk-M2EMFD6S.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-JEYQU3JT.js";
+} from "../chunk-DPUJDOKV.js";
+import "../chunk-O4SRD3J5.js";
+import "../chunk-PP2UHLBA.js";
+import {
+  diceColumnAt,
+  unarmedDieColumnFor
+} from "../chunk-IUAAXXNO.js";
+import "../chunk-YHYTW5QA.js";
+import "../chunk-MI7P3NX3.js";
+import "../chunk-PVCEA4HZ.js";
+import {
+  toDefenseSlug
+} from "../chunk-XJ2F2WO6.js";
 import {
+  buildUnarmedRow,
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-EMOORSQ7.js";
-import "../chunk-353WXS6S.js";
-import "../chunk-N6N74K6X.js";
+} from "../chunk-OSQFPGLM.js";
+import "../chunk-UIRMA5KM.js";
+import "../chunk-UBBKSYBY.js";
 import {
-  computeFeatureEffects
-} from "../chunk-AIRFC5NQ.js";
+  assembleEffectFeatures,
+  computeFeatureEffects,
+  foldsNow,
+  selfEffectsOf
+} from "../chunk-JJ46T5XX.js";
+import "../chunk-TOM66P2P.js";
+import "../chunk-KU3YLF6D.js";
+import "../chunk-RLGQ5PZZ.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
-import "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-WXWPK3LI.js";
+import "../chunk-6X4KUDMU.js";
+import "../chunk-YBLDE5CG.js";
+import {
+  evaluateMaxFormula,
+  isValidMaxFormula
+} from "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
+import "../chunk-OZP6JFGT.js";
+import "../chunk-VQAXTIBW.js";
 import {
   abilityModifier,
   attackBonus,
+  isCanonicalDamageType,
+  isChosenDamageType,
   passive,
   passivePerception,
   proficiencyFromLevel,
   saveDC,
   savingThrow,
   skillBonus
-} from "../chunk-NAEPSZAM.js";
+} from "../chunk-PDJSUH24.js";
 import {
   ABILITY_KEYS,
   ALL_SKILLS,
   SKILL_ABILITY
-} from "../chunk-WP2CX2JO.js";
+} from "../chunk-WELIKLZF.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-UA5KS2PL.js";
 
 // src/pc/pc.recalc.ts
+var WEAPON_CATEGORY_WORDS = /* @__PURE__ */ new Set([
+  "simple",
+  "martial",
+  "simple-melee",
+  "simple-ranged",
+  "martial-melee",
+  "martial-ranged",
+  "natural"
+]);
 function phbAverageForDie(hitDieStr) {
   const n = parseDieSize(hitDieStr);
   if (n == null) return 4;
@@ -86,7 +127,9 @@ function collectClassAsiBranch(resolved) {
   const out = {};
   for (const c of resolved.classes) {
     for (const [, choice] of Object.entries(c.choices)) {
-      const asi = choice == null ? void 0 : choice.asi;
+      const block = choice;
+      if (typeof (block == null ? void 0 : block.feat) === "string") continue;
+      const asi = block == null ? void 0 : block.asi;
       if (!asi) continue;
       for (const ab of ABILITY_KEYS) {
         const v = asi[ab];
@@ -96,8 +139,8 @@ function collectClassAsiBranch(resolved) {
   }
   return out;
 }
-function abilityBonusBreakdown(resolved) {
-  var _a, _b, _c, _d, _e, _f;
+function abilityBonusBreakdown(resolved, featureEffects) {
+  var _a, _b, _c, _d, _e, _f, _g;
   const race = flattenRaceAsi(resolved.race);
   const origin = collectChosenAbilityPoints(resolved);
   const sub = subraceAsi(resolved);
@@ -114,7 +157,7 @@ function abilityBonusBreakdown(resolved) {
       const bonus = (_d = f.ability_bonuses) == null ? void 0 : _d[ab];
       if (typeof bonus === "number") feat += bonus;
     }
-    out[ab] = { species, background: (_e = origin.background[ab]) != null ? _e : 0, class: (_f = classAsi[ab]) != null ? _f : 0, feat };
+    out[ab] = { species, background: (_e = origin.background[ab]) != null ? _e : 0, class: ((_f = classAsi[ab]) != null ? _f : 0) + ((_g = featureEffects == null ? void 0 : featureEffects.ability_bonus[ab]) != null ? _g : 0), feat };
   }
   return out;
 }
@@ -149,65 +192,123 @@ function hpLevelCount(classes) {
 function multiclassMaxHP(classes, conMod) {
   return Math.max(1, hitDiceAverageSum(classes) + conMod * hpLevelCount(classes));
 }
+function resolveRiderAmount(amount, bindings) {
+  if (!amount.includes("{")) return amount;
+  const formula = amount.replace(/\{prof_bonus\}/g, "{prof}");
+  if (!isValidMaxFormula(formula)) return amount;
+  return String(evaluateMaxFormula(formula, bindings));
+}
+function resolveDamageRider(rider, rowDamageType, bindings) {
+  const out = { ...rider, amount: resolveRiderAmount(rider.amount, bindings) };
+  if (rider.damage_type !== void 0 && !isChosenDamageType(rider.damage_type)) {
+    const resolved = isCanonicalDamageType(rider.damage_type) ? rider.damage_type : rowDamageType;
+    if (resolved) out.damage_type = resolved;
+    else delete out.damage_type;
+  }
+  return out;
+}
 function unarmoredAC(resolved, mods, warnings) {
   return unarmoredACBreakdown(resolved, mods, warnings).total;
 }
-function unarmoredACBreakdown(resolved, mods, warnings) {
-  var _a, _b, _c, _d, _e, _f;
+function unarmoredACBreakdown(resolved, mods, warnings, shieldBonus = 0) {
+  var _a, _b, _c, _d, _e;
   const baseTerms = [
     { source: "Unarmored", amount: 10, kind: "unarmored" },
     { source: "DEX modifier", amount: mods.dex, kind: "dex" }
   ];
+  const { activeBuffs } = assembleEffectFeatures(resolved);
+  const candidates = [
+    { total: 10 + mods.dex, terms: baseTerms, shieldAllowed: true }
+  ];
   for (const rf of resolved.features) {
-    const eff = ((_a = rf.feature.effects) != null ? _a : []).find((e) => e.kind === "unarmored-ac");
-    if (eff && eff.kind === "unarmored-ac") {
-      const base = (_b = eff.base) != null ? _b : 10;
-      const terms = [
-        { source: "Unarmored", amount: base, kind: "unarmored" },
-        { source: "DEX modifier", amount: mods.dex, kind: "dex" }
-      ];
-      let total = base + mods.dex;
+    if (!foldsNow(rf, activeBuffs)) continue;
+    for (const eff of selfEffectsOf(rf.feature)) {
+      if (eff.kind !== "unarmored-ac") continue;
+      const base = (_a = eff.base) != null ? _a : 10;
+      const terms = [{ source: "Unarmored", amount: base, kind: "unarmored" }];
+      let total = base;
       for (const ab of eff.abilities) {
-        if (ab === "dex") continue;
-        terms.push({ source: `${ab.toUpperCase()} modifier (${(_c = rf.feature.name) != null ? _c : "Unarmored"})`, amount: mods[ab], kind: "ability" });
+        terms.push(ab === "dex" ? { source: "DEX modifier", amount: mods.dex, kind: "dex" } : { source: `${ab.toUpperCase()} modifier (${(_b = rf.feature.name) != null ? _b : "Unarmored"})`, amount: mods[ab], kind: "ability" });
         total += mods[ab];
       }
-      return { total, terms };
+      candidates.push({ total, terms, shieldAllowed: eff.allow_shield === true });
     }
   }
+  if (candidates.length > 1) {
+    const applied = (c) => c.total + (c.shieldAllowed ? shieldBonus : 0);
+    let best = candidates[0];
+    for (const c of candidates) if (applied(c) > applied(best)) best = c;
+    return best;
+  }
   for (const rf of resolved.features) {
     const feat = rf.feature;
-    if ((_d = feat.unarmored_defense) == null ? void 0 : _d.ability) {
+    if ((_c = feat.unarmored_defense) == null ? void 0 : _c.ability) {
       const ab = feat.unarmored_defense.ability;
-      const amt = (_e = mods[ab]) != null ? _e : 0;
+      const amt = (_d = mods[ab]) != null ? _d : 0;
       const terms = [
         ...baseTerms,
         { source: `${ab.toUpperCase()} modifier (Unarmored Defense)`, amount: amt, kind: "ability" }
       ];
-      return { total: 10 + mods.dex + amt, terms };
+      return { total: 10 + mods.dex + amt, terms, shieldAllowed: true };
     }
   }
   for (const rf of resolved.features) {
-    const name = ((_f = rf.feature.name) != null ? _f : "").toLowerCase();
+    const name = ((_e = rf.feature.name) != null ? _e : "").toLowerCase();
     if (!/unarmored\s*defense/.test(name)) continue;
     if (rf.source.kind === "class" && rf.source.slug.includes("monk")) {
-      warnings.push(`Unarmored Defense detected by name on ${rf.source.slug}; populate unarmored_defense:{ability:wis} flag for accuracy.`);
       const terms = [
         ...baseTerms,
         { source: "WIS modifier (Unarmored Defense)", amount: mods.wis, kind: "ability" }
       ];
-      return { total: 10 + mods.dex + mods.wis, terms };
+      return { total: 10 + mods.dex + mods.wis, terms, shieldAllowed: true };
     }
     if (rf.source.kind === "class" && rf.source.slug.includes("barbarian")) {
-      warnings.push(`Unarmored Defense detected by name on ${rf.source.slug}; populate unarmored_defense:{ability:con} flag for accuracy.`);
       const terms = [
         ...baseTerms,
         { source: "CON modifier (Unarmored Defense)", amount: mods.con, kind: "ability" }
       ];
-      return { total: 10 + mods.dex + mods.con, terms };
+      return { total: 10 + mods.dex + mods.con, terms, shieldAllowed: true };
     }
   }
-  return { total: 10 + mods.dex, terms: baseTerms };
+  return { total: 10 + mods.dex, terms: baseTerms, shieldAllowed: true };
+}
+function resolveUnarmedStrike(resolved) {
+  var _a, _b, _c;
+  const dice = [];
+  const abilities = /* @__PURE__ */ new Set();
+  const classOf = (rf) => rf.source.kind === "class" ? resolved.classes.find((c) => {
+    var _a2;
+    return ((_a2 = c.entity) == null ? void 0 : _a2.slug) === rf.source.slug;
+  }) : void 0;
+  const readDie = (rf, d) => {
+    var _a2, _b2;
+    if (typeof d === "string") return d;
+    if (!d) return void 0;
+    const cls = classOf(rf);
+    return cls ? (_b2 = diceColumnAt((_a2 = cls.entity) == null ? void 0 : _a2.table, cls.level, d.column)) != null ? _b2 : void 0 : void 0;
+  };
+  for (const rf of resolved.features) {
+    const authored = selfEffectsOf(rf.feature).filter((e) => e.kind === "unarmed-strike");
+    for (const e of authored) {
+      const d2 = readDie(rf, e.dice);
+      if (d2) dice.push(d2);
+      for (const ab of (_a = e.abilities) != null ? _a : []) abilities.add(ab);
+    }
+    if (authored.length || rf.source.kind !== "class") continue;
+    const slug = ((_c = (_b = rf.feature.id) != null ? _b : rf.feature.name) != null ? _c : "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+    const column = unarmedDieColumnFor(slug);
+    if (!column) continue;
+    const d = readDie(rf, { column });
+    if (!d) continue;
+    dice.push(d);
+    abilities.add("dex");
+  }
+  const avg = (d) => {
+    const m = /^(\d+)d(\d+)$/i.exec(d);
+    return m ? Number(m[1]) * (Number(m[2]) + 1) / 2 : 1;
+  };
+  const best = dice.sort((a, b) => avg(b) - avg(a))[0];
+  return { ...best ? { dice: best } : {}, ...abilities.size ? { abilities: [...abilities] } : {} };
 }
 function initiativeBonus(dexMod, feats, edition) {
   let bonus = dexMod;
@@ -308,28 +409,67 @@ 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);
 }
-function dedupeDefenseList(lists) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const list of lists) {
-    for (const v of list) {
-      const key = v.trim().toLowerCase();
-      if (!key || seen.has(key)) continue;
-      seen.add(key);
-      out.push(v);
+var ORIGIN_RANK = { manual: 0, equipment: 1, grant: 2 };
+function composeDefenseEntries(manual, equipment, grants) {
+  var _a;
+  const byValue = /* @__PURE__ */ new Map();
+  const consider = (list, origin) => {
+    for (const raw of list) {
+      const value = toDefenseSlug(raw);
+      if (!value) continue;
+      const existing = byValue.get(value);
+      if (!existing) {
+        byValue.set(value, { value, label: raw.trim(), origin });
+        continue;
+      }
+      if (ORIGIN_RANK[origin] > ORIGIN_RANK[existing.origin]) existing.origin = origin;
     }
+  };
+  consider(manual, "manual");
+  consider(equipment, "equipment");
+  for (const g of grants) {
+    const value = toDefenseSlug(g.value);
+    if (!value) continue;
+    const existing = byValue.get(value);
+    if (!existing) {
+      byValue.set(value, {
+        value,
+        label: g.value.trim(),
+        origin: "grant",
+        sources: [...g.sources],
+        ...g.condition ? { condition: g.condition } : {}
+      });
+      continue;
+    }
+    if (ORIGIN_RANK.grant > ORIGIN_RANK[existing.origin]) existing.origin = "grant";
+    const sources = (_a = existing.sources) != null ? _a : existing.sources = [];
+    for (const src of g.sources) if (!sources.includes(src)) sources.push(src);
+    if (!existing.condition && g.condition) existing.condition = g.condition;
   }
-  return out;
+  return [...byValue.values()];
+}
+function suppress(resolved, bucket, entries) {
+  var _a, _b, _c, _d, _e;
+  const suppressed = new Set(
+    ((_e = (_d = (_c = (_b = (_a = resolved.definition) == null ? void 0 : _a.overrides) == null ? void 0 : _b.defenses) == null ? void 0 : _c[bucket]) == null ? void 0 : _d.remove) != null ? _e : []).map(toDefenseSlug)
+  );
+  return entries.filter((e) => !suppressed.has(e.value));
 }
 function computeProficiencies(resolved) {
   var _a, _b, _c, _d, _e, _f, _g;
@@ -340,31 +480,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 {
@@ -376,28 +516,12 @@ 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, _X, _Y, _Z, __, _$, _aa;
+  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;
   const warnings = [];
   const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
   const chosenProfs = collectChosenProficiencies(resolved);
-  const activeBuffs = new Set((_b = resolved.state.active_buffs) != null ? _b : []);
-  const buffFeatures = [];
-  const pushBoon = (item, pool) => {
-    var _a2, _b2, _c2, _d2, _e2, _f2;
-    const e = item.entity;
-    if (!e || ((_b2 = (_a2 = e.effects) == null ? void 0 : _a2.length) != null ? _b2 : 0) === 0) return;
-    buffFeatures.push({
-      feature: { id: item.slug, name: e.name, activatable: (_c2 = e.activatable) != null ? _c2 : false, effects: e.effects },
-      // source is inert for the fold; attribute to the pool's owning class
-      // (never a hardcoded class) so the generic engine carries no homebrew name.
-      source: { kind: "class", slug: (_f2 = (_e2 = (_d2 = resolved.classes[pool.classIndex]) == null ? void 0 : _d2.entity) == null ? void 0 : _e2.slug) != null ? _f2 : pool.id, level: pool.anchorLevel }
-    });
-  };
-  for (const pool of (_c = resolved.pools) != null ? _c : []) {
-    for (const sel of (_d = pool.selected) != null ? _d : []) pushBoon(sel, pool);
-    for (const g of (_e = pool.grants) != null ? _e : []) pushBoon(g, pool);
-  }
-  const featureEffects = computeFeatureEffects([...resolved.features, ...buffFeatures], { activeBuffs });
+  const { features: effectFeatures, activeBuffs } = assembleEffectFeatures(resolved);
+  const featureEffects = computeFeatureEffects(effectFeatures, { activeBuffs, levelFor: (src) => resourceLevelFor(src, resolved) });
   const profsForApply = computeProficiencies(resolved);
   for (const t of chosenProfs.tools) {
     if (!profsForApply.tools.specific.includes(t)) profsForApply.tools.specific.push(t);
@@ -405,6 +529,9 @@ function recalc(resolved, registry) {
   for (const l of chosenProfs.languages) {
     if (!profsForApply.languages.includes(l)) profsForApply.languages.push(l);
   }
+  for (const w of chosenProfs.weapons) {
+    if (!profsForApply.weapons.specific.includes(w)) profsForApply.weapons.specific.push(w);
+  }
   for (const t of featureEffects.proficiencies.tools) {
     if (!profsForApply.tools.specific.includes(t)) profsForApply.tools.specific.push(t);
   }
@@ -416,6 +543,9 @@ function recalc(resolved, registry) {
   }
   for (const w of featureEffects.proficiencies.weapons) {
     if (!profsForApply.weapons.categories.includes(w)) profsForApply.weapons.categories.push(w);
+    if (!WEAPON_CATEGORY_WORDS.has(w) && !profsForApply.weapons.specific.includes(w)) {
+      profsForApply.weapons.specific.push(w);
+    }
   }
   profsForApply.languages.sort();
   const applied = registry ? computeAppliedBonuses(resolved, profsForApply, registry, warnings) : emptyAppliedBonuses();
@@ -432,7 +562,7 @@ function recalc(resolved, registry) {
   const scores = { ...baseScores };
   for (const ab of ABILITY_KEYS) {
     const bonus = applied.ability_bonuses[ab];
-    if (typeof bonus === "number") scores[ab] += bonus;
+    scores[ab] += (typeof bonus === "number" ? bonus : 0) + ((_b = featureEffects.ability_bonus[ab]) != null ? _b : 0);
   }
   for (const ab of ABILITY_KEYS) {
     const stat = applied.ability_statics[ab];
@@ -459,31 +589,32 @@ function recalc(resolved, registry) {
     resolved.definition.edition,
     scores
   );
-  const firstClass = (_g = (_f = resolved.classes[0]) == null ? void 0 : _f.entity) != null ? _g : null;
-  const saveProfs = new Set((_h = firstClass == null ? void 0 : firstClass.saving_throws) != null ? _h : []);
+  const firstClass = (_d = (_c = resolved.classes[0]) == null ? void 0 : _c.entity) != null ? _d : null;
+  const saveProfs = new Set((_e = firstClass == null ? void 0 : firstClass.saving_throws) != null ? _e : []);
   for (const ab of featureEffects.proficiencies.saves) saveProfs.add(ab);
+  for (const ab of chosenProfs.saves) saveProfs.add(ab);
   const saves = {};
   for (const ab of ABILITY_KEYS) {
-    const override = (_i = overrides.saves) == null ? void 0 : _i[ab];
-    const prof = (_j = override == null ? void 0 : override.proficient) != null ? _j : saveProfs.has(ab);
+    const override = (_f = overrides.saves) == null ? void 0 : _f[ab];
+    const prof = (_g = override == null ? void 0 : override.proficient) != null ? _g : saveProfs.has(ab);
     const derivedBonus = savingThrow(scores[ab], prof, proficiencyBonus) + applied.save_bonus + conditionEffects.d20_test_penalty;
-    const bonus = (_k = override == null ? void 0 : override.bonus) != null ? _k : derivedBonus;
+    const bonus = (_h = override == null ? void 0 : override.bonus) != null ? _h : derivedBonus;
     saves[ab] = { bonus, proficient: prof };
   }
   const profSet = /* @__PURE__ */ new Set([
     ...resolved.definition.skills.proficient,
-    ...(_m = (_l = resolved.background) == null ? void 0 : _l.skill_proficiencies) != null ? _m : [],
+    ...(_j = (_i = resolved.background) == null ? void 0 : _i.skill_proficiencies) != null ? _j : [],
     ...chosenProfs.skills,
     ...featureEffects.proficiencies.skills
   ]);
-  const expSet = /* @__PURE__ */ new Set([...resolved.definition.skills.expertise, ...chosenProfs.expertise]);
+  const expSet = /* @__PURE__ */ new Set([...resolved.definition.skills.expertise, ...chosenProfs.expertise, ...featureEffects.proficiencies.skillExpertise]);
   const skills = {};
   for (const skill of ALL_SKILLS) {
     const skillKey = skillSlugFromDisplay(skill);
     const ab = SKILL_ABILITY[skillSlugToAbilityLookup(skillKey)];
-    const override = (_n = overrides.skills) == null ? void 0 : _n[skillKey];
-    const tri = (_o = override == null ? void 0 : override.proficiency) != null ? _o : expSet.has(skillKey) ? "expertise" : profSet.has(skillKey) ? "proficient" : "none";
-    const bonus = (_p = override == null ? void 0 : override.bonus) != null ? _p : skillBonus(scores[ab], tri, proficiencyBonus) + conditionEffects.d20_test_penalty;
+    const override = (_k = overrides.skills) == null ? void 0 : _k[skillKey];
+    const tri = (_l = override == null ? void 0 : override.proficiency) != null ? _l : expSet.has(skillKey) ? "expertise" : profSet.has(skillKey) ? "proficient" : "none";
+    const bonus = (_m = override == null ? void 0 : override.bonus) != null ? _m : skillBonus(scores[ab], tri, proficiencyBonus) + conditionEffects.d20_test_penalty;
     skills[skillKey] = {
       bonus,
       proficiency: tri,
@@ -494,12 +625,12 @@ function recalc(resolved, registry) {
   const investigationTri = skills.investigation.proficiency;
   const insightTri = skills.insight.proficiency;
   const passives = {
-    perception: (_r = (_q = overrides.passives) == null ? void 0 : _q.perception) != null ? _r : passivePerception(scores.wis, perceptionTri, proficiencyBonus),
-    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)
+    perception: (_o = (_n = overrides.passives) == null ? void 0 : _n.perception) != null ? _o : passivePerception(scores.wis, perceptionTri, proficiencyBonus),
+    investigation: (_q = (_p = overrides.passives) == null ? void 0 : _p.investigation) != null ? _q : passive(scores.int, investigationTri, proficiencyBonus),
+    insight: (_s = (_r = overrides.passives) == null ? void 0 : _r.insight) != null ? _s : passive(scores.wis, insightTri, proficiencyBonus)
   };
-  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 hpRolled = (_u = (_t = overrides.hp) == null ? void 0 : _t.rolled) != null ? _u : null;
+  const hpModifier = (_w = (_v = overrides.hp) == null ? void 0 : _v.modifier) != null ? _w : null;
   const averageDiceSum = hitDiceAverageSum(resolved.classes);
   const conLevels = hpLevelCount(resolved.classes);
   const diceSum = hpRolled != null ? hpRolled : averageDiceSum;
@@ -507,7 +638,7 @@ function recalc(resolved, registry) {
   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 hpMax = (_y = (_x = overrides.hp) == null ? void 0 : _x.max) != null ? _y : hpMaxAfterConditions;
   const hpBreakdown = {
     diceSum,
     diceSource: hpRolled != null ? "rolled" : "average",
@@ -525,23 +656,20 @@ function recalc(resolved, registry) {
     exhaustionMultiplier: conditionEffects.hp_max_multiplier,
     exhaustionLevel: conditionEffects.exhaustion_level,
     derivedMax: hpMaxAfterConditions,
-    override: (_D = (_C = overrides.hp) == null ? void 0 : _C.max) != null ? _D : null,
+    override: (_A = (_z = overrides.hp) == null ? void 0 : _z.max) != null ? _A : 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 featureAcTermsFor = (hasArmor) => featureEffects.ac_terms.filter((t) => !t.requires_armor || hasArmor).map((t) => ({ source: t.label, amount: t.value, kind: "feature", condition: t.condition }));
   const sumTerms = (terms) => terms.reduce((s, t) => s + t.amount, 0);
   const weaponAbilities = [...featureEffects.weaponAbilities];
-  const wantsSpellcasting = resolved.features.some((rf) => {
-    var _a2;
-    return ((_a2 = rf.feature.effects) != null ? _a2 : []).some((e) => e.kind === "weapon-ability" && e.ability === "spellcasting");
-  });
+  const wantsSpellcasting = resolved.features.some((rf) => selfEffectsOf(rf.feature).some((e) => e.kind === "weapon-ability" && e.ability === "spellcasting"));
   if (wantsSpellcasting) {
     let primaryCasterAbility = null;
     for (const c of resolved.classes) {
       if (!c.entity) continue;
       const profile = resolveSpellcasting(c);
       if (profile) {
-        primaryCasterAbility = profile.ability;
+        primaryCasterAbility = effectiveSpellcastingAbility(c.entity.slug, profile.ability, overrides);
         break;
       }
     }
@@ -552,16 +680,17 @@ function recalc(resolved, registry) {
   let acBreakdownDerived = [];
   let acInformationalDerived = [];
   if (registry) {
-    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_E = resolved.weaponMasteries) != null ? _E : []);
+    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_B = resolved.weaponMasteries) != null ? _B : []);
     if (derivedEquipment.equippedSlots.armor) {
       const featTerms = featureAcTermsFor(true);
       acDerived = derivedEquipment.ac + sumTerms(featTerms);
       acBreakdownDerived = [...derivedEquipment.acBreakdown, ...featTerms];
       acInformationalDerived = derivedEquipment.acInformational;
     } else {
-      const { total: unarmored, terms: unarmoredTerms } = unarmoredACBreakdown(resolved, mods, warnings);
+      const shieldBonus = derivedEquipment.acBreakdown.filter((b) => b.kind === "shield").reduce((sum, b) => sum + b.amount, 0);
+      const { total: unarmored, terms: unarmoredTerms, shieldAllowed } = unarmoredACBreakdown(resolved, mods, warnings, shieldBonus);
       const additive = derivedEquipment.acBreakdown.filter(
-        (b) => b.kind === "item" || b.kind === "override" || b.kind === "shield"
+        (b) => b.kind === "item" || b.kind === "override" || b.kind === "shield" && shieldAllowed
       );
       const featTerms = featureAcTermsFor(false);
       const additiveSum = additive.reduce((sum, b) => sum + b.amount, 0);
@@ -575,16 +704,16 @@ function recalc(resolved, registry) {
     acDerived = total + sumTerms(featTerms);
     acBreakdownDerived = [...terms, ...featTerms];
   }
-  const ac = (_F = overrides.ac) != null ? _F : acDerived;
+  const ac = (_C = overrides.ac) != null ? _C : 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 = (_G = overrides.speed) != null ? _G : conditionSpeed;
+  const speed = (_D = overrides.speed) != null ? _D : conditionSpeed;
   if (!resolved.race) warnings.push("No race resolved; speed defaulted to 30.");
-  const init = (_H = overrides.initiative) != null ? _H : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
+  const init = (_E = overrides.initiative) != null ? _E : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
   const senses = {
-    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),
+    darkvision: Math.max((_H = (_G = (_F = resolved.race) == null ? void 0 : _F.vision) == null ? void 0 : _G.darkvision) != null ? _H : 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)
@@ -596,19 +725,22 @@ 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: (_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,
+      ability: ab,
+      defaultAbility: profile.ability,
+      saveDC: dc,
+      attackBonus: atk,
       casterType: profile.casterType,
-      preparation: profile.preparation
+      preparation: profile.preparation,
+      spellList: profile.spellList
     });
     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,
@@ -627,24 +759,39 @@ function recalc(resolved, registry) {
   const derivedSlots = deriveSpellSlots(slotInputs);
   const spellLimits = computeSpellLimits(limitInputs);
   const defenses = {
-    resistances: dedupeDefenseList([
-      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.resistances) != null ? _Q : [],
+    resistances: suppress(resolved, "resistances", composeDefenseEntries(
+      (_J = (_I = resolved.definition.defenses) == null ? void 0 : _I.resistances) != null ? _J : [],
       applied.defenses.resistances,
       featureEffects.resistances
-    ]),
-    immunities: dedupeDefenseList([
-      (_S = (_R = resolved.definition.defenses) == null ? void 0 : _R.immunities) != null ? _S : [],
-      applied.defenses.immunities
-    ]),
-    vulnerabilities: dedupeDefenseList([
-      (_U = (_T = resolved.definition.defenses) == null ? void 0 : _T.vulnerabilities) != null ? _U : [],
-      applied.defenses.vulnerabilities
-    ]),
-    condition_immunities: dedupeDefenseList([
-      (_W = (_V = resolved.definition.defenses) == null ? void 0 : _V.condition_immunities) != null ? _W : [],
+    )),
+    immunities: suppress(resolved, "immunities", composeDefenseEntries(
+      (_L = (_K = resolved.definition.defenses) == null ? void 0 : _K.immunities) != null ? _L : [],
+      applied.defenses.immunities,
+      featureEffects.immunities
+    )),
+    vulnerabilities: suppress(resolved, "vulnerabilities", composeDefenseEntries(
+      (_N = (_M = resolved.definition.defenses) == null ? void 0 : _M.vulnerabilities) != null ? _N : [],
+      applied.defenses.vulnerabilities,
+      featureEffects.vulnerabilities
+    )),
+    condition_immunities: suppress(resolved, "condition_immunities", composeDefenseEntries(
+      (_P = (_O = resolved.definition.defenses) == null ? void 0 : _O.condition_immunities) != null ? _P : [],
       applied.defenses.condition_immunities,
       featureEffects.condition_immunities
-    ])
+    ))
+  };
+  const attackRows = [...(_Q = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _Q : [], buildUnarmedRow(mods, proficiencyBonus, resolveUnarmedStrike(resolved))];
+  const riderBindings = {
+    level: totalLevel,
+    class_level: totalLevel,
+    prof: proficiencyBonus,
+    str_mod: mods.str,
+    dex_mod: mods.dex,
+    con_mod: mods.con,
+    int_mod: mods.int,
+    wis_mod: mods.wis,
+    cha_mod: mods.cha,
+    columns: {}
   };
   return {
     totalLevel,
@@ -685,9 +832,9 @@ 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: ((_X = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _X : []).map((a) => {
+    attacks: attackRows.map((a) => {
       var _a2;
-      const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses];
+      const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses].map((r) => resolveDamageRider(r, a.damageType, riderBindings));
       return {
         ...a,
         toHit: a.toHit + conditionEffects.d20_test_penalty,
@@ -696,12 +843,13 @@ function recalc(resolved, registry) {
         ...riders.length ? { damageRiders: riders } : {}
       };
     }),
-    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,
+    equippedSlots: (_R = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _R : {},
+    carriedWeight: (_S = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _S : 0,
+    attunementUsed: (_T = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _T : 0,
+    attunementLimit: (_V = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _V : (_U = overrides.attunement_limit) != null ? _U : 3,
     conditionEffects,
-    rollModifiers: featureEffects.rollModifiers
+    rollModifiers: featureEffects.rollModifiers,
+    saveOutcomes: featureEffects.saveOutcomes
   };
 }
 export {
@@ -718,6 +866,7 @@ export {
   parseDieSize,
   phbAverageForDie,
   recalc,
+  resolveUnarmedStrike,
   speedFromRace,
   unarmoredAC,
   unarmoredACBreakdown