@archivist-gg/dnd5e 0.1.1 → 0.2.0

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

@@ -33,9 +33,16 @@ export declare const ITEM_ACTIONS: Record<string, ItemAction>;
 export declare function findItemAction(slug: string): ItemAction | undefined;
 /**
  * Resolve the ItemAction for an equipped entry.
- * Priority: entry.overrides (action + range) merged onto curated map.
- * Returns null when neither source supplies an action cost.
+ * Priority: per-instance override > curated map > `itemType==="potion"`
+ * bonus-action default > null.
+ *
+ * `itemType` is the entity's `data.type` (from the registry, statically
+ * `unknown`); per the 2024 SRD, drinking/administering a potion is a Bonus
+ * Action, so an uncurated `type==="potion"` item still surfaces (curated oils
+ * mis-typed `"potion"` are pinned to "action" so this default cannot mislabel
+ * them). Returns null when no source supplies a cost (non-potion uncurated with
+ * no override).
  *
  * Accepts both bare and compendium-prefixed slugs (see `findItemAction`).
  */
-export declare function resolveItemAction(slug: string, entry: EquipmentEntry): ItemAction | null;
+export declare function resolveItemAction(slug: string, entry: EquipmentEntry, itemType?: unknown): ItemAction | null;

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

@@ -46,13 +46,19 @@ var ITEM_ACTIONS = {
   // Magic weapons with activation actions (surface in items table only via override; weapons table is primary)
   "sun-blade": { cost: "free", range: "self" },
   // Potions / consumables
-  "potion-of-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
-  "potion-of-greater-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
-  "potion-of-superior-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
-  "potion-of-supreme-healing": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  // 2024 healing potions are a Bonus Action to drink/administer (curation still
+  // carries range/max_charges/recovery; the type=potion default covers uncurated ones).
+  "potion-of-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "potion-of-greater-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "potion-of-superior-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "potion-of-supreme-healing": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
   "alchemists-fire": { cost: "action", range: "20 ft.", max_charges: 1, recovery: { amount: "0", reset: "special" } },
   "holy-water": { cost: "action", range: "20 ft.", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  // Oils are APPLIED (minutes), not drunk: curated to "action" so the blanket
+  // type=potion → bonus-action default never mislabels these mis-typed items.
   "oil-of-sharpness": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "oil-of-etherealness": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
+  "oil-of-slipperiness": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } },
   "dust-of-disappearance": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "0", reset: "special" } }
 };
 function findItemAction(slug) {
@@ -62,14 +68,13 @@ function findItemAction(slug) {
   const bare = slug.slice(underscore + 1);
   return ITEM_ACTIONS[bare];
 }
-function resolveItemAction(slug, entry) {
-  var _a;
+function resolveItemAction(slug, entry, itemType) {
+  var _a, _b;
   const curated = (_a = findItemAction(slug)) != null ? _a : null;
   const override = entry.overrides;
   const overrideCost = override == null ? void 0 : override.action;
   const overrideRange = override == null ? void 0 : override.range;
-  if (!curated && !overrideCost) return null;
-  const cost = overrideCost != null ? overrideCost : curated == null ? void 0 : curated.cost;
+  const cost = (_b = overrideCost != null ? overrideCost : curated == null ? void 0 : curated.cost) != null ? _b : itemType === "potion" ? "bonus-action" : void 0;
   if (!cost) return null;
   return {
     cost,

package/dist/item/item.codec.js

@@ -1,8 +1,8 @@
 import {
   itemCodec
-} from "../chunk-TPZSPU4L.js";
-import "../chunk-YDPWD2T7.js";
-import "../chunk-VLKIB33F.js";
+} from "../chunk-4JHOHWBI.js";
+import "../chunk-7VJ6BOA5.js";
+import "../chunk-K6Q5OUGK.js";
 export {
   itemCodec
 };

package/dist/item/item.parser.js

@@ -1,7 +1,7 @@
 import {
   parseItem
-} from "../chunk-YDPWD2T7.js";
-import "../chunk-VLKIB33F.js";
+} from "../chunk-7VJ6BOA5.js";
+import "../chunk-K6Q5OUGK.js";
 export {
   parseItem
 };

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

@@ -175,6 +175,9 @@ export declare const itemEntitySchema: z.ZodObject<{
         }>>;
         condition: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    scroll_level: z.ZodOptional<z.ZodNumber>;
+    unidentified: z.ZodOptional<z.ZodBoolean>;
+    masked_category: z.ZodOptional<z.ZodString>;
     raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     damage_dice: z.ZodOptional<z.ZodString>;
     damage_type: z.ZodOptional<z.ZodString>;

package/dist/item/item.schema.js

@@ -1,7 +1,7 @@
 import {
   conditionSchema,
   itemEntitySchema
-} from "../chunk-VLKIB33F.js";
+} from "../chunk-K6Q5OUGK.js";
 export {
   conditionSchema,
   itemEntitySchema

package/dist/item/item.types.d.ts

@@ -106,6 +106,14 @@ export interface ItemEntity {
         applies_to?: "weapon" | "spell" | "all";
         condition?: string;
     }>;
+    /** Spell-scroll casting level (e.g. 3 for a "Spell Scroll (3rd Level)"). */
+    scroll_level?: number;
+    /** Marks an item the player has not yet identified: the sheet shows the
+     *  masked_category label instead of the item's true identity. */
+    unidentified?: boolean;
+    /** Generic category label shown for an unidentified item (e.g. "potion",
+     *  "scroll", "wand") in place of its real name. */
+    masked_category?: string;
     raw?: Record<string, unknown>;
     damage_dice?: string;
     damage_type?: string;

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

@@ -5,9 +5,16 @@ import {
   collectChosenAbilityPoints,
   collectChosenProficiencies,
   wikilinkTailSlug
-} from "../chunk-TJCNX6UZ.js";
+} from "../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";
 import "../chunk-WP2CX2JO.js";
 export {
   __matchesFilterForTest,

package/dist/pc/pc.equipment.js

@@ -2,15 +2,19 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-ADLTSHOR.js";
-import "../chunk-UC4FE5X3.js";
-import "../chunk-TJCNX6UZ.js";
+} 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";
 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";
 export {
   computeAppliedBonuses,

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

@@ -1,10 +1,17 @@
 import {
   computeFeatureEffects,
   emptyFeatureEffectTotals
-} from "../chunk-GEJSJP6E.js";
-import "../chunk-TJCNX6UZ.js";
+} 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";
 import "../chunk-WP2CX2JO.js";
 export {
   computeFeatureEffects,

package/dist/pc/pc.parser.js

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

package/dist/pc/pc.pools.js

@@ -2,11 +2,16 @@ import {
   levelPrereqMax,
   resolveAllPools,
   resolvePool
-} from "../chunk-6PXE7T7C.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-TJCNX6UZ.js";
+} from "../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";
 import "../chunk-WP2CX2JO.js";
 export {
   levelPrereqMax,

package/dist/pc/pc.recalc.js

@@ -1,9 +1,3 @@
-import {
-  computeSpellLimits,
-  deriveSpellSlots,
-  resolveSpellcasting
-} from "../chunk-IXZXFFFW.js";
-import "../chunk-5XUXXAQJ.js";
 import {
   computeConditionEffects
 } from "../chunk-R2ZV233X.js";
@@ -11,16 +5,22 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-ADLTSHOR.js";
-import "../chunk-UC4FE5X3.js";
+} from "../chunk-TQZB4OCJ.js";
 import {
   computeFeatureEffects
-} from "../chunk-GEJSJP6E.js";
+} from "../chunk-V6SOFUJW.js";
 import {
   collectChosenAbilityPoints,
   collectChosenProficiencies
-} from "../chunk-TJCNX6UZ.js";
+} from "../chunk-R5SQHP2X.js";
 import "../chunk-BH6AMZVY.js";
