@archivist-gg/dnd5e 0.3.19 → 0.3.24

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;

package/dist/pc/pc.infusions.js

@@ -1,65 +1 @@
-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-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 {
-  buildInfusionContext,
-  createEntry,
-  eligibleTargets,
-  endInfusion,
-  entryCharges,
-  infuseEntry,
-  infusionsEndedByChoice,
-  infusionsEndedByClassEdit,
-  isItemBound,
-  isMarkedEntry,
-  markerKey,
-  normalizedPickKey,
-  optionCandidates,
-  parsePickKey,
-  poolActiveWords,
-  poolCountLabel,
-  reconcileChoiceEdit,
-  reconcileClassEdit,
-  resolveCopyOption,
-  resolveEntryEntity,
-  resolveOptionRows,
-  scaledInfuseItem,
-  splitOne,
-  withEntryCharges
-};
+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-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-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{buildInfusionContext,createEntry,eligibleTargets,endInfusion,entryCharges,infuseEntry,infusionsEndedByChoice,infusionsEndedByClassEdit,isItemBound,isMarkedEntry,markerKey,normalizedPickKey,optionCandidates,parsePickKey,poolActiveWords,poolCountLabel,reconcileChoiceEdit,reconcileClassEdit,resolveCopyOption,resolveEntryEntity,resolveOptionRows,scaledInfuseItem,splitOne,withEntryCharges};

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

@@ -0,0 +1,18 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { ItemEntity } from "@archivist-gg/dnd5e/item/item.types";
+import type { ArmorEntity } from "@archivist-gg/dnd5e/armor/armor.types";
+import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
+import type { FeatureEffect } from "../types/feature-effect.js";
+import { type EntryView, type InfusionContext } from "./pc.infusions.js";
+import type { EquipmentEntry, ResolvedFeature } from "./pc.types.js";
+export declare function itemBenefitsActive(entry: EquipmentEntry, entity: ItemEntity | ArmorEntity | WeaponEntity | null, registry: EntityRegistry | null, view?: EntryView | null): boolean;
+export declare function itemLabel(entry: EquipmentEntry, entity: {
+    name?: unknown;
+} | null): string;
+export declare const ITEM_ROW_KINDS: ReadonlySet<FeatureEffect["kind"]>;
+export declare function readItemEffects(entity: unknown): {
+    effects: FeatureEffect[];
+    invalid: string[];
+};
+export declare function itemRowEffects(entity: unknown): FeatureEffect[];
+export declare function buildItemFeatures(equipment: readonly EquipmentEntry[], registry: EntityRegistry, infusions: InfusionContext | undefined, warnings: string[]): ResolvedFeature[];

package/dist/pc/pc.member-choices.d.ts

@@ -1,63 +1,26 @@
-/**
- * D2b-A · nested choices on pool members (design §2.2, user rulings 2026-09-27: GENERAL and RECURSIVE).
- *
- * A pool member (an invocation, a maneuver, a fighting-style option, ...) may carry its own choices: Lessons of the First
- * Ones' Origin feat, Superior Technique's maneuver, Blessed and Druidic Warrior's cantrips, Pact of the Tome's cantrips
- * and rituals, the three blasts' cantrip. A nested pick lives in the pool's ANCHOR block under
- * `<poolId>:<pickKey>:<choiceId>` (a nested feat's own children under `<poolId>:<pickKey>:feat:<childId>`, the decision
- * engine's prefix chaining), keyed by the stored pick string, so reordering or adding picks never moves it.
- *
- * The choices are the member's authored `choices`; absent (every note in the vault today), they are DERIVED at read time
- * from the raw keys the notes already carry (`feat_progression`, `optionalfeature_progression`, `additional_spells`
- * with `choose`, a `spell-choose` prerequisite), so existing notes work with no re-import. Authored `choices` win.
- */
 import type { Character, ChoiceValue, FeatVia, ResolvedCharacter, ResolvedClass, ResolvedSpell, SpellTargets } from "./pc.types.js";
 import type { Choice } from "@archivist-gg/dnd5e/types/choice";
 import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
 import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
