@archivist-gg/dnd5e 0.3.17 → 0.3.19

package/dist/pc/pc.rest.js

@@ -5,15 +5,16 @@ import "../chunk-DPUJDOKV.js";
 import {
   effectiveItemCharges,
   effectiveItemRecovery
-} from "../chunk-3VZZDKRA.js";
+} 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-ZUQW5VBZ.js";
 import "../chunk-LVQLWRCU.js";
 import "../chunk-CM5CWO4K.js";
+import "../chunk-4J6DS3EJ.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
 import "../chunk-ZCTUYGNV.js";

package/dist/pc/pc.schema.d.ts

@@ -90,6 +90,14 @@ export declare const characterOverridesShape: z.ZodObject<{
             proficient: "proficient";
         }>>>;
     }, z.core.$strip>>;
+    weapons: z.ZodOptional<z.ZodObject<{
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    armor: z.ZodOptional<z.ZodObject<{
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
     defenses: z.ZodOptional<z.ZodObject<{
         resistances: z.ZodOptional<z.ZodObject<{
             remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -381,6 +389,14 @@ export declare const characterSchema: z.ZodObject<{
                 proficient: "proficient";
             }>>>;
         }, z.core.$strip>>;
+        weapons: z.ZodOptional<z.ZodObject<{
+            add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        armor: z.ZodOptional<z.ZodObject<{
+            add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
         defenses: z.ZodOptional<z.ZodObject<{
             resistances: z.ZodOptional<z.ZodObject<{
                 remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -416,6 +432,9 @@ export declare const characterSchema: z.ZodObject<{
             saves: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
                 section: "section";
             }>>>;
+            body: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                wide: "wide";
+            }>>>;
         }, z.core.$strip>>;
         favorites: z.ZodOptional<z.ZodArray<z.ZodString>>;
         filters: z.ZodOptional<z.ZodObject<{

package/dist/pc/pc.schema.js

@@ -1,7 +1,7 @@
 import {
   characterOverridesShape,
   characterSchema
-} from "../chunk-T6QIF5XR.js";
+} from "../chunk-NTU2DXNG.js";
 import "../chunk-S7REMWW4.js";
 export {
   characterOverridesShape,

package/dist/pc/pc.spell-scope.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A spell damage rider's `spell_scope` read against the character's spells (found 2026-09-29: Potent Spellcasting,
+ * Empowered Evocation, Elemental Affinity, Radiant Soul and the Artificer riders said which spells they reach only in
+ * prose, so they reached none). Data, not per-feature code: every word of the scope is one test on the spell entity.
+ */
+import type { SpellScope } from "../types/feature-effect.js";
+import type { Spell } from "../spell/spell.types.js";
+import type { ResolvedCharacter, ResolvedSpell } from "./pc.types.js";
+/** Does `spell` deal damage? Its data names at least one damage type. */
+export declare function dealsDamage(spell: Pick<Spell, "damage">): boolean;
+/**
+ * The slugs of the character's `spells` a rider with `scope` reaches, unique, in `spells` order: every spell that DEALS
+ * DAMAGE and matches every word the scope carries (see `SpellScope`). `pickedTypes` answers `damage_type_pick` (the
+ * types the character's pick names; none reaches no spell). No scope reaches none; an empty scope every damaging spell.
+ */
+export declare function spellsInScope(scope: SpellScope | undefined, spells: ReadonlyArray<Pick<ResolvedSpell, "slug" | "entity">>, pickedTypes: (choiceId: string) => string[]): string[];
+/**
+ * The damage types the character chose at the `select-inline` `choiceId` of one of its class or subclass features (the
+ * 2014 Dragon Ancestor's "Red (Fire)", the 2024 Elemental Affinity's "fire"): the canonical types its answer's option
+ * names, in its value or its label. Empty when no feature offers that choice or it is unanswered.
+ */
+export declare function pickedDamageTypes(resolved: Pick<ResolvedCharacter, "classes">, choiceId: string): string[];

package/dist/pc/pc.tool-picks.js

@@ -5,9 +5,9 @@ import {
   classToolPicks,
   expandToolPool,
   toolCategoriesOf
-} from "../chunk-H5PTKYXL.js";
+} from "../chunk-QA3YCOML.js";
 import "../chunk-KU3YLF6D.js";
-import "../chunk-RLGQ5PZZ.js";
+import "../chunk-5JXFJ5AU.js";
 export {
   TOOL_CATEGORIES,
   backgroundToolPicks,

package/dist/pc/pc.types.d.ts

@@ -1,7 +1,7 @@
-import type { Ability } from "../types/choice.js";
+import type { Ability, EntityFilter } from "../types/choice.js";
 import type { ArmorEntity } from "../armor/armor.types.js";
 import type { WeaponEntity } from "../weapon/weapon.types.js";
-import type { WeaponScope } from "../types/feature-effect.js";
+import type { SpellScope, WeaponScope } from "../types/feature-effect.js";
 import type { ItemEntity } from "../item/item.types.js";
 import type { SkillSlug, Feature, Choice } from "@archivist-gg/dnd5e";
 import type { ClassEntity } from "@archivist-gg/dnd5e/class/class.types";
@@ -125,8 +125,8 @@ export type KnownSpellEntry = string | KnownSpellObject;
 export type PassiveKind = "perception" | "investigation" | "insight";
 /** The manual proficiency tri, in ONE place. The runtime twin is `proficiencyTri`
  *  (pc.schema.ts); `pc.recalc.ts` imports this name for the skills tri, and the plugin's
- *  `CharacterEditState.setToolProficiency` and `ProficiencyEditModal` import it for the
- *  tools tri (R4-G4 §9.3, UR1), so no consumer re-spells the union. */
+ *  `CharacterEditState` imports it for the tools tri its writers keep (R4-G4 §9.3, UR1;
+ *  `setToolExpertise` since D4 A), so no consumer re-spells the union. */
 export type ProficiencyTri = "none" | "proficient" | "expertise";
 export interface CharacterOverrides {
     scores?: Partial<Record<Ability, number>>;
@@ -181,6 +181,18 @@ export interface CharacterOverrides {
         remove?: string[];
         proficiency?: Record<string, ProficiencyTri>;
     };
+    /** D4 A: the same add / remove pair for WEAPON and ARMOR proficiencies. A weapon value is a category (`simple`,
+     *  `martial`) or one weapon (`longsword`, `hand-crossbow`); an armor value is `light`, `medium`, `heavy` or `shield`.
+     *  Read through `proficiencyKey` (pc.proficiency-normalize.ts), so any spelling of a grant matches. No defaults, like
+     *  `languages`/`tools`: an untouched note stays byte-identical. */
+    weapons?: {
+        add?: string[];
+        remove?: string[];
+    };
+    armor?: {
+        add?: string[];
+        remove?: string[];
+    };
     /** Manual defense edits, mirroring `characterOverridesShape` (pc.schema.ts). SUPPRESSION-ONLY:
      *  the absent `add` channel is a DELIBERATE asymmetry with `languages`/`tools` above, not an
      *  oversight · do not "complete the pattern". The additive store is `character.defenses.*`,
@@ -263,8 +275,10 @@ export interface SheetPoolView {
     folded?: string[];
 }
 export interface CharacterSheetState {
+    /** `saves: section` (SL) draws the saves as a sidebar section; `body: wide` (D13) is the wide three-column sheet. */
     layout?: {
         saves?: "section";
+        body?: "wide";
     };
     favorites?: string[];
     filters?: {
@@ -345,6 +359,11 @@ export type FeatVia = {
     kind: "background";
     slug: string;
 }
+/** SRD-G T4 (audit §3b): a feat picked through a species trait (the SRD 5.2 Human's Versatile origin feat). */
+ | {
+    kind: "race";
+    slug: string;
+}
 /** D2b-A (design §2.2 step 6): a feat a POOL MEMBER grants (Lessons of the First Ones' Origin feat). `slug` is the
  *  member's note slug and `name` its display name; `classSlug` / `level` are the pool's class and anchor level. */
  | {
@@ -394,6 +413,10 @@ export interface ResolvedFeature {
     renderSuppressed?: boolean;
     /** The feat's entire substance is a full ability-score improvement (a pure ASI). The DISPLAY layer hides these. */
     buildOnly?: boolean;
+    /** The spells this feature's spell-scoped damage riders reach, as its data names them (`memberSpellTargets`): set by
+     *  `assembleEffectFeatures` on a pool member (Agonizing Blast's cantrip pick, the 2014 invocation's `spell-known`
+     *  prerequisite). A wrapper-only field; absent on every other feature, whose spell riders then reach no spell. */
+    spellTargets?: SpellTargets;
     /** R4-G7 §7.1: EVERY LOWER copy the resolve-time fold collapsed into this wrapper, ASCENDING by level, with
      *  that copy's own card identity (`name`, and `description` = its `description` else its `entries` joined) and
      *  its `choices` when it carries any. A wrapper-only field, the `chosenInline` precedent: the shared registry
@@ -440,6 +463,9 @@ export interface ResolvedSpell {
     /** True ONLY for a row from character.spells.known (removable / toggleable);
      *  absent on every grant · R4-G3b §5.2.7. */
     persisted?: boolean;
+    /** True for a spell cast at will without a spell slot: a pool member's `innate` at-will grant (Armor of Shadows'
+     *  Mage Armor). The Spells tab gives it the At Will chip, never a slot's CAST. Absent on every other row. */
+    atWill?: boolean;
 }
 export interface ResolvedClass {
     entity: ClassEntity | null;
@@ -617,6 +643,38 @@ export interface DamageRider {
      *  `computeFeatureEffects`; consumed and DROPPED by recalc's rider resolution (an attack row never carries it). */
     owner?: FeatureSource;
 }
+/** The spells a feature's spell-scoped damage rider reaches, as the member's DATA names them (`memberSpellTargets`):
+ *  `refs` are the answers of its target picks (`target: true`, Agonizing Blast's cantrip) and its `spell-known`
+ *  prerequisites (the 2014 invocation's Eldritch Blast); `open` holds the filter of each target pick left unanswered,
+ *  which reaches a spell only when the character has exactly one legal answer (`spellsReached`). */
+export interface SpellTargets {
+    refs: string[];
+    open: EntityFilter[];
+}
+/** A `damage-bonus` effect with `applies_to: spell` (Agonizing Blast's "your Charisma modifier") or `all` (Hexblade's
+ *  Curse). The fold carries the authored amount with its `owner`, `targets` and `scope`; recalc resolves the amount against
+ *  the owning class, reads the targets and the scope against the character's spells into `spells` and drops `owner`,
+ *  `targets` and `scope`, keeping only riders that reach a spell. `damage_type` survives only when it is a canonical type
+ *  (a `chosen` or prose type is the spell's own). How the sheet prints it is `addSpellDamageRiders` (inside the roll: an
+ *  unconditional rider of the spell's own type) and `spellDamageRiderLines` (its own line: a `condition`, like a
+ *  conditional weapon rider, or another damage type). */
+export interface SpellDamageRider {
+    amount: string;
+    damage_type?: string;
+    source?: string;
+    condition?: string;
+    /** The scope's `once`: the rider adds to one damage roll of the casting ("one damage roll of that spell"). */
+    once?: boolean;
+    /** The slugs of the character's resolved spells this rider reaches (recalc). */
+    spells?: string[];
+    /** Fold only: see {@link DamageRider.owner}. */
+    owner?: FeatureSource;
+    /** Fold only: the feature's {@link SpellTargets} (a pool member's named spells). */
+    targets?: SpellTargets;
+    /** Fold only: the effect's `spell_scope` ({} for an unscoped `applies_to: all`: every damaging spell). Absent (and no
+     *  `targets`) reaches no spell. */
+    scope?: SpellScope;
+}
 export interface AttackRow {
     id: string;
     name: string;
@@ -928,6 +986,9 @@ export interface DerivedStats {
      */
     attacksPerAction: number;
     attacks: AttackRow[];
+    /** Spell-scoped damage riders that reach at least one of the character's spells, amounts resolved (Agonizing Blast's
+     *  "3" on Eldritch Blast). Absent when none does. The Spells tab adds them into the spell's roll. */
+    spellDamageRiders?: SpellDamageRider[];
     equippedSlots: EquippedSlots;
     carriedWeight: number;
     attunementUsed: number;

package/dist/race/race.codec.js

@@ -1,14 +1,14 @@
 import {
   raceCodec
-} from "../chunk-AZRGFUSR.js";
-import "../chunk-Y5VVP73C.js";
-import "../chunk-FANQVQ3D.js";
+} from "../chunk-BJGOSM76.js";
+import "../chunk-HY2SRSVM.js";
+import "../chunk-FJYBLXV7.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-YD2VAHA6.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   raceCodec

package/dist/race/race.parser.js

@@ -1,13 +1,13 @@
 import {
   parseRace
-} from "../chunk-Y5VVP73C.js";
-import "../chunk-FANQVQ3D.js";
+} from "../chunk-HY2SRSVM.js";
+import "../chunk-FJYBLXV7.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-YD2VAHA6.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseRace

package/dist/race/race.schema.js

@@ -1,12 +1,12 @@
 import {
   fixedAsiSchema,
   raceEntitySchema
-} from "../chunk-FANQVQ3D.js";
-import "../chunk-YD2VAHA6.js";
+} from "../chunk-FJYBLXV7.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   fixedAsiSchema,

package/dist/schemas/choice-schema.js

@@ -1,7 +1,7 @@
 import {
   choiceSchema
-} from "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+} from "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 export {
   choiceSchema
 };

package/dist/schemas/feature-effect-schema.d.ts

@@ -136,6 +136,15 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         finesse: "finesse";
         thrown: "thrown";
     }>>]>>;
+    spell_scope: z.ZodOptional<z.ZodObject<{
+        list: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodNumber>;
+        school: z.ZodOptional<z.ZodString>;
+        damage_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        damage_type_pick: z.ZodOptional<z.ZodString>;
+        spells: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        once: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{

package/dist/schemas/feature-effect-schema.js

@@ -1,6 +1,6 @@
 import {
   featureEffectSchema
-} from "../chunk-2JSQE3DD.js";
+} from "../chunk-JXWNXIIZ.js";
 export {
   featureEffectSchema
 };

package/dist/schemas/feature-schema.js

@@ -1,11 +1,11 @@
 import {
   featureObjectSchema,
   featureSchema
-} from "../chunk-YD2VAHA6.js";
+} from "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 export {
   featureObjectSchema,
   featureSchema

package/dist/subclass/subclass.codec.js

@@ -1,16 +1,16 @@
 import {
   subclassCodec
-} from "../chunk-QZSWN2KT.js";
-import "../chunk-OFCSP6MT.js";
-import "../chunk-LF5AGJA4.js";
+} from "../chunk-NZO7M5GV.js";
+import "../chunk-UNYR5GLI.js";
+import "../chunk-LNT64X7C.js";
 import "../chunk-4U55VNC7.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-YD2VAHA6.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   subclassCodec

package/dist/subclass/subclass.parser.js

@@ -1,15 +1,15 @@
 import {
   parseSubclass
-} from "../chunk-OFCSP6MT.js";
-import "../chunk-LF5AGJA4.js";
+} from "../chunk-UNYR5GLI.js";
+import "../chunk-LNT64X7C.js";
 import "../chunk-4U55VNC7.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-YD2VAHA6.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseSubclass

package/dist/subclass/subclass.schema.js

@@ -1,13 +1,13 @@
 import {
   subclassEntitySchema
-} from "../chunk-LF5AGJA4.js";
+} from "../chunk-LNT64X7C.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-YD2VAHA6.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   subclassEntitySchema

package/dist/types/choice.d.ts

@@ -22,8 +22,8 @@ export declare const ALL_SKILL_SLUGS: SkillSlug[];
  *     comparison, `matchPool` — a module-level helper it shares with its other call
  *     sites, not one of its own. `computeEffectiveProficiencies` reads ALL_LANGUAGES
  *     from HERE, directly — it does not go through the generator's KNOWN_LANGUAGES.
- *   · the PLUGIN: `proficiency-edit-modal.ts` renders its LANGUAGE section from
- *     `[...ALL_LANGUAGES, ...suppressed]`.
+ *   · the PLUGIN: `proficiency-picker.ts` (D4 A) lists STANDARD, EXOTIC ("Rare") and
+ *     SECRET_LANGUAGES as its Languages rows, plus any held or removed value they miss.
  *  Membership is also what makes two spellings of one language FOLD onto a single
  *  row: a vocabulary MISS keys on the raw string and splits the row in two. */
 export declare const STANDARD_LANGUAGES: string[];

package/dist/types/feature-effect.d.ts

@@ -5,6 +5,23 @@ export type SenseType = "darkvision" | "blindsight" | "tremorsense" | "truesight
  *  Unarmed Strike row, `finesse` and `thrown` the row's properties, and `weapon` every attack row (today's reach, the
  *  Unarmed Strike row included). A list reaches a row when ANY word matches it. */
 export type WeaponScope = "weapon" | "melee" | "ranged" | "unarmed" | "finesse" | "thrown";
+/** A spell damage rider's spell scope, the `damage-bonus` arm's `spell_scope` (found 2026-09-29: Potent Spellcasting,
+ *  Empowered Evocation, Elemental Affinity and Radiant Soul said which spells they reach only in prose, so they reached
+ *  none). The rider reaches a character's spell that DEALS DAMAGE when every word it carries matches: `list` the spell is
+ *  on that class's list, `level` its exact level (0 = cantrip), `school` its school, `damage_types` it deals ANY of them,
+ *  `damage_type_pick` it deals the damage type the character chose at that `select-inline` (its option value or a type
+ *  named in its label, "Red (Fire)"), `spells` it is one of these (a name or a slug). `once`: the rider adds to ONE damage
+ *  roll of the casting, however many rolls or targets the spell has ("one damage roll of that spell"). Read with
+ *  `applies_to: spell` or `all`; `all` with no scope reaches every damaging spell. */
+export interface SpellScope {
+    list?: string;
+    level?: number;
+    school?: string;
+    damage_types?: string[];
+    damage_type_pick?: string;
+    spells?: string[];
+    once?: boolean;
+}
 /** Present on every arm: whose numbers the effect changes. Absent === "self". The engine's fold readers skip
  *  every effect whose subject is present and not "self" (`foldsOnSelf` in pc.feature-effects.ts). */
 type Subject = {
@@ -81,6 +98,7 @@ export type FeatureEffect = ({
     damage_type: string;
     amount: string;
     applies_to?: "spell" | "all" | WeaponScope | WeaponScope[];
+    spell_scope?: SpellScope;
 } & Qualified) | ({
     kind: "proficiency";
     proficiency_type: "skill" | "tool" | "language" | "saving-throw" | "armor" | "weapon";

package/dist/types/optional-feature.types.d.ts

@@ -9,7 +9,7 @@ import type { AdditionalSpellsEntry, ProgressionEntry } from "../schemas/entity-
  * `feature_type` field is now an open string (see {@link OptionalFeatureEntity})
  * so homebrew categories parse; this union is kept purely as a reference list.
  */
-export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion" | "artificer_plan";
+export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion" | "artificer_plan" | "pact_boon";
 /** A class/subclass named reference carried by a level prerequisite; mirrors namedRefSchema. */
 export type OptionalFeatureNamedRef = {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archivist-gg/dnd5e",
-  "version": "0.3.17",
+  "version": "0.3.19",
   "license": "MIT AND CC-BY-4.0",
   "type": "module",
   "publishConfig": {