@archivist-gg/dnd5e 0.3.17 → 0.3.19

package/dist/pc/pc.proficiencies.js

@@ -1,34 +1,43 @@
+import {
+  qualifiedGrantCovers
+} from "../chunk-3LWMFYKS.js";
+import "../chunk-YDGMBMYI.js";
 import {
   collectChosenProficiencies,
   collectProficiencyGrants,
-  computeEffectiveProficiencies
-} from "../chunk-ONTGZR5T.js";
+  computeEffectiveProficiencies,
+  computeSuppressedProficiencies
+} from "../chunk-EJD47JHL.js";
 import "../chunk-2LULMQTF.js";
-import "../chunk-H5PTKYXL.js";
-import "../chunk-TULQ4FFX.js";
+import "../chunk-QA3YCOML.js";
+import "../chunk-64VNLMSG.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
-import "../chunk-HTYMW5CH.js";
+import {
+  normKey,
+  proficiencyKey,
+  proficiencyLabel,
+  toProfSlug,
+  weaponProfKey
+} from "../chunk-5JXFJ5AU.js";
+import "../chunk-RD2MID3M.js";
+import "../chunk-LICYHPI3.js";
+import "../chunk-PVCEA4HZ.js";
 import "../chunk-KSTV7J2U.js";
 import "../chunk-DPUJDOKV.js";
 import "../chunk-LBEXLN6I.js";
-import {
-  proficiencyLabel,
-  toProfSlug
-} from "../chunk-RLGQ5PZZ.js";
-import "../chunk-3VZZDKRA.js";
+import "../chunk-NXUY5XQN.js";
 import "../chunk-W6GC6OKK.js";
 import "../chunk-B3DP42OM.js";
 import "../chunk-IUAAXXNO.js";
 import "../chunk-YHYTW5QA.js";
-import "../chunk-VRV3NNTA.js";
-import "../chunk-PVCEA4HZ.js";
+import "../chunk-ZUQW5VBZ.js";
 import "../chunk-IHE6KVC3.js";
 import "../chunk-LHZXYFBU.js";
 import "../chunk-YBLDE5CG.js";
-import "../chunk-ZUQW5VBZ.js";
 import "../chunk-LVQLWRCU.js";
 import "../chunk-CM5CWO4K.js";
+import "../chunk-4J6DS3EJ.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
 import "../chunk-ZCTUYGNV.js";
