@archivist-gg/dnd5e 0.3.11 → 0.3.17

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

@@ -0,0 +1,90 @@
+/**
+ * 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 } 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 function memberChoices(entity: OptionalFeatureEntity | null | undefined): Choice[];
+/** 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;
+        data: Record<string, unknown>;
+    } | undefined;
+    search(query: string, entityType: string, limit: number): Array<{
+        slug: string;
+        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[];
+/** 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

@@ -0,0 +1,32 @@
+import {
+  featOfSite,
+  featPickSites,
+  isTargetChoice,
+  memberChoices,
+  nestedPickKeysToPrune,
+  poolMemberSites,
+  poolMemberSitesOf
+} from "../chunk-HTYMW5CH.js";
+import "../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-YBLDE5CG.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 {
+  featOfSite,
+  featPickSites,
+  isTargetChoice,
+  memberChoices,
+  nestedPickKeysToPrune,
+  poolMemberSites,
+  poolMemberSitesOf
+};

package/dist/pc/pc.parser.js

@@ -1,11 +1,16 @@
 import {
   characterSchema
-} from "../chunk-PZCE7DJM.js";
+} from "../chunk-T6QIF5XR.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);
@@ -34,8 +39,20 @@ function parsePC(source) {
   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

@@ -9,7 +9,14 @@ export interface PoolRegistry {
     getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
 }
 export declare function levelPrereqMax(d: OptionalFeatureEntity): number;
-export declare function resolvePool(rc: ResolvedClass, classIndex: number, pool: SelectionPool, registry: PoolRegistry, index: ResourceIndex): ResolvedPool;
+/** 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 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

package/dist/pc/pc.pools.js

@@ -1,15 +1,25 @@
 import {
   levelPrereqMax,
+  poolAnchorLevel,
   resolveAllPools,
   resolvePool,
   strandedPicks
-} from "../chunk-O4SRD3J5.js";
-import "../chunk-PP2UHLBA.js";
+} 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-6X4KUDMU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
+import "../chunk-3TM34RSJ.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   levelPrereqMax,
+  poolAnchorLevel,
   resolveAllPools,
   resolvePool,
   strandedPicks

package/dist/pc/pc.proficiencies.js

@@ -2,31 +2,39 @@ import {
   collectChosenProficiencies,
   collectProficiencyGrants,
   computeEffectiveProficiencies
-} from "../chunk-2INMRR3Q.js";
-import "../chunk-4ISR76DH.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-O4SRD3J5.js";
-import "../chunk-PP2UHLBA.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-YHYTW5QA.js";
-import "../chunk-3HX5VLWP.js";
-import "../chunk-PVCEA4HZ.js";
-import "../chunk-UBBKSYBY.js";
-import "../chunk-CBEKVAX4.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-LBEXLN6I.js";
 import {
   proficiencyLabel,
   toProfSlug
 } from "../chunk-RLGQ5PZZ.js";
-import "../chunk-LVQLWRCU.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-YHYTW5QA.js";
+import "../chunk-VRV3NNTA.js";
+import "../chunk-PVCEA4HZ.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 "../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";

package/dist/pc/pc.proficiency-query.js

@@ -1,10 +1,16 @@
+import {
+  qualifiedGrantCovers
+} from "../chunk-3LWMFYKS.js";
+import "../chunk-YDGMBMYI.js";
 import {
   normKey
 } from "../chunk-RLGQ5PZZ.js";
+import "../chunk-ZCTUYGNV.js";
 
 // src/pc/pc.proficiency-query.ts
 function isProficientWithWeapon(weapon, profs) {
   if (profs.weapons.specific.some((e) => e === weapon.slug || normKey(e) === normKey(weapon.name))) return true;
+  if (profs.weapons.specific.some((e) => qualifiedGrantCovers(e, weapon))) return true;
   const baseCategory = weapon.category.split("-")[0];
   return profs.weapons.categories.includes(baseCategory);
 }

package/dist/pc/pc.recalc.d.ts

@@ -4,7 +4,7 @@ import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
 import type { EntityRegistry } from "@archivist-gg/core";
 import { type UnarmedStrikeSpec } from "./pc.equipment.js";
 import { type FeatureEffectTotals } from "./pc.feature-effects.js";
-import type { ACTerm, DerivedStats, ProficiencySet, ResolvedCharacter, ResolvedClass, CharacterOverrides } from "./pc.types.js";
+import type { ACTerm, AttackRow, DamageRider, DerivedStats, ProficiencySet, ResolvedCharacter, ResolvedClass, CharacterOverrides } from "./pc.types.js";
 /**
  * PHB "fixed average" value per hit die (per level beyond first). Called
  * "average" in the PHB but actually ceil((die + 1) / 2); equivalent to
@@ -23,19 +23,14 @@ export declare function parseDieSize(die: string | number | undefined | null): n
  */
 export declare function flattenRaceAsi(race: RaceEntity | null): Partial<Record<Ability, number>>;
 /**
- * Sums the LEGACY class-level ASI-BRANCH allocations (`choices[lvl].asi`) per
- * ability across every class. This is the path taken when an L4/L8-style
- * "Ability Score Increase or Feat" decision resolves to the plain +2 ASI branch
- * rather than a feat. Shared by both `computeAbilityScores`' fold and
- * `abilityBonusBreakdown`'s `class` bucket so the two reads can never drift.
+ * Sums the LEGACY class-level ASI-BRANCH allocations (`choices[lvl].asi`) per ability across every class: the path of an
+ * L4/L8-style "Ability Score Increase or Feat" decision saved on the plain +2 ASI branch rather than a feat. Shared by
+ * `computeAbilityScores`' fold and `abilityBonusBreakdown`'s `class` bucket so the two reads can never drift.
  *
- * Disjoint from chosen-feat ability-points (`choices[lvl]["feat:<id>"]`) and from
- * origin ability-points · no source double-counts.
- *
- * Since R4-P4 Decision B an `asi` that SHARES a level with a string `feat` key is
- * discarded as an orphan rather than folded: that level took the feat branch, and
- * the `asi` beside it is residue the picker never cleared on a branch switch.
- * Folding both paid the same slot twice (Volker.md drew FOUR points from one L4).
+ * The level gate is the ONE predicate `legacyAsiBranch` (pc.asi-flatten.ts, H234 H4(2)), shared with the Builder's ledger
+ * alias and write path: a level whose `feat` is a string took the feat branch, and its `asi` is an orphan discarded since
+ * R4-P4 Decision B (Volker.md drew FOUR points from one L4 when both folded). Disjoint from chosen-feat ability-points
+ * (`choices[lvl]["feat:<id>"]`, collectClassFeatAbilityPoints) and from origin ability-points: no source double-counts.
  */
 export declare function collectClassAsiBranch(resolved: ResolvedCharacter): Partial<Record<Ability, number>>;
 /** Per-ability bonus provenance for the builder's obelisk captions:
@@ -69,6 +64,10 @@ export declare function hpLevelCount(classes: ResolvedClass[]): number;
  * so a later popup can render the two components separately.
  */
 export declare function multiclassMaxHP(classes: ResolvedClass[], conMod: number): number;
