@archivist-gg/dnd5e 0.1.0 → 0.1.1

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,16 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-QQ5W2AZP.js";
+} from "../chunk-ADLTSHOR.js";
 import "../chunk-UC4FE5X3.js";
+import "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-JEYQU3JT.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
 import "../chunk-DC74TZNA.js";
 import "../chunk-3TRGRSCH.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,10 @@
 import {
   computeFeatureEffects,
   emptyFeatureEffectTotals
-} from "../chunk-XURS6Q6Q.js";
+} from "../chunk-GEJSJP6E.js";
+import "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-JEYQU3JT.js";
 import "../chunk-WP2CX2JO.js";
 export {
   computeFeatureEffects,

package/dist/pc/pc.recalc.js

@@ -7,21 +7,21 @@ 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";
+} from "../chunk-ADLTSHOR.js";
 import "../chunk-UC4FE5X3.js";
 import {
   computeFeatureEffects
-} from "../chunk-XURS6Q6Q.js";
+} from "../chunk-GEJSJP6E.js";
+import {
+  collectChosenAbilityPoints,
+  collectChosenProficiencies
+} from "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.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
     });
@@ -575,20 +578,20 @@ function recalc(resolved, registry) {
   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
     ])
@@ -630,16 +633,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
   };

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

@@ -15,6 +15,18 @@ export declare class PCResolver {
     get registry(): EntityRegistry;
     resolve(character: Character): ResolveResult;
 }
