@archivist-gg/dnd5e 0.3.11 → 0.3.17

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

@@ -1,38 +1,48 @@
 import {
+  __categoryToEntitySelectForTest,
   __matchesFilterForTest,
   buildDecisionLedger,
   collectChosenAbilityPoints,
   collectChosenProficiencies,
   computeEffectiveProficiencies
-} from "../chunk-2INMRR3Q.js";
-import "../chunk-4ISR76DH.js";
+} from "../chunk-ONTGZR5T.js";
+import "../chunk-2LULMQTF.js";
+import "../chunk-H5PTKYXL.js";
+import "../chunk-TULQ4FFX.js";
+import "../chunk-TOM66P2P.js";
+import "../chunk-KU3YLF6D.js";
+import "../chunk-HTYMW5CH.js";
+import "../chunk-KSTV7J2U.js";
 import "../chunk-DPUJDOKV.js";
-import "../chunk-O4SRD3J5.js";
-import "../chunk-PP2UHLBA.js";
+import "../chunk-LBEXLN6I.js";
+import "../chunk-RLGQ5PZZ.js";
+import "../chunk-3VZZDKRA.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-B3DP42OM.js";
 import "../chunk-IUAAXXNO.js";
 import "../chunk-YHYTW5QA.js";
-import "../chunk-3HX5VLWP.js";
+import "../chunk-VRV3NNTA.js";
 import "../chunk-PVCEA4HZ.js";
-import "../chunk-UBBKSYBY.js";
-import "../chunk-CBEKVAX4.js";
-import "../chunk-TOM66P2P.js";
-import "../chunk-KU3YLF6D.js";
-import "../chunk-RLGQ5PZZ.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-WXWPK3LI.js";
-import {
-  wikilinkTailSlug
-} from "../chunk-6X4KUDMU.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-LHZXYFBU.js";
 import "../chunk-YBLDE5CG.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-CM5CWO4K.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