+import "../chunk-UC4FE5X3.js";
+import {
+  computeSpellLimits,
+  deriveSpellSlots,
+  resolveSpellcasting
+} from "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
 import "../chunk-JEYQU3JT.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
@@ -574,6 +574,15 @@ function recalc(resolved, registry) {
     saveDC: spellcastingClasses[0].saveDC,
     attackBonus: spellcastingClasses[0].attackBonus
   } : null;
+  const abilitySpellcasting = {};
+  for (const s of resolved.spells) {
+    const ab = s.ability;
+    if (!ab || abilitySpellcasting[ab]) continue;
+    abilitySpellcasting[ab] = {
+      saveDC: saveDC(scores[ab], proficiencyBonus) + applied.spell_save_dc,
+      attackBonus: attackBonus(scores[ab], proficiencyBonus) + applied.spell_attack
+    };
+  }
   const derivedSlots = deriveSpellSlots(slotInputs);
   const spellLimits = computeSpellLimits(limitInputs);
   const defenses = {
@@ -616,6 +625,7 @@ function recalc(resolved, registry) {
     initiative: init,
     spellcasting,
     spellcastingClasses,
+    abilitySpellcasting,
     derivedSpellSlots: derivedSlots.standard,
     pactMagic: derivedSlots.pact,
     spellLimits,

package/dist/pc/pc.resolver.d.ts

@@ -2,12 +2,28 @@ import type { EntityRegistry } from "@archivist-gg/core";
 import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
 import type { BackgroundEntity } from "@archivist-gg/dnd5e/background/background.types";
 import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
-import type { Character, ResolvedCharacter, ResolvedClass, ResolvedFeature } from "./pc.types.js";
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { Character, ChoiceValue, ResolvedCharacter, ResolvedClass, ResolvedFeature, ResolvedSpell } from "./pc.types.js";
 export interface ResolveResult {
     character: ResolvedCharacter;
     warnings: string[];
 }
 export declare function stripSlug(ref: string | null): string | null;
+/**
+ * Resolve a background's `origin_feat` wikilink into a real FeatEntity + a display
+ * name, using ONLY the EntityRegistry (no DOM). Lifted from the builder's
+ * background-step so the resolver pipeline and the builder share ONE resolution
+ * (R2-m7, [[always-retire-shims-edit-all]]). Handles both path-style refs
+ * ("[[SRD 2024/Feats/Alert]]") and bare-slug refs ("[[my-feat]]"), plus the 2024
+ * parenthetical-variant refs ("[[SRD 2024/Feats/Magic Initiate (Cleric)]]") that
+ * resolve to the BASE feat ("magic-initiate") while keeping the full variant
+ * string as the display name. Returns null when the ref is empty or resolves to no
+ * feat (an unresolvable ref folds nothing into the pipeline).
+ */
+export declare function resolveOriginFeat(entities: EntityRegistry, originFeatRef: string | null): {
+    feat: FeatEntity;
+    display: string;
+} | null;
 export declare class PCResolver {
     private readonly entities;
     constructor(entities: EntityRegistry);
@@ -32,6 +48,48 @@ export declare function collectChosenWeaponMasteries(character: Character): {
  * Returns bare slugs (no `[[ ]]`).
  */
 export declare function collectFeatSlugs(character: Character): string[];
+/**
+ * Feat→spell application (3d). Walks a feat's OWN `choices` to find its spell
+ * picks and turns each into a ResolvedSpell. A feat's spells sit behind a
+ * `spell-list` select-inline whose CHOSEN branch nests `select-entity{spell}`
+ * picks; the chosen spellcasting ability comes from the feat's
+ * `spellcasting-ability` select-inline. `read(childId)` yields the persisted pick
+ * for a child choice id (origin feat: `origin_choices["background:feat:<id>"]`;
+ * class-slot feat: `choices[lvl]["feat:<id>"]`). Unresolvable spell slugs warn and
+ * are skipped, mirroring the known-spell loop. classSlug stays null: a feat spell
+ * is not owned by a class for DC/ability; the carried `ability` drives its casting.
+ */
+export declare function collectFeatGrantedSpells(feat: FeatEntity, read: (childId: string) => ChoiceValue | undefined, entities: EntityRegistry, warnings: string[]): ResolvedSpell[];
+/**
+ * Item→spell application (P4-T3). Walks the character's equipment for entries whose
+ * resolved item is a spell scroll (carries the T1 `scroll_level` marker) AND names a
+ * chosen spell via `overrides.spell`, turning each into a
+ * ResolvedSpell{ source:"item", classSlug:null, prepared:true, alwaysPrepared:true }.
+ * The casting `ability` is the character's OWN spellcasting ability when they have
+ * one (`ownAbility`, the first caster class's ability), else the per-instance
+ * `overrides.spell_ability`, else undefined (a no-ability scroll is left ability-less:
+ * the plugin surfaces it without a DC; an ability is NEVER fabricated here).
+ * `entryIndex` records the originating equipment index so the segmented dedupe keeps
+ * two scrolls of one spell (and a scroll of a class-known spell) as their own rows.
+ * Unresolvable spell slugs warn and are skipped, mirroring the known-spell + feat loops.
+ * In-memory only: no KnownSpellObject{source:"item"} is injected (its strict schema
+ * omits `ability`).
+ */
+export declare function collectItemGrantedSpells(character: Character, ownAbility: Ability | null, entities: EntityRegistry, warnings: string[]): ResolvedSpell[];
+/**
+ * Collapses duplicate resolved spells (3d Minor #2 carry-forward + P4-T3 segmented
+ * dedupe). A spell can be emitted more than once: it may be BOTH in
+ * `character.spells.known` AND a feat pick, or a feat may be taken as both origin +
+ * class-slot. A class-sourced copy owns a real DC via its `classSlug`, so it always
+ * wins over a feat copy of the same slug; otherwise first-seen wins. Insertion order
+ * is preserved (a later class copy replaces an earlier feat copy in place), so the
+ * Spells section never renders duplicate rows while a legitimately class-known copy is
+ * never lost. Item-source spells carry INSTANCE identity: they key by
+ * `slug + "#" + entryIndex`, so two scrolls of one spell stay two rows and a scroll of
+ * a class-known spell keeps its OWN item row, never collapsing into / being collapsed
+ * by a class/feat copy. The class/feat slug-only merge is unchanged.
+ */
+export declare function dedupeResolvedSpells(spells: ResolvedSpell[]): ResolvedSpell[];
 /** Selected select-entity values (optional-features) and selected inline
  *  options carrying effects[] become synthesized resolved features (SP2 Plan 3 §9).
  *  The actions/resources engines consume these synthesized features, and the