@archivist-gg/dnd5e 0.1.0

package/dist/chunk-DNAJRMNN.js

@@ -0,0 +1,68 @@
+// src/item/item.conditions.ts
+function unwrapSlug(maybeWiki) {
+  if (!maybeWiki) return "";
+  const m = /^\[\[([^\]]+)\]\]$/.exec(maybeWiki);
+  return (m ? m[1] : maybeWiki).toLowerCase();
+}
+function evaluateCondition(cond, ctx) {
+  var _a;
+  switch (cond.kind) {
+    case "no_armor":
+      return ctx.derived.equippedSlots.armor === void 0 ? "true" : "false";
+    case "no_shield":
+      return ctx.derived.equippedSlots.shield === void 0 ? "true" : "false";
+    case "wielding_two_handed": {
+      const main = (_a = ctx.derived.equippedSlots.mainhand) == null ? void 0 : _a.entity;
+      if (!main || typeof main !== "object" || !("properties" in main)) return "false";
+      const props = main.properties;
+      if (!Array.isArray(props)) return "false";
+      return props.some((p) => p === "two_handed") ? "true" : "false";
+    }
+    case "is_class": {
+      const target = cond.value.toLowerCase();
+      return ctx.classList.some((c) => unwrapSlug(c.name) === target) ? "true" : "false";
+    }
+    case "is_race":
+      return unwrapSlug(ctx.race) === cond.value.toLowerCase() ? "true" : "false";
+    case "is_subclass":
+      return ctx.subclasses.some((s) => s.toLowerCase() === cond.value.toLowerCase()) ? "true" : "false";
+    // Tier 2-4 - always informational in v1.
+    case "vs_creature_type":
+    case "vs_attack_type":
+    case "on_attack_type":
+    case "with_weapon_property":
+    case "vs_spell_save":
+    case "lighting":
+    case "underwater":
+    case "movement_state":
+    case "has_condition":
+    case "is_concentrating":
+    case "bloodied":
+      return "informational";
+    case "raw":
+      return "informational";
+    case "any_of": {
+      let sawInformational = false;
+      for (const branch of cond.conditions) {
+        const o = evaluateCondition(branch, ctx);
+        if (o === "true") return "true";
+        if (o === "informational") sawInformational = true;
+      }
+      return sawInformational ? "informational" : "false";
+    }
+  }
+}
+function evaluateConditions(conds, ctx) {
+  let sawInformational = false;
+  for (const c of conds) {
+    const o = evaluateCondition(c, ctx);
+    if (o === "false") return "false";
+    if (o === "informational") sawInformational = true;
+  }
+  return sawInformational ? "informational" : "true";
+}
+
+export {
+  evaluateCondition,
+  evaluateConditions
+};

package/dist/chunk-DRNZJNJP.js

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

package/dist/chunk-FEOB24KP.js

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

package/dist/chunk-FFULAF2P.js

@@ -0,0 +1,63 @@
+import {
+  featureSchema
+} from "./chunk-DABBCYTT.js";
+import {
+  choiceSchema
+} from "./chunk-CDW7R2QT.js";
+
+// src/race/race.schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var editionEnum = z.enum(["2014", "2024"]);
+var sizeEnum = z.enum(["tiny", "small", "medium", "large", "huge"]);
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var speedSchema = z.object({
+  walk: z.number().int().nonnegative().optional(),
+  fly: z.number().int().nonnegative().optional(),
+  swim: z.number().int().nonnegative().optional(),
+  climb: z.number().int().nonnegative().optional(),
+  burrow: z.number().int().nonnegative().optional(),
+  hover: z.boolean().optional()
+});
+var visionSchema = z.object({
+  darkvision: z.number().int().nonnegative().optional(),
+  blindsight: z.number().int().nonnegative().optional(),
+  tremorsense: z.number().int().nonnegative().optional(),
+  truesight: z.number().int().nonnegative().optional()
+});
+var fixedAsiSchema = z.object({ ability: abilityEnum, amount: z.number().int() });
+var choiceAsiSchema = z.object({
+  choose: z.number().int().positive(),
+  pool: z.array(abilityEnum).nonempty(),
+  amount: z.number().int()
+});
+var asiSchema = z.union([fixedAsiSchema, choiceAsiSchema]);
+var languagesSchema = z.object({
+  fixed: z.array(z.string()),
+  choice: z.object({
+    count: z.number().int().positive(),
+    from: z.union([z.string(), z.array(z.string())])
+  }).optional()
+});
+var raceEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  edition: editionEnum,
+  source: z.string().min(1),
+  description: z.string(),
+  size: sizeEnum,
+  speed: speedSchema,
+  ability_score_increases: z.array(asiSchema),
+  age: z.string(),
+  alignment: z.string(),
+  vision: visionSchema,
+  languages: languagesSchema,
+  variant_label: z.string().min(1),
+  traits: z.array(featureSchema),
+  choices: z.array(choiceSchema).optional(),
+  subspecies_of: z.string().regex(wikilinkRegex).optional()
+});
+
+export {
+  raceEntitySchema
+};