+/**
+ * 2024 Weapon Mastery: unions the persisted `weapon-mastery` picks across every
+ * class/level `ClassEntry.choices[level]["weapon-mastery"]`. Returns both the
+ * ORIGINAL full picked slugs (`full` — used for exact-match display-name lookup)
+ * and their BARE-normalized form (`bare` — e.g. "srd-2024_greatsword" →
+ * "greatsword"), each de-duplicated in first-seen order. Bare-authored picks
+ * normalize to themselves. Non-string / non-array picks are ignored.
+ */
+export declare function collectChosenWeaponMasteries(character: Character): {
+    bare: string[];
+    full: string[];
+};
 /**
  * Walks class.choices for `feat` entries and adds background feat slugs.
  * Returns bare slugs (no `[[ ]]`).

package/dist/pc/pc.resolver.js

@@ -6,7 +6,9 @@ import {
   resolveSpellcasting
 } from "../chunk-IXZXFFFW.js";
 import "../chunk-5XUXXAQJ.js";
-import "../chunk-TJCNX6UZ.js";
+import {
+  bareEntitySlug
+} from "../chunk-TJCNX6UZ.js";
 import "../chunk-BH6AMZVY.js";
 import "../chunk-JEYQU3JT.js";
 import "../chunk-J2RYSZMQ.js";
@@ -75,6 +77,27 @@ var PCResolver = class {
       const prep = isCantrip || n.alwaysPrepared ? true : (_e = n.preparedFlag) != null ? _e : false;
       spells.push({ entity, slug: n.slug, classSlug, source: n.source, prepared: prep, alwaysPrepared: n.alwaysPrepared });
     }
+    const chosenMasteries = collectChosenWeaponMasteries(character);
+    if (chosenMasteries.full.length > 0) {
+      const target = features.find(
+        (rf) => {
+          var _a2;
+          return rf.feature.id === "weapon-mastery" || ((_a2 = rf.feature.choices) == null ? void 0 : _a2.some(
+            (ch) => ch.kind === "select-entity" && ch.id === "weapon-mastery" && ch.entity_type === "weapon"
+          ));
+        }
+      );
+      if (target) {
+        const names = chosenMasteries.full.map(
+          (fullSlug) => {
+            var _a2, _b2;
+            return (_b2 = (_a2 = this.entities.getByTypeAndSlug("weapon", fullSlug)) == null ? void 0 : _a2.name) != null ? _b2 : fullSlug;
+          }
+        );
+        const entry = { label: "Mastered weapons", description: names.join(", ") };
+        target.chosenInline = target.chosenInline ? [...target.chosenInline, entry] : [entry];
+      }
+    }
     const resolvedCharacter = {
       definition: character,
       race,
@@ -85,12 +108,26 @@ var PCResolver = class {
       features,
       spells,
       pools: [],
+      weaponMasteries: chosenMasteries.bare,
       state: character.state
     };
     resolvedCharacter.pools = resolveAllPools(resolvedCharacter, this.entities);
     return { character: resolvedCharacter, warnings };
   }
 };
+function collectChosenWeaponMasteries(character) {
+  var _a, _b;
+  const full = /* @__PURE__ */ new Set();
+  for (const cls of (_a = character.class) != null ? _a : []) {
+    for (const lvl of Object.values((_b = cls.choices) != null ? _b : {})) {
+      const pick = lvl["weapon-mastery"];
+      if (Array.isArray(pick)) {
+        for (const s of pick) if (typeof s === "string") full.add(s);
+      }
+    }
+  }
+  return { full: [...full], bare: [...new Set([...full].map(bareEntitySlug))] };
+}
 function collectFeatSlugs(character) {
   const slugs = /* @__PURE__ */ new Set();
   for (const c of character.class) {
@@ -119,8 +156,12 @@ function collectChosenGrantedFeatures(character, classes, registry, race = null,
       const features = (_b2 = ((_a2 = entity.features_by_level) != null ? _a2 : {})[lvl]) != null ? _b2 : [];
       const subFeatures = c.subclass ? (_d = ((_c = c.subclass.features_by_level) != null ? _c : {})[lvl]) != null ? _d : [] : [];
       for (const feature of [...features, ...subFeatures]) {
-        walkChoiceGrants(feature.choices, atLevel, (granted) => {
-          out.push({ feature: granted, source: { kind: "class", slug: entity.slug, level: lvl } });
+        walkChoiceGrants(feature.choices, atLevel, (granted, suppress) => {
+          out.push({
+            feature: granted,
+            source: { kind: "class", slug: entity.slug, level: lvl },
+            ...suppress ? { renderSuppressed: true } : {}
+          });
         }, registry);
       }
     }
@@ -135,8 +176,12 @@ function collectChosenGrantedFeatures(character, classes, registry, race = null,
   };
   if (race) {
     const atRace = originAt("race");
-    const emitRace = (granted) => {
-      out.push({ feature: granted, source: { kind: "race", slug: race.slug } });
+    const emitRace = (granted, suppress) => {
+      out.push({
+        feature: granted,
+        source: { kind: "race", slug: race.slug },
+        ...suppress ? { renderSuppressed: true } : {}
+      });
     };
     walkChoiceGrants(race.choices, atRace, emitRace, registry);
     for (const trait of (_b = race.traits) != null ? _b : []) {
@@ -145,8 +190,12 @@ function collectChosenGrantedFeatures(character, classes, registry, race = null,
   }
   if (background) {
     const atBg = originAt("background");
-    const emitBg = (granted) => {
-      out.push({ feature: granted, source: { kind: "background", slug: background.slug } });
+    const emitBg = (granted, suppress) => {
+      out.push({
+        feature: granted,
+        source: { kind: "background", slug: background.slug },
+        ...suppress ? { renderSuppressed: true } : {}
+      });
     };
     walkChoiceGrants(background.choices, atBg, emitBg, registry);
     if (background.feature) {
@@ -156,7 +205,7 @@ function collectChosenGrantedFeatures(character, classes, registry, race = null,
   return out;
 }
 function walkChoiceGrants(choices, atLevel, emit, registry) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e;
   for (const ch of choices != null ? choices : []) {
     const sel = atLevel[ch.id];
     if (ch.kind === "select-entity" && ch.entity_type === "optional-feature") {
@@ -177,14 +226,39 @@ function walkChoiceGrants(choices, atLevel, emit, registry) {
     if (ch.kind === "select-inline") {
       const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
       if ((_d = branch == null ? void 0 : branch.effects) == null ? void 0 : _d.length) {
-        emit({ id: `${ch.id}-${branch.value}`, name: branch.label, description: branch.description, effects: branch.effects });
+        const wc = (_e = branch.choices) == null ? void 0 : _e.find(
+          (c) => c.kind === "select-entity" && c.entity_type === "weapon"
+        );
+        const picked = wc ? atLevel == null ? void 0 : atLevel[wc.id] : void 0;
+        const effects = branch.effects.map(
+          (e) => e.kind === "weapon-ability" && e.weapons === "chosen" && typeof picked === "string" ? { ...e, weapons: [bareEntitySlug(picked)] } : e
+        );
+        emit({ id: `${ch.id}-${branch.value}`, name: branch.label, description: branch.description, effects }, true);
       }
       if (branch == null ? void 0 : branch.choices) walkChoiceGrants(branch.choices, atLevel, emit, registry);
     }
   }
 }
+function resolveChosenInline(feature, atLevel) {
+  var _a;
+  if (!atLevel) return void 0;
+  const picks = [];
+  for (const ch of (_a = feature.choices) != null ? _a : []) {
+    if (ch.kind !== "select-inline") continue;
+    const sel = atLevel[ch.id];
+    if (typeof sel !== "string") continue;
+    const opt = ch.options.find((o) => o.value === sel);
+    if (!opt) continue;
+    picks.push({ label: opt.label, description: opt.description });
+  }
+  return picks.length ? picks : void 0;
+}
+function isAsiSlotFeature(feature) {
+  var _a, _b, _c, _d;
+  return feature.id === "ability-score-improvement" && !((_a = feature.effects) == null ? void 0 : _a.length) && !((_b = feature.resources) == null ? void 0 : _b.length) && !feature.action && !((_c = feature.sub_features) == null ? void 0 : _c.length) && !((_d = feature.attacks) == null ? void 0 : _d.length);
+}
 function collectResolvedFeatures(race, classes, background, feats) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
   const out = [];
   for (const c of classes) {
     if (!c.entity) continue;
@@ -194,10 +268,16 @@ function collectResolvedFeatures(race, classes, background, feats) {
       const lvl = parseInt(lvlStr, 10);
       if (Number.isNaN(lvl) || lvl > c.level) continue;
       for (const feat of feats0) {
-        out.push({ feature: feat, source: { kind: "class", slug, level: lvl } });
+        const chosenInline = resolveChosenInline(feat, (_b = c.choices) == null ? void 0 : _b[lvl]);
+        out.push({
+          feature: feat,
+          source: { kind: "class", slug, level: lvl },
+          ...chosenInline ? { chosenInline } : {},
+          ...isAsiSlotFeature(feat) ? { buildOnly: true } : {}
+        });
       }
     }
-    if ((_b = c.entity.resources) == null ? void 0 : _b.length) {
+    if ((_c = c.entity.resources) == null ? void 0 : _c.length) {
       out.push({
         feature: { name: c.entity.name, resources: c.entity.resources },
         source: { kind: "class", slug, level: 1 }
@@ -205,15 +285,21 @@ function collectResolvedFeatures(race, classes, background, feats) {
     }
     if (c.subclass) {
       const sSlug = c.subclass.slug;
-      const sByLevel = (_c = c.subclass.features_by_level) != null ? _c : {};
+      const sByLevel = (_d = c.subclass.features_by_level) != null ? _d : {};
       for (const [lvlStr, feats0] of Object.entries(sByLevel)) {
         const lvl = parseInt(lvlStr, 10);
         if (Number.isNaN(lvl) || lvl > c.level) continue;
         for (const feat of feats0) {
-          out.push({ feature: feat, source: { kind: "subclass", slug: sSlug, level: lvl } });
+          const chosenInline = resolveChosenInline(feat, (_e = c.choices) == null ? void 0 : _e[lvl]);
+          out.push({
+            feature: feat,
+            source: { kind: "subclass", slug: sSlug, level: lvl },
+            ...chosenInline ? { chosenInline } : {},
+            ...isAsiSlotFeature(feat) ? { buildOnly: true } : {}
+          });
         }
       }
-      if ((_d = c.subclass.resources) == null ? void 0 : _d.length) {
+      if ((_f = c.subclass.resources) == null ? void 0 : _f.length) {
         out.push({
           feature: { name: c.subclass.name, resources: c.subclass.resources },
           source: { kind: "subclass", slug: sSlug, level: 1 }
@@ -222,7 +308,7 @@ function collectResolvedFeatures(race, classes, background, feats) {
     }
   }
   if (race) {
-    const traits = (_e = race.traits) != null ? _e : [];
+    const traits = (_g = race.traits) != null ? _g : [];
     for (const feat of traits) {
       out.push({ feature: feat, source: { kind: "race", slug: race.slug } });
     }
@@ -234,8 +320,8 @@ function collectResolvedFeatures(race, classes, background, feats) {
     }
   }
   for (const feat of feats) {
-    const bundled = (_f = feat.features) != null ? _f : [];
-    const entityEffects = (_g = feat.effects) != null ? _g : [];
+    const bundled = (_h = feat.features) != null ? _h : [];
+    const entityEffects = (_i = feat.effects) != null ? _i : [];
     if (bundled.length > 0) {
       bundled.forEach((f, i) => {
         var _a2;
@@ -243,16 +329,18 @@ function collectResolvedFeatures(race, classes, background, feats) {
         out.push({ feature, source: { kind: "feat", slug: feat.slug } });
       });
     } else {
-      const name = (_h = feat.name) != null ? _h : feat.slug;
-      const description = (_i = feat.description) != null ? _i : "";
+      const name = (_j = feat.name) != null ? _j : feat.slug;
+      const foldedDesc = [feat.description, ...(_k = feat.benefits) != null ? _k : []].filter(Boolean).join("\n\n") || void 0;
+      const buildOnly = ((_l = feat.choices) != null ? _l : []).some((c) => c.kind === "ability-points" && c.points >= 2) && !((_m = feat.effects) == null ? void 0 : _m.length) && !((_n = feat.resources) == null ? void 0 : _n.length) && bundled.length === 0;
       out.push({
         feature: {
           name,
-          description,
+          ...foldedDesc ? { description: foldedDesc } : {},
           ...feat.resources ? { resources: feat.resources } : {},
           ...entityEffects.length > 0 ? { effects: entityEffects } : {}
         },
-        source: { kind: "feat", slug: feat.slug }
+        source: { kind: "feat", slug: feat.slug },
+        ...buildOnly ? { buildOnly: true } : {}
       });
     }
   }
@@ -261,6 +349,7 @@ function collectResolvedFeatures(race, classes, background, feats) {
 export {
   PCResolver,
   collectChosenGrantedFeatures,
+  collectChosenWeaponMasteries,
   collectFeatSlugs,
   collectResolvedFeatures,
   stripSlug