@archivist-gg/dnd5e 0.3.19 → 0.3.26

package/dist/pc/pc.entry-overrides.js

@@ -1,41 +1 @@
-import {
-  WEAPON_DEFAULT_ACTION_COST,
-  customizableOverrideKeys,
-  defaultActionCost,
-  effectiveItemArmorClass,
-  effectiveItemCharges,
-  effectiveItemRecovery,
-  isCastableScroll,
-  isConsumedOnUse,
-  isScrollEntity,
-  isWeaponLikeEntry,
-  itemChargesMax,
-  scrollSpellCost
-} from "../chunk-NXUY5XQN.js";
-import "../chunk-W6GC6OKK.js";
-import "../chunk-B3DP42OM.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-ZUQW5VBZ.js";
-import "../chunk-IHE6KVC3.js";
-import "../chunk-LHZXYFBU.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-CM5CWO4K.js";
-import "../chunk-4J6DS3EJ.js";
-import "../chunk-ZCTUYGNV.js";
-import "../chunk-3TM34RSJ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  WEAPON_DEFAULT_ACTION_COST,
-  customizableOverrideKeys,
-  defaultActionCost,
-  effectiveItemArmorClass,
-  effectiveItemCharges,
-  effectiveItemRecovery,
-  isCastableScroll,
-  isConsumedOnUse,
-  isScrollEntity,
-  isWeaponLikeEntry,
-  itemChargesMax,
-  scrollSpellCost
-};
+import{WEAPON_DEFAULT_ACTION_COST,customizableOverrideKeys,defaultActionCost,effectiveItemArmorClass,effectiveItemCharges,effectiveItemRecovery,isCastableScroll,isConsumedOnUse,isScrollEntity,isWeaponLikeEntry,itemChargesMax,itemSpellUse,scrollSpellCost,settableSpellLevel,storedSpellNumbers,storesSpell}from"../chunk-PKIMOVQG.js";import"../chunk-CMIEZQL4.js";import"../chunk-CSTAQQGX.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-63YJPWTM.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{WEAPON_DEFAULT_ACTION_COST,customizableOverrideKeys,defaultActionCost,effectiveItemArmorClass,effectiveItemCharges,effectiveItemRecovery,isCastableScroll,isConsumedOnUse,isScrollEntity,isWeaponLikeEntry,itemChargesMax,itemSpellUse,scrollSpellCost,settableSpellLevel,storedSpellNumbers,storesSpell};

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

@@ -10,33 +10,13 @@ interface ProficienciesForQuery {
 }
 export declare function emptyAppliedBonuses(): AppliedBonuses;
 export declare function computeAppliedBonuses(resolved: ResolvedCharacter, _profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[]): AppliedBonuses;
-/** The LIVE weapon-proficiency gate · the one the attack pipeline calls at
- *  `computeAttacks` below. Exported for the overlay effect-slug guard
- *  (`tests/srd-canonical/overlay-effect-slugs.test.ts`), which validates
- *  authored `proficiency_type: weapon` values by asking this function whether
- *  any SRD weapon comes out proficient. Note `pc.proficiency-query.ts`'s
- *  `isProficientWithWeapon` is a near-twin with NO production callers · it
- *  differs on the third arm (it compares only the base category, this one also
- *  accepts the full hyphenated form), so guards wanting runtime fidelity must
- *  use THIS one. */
+export declare function pactWeaponIndexes(resolved: Pick<ResolvedCharacter, "pactWeapon" | "definition">, registry?: EntityRegistry | null): Set<number> | null;
 export declare function isWeaponSlugProficient(weapon: WeaponEntity, weaponSlug: string, profs: ProficienciesForQuery): boolean;
-/** The die and ability set an `unarmed-strike` effect (or its synthetic) resolved for this character (R4-G6b §5.1). */
 export interface UnarmedStrikeSpec {
     dice?: string;
     abilities?: Ability[];
 }