@@ -52,8 +61,29 @@ function collectProficiencySources(resolved) {
   };
 }
 function aggregateProficiencies(resolved) {
-  const src = collectProficiencySources(resolved);
+  const { armor, weapons } = composeArmorWeapons(resolved);
   const effective = computeEffectiveProficiencies(resolved);
+  return { armor: armor.kept, weapons: weapons.kept, tools: effective.tools, languages: effective.languages };
+}
+function proficiencyOverview(resolved, kind) {
+  if (kind === "armor" || kind === "weapons") {
+    const c = composeArmorWeapons(resolved)[kind];
+    return { effective: c.kept, removed: c.suppressed };
+  }
+  return { effective: computeEffectiveProficiencies(resolved)[kind], removed: computeSuppressedProficiencies(resolved)[kind] };
+}
+function weaponCoveredBy(effective, weapon) {
+  const cat = typeof weapon.category === "string" ? weapon.category : "";
+  const base = cat.split("-")[0];
+  return effective.find((e) => {
+    const key = weaponProfKey(e.value);
+    if ((key === "simple" || key === "martial") && key === base) return true;
+    if (cat && key === normKey(cat)) return true;
+    return qualifiedGrantCovers(e.value, weapon);
+  });
+}
+function composeArmorWeapons(resolved) {
+  const src = collectProficiencySources(resolved);
   return {
     // Walk order defines `sources` order (spec §4.1): class before feats, and
     // for weapons the class `fixed` names before the class categories, matching
@@ -68,10 +98,27 @@ function aggregateProficiencies(resolved) {
     // keeps origin `grant` and its granting source(s) (R4-G3b §7 F5 · the same
     // grants-then-picks order computeEffectiveProficiencies uses for the
     // language and tool buckets). Armor passes none.
-    armor: composeGrantEntries([src.classArmor, src.featArmor, src.effectArmor]),
-    weapons: composeGrantEntries([src.classWeaponFixed, src.classWeaponCategories, src.featWeapons, src.effectWeapons], src.chosenWeapons),
-    tools: effective.tools,
-    languages: effective.languages
+    armor: applyKindOverrides(resolved, "armor", composeGrantEntries([src.classArmor, src.featArmor, src.effectArmor])),
+    weapons: applyKindOverrides(
+      resolved,
+      "weapons",
+      composeGrantEntries([src.classWeaponFixed, src.classWeaponCategories, src.featWeapons, src.effectWeapons], src.chosenWeapons)
+    )
+  };
+}
+function applyKindOverrides(resolved, kind, entries) {
+  var _a, _b, _c, _d;
+  const ov = (_b = (_a = resolved.definition) == null ? void 0 : _a.overrides) == null ? void 0 : _b[kind];
+  const key = (v) => proficiencyKey(kind, v);
+  const all = [...entries];
+  for (const v of (_c = ov == null ? void 0 : ov.add) != null ? _c : []) {
+    if (!all.some((e) => key(e.value) === key(v))) all.push({ value: v, label: prettyName(v), sources: [], origin: "manual" });
+  }
+  const removes = new Set(((_d = ov == null ? void 0 : ov.remove) != null ? _d : []).map(key));
+  const byLabel = (a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0;
+  return {
+    kept: all.filter((e) => !removes.has(key(e.value))).sort(byLabel),
+    suppressed: all.filter((e) => removes.has(key(e.value))).sort(byLabel)
   };
 }
 function composeGrantEntries(buckets, picks = []) {
@@ -103,5 +150,7 @@ function prettyName(slug) {
 }
 export {
   aggregateProficiencies,
-  collectProficiencySources
+  collectProficiencySources,
+  proficiencyOverview,
+  weaponCoveredBy
 };

package/dist/pc/pc.proficiency-normalize.d.ts

@@ -27,3 +27,17 @@ export declare const humanizeProficiency: (s: string) => string;
  *    the first character capitalised, every other letter untouched. Title-casing it word by word lower-cased
  *    `2H` to `2h` and read "That Have The Light Property". */
 export declare const proficiencyLabel: (raw: string) => string;
+/** The four proficiency kinds the sheet lists and the D4 pickers edit, one picker per kind. */
+export type ProficiencyKind = "armor" | "weapons" | "tools" | "languages";
+/** D4 A: the key of a WEAPON proficiency value, so every spelling of one grant folds onto one key. A category reads
+ *  `simple` or `martial` whatever its spelling ("martial", "Martial weapons"); anything else is keyed by
+ *  {@link normKey}, the rule the live weapon gate (`isWeaponSlugProficient`) matches a weapon's name by, so
+ *  "longswords", "Longsword" and "longsword" meet, and "hand-crossbow" meets "Hand Crossbows" and "Crossbow, hand". */
+export declare const weaponProfKey: (raw: string) => string;
+/** D4 A: the key of an ARMOR proficiency value: `light`, `medium`, `heavy`, `shield` whatever the spelling
+ *  ("Heavy armor", "shields"). */
+export declare const armorProfKey: (raw: string) => string;
+/** D4 A: the one comparison key per kind, used by the engine's override readers and the plugin's writers alike, so a
+ *  value the writer stores and the value the reader suppresses always meet. Languages and tools keep `toProfSlug`,
+ *  unchanged. */
+export declare const proficiencyKey: (kind: ProficiencyKind, raw: string) => string;

package/dist/pc/pc.proficiency-normalize.js

@@ -1,12 +1,18 @@
 import {
+  armorProfKey,
   humanizeProficiency,
   normKey,
+  proficiencyKey,
   proficiencyLabel,
-  toProfSlug
-} from "../chunk-RLGQ5PZZ.js";
+  toProfSlug,
+  weaponProfKey
+} from "../chunk-5JXFJ5AU.js";
 export {
+  armorProfKey,
   humanizeProficiency,
   normKey,
+  proficiencyKey,
   proficiencyLabel,
-  toProfSlug
+  toProfSlug,
+  weaponProfKey
 };

package/dist/pc/pc.proficiency-query.js

@@ -4,7 +4,7 @@ import {
 import "../chunk-YDGMBMYI.js";
 import {
   normKey
-} from "../chunk-RLGQ5PZZ.js";
+} from "../chunk-5JXFJ5AU.js";
 import "../chunk-ZCTUYGNV.js";
 
 // src/pc/pc.proficiency-query.ts

package/dist/pc/pc.recalc.js

@@ -1,28 +1,43 @@
+import {
+  buildUnarmedRow,
+  computeAppliedBonuses,
+  computeSlotsAndAttacks,
+  emptyAppliedBonuses
+} from "../chunk-7XJHI5H5.js";
+import "../chunk-3LWMFYKS.js";
+import "../chunk-YDGMBMYI.js";
 import {
   amountBindingsFor
-} from "../chunk-PXVNAY7T.js";
+} from "../chunk-TRBGC4ZG.js";
 import "../chunk-KR6JF3BF.js";
 import {
   computeConditionEffects
 } from "../chunk-MYY2C5MB.js";
+import "../chunk-EJP263OP.js";
 import {
   collectChosenAbilityPoints,
   collectChosenProficiencies
-} from "../chunk-ONTGZR5T.js";
+} from "../chunk-EJD47JHL.js";
 import "../chunk-2LULMQTF.js";
