@archivist-gg/dnd5e 0.1.0

package/dist/chunk-4C2KOKLF.js

@@ -0,0 +1,185 @@
+// src/item/item.schema.ts
+import { z } from "zod";
+var tier1Conditions = [
+  z.object({ kind: z.literal("no_armor") }),
+  z.object({ kind: z.literal("no_shield") }),
+  z.object({ kind: z.literal("wielding_two_handed") }),
+  z.object({ kind: z.literal("is_class"), value: z.string() }),
+  z.object({ kind: z.literal("is_race"), value: z.string() }),
+  z.object({ kind: z.literal("is_subclass"), value: z.string() })
+];
+var tier2Conditions = [
+  z.object({ kind: z.literal("vs_creature_type"), value: z.string() }),
+  z.object({ kind: z.literal("vs_attack_type"), value: z.enum(["ranged", "melee"]) }),
+  z.object({ kind: z.literal("on_attack_type"), value: z.enum(["ranged", "melee"]) }),
+  z.object({ kind: z.literal("with_weapon_property"), value: z.string() }),
+  z.object({ kind: z.literal("vs_spell_save") })
+];
+var tier3Conditions = [
+  z.object({ kind: z.literal("lighting"), value: z.enum(["dim", "bright", "daylight", "darkness"]) }),
+  z.object({ kind: z.literal("underwater") }),
+  z.object({ kind: z.literal("movement_state"), value: z.enum(["flying", "swimming", "climbing", "mounted"]) })
+];
+var tier4Conditions = [
+  z.object({ kind: z.literal("has_condition"), value: z.string() }),
+  z.object({ kind: z.literal("is_concentrating") }),
+  z.object({ kind: z.literal("bloodied") })
+];
+var rawCondition = z.object({ kind: z.literal("raw"), text: z.string() });
+var conditionSchema = z.lazy(
+  () => z.discriminatedUnion("kind", [
+    ...tier1Conditions,
+    ...tier2Conditions,
+    ...tier3Conditions,
+    ...tier4Conditions,
+    rawCondition,
+    z.object({ kind: z.literal("any_of"), conditions: z.array(conditionSchema) })
+  ])
+);
+var conditionalBonusSchema = z.object({
+  value: z.number().int(),
+  when: z.array(conditionSchema)
+});
+var numberOrConditional = z.union([z.number().int(), conditionalBonusSchema]);
+var bonusesSchema = z.object({
+  ac: numberOrConditional.optional(),
+  weapon_attack: numberOrConditional.optional(),
+  weapon_damage: numberOrConditional.optional(),
+  spell_attack: numberOrConditional.optional(),
+  spell_save_dc: numberOrConditional.optional(),
+  saving_throws: numberOrConditional.optional(),
+  ability_scores: z.object({
+    // partial: each ability is independently optional. z.record(enum, …) in
+    // Zod v4 treats every enum key as required, which doesn't match the
+    // data (e.g. Amulet of Health only sets `con: 19`).
+    static: z.object({
+      str: z.number().int().optional(),
+      dex: z.number().int().optional(),
+      con: z.number().int().optional(),
+      int: z.number().int().optional(),
+      wis: z.number().int().optional(),
+      cha: z.number().int().optional()
+    }).optional(),
+    bonus: z.object({
+      str: numberOrConditional.optional(),
+      dex: numberOrConditional.optional(),
+      con: numberOrConditional.optional(),
+      int: numberOrConditional.optional(),
+      wis: numberOrConditional.optional(),
+      cha: numberOrConditional.optional()
+    }).optional()
+  }).optional(),
+  speed: z.object({
+    walk: numberOrConditional.optional(),
+    fly: z.union([numberOrConditional, z.literal("walk")]).optional(),
+    swim: numberOrConditional.optional(),
+    climb: numberOrConditional.optional()
+  }).optional()
+});
+var chargesSchema = z.object({
+  max: z.number().int(),
+  recharge: z.string().optional(),
+  recharge_amount: z.string().optional(),
+  destroy_on_empty: z.object({
+    roll: z.string(),
+    threshold: z.number().int(),
+    effect: z.string().optional()
+  }).optional()
+});
+var attachedSpellsSchema = z.object({
+  charges: z.record(z.string(), z.array(z.string())).optional(),
+  daily: z.record(z.string(), z.array(z.string())).optional(),
+  will: z.array(z.string()).optional(),
+  rest: z.record(z.string(), z.array(z.string())).optional(),
+  // `limited` = total uses with no recharge (item often consumed when empty).
+  // Distinct from `charges` (cost-per-cast) and `daily` (resets per day).
+  // Source canonical pipeline emits this for Necklace of Fireballs, Helm of
+  // Brilliance, Candle of Invocation, Efreeti Bottle. Key is total available
+  // uses (e.g. "9": ["fireball"] for the necklace's 9 beads).
+  limited: z.record(z.string(), z.array(z.string())).optional()
+});
+var attunementTagSchema = z.union([
+  z.object({ class: z.string(), subclass: z.string().optional() }),
+  // alignment can be a single string OR an array of alignment-letter codes
+  // (e.g. ["G"] for good, ["L", "G"] for lawful good).
+  z.object({ alignment: z.union([z.string(), z.array(z.string())]) }),
+  z.object({ race: z.string() }),
+  z.object({ creature_type: z.string() }),
+  z.object({ spellcasting: z.boolean() })
+]);
+var attunementCanonicalSchema = z.object({
+  required: z.boolean(),
+  restriction: z.string().optional(),
+  tags: z.array(attunementTagSchema).optional()
+});
+var grantsSchema = z.object({
+  proficiency: z.boolean().optional(),
+  languages: z.union([z.boolean(), z.array(z.string())]).optional(),
+  senses: z.object({
+    darkvision: z.number().optional(),
+    tremorsense: z.number().optional(),
+    truesight: z.number().optional(),
+    blindsight: z.number().optional()
+  }).optional()
+});
+var containerSchema = z.object({
+  capacity_weight: z.number().optional(),
+  weightless: z.boolean().optional(),
+  pack_contents: z.array(z.string()).optional()
+});
+var lightSchema = z.object({
+  bright_radius: z.number(),
+  dim_radius: z.number()
+});
+var itemEntitySchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().optional(),
+  type: z.string().optional(),
+  rarity: z.string().optional(),
+  base_item: z.string().optional(),
+  bonuses: bonusesSchema.optional(),
+  resist: z.array(z.string()).optional(),
+  immune: z.array(z.string()).optional(),
+  vulnerable: z.array(z.string()).optional(),
+  condition_immune: z.array(z.string()).optional(),
+  charges: z.union([chargesSchema, z.number().int().nonnegative()]).optional(),
+  attached_spells: attachedSpellsSchema.optional(),
+  attunement: z.union([attunementCanonicalSchema, z.boolean(), z.string()]).optional(),
+  grants: grantsSchema.optional(),
+  container: containerSchema.optional(),
+  light: lightSchema.optional(),
+  cursed: z.boolean().optional(),
+  sentient: z.boolean().optional(),
+  focus: z.union([z.boolean(), z.string()]).optional(),
+  tier: z.enum(["major", "minor"]).optional(),
+  damage: z.union([
+    z.object({
+      dice: z.string(),
+      type: z.string(),
+      versatile_dice: z.string().optional()
+    }),
+    z.string()
+  ]).optional(),
+  weapon_category: z.string().optional(),
+  armor_category: z.string().optional(),
+  weight: z.union([z.number(), z.string()]).optional(),
+  cost: z.string().optional(),
+  source: z.string().optional(),
+  page: z.number().int().optional(),
+  edition: z.string().optional(),
+  description: z.string().optional(),
+  entries: z.array(z.unknown()).optional(),
+  effects: z.array(z.unknown()).optional(),
+  raw: z.record(z.string(), z.unknown()).optional(),
+  // Legacy fields preserved
+  damage_dice: z.string().optional(),
+  damage_type: z.string().optional(),
+  properties: z.array(z.string()).optional(),
+  recharge: z.string().optional(),
+  curse: z.boolean().optional()
+});
+
+export {
+  conditionSchema,
+  itemEntitySchema
+};