+/** Does a damage rider reach this attack row (ART-c1 Task 9b, controller ruling 8)? A rider with no `scope` reaches
+ *  every row (today's reach); a scoped one reaches a row when ANY of its words matches it: `melee` / `ranged` the
+ *  row's `weaponCategory`, `unarmed` the engine's Unarmed Strike row, `finesse` / `thrown` the row's properties. */
+export declare function riderReachesRow(rider: DamageRider, row: AttackRow): boolean;
 /**
  * The BEST APPLICABLE unarmoured formula (R4-G7 T6a, spec §4): the plain 10 + DEX mod, against every
  * `unarmored-ac` effect that folds right now (its `base ?? 10` plus the modifier of every ability its
@@ -121,29 +120,33 @@ export declare function speedFromRace(resolved: ResolvedCharacter): number;
  * double-counts. The chosen feat entity is resolved from `resolved.feats`
  * (already looked up by the resolver) — no registry needed here.
  *
- * The L19 Epic Boon folds through this SAME path, but only as of R4-P4's
- * re-key (live in the SRD data from that phase's regeneration). This docblock
- * earlier cited it as an existing example, which it was not. EVERY reader OF THE
- * FEAT PICK keys on the LITERAL string `feat`, and there are THREE of them, not
- * the two the R4-P4 spec §2.3 and task brief enumerate: this function
- * (`block.feat`, below), `collectFeatPicks` (pc.resolver.ts) and
- * `PCResolver.resolve`'s feat-to-spell application pass, the two
- * `collectFeatGrantedSpells` calls (pc.resolver.ts), the one that
- * makes a SPELL-granting boon work. Note the qualifier: this is NOT a claim that
- * every reader of a saved class choice block keys on `feat`. Others read the very
- * same block by OTHER keys · `collectClassAsiBranch` (above) reads the literal
- * `.asi`, while `resolvePool` (pc.pools.ts) and `resolveChosenInline`
- * (pc.resolver.ts) read by a DYNAMIC pool/choice id. As of R4-P4 Decision B
- * `collectClassAsiBranch` also tests `block.feat`, but only to DETECT the feat
- * branch, not to consume the pick. pc.decision-engine.ts is NOT a fourth:
- * it reads generically by `choice.id`, which is exactly why re-keying works at
- * all. srd-2024.yaml authored the boon's pick `id: epic-boon`, so an L19
- * selection persisted under `choices[19]["epic-boon"]`, which no reader looks
- * at: the boon resolved to no feat, granted no spells, and contributed no
- * ability points at all. Re-keying the authored pick to `id: feat` is what
- * makes it fold. No persisted GRANDCHILD key moved with it ·
- * pc.decision-engine.ts builds `feat:<childId>` off a hardcoded prefix,
- * independent of the parent choice's own id.
+ * The L19 Epic Boon folds through this SAME path, but only as of R4-P4's re-key
+ * (live in the SRD data from that phase's regeneration). This docblock earlier
+ * cited it as an existing example, which it was not. EVERY reader OF THE FEAT
+ * PICK keys on the LITERAL string `feat`, and there are FOUR of them, not the two
+ * the R4-P4 spec §2.3 and task brief enumerate: this function (`block.feat`,
+ * below), `collectFeatPicks` (pc.resolver.ts), `PCResolver.resolve`'s
+ * feat-to-spell application pass, the two `collectFeatGrantedSpells` calls
+ * (pc.resolver.ts), the one that makes a SPELL-granting boon work, and
+ * `visitProficiencyChoices`' arm (A) (pc.decision-engine.ts, R4-G3b §8), which
+ * reads `block.feat` to walk the chosen feat's own proficiency choices. Note the
+ * qualifier: this is NOT a claim that every reader of a saved class choice block
+ * keys on `feat`. Others read the very same block by OTHER keys ·
+ * `collectClassAsiBranch` (above) reads the legacy `.asi` through
+ * `legacyAsiBranch` (pc.asi-flatten.ts), while `resolvePool` (pc.pools.ts) and
+ * `resolveChosenInline` (pc.resolver.ts) read by a DYNAMIC pool/choice id.
+ * `legacyAsiBranch` also tests `block.feat`, but only to DETECT the feat branch
+ * (R4-P4 Decision B), not to consume the pick. pc.decision-engine.ts's LEDGER
+ * (`buildItem`) is NOT a reader: it reads generically by `choice.id`, which is
+ * exactly why re-keying works at all; since H234 its class walk also SYNTHESIZES
+ * a `feat` answer, the read-only alias for a level saved in the older ASI shape
+ * (`legacyAsiReader`), which consumes no persisted `feat` key. srd-2024.yaml
+ * authored the boon's pick `id: epic-boon`, so an L19 selection persisted under
+ * `choices[19]["epic-boon"]`, which no reader looks at: the boon resolved to no
+ * feat, granted no spells, and contributed no ability points at all. Re-keying
+ * the authored pick to `id: feat` is what makes it fold. No persisted GRANDCHILD
+ * key moved with it · pc.decision-engine.ts builds `feat:<childId>` off a
+ * hardcoded prefix, independent of the parent choice's own id.
  *
  * Clamps defensively (per-ability max_per, then stops at the points total in
  * ABILITY_KEYS order), mirroring collectChosenAbilityPoints.