package/dist/chunk-FUK7QSN5.js

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

package/dist/chunk-GIOH5JB5.js

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

package/dist/chunk-GJOI2GHP.js

@@ -0,0 +1,25 @@
+import {
+  STATIC_FALLBACK_CONTEXT,
+  convertDescToTags
+} from "./chunk-RAWJTA45.js";
+
+// src/item/item.enrichment.ts
+function enrichItem(raw) {
+  var _a, _b, _c;
+  const enriched = {
+    ...raw,
+    source: (_a = raw.source) != null ? _a : "Homebrew",
+    attunement: (_b = raw.attunement) != null ? _b : false,
+    curse: (_c = raw.curse) != null ? _c : false
+  };
+  if (Array.isArray(enriched.entries)) {
+    enriched.entries = enriched.entries.map(
+      (e) => convertDescToTags(e, STATIC_FALLBACK_CONTEXT)
+    );
+  }
+  return enriched;
+}
+
+export {
+  enrichItem
+};

package/dist/chunk-GZ46OVGZ.js

@@ -0,0 +1,31 @@
+import {
+  STATIC_FALLBACK_CONTEXT,
+  convertDescToTags
+} from "./chunk-RAWJTA45.js";
+
+// src/spell/spell.enrichment.ts
+function enrichSpell(raw) {
+  var _a, _b, _c, _d;
+  const duration = raw.duration;
+  const concentration = (_b = raw.concentration) != null ? _b : (_a = duration == null ? void 0 : duration.toLowerCase().includes("concentration")) != null ? _a : false;
+  const classes = ((_c = raw.classes) == null ? void 0 : _c.length) ? raw.classes : ["Wizard", "Sorcerer"];
+  const enriched = {
+    ...raw,
+    concentration,
+    ritual: (_d = raw.ritual) != null ? _d : false,
+    classes
+  };
+  if (typeof enriched.description === "string") {
+    enriched.description = convertDescToTags(enriched.description, STATIC_FALLBACK_CONTEXT);
+  }
+  if (Array.isArray(enriched.at_higher_levels)) {
+    enriched.at_higher_levels = enriched.at_higher_levels.map(
+      (p) => convertDescToTags(p, STATIC_FALLBACK_CONTEXT)
+    );
+  }
+  return enriched;
+}
+
+export {
+  enrichSpell
+};

package/dist/chunk-HCP3GMHS.js