-/** The always-present Unarmed Strike row (R4-G6b §5.1): 1 + the modifier bludgeoning, 5 ft., always proficient. With a
- *  DIE the damage string reproduces the OUTPUT of `buildAttackRow`'s `formatDice` (a closure over `dmgFlat` that cannot
- *  be called): the flat part's `^\+0$` strip equals the whole-string `\+0$` strip for every modifier, so a die reads
- *  `1d6-1`. With NO die the base is the number 1, and a signed suffix on a number is unevaluated arithmetic (`1-1`,
- *  `1+3`), so the flat base prints EVALUATED and floored at 0: `String(Math.max(0, 1 + mod))` (R4-G7 T8 RIDER-10; the
- *  user's Q-3 "1 + STR" is the formula, the evaluated number its display). The
- *  ability is STR unless the spec lists others; the highest modifier wins and a LATER candidate wins a tie, so a
- *  listed DEX beats STR on a tie (the shipped finesse idiom `mods.dex >= mods.str`). Called from recalc, which owns
- *  the walk that produces `spec`; never from `computeAttacks`, so the row is present with or without a registry.
- *  The `subLabel` is an ENGINE string, printed as it ships: the sheet humanizes a weapon's category tokens, and
- *  this row carries no weapon, so `Unarmed` is capitalised here beside `Unarmed Strike`, `5 ft.` and `bludgeoning`
- *  rather than in a renderer (R4-G6b live rider R-1). */
 export declare function buildUnarmedRow(mods: Record<Ability, number>, proficiencyBonus: number, spec?: UnarmedStrikeSpec): AttackRow;
+export declare function buildFeatureAttackRows(resolved: Pick<ResolvedCharacter, "features">, mods: Record<Ability, number>, profs: ProficienciesForQuery, proficiencyBonus: number, weaponAbilities?: WeaponAbilityOverride[]): AttackRow[];
 export declare function computeSlotsAndAttacks(resolved: ResolvedCharacter, mods: Record<Ability, number>, profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[], proficiencyBonus: number, weaponAbilities?: WeaponAbilityOverride[], weaponMasteries?: string[], attunementFloor?: number): DerivedEquipment;
 export {};

package/dist/pc/pc.equipment.js

@@ -1,34 +1 @@
-import {
-  buildUnarmedRow,
-  computeAppliedBonuses,
-  computeSlotsAndAttacks,
-  emptyAppliedBonuses,
-  isWeaponSlugProficient
-} from "../chunk-7XJHI5H5.js";
-import "../chunk-3LWMFYKS.js";
-import "../chunk-YDGMBMYI.js";
-import "../chunk-EJP263OP.js";
-import "../chunk-5JXFJ5AU.js";
-import "../chunk-NXUY5XQN.js";
-import "../chunk-W6GC6OKK.js";
-import "../chunk-B3DP42OM.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-ZUQW5VBZ.js";
-import "../chunk-IHE6KVC3.js";
-import "../chunk-HHBD4SQ6.js";
-import "../chunk-A54HHCWW.js";
-import "../chunk-LHZXYFBU.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-CM5CWO4K.js";
-import "../chunk-4J6DS3EJ.js";
-import "../chunk-ZCTUYGNV.js";
-import "../chunk-3TM34RSJ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  buildUnarmedRow,
-  computeAppliedBonuses,
-  computeSlotsAndAttacks,
-  emptyAppliedBonuses,
-  isWeaponSlugProficient
-};
+import{buildFeatureAttackRows,buildUnarmedRow,computeAppliedBonuses,computeSlotsAndAttacks,emptyAppliedBonuses,isWeaponSlugProficient,pactWeaponIndexes}from"../chunk-E3MS4M3N.js";import"../chunk-T55DELVL.js";import"../chunk-SEOASDO4.js";import"../chunk-4E2GIWJE.js";import"../chunk-GD7WRCNH.js";import"../chunk-FOLHTMSC.js";import"../chunk-4JEF3CET.js";import"../chunk-VTQ4RWEG.js";import"../chunk-J3RP5C7L.js";import"../chunk-WAUNLUFQ.js";import"../chunk-PKIMOVQG.js";import"../chunk-CMIEZQL4.js";import"../chunk-CSTAQQGX.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-NEMX7QGG.js";import"../chunk-56JK6VCL.js";import"../chunk-4IAMSRHD.js";import"../chunk-3QQOATV3.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-63YJPWTM.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";import"../chunk-ZVL5FXXO.js";export{buildFeatureAttackRows,buildUnarmedRow,computeAppliedBonuses,computeSlotsAndAttacks,emptyAppliedBonuses,isWeaponSlugProficient,pactWeaponIndexes};

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