-import "../chunk-XY6X2APM.js";
+import {
+  wikilinkTailSlug
+} from "../chunk-ZCTUYGNV.js";
+import "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
+import "../chunk-3TM34RSJ.js";
 import "../chunk-PDJSUH24.js";
 import "../chunk-WELIKLZF.js";
 import "../chunk-4U55VNC7.js";
 import "../chunk-UA5KS2PL.js";
 export {
+  __categoryToEntitySelectForTest,
   __matchesFilterForTest,
   buildDecisionLedger,
   collectChosenAbilityPoints,

package/dist/pc/pc.entry-overrides.d.ts

@@ -0,0 +1,79 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { ActionCost } from "../types/resource.js";
+import type { EquipmentEntry, EquipmentEntryState } from "./pc.types.js";
+import { type EntryView } from "./pc.infusions.js";
+export type CustomizableKey = "name" | "charges" | "recovery" | "action" | "range" | "bonus" | "damage_bonus" | "extra_damage" | "ac_bonus" | "resist";
+/** The attack row's cost when the entry stores no `overrides.action` (pc.equipment.ts). */
+export declare const WEAPON_DEFAULT_ACTION_COST: ActionCost;
+/** A weapon, or an item whose `base_item` resolves to a weapon: it fills the main hand and owns an
+ *  attack row (pc.slotting.ts `defaultSlotForType`). With a view, its rule entity decides (an infused
+ *  weapon's wrapper routes through its `base_item`). */
+export declare function isWeaponLikeEntry(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): boolean;
+/** The override keys some consumer reads for this entry's type. The Customize card adds every key the
+ *  entry already STORES (so it can always be cleared); that union is the card's, not this rule's. */
+export declare function customizableOverrideKeys(entry: EquipmentEntry, registry: EntityRegistry | null): Set<CustomizableKey>;
+/** The action cost the sheet shows when no `overrides.action` is stored: the attack row's default for a
+ *  weapon-like entry; the items row's cost (a view's `action`, the curated cost, or the potion or scroll
+ *  default) otherwise; else null. With a view, its rule entity decides each read. */
+export declare function defaultActionCost(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): ActionCost | null;
+/** A spell scroll's spell's cost, the registry half of `resolveItemAction`'s scroll default (it has no registry; its
+ *  two callers do, and pass this as `opts.spellCost`: `defaultActionCost` here and the plugin's Actions collector).
+ *  The spell is the one the entry sets (`overrides.spell`: a `[[slug]]` wikilink or a bare slug), looked up as the
+ *  Spells tab looks it up (`collectItemGrantedSpells`); its `casting_time` is read by the ONE casting-time reader. An
+ *  action, bonus action or reaction is the cost; anything else (a minute or hour cast, no spell set, a spell not
+ *  installed, no registry) is undefined, so the scroll default falls back to Action. */
+export declare function scrollSpellCost(entry: EquipmentEntry, registry: EntityRegistry | null): ActionCost | undefined;
+/** A charges field's maximum (spec §5.6, U-7 A): an object's `max`, or a positive number (the two item-note shapes,
+ *  item.schema.ts); an infusion overlay's `charges` has the object shape. */
+export declare function itemChargesMax(entity: unknown): number | undefined;
+/** The recovery rule an item recharges by (spec §5.5, §5.6, U-7 A), in this order: none for an item consumed on use
+ *  ({@link isConsumedOnUse}: it has no charges to recharge, even over a rule stored before that ruling) or an orphan
+ *  created entry (its RULE entity is null, nothing folds); an INFUSED view's overlay `charges` (their `recharge`,
+ *  `dawn` refilling on a long rest); the stored rule; the item note's own `charges.recharge`; else the curated rule
+ *  for a wikilinked entry. A plain-text entry never picks up a curated rule the Actions row cannot show. */
+export declare function effectiveItemRecovery(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): NonNullable<EquipmentEntryState["recovery"]> | undefined;
+/** Consumed on use (T17 rider C fold, user ruling 2026-09-24): using one spends the entry's QUANTITY, never a charge
+ *  (a potion, Holy Water, an oil, Alchemist's Fire, Dust of Disappearance, a scroll), so the item has no charges and
+ *  no recovery anywhere and the sheet shows its quantity only. Data decides, in two places: the curated `consumed`
+ *  flag of `ITEM_ACTIONS` (no registry needed), else the entity's own data, a `potion` or `scroll` type (the type the
+ *  potion default of `resolveItemAction` already reads) or a `scroll_level` marker. A plain-text entry is never one:
+ *  it resolves to no entity, as in every other rule here. */
+export declare function isConsumedOnUse(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): boolean;
+/** The ONE "is a spell scroll" rule (T17 rider GH, carried from rider C's close), by the entity's own data: its `scroll`
+ *  type or its `scroll_level` marker. A scroll is consumed on use ({@link isConsumedOnUse}). Read value-based, with no
+ *  rarity gate: null, a non-object or an entity with neither field is no scroll. An entry reaches it through its resolved
+ *  entity, so with no registry, or for a plain-text entry, nothing is a scroll. */
+export declare function isScrollEntity(entity: unknown): boolean;
+/** A scroll the sheet can CAST: it carries the `scroll_level` marker, the level its spell is cast at (0 = cantrip). Its
+ *  use is that cast (the Spells tab spends it), so the Actions row offers it no Use of its own. A scroll typed `scroll`
+ *  with no marker (the 2014 SRD spell scrolls) names no level: it is not castable, and its Actions row keeps the plain
+ *  Use every other item consumed on use has (T17 rider GH). */
+export declare function isCastableScroll(entity: unknown): boolean;
+/** The charge pair an item shows, the twin of {@link effectiveItemRecovery}. Its sources, in this order (spec §5.5,
+ *  §5.6, U-7 A):
+ *  1. none for an item consumed on use (its quantity is what it has, {@link isConsumedOnUse}, even over a pair stored
+ *     before that ruling), and none for an orphan created entry (its view's RULE entity is null: nothing folds);
+ *  2. an INFUSED view whose overlay has `charges`: they live in the MARKER, `infusion.charges.current` (absent = full,
+ *     clamped to the overlay max), never in `state`;
+ *  3. the stored pair as stored (a legacy `{0, 0}` included, so it can still be cleared);
+ *  4. the item note's OWN `charges` (an object's `max`, or a number) as a FULL pair: every item reads its own data;
+ *  5. the curated `max_charges` of a wikilinked entry as a FULL pair, the fallback for notes without data;
+ *  else none. An item with no stored charges is full, the rest plan's own reading. Every surface that shows or spends
+ *  an item's charges reads this (through `entryCharges` once it holds the view), and so does the rest plan, so a wand
+ *  is listed wherever its charges are and a potion nowhere. */
+export declare function effectiveItemCharges(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): NonNullable<EquipmentEntryState["charges"]> | undefined;
+/** The Armor Class an armour or shield entry gives (T17 T-25), by the terms `computeAC` (pc.equipment.ts) adds for it:
+ *  the slot's own terms ({@link slotAcTerms}: the armour's AC, through `base_item` for a magic armour, `effectiveArmor`,
+ *  and the entry's `overrides.ac_bonus`), and the item's own unconditional `bonuses.ac` (a +2 armour's +2). A shield's `value` is what it
+ *  ADDS; an armour's is the AC it sets, plus Dex where `addDex` says so. What the item gives WORN: the engine applies
+ *  these only while it is equipped (the bonus only while attuned where attunement is required), and a conditional
+ *  `bonuses.ac` is left out, its conditions being the character's. Every surface that shows an entry's AC reads this, so
+ *  a magic armour never shows its base armour's AC; the consumer-agreement test holds it to the engine's own sum. Null
+ *  for an entry that is neither (a weapon, a ring, an unresolved link, plain text) and without a registry. With the
+ *  entry's view (ART-a, spec §5.3) the rule entity is read: an infused armor or shield gives its base's terms plus the
+ *  wrapper's scaled `bonuses.ac`, the ONE slot term `computeAC` merges for it. */
+export declare function effectiveItemArmorClass(entry: EquipmentEntry, registry: EntityRegistry | null, view?: EntryView | null): {
+    value: number;
+    shield: boolean;
+    addDex: boolean;
+} | null;

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

@@ -0,0 +1,40 @@
+import {
+  WEAPON_DEFAULT_ACTION_COST,
+  customizableOverrideKeys,
+  defaultActionCost,
+  effectiveItemArmorClass,
+  effectiveItemCharges,
+  effectiveItemRecovery,
+  isCastableScroll,
+  isConsumedOnUse,
+  isScrollEntity,
+  isWeaponLikeEntry,
+  itemChargesMax,
+  scrollSpellCost
+} from "../chunk-3VZZDKRA.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-B3DP42OM.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-LHZXYFBU.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-CM5CWO4K.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
+};

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