@@ -0,0 +1,44 @@
+import {
+  armorEntitySchema
+} from "./chunk-XJNECUPT.js";
+
+// src/armor/armor.parser.ts
+import { parseYaml } from "@archivist-gg/core";
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "slug",
+  "category",
+  "ac",
+  "strength_requirement",
+  "stealth_disadvantage",
+  "weight",
+  "cost",
+  "rarity",
+  "source",
+  "page",
+  "edition",
+  "entries",
+  "raw"
+]);
+function parseArmor(source) {
+  var _a;
+  const raw = parseYaml(source, ["name", "slug", "category", "ac"]);
+  if (!raw.success) return raw;
+  const result = armorEntitySchema.safeParse(raw.data);
+  if (!result.success) {
+    return { success: false, error: `armor 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 {
+  parseArmor
+};

package/dist/chunk-IDTDACM6.js

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

package/dist/chunk-IXZXFFFW.js

@@ -0,0 +1,269 @@
+import {
+  readTableColumn
+} from "./chunk-5XUXXAQJ.js";
+import {
+  bareSlug
+} from "./chunk-J2RYSZMQ.js";
+import {
+  abilityModifier
+} from "./chunk-NAEPSZAM.js";
+
+// src/pc/pc.spellcasting.ts
+function resolveSpellcasting(rc) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const sub = (_b = (_a = rc.subclass) == null ? void 0 : _a.spellcasting) != null ? _b : null;
+  const cls = (_d = (_c = rc.entity) == null ? void 0 : _c.spellcasting) != null ? _d : null;
+  const sc = sub != null ? sub : cls;
+  if (!sc) return null;
+  const table = (_i = (_h = sub ? (_e = rc.subclass) == null ? void 0 : _e.table : (_f = rc.entity) == null ? void 0 : _f.table) != null ? _h : (_g = rc.entity) == null ? void 0 : _g.table) != null ? _i : {};
+  return {
+    ability: sc.ability,
+    casterType: sc.caster_type,
+    preparation: sc.preparation,
+    spellList: sc.spell_list,
+    table
+  };
+}
+function normalizeKnownSpell(entry) {
+  var _a, _b;
+  if (typeof entry === "string") {
+    return { slug: bareSlug(entry), classSlug: null, source: "class", preparedFlag: void 0, alwaysPrepared: false };
+  }
+  return {
+    slug: bareSlug(entry.spell),
+    classSlug: entry.class ? bareSlug(entry.class) : null,
+    source: (_a = entry.source) != null ? _a : "class",
+    preparedFlag: entry.prepared,
+    alwaysPrepared: (_b = entry.always_prepared) != null ? _b : false
+  };
+}
+var FULL_CASTER_SLOTS = [
+  /* 1  */
+  [2, 0, 0, 0, 0, 0, 0, 0, 0],
+  /* 2  */
+  [3, 0, 0, 0, 0, 0, 0, 0, 0],
+  /* 3  */
+  [4, 2, 0, 0, 0, 0, 0, 0, 0],
+  /* 4  */
+  [4, 3, 0, 0, 0, 0, 0, 0, 0],
+  /* 5  */
+  [4, 3, 2, 0, 0, 0, 0, 0, 0],
+  /* 6  */
+  [4, 3, 3, 0, 0, 0, 0, 0, 0],
+  /* 7  */
+  [4, 3, 3, 1, 0, 0, 0, 0, 0],
+  /* 8  */
+  [4, 3, 3, 2, 0, 0, 0, 0, 0],
+  /* 9  */
+  [4, 3, 3, 3, 1, 0, 0, 0, 0],
+  /* 10 */
+  [4, 3, 3, 3, 2, 0, 0, 0, 0],
+  /* 11 */
+  [4, 3, 3, 3, 2, 1, 0, 0, 0],
+  /* 12 */
+  [4, 3, 3, 3, 2, 1, 0, 0, 0],
+  /* 13 */
+  [4, 3, 3, 3, 2, 1, 1, 0, 0],
+  /* 14 */
+  [4, 3, 3, 3, 2, 1, 1, 0, 0],
+  /* 15 */
+  [4, 3, 3, 3, 2, 1, 1, 1, 0],
+  /* 16 */
+  [4, 3, 3, 3, 2, 1, 1, 1, 0],
+  /* 17 */
+  [4, 3, 3, 3, 2, 1, 1, 1, 1],
+  /* 18 */
+  [4, 3, 3, 3, 3, 1, 1, 1, 1],
+  /* 19 */
+  [4, 3, 3, 3, 3, 2, 1, 1, 1],
+  /* 20 */
+  [4, 3, 3, 3, 3, 2, 2, 1, 1]
+];
+var HALF_CASTER_SLOTS = [
+  /* 1  */
+  [0, 0, 0, 0, 0],
+  /* 2  */
+  [2, 0, 0, 0, 0],
+  /* 3  */
+  [3, 0, 0, 0, 0],
+  /* 4  */
+  [3, 0, 0, 0, 0],
+  /* 5  */
+  [4, 2, 0, 0, 0],
+  /* 6  */
+  [4, 2, 0, 0, 0],
+  /* 7  */
+  [4, 3, 0, 0, 0],
+  /* 8  */
+  [4, 3, 0, 0, 0],
+  /* 9  */
+  [4, 3, 2, 0, 0],
+  /* 10 */
+  [4, 3, 2, 0, 0],
+  /* 11 */
+  [4, 3, 3, 0, 0],
+  /* 12 */
+  [4, 3, 3, 0, 0],
+  /* 13 */
+  [4, 3, 3, 1, 0],
+  /* 14 */
+  [4, 3, 3, 1, 0],
+  /* 15 */
+  [4, 3, 3, 2, 0],
+  /* 16 */
+  [4, 3, 3, 2, 0],
+  /* 17 */
+  [4, 3, 3, 3, 1],
+  /* 18 */
+  [4, 3, 3, 3, 1],
+  /* 19 */
+  [4, 3, 3, 3, 2],
+  /* 20 */
+  [4, 3, 3, 3, 2]
+];
+var THIRD_CASTER_SLOTS = [
+  /* 1  */
+  [0, 0, 0, 0],
+  /* 2  */
+  [0, 0, 0, 0],
+  /* 3  */
+  [2, 0, 0, 0],
+  /* 4  */
+  [3, 0, 0, 0],
+  /* 5  */
+  [3, 0, 0, 0],
+  /* 6  */
+  [3, 0, 0, 0],
+  /* 7  */
+  [4, 2, 0, 0],
+  /* 8  */
+  [4, 2, 0, 0],
+  /* 9  */
+  [4, 2, 0, 0],
+  /* 10 */
+  [4, 3, 0, 0],
+  /* 11 */
+  [4, 3, 0, 0],
+  /* 12 */
+  [4, 3, 0, 0],
+  /* 13 */
+  [4, 3, 2, 0],
+  /* 14 */
+  [4, 3, 2, 0],
+  /* 15 */
+  [4, 3, 2, 0],
+  /* 16 */
+  [4, 3, 3, 0],
+  /* 17 */
+  [4, 3, 3, 0],
+  /* 18 */
+  [4, 3, 3, 0],
+  /* 19 */
+  [4, 3, 3, 1],
+  /* 20 */
+  [4, 3, 3, 1]
+];
+var PACT_MAGIC = [
+  /* 1  */
+  { level: 1, total: 1 },
+  /* 2  */
+  { level: 1, total: 2 },
+  /* 3  */
+  { level: 2, total: 2 },
+  /* 4  */
+  { level: 2, total: 2 },
+  /* 5  */
+  { level: 3, total: 2 },
+  /* 6  */
+  { level: 3, total: 2 },
+  /* 7  */
+  { level: 4, total: 2 },
+  /* 8  */
+  { level: 4, total: 2 },
+  /* 9  */
+  { level: 5, total: 2 },
+  /* 10 */
+  { level: 5, total: 2 },
+  /* 11 */
+  { level: 5, total: 3 },
+  /* 12 */
+  { level: 5, total: 3 },
+  /* 13 */
+  { level: 5, total: 3 },
+  /* 14 */
+  { level: 5, total: 3 },
+  /* 15 */
+  { level: 5, total: 3 },
+  /* 16 */
+  { level: 5, total: 3 },
+  /* 17 */
+  { level: 5, total: 4 },
+  /* 18 */
+  { level: 5, total: 4 },
+  /* 19 */
+  { level: 5, total: 4 },
+  /* 20 */
+  { level: 5, total: 4 }
+];
+function rowToRecord(row) {
+  const out = {};
+  row.forEach((n, i) => {
+    if (n > 0) out[i + 1] = n;
+  });
+  return out;
+}
+function deriveSpellSlots(classes) {
+  let fullLevels = 0, halfLevels = 0, thirdLevels = 0, warlockLevel = 0;
+  const regular = [];
+  for (const c of classes) {
+    if (c.casterType === "pact") {
+      warlockLevel += c.level;
+      continue;
+    }
+    regular.push({ caster: c.casterType, level: c.level });
+    if (c.casterType === "full") fullLevels += c.level;
+    else if (c.casterType === "half") halfLevels += c.level;
+    else if (c.casterType === "third") thirdLevels += c.level;
+  }
+  let standard = {};
+  if (regular.length === 1) {
+    const only = regular[0];
+    const idx = only.level - 1;
+    if (only.caster === "half") {
+      if (idx >= 0 && idx < HALF_CASTER_SLOTS.length) standard = rowToRecord(HALF_CASTER_SLOTS[idx]);
+    } else if (only.caster === "third") {
+      if (idx >= 0 && idx < THIRD_CASTER_SLOTS.length) standard = rowToRecord(THIRD_CASTER_SLOTS[idx]);
+    } else {
+      if (only.level >= 1 && only.level <= FULL_CASTER_SLOTS.length) standard = rowToRecord(FULL_CASTER_SLOTS[only.level - 1]);
+    }
+  } else if (regular.length >= 2) {
+    const cl = fullLevels + Math.floor(halfLevels / 2) + Math.floor(thirdLevels / 3);
+    if (cl >= 1 && cl <= FULL_CASTER_SLOTS.length) standard = rowToRecord(FULL_CASTER_SLOTS[cl - 1]);
+  }
+  const pact = warlockLevel >= 1 && warlockLevel <= PACT_MAGIC.length ? PACT_MAGIC[warlockLevel - 1] : null;
+  return { standard, pact };
+}
+function computeSpellLimits(inputs) {
+  const out = [];
+  for (const i of inputs) {
+    const p = i.profile;
+    const cantripsKnown = readTableColumn(p.table, i.level, ["Cantrips Known", "Cantrips"]);
+    const mod = abilityModifier(i.abilityScore);
+    let preparedOrKnown;
+    if (p.preparation === "prepared") {
+      const levelTerm = p.casterType === "half" ? Math.floor(i.level / 2) : i.level;
+      preparedOrKnown = Math.max(1, mod + levelTerm);
+    } else {
+      preparedOrKnown = readTableColumn(p.table, i.level, ["Spells Known", "Prepared Spells"]);
+    }
+    out.push({ classSlug: i.classSlug, kind: p.preparation, cantripsKnown, preparedOrKnown });
+  }
+  return out;
+}
+
+export {
+  resolveSpellcasting,
+  normalizeKnownSpell,
+  deriveSpellSlots,
+  computeSpellLimits
+};

package/dist/chunk-J2RYSZMQ.js

@@ -0,0 +1,16 @@
+// src/class/class.slug.ts
+function bareSlug(ref) {
+  if (typeof ref !== "string") return "";
+  const m = ref.match(/^\[\[(.+?)\]\]$/);
+  return (m ? m[1] : ref).toLowerCase();
+}
+function baseClassName(ref) {
+  const bare = bareSlug(ref);
+  const sep = bare.indexOf("_");
+  return sep >= 0 ? bare.slice(sep + 1) : bare;
+}
+
+export {
+  bareSlug,
+  baseClassName
+};

package/dist/chunk-JEYQU3JT.js

@@ -0,0 +1,36 @@
+// src/pc/decision-recognizer.ts
+var DECISION_SIGNAL = [/\bchoose (one|two|three|a|an)\b/i, /\bof your choice\b/i, /\byour choice of\b/i];
+var ASI_OR_FEAT = {
+  kind: "select-inline",
+  id: "asi-or-feat",
+  count: 1,
+  options: [
+    {
+      value: "asi",
+      label: "Ability Score Increase",
+      choices: [{ kind: "ability-points", id: "asi", points: 2, max_per: 2 }]
+    },
+    {
+      value: "feat",
+      label: "Feat",
+      choices: [{ kind: "select-entity", id: "feat", entity_type: "feat", count: 1 }]
+    }
+  ]
+};
+var TABLE = {
+  "ability-score-improvement": [ASI_OR_FEAT],
+  "expertise": [{ kind: "select-proficiency", id: "expertise", count: 2, domain: "skill", from_proficient: true, expertise: true }],
+  "fighting-style": [{ kind: "select-entity", id: "fighting-style", count: 1, entity_type: "optional-feature", where: { feature_type: "fighting_style", available_to: "self" } }]
+};
+function recognizeDecision(feature) {
+  var _a, _b;
+  const slug = ((_a = feature.id) != null ? _a : feature.name).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+  if (TABLE[slug]) return TABLE[slug];
+  const desc = (_b = feature.description) != null ? _b : "";
+  return DECISION_SIGNAL.some((re) => re.test(desc)) ? "informational" : null;
+}
+
+export {
+  DECISION_SIGNAL,
+  recognizeDecision
+};

package/dist/chunk-LSLSG67V.js

@@ -0,0 +1,31 @@
+// src/encounter/encounter.ai-schema.ts
+import { z } from "zod";
+var encounterInputSchema = z.object({
+  party_size: z.number().min(1).max(10).describe("Number of players"),
+  party_level: z.number().min(1).max(20).describe("Average party level"),
+  difficulty: z.enum(["easy", "medium", "hard", "deadly"]),
+  environment: z.string().optional().describe('e.g., "swamp", "dungeon", "forest"'),
+  theme: z.string().optional().describe('e.g., "undead horde", "dragon lair"')
+});
+var encounterMonsterSchema = z.object({
+  name: z.string(),
+  cr: z.string(),
+  count: z.number(),
+  role: z.string()
+});
+var encounterOutputSchema = z.object({
+  monsters: z.array(encounterMonsterSchema),
+  tactics: z.string(),
+  terrain: z.string(),
+  notes: z.string(),
+  xp_budget: z.object({
+    target: z.number(),
+    actual: z.number(),
+    difficulty_rating: z.string()
+  })
+});
+
+export {
+  encounterInputSchema,
+  encounterOutputSchema
+};