@archivist-gg/dnd5e 0.1.0

package/dist/chunk-QQ5W2AZP.js

@@ -0,0 +1,515 @@
+import {
+  defaultSlotForType,
+  effectiveArmor,
+  isItemEntity,
+  isWeaponEntity,
+  resolveEntityForEntry
+} from "./chunk-UC4FE5X3.js";
+import {
+  readNumericBonus
+} from "./chunk-LWFTHJIE.js";
+import {
+  resolveBaseItem
+} from "./chunk-DC74TZNA.js";
+
+// src/pc/pc.equipment.ts
+var ABILITY_KEYS = ["str", "dex", "con", "int", "wis", "cha"];
+function isAbilityKey(k) {
+  return ABILITY_KEYS.includes(k);
+}
+function emptyAppliedBonuses() {
+  return {
+    ability_bonuses: {},
+    ability_statics: {},
+    save_bonus: 0,
+    speed_bonuses: { walk: 0, fly: null, swim: 0, climb: 0 },
+    spell_attack: 0,
+    spell_save_dc: 0,
+    defenses: { resistances: [], immunities: [], vulnerabilities: [], condition_immunities: [] },
+    informational: [],
+    senses: { darkvision: 0, blindsight: 0, tremorsense: 0, truesight: 0 }
+  };
+}
+function unwrapSlug(item) {
+  const m = item.match(/^\[\[(.+)\]\]$/);
+  return m ? m[1] : null;
+}
+function isAttunedActive(entry, entity) {
+  if (!entry.equipped) return false;
+  const requires = isItemEntity(entity) && entity.attunement && typeof entity.attunement === "object" && "required" in entity.attunement && entity.attunement.required === true;
+  if (!requires) return true;
+  return entry.attuned === true;
+}
+function unwrapClassSlug(maybeWiki) {
+  if (!maybeWiki) return "";
+  const m = /^\[\[([^\]]+)\]\]$/.exec(maybeWiki);
+  return (m ? m[1] : maybeWiki).toLowerCase();
+}
+function buildConditionContext(resolved, equippedSlots) {
+  var _a, _b;
+  return {
+    derived: { equippedSlots },
+    classList: (_a = resolved.definition.class) != null ? _a : [],
+    race: resolved.definition.race,
+    subclasses: ((_b = resolved.definition.class) != null ? _b : []).map((c) => c.subclass).filter((s) => typeof s === "string" && s.length > 0).map(unwrapClassSlug)
+  };
+}
+function pushApply(outcome, field, source, pool, onApply) {
+  if (!outcome) return;
+  if (outcome.kind === "applied") onApply(outcome.value);
+  else if (outcome.kind === "informational") {
+    pool.push({ field, source, value: outcome.value, conditions: outcome.conditions });
+  }
+}
+function computeAppliedBonuses(resolved, _profs, registry, warnings) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  const out = emptyAppliedBonuses();
+  const equipment = (_a = resolved.definition.equipment) != null ? _a : [];
+  const ctx = buildConditionContext(resolved, {});
+  for (const entry of equipment) {
+    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+    if (!entity) {
+      const slug = unwrapSlug(entry.item);
+      if (slug && entry.equipped) warnings.push(`Equipped item [[${slug}]] not found in compendium.`);
+      continue;
+    }
+    if (!isAttunedActive(entry, entity)) continue;
+    if (entityType !== "item") continue;
+    const item = entity;
+    (_b = item.resist) == null ? void 0 : _b.forEach((s) => out.defenses.resistances.push(s));
+    (_c = item.immune) == null ? void 0 : _c.forEach((s) => out.defenses.immunities.push(s));
+    (_d = item.vulnerable) == null ? void 0 : _d.forEach((s) => out.defenses.vulnerabilities.push(s));
+    (_e = item.condition_immune) == null ? void 0 : _e.forEach((s) => out.defenses.condition_immunities.push(s));
+    (_g = (_f = entry.overrides) == null ? void 0 : _f.resist) == null ? void 0 : _g.forEach((s) => out.defenses.resistances.push(s));
+    (_i = (_h = entry.overrides) == null ? void 0 : _h.immune) == null ? void 0 : _i.forEach((s) => out.defenses.immunities.push(s));
+    (_k = (_j = entry.overrides) == null ? void 0 : _j.vulnerable) == null ? void 0 : _k.forEach((s) => out.defenses.vulnerabilities.push(s));
+    (_m = (_l = entry.overrides) == null ? void 0 : _l.condition_immune) == null ? void 0 : _m.forEach((s) => out.defenses.condition_immunities.push(s));
+    const gs = (_n = item.grants) == null ? void 0 : _n.senses;
+    if (gs) {
+      if (typeof gs.darkvision === "number") out.senses.darkvision = Math.max(out.senses.darkvision, gs.darkvision);
+      if (typeof gs.blindsight === "number") out.senses.blindsight = Math.max(out.senses.blindsight, gs.blindsight);
+      if (typeof gs.tremorsense === "number") out.senses.tremorsense = Math.max(out.senses.tremorsense, gs.tremorsense);
+      if (typeof gs.truesight === "number") out.senses.truesight = Math.max(out.senses.truesight, gs.truesight);
+    }
+    const b = item.bonuses;
+    if (!b) continue;
+    pushApply(
+      readNumericBonus(b.saving_throws, ctx),
+      "saving_throws",
+      item.name,
+      out.informational,
+      (v) => {
+        out.save_bonus += v;
+      }
+    );
+    pushApply(
+      readNumericBonus(b.spell_attack, ctx),
+      "spell_attack",
+      item.name,
+      out.informational,
+      (v) => {
+        out.spell_attack += v;
+      }
+    );
+    pushApply(
+      readNumericBonus(b.spell_save_dc, ctx),
+      "spell_save_dc",
+      item.name,
+      out.informational,
+      (v) => {
+        out.spell_save_dc += v;
+      }
+    );
+    if ((_o = b.ability_scores) == null ? void 0 : _o.bonus) {
+      for (const [k, v] of Object.entries(b.ability_scores.bonus)) {
+        if (!isAbilityKey(k)) continue;
+        pushApply(
+          readNumericBonus(v, ctx),
+          `ability_scores.bonus.${k}`,
+          item.name,
+          out.informational,
+          (val) => {
+            var _a2;
+            out.ability_bonuses[k] = ((_a2 = out.ability_bonuses[k]) != null ? _a2 : 0) + val;
+          }
+        );
+      }
+    }
+    if ((_p = b.ability_scores) == null ? void 0 : _p.static) {
+      for (const [k, n] of Object.entries(b.ability_scores.static)) {
+        if (!isAbilityKey(k) || typeof n !== "number") continue;
+        const prev = out.ability_statics[k];
+        if (prev === void 0) {
+          out.ability_statics[k] = n;
+        } else {
+          if (n !== prev) {
+            warnings.push(
+              `Multiple static ${k.toUpperCase()} bonuses on equipped+attuned items; using highest (${Math.max(prev, n)}).`
+            );
+          }
+          out.ability_statics[k] = Math.max(prev, n);
+        }
+      }
+    }
+    if (b.speed) {
+      pushApply(
+        readNumericBonus(b.speed.walk, ctx),
+        "speed.walk",
+        item.name,
+        out.informational,
+        (v) => {
+          out.speed_bonuses.walk += v;
+        }
+      );
+      if (b.speed.fly === "walk") {
+        out.speed_bonuses.fly = "walk";
+      } else {
+        pushApply(
+          readNumericBonus(b.speed.fly, ctx),
+          "speed.fly",
+          item.name,
+          out.informational,
+          (v) => {
+            const cur = out.speed_bonuses.fly;
+            out.speed_bonuses.fly = (typeof cur === "number" ? cur : 0) + v;
+          }
+        );
+      }
+      pushApply(
+        readNumericBonus(b.speed.swim, ctx),
+        "speed.swim",
+        item.name,
+        out.informational,
+        (v) => {
+          out.speed_bonuses.swim += v;
+        }
+      );
+      pushApply(
+        readNumericBonus(b.speed.climb, ctx),
+        "speed.climb",
+        item.name,
+        out.informational,
+        (v) => {
+          out.speed_bonuses.climb += v;
+        }
+      );
+    }
+  }
+  return out;
+}
+function isTwoHanded(weapon) {
+  return weapon.properties.some((p) => p === "two_handed");
+}
+function assignSlots(resolved, registry, warnings) {
+  var _a, _b;
+  const slots = {};
+  const eq = (_a = resolved.definition.equipment) != null ? _a : [];
+  for (let i = 0; i < eq.length; i++) {
+    const entry = eq[i];
+    if (!entry.equipped || !entry.slot) continue;
+    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+    if (slots[entry.slot]) {
+      warnings.push(`${entry.slot} slot conflict: ${entry.item} ignored (already taken).`);
+      continue;
+    }
+    const placed = { index: i, entity, entityType, entry };
+    slots[entry.slot] = placed;
+  }
+  for (let i = 0; i < eq.length; i++) {
+    const entry = eq[i];
+    if (!entry.equipped || entry.slot) continue;
+    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+    if (!entity || !entityType) continue;
+    const defaultSlot = defaultSlotForType(entityType, entity, registry);
+    if (!defaultSlot) continue;
+    const placed = { index: i, entity, entityType, entry };
+    if (defaultSlot === "mainhand") {
+      if (!slots.mainhand) slots.mainhand = placed;
+      else if (!slots.offhand) slots.offhand = placed;
+      else warnings.push(`No free hand for ${entry.item}; entry remains equipped without slot.`);
+    } else {
+      if (slots[defaultSlot]) {
+        warnings.push(`${defaultSlot} slot already filled; ${entry.item} ignored.`);
+      } else {
+        slots[defaultSlot] = placed;
+      }
+    }
+  }
+  const main = (_b = slots.mainhand) == null ? void 0 : _b.entity;
+  if (main && isWeaponEntity(main) && isTwoHanded(main) && slots.shield) {
+    warnings.push(`Two-handed weapon equipped; shield ignored.`);
+  }
+  return slots;
+}
+function computeAC(equippedSlots, resolved, mods, registry) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const breakdown = [];
+  const armorSlot = equippedSlots.armor;
+  const armorEntity = (_a = armorSlot == null ? void 0 : armorSlot.entity) != null ? _a : null;
+  const armor = effectiveArmor(armorEntity, registry);
+  let ac = 10;
+  if (armor) {
+    const armorBase = armor.ac.base + ((_b = armor.ac.flat) != null ? _b : 0);
+    ac = armorBase;
+    breakdown.push({ source: (_c = armorEntity == null ? void 0 : armorEntity.name) != null ? _c : armor.name, amount: armorBase, kind: "armor" });
+    if (armor.ac.add_dex) {
+      const dexCap = (_d = armor.ac.dex_max) != null ? _d : Number.POSITIVE_INFINITY;
+      const dexAdd = Math.min(mods.dex, dexCap);
+      ac += dexAdd;
+      const capped = mods.dex > dexCap;
+      breakdown.push({ source: `DEX modifier${capped ? " (capped)" : ""}`, amount: dexAdd, kind: "dex" });
+    }
+  } else {
+    ac = 10 + mods.dex;
+    breakdown.push({ source: "Base", amount: 10, kind: "unarmored" });
+    breakdown.push({ source: "DEX modifier", amount: mods.dex, kind: "dex" });
+  }
+  const acBonus = (_e = armorSlot == null ? void 0 : armorSlot.entry.overrides) == null ? void 0 : _e.ac_bonus;
+  if (typeof acBonus === "number" && acBonus !== 0) {
+    ac += acBonus;
+    breakdown.push({ source: `${(_f = armorEntity == null ? void 0 : armorEntity.name) != null ? _f : "Armor"} (override)`, amount: acBonus, kind: "override" });
+  }
+  const main = (_g = equippedSlots.mainhand) == null ? void 0 : _g.entity;
+  const mainIsTwoHanded = main && isWeaponEntity(main) && isTwoHanded(main);
+  const shieldEntity = (_i = (_h = equippedSlots.shield) == null ? void 0 : _h.entity) != null ? _i : null;
+  const shield = effectiveArmor(shieldEntity, registry);
+  if (shield && !mainIsTwoHanded) {
+    const n = shield.ac.base + ((_j = shield.ac.flat) != null ? _j : 0);
+    ac += n;
+    breakdown.push({ source: (_k = shieldEntity == null ? void 0 : shieldEntity.name) != null ? _k : shield.name, amount: n, kind: "shield" });
+  }
+  const acInformational = [];
+  const acCtx = buildConditionContext(resolved, equippedSlots);
+  for (const entry of (_l = resolved.definition.equipment) != null ? _l : []) {
+    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+    if (!entity || entityType !== "item") continue;
+    if (!isAttunedActive(entry, entity)) continue;
+    const item = entity;
+    const out = readNumericBonus((_m = item.bonuses) == null ? void 0 : _m.ac, acCtx);
+    if (!out) continue;
+    if (out.kind === "applied") {
+      ac += out.value;
+      breakdown.push({ source: item.name, amount: out.value, kind: "item" });
+    } else if (out.kind === "informational") {
+      acInformational.push({
+        field: "ac",
+        source: item.name,
+        value: out.value,
+        conditions: out.conditions
+      });
+    }
+  }
+  return { ac, breakdown, informational: acInformational };
+}
+function hasProperty(weapon, prop) {
+  return weapon.properties.some((p) => p === prop);
+}
+function attackAbility(weapon, mods, override) {
+  const isRanged = /ranged/.test(weapon.category);
+  if (override && !isRanged) return override;
+  if (isRanged) return "dex";
+  if (hasProperty(weapon, "finesse")) return mods.dex >= mods.str ? "dex" : "str";
+  return "str";
+}
+function isWeaponSlugProficient(weapon, weaponSlug, profs) {
+  const wp = profs.weapons;
+  if (wp.specific.includes(weaponSlug)) return true;
+  const cat = weapon.category;
+  if (typeof cat === "string") {
+    if (/^simple\b/.test(cat) && wp.categories.includes("simple")) return true;
+    if (/^martial\b/.test(cat) && wp.categories.includes("martial")) return true;
+    if (wp.categories.includes(cat)) return true;
+  }
+  return false;
+}
+function magicBonusesForWeaponEntry(entry, registry, ctx) {
+  var _a;
+  const { entity } = resolveEntityForEntry(entry.item, registry);
+  const ovr = (_a = entry.overrides) != null ? _a : {};
+  const entryAttack = typeof ovr.bonus === "number" ? ovr.bonus : 0;
+  const entryDamage = typeof ovr.damage_bonus === "number" ? ovr.damage_bonus : 0;
+  const extra = typeof ovr.extra_damage === "string" ? ovr.extra_damage : void 0;
+  let itemAttack = 0;
+  let itemDamage = 0;
+  let sourceName;
+  let itemName;
+  let damageTypeOverride;
+  let propertiesOverride;
+  const informational = [];
+  if (entity && isItemEntity(entity)) {
+    sourceName = entity.name;
+    itemName = entity.name;
+    damageTypeOverride = typeof entity.damage_type === "string" && entity.damage_type.length > 0 ? entity.damage_type : void 0;
+    propertiesOverride = Array.isArray(entity.properties) && entity.properties.length > 0 ? entity.properties : void 0;
+    const b = entity.bonuses;
+    const atkOut = readNumericBonus(b == null ? void 0 : b.weapon_attack, ctx);
+    const dmgOut = readNumericBonus(b == null ? void 0 : b.weapon_damage, ctx);
+    if ((atkOut == null ? void 0 : atkOut.kind) === "applied") itemAttack = atkOut.value;
+    else if ((atkOut == null ? void 0 : atkOut.kind) === "informational")
+      informational.push({ field: "weapon_attack", source: entity.name, value: atkOut.value, conditions: atkOut.conditions });
+    if ((dmgOut == null ? void 0 : dmgOut.kind) === "applied") itemDamage = dmgOut.value;
+    else if ((dmgOut == null ? void 0 : dmgOut.kind) === "informational")
+      informational.push({ field: "weapon_damage", source: entity.name, value: dmgOut.value, conditions: dmgOut.conditions });
+  }
+  return {
+    atk: itemAttack + entryAttack,
+    dmg: itemDamage + entryDamage,
+    extra,
+    sourceName,
+    itemName,
+    damageTypeOverride,
+    propertiesOverride,
+    informational
+  };
+}
+function buildAttackRow(args) {
+  var _a, _b;
+  const { id, name, weapon, baseDice, ability, mods, proficient, proficiencyBonus, magic } = args;
+  const abilityMod = mods[ability];
+  const pb = proficient ? proficiencyBonus : 0;
+  const toHit = abilityMod + pb + magic.atk;
+  const dmgFlat = abilityMod + magic.dmg;
+  const formatDice = (dice) => `${dice}${dmgFlat >= 0 ? "+" : ""}${dmgFlat}`.replace(/\+0$/, "");
+  const damageDice = formatDice(baseDice);
+  const magicSource = magic.sourceName ? `${magic.sourceName} bonus` : "Magic weapon";
+  const toHitBreakdown = [
+    { source: `${ability.toUpperCase()} modifier`, amount: abilityMod, kind: "ability" },
+    { source: "Proficiency bonus", amount: proficient ? proficiencyBonus : 0, kind: "ability" },
+    { source: magicSource, amount: magic.atk, kind: "item" }
+  ];
+  const damageBreakdown = [
+    { source: "Base damage", amount: 0, kind: "ability" },
+    { source: `${ability.toUpperCase()} modifier`, amount: abilityMod, kind: "ability" },
+    { source: magicSource, amount: magic.dmg, kind: "item" }
+  ];
+  const isRanged = /ranged/.test(weapon.category);
+  const range = isRanged && weapon.range ? `${weapon.range.normal}/${weapon.range.long}` : "melee";
+  const stringProps = weapon.properties.filter(
+    (p) => typeof p === "string"
+  );
+  const finalProps = (_a = magic.propertiesOverride) != null ? _a : stringProps;
+  return {
+    id,
+    name,
+    range,
+    toHit,
+    damageDice,
+    damageType: (_b = magic.damageTypeOverride) != null ? _b : weapon.damage.type,
+    extraDamage: magic.extra,
+    properties: finalProps,
+    proficient,
+    breakdown: { toHit: toHitBreakdown, damage: damageBreakdown },
+    informational: args.magic.informational.length > 0 ? args.magic.informational : void 0,
+    slotKey: args.slotKey,
+    subLabel: formatWeaponSubLabel(weapon, finalProps),
+    actionCost: args.actionCost,
+    versatile: args.versatileDice ? { damageDice: formatDice(args.versatileDice) } : void 0
+  };
+}
+function formatWeaponSubLabel(weapon, properties) {
+  const parts = [];
+  if (weapon.category) parts.push(weapon.category);
+  if (properties.length > 0) parts.push(properties.join(", "));
+  return parts.join(" \xB7 ");
+}
+function computeAttacks(equippedSlots, mods, profs, registry, warnings, proficiencyBonus, ctx, weaponAbilityOverride) {
+  var _a, _b, _c, _d, _e;
+  const rows = [];
+  const handedSlots = [
+    { key: "mainhand", placed: equippedSlots.mainhand },
+    { key: "offhand", placed: equippedSlots.offhand }
+  ];
+  for (const { key, placed } of handedSlots) {
+    if (!placed) continue;
+    const { entity, entry } = placed;
+    if (!entity) continue;
+    let weapon = null;
+    if (isWeaponEntity(entity)) {
+      weapon = entity;
+    } else if (isItemEntity(entity) && typeof entity.base_item === "string") {
+      const baseSlug = entity.base_item;
+      const found = resolveBaseItem(baseSlug, registry);
+      if (found && found.entityType === "weapon" && isWeaponEntity(found.data)) {
+        weapon = found.data;
+      } else {
+        warnings.push(`Magic weapon ${entity.name} references missing base_item [[${baseSlug}]].`);
+        continue;
+      }
+    } else {
+      continue;
+    }
+    const slugFromEntry = (_a = unwrapSlug(entry.item)) != null ? _a : weapon.slug;
+    const proficient = isWeaponSlugProficient(weapon, slugFromEntry, profs) || isWeaponSlugProficient(weapon, weapon.slug, profs);
+    if (!proficient) {
+      warnings.push(`Character not proficient with ${weapon.name}; proficiency bonus excluded.`);
+    }
+    const ability = attackAbility(weapon, mods, weaponAbilityOverride);
+    const magic = magicBonusesForWeaponEntry(entry, registry, ctx);
+    const ovr = (_b = entry.overrides) != null ? _b : {};
+    const displayName = (_d = (_c = ovr.name) != null ? _c : magic.itemName) != null ? _d : weapon.name;
+    const versatileDice = key === "mainhand" && hasProperty(weapon, "versatile") && typeof weapon.damage.versatile_dice === "string" && !equippedSlots.offhand ? weapon.damage.versatile_dice : void 0;
+    const baseRow = buildAttackRow({
+      id: `${placed.index}:standard`,
+      name: displayName,
+      weapon,
+      baseDice: weapon.damage.dice,
+      ability,
+      mods,
+      proficient,
+      proficiencyBonus,
+      magic,
+      slotKey: key,
+      actionCost: (_e = ovr.action) != null ? _e : "action",
+      versatileDice
+    });
+    rows.push(baseRow);
+  }
+  return rows;
+}
+function coerceWeight(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) return raw;
+  if (typeof raw === "string") {
+    const n = Number.parseFloat(raw);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return 0;
+}
+function computeCarriedWeight(resolved, registry) {
+  var _a;
+  let total = 0;
+  for (const entry of (_a = resolved.definition.equipment) != null ? _a : []) {
+    const found = resolveBaseItem(entry.item, registry);
+    if (!found) continue;
+    const entity = found.data;
+    const w = coerceWeight(entity.weight);
+    if (w === 0) continue;
+    const qty = typeof entry.qty === "number" && entry.qty >= 0 ? entry.qty : 1;
+    total += w * qty;
+  }
+  return total;
+}
+function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, proficiencyBonus, weaponAbilityOverride) {
+  var _a, _b, _c;
+  const equippedSlots = assignSlots(resolved, registry, warnings);
+  const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
+  const acOut = computeAC(equippedSlots, resolved, mods, registry);
+  const ctx = buildConditionContext(resolved, equippedSlots);
+  const attacks = computeAttacks(equippedSlots, mods, profs, registry, warnings, proficiencyBonus, ctx, weaponAbilityOverride);
+  return {
+    ac: acOut.ac,
+    acBreakdown: acOut.breakdown,
+    acInformational: acOut.informational,
+    attacks,
+    equippedSlots,
+    carriedWeight: computeCarriedWeight(resolved, registry),
+    // Attunement is persistent: an attuned item still occupies a slot even when unequipped (SRD).
+    attunementUsed: ((_b = resolved.definition.equipment) != null ? _b : []).filter((e) => e.attuned).length,
+    attunementLimit: (_c = overrides.attunement_limit) != null ? _c : 3
+  };
+}
+
+export {
+  emptyAppliedBonuses,
+  computeAppliedBonuses,
+  computeSlotsAndAttacks
+};

