@archivist-gg/dnd5e 0.1.0

package/dist/inline-tag-parser.d.ts

@@ -0,0 +1,11 @@
+export type InlineTagType = "dice" | "damage" | "dc" | "atk" | "mod" | "check";
+export interface FormulaRef {
+    ability: string;
+    kind: "attack" | "damage" | "dc";
+}
+export interface InlineTag {
+    type: InlineTagType;
+    content: string;
+    formula?: FormulaRef | null;
+}
+export declare function parseInlineTag(text: string): InlineTag | null;

package/dist/inline-tag-parser.js

@@ -0,0 +1,6 @@
+import {
+  parseInlineTag
+} from "./chunk-3TM34RSJ.js";
+export {
+  parseInlineTag
+};

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

@@ -0,0 +1,41 @@
+import type { EquipmentEntry } from "../pc/pc.types.js";
+export type ActionCost = "action" | "bonus-action" | "reaction" | "free" | "special";
+export interface ItemAction {
+    cost: ActionCost;
+    range?: string;
+    max_charges?: number;
+    recovery?: {
+        amount: string;
+        reset: "dawn" | "short" | "long" | "special";
+    };
+}
+/**
+ * Curated map of canonical SRD chargeable / activated items.
+ * Slugs match the SRD compendium slug format. Augmenter reads this map
+ * and stamps `actions: ItemAction` onto the augmented entity bundle.
+ */
+export declare const ITEM_ACTIONS: Record<string, ItemAction>;
+/**
+ * Look up an ItemAction by slug, accepting either a bare name slug
+ * (`wand-of-fireballs`) or a compendium-prefixed slug
+ * (`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.
+ *
+ * Returns `undefined` if no map entry matches either form. Does not crash
+ * on slugs without an underscore — those are treated as already-bare.
+ */
+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.
+ *
+ * Accepts both bare and compendium-prefixed slugs (see `findItemAction`).
+ */
+export declare function resolveItemAction(slug: string, entry: EquipmentEntry): ItemAction | null;

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