-import "../chunk-H5PTKYXL.js";
+import "../chunk-QA3YCOML.js";
 import {
   assembleEffectFeatures,
   computeFeatureEffects,
   foldsNow,
   selfEffectsOf
-} from "../chunk-TULQ4FFX.js";
+} from "../chunk-64VNLMSG.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
+import {
+  proficiencyKey
+} from "../chunk-5JXFJ5AU.js";
 import {
   featPickSites,
-  poolMemberSitesOf
-} from "../chunk-HTYMW5CH.js";
+  poolMemberSitesOf,
+  spellsReached
+} from "../chunk-RD2MID3M.js";
+import "../chunk-LICYHPI3.js";
+import "../chunk-PVCEA4HZ.js";
 import {
   resourceLevelFor
 } from "../chunk-KSTV7J2U.js";
@@ -38,17 +53,7 @@ import {
 import {
   toDefenseSlug
 } from "../chunk-XJ2F2WO6.js";
-import {
-  buildUnarmedRow,
-  computeAppliedBonuses,
-  computeSlotsAndAttacks,
-  emptyAppliedBonuses
-} from "../chunk-JSM6JFZR.js";
-import "../chunk-3LWMFYKS.js";
-import "../chunk-YDGMBMYI.js";
-import "../chunk-EJP263OP.js";
-import "../chunk-RLGQ5PZZ.js";
-import "../chunk-3VZZDKRA.js";
+import "../chunk-NXUY5XQN.js";
 import "../chunk-W6GC6OKK.js";
 import "../chunk-B3DP42OM.js";
 import {
@@ -56,22 +61,24 @@ import {
   unarmedDieColumnFor
 } from "../chunk-IUAAXXNO.js";
 import "../chunk-YHYTW5QA.js";
-import "../chunk-VRV3NNTA.js";
-import "../chunk-PVCEA4HZ.js";
+import "../chunk-ZUQW5VBZ.js";
 import "../chunk-IHE6KVC3.js";
 import "../chunk-HHBD4SQ6.js";
 import "../chunk-A54HHCWW.js";
 import "../chunk-LHZXYFBU.js";
 import "../chunk-YBLDE5CG.js";
-import "../chunk-ZUQW5VBZ.js";
 import "../chunk-LVQLWRCU.js";
 import "../chunk-CM5CWO4K.js";
+import "../chunk-4J6DS3EJ.js";
 import {
   resolveAmountText
-} from "../chunk-QH36K2PU.js";
+} from "../chunk-WOHX7YTH.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
-import "../chunk-ZCTUYGNV.js";
+import {
+  bareEntitySlug,
+  slugify
+} from "../chunk-ZCTUYGNV.js";
 import "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
 import "../chunk-3TM34RSJ.js";
@@ -93,6 +100,60 @@ import {
 import "../chunk-4U55VNC7.js";
 import "../chunk-UA5KS2PL.js";
 
+// src/pc/pc.spell-scope.ts
+var lower = (s) => (s != null ? s : "").trim().toLowerCase();
+function namedSpellSlug(ref) {
+  var _a;
+  const inner = ref.replace(/^\[\[/, "").replace(/\]\]$/, "").split("|")[0];
+  return slugify((_a = inner.split("/").pop()) != null ? _a : inner);
+}
+function dealsDamage(spell) {
+  var _a, _b;
+  return ((_b = (_a = spell.damage) == null ? void 0 : _a.types) != null ? _b : []).some((t) => t.trim() !== "");
+}
+function spellsInScope(scope, spells, pickedTypes) {
+  var _a, _b;
+  if (!scope) return [];
+  const picked = scope.damage_type_pick !== void 0 ? pickedTypes(scope.damage_type_pick).map(lower) : null;
+  const types = (_a = scope.damage_types) == null ? void 0 : _a.map(lower);
+  const named = (_b = scope.spells) == null ? void 0 : _b.map(namedSpellSlug);
+  const hit = spells.filter(({ slug, entity: e }) => {
+    var _a2, _b2, _c, _d, _e;
+    if (!dealsDamage(e)) return false;
+    const own = ((_b2 = (_a2 = e.damage) == null ? void 0 : _a2.types) != null ? _b2 : []).map(lower);
+    if (scope.list !== void 0 && !((_c = e.classes) != null ? _c : []).map(lower).includes(lower(scope.list))) return false;
+    if (scope.level !== void 0 && ((_d = e.level) != null ? _d : 0) !== scope.level) return false;
+    if (scope.school !== void 0 && lower(e.school) !== lower(scope.school)) return false;
+    if (types && !own.some((t) => types.includes(t))) return false;
+    if (picked && !own.some((t) => picked.includes(t))) return false;
+    if (named && !named.includes(bareEntitySlug(slug)) && !named.includes(slugify((_e = e.name) != null ? _e : ""))) return false;
+    return true;
+  });
+  return [...new Set(hit.map((s) => s.slug))];
+}
+function pickedDamageTypes(resolved, choiceId) {
+  var _a, _b, _c, _d, _e, _f;
+  const out = /* @__PURE__ */ new Set();
+  for (const c of (_a = resolved.classes) != null ? _a : []) {
+    for (const owner of [c.entity, c.subclass]) {
+      for (const [lvl, feats] of Object.entries((_b = owner == null ? void 0 : owner.features_by_level) != null ? _b : {})) {
+        for (const feat of feats != null ? feats : []) {
+          for (const ch of (_c = feat.choices) != null ? _c : []) {
+            if (ch.kind !== "select-inline" || ch.id !== choiceId) continue;
+            const sel = ((_e = (_d = c.choices) == null ? void 0 : _d[Number(lvl)]) != null ? _e : {})[ch.id];
+            if (typeof sel !== "string") continue;
+            const opt = ch.options.find((o) => o.value === sel);
+            for (const word of `${sel} ${(_f = opt == null ? void 0 : opt.label) != null ? _f : ""}`.split(/[^A-Za-z]+/)) {
+              if (word && isCanonicalDamageType(word)) out.add(word.toLowerCase());
+            }
+          }
+        }
+      }
+    }
+  }
+  return [...out];
+}
+
 // src/pc/pc.recalc.ts
 var WEAPON_CATEGORY_WORDS = /* @__PURE__ */ new Set([
   "simple",
@@ -453,6 +514,25 @@ 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 applyArmorWeaponOverrides(profs, overrides) {
+  var _a, _b;
+  for (const kind of ["armor", "weapons"]) {
+    const ov = overrides == null ? void 0 : overrides[kind];
+    if (!ov) continue;
+    const set = profs[kind];
+    const key = (v) => proficiencyKey(kind, v);
+    const removes = new Set(((_a = ov.remove) != null ? _a : []).map(key));
+    for (const v of (_b = ov.add) != null ? _b : []) {
+      const k = key(v);
+      if (removes.has(k)) continue;
+      const category = kind === "armor" || k === "simple" || k === "martial";
+      const target = category ? set.categories : set.specific;
+      if (!target.some((e) => key(e) === k)) target.push(category ? k : v);
+    }
+    set.categories = set.categories.filter((e) => !removes.has(key(e)));
+    set.specific = set.specific.filter((e) => !removes.has(key(e)));
+  }
+}
 var ORIGIN_RANK = { manual: 0, equipment: 1, grant: 2 };
 function composeDefenseEntries(manual, equipment, grants) {
   var _a;
@@ -544,7 +624,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, _X, _Y, _Z;
+  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, __, _$;
   const warnings = [];
   const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
   const chosenProfs = collectChosenProficiencies(resolved);
@@ -587,6 +667,7 @@ function recalc(resolved, registry) {
     }
   }
   profsForApply.languages.sort();
+  applyArmorWeaponOverrides(profsForApply, (_b = resolved.definition) == null ? void 0 : _b.overrides);
   const applied = registry ? computeAppliedBonuses(resolved, profsForApply, registry, warnings) : emptyAppliedBonuses();
   const savesInformational = applied.informational.filter(
     (i) => i.field === "saving_throws"
@@ -601,7 +682,7 @@ function recalc(resolved, registry) {
   const scores = { ...baseScores };
   for (const ab of ABILITY_KEYS) {
     const bonus = applied.ability_bonuses[ab];
-    scores[ab] += (typeof bonus === "number" ? bonus : 0) + ((_b = featureEffects.ability_bonus[ab]) != null ? _b : 0);
+    scores[ab] += (typeof bonus === "number" ? bonus : 0) + ((_c = featureEffects.ability_bonus[ab]) != null ? _c : 0);
   }
   for (const ab of ABILITY_KEYS) {
     const stat = applied.ability_statics[ab];
@@ -628,8 +709,8 @@ function recalc(resolved, registry) {
     resolved.definition.edition,
     scores
   );
-  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 : []);
+  const firstClass = (_e = (_d = resolved.classes[0]) == null ? void 0 : _d.entity) != null ? _e : null;
+  const saveProfs = new Set((_f = firstClass == null ? void 0 : firstClass.saving_throws) != null ? _f : []);
   for (const ab of featureEffects.proficiencies.saves) saveProfs.add(ab);
   for (const ab of chosenProfs.saves) saveProfs.add(ab);
   const saves = {};
@@ -639,8 +720,8 @@ function recalc(resolved, registry) {
     return t.inactiveWhile === "incapacitated" ? !conditionEffects.actions_disabled : t.inactiveWhile === "unconscious" ? !((_a2 = resolved.state.conditions) != null ? _a2 : []).includes("unconscious") : true;
   });
   for (const ab of ABILITY_KEYS) {
-    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 override = (_g = overrides.saves) == null ? void 0 : _g[ab];
+    const prof = (_h = override == null ? void 0 : override.proficient) != null ? _h : saveProfs.has(ab);
     const featureTerms = [];
     for (const t of activeSaveBonusTerms) {
       if (t.saves.length > 0 && !t.saves.includes(ab)) continue;
@@ -650,7 +731,7 @@ function recalc(resolved, registry) {
       else if (amount > prior.amount) prior.amount = amount;
     }
     const derivedBonus = savingThrow(scores[ab], prof, proficiencyBonus) + applied.save_bonus + featureTerms.reduce((sum, t) => sum + t.amount, 0) + conditionEffects.d20_test_penalty;
-    const bonus = (_h = override == null ? void 0 : override.bonus) != null ? _h : derivedBonus;
+    const bonus = (_i = override == null ? void 0 : override.bonus) != null ? _i : derivedBonus;
     saves[ab] = { bonus, proficient: prof };
     saveBreakdowns[ab] = [
       { source: ab.toUpperCase(), amount: mods[ab] },
@@ -662,7 +743,7 @@ function recalc(resolved, registry) {
   }
   const profSet = /* @__PURE__ */ new Set([
     ...resolved.definition.skills.proficient,
-    ...(_j = (_i = resolved.background) == null ? void 0 : _i.skill_proficiencies) != null ? _j : [],
+    ...(_k = (_j = resolved.background) == null ? void 0 : _j.skill_proficiencies) != null ? _k : [],
     ...chosenProfs.skills,
     ...featureEffects.proficiencies.skills
   ]);
@@ -672,12 +753,12 @@ function recalc(resolved, registry) {
   for (const skill of ALL_SKILLS) {
     const skillKey = skillSlugFromDisplay(skill);
     const ab = SKILL_ABILITY[skillSlugToAbilityLookup(skillKey)];
-    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 override = (_l = overrides.skills) == null ? void 0 : _l[skillKey];
+    const tri = (_m = override == null ? void 0 : override.proficiency) != null ? _m : expSet.has(skillKey) ? "expertise" : profSet.has(skillKey) ? "proficient" : "none";
     const skillTerms = featureEffects.skill_bonus_terms.filter((t) => t.skills.includes(skillKey)).map((t) => ({ source: t.label, amount: Math.max(t.minimum, mods[t.ability]) }));
     const halfProfTerms = tri !== "none" ? [] : featureEffects.half_proficiency_terms.filter((t) => t.skills.length === 0 || t.skills.includes(skillKey)).map((t) => ({ source: t.label, amount: t.round === "up" ? Math.ceil(proficiencyBonus / 2) : Math.floor(proficiencyBonus / 2) }));
     const halfProfBest = halfProfTerms.length ? halfProfTerms.reduce((best, t) => t.amount > best.amount ? t : best) : null;
-    const bonus = (_n = override == null ? void 0 : override.bonus) != null ? _n : skillBonus(scores[ab], tri, proficiencyBonus) + skillTerms.reduce((sum, t) => sum + t.amount, 0) + ((_m = halfProfBest == null ? void 0 : halfProfBest.amount) != null ? _m : 0) + conditionEffects.d20_test_penalty;
+    const bonus = (_o = override == null ? void 0 : override.bonus) != null ? _o : skillBonus(scores[ab], tri, proficiencyBonus) + skillTerms.reduce((sum, t) => sum + t.amount, 0) + ((_n = halfProfBest == null ? void 0 : halfProfBest.amount) != null ? _n : 0) + conditionEffects.d20_test_penalty;
     skillBreakdowns[skillKey] = [
       { source: ab.toUpperCase(), amount: mods[ab] },
       ...tri !== "none" ? [{ source: tri === "expertise" ? "Expertise" : "Proficiency", amount: proficiencyBonus * (tri === "expertise" ? 2 : 1) }] : [],
@@ -693,12 +774,12 @@ function recalc(resolved, registry) {
     };
   }
   const passives = {
-    perception: (_p = (_o = overrides.passives) == null ? void 0 : _o.perception) != null ? _p : 10 + skills.perception.bonus,
-    investigation: (_r = (_q = overrides.passives) == null ? void 0 : _q.investigation) != null ? _r : 10 + skills.investigation.bonus,
-    insight: (_t = (_s = overrides.passives) == null ? void 0 : _s.insight) != null ? _t : 10 + skills.insight.bonus
+    perception: (_q = (_p = overrides.passives) == null ? void 0 : _p.perception) != null ? _q : 10 + skills.perception.bonus,
+    investigation: (_s = (_r = overrides.passives) == null ? void 0 : _r.investigation) != null ? _s : 10 + skills.investigation.bonus,
+    insight: (_u = (_t = overrides.passives) == null ? void 0 : _t.insight) != null ? _u : 10 + skills.insight.bonus
   };
-  const hpRolled = (_v = (_u = overrides.hp) == null ? void 0 : _u.rolled) != null ? _v : null;
-  const hpModifier = (_x = (_w = overrides.hp) == null ? void 0 : _w.modifier) != null ? _x : null;
+  const hpRolled = (_w = (_v = overrides.hp) == null ? void 0 : _v.rolled) != null ? _w : null;
+  const hpModifier = (_y = (_x = overrides.hp) == null ? void 0 : _x.modifier) != null ? _y : null;
   const averageDiceSum = hitDiceAverageSum(resolved.classes);
   const conLevels = hpLevelCount(resolved.classes);
   const diceSum = hpRolled != null ? hpRolled : averageDiceSum;
@@ -706,7 +787,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 = (_z = (_y = overrides.hp) == null ? void 0 : _y.max) != null ? _z : hpMaxAfterConditions;
+  const hpMax = (_A = (_z = overrides.hp) == null ? void 0 : _z.max) != null ? _A : hpMaxAfterConditions;
   const hpBreakdown = {
     diceSum,
     diceSource: hpRolled != null ? "rolled" : "average",
@@ -724,7 +805,7 @@ function recalc(resolved, registry) {
     exhaustionMultiplier: conditionEffects.hp_max_multiplier,
     exhaustionLevel: conditionEffects.exhaustion_level,
     derivedMax: hpMaxAfterConditions,
-    override: (_B = (_A = overrides.hp) == null ? void 0 : _A.max) != null ? _B : null,
+    override: (_C = (_B = overrides.hp) == null ? void 0 : _B.max) != null ? _C : 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", condition: t.condition }));
@@ -748,7 +829,7 @@ function recalc(resolved, registry) {
   let acBreakdownDerived = [];
   let acInformationalDerived = [];
   if (registry) {
-    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_C = resolved.weaponMasteries) != null ? _C : [], featureEffects.attunement_set);
+    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_D = resolved.weaponMasteries) != null ? _D : [], featureEffects.attunement_set);
     if (derivedEquipment.equippedSlots.armor) {
       const featTerms = featureAcTermsFor(true);
       acDerived = derivedEquipment.ac + sumTerms(featTerms);
@@ -772,13 +853,13 @@ function recalc(resolved, registry) {
     acDerived = total + sumTerms(featTerms);
     acBreakdownDerived = [...terms, ...featTerms];
   }
-  const ac = (_D = overrides.ac) != null ? _D : acDerived;
+  const ac = (_E = overrides.ac) != null ? _E : 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 = (_E = overrides.speed) != null ? _E : conditionSpeed;
-  const raceSpeed = (_H = (_G = (_F = resolved.race) == null ? void 0 : _F.speed) == null ? void 0 : _G.walk) != null ? _H : 30;
+  const speed = (_F = overrides.speed) != null ? _F : conditionSpeed;
+  const raceSpeed = (_I = (_H = (_G = resolved.race) == null ? void 0 : _G.speed) == null ? void 0 : _H.walk) != null ? _I : 30;
   const speedBreakdown = [
     { source: "Base speed", amount: raceSpeed },
     ...speedFromRace(resolved) !== raceSpeed ? [{ source: "Feats", amount: speedFromRace(resolved) - raceSpeed }] : [],
@@ -788,14 +869,14 @@ function recalc(resolved, registry) {
     ...conditionSpeed !== baseSpeed ? [{ source: "Conditions", amount: conditionSpeed - baseSpeed }] : []
   ];
   if (!resolved.race) warnings.push("No race resolved; speed defaulted to 30.");
-  const init = (_I = overrides.initiative) != null ? _I : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
+  const init = (_J = overrides.initiative) != null ? _J : initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) + featureEffects.initiative_bonus;
   const initiativeBreakdown = [
     { source: "DEX", amount: mods.dex },
     ...initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) !== mods.dex ? [{ source: "Feats", amount: initiativeBonus(mods.dex, resolved.feats, resolved.definition.edition) - mods.dex }] : [],
     ...featureEffects.initiative_terms.map((term) => ({ source: term.label, amount: term.value }))
   ];
   const senses = {
-    darkvision: Math.max((_L = (_K = (_J = resolved.race) == null ? void 0 : _J.vision) == null ? void 0 : _K.darkvision) != null ? _L : 0, featureEffects.senses.darkvision, applied.senses.darkvision),
+    darkvision: Math.max((_M = (_L = (_K = resolved.race) == null ? void 0 : _K.vision) == null ? void 0 : _L.darkvision) != null ? _M : 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)
@@ -842,28 +923,42 @@ function recalc(resolved, registry) {
   const spellLimits = computeSpellLimits(limitInputs);
   const defenses = {
     resistances: suppress(resolved, "resistances", composeDefenseEntries(
-      (_N = (_M = resolved.definition.defenses) == null ? void 0 : _M.resistances) != null ? _N : [],
+      (_O = (_N = resolved.definition.defenses) == null ? void 0 : _N.resistances) != null ? _O : [],
       applied.defenses.resistances,
       featureEffects.resistances
     )),
     immunities: suppress(resolved, "immunities", composeDefenseEntries(
-      (_P = (_O = resolved.definition.defenses) == null ? void 0 : _O.immunities) != null ? _P : [],
+      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.immunities) != null ? _Q : [],
       applied.defenses.immunities,
       featureEffects.immunities
     )),
     vulnerabilities: suppress(resolved, "vulnerabilities", composeDefenseEntries(
-      (_R = (_Q = resolved.definition.defenses) == null ? void 0 : _Q.vulnerabilities) != null ? _R : [],
+      (_S = (_R = resolved.definition.defenses) == null ? void 0 : _R.vulnerabilities) != null ? _S : [],
       applied.defenses.vulnerabilities,
       featureEffects.vulnerabilities
     )),
     condition_immunities: suppress(resolved, "condition_immunities", composeDefenseEntries(
-      (_T = (_S = resolved.definition.defenses) == null ? void 0 : _S.condition_immunities) != null ? _T : [],
+      (_U = (_T = resolved.definition.defenses) == null ? void 0 : _T.condition_immunities) != null ? _U : [],
       applied.defenses.condition_immunities,
       featureEffects.condition_immunities
     ))
   };
-  const attackRows = [...(_U = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _U : [], buildUnarmedRow(mods, proficiencyBonus, resolveUnarmedStrike(resolved))];
+  const attackRows = [...(_V = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _V : [], buildUnarmedRow(mods, proficiencyBonus, resolveUnarmedStrike(resolved))];
   const riderBindings = (owner) => amountBindingsFor(owner, resolved, { proficiencyBonus, mods, spellcastingClasses });
+  const ownSpells = (_W = resolved.spells) != null ? _W : [];
+  const spellDamageRiders = featureEffects.spellDamageBonuses.flatMap((r) => {
+    const reached = /* @__PURE__ */ new Set([...spellsReached(r.targets, ownSpells), ...spellsInScope(r.scope, ownSpells, (id) => pickedDamageTypes(resolved, id))]);
+    const spells = [...new Set(ownSpells.map((s) => s.slug))].filter((slug) => reached.has(slug));
+    if (!spells.length) return [];
+    const { owner, targets: _targets, scope, damage_type, ...rest } = r;
+    return [{
+      ...rest,
+      amount: resolveAmountText(r.amount, riderBindings(owner)),
+      ...damage_type && isCanonicalDamageType(damage_type) ? { damage_type } : {},
+      ...(scope == null ? void 0 : scope.once) ? { once: true } : {},
+      spells
+    }];
+  });
   return {
     totalLevel,
     proficiencyBonus,
@@ -915,10 +1010,11 @@ function recalc(resolved, registry) {
         ...riders.length ? { damageRiders: riders } : {}
       };
     }),
-    equippedSlots: (_V = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _V : {},
-    carriedWeight: (_W = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _W : 0,
-    attunementUsed: (_X = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _X : 0,
-    attunementLimit: (_Z = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _Z : (_Y = overrides.attunement_limit) != null ? _Y : Math.max(3, featureEffects.attunement_set),
+    ...spellDamageRiders.length ? { spellDamageRiders } : {},
+    equippedSlots: (_X = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _X : {},
+    carriedWeight: (_Y = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _Y : 0,
+    attunementUsed: (_Z = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _Z : 0,
+    attunementLimit: (_$ = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _$ : (__ = overrides.attunement_limit) != null ? __ : Math.max(3, featureEffects.attunement_set),
     conditionEffects,
     rollModifiers: featureEffects.rollModifiers,
     saveOutcomes: featureEffects.saveOutcomes

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

@@ -114,7 +114,10 @@ export declare function collectItemGrantedSpells(character: Character, ownAbilit
  * never lost. Item-source spells carry INSTANCE identity: they key by
  * `slug + "#" + entryIndex`, so two scrolls of one spell stay two rows and a scroll of
  * a class-known spell keeps its OWN item row, never collapsing into / being collapsed
- * by a class/feat copy. The class/feat slug-only merge is unchanged.
+ * by a class/feat copy. The class/feat slug-only merge is unchanged. An AT-WILL copy (a pool member's innate grant) keys
+ * by `slug + "#atwill"` (review D1, coordinator ruling 2026-09-28): it is a row of its own beside a copy the character
+ * already has (the slotted cast can upcast and target others), neither row's flags cross to the other, and two at-will
+ * copies of one spell are still one row.
  */
 export declare function dedupeResolvedSpells(spells: ResolvedSpell[]): ResolvedSpell[];
 /** Selected select-entity values (optional-features) and selected inline

package/dist/pc/pc.resolver.js

@@ -10,30 +10,31 @@ import {
   dedupeResolvedSpells,
   resolveOriginFeat,
   stripSlug
-} from "../chunk-ONTGZR5T.js";
+} from "../chunk-EJD47JHL.js";
 import "../chunk-2LULMQTF.js";
-import "../chunk-H5PTKYXL.js";
-import "../chunk-TULQ4FFX.js";
+import "../chunk-QA3YCOML.js";
+import "../chunk-64VNLMSG.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
-import "../chunk-HTYMW5CH.js";
+import "../chunk-5JXFJ5AU.js";
+import "../chunk-RD2MID3M.js";
+import "../chunk-LICYHPI3.js";
+import "../chunk-PVCEA4HZ.js";
 import "../chunk-KSTV7J2U.js";
 import "../chunk-DPUJDOKV.js";
 import "../chunk-LBEXLN6I.js";
-import "../chunk-RLGQ5PZZ.js";
-import "../chunk-3VZZDKRA.js";
+import "../chunk-NXUY5XQN.js";
 import "../chunk-W6GC6OKK.js";
 import "../chunk-B3DP42OM.js";
 import "../chunk-IUAAXXNO.js";
 import "../chunk-YHYTW5QA.js";
-import "../chunk-VRV3NNTA.js";
-import "../chunk-PVCEA4HZ.js";
+import "../chunk-ZUQW5VBZ.js";
 import "../chunk-IHE6KVC3.js";
 import "../chunk-LHZXYFBU.js";
 import "../chunk-YBLDE5CG.js";
-import "../chunk-ZUQW5VBZ.js";
 import "../chunk-LVQLWRCU.js";
 import "../chunk-CM5CWO4K.js";
+import "../chunk-4J6DS3EJ.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
 import "../chunk-ZCTUYGNV.js";