package/dist/chunk-4F6AIZ36.js

@@ -0,0 +1,19 @@
+import {
+  optionalFeatureEntitySchema
+} from "./chunk-MDEJHMKK.js";
+
+// src/optional-feature/optional-feature.parser.ts
+import { parseYaml } from "@archivist-gg/core";
+function parseOptionalFeature(source) {
+  const raw = parseYaml(source, ["name", "slug", "feature_type"]);
+  if (!raw.success) return raw;
+  const result = optionalFeatureEntitySchema.safeParse({ edition: "2014", ...raw.data });
+  if (!result.success) {
+    return { success: false, error: `optional-feature schema validation failed: ${result.error.message}` };
+  }
+  return { success: true, data: result.data };
+}
+
+export {
+  parseOptionalFeature
+};

package/dist/chunk-4SSDYJS2.js

@@ -0,0 +1,86 @@
+import {
+  itemEntitySchema
+} from "./chunk-4C2KOKLF.js";
+
+// src/item/item.parser.ts
+import { parseYaml } from "@archivist-gg/core";
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "slug",
+  "type",
+  "rarity",
+  "base_item",
+  "bonuses",
+  "resist",
+  "immune",
+  "vulnerable",
+  "condition_immune",
+  "charges",
+  "attached_spells",
+  "attunement",
+  "grants",
+  "container",
+  "light",
+  "cursed",
+  "sentient",
+  "focus",
+  "tier",
+  "damage",
+  "weapon_category",
+  "armor_category",
+  "weight",
+  "cost",
+  "source",
+  "page",
+  "edition",
+  "description",
+  "entries",
+  "effects",
+  "raw",
+  // Legacy fields kept (removed in Slice 7 after grep verifies no consumer)
+  "damage_dice",
+  "damage_type",
+  "properties",
+  "recharge",
+  "curse"
+]);
+function migrateAttunement(raw) {
+  const legacy = raw.requires_attunement;
+  if (raw.attunement === void 0 && typeof legacy === "boolean") {
+    raw.attunement = { required: legacy };
+  }
+  if (legacy !== void 0) {
+    delete raw.requires_attunement;
+  }
+  const v = raw.attunement;
+  if (v === void 0 || v === null) return;
+  if (typeof v === "object" && !Array.isArray(v)) return;
+  if (typeof v === "boolean") {
+    raw.attunement = { required: v };
+  } else if (typeof v === "string") {
+    raw.attunement = { required: true, restriction: v };
+  }
+}
+function parseItem(source) {
+  var _a;
+  const raw = parseYaml(source, ["name"]);
+  if (!raw.success) return raw;
+  migrateAttunement(raw.data);
+  const result = itemEntitySchema.safeParse(raw.data);
+  if (!result.success) {
+    return { success: false, error: `item schema validation failed: ${result.error.message}` };
+  }
+  const entity = result.data;
+  const extras = {};
+  for (const [k, v] of Object.entries(raw.data)) {
+    if (!KNOWN_KEYS.has(k)) extras[k] = v;
+  }
+  if (Object.keys(extras).length > 0) {
+    entity.raw = { ...(_a = entity.raw) != null ? _a : {}, ...extras };
+  }
+  return { success: true, data: entity };
+}
+
+export {
+  parseItem
+};

