@archivist-gg/dnd5e 0.3.10 → 0.3.13

package/dist/spell/spell.scaling.js

@@ -3,10 +3,19 @@ function spellScales(spell) {
   var _a, _b, _c, _d;
   return ((_b = (_a = spell.casting_options) == null ? void 0 : _a.length) != null ? _b : 0) > 0 || ((_d = (_c = spell.at_higher_levels) == null ? void 0 : _c.length) != null ? _d : 0) > 0;
 }
+function spellBaseRoll(spell) {
+  const roll = typeof spell.damage_roll === "string" ? spell.damage_roll.trim() : "";
+  return roll !== "" ? roll : null;
+}
 function spellEffectPartsAtSlot(spell, slotLevel) {
-  var _a;
-  const opt = ((_a = spell.casting_options) != null ? _a : []).find((o) => o.type === `slot_level_${slotLevel}`);
-  if (!opt) return null;
+  var _a, _b;
+  const base = (_a = spell.level) != null ? _a : 0;
+  if (base === 0) return null;
+  const opt = ((_b = spell.casting_options) != null ? _b : []).find((o) => o.type === `slot_level_${slotLevel}`);
+  if (!opt) {
+    const roll = spellBaseRoll(spell);
+    return roll !== null && slotLevel === base ? { field: "damage_roll", value: roll } : null;
+  }
   if (opt.damage_roll) return { field: "damage_roll", value: opt.damage_roll };
   if (typeof opt.target_count === "number") {
     if (opt.target_count === slotLevel) return null;
@@ -15,6 +24,27 @@ function spellEffectPartsAtSlot(spell, slotLevel) {
   if (opt.duration) return { field: "duration", value: opt.duration };
   return opt.desc != null ? { field: "desc", value: opt.desc } : null;
 }
+var NON_ROLL_SCALES = /* @__PURE__ */ new Set(["duration", "target_count"]);
+var NON_ROLL_OPTION_FIELDS = /* @__PURE__ */ new Set([...NON_ROLL_SCALES, "concentration"]);
+function spellBaseRollAtSlot(spell, slotLevel) {
+  var _a, _b, _c;
+  const base = (_a = spell.level) != null ? _a : 0;
+  if (base === 0 || slotLevel < base) return null;
+  const roll = spellBaseRoll(spell);
+  if (roll === null) return null;
+  const slotOptions = ((_b = spell.casting_options) != null ? _b : []).filter((o) => {
+    var _a2;
+    return /^slot_level_\d+$/.test(String((_a2 = o.type) != null ? _a2 : ""));
+  });
+  if (slotOptions.length > 0) {
+    const onlyNonRoll = slotOptions.every((o) => {
+      const fields = Object.entries(o).filter(([k, v]) => k !== "type" && v != null).map(([k]) => k);
+      return fields.some((k) => NON_ROLL_SCALES.has(k)) && fields.every((k) => NON_ROLL_OPTION_FIELDS.has(k));
+    });
+    return onlyNonRoll ? roll : null;
+  }
+  return ((_c = spell.at_higher_levels) != null ? _c : []).some((t) => typeof t === "string" && t.trim() !== "") ? null : roll;
+}
 function spellEffectAtSlot(spell, slotLevel) {
   var _a, _b;
   return (_b = (_a = spellEffectPartsAtSlot(spell, slotLevel)) == null ? void 0 : _a.value) != null ? _b : null;
@@ -30,7 +60,7 @@ function spellEffectAtCharacterLevel(spell, characterLevel) {
     const n = Number(m[1]);
     if (n <= characterLevel && (best === null || n > best.n)) best = { n, roll: opt.damage_roll };
   }
-  return best ? best.roll : null;
+  return best ? best.roll : spellBaseRoll(spell);
 }
 function upcastLevelsFor(spell, ownedSlotLevels) {
   var _a;
@@ -39,6 +69,8 @@ function upcastLevelsFor(spell, ownedSlotLevels) {
   return ownedSlotLevels.filter((l) => l > base).sort((a, b) => a - b);
 }
 export {
+  spellBaseRoll,
+  spellBaseRollAtSlot,
   spellEffectAtCharacterLevel,
   spellEffectAtSlot,
   spellEffectPartsAtSlot,

package/dist/spell/spell.schema.d.ts

@@ -40,6 +40,7 @@ export declare const spellEntitySchema: z.ZodObject<{
     damage: z.ZodOptional<z.ZodObject<{
         types: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
+    damage_roll: z.ZodOptional<z.ZodString>;
     saving_throw: z.ZodOptional<z.ZodObject<{
         ability: z.ZodString;
     }, z.core.$strip>>;

package/dist/spell/spell.schema.js

@@ -1,6 +1,6 @@
 import {
   spellEntitySchema
-} from "../chunk-VQAXTIBW.js";
+} from "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {
   spellEntitySchema

package/dist/spell/spell.types.d.ts

@@ -16,6 +16,10 @@ export interface Spell {
     damage?: {
         types: string[];
     };
+    /** The BASE roll: the roll at the spell's own level, or a cantrip's tier-1 roll (before its first
+     *  `player_level_<N>` option). Like `casting_options[].damage_roll` it also carries healing rolls
+     *  (Cure Wounds `2d8`). Mirrors Open5e v2's top-level `damage_roll`. */
+    damage_roll?: string;
     saving_throw?: {
         ability: string;
     };

package/dist/srd/retired-items.d.ts

@@ -0,0 +1,14 @@
+export interface RetiredItem {
+    retired_slug: string;
+    retired_name: string;
+    /** The bundle-relative note path the retired record shipped at (dnd5e 0.3.12). */
+    retired_path: string;
+    kept_slug: string;
+    kept_name: string;
+}
+export declare const RETIRED_ITEMS: readonly RetiredItem[];
+/** The kept slug for a retired item slug, or undefined. */
+export declare function keptSlugFor(slug: string): string | undefined;
+/** The kept slug for an UNWRAPPED link target: a slug, or a compendium path (`SRD 5e/Magic Items/Hand Crossbow +2`), read
+ *  the way `resolveBaseItem` reads one. A vault-root path (`Compendium/SRD 5e/...`) never resolved and is left alone. */
+export declare function keptSlugForLink(target: string): string | undefined;

package/dist/srd/retired-items.js

@@ -0,0 +1,11 @@
+import {
+  RETIRED_ITEMS,
+  keptSlugFor,
+  keptSlugForLink
+} from "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
+export {
+  RETIRED_ITEMS,
+  keptSlugFor,
+  keptSlugForLink
+};

package/dist/subclass/subclass.codec.js

@@ -1,16 +1,16 @@
 import {
   subclassCodec
-} from "../chunk-R747YKS7.js";
-import "../chunk-J77CKYV3.js";
-import "../chunk-BLRW2UU6.js";
+} from "../chunk-M2OWVAZG.js";
+import "../chunk-5KGV6TF7.js";
+import "../chunk-J53ERF6K.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-23LZLBJK.js";
+import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 import "../chunk-UA5KS2PL.js";
 export {
   subclassCodec

package/dist/subclass/subclass.parser.js

@@ -1,15 +1,15 @@
 import {
   parseSubclass
-} from "../chunk-J77CKYV3.js";
-import "../chunk-BLRW2UU6.js";
+} from "../chunk-5KGV6TF7.js";
+import "../chunk-J53ERF6K.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-23LZLBJK.js";
+import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseSubclass

package/dist/subclass/subclass.schema.d.ts

@@ -106,8 +106,18 @@ export declare const subclassEntitySchema: z.ZodObject<{
         }, z.core.$strip>;
         count: z.ZodObject<{
             column: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
         replaceable: z.ZodOptional<z.ZodBoolean>;
+        active: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            label: z.ZodString;
+            verb: z.ZodString;
+            counter_label: z.ZodOptional<z.ZodString>;
+            create_label: z.ZodOptional<z.ZodString>;
+            create_verb: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        head_resource: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     pool_grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
         pool: z.ZodString;

package/dist/subclass/subclass.schema.js

@@ -1,13 +1,13 @@
 import {
   subclassEntitySchema
-} from "../chunk-BLRW2UU6.js";
-import "../chunk-23LZLBJK.js";
+} from "../chunk-J53ERF6K.js";
+import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-FPGXFD2M.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-BRGLDWUP.js";
+import "../chunk-ZMJQUZQH.js";
 import "../chunk-UA5KS2PL.js";
 export {
   subclassEntitySchema

package/dist/types/choice.d.ts

@@ -75,6 +75,14 @@ export interface EntityFilter {
     /** Armor proficiency class. Matched against an armor entity's `category`
      *  field exactly; "shield" selects shields. */
     armor_category?: "light" | "medium" | "heavy" | "shield";
+    /** Item axis: an item entity's `type` ("instrument", "artisan's tools", "gaming set"); ANY listed type matches.
+     *  Compared case-insensitively with apostrophes, separators and a plural "s" folded (`categoryWords` in
+     *  pc.tool-picks.ts), so "artisans tools" matches "artisan's tools". A starting-equipment tool category
+     *  (`musical-instrument`, `artisan's-tools`, `gaming-set`, or an `X-or-Y` union of them) sets it. */
+    item_type?: string[];
+    /** Item axis: true keeps only MUNDANE items, dropping one whose `rarity` names a magic tier. Starting gear sets
+     *  it, because magic instruments (Instrument of Scribing, +3 Rhythm-Maker's Drum) also carry `type: instrument`. */
+    mundane?: boolean;
     /** Spell axis: filter spells by class list, level, and edition. Set together on a
      *  select-entity{entity_type:"spell"} choice (e.g. Magic Initiate). */
     list?: string;

package/dist/types/equipment-grant.d.ts

@@ -1,7 +1,9 @@
 /** One thing a starting-equipment option grants. `item` is a BARE compendium
  *  slug (e.g. "chain-mail"); the seeder resolves it to the full edition slug.
  *  `category` is a player-picked class of item ("martial-weapon",
- *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield", …) resolved
+ *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield",
+ *  "musical-instrument", "artisan's-tools", "gaming-set", a tool `X-or-Y` union;
+ *  the vocabulary is `categoryToEntitySelect`'s in pc.decision-engine.ts) resolved
  *  by a nested select-entity. `gold` is gp folded into the bundle. */
 export type EquipmentGrant = 
 /** `contains_value` (COPPER; `1500` = 15 gp) is seeded as gold by the plugin's starting-equipment seeder
@@ -19,6 +21,21 @@ export type EquipmentGrant =
 } | {
     gold: number;
 };
+/** THE rule for which grant is a player-picked CATEGORY: an object whose `category` is a non-empty string. Shared by
+ *  the engine's nested-pick synthesis and the plugin's seeder, so the nth category grant of an option always
+ *  consumes the nth pick key and the two can never count a malformed grant differently. */
+export declare function isCategoryGrant(g: unknown): g is Extract<EquipmentGrant, {
+    category: string;
+}>;
+/** The persistence key of the nested pick for grant `k` of option `j` of starting-equipment entry `i`: the one
+ *  spelling the engine emits and the plugin reads. `k` indexes the option's WHOLE grant list, not its category
+ *  grants alone. */
+export declare const equipmentCategoryKey: (i: number, j: number, k: number) => string;
+/** The ORDERED pick keys of one option's category grants, the order `resolveGrants` consumes them in. */
+export declare const equipmentCategoryKeys: (grants: readonly unknown[], i: number, j: number) => string[];
+/** True for a starting-equipment decision key (`equipment-<i>` and its nested picks). The Equipment step owns
+ *  these; every other step's decision strip leaves them out. */
+export declare const isStartingEquipmentKey: (key: string) => boolean;
 /** One selectable option of a `kind:"choice"` starting-equipment entry. `label`
  *  is the human display string (the `.pc-cb-eqopt` text); `grants` is what seeds. */
 export interface EquipmentOption {

package/dist/types/equipment-grant.js

@@ -0,0 +1,12 @@
+import {
+  equipmentCategoryKey,
+  equipmentCategoryKeys,
+  isCategoryGrant,
+  isStartingEquipmentKey
+} from "../chunk-2LULMQTF.js";
+export {
+  equipmentCategoryKey,
+  equipmentCategoryKeys,
+  isCategoryGrant,
+  isStartingEquipmentKey
+};

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

@@ -1,5 +1,10 @@
 import type { Ability } from "./choice.js";
 export type SenseType = "darkvision" | "blindsight" | "tremorsense" | "truesight";
+/** A damage rider's weapon scope, the `damage-bonus` arm's structured `applies_to` words (ART-c1 Task 9b, controller
+ *  ruling 8): `melee` and `ranged` are the weapon's CATEGORY (a thrown melee weapon stays melee), `unarmed` the engine's
+ *  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";
 /** 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 = {
@@ -69,7 +74,7 @@ export type FeatureEffect = ({
     kind: "damage-bonus";
     damage_type: string;
     amount: string;
-    applies_to?: "weapon" | "spell" | "all";
+    applies_to?: "spell" | "all" | WeaponScope | WeaponScope[];
 } & Qualified) | ({
     kind: "proficiency";
     proficiency_type: "skill" | "tool" | "language" | "saving-throw" | "armor" | "weapon";

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

@@ -8,7 +8,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";
+export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion" | "artificer_plan";
 /** A class/subclass named reference carried by a level prerequisite; mirrors namedRefSchema. */
 export type OptionalFeatureNamedRef = {
     name: string;
@@ -45,6 +45,76 @@ export type OptionalFeaturePrerequisite = {
     entry?: string;
     entry_summary?: string;
 };
+/** ART-a (spec §4.2). */
+export interface FilterSpec {
+    rarity: string[];
+    types?: string[];
+    exclude_types?: string[];
+    cursed?: false;
+}
+export interface OptionCreates {
+    item?: string;
+    variant?: {
+        candidates: string[];
+    };
+    filter?: FilterSpec;
+}
+export interface OptionRow {
+    key: string;
+    name: string;
+    min_level: number;
+    attunement?: boolean;
+    creates: OptionCreates;
+}
+export interface InfuseItem {
+    bonuses?: {
+        ac?: number;
+        weapon_attack?: number;
+        weapon_damage?: number;
+        spell_attack?: number;
+        saving_throws?: number;
+        speed?: {
+            walk?: number;
+            fly?: number;
+            swim?: number;
+            climb?: number;
+        };
+    };
+    resist?: string[];
+    charges?: {
+        max: number;
+        dice?: string;
+        recharge?: string;
+        recharge_amount?: string;
+    };
+    action?: ActionCost;
+    /** ART-c1 (R-3 a): the Actions row's range ("Self"); absent draws no range. */
+    range?: string;
+}
+export interface InfuseTarget {
+    kind: "armor" | "shield" | "weapon" | "gear";
+    category?: string[];
+    property?: string;
+    name_any?: string[];
+}
+export interface InfuseBlock {
+    targets: InfuseTarget[];
+    targets_label?: string;
+    new_object?: string;
+    rarity?: string;
+    attunement?: {
+        required: true;
+    };
+    choice?: {
+        kind: "damage-type";
+        options?: string[];
+    };
+    item?: InfuseItem;
+    scales_at?: Array<{
+        level: number;
+        item: InfuseItem;
+    }>;
+}
 export interface OptionalFeatureEntity {
     slug: string;
     name: string;
@@ -87,4 +157,12 @@ export interface OptionalFeatureEntity {
     optionalfeature_progression?: ProgressionEntry[];
     /** One wikilink, or an array of them for the multi-fluff-image emit. */
     image?: string | string[];
+    /** ART-a (spec §4.1): a pick is a COPY `<note slug>#<param>`; needs `options` and `item_choice`. */
+    repeatable?: true;
+    /** `learn`: the param is the item's FULL slug (TCE); `create`: the param is a row key, the item chosen at Create (EFA). */
+    item_choice?: "learn" | "create";
+    /** The table a copy's param must satisfy (spec §4.2). */
+    options?: OptionRow[];
+    /** This member infuses an existing object; its effect is an item-vocabulary overlay (spec §4.2). */
+    infuse?: InfuseBlock;
 }

package/dist/types/selection-pool.d.ts

@@ -1,3 +1,12 @@
+/** ART-a (spec §4.5): the at-once counter of an item-bound pool; its defaults are applied at read (`poolActiveWords`). */
+export interface PoolActive {
+    column: string;
+    label: string;
+    verb: string;
+    counter_label?: string;
+    create_label?: string;
+    create_verb?: string;
+}
 /** A (sub)class-declared selectable pool (e.g. Interdict Boons). The engine is
  *  generic: every game-specific string lives here in data, never in code. */
 export interface SelectionPool {
@@ -10,11 +19,17 @@ export interface SelectionPool {
             available_to: "self";
         };
     };
-    /** Pick count read from the owning class table column at the current level. */
+    /** Pick count read from the owning class table column at the current level. `label` is the known-counter word,
+     *  read through `poolCountLabel` (absent reads "Known", ART-a spec §4.5). */
     count: {
         column: string;
+        label?: string;
     };
     replaceable?: boolean;
+    /** ART-a (spec §4.5): the at-once counter (Infused Items, Magic Items). */
+    active?: PoolActive;
+    /** ART-a (spec §4.5): a resource id the tab head shows when the pool spends none of its own. */
+    head_resource?: string;
 }
 /** Subclass auto-grants that extend a named pool and do NOT count toward picks. */
 export interface PoolGrant {

package/dist/weapon/weapon.classify.d.ts

@@ -1,13 +1,15 @@
 import type { WeaponEntity } from "./weapon.types.js";
 /** The two attack modes a weapon supports, derived from data the SRD pipeline
- *  actually preserves. The SRD runtime data miscategorizes throwable MELEE
- *  weapons (dagger/spear/handaxe/javelin/light hammer/trident) as `*-ranged`,
- *  so the melee/ranged split is reconstructed here instead of trusted:
- *  a category-ranged weapon is PURE ranged only when it needs ammunition or
- *  loading, or is one of the two genuinely-ranged thrown weapons (dart, net —
- *  a closed SRD set; a homebrew weapon whose bare slug is exactly "dart"/"net"
- *  is force-classified pure ranged). Everything else category-ranged is a
- *  throwable melee weapon. `reach` is 5 ft, +5 with the reach property. */
+ *  actually preserves. Since dnd5e 0.3.13 the SRD data files the throwable
+ *  MELEE weapons (dagger/spear/handaxe/javelin/light hammer/trident) as
+ *  `*-melee`, but older SRD data, imported records and homebrew can still file
+ *  them as `*-ranged` (by their thrown range), so the melee/ranged split is
+ *  reconstructed here instead of trusted: a category-ranged weapon is PURE
+ *  ranged only when it needs ammunition or loading, or is one of the two
+ *  genuinely-ranged thrown weapons (dart, net: a closed SRD set; a homebrew
+ *  weapon whose bare slug is exactly "dart"/"net" is force-classified pure
+ *  ranged). Everything else category-ranged is a throwable melee weapon.
+ *  `reach` is 5 ft., +5 with the reach property. */
 export interface WeaponRangeModes {
     melee: {
         reach: number;

package/dist/weapon/weapon.classify.js

@@ -1,7 +1,7 @@
 import {
   classifyWeaponRange
-} from "../chunk-UIRMA5KM.js";
-import "../chunk-6X4KUDMU.js";
+} from "../chunk-YDGMBMYI.js";
+import "../chunk-ZCTUYGNV.js";
 export {
   classifyWeaponRange
 };

package/dist/weapon/weapon.codec.js

@@ -1,8 +1,8 @@
 import {
   weaponCodec
-} from "../chunk-LDDCNPHD.js";
-import "../chunk-HZA7OE7N.js";
-import "../chunk-2DFENQIJ.js";
+} from "../chunk-K5NJBTE2.js";
+import "../chunk-XCFC7LGF.js";
+import "../chunk-5GKJAUMX.js";
 import "../chunk-UA5KS2PL.js";
 export {
   weaponCodec

package/dist/weapon/weapon.parser.js

@@ -1,7 +1,7 @@
 import {
   parseWeapon
-} from "../chunk-HZA7OE7N.js";
-import "../chunk-2DFENQIJ.js";
+} from "../chunk-XCFC7LGF.js";
+import "../chunk-5GKJAUMX.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseWeapon

package/dist/weapon/weapon.schema.d.ts

@@ -31,6 +31,7 @@ export declare const weaponEntitySchema: z.ZodObject<{
     }>;
     entries: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     rendering_hint: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
     has_fluff: z.ZodOptional<z.ZodBoolean>;
     has_fluff_images: z.ZodOptional<z.ZodBoolean>;
     image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;

package/dist/weapon/weapon.schema.js

@@ -1,6 +1,6 @@
 import {
   weaponEntitySchema
-} from "../chunk-2DFENQIJ.js";
+} from "../chunk-5GKJAUMX.js";
 import "../chunk-UA5KS2PL.js";
 export {
   weaponEntitySchema

package/dist/weapon/weapon.types.d.ts

@@ -36,6 +36,8 @@ export interface WeaponEntity {
     entries?: unknown[];
     /** Carried as the empty string on every converter weapon carrier today (98). */
     rendering_hint?: string;
+    /** The icon key (I3): a key of the renderer's icon set or a Lucide name. */
+    icon?: string;
     has_fluff?: boolean;
     has_fluff_images?: boolean;
     /** One wikilink, or an array for >= 2 fluff images (images-ON emit). */

package/package.json

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