@@ -1,41 +1,37 @@
-import type { FeatureEffect, SenseType } from "@archivist-gg/dnd5e/types/feature-effect";
+import type { FeatureEffect, SenseType, SpeedGateWord, WeaponScope } from "@archivist-gg/dnd5e/types/feature-effect";
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { DamageRider, DefenseGrant, FeatureSource, ResolvedCharacter, ResolvedFeature, RollModifierEntry, SaveOutcomeEntry, SpellDamageRider } 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.
- */
+import type { ConditionalCrit, DamageRider, DefenseGrant, DefenseItemSource, FeatureSource, SpeedMode, ResolvedCharacter, ResolvedFeature, RollModifierEntry, SaveOutcomeEntry, SpellDamageRider } from "./pc.types.js";
 export interface WeaponAbilityOverride {
     ability: Ability;
     weaponSlugs?: string[];
+    pactWeapon?: true;
+}
+export interface SpeedEffectTerm {
+    mode: SpeedMode;
+    label: string;
+    value: number;
+    set: boolean;
+    condition?: string;
+    equalsWalk?: true;
+    inactiveWhile?: SpeedGateWord[];
 }
-/**
- * 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 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;
     initiative_terms: {
         label: string;
         value: number;
     }[];
-    /** Ability-based numeric skill bonuses, resolved against final scores in recalc. */
+    initiative_amount_terms: {
+        label: string;
+        amount: string;
+        owner?: FeatureSource;
+    }[];
     skill_bonus_terms: {
         skills: string[];
         ability: Ability;
         minimum: number;
         label: string;
     }[];