package/dist/chunk-QS5L5YTJ.js

@@ -0,0 +1,24 @@
+// src/item/item.ai-schema.ts
+import { z } from "zod";
+var itemInputSchema = z.object({
+  name: z.string().describe("Item name"),
+  type: z.enum(["weapon", "armor", "potion", "ring", "rod", "scroll", "staff", "wand", "wondrous item", "shield"]),
+  rarity: z.enum(["common", "uncommon", "rare", "very rare", "legendary", "artifact"]),
+  entries: z.array(z.string()).optional().describe(
+    "Item description and properties. Use inline formula tags for attack rolls, damage, and save DCs: `atk:ABILITY` for attack bonus, `damage:DICE+ABILITY` for damage (e.g. `damage:2d6`), `dc:ABILITY` for save DCs. Valid abilities: STR, DEX, CON, INT, WIS, CHA."
+  ),
+  weight: z.number().optional(),
+  value: z.number().optional(),
+  attunement: z.union([z.boolean(), z.string()]).optional(),
+  properties: z.array(z.string()).optional(),
+  damage: z.string().optional(),
+  damage_type: z.string().optional(),
+  ac: z.number().optional(),
+  charges: z.number().optional(),
+  recharge: z.string().optional(),
+  curse: z.boolean().optional()
+});
+
+export {
+  itemInputSchema
+};

