@archivist-gg/dnd5e 0.1.0

package/dist/chunk-LWFTHJIE.js

@@ -0,0 +1,24 @@
+import {
+  evaluateConditions
+} from "./chunk-DNAJRMNN.js";
+
+// src/item/item.bonuses.ts
+function isConditionalBonus(x) {
+  return !!x && typeof x === "object" && typeof x.value === "number" && Array.isArray(x.when);
+}
+function readNumericBonus(raw, ctx) {
+  if (raw === void 0 || raw === null) return null;
+  if (typeof raw === "number") {
+    return raw === 0 ? null : { kind: "applied", value: raw };
+  }
+  if (!isConditionalBonus(raw)) return null;
+  if (raw.value === 0) return null;
+  const outcome = evaluateConditions(raw.when, ctx);
+  if (outcome === "true") return { kind: "applied", value: raw.value };
+  if (outcome === "false") return { kind: "skipped" };
+  return { kind: "informational", value: raw.value, conditions: raw.when };
+}
+
+export {
+  readNumericBonus
+};

package/dist/chunk-MDEJHMKK.js

@@ -0,0 +1,52 @@
+import {
+  durationSchema
+} from "./chunk-WYGD2UGN.js";
+import {
+  actionCostEnum,
+  resetTriggerEnum,
+  resourceConsumptionSchema
+} from "./chunk-PZOWBI3B.js";
+import {
+  featureEffectSchema
+} from "./chunk-NXR3BD2V.js";
+
+// src/optional-feature/optional-feature.schema.ts
+import { z } from "zod";
+var editionEnum = z.enum(["2014", "2024"]);
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var prerequisiteSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("level"), min: z.number().int().positive() }),
+  z.object({ kind: z.literal("spell-known"), spell: z.string().regex(wikilinkRegex) }),
+  z.object({ kind: z.literal("pact"), pact: z.enum(["tome", "blade", "chain", "talisman"]) }),
+  z.object({ kind: z.literal("class"), class: z.string().regex(wikilinkRegex) }),
+  z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
+  z.object({ kind: z.literal("other"), detail: z.string() })
+]);
+var usesSchema = z.object({
+  max: z.union([z.number(), z.string()]),
+  recharge: resetTriggerEnum
+});
+var optionalFeatureEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  edition: editionEnum,
+  source: z.string().min(1),
+  feature_type: z.string().min(1),
+  description: z.string(),
+  prerequisites: z.array(prerequisiteSchema),
+  available_to: z.array(z.string().regex(wikilinkRegex)),
+  effects: z.array(featureEffectSchema),
+  action_cost: actionCostEnum.nullable().optional(),
+  uses: usesSchema.nullable().optional(),
+  consumes: resourceConsumptionSchema.nullable().optional(),
+  duration: durationSchema.nullable().optional(),
+  passive: z.boolean().optional(),
+  // Phase 3 activatable buffs: an activatable boon folds its effects only while
+  // its slug is present in state.active_buffs (toggled in the PoolTab).
+  activatable: z.boolean().optional()
+});
+
+export {
+  optionalFeatureEntitySchema
+};

package/dist/chunk-N2JE7BWL.js