-/** Whether `ch` names a target rather than granting what it picks (the data flag `target: true`, which the spell-choose
- *  derivation below writes and an authored note may carry). */
 export declare function isTargetChoice(ch: Choice): boolean;
-/**
- * The member's choices: its authored `choices`, else the ones its raw keys ask for (see the module docblock). Pure; the
- * derived rows carry the member's edition so a pick never offers the other edition's twin.
- */
+export declare const PACT_WEAPON_CHOICE_ID = "pact-weapon";
+export declare function pactWeaponPick(sites: ReadonlyArray<Pick<PoolMemberSite, "choices" | "read">>): string | undefined;
+export declare function classPactWeaponPick(character: Pick<Character, "class">, classes: ReadonlyArray<Pick<ResolvedClass, "entity" | "subclass">>): string | undefined;
 export declare function memberChoices(entity: OptionalFeatureEntity | null | undefined): Choice[];
-/**
- * The spells a member's spell-scoped damage rider reaches, as its DATA names them (found live 2026-09-28: Agonizing
- * Blast's Charisma never reached its cantrip): each answer of a spell target pick (`isTargetChoice`, the blasts' cantrip,
- * read through `read`, the member's nested key) and each `spell-known` prerequisite (the 2014 Agonizing Blast's Eldritch
- * Blast). A target pick left unanswered keeps its filter in `open` (see {@link spellsReached}). Null when the member names
- * no spell, so its spell riders reach none.
- */
 export declare function memberSpellTargets(member: OptionalFeatureEntity, read: (choiceId: string) => ChoiceValue | undefined): SpellTargets | null;
-/**
- * The slugs of the character's `spells` a rider with `targets` reaches, unique, in `spells` order: every spell a ref
- * names (its full slug, else its bare name, so a path link `[[SRD 5e/eldritch-blast]]` finds `srd-5e_spell_eldritch-blast`),
- * and, for each open target pick, its ONE legal answer: the character's own spells that match the pick's filter and roll
- * damage, when exactly one does ("one of your known Warlock cantrips that deals damage" with only Eldritch Blast known).
- * Two or more legal answers are a choice the player has not made, and reach none.
- */
 export declare function spellsReached(targets: SpellTargets | undefined, spells: ReadonlyArray<Pick<ResolvedSpell, "slug" | "entity">>): string[];
-/** One stored pool pick whose member carries choices, with the block its nested picks live in. */
 export interface PoolMemberSite {
     classIndex: number;
-    /** The pool's anchor level (the block's key in `choices`). */
     level: number;
     poolId: string;
-    /** The stored pick string (a copy of a repeatable note keeps its `slug#param`). */
     pickKey: string;
     member: OptionalFeatureEntity;
     memberSlug: string;
     choices: Choice[];
-    /** `<poolId>:<pickKey>:` */
     prefix: string;
-    /** The nested pick stored for a member choice id. */
     read: (choiceId: string) => ChoiceValue | undefined;
-    /** The anchor block, as stored. */
     block: Record<string, ChoiceValue>;
 }