package/dist/chunk-QYZV2MQA.js

@@ -0,0 +1,97 @@
+// src/dnd/tag-grammar.ts
+var TAG_TYPE_ALIASES = {
+  atk: "atk",
+  attack: "atk",
+  dmg: "dmg",
+  damage: "dmg",
+  dc: "dc",
+  dice: "dice"
+};
+function normalizeTagType(input) {
+  var _a;
+  const lower = input.toLowerCase().trim();
+  return (_a = TAG_TYPE_ALIASES[lower]) != null ? _a : null;
+}
+var ABILITY_RE = /^(str|dex|con|int|wis|cha)$/i;
+var PB_RE = /^pb$/i;
+var DICE_RE = /^(\d+)d(\d+)$/;
+var LITERAL_RE = /^([+-]?\d+)$/;
+var SLUG_RE = /^\[\[([^[\]]+)\]\]$/;
+function parseTagTerms(content) {
+  const out = {
+    pbTerm: false,
+    literalTerms: [],
+    diceTerms: [],
+    slugTerms: []
+  };
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return { error: "empty content" };
+  const tokens = [];
+  let i = 0;
+  const advancePastTerm = (start) => {
+    let j = start;
+    while (j < trimmed.length && trimmed[j] !== "+" && trimmed[j] !== "-") {
+      if (trimmed[j] === "[" && trimmed[j + 1] === "[") {
+        const close = trimmed.indexOf("]]", j + 2);
+        if (close === -1) return trimmed.length;
+        j = close + 2;
+        continue;
+      }
+      j++;
+    }
+    return j;
+  };
+  while (i < trimmed.length) {
+    if (trimmed[i] === "+" || trimmed[i] === "-") {
+      const j = advancePastTerm(i + 1);
+      tokens.push(trimmed.slice(i, j));
+      i = j;
+    } else {
+      const j = advancePastTerm(i);
+      tokens.push(trimmed.slice(i, j));
+      i = j;
+    }
+  }
+  for (let raw of tokens) {
+    raw = raw.trim();
+    if (raw.length === 0) return { error: "empty term" };
+    let signed = raw;
+    let body = raw;
+    if (raw[0] === "+" || raw[0] === "-") {
+      body = raw.slice(1).trim();
+    } else {
+      signed = "+" + raw;
+    }
+    if (DICE_RE.test(body)) {
+      const m = body.match(DICE_RE);
+      out.diceTerms.push({ count: Number.parseInt(m[1], 10), sides: Number.parseInt(m[2], 10) });
+      continue;
+    }
+    if (ABILITY_RE.test(body)) {
+      if (out.abilityTerm) return { error: `multiple ability terms (${out.abilityTerm}, ${body.toLowerCase()})` };
+      out.abilityTerm = body.toLowerCase();
+      continue;
+    }
+    if (PB_RE.test(body)) {
+      if (out.pbTerm) return { error: "duplicate PB term" };
+      out.pbTerm = true;
+      continue;
+    }
+    const slugMatch = body.match(SLUG_RE);
+    if (slugMatch) {
+      out.slugTerms.push(slugMatch[1]);
+      continue;
+    }
+    if (LITERAL_RE.test(signed)) {
+      out.literalTerms.push(Number.parseInt(signed, 10));
+      continue;
+    }
+    return { error: `unrecognized term: ${raw}` };
+  }
+  return out;
+}
+
+export {
+  normalizeTagType,
+  parseTagTerms
+};