@@ -0,0 +1,81 @@
+import {
+  spellEntitySchema
+} from "./chunk-Y4I74YEG.js";
+
+// src/spell/spell.parser.ts
+import { parseYaml, toStringSafe } from "@archivist-gg/core";
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "level",
+  "school",
+  "casting_time",
+  "range",
+  "components",
+  "duration",
+  "concentration",
+  "ritual",
+  "classes",
+  "description",
+  "at_higher_levels",
+  "damage",
+  "saving_throw",
+  "casting_options",
+  // Body-only metadata that's emitted to YAML but ignored at runtime — accept silently.
+  "slug",
+  "edition",
+  "source"
+]);
+function parseSpell(source) {
+  const result = parseYaml(source, ["name"]);
+  if (!result.success) return result;
+  const meta = {};
+  if (typeof result.data.source === "string") meta.source = result.data.source;
+  if (typeof result.data.edition === "string") meta.edition = result.data.edition;
+  const filtered = {};
+  for (const [k, v] of Object.entries(result.data)) {
+    if (k === "slug" || k === "edition" || k === "source") continue;
+    if (!KNOWN_KEYS.has(k)) {
+      return { success: false, error: `Unknown spell field: ${k}` };
+    }
+    filtered[k] = v;
+  }
+  const parsed = spellEntitySchema.safeParse(filtered);
+  if (!parsed.success) {
+    return { success: false, error: `spell schema validation failed: ${parsed.error.message}` };
+  }
+  const raw = parsed.data;
+  const spell = { name: raw.name };
+  if (raw.level != null) spell.level = raw.level;
+  if (raw.school != null) spell.school = toStringSafe(raw.school);
+  if (raw.casting_time != null) spell.casting_time = toStringSafe(raw.casting_time);
+  if (raw.range != null) spell.range = toStringSafe(raw.range);
+  if (raw.components != null) spell.components = toStringSafe(raw.components);
+  if (raw.duration != null) spell.duration = toStringSafe(raw.duration);
+  if (raw.concentration != null) spell.concentration = Boolean(raw.concentration);
+  if (raw.ritual != null) spell.ritual = Boolean(raw.ritual);
+  if (raw.classes) spell.classes = raw.classes.map(String);
+  if (raw.description) spell.description = raw.description;
+  if (raw.at_higher_levels) spell.at_higher_levels = raw.at_higher_levels.map(String);
+  if (raw.damage) spell.damage = { types: raw.damage.types.map(String) };
+  if (raw.saving_throw) spell.saving_throw = { ability: raw.saving_throw.ability };
+  if (raw.casting_options) {
+    spell.casting_options = raw.casting_options.map((opt) => {
+      const co = { type: opt.type };
+      if (opt.damage_roll !== void 0) co.damage_roll = opt.damage_roll;
+      if (opt.target_count !== void 0) co.target_count = opt.target_count;
+      if (opt.duration !== void 0) co.duration = opt.duration;
+      if (opt.range !== void 0) co.range = opt.range;
+      if (opt.concentration !== void 0) co.concentration = opt.concentration;
+      if (opt.shape_size !== void 0) co.shape_size = opt.shape_size;
+      if (opt.desc !== void 0) co.desc = opt.desc;
+      return co;
+    });
+  }
+  if (meta.source) spell.source = meta.source;
+  if (meta.edition) spell.edition = meta.edition;
+  return { success: true, data: spell };
+}
+
+export {
+  parseSpell
+};

package/dist/chunk-NAEPSZAM.js

@@ -0,0 +1,88 @@
+import {
+  ABILITY_KEYS,
+  CR_PROFICIENCY,
+  CR_XP,
+  SIZE_HIT_DICE
+} from "./chunk-WP2CX2JO.js";
+
+// src/dnd/math.ts
+function abilityModifier(score) {
+  return Math.floor((score - 10) / 2);
+}
+function formatModifier(mod) {
+  return mod >= 0 ? `+${mod}` : `${mod}`;
+}
+function proficiencyBonusFromCR(cr) {
+  var _a;
+  return (_a = CR_PROFICIENCY[cr]) != null ? _a : 2;
+}
+function proficiencyFromLevel(level) {
+  if (level < 5) return 2;
+  if (level < 9) return 3;
+  if (level < 13) return 4;
+  if (level < 17) return 5;
+  return 6;
+}
+function crToXP(cr) {
+  var _a;
+  return (_a = CR_XP[cr]) != null ? _a : 0;
+}
+function hitDiceSizeFromCreatureSize(size) {
+  var _a;
+  return (_a = SIZE_HIT_DICE[size.toLowerCase()]) != null ? _a : 8;
+}
+function hpFromHitDice(hitDiceCount, hitDiceSize, conMod) {
+  const avg = Math.floor(hitDiceCount * (hitDiceSize + 1) / 2 + hitDiceCount * conMod);
+  return Math.max(1, avg);
+}
+function parseHitDiceFormula(formula) {
+  const match = formula.match(/^(\d+)d(\d+)/i);
+  if (!match) return null;
+  return { count: parseInt(match[1], 10), size: parseInt(match[2], 10) };
+}
+function savingThrow(abilityScore, isProficient, profBonus) {
+  return abilityModifier(abilityScore) + (isProficient ? profBonus : 0);
+}
+function skillBonus(abilityScore, proficiency, profBonus) {
+  const mod = abilityModifier(abilityScore);
+  if (proficiency === "expertise") return mod + profBonus * 2;
+  if (proficiency === "proficient") return mod + profBonus;
+  return mod;
+}
+function passive(abilityScore, proficiency, profBonus) {
+  return 10 + skillBonus(abilityScore, proficiency, profBonus);
+}
+function passivePerception(wisScore, perceptionProf, profBonus) {
+  return passive(wisScore, perceptionProf, profBonus);
+}
+function attackBonus(abilityScore, profBonus) {
+  return abilityModifier(abilityScore) + profBonus;
+}
+function saveDC(abilityScore, profBonus) {
+  return 8 + profBonus + abilityModifier(abilityScore);
+}
+function abilityNameToKey(name) {
+  const lower = name.toLowerCase();
+  if (ABILITY_KEYS.includes(lower)) {
+    return lower;
+  }
+  return null;
+}
+
+export {
+  abilityModifier,
+  formatModifier,
+  proficiencyBonusFromCR,
+  proficiencyFromLevel,
+  crToXP,
+  hitDiceSizeFromCreatureSize,
+  hpFromHitDice,
+  parseHitDiceFormula,
+  savingThrow,
+  skillBonus,
+  passive,
+  passivePerception,
+  attackBonus,
+  saveDC,
+  abilityNameToKey
+};