@@ -25,7 +25,7 @@ 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
+/** 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`,
@@ -35,7 +35,7 @@ export interface UnarmedStrikeSpec {
  *  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`
+ *  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 computeSlotsAndAttacks(resolved: ResolvedCharacter, mods: Record<Ability, number>, profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[], proficiencyBonus: number, weaponAbilities?: WeaponAbilityOverride[], weaponMasteries?: string[], attunementFloor?: number): DerivedEquipment;

package/dist/pc/pc.equipment.js

@@ -4,14 +4,26 @@ import {
   computeSlotsAndAttacks,
   emptyAppliedBonuses,
   isWeaponSlugProficient
-} from "../chunk-V373TRJE.js";
-import "../chunk-UIRMA5KM.js";
-import "../chunk-UBBKSYBY.js";
+} from "../chunk-JSM6JFZR.js";
+import "../chunk-3LWMFYKS.js";
+import "../chunk-YDGMBMYI.js";
+import "../chunk-EJP263OP.js";
 import "../chunk-RLGQ5PZZ.js";
-import "../chunk-LWFTHJIE.js";
-import "../chunk-DNAJRMNN.js";
-import "../chunk-WXWPK3LI.js";
-import "../chunk-6X4KUDMU.js";
+import "../chunk-3VZZDKRA.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-B3DP42OM.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-HHBD4SQ6.js";
+import "../chunk-A54HHCWW.js";
+import "../chunk-LHZXYFBU.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
+import "../chunk-3TM34RSJ.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   buildUnarmedRow,
   computeAppliedBonuses,

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

@@ -34,6 +34,15 @@ export interface FeatureEffectTotals {
         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;
+        minimum: number;
+        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
@@ -226,6 +235,9 @@ export declare function emptyFeatureEffectTotals(): FeatureEffectTotals;
 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

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

@@ -7,12 +7,12 @@ import {
   foldsNow,
   foldsOnSelf,
   selfEffectsOf
-} from "../chunk-CBEKVAX4.js";
+} from "../chunk-TULQ4FFX.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
 import "../chunk-RLGQ5PZZ.js";
 import "../chunk-LVQLWRCU.js";
-import "../chunk-6X4KUDMU.js";
+import "../chunk-ZCTUYGNV.js";
 import "../chunk-WELIKLZF.js";
 export {
   assembleEffectFeatures,

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

@@ -0,0 +1,228 @@
+import type { EntityRegistry, RegisteredEntity } from "@archivist-gg/core";
+import type { PoolActive } from "../types/selection-pool.js";
+import type { InfuseBlock, InfuseItem, OptionalFeatureEntity, OptionRow } from "../types/optional-feature.types.js";
+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;
+export interface PoolActiveWords {
+    column: string;
+    label: string;
+    verb: string;
+    counterLabel: string;
+    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;
+}
+export interface CandidateOptions {
+    edition?: string;
+    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;
+    minLevel: number;
+    attunement?: boolean;
+    arm: "item" | "variant" | "filter";
+    candidates: string[];
+    availability: "installed" | "hidden-only" | "not-installed";
+    type: string | null;
+    rarity: string | null;
+    charges: {
+        max: number;
+        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;
+    seq: number;
+    poolId: string;
+    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 {
+    label: string;
+    used: number;
+    max: number;
+    over: boolean;
+}
+export type InfusionFlagReason = "orphan" | "duplicate" | "stack" | "mismatch" | "magic-base";
+export interface InfusionContext {
+    views: Map<number, EntryView>;
+    counters: Map<string, InfusionCounter>;
+    flags: Array<{
+        index: number;
+        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[];
+}
+export type InfuseRefusal = "not-owned" | "stranded" | "not-infusing" | "not-creating" | "target-kind" | "magic-base" | "marked" | "choice-required" | "bad-choice" | "no-target" | "invalid-item";
+export type InfusionWrite = ({
+    ok: true;
+} & EquipmentWrite) | {
+    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 | {
+        newObject: string;
+    };
+    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;
+}): InfusionWrite;
+type ChoiceEdit = {
+    classIndex: number;
+    level: number;
+    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;
+    remove: true;
+} | {
+    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;
+}>;
+export {};

package/dist/pc/pc.infusions.js

@@ -0,0 +1,64 @@
+import {
+  buildInfusionContext,
+  createEntry,
+  eligibleTargets,
+  endInfusion,
+  entryCharges,
+  infuseEntry,
+  infusionsEndedByChoice,
+  infusionsEndedByClassEdit,
+  isItemBound,
+  isMarkedEntry,
+  markerKey,
+  normalizedPickKey,
+  optionCandidates,
+  parsePickKey,
+  poolActiveWords,
+  poolCountLabel,
+  reconcileChoiceEdit,
+  reconcileClassEdit,
+  resolveCopyOption,
+  resolveEntryEntity,
+  resolveOptionRows,
+  scaledInfuseItem,
+  splitOne,
+  withEntryCharges
+} from "../chunk-3VZZDKRA.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-B3DP42OM.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-LHZXYFBU.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
+import "../chunk-3TM34RSJ.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
+export {
+  buildInfusionContext,
+  createEntry,
+  eligibleTargets,
+  endInfusion,
+  entryCharges,
+  infuseEntry,
+  infusionsEndedByChoice,
+  infusionsEndedByClassEdit,
+  isItemBound,
+  isMarkedEntry,
+  markerKey,
+  normalizedPickKey,
+  optionCandidates,
+  parsePickKey,
+  poolActiveWords,
+  poolCountLabel,
+  reconcileChoiceEdit,
+  reconcileClassEdit,
+  resolveCopyOption,
+  resolveEntryEntity,
+  resolveOptionRows,
+  scaledInfuseItem,
+  splitOne,
+  withEntryCharges
+};