@archivist-gg/dnd5e 0.3.13 → 0.3.19

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

@@ -0,0 +1,122 @@
+/**
+ * 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 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;
+        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[];
+/** 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;
+    read: (childId: string) => ChoiceValue | undefined;
+}
+export declare function raceFeatSites(race: {
+    slug: string;
+    choices?: unknown;
+    traits?: ReadonlyArray<{
+        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

@@ -0,0 +1,39 @@
+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
+};

package/dist/pc/pc.parser.js

@@ -1,6 +1,6 @@
 import {
   characterSchema
-} from "../chunk-UE6LKRXQ.js";
+} from "../chunk-NTU2DXNG.js";
 import "../chunk-S7REMWW4.js";
 import {
   keptSlugForLink

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

@@ -9,6 +9,13 @@ export interface PoolRegistry {
     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 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

package/dist/pc/pc.pools.js

@@ -1,23 +1,26 @@
 import {
   levelPrereqMax,
+  poolAnchorLevel,
   resolveAllPools,
   resolvePool,
   strandedPicks
-} from "../chunk-T5GZBKIQ.js";
+} from "../chunk-NXUY5XQN.js";
 import "../chunk-W6GC6OKK.js";
-import "../chunk-HJQNK3J5.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

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

@@ -1,4 +1,6 @@
 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
@@ -62,3 +64,15 @@ 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;

package/dist/pc/pc.proficiencies.js

@@ -1,37 +1,47 @@
+import {
+  qualifiedGrantCovers
+} from "../chunk-3LWMFYKS.js";
+import "../chunk-YDGMBMYI.js";
 import {
   collectChosenProficiencies,
   collectProficiencyGrants,
-  computeEffectiveProficiencies
-} from "../chunk-QEO7LYTG.js";
+  computeEffectiveProficiencies,
+  computeSuppressedProficiencies
+} from "../chunk-EJD47JHL.js";
 import "../chunk-2LULMQTF.js";
-import "../chunk-H5PTKYXL.js";
-import "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-4BZ47YJ4.js";
+import "../chunk-QA3YCOML.js";
+import "../chunk-64VNLMSG.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
 import {
+  normKey,
+  proficiencyKey,
   proficiencyLabel,
-  toProfSlug
-} from "../chunk-RLGQ5PZZ.js";
-import "../chunk-T5GZBKIQ.js";
+  toProfSlug,
+  weaponProfKey
+} from "../chunk-5JXFJ5AU.js";
+import "../chunk-RD2MID3M.js";
+import "../chunk-LICYHPI3.js";
+import "../chunk-PVCEA4HZ.js";
+import "../chunk-KSTV7J2U.js";
+import "../chunk-DPUJDOKV.js";
+import "../chunk-LBEXLN6I.js";
+import "../chunk-NXUY5XQN.js";
 import "../chunk-W6GC6OKK.js";
-import "../chunk-HJQNK3J5.js";
+import "../chunk-B3DP42OM.js";
 import "../chunk-IUAAXXNO.js";
 import "../chunk-YHYTW5QA.js";
-import "../chunk-DPM6V7YX.js";
-import "../chunk-PVCEA4HZ.js";
-import "../chunk-LBEXLN6I.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-ZCTUYGNV.js";
-import "../chunk-YBLDE5CG.js";
+import "../chunk-4J6DS3EJ.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";
@@ -51,8 +61,29 @@ function collectProficiencySources(resolved) {
   };
 }
 function aggregateProficiencies(resolved) {
-  const src = collectProficiencySources(resolved);
+  const { armor, weapons } = composeArmorWeapons(resolved);
   const effective = computeEffectiveProficiencies(resolved);
+  return { armor: armor.kept, weapons: weapons.kept, tools: effective.tools, languages: effective.languages };
+}
+function proficiencyOverview(resolved, kind) {
+  if (kind === "armor" || kind === "weapons") {
+    const c = composeArmorWeapons(resolved)[kind];
+    return { effective: c.kept, removed: c.suppressed };
+  }
+  return { effective: computeEffectiveProficiencies(resolved)[kind], removed: computeSuppressedProficiencies(resolved)[kind] };
+}
+function weaponCoveredBy(effective, weapon) {
+  const cat = typeof weapon.category === "string" ? weapon.category : "";
+  const base = cat.split("-")[0];
+  return effective.find((e) => {
+    const key = weaponProfKey(e.value);
+    if ((key === "simple" || key === "martial") && key === base) return true;
+    if (cat && key === normKey(cat)) return true;
+    return qualifiedGrantCovers(e.value, weapon);
+  });
+}
+function composeArmorWeapons(resolved) {
+  const src = collectProficiencySources(resolved);
   return {
     // Walk order defines `sources` order (spec §4.1): class before feats, and
     // for weapons the class `fixed` names before the class categories, matching
@@ -67,10 +98,27 @@ function aggregateProficiencies(resolved) {
     // keeps origin `grant` and its granting source(s) (R4-G3b §7 F5 · the same
     // grants-then-picks order computeEffectiveProficiencies uses for the
     // language and tool buckets). Armor passes none.
-    armor: composeGrantEntries([src.classArmor, src.featArmor, src.effectArmor]),
-    weapons: composeGrantEntries([src.classWeaponFixed, src.classWeaponCategories, src.featWeapons, src.effectWeapons], src.chosenWeapons),
-    tools: effective.tools,
-    languages: effective.languages
+    armor: applyKindOverrides(resolved, "armor", composeGrantEntries([src.classArmor, src.featArmor, src.effectArmor])),
+    weapons: applyKindOverrides(
+      resolved,
+      "weapons",
+      composeGrantEntries([src.classWeaponFixed, src.classWeaponCategories, src.featWeapons, src.effectWeapons], src.chosenWeapons)
+    )
+  };
+}
+function applyKindOverrides(resolved, kind, entries) {
+  var _a, _b, _c, _d;
+  const ov = (_b = (_a = resolved.definition) == null ? void 0 : _a.overrides) == null ? void 0 : _b[kind];
+  const key = (v) => proficiencyKey(kind, v);
+  const all = [...entries];
+  for (const v of (_c = ov == null ? void 0 : ov.add) != null ? _c : []) {
+    if (!all.some((e) => key(e.value) === key(v))) all.push({ value: v, label: prettyName(v), sources: [], origin: "manual" });
+  }
+  const removes = new Set(((_d = ov == null ? void 0 : ov.remove) != null ? _d : []).map(key));
+  const byLabel = (a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0;
+  return {
+    kept: all.filter((e) => !removes.has(key(e.value))).sort(byLabel),
+    suppressed: all.filter((e) => removes.has(key(e.value))).sort(byLabel)
   };
 }
 function composeGrantEntries(buckets, picks = []) {
@@ -102,5 +150,7 @@ function prettyName(slug) {
 }
 export {
   aggregateProficiencies,
-  collectProficiencySources
+  collectProficiencySources,
+  proficiencyOverview,
+  weaponCoveredBy
 };

package/dist/pc/pc.proficiency-normalize.d.ts

@@ -27,3 +27,17 @@ export declare const humanizeProficiency: (s: string) => string;
  *    the first character capitalised, every other letter untouched. Title-casing it word by word lower-cased
  *    `2H` to `2h` and read "That Have The Light Property". */
 export declare const proficiencyLabel: (raw: string) => string;