@@ -0,0 +1,85 @@
+// src/item/item.actions-map.ts
+var ITEM_ACTIONS = {
+  // Wands and rods
+  "wand-of-fireballs": { cost: "action", range: "150 ft.", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-magic-missiles": { cost: "action", range: "120 ft.", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-lightning-bolts": { cost: "action", range: "100 ft.", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-paralysis": { cost: "action", range: "60 ft.", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-fear": { cost: "action", range: "self", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-binding": { cost: "action", range: "self", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-secrets": { cost: "action", range: "30 ft.", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  "wand-of-web": { cost: "action", range: "60 ft.", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  "wand-of-wonder": { cost: "action", range: "120 ft.", max_charges: 7, recovery: { amount: "1d6+1", reset: "dawn" } },
+  // Activatable wondrous items
+  "boots-of-speed": { cost: "bonus-action", range: "self", max_charges: 1, recovery: { amount: "1", reset: "long" } },
+  "boots-of-levitation": { cost: "action", range: "self" },
+  "boots-of-striding-and-springing": { cost: "free", range: "self" },
+  "broom-of-flying": { cost: "action", range: "touch" },
+  "cloak-of-displacement": { cost: "free", range: "self" },
+  "cloak-of-the-bat": { cost: "action", range: "self", max_charges: 1, recovery: { amount: "1", reset: "long" } },
+  "decanter-of-endless-water": { cost: "action", range: "touch" },
+  "drum-of-panic": { cost: "action", range: "120 ft.", max_charges: 1, recovery: { amount: "1", reset: "long" } },
+  "eyes-of-charming": { cost: "action", range: "30 ft.", max_charges: 3, recovery: { amount: "3", reset: "dawn" } },
+  // Rings
+  "ring-of-three-wishes": { cost: "action", range: "self", max_charges: 3, recovery: { amount: "0", reset: "special" } },
+  "ring-of-shooting-stars": { cost: "action", range: "60 ft.", max_charges: 6, recovery: { amount: "1d6", reset: "dawn" } },
+  "ring-of-the-ram": { cost: "action", range: "60 ft.", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  "ring-of-spell-storing": { cost: "action", range: "self", max_charges: 5 },
+  "ring-of-animal-influence": { cost: "action", range: "self", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  "ring-of-elemental-command": { cost: "action", range: "self", max_charges: 5, recovery: { amount: "1d4+1", reset: "dawn" } },
+  "ring-of-evasion": { cost: "reaction", range: "self", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  // Necklaces
+  "necklace-of-fireballs": { cost: "action", range: "60 ft.", max_charges: 9 },
+  // Gems
+  "gem-of-brightness": { cost: "action", range: "60 ft.", max_charges: 50 },
+  "gem-of-seeing": { cost: "action", range: "self", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  // Helms
+  "helm-of-teleportation": { cost: "action", range: "self", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  // Medallions
+  "medallion-of-thoughts": { cost: "action", range: "30 ft.", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  // Pipes
+  "pipes-of-haunting": { cost: "action", range: "30 ft.", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  "pipes-of-the-sewers": { cost: "action", range: "self", max_charges: 3, recovery: { amount: "1d3", reset: "dawn" } },
+  // Cubes / chimes
+  "cube-of-force": { cost: "action", range: "self", max_charges: 36, recovery: { amount: "1d20", reset: "dawn" } },
+  "chime-of-opening": { cost: "action", range: "120 ft.", max_charges: 10 },
+  // 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" } },
+  "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" } },
+  "oil-of-sharpness": { 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) {
+  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];
+}
+function resolveItemAction(slug, entry) {
+  var _a;
+  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;
+  if (!cost) return null;
+  return {
+    cost,
+    range: overrideRange != null ? overrideRange : curated == null ? void 0 : curated.range,
+    max_charges: curated == null ? void 0 : curated.max_charges,
+    recovery: curated == null ? void 0 : curated.recovery
+  };
+}
+export {
+  ITEM_ACTIONS,
+  findItemAction,
+  resolveItemAction
+};

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const itemInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        weapon: "weapon";
+        armor: "armor";
+        shield: "shield";
+        staff: "staff";
+        potion: "potion";
+        ring: "ring";
+        rod: "rod";
+        scroll: "scroll";
+        wand: "wand";
+        "wondrous item": "wondrous item";
+    }>;
+    rarity: z.ZodEnum<{
+        legendary: "legendary";
+        common: "common";
+        uncommon: "uncommon";
+        rare: "rare";
+        "very rare": "very rare";
+        artifact: "artifact";
+    }>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    value: z.ZodOptional<z.ZodNumber>;
+    attunement: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage: z.ZodOptional<z.ZodString>;
+    damage_type: z.ZodOptional<z.ZodString>;
+    ac: z.ZodOptional<z.ZodNumber>;
+    charges: z.ZodOptional<z.ZodNumber>;
+    recharge: z.ZodOptional<z.ZodString>;
+    curse: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/item/item.ai-schema.js

@@ -0,0 +1,6 @@
+import {
+  itemInputSchema
+} from "../chunk-QS5L5YTJ.js";
+export {
+  itemInputSchema
+};

package/dist/item/item.attunement.d.ts

@@ -0,0 +1,18 @@
+import type { ArmorEntity } from "../armor/armor.types.js";
+import type { WeaponEntity } from "../weapon/weapon.types.js";
+import type { ItemEntity } from "../item/item.types.js";
+/**
+ * `entity.attunement` can be:
+ *   - undefined / false / ""           → not required
+ *   - true                              → required, no restriction
+ *   - "by a wizard"                     → required, with text restriction
+ *   - { required: true, restriction? }  → required (structured)
+ *   - { required: false }               → not required (structured)
+ *
+ * This predicate normalizes all five shapes into a single boolean.
+ *
+ * Accepts any equipped entity. Only items model `attunement`; armor and
+ * weapons never require attunement in this domain, so they short-circuit to
+ * `false` via the property-presence narrow below.
+ */
+export declare function requiresAttunement(entity: ArmorEntity | WeaponEntity | ItemEntity | null): boolean;

package/dist/item/item.attunement.js

@@ -0,0 +1,12 @@
+// src/item/item.attunement.ts
+function requiresAttunement(entity) {
+  if (!entity || !("attunement" in entity)) return false;
+  const a = entity.attunement;
+  if (a === true) return true;
+  if (typeof a === "string") return a.length > 0;
+  if (typeof a === "object" && a !== null) return a.required === true;
+  return false;
+}
+export {
+  requiresAttunement
+};

package/dist/item/item.bonuses.d.ts

@@ -0,0 +1,2 @@
+import type { BonusReadResult, ConditionalBonus, ConditionContext } from "./item.conditions.types.js";
+export declare function readNumericBonus(raw: number | ConditionalBonus | undefined | null, ctx: ConditionContext): BonusReadResult | null;

package/dist/item/item.bonuses.js

@@ -0,0 +1,7 @@
+import {
+  readNumericBonus
+} from "../chunk-LWFTHJIE.js";
+import "../chunk-DNAJRMNN.js";
+export {
+  readNumericBonus
+};

package/dist/item/item.codec.d.ts

@@ -0,0 +1,3 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { ItemEntity } from "./item.types.js";
+export declare const itemCodec: DocCodec<ItemEntity>;

package/dist/item/item.codec.js

@@ -0,0 +1,8 @@
+import {
+  itemCodec
+} from "../chunk-537BHVSH.js";
+import "../chunk-4SSDYJS2.js";
+import "../chunk-4C2KOKLF.js";
+export {
+  itemCodec
+};

package/dist/item/item.conditions.d.ts

@@ -0,0 +1,10 @@
+import type { Condition, ConditionContext, ConditionOutcome } from "./item.conditions.types.js";
+export declare function evaluateCondition(cond: Condition, ctx: ConditionContext): ConditionOutcome;
+/**
+ * AND-combine a list of conditions.
+ * - Empty list -> "true" (always-applies; matches flat-number semantics).
+ * - Any "false" -> "false" (engine certainty short-circuits informational).
+ * - Else any "informational" -> "informational".
+ * - Else "true".
+ */
+export declare function evaluateConditions(conds: Condition[], ctx: ConditionContext): ConditionOutcome;

package/dist/item/item.conditions.js

@@ -0,0 +1,8 @@
+import {
+  evaluateCondition,
+  evaluateConditions
+} from "../chunk-DNAJRMNN.js";
+export {
+  evaluateCondition,
+  evaluateConditions
+};

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

@@ -0,0 +1,28 @@
+import type { EquippedSlots, ClassEntry } from "../pc/pc.types.js";
+import type { BonusFieldPath, Condition } from "../types/item-conditions.types.js";
+export type { Tier1Condition, Tier2Condition, Tier3Condition, Tier4Condition, FreeTextCondition, AnyOfCondition, Condition, ConditionalBonus, BonusFieldPath, } from "../types/item-conditions.types.js";
+export interface InformationalBonus {
+    field: BonusFieldPath;
+    source: string;
+    value: number;
+    conditions: Condition[];
+}
+export type ConditionOutcome = "true" | "false" | "informational";
+export interface ConditionContext {
+    derived: {
+        equippedSlots: EquippedSlots;
+    };
+    classList: ClassEntry[];
+    race: string | null;
+    subclasses: string[];
+}
+export type BonusReadResult = {
+    kind: "applied";
+    value: number;
+} | {
+    kind: "skipped";
+} | {
+    kind: "informational";
+    value: number;
+    conditions: Condition[];
+};

package/dist/item/item.enrichment.d.ts

@@ -0,0 +1,4 @@
+import type { Item } from "@archivist-gg/dnd5e/item/item.types";
+export declare function enrichItem(raw: Record<string, unknown>): Item & {
+    source?: string;
+};

package/dist/item/item.enrichment.js

@@ -0,0 +1,9 @@
+import {
+  enrichItem
+} from "../chunk-GJOI2GHP.js";
+import "../chunk-RAWJTA45.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  enrichItem
+};

package/dist/item/item.entity-type.d.ts

@@ -0,0 +1,2 @@
+import type { EntityType } from "@archivist-gg/core";
+export declare const itemEntityType: EntityType;

package/dist/item/item.generatable.d.ts

@@ -0,0 +1,2 @@
+import type { Generatable } from "@archivist-gg/core";
+export declare const itemGeneratable: Generatable;

package/dist/item/item.parser.d.ts

@@ -0,0 +1,3 @@
+import { Item } from "./item.types.js";
+import { ParseResult } from "@archivist-gg/core";
+export declare function parseItem(source: string): ParseResult<Item>;

package/dist/item/item.parser.js

@@ -0,0 +1,7 @@
+import {
+  parseItem
+} from "../chunk-4SSDYJS2.js";
+import "../chunk-4C2KOKLF.js";
+export {
+  parseItem
+};

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

@@ -0,0 +1,174 @@
+import { z } from "zod";
+import type { Condition } from "@archivist-gg/dnd5e/types/item-conditions.types";
+export declare const conditionSchema: z.ZodType<Condition>;
+export declare const itemEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    rarity: z.ZodOptional<z.ZodString>;
+    base_item: z.ZodOptional<z.ZodString>;
+    bonuses: z.ZodOptional<z.ZodObject<{
+        ac: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        weapon_attack: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        weapon_damage: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        spell_attack: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        spell_save_dc: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        saving_throws: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        ability_scores: z.ZodOptional<z.ZodObject<{
+            static: z.ZodOptional<z.ZodObject<{
+                str: z.ZodOptional<z.ZodNumber>;
+                dex: z.ZodOptional<z.ZodNumber>;
+                con: z.ZodOptional<z.ZodNumber>;
+                int: z.ZodOptional<z.ZodNumber>;
+                wis: z.ZodOptional<z.ZodNumber>;
+                cha: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            bonus: z.ZodOptional<z.ZodObject<{
+                str: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    value: z.ZodNumber;
+                    when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                }, z.core.$strip>]>>;
+                dex: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    value: z.ZodNumber;
+                    when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                }, z.core.$strip>]>>;
+                con: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    value: z.ZodNumber;
+                    when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                }, z.core.$strip>]>>;
+                int: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    value: z.ZodNumber;
+                    when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                }, z.core.$strip>]>>;
+                wis: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    value: z.ZodNumber;
+                    when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                }, z.core.$strip>]>>;
+                cha: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    value: z.ZodNumber;
+                    when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        speed: z.ZodOptional<z.ZodObject<{
+            walk: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                value: z.ZodNumber;
+                when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            }, z.core.$strip>]>>;
+            fly: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                value: z.ZodNumber;
+                when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            }, z.core.$strip>]>, z.ZodLiteral<"walk">]>>;
+            swim: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                value: z.ZodNumber;
+                when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            }, z.core.$strip>]>>;
+            climb: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                value: z.ZodNumber;
+                when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    vulnerable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    condition_immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    charges: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        max: z.ZodNumber;
+        recharge: z.ZodOptional<z.ZodString>;
+        recharge_amount: z.ZodOptional<z.ZodString>;
+        destroy_on_empty: z.ZodOptional<z.ZodObject<{
+            roll: z.ZodString;
+            threshold: z.ZodNumber;
+            effect: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodNumber]>>;
+    attached_spells: z.ZodOptional<z.ZodObject<{
+        charges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        will: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rest: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        limited: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    attunement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        required: z.ZodBoolean;
+        restriction: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            class: z.ZodString;
+            subclass: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            alignment: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            race: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            creature_type: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            spellcasting: z.ZodBoolean;
+        }, z.core.$strip>]>>>;
+    }, z.core.$strip>, z.ZodBoolean, z.ZodString]>>;
+    grants: z.ZodOptional<z.ZodObject<{
+        proficiency: z.ZodOptional<z.ZodBoolean>;
+        languages: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        senses: z.ZodOptional<z.ZodObject<{
+            darkvision: z.ZodOptional<z.ZodNumber>;
+            tremorsense: z.ZodOptional<z.ZodNumber>;
+            truesight: z.ZodOptional<z.ZodNumber>;
+            blindsight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    container: z.ZodOptional<z.ZodObject<{
+        capacity_weight: z.ZodOptional<z.ZodNumber>;
+        weightless: z.ZodOptional<z.ZodBoolean>;
+        pack_contents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    light: z.ZodOptional<z.ZodObject<{
+        bright_radius: z.ZodNumber;
+        dim_radius: z.ZodNumber;
+    }, z.core.$strip>>;
+    cursed: z.ZodOptional<z.ZodBoolean>;
+    sentient: z.ZodOptional<z.ZodBoolean>;
+    focus: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+    }>>;
+    damage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        dice: z.ZodString;
+        type: z.ZodString;
+        versatile_dice: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodString]>>;
+    weapon_category: z.ZodOptional<z.ZodString>;
+    armor_category: z.ZodOptional<z.ZodString>;
+    weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    cost: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    edition: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    effects: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    damage_dice: z.ZodOptional<z.ZodString>;
+    damage_type: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recharge: z.ZodOptional<z.ZodString>;
+    curse: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/item/item.schema.js

@@ -0,0 +1,8 @@
+import {
+  conditionSchema,
+  itemEntitySchema
+} from "../chunk-4C2KOKLF.js";
+export {
+  conditionSchema,
+  itemEntitySchema
+};

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

@@ -0,0 +1,108 @@
+import type { Ability, ArmorCategory } from "@archivist-gg/dnd5e/armor/armor.types";
+import type { WeaponCategory, WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
+import type { ConditionalBonus } from "@archivist-gg/dnd5e/types/item-conditions.types";
+export type ItemRarity = "common" | "uncommon" | "rare" | "very rare" | "legendary" | "artifact" | string;
+export type AttunementTag = {
+    class: string;
+    subclass?: string;
+} | {
+    alignment: string;
+} | {
+    race: string;
+} | {
+    creature_type: string;
+};
+export interface ItemEntity {
+    name: string;
+    slug?: string;
+    type?: string;
+    rarity?: ItemRarity;
+    base_item?: string;
+    bonuses?: {
+        ac?: number | ConditionalBonus;
+        weapon_attack?: number | ConditionalBonus;
+        weapon_damage?: number | ConditionalBonus;
+        spell_attack?: number | ConditionalBonus;
+        spell_save_dc?: number | ConditionalBonus;
+        saving_throws?: number | ConditionalBonus;
+        ability_scores?: {
+            static?: Partial<Record<Ability, number>>;
+            bonus?: Partial<Record<Ability, number | ConditionalBonus>>;
+        };
+        speed?: {
+            walk?: number | ConditionalBonus;
+            fly?: number | ConditionalBonus | "walk";
+            swim?: number | ConditionalBonus;
+            climb?: number | ConditionalBonus;
+        };
+    };
+    resist?: string[];
+    immune?: string[];
+    vulnerable?: string[];
+    condition_immune?: string[];
+    charges?: {
+        max: number;
+        recharge?: string;
+        recharge_amount?: string;
+        destroy_on_empty?: {
+            roll: string;
+            threshold: number;
+            effect?: string;
+        };
+    } | number;
+    attached_spells?: {
+        charges?: Record<string, string[]>;
+        daily?: Record<string, string[]>;
+        will?: string[];
+        rest?: Record<string, string[]>;
+        /** Total uses with no recharge — item often consumed when empty. */
+        limited?: Record<string, string[]>;
+    };
+    attunement?: {
+        required: boolean;
+        restriction?: string;
+        tags?: AttunementTag[];
+    } | boolean | string;
+    grants?: {
+        proficiency?: boolean;
+        languages?: boolean | string[];
+        senses?: {
+            darkvision?: number;
+            tremorsense?: number;
+            truesight?: number;
+            blindsight?: number;
+        };
+    };
+    container?: {
+        capacity_weight?: number;
+        weightless?: boolean;
+        pack_contents?: string[];
+    };
+    light?: {
+        bright_radius: number;
+        dim_radius: number;
+    };
+    cursed?: boolean;
+    sentient?: boolean;
+    focus?: boolean | "arcane" | "druid" | "holy";
+    tier?: "major" | "minor";
+    damage?: WeaponEntity["damage"] | string;
+    weapon_category?: WeaponCategory;
+    armor_category?: ArmorCategory;
+    weight?: number | string;
+    cost?: string;
+    source?: string;
+    page?: number;
+    edition?: "2014" | "2024" | string;
+    description?: string;
+    entries?: unknown[];
+    effects?: unknown[];
+    raw?: Record<string, unknown>;
+    damage_dice?: string;
+    damage_type?: string;
+    properties?: string[];
+    recharge?: string;
+    curse?: boolean;
+    value?: number;
+}
+export type Item = ItemEntity;