@archivist-gg/dnd5e 0.3.17 → 0.3.24

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

@@ -1,41 +1,28 @@
-import type { FeatureEffect, SenseType } from "@archivist-gg/dnd5e/types/feature-effect";
+import type { FeatureEffect, SenseType, WeaponScope } from "@archivist-gg/dnd5e/types/feature-effect";
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { DamageRider, DefenseGrant, FeatureSource, ResolvedCharacter, ResolvedFeature, RollModifierEntry, SaveOutcomeEntry } 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;
 }
-/**
- * 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 +30,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 +45,27 @@ 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: {
+        mode: SpeedMode;
+        label: string;
+        value: number;
+        set: boolean;
+        condition?: 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,159 +75,40 @@ 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-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[];
+    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;
 }
-/** 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;
@@ -329,56 +121,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,26 +1 @@
-import {
-  assembleEffectFeatures,
-  classifyProficiencyEffect,
-  collectProficiencyEffectGrants,
-  computeFeatureEffects,
-  emptyFeatureEffectTotals,
-  foldsNow,
-  foldsOnSelf,
-  selfEffectsOf
-} from "../chunk-TULQ4FFX.js";
-import "../chunk-TOM66P2P.js";
-import "../chunk-KU3YLF6D.js";
-import "../chunk-RLGQ5PZZ.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-ZCTUYGNV.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-HCK6IUB3.js";import"../chunk-FOLHTMSC.js";import"../chunk-4JEF3CET.js";import"../chunk-VTQ4RWEG.js";import"../chunk-QBA757AU.js";import"../chunk-DY6FVAGA.js";import"../chunk-CMIEZQL4.js";import"../chunk-BGX36NPE.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};

package/dist/pc/pc.infusions.d.ts

@@ -5,7 +5,6 @@ import type { ArmorEntity } from "../armor/armor.types.js";
 import type { WeaponEntity } from "../weapon/weapon.types.js";
 import type { ItemEntity } from "../item/item.types.js";
 import type { Character, EquipmentEntry, ResolvedCharacter } from "./pc.types.js";
-/** The known-counter word (spec §4.5): the pool's `count.label`, else "Known". Applied at read, never a zod default. */
 export declare function poolCountLabel(pool: {
     countLabel?: string;
 }): string;
@@ -17,30 +16,22 @@ export interface PoolActiveWords {
     createLabel: string;
     createVerb: string;
 }
-/** The at-once counter's words (spec §4.5), defaults applied at read; null when the pool declares no `active`. */
 export declare function poolActiveWords(pool: {
     active?: PoolActive;
 }): PoolActiveWords | null;
-/** A stored pick split on its FIRST '#' (spec §4.4): `<note slug>#<param>` is a copy of a repeatable note. */
 export declare function parsePickKey(stored: string): {
     slugPart: string;
     param: string | null;
 };
-/** The comparison key (spec §4.4): `bare(note)#param` for a copy of a repeatable note, `bare(note)` for any other pick. */
 export declare function normalizedPickKey(stored: string, repeatable: boolean): string;
-/** A marker's `by`, normalized the same way: a copy when it holds '#'. */
 export declare function markerKey(by: string): string;
-/** Derived, never authored (spec §4.1): a member that infuses an object, or a repeatable member whose rows create items. */
 export declare function isItemBound(note: Pick<OptionalFeatureEntity, "infuse" | "repeatable" | "options">): boolean;
 export type OptionStatus = "ok" | "needs-choice" | "not-installed" | "level" | "invalid";
-/** A copy's resolved option (spec §4.6): its row, the resolved item's FULL slug (a `learn` copy, or a `create` copy's
- *  `item` row), and its status. */
 export interface CopyOption {
     row: OptionRow | null;
     item?: string;
     status: OptionStatus;
 }
