@archivist-gg/dnd5e 0.1.0

package/dist/pc/pc.recalc.js

@@ -0,0 +1,662 @@
+import {
+  computeSpellLimits,
+  deriveSpellSlots,
+  resolveSpellcasting
+} from "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
+import {
+  computeConditionEffects
+} from "../chunk-R2ZV233X.js";
+import {
+  collectChosenAbilityPoints,
+  collectChosenProficiencies
+} from "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-JEYQU3JT.js";
+import {
+  computeAppliedBonuses,
+  computeSlotsAndAttacks,
+  emptyAppliedBonuses
+} from "../chunk-QQ5W2AZP.js";
+import "../chunk-UC4FE5X3.js";
+import {
+  computeFeatureEffects
+} from "../chunk-XURS6Q6Q.js";
+import "../chunk-LWFTHJIE.js";
+import "../chunk-DNAJRMNN.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+import "../chunk-J2RYSZMQ.js";
+import {
+  abilityModifier,
+  attackBonus,
+  passive,
+  passivePerception,
+  proficiencyFromLevel,
+  saveDC,
+  savingThrow,
+  skillBonus
+} from "../chunk-NAEPSZAM.js";
+import {
+  ABILITY_KEYS,
+  ALL_SKILLS,
+  SKILL_ABILITY
+} from "../chunk-WP2CX2JO.js";
+
+// src/pc/pc.recalc.ts
+function phbAverageForDie(hitDieStr) {
+  const n = parseDieSize(hitDieStr);
+  if (n == null) return 4;
+  return Math.floor(n / 2) + 1;
+}
+function parseDieSize(die) {
+  if (die == null) return null;
+  if (typeof die === "number") return die;
+  const m = die.match(/^d?(\d+)$/i);
+  return m ? parseInt(m[1], 10) : null;
+}
+function skillSlugFromDisplay(display) {
+  return display.toLowerCase().replace(/\s+/g, "-");
+}
+function skillSlugToAbilityLookup(slug) {
+  return slug.replace(/-/g, " ");
+}
+function flattenRaceAsi(race) {
+  var _a;
+  const out = {};
+  if (!(race == null ? void 0 : race.ability_score_increases)) return out;
+  for (const asi of race.ability_score_increases) {
+    if ("ability" in asi) {
+      out[asi.ability] = ((_a = out[asi.ability]) != null ? _a : 0) + asi.amount;
+    }
+  }
+  return out;
+}
+function subraceAsi(resolved) {
+  var _a, _b, _c, _d, _e;
+  const subSlug = (_b = (_a = resolved.definition.subrace) == null ? void 0 : _a.replace(/\[\[|\]\]/g, "")) != null ? _b : null;
+  if (!subSlug) return [];
+  const subraces = (_d = (_c = resolved.race) == null ? void 0 : _c.subraces) != null ? _d : [];
+  const sub = subraces.find((s) => s.slug === subSlug);
+  return (_e = sub == null ? void 0 : sub.ability_score_increases) != null ? _e : [];
+}
+function collectClassAsiBranch(resolved) {
+  var _a;
+  const out = {};
+  for (const c of resolved.classes) {
+    for (const [, choice] of Object.entries(c.choices)) {
+      const asi = choice == null ? void 0 : choice.asi;
+      if (!asi) continue;
+      for (const ab of ABILITY_KEYS) {
+        const v = asi[ab];
+        if (typeof v === "number") out[ab] = ((_a = out[ab]) != null ? _a : 0) + v;
+      }
+    }
+  }
+  return out;
+}
+function abilityBonusBreakdown(resolved) {
+  var _a, _b, _c, _d, _e, _f;
+  const race = flattenRaceAsi(resolved.race);
+  const origin = collectChosenAbilityPoints(resolved);
+  const sub = subraceAsi(resolved);
+  const classAsi = collectClassAsiBranch(resolved);
+  const featPoints = collectClassFeatAbilityPoints(resolved);
+  const out = {};
+  for (const ab of ABILITY_KEYS) {
+    let species = ((_a = race[ab]) != null ? _a : 0) + ((_b = origin.race[ab]) != null ? _b : 0);
+    for (const asi of sub) {
+      if (asi.ability === ab && typeof asi.amount === "number") species += asi.amount;
+    }
+    let feat = (_c = featPoints[ab]) != null ? _c : 0;
+    for (const f of resolved.feats) {
+      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 };
+  }
+  return out;
+}
+function multiclassMaxHP(classes, conMod) {
+  var _a;
+  let total = 0;
+  let firstLevelCounted = false;
+  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;
+    for (let lvl = 1; lvl <= c.level; lvl++) {
+      if (!firstLevelCounted) {
+        total += die + conMod;
+        firstLevelCounted = true;
+      } else {
+        total += Math.floor(die / 2) + 1 + conMod;
+      }
+    }
+  }
+  return Math.max(1, total);
+}
+function unarmoredAC(resolved, mods, warnings) {
+  return unarmoredACBreakdown(resolved, mods, warnings).total;
+}
+function unarmoredACBreakdown(resolved, mods, warnings) {
+  var _a, _b, _c, _d, _e, _f;
+  const baseTerms = [
+    { source: "Unarmored", amount: 10, kind: "unarmored" },
+    { source: "DEX modifier", amount: mods.dex, kind: "dex" }
+  ];
+  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;
+      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" });
+        total += mods[ab];
+      }
+      return { total, terms };
+    }
+  }
+  for (const rf of resolved.features) {
+    const feat = rf.feature;
+    if ((_d = feat.unarmored_defense) == null ? void 0 : _d.ability) {
+      const ab = feat.unarmored_defense.ability;
+      const amt = (_e = mods[ab]) != null ? _e : 0;
+      const terms = [
+        ...baseTerms,
+        { source: `${ab.toUpperCase()} modifier (Unarmored Defense)`, amount: amt, kind: "ability" }
+      ];
+      return { total: 10 + mods.dex + amt, terms };
+    }
+  }
+  for (const rf of resolved.features) {
+    const name = ((_f = rf.feature.name) != null ? _f : "").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 };
+    }
+    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, terms: baseTerms };
+}
+function initiativeBonus(dexMod, feats, edition) {
+  let bonus = dexMod;
+  for (const f of feats) {
+    if (f.slug === "alert" && edition === "2014") bonus += 5;
+    const initBonus = f.initiative_bonus;
+    if (typeof initBonus === "number") bonus += initBonus;
+  }
+  return bonus;
+}
+function speedFromRace(resolved) {
+  var _a, _b, _c;
+  const base = (_c = (_b = (_a = resolved.race) == null ? void 0 : _a.speed) == null ? void 0 : _b.walk) != null ? _c : 30;
+  let extra = 0;
+  for (const f of resolved.feats) {
+    const bonus = f.speed_bonus;
+    if (typeof bonus === "number") extra += bonus;
+  }
+  return base + extra;
+}
+function collectClassFeatAbilityPoints(resolved) {
+  var _a, _b;
+  const out = {};
+  const stripRef = (ref) => ref.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const featBySlug = /* @__PURE__ */ new Map();
+  for (const f of resolved.feats) featBySlug.set(f.slug, f);
+  for (const c of resolved.classes) {
+    for (const atLevel of Object.values(c.choices)) {
+      const block = atLevel;
+      if (!block) continue;
+      const featRef = block.feat;
+      if (typeof featRef !== "string") continue;
+      const feat = featBySlug.get(stripRef(featRef));
+      if (!feat) continue;
+      for (const ch of (_a = feat.choices) != null ? _a : []) {
+        if (ch.kind !== "ability-points") continue;
+        const raw = block[`feat:${ch.id}`];
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+        let left = ch.points;
+        for (const ab of ABILITY_KEYS) {
+          if (ch.pool && !ch.pool.includes(ab)) continue;
+          const v = raw[ab];
+          if (typeof v !== "number" || v <= 0 || left <= 0) continue;
+          const take = Math.min(v, ch.max_per, left);
+          out[ab] = ((_b = out[ab]) != null ? _b : 0) + take;
+          left -= take;
+        }
+      }
+    }
+  }
+  return out;
+}
+function computeAbilityScores(resolved, overrides) {
+  var _a, _b, _c, _d, _e, _f;
+  const out = { ...resolved.definition.abilities };
+  const raceBonuses = flattenRaceAsi(resolved.race);
+  for (const ab of ABILITY_KEYS) {
+    const b = raceBonuses[ab];
+    if (typeof b === "number") out[ab] = ((_a = out[ab]) != null ? _a : 0) + b;
+  }
+  for (const asi of subraceAsi(resolved)) {
+    if (asi.ability && typeof asi.amount === "number") out[asi.ability] = ((_b = out[asi.ability]) != null ? _b : 0) + asi.amount;
+  }
+  const originPoints = collectChosenAbilityPoints(resolved);
+  for (const src of [originPoints.race, originPoints.background]) {
+    for (const ab of ABILITY_KEYS) {
+      const v = src[ab];
+      if (typeof v === "number") out[ab] = ((_c = out[ab]) != null ? _c : 0) + v;
+    }
+  }
+  const classAsi = collectClassAsiBranch(resolved);
+  for (const ab of ABILITY_KEYS) {
+    const v = classAsi[ab];
+    if (typeof v === "number") out[ab] = ((_d = out[ab]) != null ? _d : 0) + v;
+  }
+  const featPoints = collectClassFeatAbilityPoints(resolved);
+  for (const ab of ABILITY_KEYS) {
+    const v = featPoints[ab];
+    if (typeof v === "number") out[ab] = ((_e = out[ab]) != null ? _e : 0) + v;
+  }
+  for (const f of resolved.feats) {
+    const bonuses = f.ability_bonuses;
+    if (bonuses) {
+      for (const ab of ABILITY_KEYS) {
+        const v = bonuses[ab];
+        if (typeof v === "number") out[ab] = ((_f = out[ab]) != null ? _f : 0) + v;
+      }
+    }
+  }
+  if (overrides.scores) {
+    for (const ab of ABILITY_KEYS) {
+      const v = overrides.scores[ab];
+      if (typeof v === "number") out[ab] = v;
+    }
+  }
+  for (const ab of ABILITY_KEYS) {
+    if (typeof out[ab] !== "number") out[ab] = 10;
+  }
+  return out;
+}
+function normalizeProfList(input) {
+  var _a, _b;
+  if (!input) return { categories: [], specific: [] };
+  if (Array.isArray(input)) return { categories: [], specific: input };
+  return { categories: (_a = input.categories) != null ? _a : [], specific: (_b = input.specific) != null ? _b : [] };
+}
+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);
+    }
+  }
+  return out;
+}
+function computeProficiencies(resolved) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const armor = { categories: [], specific: [] };
+  const weapons = { categories: [], specific: [] };
+  const tools = { categories: [], specific: [] };
+  const languages = /* @__PURE__ */ new Set();
+  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));
+    (_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));
+    (_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));
+    (_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));
+    (_g = grants.languages) == null ? void 0 : _g.forEach((l) => languages.add(l));
+  }
+  return {
+    armor,
+    weapons,
+    tools,
+    languages: Array.from(languages).sort(),
+    saves: []
+  };
+}
+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;
+  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 = [];
+  for (const pool of (_c = resolved.pools) != null ? _c : []) {
+    for (const sel of (_d = pool.selected) != null ? _d : []) {
+      const e = sel.entity;
+      if ((e == null ? void 0 : e.activatable) && ((_f = (_e = e.effects) == null ? void 0 : _e.length) != null ? _f : 0) > 0) {
+        buffFeatures.push({
+          feature: { id: sel.slug, name: e.name, activatable: true, 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: (_i = (_h = (_g = resolved.classes[pool.classIndex]) == null ? void 0 : _g.entity) == null ? void 0 : _h.slug) != null ? _i : pool.id, level: pool.anchorLevel }
+        });
+      }
+    }
+  }
+  const featureEffects = computeFeatureEffects([...resolved.features, ...buffFeatures], { activeBuffs });
+  const profsForApply = computeProficiencies(resolved);
+  for (const t of chosenProfs.tools) {
+    if (!profsForApply.tools.specific.includes(t)) profsForApply.tools.specific.push(t);
+  }
+  for (const l of chosenProfs.languages) {
+    if (!profsForApply.languages.includes(l)) profsForApply.languages.push(l);
+  }
+  for (const t of featureEffects.proficiencies.tools) {
+    if (!profsForApply.tools.specific.includes(t)) profsForApply.tools.specific.push(t);
+  }
+  for (const l of featureEffects.proficiencies.languages) {
+    if (!profsForApply.languages.includes(l)) profsForApply.languages.push(l);
+  }
+  for (const a of featureEffects.proficiencies.armor) {
+    if (!profsForApply.armor.categories.includes(a)) profsForApply.armor.categories.push(a);
+  }
+  for (const w of featureEffects.proficiencies.weapons) {
+    if (!profsForApply.weapons.categories.includes(w)) profsForApply.weapons.categories.push(w);
+  }
+  profsForApply.languages.sort();
+  const applied = registry ? computeAppliedBonuses(resolved, profsForApply, registry, warnings) : emptyAppliedBonuses();
+  const savesInformational = applied.informational.filter(
+    (i) => i.field === "saving_throws"
+  );
+  const spellcastingInformational = applied.informational.filter(
+    (i) => i.field === "spell_attack" || i.field === "spell_save_dc"
+  );
+  const speedInformational = applied.informational.filter(
+    (i) => i.field.startsWith("speed.")
+  );
+  const baseScores = computeAbilityScores(resolved, overrides);
+  const scores = { ...baseScores };
+  for (const ab of ABILITY_KEYS) {
+    const bonus = applied.ability_bonuses[ab];
+    if (typeof bonus === "number") scores[ab] += bonus;
+  }
+  for (const ab of ABILITY_KEYS) {
+    const stat = applied.ability_statics[ab];
+    if (typeof stat === "number" && stat > scores[ab]) scores[ab] = stat;
+  }
+  if (overrides.scores) {
+    for (const ab of ABILITY_KEYS) {
+      const o = overrides.scores[ab];
+      if (typeof o === "number") scores[ab] = o;
+    }
+  }
+  const mods = {
+    str: abilityModifier(scores.str),
+    dex: abilityModifier(scores.dex),
+    con: abilityModifier(scores.con),
+    int: abilityModifier(scores.int),
+    wis: abilityModifier(scores.wis),
+    cha: abilityModifier(scores.cha)
+  };
+  const totalLevel = resolved.classes.reduce((s, c) => s + c.level, 0);
+  const proficiencyBonus = proficiencyFromLevel(totalLevel || 1);
+  const conditionEffects = computeConditionEffects(
+    resolved.state,
+    resolved.definition.edition,
+    scores
+  );
+  const firstClass = (_k = (_j = resolved.classes[0]) == null ? void 0 : _j.entity) != null ? _k : null;
+  const saveProfs = new Set((_l = firstClass == null ? void 0 : firstClass.saving_throws) != null ? _l : []);
+  for (const ab of featureEffects.proficiencies.saves) saveProfs.add(ab);
+  const saves = {};
+  for (const ab of ABILITY_KEYS) {
+    const override = (_m = overrides.saves) == null ? void 0 : _m[ab];
+    const prof = (_n = override == null ? void 0 : override.proficient) != null ? _n : saveProfs.has(ab);
+    const derivedBonus = savingThrow(scores[ab], prof, proficiencyBonus) + applied.save_bonus + conditionEffects.d20_test_penalty;
+    const bonus = (_o = override == null ? void 0 : override.bonus) != null ? _o : derivedBonus;
+    saves[ab] = { bonus, proficient: prof };
+  }
+  const profSet = /* @__PURE__ */ new Set([
+    ...resolved.definition.skills.proficient,
+    ...chosenProfs.skills,
+    ...featureEffects.proficiencies.skills
+  ]);
+  const expSet = /* @__PURE__ */ new Set([...resolved.definition.skills.expertise, ...chosenProfs.expertise]);
+  const skills = {};
+  for (const skill of ALL_SKILLS) {
+    const skillKey = skillSlugFromDisplay(skill);
+    const ab = SKILL_ABILITY[skillSlugToAbilityLookup(skillKey)];
+    const override = (_p = overrides.skills) == null ? void 0 : _p[skillKey];
+    const tri = (_q = override == null ? void 0 : override.proficiency) != null ? _q : expSet.has(skillKey) ? "expertise" : profSet.has(skillKey) ? "proficient" : "none";
+    const bonus = (_r = override == null ? void 0 : override.bonus) != null ? _r : skillBonus(scores[ab], tri, proficiencyBonus) + conditionEffects.d20_test_penalty;
+    skills[skillKey] = {
+      bonus,
+      proficiency: tri,
+      ability: ab
+    };
+  }
+  const perceptionTri = skills.perception.proficiency;
+  const investigationTri = skills.investigation.proficiency;
+  const insightTri = skills.insight.proficiency;
+  const passives = {
+    perception: (_t = (_s = overrides.passives) == null ? void 0 : _s.perception) != null ? _t : passivePerception(scores.wis, perceptionTri, proficiencyBonus),
+    investigation: (_v = (_u = overrides.passives) == null ? void 0 : _u.investigation) != null ? _v : passive(scores.int, investigationTri, proficiencyBonus),
+    insight: (_x = (_w = overrides.passives) == null ? void 0 : _w.insight) != null ? _x : 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 = (_z = (_y = overrides.hp) == null ? void 0 : _y.max) != null ? _z : hpMaxAfterConditions;
+  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);
+  let weaponAbility = featureEffects.weaponAbility;
+  const wantsSpellcasting = resolved.features.some((rf) => {
+    var _a2;
+    return ((_a2 = rf.feature.effects) != null ? _a2 : []).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;
+        break;
+      }
+    }
+    if (primaryCasterAbility) weaponAbility = primaryCasterAbility;
+  }
+  let derivedEquipment = null;
+  let acDerived;
+  let acBreakdownDerived = [];
+  let acInformationalDerived = [];
+  if (registry) {
+    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbility != null ? weaponAbility : void 0);
+    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 additive = derivedEquipment.acBreakdown.filter(
+        (b) => b.kind === "item" || b.kind === "override" || b.kind === "shield"
+      );
+      const featTerms = featureAcTermsFor(false);
+      const additiveSum = additive.reduce((sum, b) => sum + b.amount, 0);
+      acDerived = unarmored + additiveSum + sumTerms(featTerms);
+      acBreakdownDerived = [...unarmoredTerms, ...additive, ...featTerms];
+      acInformationalDerived = derivedEquipment.acInformational;
+    }
+  } else {
+    const { total, terms } = unarmoredACBreakdown(resolved, mods, warnings);
+    const featTerms = featureAcTermsFor(false);
+    acDerived = total + sumTerms(featTerms);
+    acBreakdownDerived = [...terms, ...featTerms];
+  }
+  const ac = (_A = overrides.ac) != null ? _A : 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 = (_B = overrides.speed) != null ? _B : conditionSpeed;
+  if (!resolved.race) warnings.push("No race resolved; speed defaulted to 30.");
+  const init = (_C = overrides.initiative) != null ? _C : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
+  const senses = {
+    darkvision: Math.max((_F = (_E = (_D = resolved.race) == null ? void 0 : _D.vision) == null ? void 0 : _E.darkvision) != null ? _F : 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)
+  };
+  const spellcastingClasses = [];
+  const slotInputs = [];
+  const limitInputs = [];
+  for (const c of resolved.classes) {
+    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;
+    spellcastingClasses.push({
+      classSlug: c.entity.slug,
+      className: c.entity.name,
+      ability: profile.ability,
+      saveDC: (_H = (_G = overrides.spellcasting) == null ? void 0 : _G.saveDC) != null ? _H : dc,
+      attackBonus: (_J = (_I = overrides.spellcasting) == null ? void 0 : _I.attackBonus) != null ? _J : 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] });
+  }
+  const spellcasting = spellcastingClasses.length > 0 ? {
+    ability: spellcastingClasses[0].ability,
+    saveDC: spellcastingClasses[0].saveDC,
+    attackBonus: spellcastingClasses[0].attackBonus
+  } : null;
+  const derivedSlots = deriveSpellSlots(slotInputs);
+  const spellLimits = computeSpellLimits(limitInputs);
+  const defenses = {
+    resistances: dedupeDefenseList([
+      (_L = (_K = resolved.definition.defenses) == null ? void 0 : _K.resistances) != null ? _L : [],
+      applied.defenses.resistances,
+      featureEffects.resistances
+    ]),
+    immunities: dedupeDefenseList([
+      (_N = (_M = resolved.definition.defenses) == null ? void 0 : _M.immunities) != null ? _N : [],
+      applied.defenses.immunities
+    ]),
+    vulnerabilities: dedupeDefenseList([
+      (_P = (_O = resolved.definition.defenses) == null ? void 0 : _O.vulnerabilities) != null ? _P : [],
+      applied.defenses.vulnerabilities
+    ]),
+    condition_immunities: dedupeDefenseList([
+      (_R = (_Q = resolved.definition.defenses) == null ? void 0 : _Q.condition_immunities) != null ? _R : [],
+      applied.defenses.condition_immunities,
+      featureEffects.condition_immunities
+    ])
+  };
+  return {
+    totalLevel,
+    proficiencyBonus,
+    scores,
+    mods,
+    saves,
+    proficiencies: profsForApply,
+    skills,
+    passives,
+    senses,
+    hp: {
+      max: hpMax,
+      current: resolved.state.hp.current,
+      temp: resolved.state.hp.temp
+    },
+    ac,
+    speed,
+    initiative: init,
+    spellcasting,
+    spellcastingClasses,
+    derivedSpellSlots: derivedSlots.standard,
+    pactMagic: derivedSlots.pact,
+    spellLimits,
+    warnings,
+    defenses,
+    acBreakdown: acBreakdownDerived,
+    acInformational: acInformationalDerived,
+    savesInformational,
+    spellcastingInformational,
+    speedInformational,
+    // Always ≥ 1; non-stacking (Math.max) extra attacks fold in pc.feature-effects.
+    attacksPerAction: 1 + featureEffects.extraAttack,
+    // Consolidated post-apply over the built attack rows: the d20 condition
+    // penalty (always), plus display-only annotations conditionally spread so
+    // 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: ((_S = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _S : []).map((a) => ({
+      ...a,
+      toHit: a.toHit + conditionEffects.d20_test_penalty,
+      ...featureEffects.critRange < 20 ? { critRange: featureEffects.critRange } : {},
+      ...featureEffects.attackNotes.length ? { attackNotes: featureEffects.attackNotes } : {}
+    })),
+    equippedSlots: (_T = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _T : {},
+    carriedWeight: (_U = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _U : 0,
+    attunementUsed: (_V = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _V : 0,
+    attunementLimit: (_X = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _X : (_W = overrides.attunement_limit) != null ? _W : 3,
+    conditionEffects,
+    rollModifiers: featureEffects.rollModifiers
+  };
+}
+export {
+  abilityBonusBreakdown,
+  collectClassAsiBranch,
+  collectClassFeatAbilityPoints,
+  computeAbilityScores,
+  computeProficiencies,
+  flattenRaceAsi,
+  initiativeBonus,
+  multiclassMaxHP,
+  parseDieSize,
+  phbAverageForDie,
+  recalc,
+  speedFromRace,
+  unarmoredAC,
+  unarmoredACBreakdown
+};

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

@@ -0,0 +1,34 @@
+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";
+export interface ResolveResult {
+    character: ResolvedCharacter;
+    warnings: string[];
+}
+export declare function stripSlug(ref: string | null): string | null;
+export declare class PCResolver {
+    private readonly entities;
+    constructor(entities: EntityRegistry);
+    /** Exposed so recalc() can apply equipment bonuses (Pass A / Pass B). */
+    get registry(): EntityRegistry;
+    resolve(character: Character): ResolveResult;
+}
+/**
+ * Walks class.choices for `feat` entries and adds background feat slugs.
+ * Returns bare slugs (no `[[ ]]`).
+ */
+export declare function collectFeatSlugs(character: Character): string[];
+/** 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
+ *  effects-application pass (pc.feature-effects.ts → recalc) consumes their
+ *  effects[]. Scope: class/subclass level choices, plus race/background origin
+ *  choices (origin_choices keys are namespaced "race:<id>" / "background:<id>"). */
+export declare function collectChosenGrantedFeatures(character: Character, classes: ResolvedClass[], registry: {
+    getByTypeAndSlug(type: string, slug: string): {
+        data: Record<string, unknown>;
+    } | undefined;
+}, race?: RaceEntity | null, background?: BackgroundEntity | null): ResolvedFeature[];
+export declare function collectResolvedFeatures(race: RaceEntity | null, classes: ResolvedClass[], background: BackgroundEntity | null, feats: FeatEntity[]): ResolvedFeature[];