package/dist/chunk-4TIJKN6O.js

@@ -0,0 +1,37 @@
+// src/schemas/selection-pool-schema.ts
+import { z } from "zod";
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var selectionPoolSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  source: z.object({
+    entity_type: z.literal("optional-feature"),
+    where: z.object({
+      feature_type: z.string().min(1),
+      available_to: z.literal("self")
+    })
+  }),
+  count: z.object({ column: z.string().min(1) }),
+  replaceable: z.boolean().optional()
+});
+var poolGrantSchema = z.object({
+  pool: z.string().min(1),
+  grants: z.array(z.object({
+    feature: z.string().regex(wikilinkRegex),
+    at_level: z.number().int().positive()
+  }))
+});
+var tabDeclSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  renders: z.object({
+    pool: z.string().min(1),
+    layout: z.enum(["spell-like", "blocks"]).optional()
+  })
+});
+
+export {
+  selectionPoolSchema,
+  poolGrantSchema,
+  tabDeclSchema
+};

package/dist/chunk-537BHVSH.js

@@ -0,0 +1,18 @@
+import {
+  parseItem
+} from "./chunk-4SSDYJS2.js";
+
+// src/item/item.codec.ts
+import yaml from "js-yaml";
+var itemCodec = {
+  parse(doc) {
+    return parseItem(doc.body);
+  },
+  serialize(item) {
+    return yaml.dump(item, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  itemCodec
+};

package/dist/chunk-5INR4NSL.js

@@ -0,0 +1,18 @@
+import {
+  parseWeapon
+} from "./chunk-6NK2MUD3.js";
+
+// src/weapon/weapon.codec.ts
+import yaml from "js-yaml";
+var weaponCodec = {
+  parse(doc) {
+    return parseWeapon(doc.body);
+  },
+  serialize(entity) {
+    return yaml.dump(entity, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  weaponCodec
+};

package/dist/chunk-5XUXXAQJ.js

@@ -0,0 +1,30 @@
+// src/pc/pc.table-column.ts
+function readTableColumn(table, level, keys) {
+  var _a;
+  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
+  if (!cols) return null;
+  for (const k of keys) {
+    const raw = cols[k];
+    if (raw === void 0 || raw === null) continue;
+    const n = typeof raw === "number" ? raw : parseInt(String(raw), 10);
+    if (!Number.isNaN(n)) return n;
+  }
+  return null;
+}
+function numericColumnsAt(table, level) {
+  var _a;
+  const out = {};
+  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
+  if (!cols) return out;
+  for (const [k, raw] of Object.entries(cols)) {
+    if (raw === void 0 || raw === null) continue;
+    const n = typeof raw === "number" ? raw : parseInt(String(raw), 10);
+    if (!Number.isNaN(n)) out[k] = n;
+  }
+  return out;
+}
+
+export {
+  readTableColumn,
+  numericColumnsAt
+};

package/dist/chunk-656QCX4U.js

@@ -0,0 +1,22 @@
+// src/spell/spell.ai-schema.ts
+import { z } from "zod";
+var spellInputSchema = z.object({
+  name: z.string().describe("Spell name"),
+  level: z.number().min(0).max(9).describe("Spell level (0 for cantrips)"),
+  school: z.enum(["abjuration", "conjuration", "divination", "enchantment", "evocation", "illusion", "necromancy", "transmutation"]),
+  casting_time: z.string().describe('e.g., "1 action", "1 bonus action"'),
+  range: z.string().describe('e.g., "Touch", "120 feet", "Self"'),
+  components: z.string().describe('e.g., "V, S", "V, S, M (diamond worth 100 gp)"'),
+  duration: z.string().describe('e.g., "Instantaneous", "Concentration, up to 1 minute"'),
+  description: z.array(z.string()).describe(
+    "Spell description paragraphs. Use inline formula tags for damage and save DCs: `damage:DICE` for damage rolls (e.g. `damage:8d6`), `dc:ABILITY` for save DCs (e.g. `dc:WIS`). Valid abilities: STR, DEX, CON, INT, WIS, CHA."
+  ),
+  at_higher_levels: z.array(z.string()).optional(),
+  classes: z.array(z.string()).optional(),
+  ritual: z.boolean().optional(),
+  concentration: z.boolean().optional()
+});
+
+export {
+  spellInputSchema
+};

package/dist/chunk-66XXW2Z2.js

@@ -0,0 +1,133 @@
+import {
+  convertDescToTags,
+  detectSpellcastingAbility
+} from "./chunk-RAWJTA45.js";
+import {
+  abilityModifier
+} from "./chunk-NAEPSZAM.js";
+
+// src/monster/monster.enrichment.ts
+import { toStringSafe } from "@archivist-gg/core";
+var CR_TO_XP = {
+  "0": 10,
+  "1/8": 25,
+  "1/4": 50,
+  "1/2": 100,
+  "1": 200,
+  "2": 450,
+  "3": 700,
+  "4": 1100,
+  "5": 1800,
+  "6": 2300,
+  "7": 2900,
+  "8": 3900,
+  "9": 5e3,
+  "10": 5900,
+  "11": 7200,
+  "12": 8400,
+  "13": 1e4,
+  "14": 11500,
+  "15": 13e3,
+  "16": 15e3,
+  "17": 18e3,
+  "18": 2e4,
+  "19": 22e3,
+  "20": 25e3,
+  "21": 33e3,
+  "22": 41e3,
+  "23": 5e4,
+  "24": 62e3,
+  "25": 75e3,
+  "26": 9e4,
+  "27": 105e3,
+  "28": 12e4,
+  "29": 135e3,
+  "30": 155e3
+};
+function parseCR(cr) {
+  if (!cr) return 0;
+  if (cr.includes("/")) {
+    const [num, denom] = cr.split("/").map(Number);
+    return num / denom;
+  }
+  return Number(cr) || 0;
+}
+function getChallengeRatingXP(cr) {
+  var _a;
+  return (_a = CR_TO_XP[cr]) != null ? _a : 0;
+}
+function getProficiencyBonus(cr) {
+  const v = parseCR(cr);
+  if (v < 5) return 2;
+  if (v < 9) return 3;
+  if (v < 13) return 4;
+  if (v < 17) return 5;
+  if (v < 21) return 6;
+  if (v < 25) return 7;
+  if (v < 29) return 8;
+  return 9;
+}
+function enrichMonster(raw) {
+  var _a, _b, _c;
+  const cr = toStringSafe((_a = raw.cr) != null ? _a : "0");
+  const abilities = raw.abilities;
+  const wisdomMod = abilities ? abilityModifier(abilities.wis) : 0;
+  const passivePerception = (_b = raw.passive_perception) != null ? _b : 10 + wisdomMod;
+  const languages = ((_c = raw.languages) == null ? void 0 : _c.length) ? raw.languages : ["---"];
+  const enriched = {
+    ...raw,
+    cr,
+    xp: getChallengeRatingXP(cr),
+    proficiency_bonus: getProficiencyBonus(cr),
+    passive_perception: passivePerception,
+    languages
+  };
+  convertMonsterEntries(enriched, cr);
+  return enriched;
+}
+var MONSTER_SECTIONS = [
+  ["traits", "trait"],
+  ["actions", "action"],
+  ["reactions", "reaction"],
+  ["legendary_actions", "legendary"]
+];
+function convertMonsterEntries(monster, cr) {
+  var _a;
+  const abilities = monster.abilities;
+  if (!abilities) return;
+  const profBonus = getProficiencyBonus(cr);
+  const spellAbility = detectSpellcastingAbility(
+    ((_a = monster.traits) != null ? _a : []).map((f) => {
+      var _a2;
+      return { name: f.name, entries: (_a2 = f.entries) != null ? _a2 : [] };
+    })
+  );
+  for (const [key, category] of MONSTER_SECTIONS) {
+    const features = monster[key];
+    if (!Array.isArray(features)) continue;
+    for (const feature of features) {
+      const f = feature;
+      if (!Array.isArray(f.entries)) continue;
+      f.entries = f.entries.map((desc) => {
+        var _a2;
+        if (/\{@\w+/.test(desc)) return desc;
+        return convertDescToTags(desc, {
+          abilities,
+          profBonus,
+          actionName: (_a2 = f.name) != null ? _a2 : "",
+          actionCategory: category,
+          spellAbility
+        });
+      });
+    }
+  }
+}
+
+export {
+  CR_TO_XP,
+  parseCR,
+  getChallengeRatingXP,
+  getProficiencyBonus,
+  enrichMonster,
+  convertMonsterEntries
+};

package/dist/chunk-6NK2MUD3.js

@@ -0,0 +1,114 @@
+import {
+  weaponEntitySchema
+} from "./chunk-AFKTJXRA.js";
+
+// src/weapon/weapon.parser.ts
+import { parseYaml } from "@archivist-gg/core";
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "slug",
+  "category",
+  "damage",
+  "properties",
+  "range",
+  "reload",
+  "mastery",
+  "type_tags",
+  "ammo_type",
+  "weight",
+  "cost",
+  "source",
+  "page",
+  "edition",
+  "entries",
+  "raw"
+]);
+var FLAG_PROPERTIES = /* @__PURE__ */ new Set([
+  "finesse",
+  "light",
+  "heavy",
+  "two_handed",
+  "reach",
+  "special",
+  "thrown",
+  "ammunition",
+  "versatile",
+  "loading"
+]);
+var VERSATILE_RE = /^versatile\s*\(\s*(\d+d\d+)\s*\)$/i;
+var THROWN_RE = /^thrown\s*\(\s*range\s+(\d+)\s*\/\s*(\d+)\s*\)$/i;
+var AMMUNITION_RE = /^ammunition\s*\(\s*range\s+(\d+)\s*\/\s*(\d+)\s*\)$/i;
+function extractFromPropertyStrings(input) {
+  const out = { properties: [], unparsed: [] };
+  if (!Array.isArray(input)) return out;
+  for (const raw of input) {
+    if (typeof raw !== "string") {
+      out.properties.push(raw);
+      continue;
+    }
+    const lower = raw.toLowerCase().trim();
+    if (FLAG_PROPERTIES.has(lower)) {
+      out.properties.push(lower);
+      continue;
+    }
+    const v = lower.match(VERSATILE_RE);
+    if (v) {
+      out.properties.push("versatile");
+      out.versatile_dice = v[1];
+      continue;
+    }
+    const t = lower.match(THROWN_RE);
+    if (t) {
+      out.properties.push("thrown");
+      out.range = { normal: Number.parseInt(t[1], 10), long: Number.parseInt(t[2], 10) };
+      continue;
+    }
+    const a = lower.match(AMMUNITION_RE);
+    if (a) {
+      out.properties.push("ammunition");
+      out.range = { normal: Number.parseInt(a[1], 10), long: Number.parseInt(a[2], 10) };
+      continue;
+    }
+    out.unparsed.push(raw);
+  }
+  return out;
+}
+function parseWeapon(source) {
+  var _a, _b;
+  const raw = parseYaml(source, ["name", "slug", "category", "damage"]);
+  if (!raw.success) return raw;
+  const propsInput = raw.data.properties;
+  if (Array.isArray(propsInput)) {
+    const extracted = extractFromPropertyStrings(propsInput);
+    raw.data.properties = extracted.properties;
+    if (extracted.versatile_dice && raw.data.damage && typeof raw.data.damage === "object") {
+      const dmg = raw.data.damage;
+      if (dmg.versatile_dice === void 0) dmg.versatile_dice = extracted.versatile_dice;
+    }
+    if (extracted.range && raw.data.range === void 0) {
+      raw.data.range = extracted.range;
+    }
+    if (extracted.unparsed.length > 0) {
+      const existingRaw = (_a = raw.data.raw) != null ? _a : {};
+      existingRaw.unparsed_properties = extracted.unparsed;
+      raw.data.raw = existingRaw;
+    }
+  }
+  const result = weaponEntitySchema.safeParse(raw.data);
+  if (!result.success) {
+    return { success: false, error: `weapon schema validation failed: ${result.error.message}` };
+  }
+  const entity = result.data;
+  const extras = {};
+  for (const [k, v] of Object.entries(raw.data)) {
+    if (!KNOWN_KEYS.has(k)) extras[k] = v;
+  }
+  if (Object.keys(extras).length > 0) {
+    entity.raw = { ...(_b = entity.raw) != null ? _b : {}, ...extras };
+  }
+  return { success: true, data: entity };
+}
+
+export {
+  parseWeapon
+};