-    /** SL (spec §11.2): ability-based numeric SAVE bonuses (Aura of Protection), resolved in recalc against final scores and
-     *  the character's conditions. Empty `saves` = every save; recalc keeps one term per `label`. */
     save_bonus_terms: {
         saves: Ability[];
         ability: Ability;
@@ -43,20 +39,12 @@ export interface FeatureEffectTotals {
         inactiveWhile?: "incapacitated" | "unconscious";
         label: string;
     }[];
-    /**
-     * Half-proficiency terms (Jack of All Trades, Remarkable Athlete). Resolved in recalc against the
-     * proficiency bonus, and ONLY for a skill whose effective tri is "none" — that gate is the mechanic
-     * ("a skill proficiency you lack"), so it lives at the consumer, not here. Empty `skills` = every skill.
-     * recalc takes the MAX across terms, never the sum: "add half your Proficiency Bonus" is one grant, so two
-     * features (or a duplicated homebrew note) must not double it.
-     */
     half_proficiency_terms: {
         skills: string[];
         round: "down" | "up";
         label: string;
     }[];
     hp_per_level_bonus: number;
-    /** One term per hp-per-level-bonus effect, labeled with the owning feature's name. */
     hp_per_level_terms: {
         label: string;
         value: number;
@@ -66,95 +54,22 @@ export interface FeatureEffectTotals {
         label: string;
         value: number;
     }[];
-    /**
-     * Absolute walk-speed FLOOR from `speed-bonus` effects with `set:true` (e.g.
-     * a "base speed becomes 60" feature). Max across all set effects; 0 = none.
-     * recalc applies it as Math.max(set, race + additive bonuses) so it never
-     * lowers an already-higher speed and is independent of the additive bonus.
-     * A `scales_at` progression resolves BEFORE the max, at the effect's own source level (R4-G7 §7.3).
-     */
+    speed_terms: SpeedEffectTerm[];
+    ignore_armor_strength: string[];
     speed_walk_set: number;
-    /**
-     * Absolute attunement CAP granted by `attunement-limit` effects (the Artificer's Magic Item
-     * Adept / Savant / Master line). Max across all grants; 0 = nothing granted it. recalc applies it
-     * as Math.max(3, attunement_set) so a grant can never LOWER the baseline, and an explicit
-     * `overrides.attunement_limit` on the character still wins outright — a number the player typed is
-     * intent, not a derived value. A `scales_at` progression resolves BEFORE the max, at the effect's
-     * own source level (R4-G7 §7.3).
-     */
     attunement_set: number;
-    /** Flat ability-score bumps from `ability-score-increase` effects whose `abilities` is a FIXED LIST (the three level-20
-     *  capstones). `chosen` arms are the ASI SLOT's second encoding and MUST NOT fold (the synthesized feat decision pays
-     *  them; a flat fold double-counts). No cap: `max` is declared and unread (user ruling 2026-09-03). */
     ability_bonus: Partial<Record<Ability, number>>;
-    /** Max range per sense type granted by effects; 0 = none for that type. */
     senses: Record<SenseType, number>;
-    /** One term per ac-bonus effect, labeled with the owning feature's name. `condition` is the
-     *  effect's situational qualifier, carried verbatim onto the ACTerm and never evaluated. */
     ac_terms: {
         value: number;
         requires_armor: boolean;
         label: string;
         condition?: string;
     }[];
-    /**
-     * The four defense buckets a feature effect can grant, as DefenseGrant ENTRIES (R4-G3a §3.2.1).
-     * Deduped by value case-insensitively, first spelling wins, trimmed · exactly the contract
-     * `pushUnique` had when these were `string[]` · but the SECOND granting feature's NAME is merged
-     * into `sources` rather than discarded. `immunity` and `vulnerability` fold REGARDLESS of
-     * `condition` (following `resistance`: dropping a real immunity is worse than showing it
-     * unqualified); `immune-condition` keeps its `while` skip. Values stay in the AUTHORED spelling ·
-     * toDefenseSlug runs in pc.recalc.ts, where composeDefenseEntries turns these into DefenseEntry.
-     */
     resistances: DefenseGrant[];
     immunities: DefenseGrant[];
     vulnerabilities: DefenseGrant[];
     condition_immunities: DefenseGrant[];
-    /**
-     * skills, tools and languages are canonical slugs (toProfSlug: lowercase, U+2019
-     * folded to ASCII, whitespace collapsed to hyphens). armor and weapons entries
-     * are only `.toLowerCase()`d, NOT slugified, so an authored value keeps its
-     * spaces. recalc folds armor into armor.categories ONLY; it folds every weapons
-     * value into weapons.categories and additionally routes a non-category value
-     * into weapons.specific. saves are canonical ability keys, and are the one
-     * bucket a closed vocabulary genuinely guarantees: normalizeAbility returns null
-     * for anything else and the effect is dropped.
-     *
-     * What is INTENDED and what is ENFORCED differ here, and the gap is silent.
-     * INTENDED: skills/tools/languages land on ALL_SKILL_SLUGS / ALL_TOOLS /
-     * ALL_LANGUAGES, over which toProfSlug is the identity; armor values are
-     * CATEGORY words ("heavy"/"shield"); weapons values are a category word
-     * ("simple"/"martial", or an entity-level "martial-melee" form) or an authored
-     * weapon NAME. ENFORCED at runtime: nothing. feature-effect-schema's proficiency
-     * arm is `value: z.string().min(1)`, an OPEN string, and classifyProficiencyEffect
-     * does no membership test. The only guard is
-     * tests/srd-canonical/overlay-effect-slugs.test.ts, and it sees OVERLAY-AUTHORED
-     * data only · there skill/tool/language are checked against those three lists and
-     * weapon against the live gate, while armor and saving-throw are unchecked even
-     * there. Vault homebrew reaching this at runtime is checked by nothing.
-     *
-     * An off-vocabulary value does not crash and does not disappear · it becomes a
-     * value that can never coincide with the canonical one. Measured: an authored
-     * `{proficiency_type:"tool", value:"Playing Card Set"}` normalizes to
-     * "playing-card-set", which is NOT in ALL_TOOLS (that list carries the 2024
-     * spelling "playing-cards"). It still folds, and still renders as its own row
-     * labeled "Playing Card Set", but everything keyed on the canonical slug · the
-     * first-seen-wins dedupe in computeEffectiveProficiencies, an
-     * `overrides.tools.remove` suppression, the builder's already-satisfied
-     * exclusion · misses it, so the character ends up able to hold both.
-     *
-     * `skillExpertise` is NOT a seventh bucket · it is a SUBSET of `skills`, in the
-     * same canonical slug form, carrying the values whose effect set
-     * `expertise: true`. An expertise skill is pushed to BOTH, so every consumer
-     * that only knows about proficiency keeps working and recalc's `expSet` gains
-     * one source. SKILLS ONLY (spec §7.2): a tool or language effect carrying
-     * `expertise: true` folds as a plain proficiency and never lands here. It is
-     * not lost · since R4-G4 §9.2 the authored flag travels the GRANT channel
-     * instead (`EffectProficiencyGrant.expertise` -> `ProficiencyGrant.expertise`
-     * -> `ProficiencyEntry.expertise`), which is the channel the sheet panel and
-     * the proficiency modal read. Routing it here as well would put a value in the
-     * skill-expertise set that no skill key can ever match.
-     */
     proficiencies: {
         skills: string[];
         skillExpertise: string[];
@@ -164,166 +79,41 @@ export interface FeatureEffectTotals {
         armor: string[];
         weapons: string[];
     };
-    /**
-     * 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.
-     */
     weaponAbilities: WeaponAbilityOverride[];
-    /**
-     * Order-preserving list of structured advantage/disadvantage entries from
-     * `roll-modifier` effects. Pass-through (no dedupe/merge); each entry is
-     * labeled with the owning feature's name.
-     */
     rollModifiers: RollModifierEntry[];
-    /**
-     * Order-preserving list of `save-outcome` entries (R4-G3a §5.3), labeled with the owning
-     * feature's name. Pass-through (no dedupe/merge); `ability: "any"` becomes an ABSENT ability,
-     * which the save chip reads as "every save".
-     */
     saveOutcomes: SaveOutcomeEntry[];
-    /**
-     * Lowest weapon-attack crit threshold (natural roll that scores a critical
-     * hit) granted by `crit-range` effects. Folds via Math.min from init 20, so
-     * 20 = no expansion. spell-only (`applies_to:"spell"`) entries do NOT lower
-     * it. recalc maps this onto each AttackRow as `critRange` only when < 20.
-     */
     critRange: number;
-    /**
-     * Max EXTRA attacks per Attack action granted by `extra-attack` effects, never the total:
-     * Non-stacking (D&D Extra Attack features don't stack): folds via Math.max
-     * from init 0, so 0 = no extra attacks. recalc maps this onto
-     * DerivedStats.attacksPerAction as `1 + extraAttack`.
-     * A `scales_at` progression resolves BEFORE the max, at the effect's own source level (R4-G7 §7.3).
-     */
+    conditionalCrits: ConditionalCrit[];
     extraAttack: number;
-    /**
-     * Order-preserving display-only captions surfaced from `reroll-damage` and
-     * `attack-rule` effects (e.g. "Reroll 2s", "No disadvantage firing in melee").
-     * recalc post-applies this list onto each AttackRow as `attackNotes` only when
-     * non-empty, so untouched attack rows keep `attackNotes: undefined`.
-     */
+    scopedExtraAttacks: Array<{
+        count: number;
+        scope: WeaponScope[];
+    }>;
     attackNotes: string[];
-    /**
-     * Additive on-hit damage riders from `damage-bonus` effects with
-     * `applies_to` weapon/all (spell and all riders also go to `spellDamageBonuses`). Each is
-     * labeled with the owning feature's name. recalc merges these onto every
-     * weapon AttackRow's `damageRiders`.
-     */
     damageBonuses: DamageRider[];
-    /**
-     * The `damage-bonus` effects with `applies_to: spell` or `all`, labeled with the owning feature's name and carrying its
-     * `spellTargets` and `spell_scope` (found live 2026-09-28: they were dropped here, so Agonizing Blast never reached its
-     * cantrip). recalc reads each against the character's spells (`spellsReached`, `spellsInScope`) into
-     * `DerivedStats.spellDamageRiders`.
-     */
     spellDamageBonuses: SpellDamageRider[];
 }
 export declare function emptyFeatureEffectTotals(): FeatureEffectTotals;
-/**
- * Optional fold inputs. `activeBuffs` is the set of currently-toggled buff
- * ids/slugs (from Character.state.active_buffs + selected pool boons). An
- * `activatable` feature's effects fold ONLY while its id is in this set; a buff
- * is OFF by default, so callers passing no opts see activatable features fold to
- * nothing (correct — a buff is off until toggled). Non-activatable features fold
- * unconditionally regardless of opts.
- *
- * R4-G7 §7.3: `levelFor` answers "at what level does an effect from THIS source resolve", which is the rule
- * `resourceLevelFor` (pc.resources.ts) already applies to a resource's own `scales_at`: the character's level
- * in the granting class for a `class` source, the level in the class owning the subclass for a `subclass`
- * source, the total level otherwise. Both production callers pass exactly that (dnd5e `pc.recalc.ts` and the
- * plugin's builder `abilities-step.ts`); a caller that passes none leaves every `scales_at` unresolved and
- * every effect at its BASE value, which is what a fixture with no character behind it should read.
- */
+export declare function pushDefenseGrant(list: DefenseGrant[], value: string, source: string, condition?: string, item?: DefenseItemSource): void;
+export declare function mergeDefenseItems(into: DefenseItemSource[], from: readonly DefenseItemSource[]): void;
 export interface FeatureEffectsOpts {
     activeBuffs?: Set<string>;
     levelFor?: (source: FeatureSource) => number;
-    /** RG: the DICE cell (`1d6`) of column `column` in the table of the class that owns `source`, at `level`; null when that
-     *  table has no such dice cell. recalc passes it; a caller that passes none leaves every rider at its authored amount. */
     tableDiceFor?: (source: FeatureSource, column: string, level: number) => string | null;
+    tableCellFor?: (source: FeatureSource, column: string) => string | null;
 }
-/** Does this feature's effects fold right now? An activatable feature folds ONLY
- *  while its id is in the active set; a buff is off until toggled. Shared by
- *  computeFeatureEffects and the display-side proficiency collector so the fold
- *  and the display can never disagree about boons (spec fence F3). */
 export declare function foldsNow(rf: ResolvedFeature, activeBuffs: Set<string>): boolean;
-/** The ONE assembly of everything whose effects fold: authored features plus
- *  pool-granted and pool-selected boons, with the active-buff set.
- *
- *  Returning BOTH halves is load-bearing: a caller handed only the feature list
- *  would drop activeBuffs and computeFeatureEffects would skip every activatable
- *  boon · exactly the display/gate divergence this helper exists to close.
- *
- *  The guards defend against CAST-BUILT FIXTURES, not against the type: `features`,
- *  `pools` and `state` are all non-optional on ResolvedCharacter, but `tests/` is
- *  typechecked by nothing. Only fixtures that actually reach this function count,
- *  and today that is THREE entry points: recalc, the display-side walk
- *  (computeEffectiveProficiencies → collectProficiencyGrants), and this
- *  function's own direct tests. All three guards are LIVE. Counts below were
- *  measured by deleting each guard and running the suite · re-derive them the
- *  same way rather than trusting the numbers, which drift as tests are added:
- *    · `pools ?? []` is exercised by `emptyResolved()` in
- *      tests/pc-recalc-feature-effects.test.ts, which omits pools and IS fed to
- *      recalc, and by `dwarf()` in tests/pc-proficiency-effective.test.ts. This
- *      guard predates the extraction; it was already here. Deleting it: 149 tests
- *      red across 13 files.
- *    · `state?.` is exercised by the "survives a cast-built fixture with no pools
- *      and no state" case in tests/pc-feature-effects.test.ts, which calls this
- *      function directly with `{ features: [...] } as never`, and again by
- *      `dwarf()`. Deleting it: 11 red across 2 files.
- *    · `features ?? []` is exercised by `dwarf()` in
- *      tests/pc-proficiency-effective.test.ts, which omits `features` and reaches
- *      here through the display walk. Deleting it: 7 red, all in that file.
- *      ⚠️ This bullet used to read "NOT exercised today, and is the one kept
- *      purely for the display-side callers". That was TRUE when written and was
- *      falsified LATER IN THIS SAME PHASE by the tasks that wired the display
- *      path, because nobody re-read it. A guard's own justification is the thing
- *      most likely to go stale under you · re-run the deletion before restating
- *      any of these three.
- *  Do not "simplify" any of the three away. */
 export declare function assembleEffectFeatures(resolved: ResolvedCharacter): {
     features: ResolvedFeature[];
     activeBuffs: Set<string>;
 };
-/** Spec R4-G1a D2. Whether an effect changes the character it is written on. `subject` is absent on every SRD
- *  effect (=== "self"); the converter emits "self" today and will emit other creatures later (Hound of Ill Omen
- *  imposes disadvantage on a TARGET). A non-self effect never folds onto the PC: not here, not in
- *  collectProficiencyEffectGrants, not in unarmoredACBreakdown, not in recalc's weapon-ability scan. Its FEATURE
- *  still resolves and renders (it is not buildOnly); R4-G3a §4 gives it a row-local caption.
- *
- *  R4-G3a §4.4: a subject that is neither absent nor "self" warns ONCE per distinct subject string
- *  (`warnOnce`, keyed on the subject). The converter's vocabulary here is open, so an unexpected
- *  spelling ("Self", "target creature") silently stops folding today; the warning names it without
- *  changing the answer. Never a refusal: the return value is unchanged. */
 export declare function foldsOnSelf(eff: {
     subject?: string;
 }): boolean;
-/** The effects of a feature that fold on the character: every reader of `feature.effects` for a derived stat goes through this. */
 export declare function selfEffectsOf(f: {
     effects?: FeatureEffect[];
 }): FeatureEffect[];
 export declare function computeFeatureEffects(features: ResolvedFeature[], opts?: FeatureEffectsOpts): FeatureEffectTotals;
-/** The ONE interpreter of `kind: "proficiency"` effects (spec fence F3).
- *
- *  Two consumers with different needs, so the return carries BOTH forms:
- *  `applyEffect` pushes `value` (normalized) into FeatureEffectTotals, while the
- *  display collector reads `raw` for armor/weapons · composeGrantEntries stores
- *  the raw authored string as ProficiencyEntry.value (spec §4.8 #1) and computes
- *  its dedupe key separately. Tools/languages read `value`.
- *
- *  `saves` is discriminated because FeatureEffectTotals.proficiencies.saves is
- *  Ability[], not string[] (fence F1). A null return means "not a proficiency
- *  effect, or an unresolvable ability".
- *
- *  `expertise` is REQUIRED and always a boolean, never absent: the authored key
- *  is optional, so folding it here once means no consumer has to tell
- *  `undefined` from `false`. It is reported for EVERY bucket · deciding that
- *  only skills act on it belongs to the fold (spec §7.2), not to the
- *  classification. */
 export type ProficiencyClassification = {
     bucket: "skills" | "tools" | "languages" | "armor" | "weapons";
     value: string;
@@ -336,56 +126,12 @@ export type ProficiencyClassification = {
     expertise: boolean;
 };
 export declare function classifyProficiencyEffect(eff: FeatureEffect): ProficiencyClassification | null;
-/** One proficiency an effect grants, tagged with the source it came from.
- *
- *  BOTH forms are carried because the two display consumers need different ones
- *  and, since the tool/language canonicalization landed, they no longer coincide:
- *  armor/weapons read `raw` (composeGrantEntries stores the raw authored string
- *  as ProficiencyEntry.value and keys its dedupe on toProfSlug separately), while
- *  tools/languages read `value`, the canonical slug the effective-proficiency
- *  matcher matches its vocabulary and suppressions on. Reaching for the wrong
- *  field is silently wrong, not harmlessly identical.
- *
- *  `sourceSlug` is the source's slug VERBATIM (namespace and all), because the
- *  consumer resolves it against the resolved character's entities to get a
- *  display name. */
 export interface EffectProficiencyGrant {
     value: string;
     raw: string;
     sourceKind: FeatureSource["kind"];
     sourceSlug: string;
-    /**
-     * Set (to `true`) only when the granting effect carried `expertise: true`, and
-     * ABSENT otherwise, so a plain grant keeps the exact four-key shape the two
-     * display consumers already read. Reported for every bucket, unlike the fold,
-     * which routes skills only (spec §7.2). CONSUMED since R4-G4 §9.2 by
-     * `toGrants` in pc.proficiency-grants.ts, which spreads it onto
-     * `ProficiencyGrant` for every bucket; the tools display is the one reader
-     * today, and it reads this rather than re-deriving it from the raw effects.
-     */
     expertise?: boolean;
 }
 export type EffectProficiencyGrants = Record<"skills" | "tools" | "languages" | "saves" | "armor" | "weapons", EffectProficiencyGrant[]>;
-/** Every proficiency an effect grants, tagged with the FeatureSource it came from.
- *
- *  Deliberately NOT deduped: composeGrantEntries collects distinct SOURCES per
- *  value, so collapsing on value alone here would silently drop the second
- *  granting entity and blank half the provenance.
- *
- *  `skills` and `saves` are collected because classifyProficiencyEffect's bucket
- *  union has SIX members and this function indexes the record by it · drop either
- *  key and `out[c.bucket].push(...)` is a type error, and a hand-built record
- *  missing one crashes on the first such effect. They have NO display consumer:
- *  effect-granted skills already reach the sheet via recalc's skill union and
- *  saves via its save set, and the Proficiencies panel has only four rows. No
- *  test asserts either bucket, and `toGrants` in pc.proficiency-grants.ts reads
- *  only the other four. That is deliberate, not an oversight.
- *
- *  Reads the same three rules as the fold, and NOTHING else: foldsNow decides
- *  what is active, selfEffectsOf decides whose numbers an effect changes and
- *  classifyProficiencyEffect decides what a proficiency effect means (spec fence
- *  F3), so the display can never disagree with the engine.
- *
- *  Reads only effects that fold on self (`selfEffectsOf`), the same predicate as
- *  the fold, so a non-self proficiency is neither granted nor displayed. */
 export declare function collectProficiencyEffectGrants(features: ResolvedFeature[], activeBuffs: Set<string>): EffectProficiencyGrants;

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

@@ -1,39 +1 @@
-import {
-  assembleEffectFeatures,
-  classifyProficiencyEffect,
-  collectProficiencyEffectGrants,
-  computeFeatureEffects,
-  emptyFeatureEffectTotals,
-  foldsNow,
-  foldsOnSelf,
-  selfEffectsOf
-} from "../chunk-64VNLMSG.js";
-import "../chunk-TOM66P2P.js";
-import "../chunk-KU3YLF6D.js";
-import "../chunk-5JXFJ5AU.js";
-import "../chunk-RD2MID3M.js";
-import "../chunk-NXUY5XQN.js";
-import "../chunk-W6GC6OKK.js";
-import "../chunk-B3DP42OM.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-ZUQW5VBZ.js";
-import "../chunk-IHE6KVC3.js";
-import "../chunk-LHZXYFBU.js";
-import "../chunk-YBLDE5CG.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-CM5CWO4K.js";
-import "../chunk-4J6DS3EJ.js";
-import "../chunk-ZCTUYGNV.js";
-import "../chunk-3TM34RSJ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  assembleEffectFeatures,
-  classifyProficiencyEffect,
-  collectProficiencyEffectGrants,
-  computeFeatureEffects,
-  emptyFeatureEffectTotals,
-  foldsNow,
-  foldsOnSelf,
-  selfEffectsOf
-};
+import{assembleEffectFeatures,classifyProficiencyEffect,collectProficiencyEffectGrants,computeFeatureEffects,emptyFeatureEffectTotals,foldsNow,foldsOnSelf,mergeDefenseItems,pushDefenseGrant,selfEffectsOf}from"../chunk-GD7WRCNH.js";import"../chunk-FOLHTMSC.js";import"../chunk-4JEF3CET.js";import"../chunk-VTQ4RWEG.js";import"../chunk-WAUNLUFQ.js";import"../chunk-PKIMOVQG.js";import"../chunk-CMIEZQL4.js";import"../chunk-CSTAQQGX.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.js";import"../chunk-3QQOATV3.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-63YJPWTM.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{assembleEffectFeatures,classifyProficiencyEffect,collectProficiencyEffectGrants,computeFeatureEffects,emptyFeatureEffectTotals,foldsNow,foldsOnSelf,mergeDefenseItems,pushDefenseGrant,selfEffectsOf};

package/dist/pc/pc.formula-context.js

@@ -1,11 +1 @@
-// src/pc/pc.formula-context.ts
-function buildFormulaContext(resolved, derived, registry) {
-  return {
-    abilities: resolved.definition.abilities,
-    proficiencyBonus: derived.proficiencyBonus,
-    compendium: registry
-  };
-}
-export {
-  buildFormulaContext
-};
+function buildFormulaContext(resolved,derived,registry){return{abilities:resolved.definition.abilities,proficiencyBonus:derived.proficiencyBonus,compendium:registry}}export{buildFormulaContext};