package/dist/chunk-NXR3BD2V.js

@@ -0,0 +1,90 @@
+// src/schemas/feature-effect-schema.ts
+import { z } from "zod";
+var featureEffectSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("initiative-bonus"), value: z.number().int() }),
+  z.object({ kind: z.literal("immune-condition"), condition: z.string().min(1), while: z.string().optional() }),
+  z.object({ kind: z.literal("resistance"), damage_type: z.string().min(1) }),
+  z.object({ kind: z.literal("hp-per-level-bonus"), value: z.number().int() }),
+  z.object({
+    kind: z.literal("speed-bonus"),
+    mode: z.enum(["walk", "fly", "swim", "climb", "burrow"]),
+    value: z.number().int(),
+    // when true, value is an absolute floor (Math.max), not additive; currently
+    // only surfaced for mode:"walk" — other modes have no derived speed yet.
+    set: z.boolean().optional()
+  }),
+  z.object({
+    kind: z.literal("sense"),
+    type: z.enum(["darkvision", "blindsight", "tremorsense", "truesight"]),
+    range: z.number().int().nonnegative()
+  }),
+  z.object({
+    kind: z.literal("apply-condition"),
+    condition: z.string().min(1),
+    duration: z.string().optional(),
+    ends_on: z.array(z.string()).optional(),
+    save_repeat: z.object({
+      ability: z.string().min(1),
+      timing: z.string().min(1)
+    }).optional()
+  }),
+  z.object({
+    kind: z.literal("damage-bonus"),
+    // intentionally an open string, NOT a damage-type enum: must accept the
+    // literal "chosen" (player-selected damage type at action time) alongside
+    // canonical damage types. Do not tighten to an enum.
+    damage_type: z.string().min(1),
+    amount: z.string().min(1),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    condition: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("proficiency"),
+    proficiency_type: z.enum(["skill", "tool", "language", "saving-throw", "armor", "weapon"]),
+    value: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("ac-bonus"),
+    value: z.number().int(),
+    requires_armor: z.boolean().optional()
+  }),
+  z.object({
+    kind: z.literal("unarmored-ac"),
+    abilities: z.array(z.enum(["str", "dex", "con", "int", "wis", "cha"])),
+    base: z.number().int().optional(),
+    allow_shield: z.boolean().optional()
+  }),
+  z.object({
+    kind: z.literal("weapon-ability"),
+    ability: z.union([z.enum(["str", "dex", "con", "int", "wis", "cha"]), z.literal("spellcasting")]),
+    weapons: z.union([z.literal("chosen"), z.string(), z.array(z.string())]).optional()
+  }),
+  z.object({
+    kind: z.literal("roll-modifier"),
+    mode: z.enum(["advantage", "disadvantage"]),
+    roll: z.enum(["ability-check", "saving-throw", "attack"]),
+    scope: z.string().optional(),
+    condition: z.string().optional()
+  }),
+  z.object({ kind: z.literal("extra-attack"), count: z.number().int().positive() }),
+  z.object({
+    kind: z.literal("crit-range"),
+    min_roll: z.number().int().min(2).max(20),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    condition: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("reroll-damage"),
+    max_reroll: z.number().int().positive(),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    once_per_die: z.boolean().optional()
+  }),
+  z.object({
+    kind: z.literal("attack-rule"),
+    flag: z.enum(["no-ranged-in-melee-disadvantage"])
+  })
+]);
+
+export {
+  featureEffectSchema
+};

package/dist/chunk-PKC77VZP.js

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

package/dist/chunk-PMADYMUI.js

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

package/dist/chunk-PTXBIDG7.js

