@archivist-gg/dnd5e 0.2.0 → 0.3.1

package/dist/item/item.actions-map.d.ts

@@ -21,14 +21,15 @@ export declare const ITEM_ACTIONS: Record<string, ItemAction>;
  * (`srd-5e_wand-of-fireballs`, `srd-2024_wand-of-fireballs`,
  * `homebrew_wand-of-fireballs`).
  *
- * Compendium-prefixed slugs follow the shape `<prefix>_<name-slug>` where
- * both prefix and name-slug are kebab-case (slugify strips underscores).
- * The first underscore is therefore the unambiguous prefix separator: we
- * try the bare slug after the first underscore first, then fall back to
- * the original slug for legacy bare-slug callers.
+ * Type-namespaced slugs follow the shape `<prefix>_<entity_type>_<name-slug>`
+ * (all kebab-case; slugify never emits `_`), so a slug splits on `_` into
+ * exactly 3 parts and the bare name is `parts.slice(2).join("_")`. This is
+ * arity-robust: it also recovers the bare name from a legacy 2-part
+ * `<prefix>_<name>` slug and an already-bare name. `ITEM_ACTIONS` is keyed by
+ * bare name.
  *
- * Returns `undefined` if no map entry matches either form. Does not crash
- * on slugs without an underscore — those are treated as already-bare.
+ * Returns `undefined` if no map entry matches. Does not crash on slugs
+ * without an underscore — those are treated as already-bare.
  */
 export declare function findItemAction(slug: string): ItemAction | undefined;
 /**

package/dist/item/item.actions-map.js

@@ -63,10 +63,9 @@ var ITEM_ACTIONS = {
 };
 function findItemAction(slug) {
   if (slug in ITEM_ACTIONS) return ITEM_ACTIONS[slug];
-  const underscore = slug.indexOf("_");
-  if (underscore < 0) return void 0;
-  const bare = slug.slice(underscore + 1);
-  return ITEM_ACTIONS[bare];
+  const p = slug.split("_");
+  const bare = p.length >= 3 ? p.slice(2).join("_") : p[p.length - 1];
+  return bare === slug ? void 0 : ITEM_ACTIONS[bare];
 }
 function resolveItemAction(slug, entry, itemType) {
   var _a, _b;

package/dist/item/item.ai-schema.d.ts

@@ -14,8 +14,8 @@ export declare const itemInputSchema: z.ZodObject<{
         "wondrous item": "wondrous item";
     }>;
     rarity: z.ZodEnum<{
-        legendary: "legendary";
         common: "common";
+        legendary: "legendary";
         uncommon: "uncommon";
         rare: "rare";
         "very rare": "very rare";

package/dist/pc/pc.decision-engine.d.ts

@@ -68,9 +68,6 @@ export interface DecisionContext {
 }
 /** "[[SRD 2024/Classes/Fighter]]" → "fighter" (tail segment, slugified). */
 export declare function wikilinkTailSlug(link: string): string;
-/** "srd-2024_fighter" → "fighter". Tolerates a nullish slug (degrades to "") so a
- *  malformed entity can't hard-crash the builder; the resolver backfills real slugs. */
-export declare function bareEntitySlug(slug: string | null | undefined): string;
 declare function matchesFilter(e: RegisteredEntity, where: EntityFilter, ownerBare: string): boolean;
 /** Test-only export of {@link matchesFilter} (Task B2). */
 export declare const __matchesFilterForTest: typeof matchesFilter;
@@ -83,6 +80,19 @@ export declare function collectChosenProficiencies(resolved: ResolvedCharacter):
     languages: string[];
     tools: string[];
 };
+export interface ChoiceStatus {
+    id: string;
+    count: number;
+    selected: number;
+}
+/** Per-choice status for language/tool select-proficiency decisions, using the
+ *  SAME walk as collectChosenProficiencies so required/selected counts cannot
+ *  diverge from the picks. `selected` counts persisted picks validated against
+ *  the choice's `from` pool (stale slugs ignored, mirroring the pick fold). */
+export declare function collectLanguageToolChoiceStatus(resolved: ResolvedCharacter): {
+    languages: ChoiceStatus[];
+    tools: ChoiceStatus[];
+};
 export interface OriginAbilityPoints {
     race: Partial<Record<Ability, number>>;
     background: Partial<Record<Ability, number>>;

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

@@ -1,26 +1,26 @@
 import {
   __matchesFilterForTest,
-  bareEntitySlug,
   buildDecisionLedger,
   collectChosenAbilityPoints,
   collectChosenProficiencies,
+  collectLanguageToolChoiceStatus,
   wikilinkTailSlug
-} from "../chunk-R5SQHP2X.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-IXZXFFFW.js";
+} from "../chunk-TNUFPIXI.js";
+import "../chunk-7TEK5KK7.js";
+import "../chunk-6IRYTM5V.js";
 import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-J2RYSZMQ.js";