-/** Structural subset of the registry the raw enumerator reads. */
 export interface MemberRegistry {
     getByTypeAndSlug(entityType: string, slug: string): {
         slug: string;
@@ -68,38 +31,18 @@ export interface MemberRegistry {
         data: Record<string, unknown>;
     }>;
 }
-/**
- * Every pool member site from the RAW character (the resolver's view, before pools resolve): each class's and subclass's
- * declared pools, their anchor levels (`poolAnchorLevel`, the one derivation `resolvePool` uses), the picks stored there,
- * each resolved to its note (full slug, else bare). A pick with no note, or a note with no choices, yields no site, so an
- * orphan nested key is inert.
- */
 export declare function poolMemberSites(classes: ResolvedClass[], registry: MemberRegistry): PoolMemberSite[];
-/** The same sites read from a RESOLVED character's pools (the ledger's, the proficiency walk's and recalc's view). */
 export declare function poolMemberSitesOf(resolved: Pick<ResolvedCharacter, "pools" | "classes">): PoolMemberSite[];
-/** A feat the character picked, where it was picked, and how its own children are read. */
 export interface FeatPickSite {
     slug: string;
     classIndex: number;
     level: number | null;
     via: FeatVia | null;
-    /** A child choice of THIS feat, as stored (`feat:<id>` in the slot's block, or `<prefix>feat:<id>` under a member). */
     read: (childId: string) => ChoiceValue | undefined;
 }
-/**
- * Every feat pick with its own read (design §2.2 step 4): the class-slot picks (`choices[<level>].feat`, children under
- * `feat:<id>`) and the pool-member picks (a member choice of `entity_type: feat`, children under `<prefix>feat:<id>`).
- * The ONE list the four feat readers walk (the resolver's feats and feat spells, the proficiency walk, ability points).
- * `classSlugOf` names a class for the provenance. NOT de-duplicated: a feat taken twice (Magic Initiate, one spell list
- * each) is two sites with two reads; a reader that lists feats de-duplicates by slug itself (first wins).
- */
 export declare function featPickSites(classEntries: ReadonlyArray<{
     choices?: Character["class"][number]["choices"] | ResolvedClass["choices"];
 }> | undefined, memberSites: PoolMemberSite[], classSlugOf: (classIndex: number) => string | null): FeatPickSite[];
-/** SRD-G T4 (audit §3b): a feat the character picked through a SPECIES (the SRD 5.2 Human's Versatile: "You gain an
- *  Origin feat of your choice"): a `select-entity` of `entity_type: feat` on `race.choices[]` or a trait's `choices[]`,
- *  answered under `origin_choices["race:<id>"]`. The feat's OWN children are read under `race:feat:<childId>`, the key
- *  the builder's ledger writes them to (a race item's feat children carry the `feat:` prefix, namespace `race`). */
 export interface RaceFeatSite {
     slug: string;
     via: FeatVia;
@@ -112,11 +55,5 @@ export declare function raceFeatSites(race: {
         choices?: unknown;
     }>;
 } | null | undefined, originChoices: Readonly<Record<string, ChoiceValue>> | undefined): RaceFeatSite[];
-/** Look a feat pick up in the resolved feats (by slug, then bare slug). */
 export declare function featOfSite(site: FeatPickSite, feats: ReadonlyArray<FeatEntity>): FeatEntity | undefined;
-/**
- * The nested keys an array write to `key` orphans (design §2.2 step 8): every `<key>:<k>:*` whose `k` was stored before
- * and is not in `next`. Pure; the writer deletes them in the same write, so a re-pick never resurrects an old answer.
- * A key that is not a pool (no array stored) orphans nothing.
- */
 export declare function nestedPickKeysToPrune(block: Record<string, unknown> | undefined, key: string, next: readonly string[]): string[];

package/dist/pc/pc.member-choices.js

@@ -1,39 +1 @@
-import {
-  featOfSite,
-  featPickSites,
-  isTargetChoice,
-  memberChoices,
-  memberSpellTargets,
-  nestedPickKeysToPrune,
-  poolMemberSites,
-  poolMemberSitesOf,
-  raceFeatSites,
-  spellsReached
-} from "../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 {
-  featOfSite,
-  featPickSites,
-  isTargetChoice,
-  memberChoices,
-  memberSpellTargets,
-  nestedPickKeysToPrune,
-  poolMemberSites,
-  poolMemberSitesOf,
-  raceFeatSites,
-  spellsReached
-};
+import{PACT_WEAPON_CHOICE_ID,classPactWeaponPick,featOfSite,featPickSites,isTargetChoice,memberChoices,memberSpellTargets,nestedPickKeysToPrune,pactWeaponPick,poolMemberSites,poolMemberSitesOf,raceFeatSites,spellsReached}from"../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{PACT_WEAPON_CHOICE_ID,classPactWeaponPick,featOfSite,featPickSites,isTargetChoice,memberChoices,memberSpellTargets,nestedPickKeysToPrune,pactWeaponPick,poolMemberSites,poolMemberSitesOf,raceFeatSites,spellsReached};