@@ -0,0 +1,63 @@
+// src/monster/monster.ai-schema.ts
+import { z } from "zod";
+var abilitiesSchema = z.object({
+  str: z.number().min(1).max(30),
+  dex: z.number().min(1).max(30),
+  con: z.number().min(1).max(30),
+  int: z.number().min(1).max(30),
+  wis: z.number().min(1).max(30),
+  cha: z.number().min(1).max(30)
+});
+var acSchema = z.object({
+  ac: z.number(),
+  from: z.array(z.string()).optional(),
+  condition: z.string().optional()
+});
+var hpSchema = z.object({
+  average: z.number(),
+  formula: z.string()
+});
+var speedSchema = z.object({
+  walk: z.number().optional(),
+  fly: z.number().optional(),
+  swim: z.number().optional(),
+  climb: z.number().optional(),
+  burrow: z.number().optional()
+});
+var featureSchema = z.object({
+  name: z.string(),
+  entries: z.array(z.string().describe(
+    "Inline tag forms: `atk:ABILITY` for non-proficient attacks (ability mod alone), `atk:ABILITY+PB` for proficient attacks (ability mod + proficiency), `atk:+N` for literal attack bonuses, `dmg:DICE+ABILITY` for damage rolls (PB never added to damage), `dc:ABILITY` for save DCs (proficiency always included implicitly)."
+  ))
+});
+var monsterInputSchema = z.object({
+  name: z.string().describe("Monster name"),
+  size: z.enum(["Tiny", "Small", "Medium", "Large", "Huge", "Gargantuan"]),
+  type: z.string().describe("Creature type (e.g., aberration, beast, dragon)"),
+  subtype: z.string().optional(),
+  alignment: z.string(),
+  cr: z.string().describe('Challenge rating (e.g., "0", "1/8", "1/4", "1/2", "1" through "30")'),
+  abilities: abilitiesSchema,
+  ac: z.array(acSchema),
+  hp: hpSchema,
+  speed: speedSchema,
+  saves: z.record(z.string(), z.number()).optional(),
+  skills: z.record(z.string(), z.number()).optional(),
+  damage_vulnerabilities: z.array(z.string()).optional(),
+  damage_resistances: z.array(z.string()).optional(),
+  damage_immunities: z.array(z.string()).optional(),
+  condition_immunities: z.array(z.string()).optional(),
+  senses: z.array(z.string()).optional(),
+  passive_perception: z.number().optional(),
+  languages: z.array(z.string()).optional(),
+  traits: z.array(featureSchema).optional(),
+  actions: z.array(featureSchema).optional(),
+  reactions: z.array(featureSchema).optional(),
+  legendary_actions: z.array(featureSchema).optional(),
+  legendary_action_uses: z.number().optional(),
+  legendary_resistance: z.number().optional()
+});
+
+export {
+  monsterInputSchema
+};

package/dist/chunk-PZOWBI3B.js

@@ -0,0 +1,49 @@
+// src/schemas/resource-schema.ts
+import { z } from "zod";
+var resetTriggerEnum = z.enum(["short-rest", "long-rest", "dawn", "dusk", "turn", "round", "custom"]);
+var actionCostEnum = z.enum(["action", "bonus-action", "reaction", "free", "special"]);
+var resourceSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  max_formula: z.string().min(1),
+  scales_at: z.array(z.object({
+    level: z.number().int().positive(),
+    max: z.string().min(1)
+  }).strict()).optional(),
+  die: z.object({
+    base: z.string().min(1),
+    scaling: z.record(z.string(), z.string()).optional()
+  }).optional(),
+  reset: resetTriggerEnum,
+  consumes: z.object({
+    resource: z.string().min(1),
+    amount: z.number().int().positive()
+  }).optional(),
+  recovery: z.array(z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    amount: z.union([z.number(), z.string()]),
+    action: actionCostEnum.optional(),
+    uses: z.number().int().nonnegative().optional(),
+    reset: resetTriggerEnum
+  })).optional()
+});
+var resourceConsumptionSchema = z.object({
+  source: z.enum(["resource", "class-column", "attack-dice"]).optional(),
+  resource: z.string().optional(),
+  column: z.string().optional(),
+  amount: z.number().int().positive(),
+  expend_condition: z.enum(["roll_succeeds", "roll_fails", "target_takes_damage", "always"]).optional(),
+  free_uses: z.object({
+    amount: z.number().int().positive(),
+    reset: resetTriggerEnum,
+    state_key: z.string().optional()
+  }).optional()
+});
+
+export {
+  resetTriggerEnum,
+  actionCostEnum,
+  resourceSchema,
+  resourceConsumptionSchema
+};