+/** The four proficiency kinds the sheet lists and the D4 pickers edit, one picker per kind. */
+export type ProficiencyKind = "armor" | "weapons" | "tools" | "languages";
+/** D4 A: the key of a WEAPON proficiency value, so every spelling of one grant folds onto one key. A category reads
+ *  `simple` or `martial` whatever its spelling ("martial", "Martial weapons"); anything else is keyed by
+ *  {@link normKey}, the rule the live weapon gate (`isWeaponSlugProficient`) matches a weapon's name by, so
+ *  "longswords", "Longsword" and "longsword" meet, and "hand-crossbow" meets "Hand Crossbows" and "Crossbow, hand". */
+export declare const weaponProfKey: (raw: string) => string;
+/** D4 A: the key of an ARMOR proficiency value: `light`, `medium`, `heavy`, `shield` whatever the spelling
+ *  ("Heavy armor", "shields"). */
+export declare const armorProfKey: (raw: string) => string;
+/** D4 A: the one comparison key per kind, used by the engine's override readers and the plugin's writers alike, so a
+ *  value the writer stores and the value the reader suppresses always meet. Languages and tools keep `toProfSlug`,
+ *  unchanged. */
+export declare const proficiencyKey: (kind: ProficiencyKind, raw: string) => string;

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

@@ -1,12 +1,18 @@
 import {
+  armorProfKey,
   humanizeProficiency,
   normKey,
+  proficiencyKey,
   proficiencyLabel,
-  toProfSlug
-} from "../chunk-RLGQ5PZZ.js";
+  toProfSlug,
+  weaponProfKey
+} from "../chunk-5JXFJ5AU.js";
 export {
+  armorProfKey,
   humanizeProficiency,
   normKey,
+  proficiencyKey,
   proficiencyLabel,
-  toProfSlug
+  toProfSlug,
+  weaponProfKey
 };

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";
+} from "../chunk-5JXFJ5AU.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);
 }