package/dist/pc/pc.parser.js

@@ -1,58 +1 @@
-import {
-  characterSchema
-} from "../chunk-NTU2DXNG.js";
-import "../chunk-S7REMWW4.js";
-import {
-  keptSlugForLink
-} from "../chunk-CM5CWO4K.js";
-import "../chunk-ZCTUYGNV.js";
-
-// src/pc/pc.parser.ts
-import * as yaml from "js-yaml";
-function parsePC(source) {
-  var _a;
-  let raw;
-  try {
-    raw = yaml.load(source);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return { success: false, error: `YAML parse error: ${msg}` };
-  }
-  if (!raw || typeof raw !== "object") {
-    return { success: false, error: "Invalid YAML: expected an object" };
-  }
-  const result = characterSchema.safeParse(raw);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    const path = issue.path.length ? issue.path.join(".") : "(root)";
-    return { success: false, error: `${path}: ${issue.message}` };
-  }
-  const data = result.data;
-  const legacyState = data.state;
-  const legacyCurrency = legacyState.currency;
-  if (legacyCurrency && !data.currency) {
-    data.currency = legacyCurrency;
-  }
-  if (legacyCurrency) {
-    delete legacyState.currency;
-  }
-  if (legacyState.attuned_items) {
-    delete legacyState.attuned_items;
-  }
-  for (const entry of (_a = data.equipment) != null ? _a : []) {
-    if (typeof entry.item !== "string") continue;
-    const next = migrateRetiredItemLink(entry.item);
-    if (next !== null) entry.item = next;
-  }
-  return { success: true, data };
-}
-function migrateRetiredItemLink(item) {
-  var _a;
-  const m = /^\[\[([^\]|]+)(\|[^\]]*)?\]\]$/.exec(item.trim());
-  const kept = keptSlugForLink(m ? m[1] : item);
-  if (kept === void 0) return null;
-  return m ? `[[${kept}${(_a = m[2]) != null ? _a : ""}]]` : kept;
-}
-export {
-  parsePC
-};
+import{characterSchema}from"../chunk-5FEXHY4U.js";import"../chunk-KM75CC6Q.js";import{keptSlugForLink}from"../chunk-PZ4L2EEG.js";import"../chunk-63YJPWTM.js";import*as yaml from"js-yaml";function parsePC(source){var _a;let raw;try{raw=yaml.load(source)}catch(e){const msg=e instanceof Error?e.message:String(e);return{success:false,error:`YAML parse error: ${msg}`}}if(!raw||typeof raw!=="object"){return{success:false,error:"Invalid YAML: expected an object"}}const result=characterSchema.safeParse(raw);if(!result.success){const issue=result.error.issues[0];const path=issue.path.length?issue.path.join("."):"(root)";return{success:false,error:`${path}: ${issue.message}`}}const data=result.data;const legacyState=data.state;const legacyCurrency=legacyState.currency;if(legacyCurrency&&!data.currency){data.currency=legacyCurrency}if(legacyCurrency){delete legacyState.currency}if(legacyState.attuned_items){delete legacyState.attuned_items}for(const entry of(_a=data.equipment)!=null?_a:[]){if(typeof entry.item!=="string")continue;const next=migrateRetiredItemLink(entry.item);if(next!==null)entry.item=next}return{success:true,data}}function migrateRetiredItemLink(item){var _a;const m=/^\[\[([^\]|]+)(\|[^\]]*)?\]\]$/.exec(item.trim());const kept=keptSlugForLink(m?m[1]:item);if(kept===void 0)return null;return m?`[[${kept}${(_a=m[2])!=null?_a:""}]]`:kept}export{parsePC};

package/dist/pc/pc.pools.d.ts

