@archivist-gg/dnd5e 0.1.0 → 0.2.0

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

@@ -33,9 +33,16 @@ export declare const ITEM_ACTIONS: Record<string, ItemAction>;
 export declare function findItemAction(slug: string): ItemAction | undefined;
 /**
  * Resolve the ItemAction for an equipped entry.
- * Priority: entry.overrides (action + range) merged onto curated map.
- * Returns null when neither source supplies an action cost.
+ * Priority: per-instance override > curated map > `itemType==="potion"`
+ * bonus-action default > null.
+ *
+ * `itemType` is the entity's `data.type` (from the registry, statically
+ * `unknown`); per the 2024 SRD, drinking/administering a potion is a Bonus
+ * Action, so an uncurated `type==="potion"` item still surfaces (curated oils
+ * mis-typed `"potion"` are pinned to "action" so this default cannot mislabel
+ * them). Returns null when no source supplies a cost (non-potion uncurated with
+ * no override).
  *
  * Accepts both bare and compendium-prefixed slugs (see `findItemAction`).
  */
-export declare function resolveItemAction(slug: string, entry: EquipmentEntry): ItemAction | null;
+export declare function resolveItemAction(slug: string, entry: EquipmentEntry, itemType?: unknown): ItemAction | null;

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

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

package/dist/item/item.codec.js

@@ -1,8 +1,8 @@
 import {
   itemCodec
-} from "../chunk-537BHVSH.js";
-import "../chunk-4SSDYJS2.js";
-import "../chunk-4C2KOKLF.js";
+} from "../chunk-4JHOHWBI.js";
+import "../chunk-7VJ6BOA5.js";
+import "../chunk-K6Q5OUGK.js";
 export {
   itemCodec
 };

package/dist/item/item.parser.js

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

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

@@ -165,6 +165,19 @@ export declare const itemEntitySchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     entries: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     effects: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    damage_riders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        amount: z.ZodString;
+        damage_type: z.ZodString;
+        applies_to: z.ZodOptional<z.ZodEnum<{
+            weapon: "weapon";
+            spell: "spell";
+            all: "all";
+        }>>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    scroll_level: z.ZodOptional<z.ZodNumber>;
+    unidentified: z.ZodOptional<z.ZodBoolean>;
+    masked_category: z.ZodOptional<z.ZodString>;
     raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     damage_dice: z.ZodOptional<z.ZodString>;
     damage_type: z.ZodOptional<z.ZodString>;

package/dist/item/item.schema.js

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

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

@@ -97,6 +97,23 @@ export interface ItemEntity {
     description?: string;
     entries?: unknown[];
     effects?: unknown[];
+    /** Structured additive on-hit damage riders (e.g. Flame Tongue "+2d6 fire",
+     *  Wounding "+2d6 necrotic"). Read per-weapon in the equipment builder →
+     *  AttackRow.damageRiders. `amount` is a dice/flat string. */
+    damage_riders?: Array<{
+        amount: string;
+        damage_type: string;
+        applies_to?: "weapon" | "spell" | "all";
+        condition?: string;
+    }>;
+    /** Spell-scroll casting level (e.g. 3 for a "Spell Scroll (3rd Level)"). */
+    scroll_level?: number;
+    /** Marks an item the player has not yet identified: the sheet shows the
+     *  masked_category label instead of the item's true identity. */
+    unidentified?: boolean;
+    /** Generic category label shown for an unidentified item (e.g. "potion",
+     *  "scroll", "wand") in place of its real name. */
+    masked_category?: string;
     raw?: Record<string, unknown>;
     damage_dice?: string;
     damage_type?: string;

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

@@ -5,9 +5,16 @@ import {
   collectChosenAbilityPoints,
   collectChosenProficiencies,
   wikilinkTailSlug
-} from "../chunk-TJCNX6UZ.js";
+} from "../chunk-R5SQHP2X.js";
 import "../chunk-BH6AMZVY.js";
+import "../chunk-UC4FE5X3.js";
+import "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+import "../chunk-J2RYSZMQ.js";
+import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   __matchesFilterForTest,

package/dist/pc/pc.equipment.d.ts

@@ -1,6 +1,7 @@
 import type { EntityRegistry } from "@archivist-gg/core";
 import type { Ability } from "@archivist-gg/dnd5e";
 import type { AppliedBonuses, DerivedEquipment, ResolvedCharacter, ProficiencySet } from "./pc.types.js";