+import "../chunk-N6N74K6X.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
+import "../chunk-VTTA2ALZ.js";
 import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {
   __matchesFilterForTest,
-  bareEntitySlug,
   buildDecisionLedger,
   collectChosenAbilityPoints,
   collectChosenProficiencies,
+  collectLanguageToolChoiceStatus,
   wikilinkTailSlug
 };

package/dist/pc/pc.equipment.js

@@ -2,20 +2,14 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-TQZB4OCJ.js";
-import "../chunk-R5SQHP2X.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-IXZXFFFW.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-JEYQU3JT.js";
+} from "../chunk-D3CLOBE3.js";
+import "../chunk-353WXS6S.js";
+import "../chunk-O5EYMKFH.js";
+import "../chunk-N6N74K6X.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-J2RYSZMQ.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
 export {
   computeAppliedBonuses,
   computeSlotsAndAttacks,

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

@@ -24,6 +24,11 @@ export interface WeaponAbilityOverride {
 export interface FeatureEffectTotals {
     initiative_bonus: number;
     hp_per_level_bonus: number;
+    /** One term per hp-per-level-bonus effect, labeled with the owning feature's name. */
+    hp_per_level_terms: {
+        label: string;
+        value: number;
+    }[];
     speed_walk_bonus: number;
     /**
      * Absolute walk-speed FLOOR from `speed-bonus` effects with `set:true` (e.g.

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

@@ -1,17 +1,8 @@
 import {
   computeFeatureEffects,
   emptyFeatureEffectTotals
-} from "../chunk-V6SOFUJW.js";
-import "../chunk-R5SQHP2X.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-IXZXFFFW.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-JEYQU3JT.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-J2RYSZMQ.js";
-import "../chunk-NAEPSZAM.js";
+} from "../chunk-AIRFC5NQ.js";
+import "../chunk-LV4SNWZQ.js";
 import "../chunk-WP2CX2JO.js";
 export {
   computeFeatureEffects,

package/dist/pc/pc.parser.js

@@ -1,6 +1,6 @@
 import {
   characterSchema
-} from "../chunk-5WQD3WNZ.js";
+} from "../chunk-TN6ZLTNU.js";
 import "../chunk-TZK36BU7.js";
 
 // src/pc/pc.parser.ts

package/dist/pc/pc.pools.js

@@ -2,15 +2,15 @@ import {
   levelPrereqMax,
   resolveAllPools,
   resolvePool
-} from "../chunk-R5SQHP2X.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-IXZXFFFW.js";
+} from "../chunk-TNUFPIXI.js";
+import "../chunk-7TEK5KK7.js";
+import "../chunk-6IRYTM5V.js";
 import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
-import "../chunk-DC74TZNA.js";
-import "../chunk-3TRGRSCH.js";
-import "../chunk-J2RYSZMQ.js";
+import "../chunk-N6N74K6X.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
+import "../chunk-VTTA2ALZ.js";
 import "../chunk-NAEPSZAM.js";
 import "../chunk-WP2CX2JO.js";
 export {

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

@@ -1,8 +1,39 @@
 import type { ResolvedCharacter } from "./pc.types.js";
+import { type ChoiceStatus } from "./pc.decision-engine.js";
 export interface ProficiencyAggregate {
     armor: string[];
     weapons: string[];
     tools: string[];
     languages: string[];
+    /** Unresolved language/tool decisions as "choose N" placeholders (N = count -
+     *  selected, only when > 0). Additive; consumed by the plugin proficiency panel. */
+    choices: {
+        languages: string[];
+        tools: string[];
+    };
 }
+/** Normalized intermediate of every proficiency/language source the DISPLAY path
+ *  reads, in one place. Only the class branch 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. Chosen
+ *  picks + per-choice status come from the single decision walk in
+ *  pc.decision-engine so display can never diverge from the persisted picks. */
+export interface ProficiencySources {
+    classArmor: string[];
+    classWeaponFixed: string[];
+    classWeaponCategories: string[];
+    classToolFixed: string[];
+    raceLangFixed: string[];
+    bgToolFixed: string[];
+    bgLangFixed: string[];
+    featArmor: string[];
+    featWeapons: string[];
+    featTools: string[];
+    featLanguages: string[];
+    chosenLanguages: string[];
+    chosenTools: string[];
+    languageChoices: ChoiceStatus[];
+    toolChoices: ChoiceStatus[];
+}
+export declare function collectProficiencySources(resolved: ResolvedCharacter): ProficiencySources;
 export declare function aggregateProficiencies(resolved: ResolvedCharacter): ProficiencyAggregate;

package/dist/pc/pc.proficiencies.js

@@ -1,47 +1,120 @@
+import {
+  collectChosenProficiencies,
+  collectLanguageToolChoiceStatus
+} from "../chunk-TNUFPIXI.js";
+import "../chunk-7TEK5KK7.js";
+import "../chunk-6IRYTM5V.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-JEYQU3JT.js";
+import "../chunk-N6N74K6X.js";
+import "../chunk-4LZJXJJS.js";
+import "../chunk-LV4SNWZQ.js";
+import "../chunk-VTTA2ALZ.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+
 // src/pc/pc.proficiencies.ts
-function aggregateProficiencies(resolved) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-  const armor = /* @__PURE__ */ new Set();
-  const weapons = /* @__PURE__ */ new Set();
-  const tools = /* @__PURE__ */ new Set();
-  const languages = /* @__PURE__ */ new Set();
+function collectProficiencySources(resolved) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+  const classArmor = [];
+  const classWeaponFixed = [];
+  const classWeaponCategories = [];
+  const classToolFixed = [];
   for (const c of resolved.classes) {
     const prof = (_a = c.entity) == null ? void 0 : _a.proficiencies;
     if (!prof) continue;
-    for (const a of (_b = prof.armor) != null ? _b : []) armor.add(prettyName(a));
-    if ((_c = prof.weapons) == null ? void 0 : _c.fixed) for (const w of prof.weapons.fixed) weapons.add(prettyName(w));
-    if ((_d = prof.weapons) == null ? void 0 : _d.categories) for (const w of prof.weapons.categories) weapons.add(prettyName(w));
-    if ((_e = prof.tools) == null ? void 0 : _e.fixed) for (const t of prof.tools.fixed) tools.add(prettyName(t));
+    for (const a of (_b = prof.armor) != null ? _b : []) classArmor.push(a);
+    for (const w of (_d = (_c = prof.weapons) == null ? void 0 : _c.fixed) != null ? _d : []) classWeaponFixed.push(w);
+    for (const w of (_f = (_e = prof.weapons) == null ? void 0 : _e.categories) != null ? _f : []) classWeaponCategories.push(w);
+    for (const t of (_h = (_g = prof.tools) == null ? void 0 : _g.fixed) != null ? _h : []) classToolFixed.push(t);
   }
-  const raceLangs = (_f = resolved.race) == null ? void 0 : _f.languages;
-  if (raceLangs == null ? void 0 : raceLangs.fixed) for (const l of raceLangs.fixed) languages.add(prettyName(l));
+  const raceLangFixed = [...(_k = (_j = (_i = resolved.race) == null ? void 0 : _i.languages) == null ? void 0 : _j.fixed) != null ? _k : []];
+  const bgToolFixed = [];
+  const bgLangFixed = [];
   const bg = resolved.background;
   if (bg) {
-    for (const entry of (_g = bg.tool_proficiencies) != null ? _g : []) {
-      if (entry.kind === "fixed") for (const t of entry.items) tools.add(prettyName(t));
+    for (const entry of (_l = bg.tool_proficiencies) != null ? _l : []) {
+      if (entry.kind === "fixed") bgToolFixed.push(...entry.items);
     }
-    for (const entry of (_h = bg.language_proficiencies) != null ? _h : []) {
-      if (entry.kind === "fixed") for (const l of entry.languages) languages.add(prettyName(l));
+    for (const entry of (_m = bg.language_proficiencies) != null ? _m : []) {
+      if (entry.kind === "fixed") bgLangFixed.push(...entry.languages);
     }
   }
+  const featArmor = [];
+  const featWeapons = [];
+  const featTools = [];
+  const featLanguages = [];
   for (const f of resolved.feats) {
-    const grants = f.proficiencies;
+    const featView = f;
+    const grants = featView.proficiencies;
     if (!grants) continue;
-    for (const a of (_i = grants.armor) != null ? _i : []) armor.add(prettyName(a));
-    for (const w of (_j = grants.weapons) != null ? _j : []) weapons.add(prettyName(w));
-    for (const t of (_k = grants.tools) != null ? _k : []) tools.add(prettyName(t));
-    for (const l of (_l = grants.languages) != null ? _l : []) languages.add(prettyName(l));
+    featArmor.push(...(_n = grants.armor) != null ? _n : []);
+    featWeapons.push(...(_o = grants.weapons) != null ? _o : []);
+    featTools.push(...(_p = grants.tools) != null ? _p : []);
+    featLanguages.push(...(_q = grants.languages) != null ? _q : []);
   }
+  const chosen = collectChosenProficiencies(resolved);
+  const status = collectLanguageToolChoiceStatus(resolved);
+  return {
+    classArmor,
+    classWeaponFixed,
+    classWeaponCategories,
+    classToolFixed,
+    raceLangFixed,
+    bgToolFixed,
+    bgLangFixed,
+    featArmor,
+    featWeapons,
+    featTools,
+    featLanguages,
+    chosenLanguages: chosen.languages,
+    chosenTools: chosen.tools,
+    languageChoices: status.languages,
+    toolChoices: status.tools
+  };
+}
+function aggregateProficiencies(resolved) {
+  const src = collectProficiencySources(resolved);
+  const armor = /* @__PURE__ */ new Set();
+  const weapons = /* @__PURE__ */ new Set();
+  const tools = /* @__PURE__ */ new Set();
+  const languages = /* @__PURE__ */ new Set();
+  for (const a of src.classArmor) armor.add(prettyName(a));
+  for (const w of src.classWeaponFixed) weapons.add(prettyName(w));
+  for (const w of src.classWeaponCategories) weapons.add(prettyName(w));
+  for (const t of src.classToolFixed) tools.add(prettyName(t));
+  for (const l of src.raceLangFixed) languages.add(prettyName(l));
+  for (const t of src.bgToolFixed) tools.add(prettyName(t));
+  for (const l of src.bgLangFixed) languages.add(prettyName(l));
+  for (const a of src.featArmor) armor.add(prettyName(a));
+  for (const w of src.featWeapons) weapons.add(prettyName(w));
+  for (const t of src.featTools) tools.add(prettyName(t));
+  for (const l of src.featLanguages) languages.add(prettyName(l));
+  for (const l of src.chosenLanguages) languages.add(prettyName(l));
+  for (const t of src.chosenTools) tools.add(prettyName(t));
   return {
     armor: [...armor].sort(),
     weapons: [...weapons].sort(),
     tools: [...tools].sort(),
-    languages: [...languages].sort()
+    languages: [...languages].sort(),
+    choices: {
+      languages: placeholders(src.languageChoices),
+      tools: placeholders(src.toolChoices)
+    }
   };
 }
+function placeholders(choices) {
+  const out = [];
+  for (const c of choices) {
+    const remaining = c.count - c.selected;
+    if (remaining > 0) out.push("choose " + remaining);
+  }
+  return out;
+}
 function prettyName(slug) {
   return slug.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 export {
-  aggregateProficiencies
+  aggregateProficiencies,
+  collectProficiencySources
 };

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

@@ -0,0 +1,5 @@
+/** Normalized token-set key for matching class weapon DISPLAY names ("hand crossbows")
+ *  against weapon-entity names ("Crossbow, hand"). EXACT equality on the key; verified
+ *  collision-free across the SRD weapon set. Strip-"s" singularizer does not handle
+ *  irregular plurals; no SRD weapon triggers that. */
+export declare const normKey: (s: string) => string;

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

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

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

@@ -45,11 +45,18 @@ export declare function abilityBonusBreakdown(resolved: ResolvedCharacter): Reco
     class: number;
     feat: number;
 }>;
+/** Dice-only portion of PC max HP: first VALID level anywhere = max(die),
+ *  every later valid level = PHB average. Skip rule identical to hpLevelCount. */
+export declare function hitDiceAverageSum(classes: ResolvedClass[]): number;
+/** Count of levels that contribute to HP (valid class entries only). */
+export declare function hpLevelCount(classes: ResolvedClass[]): number;
 /**
  * PC-oriented multiclass HP.
  * - First class's first level: max(hit_die) + conMod.
  * - Every subsequent level (in any class): phbAverageForDie(thatLevel'sClass) + conMod.
  * CON mod contributes once per total level.
+ * Decomposed (P5 T2) into hitDiceAverageSum (dice-only) + hpLevelCount (level count),
+ * so a later popup can render the two components separately.
  */
 export declare function multiclassMaxHP(classes: ResolvedClass[], conMod: number): number;
 /**