-/** The registry subset option resolution reads (structurally `PoolRegistry` and `DecisionRegistry`). */
 export interface ItemLookup {
     search(q: string, t: string, n: number): RegisteredEntity[];
     getByTypeAndSlug(t: string, s: string): RegisteredEntity | undefined;
@@ -50,9 +41,6 @@ export interface CandidateOptions {
     isEntityVisible?: (e: RegisteredEntity) => boolean;
     exclude?: readonly string[];
 }
-/** One option row as the pickers read it (R20): `candidates` are VISIBLE full slugs in the §5.8 order (U-A). PT (spec §4,
- *  §6.5): `type` and `rarity` (lower-case) name the row's item, read from its first candidate (else its first installed
- *  item, visible or not), a `filter` row from its filter; `charges` are that item's own; null when nothing says. */
 export interface ResolvedOptionRow {
     key: string;
     name: string;
@@ -68,31 +56,21 @@ export interface ResolvedOptionRow {
         recharge?: string;
     } | null;
 }
-/** The per-copy picker's data for one repeatable member of a pool (spec §5.1, R20). */
 export interface RepeatableMember {
     noteSlug: string;
     itemChoice: "learn" | "create";
     rows: ResolvedOptionRow[];
 }
-/** The picker list for a row (spec §5.8, U-A): VISIBLE notes only, the character's edition first, the SRD books before
- *  importer books, then the full slug; one per bare slug; rows already replicated (by name or bare slug) left out. */
 export declare function optionCandidates(row: OptionRow, registry: ItemLookup, opts?: CandidateOptions): string[];
-/** Every row of a repeatable note as the pickers read it (R20): its candidates, and whether its items are installed,
- *  installed only in hidden books (absent from every list, U-A), or not installed at all. */
 export declare function resolveOptionRows(note: Pick<OptionalFeatureEntity, "options">, registry: ItemLookup, opts?: CandidateOptions): ResolvedOptionRow[];
-/** A copy's option (spec §5.8): validation by row identity, BLIND to visibility (Gate 1 C3, U-A). A `learn` param passes
- *  through the retired-item map first; the stored key is never rewritten (Gate 1 m5). `edition` orders the installed
- *  notes a `create` copy's `item` row falls back to when the row's own slug is not installed. */
 export declare function resolveCopyOption(note: OptionalFeatureEntity, param: string | null, ctx: {
     classLevel: number;
     registry: ItemLookup;
     edition?: string;
 }): CopyOption;
-/** One marked equipment entry's view (spec §4.6). The DISPLAY identity is not stored: it is the entry's own resolution. */
 export interface EntryView {
     index: number;
     kind: "infused" | "created";
-    /** The RULE entity (spec §5.4): the wrapper (infused) or the real item (created); null for an orphan or duplicate created entry. */
     entity: ArmorEntity | WeaponEntity | ItemEntity | null;
     entityType: string | null;
     key: string;
@@ -101,7 +79,6 @@ export interface EntryView {
     classIndex: number;
     noteSlug: string;
     noteName: string;
-    /** The infusing or creating member's name (ART-c's sub-line part reads it). */
     sourceLabel: string;
 }
 export interface InfusionCounter {
@@ -119,44 +96,25 @@ export interface InfusionContext {
         reason: InfusionFlagReason;
     }>;
 }
-/** The overlay at the OWNING class level (spec §5.3 "Scaling"): `scales_at` rows at or below it replace keys, in level order. */
 export declare function scaledInfuseItem(infuse: InfuseBlock, classLevel: number): InfuseItem;
-/** The RULE entity of an equipment entry (spec §5.4): its view when it has one (null for an orphan or duplicate created
- *  entry), else the entry's own resolution. The ONE resolver every dnd5e fold reads (grep gate). `infusions` is the
- *  character's context, or ONE view (an entry-level helper's caller holds just that entry's view), or nothing. */
 export declare function resolveEntryEntity(entry: EquipmentEntry, index: number, registry: EntityRegistry, infusions?: Pick<InfusionContext, "views"> | EntryView | null): {
     entity: ArmorEntity | WeaponEntity | ItemEntity | null;
     entityType: string | null;
 };
-/** Views, counters and flags (spec §5.4). Undefined, at no cost, for a character with no item-bound pool and no marker. */
 export declare function buildInfusionContext(character: Character, resolved: ResolvedCharacter, registry: EntityRegistry): InfusionContext | undefined;
-/** The charge pair's reader (spec §5.5): an infused view's overlay charges live in the MARKER (`infusion.charges.current`,
- *  absent = full); anything else is `effectiveItemCharges` (stored, the note's own data, the curated map). */
 export declare function entryCharges(entry: EquipmentEntry, view: EntryView | null | undefined, registry: EntityRegistry | null): {
     current: number;
     max: number;
 } | undefined;
-/** The charge pair's writer (spec §5.5): an infused view whose overlay has charges writes `infusion.charges.current`,
- *  clamped to 0..max, and never `state`; any other entry writes `state.charges` as today (`setItemCharges`): the stored
- *  max kept, else seeded from the item's own max ({@link effectiveItemCharges}: the note's data, then the curated map),
- *  else the new value; `current` clamped to 0..max. Returns a NEW entry. */
 export declare function withEntryCharges(entry: EquipmentEntry, view: EntryView | null | undefined, current: number, registry: EntityRegistry | null): EquipmentEntry;
-/** The reseed predicate (spec §5.7, Gate 0 M2, Gate 1 I10): the Builder's starting-equipment reseed,
- *  `setBuilderEquipmentMode` and `finishBuild` never replace, remove or duplicate an entry carrying `infusion`. */
 export declare function isMarkedEntry(entry: EquipmentEntry): boolean;
-/** One object off a stack (spec §5.7, Gate 1 m3): the source keeps qty - 1 and its hand; the new x1 keeps only
- *  `item`, `in` and `overrides`, unequipped, so a split never moves a hand slot. */
 export declare function splitOne(equipment: readonly EquipmentEntry[], index: number): EquipmentEntry[];
-/** One ended marker (spec §5.7, R18): `index` is the entry's position in the RETURNED array for an infused end (the
- *  entry stays) and -1 for a created one (it is removed); `item` (the entry's link or text) names it for a
- *  confirmation. The read-only twins `infusionsEndedByChoice` and `infusionsEndedByClassEdit` give the CURRENT index. */
 export interface EndedEntry {
     index: number;
     key: string;
     kind: "infused" | "created";
     item: string;
 }
-/** A writer's result (spec §5.7): a NEW equipment array and the markers the write ended. */
 export interface EquipmentWrite {
     equipment: EquipmentEntry[];
     ended: EndedEntry[];
@@ -168,17 +126,7 @@ export type InfusionWrite = ({
     ok: false;
     reason: InfuseRefusal;
 };
-/** Ends one marker (spec §5.7, Gate 0 I3). Infused: the marker goes, `attuned` too when the base needs none (the entry's
- *  own resolution: arms b, b′ and c never need it, an arm d magic base may). Created: its children move to its own
- *  parent (or lose `in` at the top level), then it is removed. Every end path calls this; a marker's charges live in
- *  the marker (spec §5.5), so they go with it. */
 export declare function endInfusion(equipment: readonly EquipmentEntry[], index: number, registry: EntityRegistry): EquipmentWrite;
-/** Infuse one object (spec §5.7): refusals in the order `not-owned`, `not-infusing`, `stranded`, `choice-required` /
- *  `bad-choice` (a damage type, dnd5e's own list, and one of the note's `choice.options` when it lists them),
- *  `no-target`, `marked`, `magic-base` / `target-kind`; a stacked target is split first (`splitOne`) and the new x1 takes
- *  the marker; "A new object" is offered for EVERY infusing member (R23); then the same key's other marker and the pool's
- *  oldest over the cap end. `seq` is max + 1 over the INPUT equipment (an ended seq is never reused); charges start at the
- *  scaled overlay's max. */
 export declare function infuseEntry(character: Character, resolved: ResolvedCharacter, registry: EntityRegistry, req: {
     key: string;
     target: number | {
@@ -187,11 +135,6 @@ export declare function infuseEntry(character: Character, resolved: ResolvedChar
     choice?: string;
     isEntityVisible?: (e: RegisteredEntity) => boolean;
 }): InfusionWrite;
-/** Create one item from a creating copy (spec §5.7): `not-owned`; `not-creating` (not a repeatable member whose rows
- *  create items); `stranded` (the note, or its copy's option at `level`); `invalid-item` (any other status, or an item
- *  that is not installed or satisfies neither the copy's row nor equals its `option.item`: validation by row identity,
- *  §5.8). The same key's created entry and the pool's oldest over the cap end; the new entry is appended unequipped,
- *  x1, `kind: created`, with `seq` over the INPUT equipment. */
 export declare function createEntry(character: Character, resolved: ResolvedCharacter, registry: EntityRegistry, req: {
     key: string;
     item: string;
@@ -202,10 +145,7 @@ type ChoiceEdit = {
     choiceKey: string;
     next: readonly string[];
 };
-/** Read-only (U-9): the markers `reconcileChoiceEdit` would end, with their CURRENT indices, for the confirmation. */
 export declare function infusionsEndedByChoice(character: Character, resolved: ResolvedCharacter, _registry: EntityRegistry, req: ChoiceEdit): EndedEntry[];
-/** Un-picking an infusion or a copy ends its markers in the same write (spec §5.7, Gate 0 I4): created items leave by the
- *  approved end path. Null when nothing ends. */
 export declare function reconcileChoiceEdit(character: Character, resolved: ResolvedCharacter, registry: EntityRegistry, req: ChoiceEdit): EquipmentWrite | null;
 type ClassEdit = {
     classIndex: number;
@@ -214,13 +154,8 @@ type ClassEdit = {
     classIndex: number;
     subclass: string | null;
 };
-/** Read-only (B-8.2): the markers `reconcileClassEdit` would end, with their CURRENT indices, for the confirmation. */
 export declare function infusionsEndedByClassEdit(character: Character, resolved: ResolvedCharacter, _registry: EntityRegistry, req: ClassEdit): EndedEntry[];
-/** Removing a class or changing its subclass ends the markers it owns in the same write ("when the infusion's source is
- *  gone, the item ends like an ended infusion"). Null when nothing ends. */
 export declare function reconcileClassEdit(character: Character, resolved: ResolvedCharacter, registry: EntityRegistry, req: ClassEdit): EquipmentWrite | null;
-/** The Infuse picker's list (spec §5.7): the unmarked entries an owned infusing pick's targets admit, nonmagical, each
- *  with `stack` when infusing it splits one object off. */
 export declare function eligibleTargets(character: Character, resolved: ResolvedCharacter, registry: EntityRegistry, key: string): Array<{
     index: number;
     stack: boolean;