+import type { WeaponAbilityOverride } from "./pc.feature-effects.js";
 interface ProficienciesForQuery {
     armor: ProficiencySet;
     weapons: ProficiencySet;
@@ -8,5 +9,5 @@ interface ProficienciesForQuery {
 }
 export declare function emptyAppliedBonuses(): AppliedBonuses;
 export declare function computeAppliedBonuses(resolved: ResolvedCharacter, _profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[]): AppliedBonuses;
-export declare function computeSlotsAndAttacks(resolved: ResolvedCharacter, mods: Record<Ability, number>, profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[], proficiencyBonus: number, weaponAbilityOverride?: Ability): DerivedEquipment;
+export declare function computeSlotsAndAttacks(resolved: ResolvedCharacter, mods: Record<Ability, number>, profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[], proficiencyBonus: number, weaponAbilities?: WeaponAbilityOverride[], weaponMasteries?: string[]): DerivedEquipment;
 export {};

package/dist/pc/pc.equipment.js

@@ -2,12 +2,20 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-QQ5W2AZP.js";
+} from "../chunk-TQZB4OCJ.js";
+import "../chunk-R5SQHP2X.js";
+import "../chunk-BH6AMZVY.js";
 import "../chunk-UC4FE5X3.js";
+import "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-JEYQU3JT.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
 import "../chunk-DC74TZNA.js";
 import "../chunk-3TRGRSCH.js";