@@ -3,25 +3,22 @@ import type { ResolvedCharacter, ResolvedClass, ResolvedPool, ResolvedPoolEntry
 import type { SelectionPool } from "@archivist-gg/dnd5e/types/selection-pool";
 import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
 import type { ResourceIndex } from "./pc.resources.js";
-/** Structural subset of EntityRegistry used here (lets tests pass a fake). */
 export interface PoolRegistry {
     search(query: string, entityType: string, limit: number): RegisteredEntity[];
     getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
 }
 export declare function levelPrereqMax(d: OptionalFeatureEntity): number;
-/** The pool's ANCHOR level (its picks live in `choices[anchorLevel][pool.id]`): the first level whose count column
- *  carries a value of at least 1, else 1; `columnSeen` says whether any level carried the column at all. ONE derivation
- *  shared by `resolvePool` and the nested-choice enumerator (D2b-A, `pc.member-choices.ts`), so the two always agree. */
+export declare function levelPrereqRefsMet(d: OptionalFeatureEntity, rc: Pick<ResolvedClass, "entity" | "subclass">): boolean;
 export declare function poolAnchorLevel(entity: Pick<NonNullable<ResolvedClass["entity"]>, "table">, pool: Pick<SelectionPool, "count">): {
     anchorLevel: number;
     columnSeen: boolean;
 };
 export declare function resolvePool(rc: ResolvedClass, classIndex: number, pool: SelectionPool, registry: PoolRegistry, index: ResourceIndex, edition?: string): ResolvedPool;
 export declare function resolveAllPools(resolved: ResolvedCharacter, registry: PoolRegistry, index: ResourceIndex): ResolvedPool[];
-/** The stored picks that survived resolution but are NOT in the collapsed `available` list, compared by FULL
- *  slug: exactly the rule the plugin's `strandedSelections` used before T3 retires it (R4-G5 §3.2.3). Because
- *  §9.2.3's resolution rewrites a collapsed twin to its survivor, only a GENUINE prerequisite-failing pick (the
- *  one resolved by step 3 from the full scan) can land here, and it keeps its entity so the builder strip and the
- *  sheet can both dress it "prerequisite unmet". A granted feature is already excluded from `selected`, so a
- *  grant never appears here. Pure over the resolved pool: it reads nothing the resolver did not compute. */
 export declare function strandedPicks(pool: ResolvedPool): ResolvedPoolEntry[];
+export declare function heldPicks(pool: ResolvedPool): ResolvedPoolEntry[];
+export declare function withoutStrandedSites<T extends {
+    classIndex: number;
+    poolId: string;
+    memberSlug: string;
+}>(sites: T[], classes: ResolvedClass[], registry: PoolRegistry, edition?: string): T[];

package/dist/pc/pc.pools.js

@@ -1,27 +1 @@
-import {
-  levelPrereqMax,
-  poolAnchorLevel,
-  resolveAllPools,
-  resolvePool,
-  strandedPicks
-} 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 {
-  levelPrereqMax,
-  poolAnchorLevel,
-  resolveAllPools,
-  resolvePool,
-  strandedPicks
-};
+import{heldPicks,levelPrereqMax,levelPrereqRefsMet,poolAnchorLevel,resolveAllPools,resolvePool,strandedPicks,withoutStrandedSites}from"../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-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{heldPicks,levelPrereqMax,levelPrereqRefsMet,poolAnchorLevel,resolveAllPools,resolvePool,strandedPicks,withoutStrandedSites};

package/dist/pc/pc.proficiencies.d.ts

@@ -2,46 +2,13 @@ import type { ResolvedCharacter } from "./pc.types.js";
 import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
 import { type ProficiencyKind } from "./pc.proficiency-normalize.js";
 import { type ProficiencyEntry, type ProficiencyGrant } from "./pc.proficiency-grants.js";
-/** Re-exported for the plugin: both types are DECLARED in the leaf so that
- *  pc.decision-engine can reference them without importing this module, which
- *  would close a cycle (spec §4.3). */
 export type { ProficiencyEntry, ProficiencyOrigin } from "./pc.proficiency-grants.js";
-/** Every bucket carries provenance (spec §7.1). `languages`/`tools` ARE
- *  {@link computeEffectiveProficiencies}' output, unmodified · `armor`/`weapons`
- *  are composed below from the raw grant walk, because they have no vocabulary
- *  constant to canonicalize against (spec §3.3's second rule) · and for `weapons`
- *  that grant walk is followed by the chosen `select-entity{weapon}` picks
- *  (R4-G3b §7 F5), which land with origin `pick`. */
 export interface ProficiencyAggregate {
     armor: ProficiencyEntry[];
     weapons: ProficiencyEntry[];
     tools: ProficiencyEntry[];
     languages: ProficiencyEntry[];
 }
-/** Normalized intermediate of every proficiency/language source the DISPLAY path
- *  reads, in one place. Among the ENTITY branches only the class one is a live
- *  proficiency source today (race/bg/feat `.proficiencies` object fields do not
- *  exist on those entities); race languages, bg tool/lang, and feat grants read
- *  their real fields, and the four `effect*` buckets carry what a feature's
- *  `kind: "proficiency"` effects grant · that is the live path a 2014 race trait
- *  actually uses (R4-P3c). Chosen picks come from the single decision walk in
- *  pc.decision-engine so display can never diverge from the persisted picks.
- *
- *  Every grant bucket carries `{value, source}` rather than a bare value: the
- *  walk holds the granting entity and the aggregate needs it to fill
- *  `ProficiencyEntry.sources` for armor and weapons (spec §7.1). The
- *  language/tool grant buckets are still surfaced here for completeness, but
- *  the aggregate no longer reads them · languages and tools come from
- *  computeEffectiveProficiencies, which does its own grant walk so that
- *  suppressions and manual adds can never be skipped by a second composer.
- *
- *  These names are RE-DECLARED by hand rather than inherited: this interface
- *  does not `extends ProficiencyGrants`, so a bucket added to the grant walk
- *  stays invisible here until it is added here too. `collectProficiencySources`
- *  spreads the grants object, so an undeclared bucket still flows at RUNTIME ·
- *  the compiler is the only thing that notices, and only where the field is
- *  read. Nothing iterates these objects with Object.keys/values/entries, so a
- *  declaration gap is inert rather than corrupting; it is still a gap. */
 export interface ProficiencySources {
     classArmor: ProficiencyGrant[];
     classWeaponFixed: ProficiencyGrant[];
@@ -64,15 +31,8 @@ export interface ProficiencySources {
 }
 export declare function collectProficiencySources(resolved: ResolvedCharacter): ProficiencySources;
 export declare function aggregateProficiencies(resolved: ResolvedCharacter): ProficiencyAggregate;
-/** D4 A: one kind's proficiencies as the picker needs them: `effective` is exactly the sheet's line (the aggregate's
- *  bucket), `removed` every grant or pick the user's overrides suppress, keeping its `sources`. Both halves come out of
- *  the composers the sheet reads, so the picker and the sheet line cannot disagree. */
 export declare function proficiencyOverview(resolved: ResolvedCharacter, kind: ProficiencyKind): {
     effective: ProficiencyEntry[];
     removed: ProficiencyEntry[];
 };
-/** D4 A: the effective weapon entry that covers `weapon` without naming it, a category (`simple`, `martial`, or the
- *  entity's own `martial-melee` form) or a property-qualified grant ("Martial weapons that have the Light property").
- *  The same three arms as the live gate, `isWeaponSlugProficient` (pc.equipment.ts), so the picker's dimmed "via" row
- *  and the attack row's proficiency agree. Undefined when nothing but the weapon's own entry could cover it. */
 export declare function weaponCoveredBy(effective: readonly ProficiencyEntry[], weapon: Pick<WeaponEntity, "category" | "properties" | "range" | "slug">): ProficiencyEntry | undefined;