+import "../chunk-J2RYSZMQ.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
 export {
   computeAppliedBonuses,
   computeSlotsAndAttacks,

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

@@ -1,13 +1,25 @@
 import type { SenseType } from "@archivist-gg/dnd5e/types/feature-effect";
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { ResolvedFeature, RollModifierEntry } from "./pc.types.js";
+import type { DamageRider, ResolvedFeature, RollModifierEntry } from "./pc.types.js";
+/**
+ * A melee-attack ability override from a `weapon-ability` effect. `weaponSlugs`
+ * (bare, namespace-stripped) scopes the override to matching weapon types only;
+ * empty/absent `weaponSlugs` = GLOBAL (applies to every melee weapon). The
+ * `"spellcasting"` sentinel is NOT stored here — it is resolved against the
+ * caster ability in recalc and prepended as a global.
+ */
+export interface WeaponAbilityOverride {
+    ability: Ability;
+    weaponSlugs?: string[];
+}
 /**
  * Aggregated passive feature effects (effects-application engine).
  * One pure scan over resolved.features[].feature.effects[]. Merge semantics
  * mirror pc.conditions mergePartial: numbers add, each sense range takes max,
- * lists union case-insensitively. apply-condition and damage-bonus are action/attack
- * time and intentionally not aggregated; `while`-gated immune-condition
- * entries are skipped entirely (conditional effects are a named deferral).
+ * lists union case-insensitively. apply-condition is action time and
+ * intentionally not aggregated; `damage-bonus` folds into damageBonuses (additive
+ * on-hit riders); `while`-gated immune-condition entries are skipped entirely
+ * (conditional effects are a named deferral).
  */
 export interface FeatureEffectTotals {
     initiative_bonus: number;
@@ -46,12 +58,15 @@ export interface FeatureEffectTotals {
         weapons: string[];
     };
     /**
-     * v1 global melee-attack ability override (Hexblade "Lies", etc.). The first
-     * `weapon-ability` effect with a concrete ability (not `"spellcasting"`) wins;
-     * `"spellcasting"` is resolved against the caster ability in recalc. `weapons`
-     * scope is parsed but ignored here (global override). null = no override.
+     * Melee-attack ability overrides (Hexblade "Lies", MCDM Illrigger scoped
+     * "Lies", etc.), in fold order. Each carries an optional `weaponSlugs` scope
+     * (bare slugs) — absent/empty = GLOBAL (every melee weapon). The
+     * `"spellcasting"` sentinel is excluded here (no caster context in the fold);
+     * recalc resolves it and prepends the resolved global so it wins over concrete
+     * globals. recalc threads this list into attack computation, where a
+     * scoped-match wins over a global for the matching weapon. [] = no override.
      */
-    weaponAbility: Ability | null;
+    weaponAbilities: WeaponAbilityOverride[];
     /**
      * Order-preserving list of structured advantage/disadvantage entries from
      * `roll-modifier` effects. Pass-through (no dedupe/merge); each entry is
@@ -79,6 +94,13 @@ export interface FeatureEffectTotals {
      * non-empty, so untouched attack rows keep `attackNotes: undefined`.
      */
     attackNotes: string[];
+    /**
+     * Additive on-hit damage riders from `damage-bonus` effects with
+     * `applies_to` weapon/all (spell-only ignored — no spell surface). Each is
+     * labeled with the owning feature's name. recalc merges these onto every
+     * weapon AttackRow's `damageRiders`.
+     */
+    damageBonuses: DamageRider[];
 }
 export declare function emptyFeatureEffectTotals(): FeatureEffectTotals;
 /**

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

@@ -1,7 +1,17 @@
 import {
   computeFeatureEffects,
   emptyFeatureEffectTotals
-} from "../chunk-XURS6Q6Q.js";
+} from "../chunk-V6SOFUJW.js";
+import "../chunk-R5SQHP2X.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-UC4FE5X3.js";
+import "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-JEYQU3JT.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+import "../chunk-J2RYSZMQ.js";
+import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   computeFeatureEffects,

package/dist/pc/pc.parser.js

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

package/dist/pc/pc.pools.js

@@ -2,11 +2,16 @@ import {
   levelPrereqMax,
   resolveAllPools,
   resolvePool
-} from "../chunk-6PXE7T7C.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-TJCNX6UZ.js";
+} from "../chunk-R5SQHP2X.js";
 import "../chunk-BH6AMZVY.js";
+import "../chunk-UC4FE5X3.js";
+import "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+import "../chunk-J2RYSZMQ.js";
+import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   levelPrereqMax,

package/dist/pc/pc.recalc.js

@@ -1,27 +1,27 @@
-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";
+} from "../chunk-TQZB4OCJ.js";
 import {
   computeFeatureEffects
-} from "../chunk-XURS6Q6Q.js";
+} from "../chunk-V6SOFUJW.js";
+import {
+  collectChosenAbilityPoints,
+  collectChosenProficiencies
+} from "../chunk-R5SQHP2X.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-UC4FE5X3.js";
+import {
+  computeSpellLimits,
+  deriveSpellSlots,
+  resolveSpellcasting
+} from "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-JEYQU3JT.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
 import "../chunk-DC74TZNA.js";
@@ -362,24 +362,26 @@ 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;
+  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;
   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 : []) {
-      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 }
-        });
-      }
-    }
+    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 profsForApply = computeProficiencies(resolved);
@@ -443,19 +445,20 @@ function recalc(resolved, registry) {
     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 : []);
+  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 : []);
   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 override = (_i = overrides.saves) == null ? void 0 : _i[ab];
+    const prof = (_j = override == null ? void 0 : override.proficient) != null ? _j : 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;
+    const bonus = (_k = override == null ? void 0 : override.bonus) != null ? _k : 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 : [],
     ...chosenProfs.skills,
     ...featureEffects.proficiencies.skills
   ]);
@@ -464,9 +467,9 @@ function recalc(resolved, registry) {
   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;
+    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;
     skills[skillKey] = {
       bonus,
       proficiency: tri,
@@ -477,16 +480,16 @@ function recalc(resolved, registry) {
   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)
+    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)
   };
   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 hpMax = (_x = (_w = overrides.hp) == null ? void 0 : _w.max) != null ? _x : 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 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");
@@ -501,14 +504,14 @@ function recalc(resolved, registry) {
         break;
       }
     }
-    if (primaryCasterAbility) weaponAbility = primaryCasterAbility;
+    if (primaryCasterAbility) weaponAbilities.unshift({ ability: 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);
+    derivedEquipment = computeSlotsAndAttacks(resolved, mods, profsForApply, registry, warnings, proficiencyBonus, weaponAbilities, (_y = resolved.weaponMasteries) != null ? _y : []);
     if (derivedEquipment.equippedSlots.armor) {
       const featTerms = featureAcTermsFor(true);
       acDerived = derivedEquipment.ac + sumTerms(featTerms);
@@ -531,16 +534,16 @@ function recalc(resolved, registry) {
     acDerived = total + sumTerms(featTerms);
     acBreakdownDerived = [...terms, ...featTerms];
   }
-  const ac = (_A = overrides.ac) != null ? _A : acDerived;
+  const ac = (_z = overrides.ac) != null ? _z : 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;
+  const speed = (_A = overrides.speed) != null ? _A : 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 init = (_B = overrides.initiative) != null ? _B : 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),
+    darkvision: Math.max((_E = (_D = (_C = resolved.race) == null ? void 0 : _C.vision) == null ? void 0 : _D.darkvision) != null ? _E : 0, featureEffects.senses.darkvision, applied.senses.darkvision),
     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)
@@ -558,8 +561,8 @@ function recalc(resolved, registry) {
       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,
+      saveDC: (_G = (_F = overrides.spellcasting) == null ? void 0 : _F.saveDC) != null ? _G : dc,
+      attackBonus: (_I = (_H = overrides.spellcasting) == null ? void 0 : _H.attackBonus) != null ? _I : atk,
       casterType: profile.casterType,
       preparation: profile.preparation
     });
@@ -571,24 +574,33 @@ function recalc(resolved, registry) {
     saveDC: spellcastingClasses[0].saveDC,
     attackBonus: spellcastingClasses[0].attackBonus
   } : null;
+  const abilitySpellcasting = {};
+  for (const s of resolved.spells) {
+    const ab = s.ability;
+    if (!ab || abilitySpellcasting[ab]) continue;
+    abilitySpellcasting[ab] = {
+      saveDC: saveDC(scores[ab], proficiencyBonus) + applied.spell_save_dc,
+      attackBonus: attackBonus(scores[ab], proficiencyBonus) + applied.spell_attack
+    };
+  }
   const derivedSlots = deriveSpellSlots(slotInputs);
   const spellLimits = computeSpellLimits(limitInputs);
   const defenses = {
     resistances: dedupeDefenseList([
-      (_L = (_K = resolved.definition.defenses) == null ? void 0 : _K.resistances) != null ? _L : [],
+      (_K = (_J = resolved.definition.defenses) == null ? void 0 : _J.resistances) != null ? _K : [],
       applied.defenses.resistances,
       featureEffects.resistances
     ]),
     immunities: dedupeDefenseList([
-      (_N = (_M = resolved.definition.defenses) == null ? void 0 : _M.immunities) != null ? _N : [],
+      (_M = (_L = resolved.definition.defenses) == null ? void 0 : _L.immunities) != null ? _M : [],
       applied.defenses.immunities
     ]),
     vulnerabilities: dedupeDefenseList([
-      (_P = (_O = resolved.definition.defenses) == null ? void 0 : _O.vulnerabilities) != null ? _P : [],
+      (_O = (_N = resolved.definition.defenses) == null ? void 0 : _N.vulnerabilities) != null ? _O : [],
       applied.defenses.vulnerabilities
     ]),
     condition_immunities: dedupeDefenseList([
-      (_R = (_Q = resolved.definition.defenses) == null ? void 0 : _Q.condition_immunities) != null ? _R : [],
+      (_Q = (_P = resolved.definition.defenses) == null ? void 0 : _P.condition_immunities) != null ? _Q : [],
       applied.defenses.condition_immunities,
       featureEffects.condition_immunities
     ])
@@ -613,6 +625,7 @@ function recalc(resolved, registry) {
     initiative: init,
     spellcasting,
     spellcastingClasses,
+    abilitySpellcasting,
     derivedSpellSlots: derivedSlots.standard,
     pactMagic: derivedSlots.pact,
     spellLimits,
@@ -630,16 +643,21 @@ 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: ((_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,
+    attacks: ((_R = derivedEquipment == null ? void 0 : derivedEquipment.attacks) != null ? _R : []).map((a) => {
+      var _a2;
+      const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses];
+      return {
+        ...a,
+        toHit: a.toHit + conditionEffects.d20_test_penalty,
+        ...featureEffects.critRange < 20 ? { critRange: featureEffects.critRange } : {},
+        ...featureEffects.attackNotes.length ? { attackNotes: featureEffects.attackNotes } : {},
+        ...riders.length ? { damageRiders: riders } : {}
+      };
+    }),
+    equippedSlots: (_S = derivedEquipment == null ? void 0 : derivedEquipment.equippedSlots) != null ? _S : {},
+    carriedWeight: (_T = derivedEquipment == null ? void 0 : derivedEquipment.carriedWeight) != null ? _T : 0,
+    attunementUsed: (_U = derivedEquipment == null ? void 0 : derivedEquipment.attunementUsed) != null ? _U : 0,
+    attunementLimit: (_W = derivedEquipment == null ? void 0 : derivedEquipment.attunementLimit) != null ? _W : (_V = overrides.attunement_limit) != null ? _V : 3,
     conditionEffects,
     rollModifiers: featureEffects.rollModifiers
   };