@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/chunk-2FRUSVZS.js

@@ -0,0 +1,489 @@
+import {
+  CR_TO_XP,
+  getProficiencyBonus
+} from "./chunk-6PXTNCBP.js";
+import {
+  abilityModifier
+} from "./chunk-PDJSUH24.js";
+import {
+  ALL_SKILLS
+} from "./chunk-WELIKLZF.js";
+
+// src/monster/monster.format.ts
+function capitalizeWords(str) {
+  return str.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function capitalizeOutsideLinks(str) {
+  return str.replace(/\[\[([^\]|]+)(?:\|([^\]]*))?\]\]|([^[]+|\[)/g, (m, target, alias, plain) => {
+    if (target !== void 0) return alias !== void 0 ? `[[${target}|${capitalizeWords(alias)}]]` : `[[${target}]]`;
+    return capitalizeWords(plain != null ? plain : m);
+  });
+}
+var SIZE_CODES = { T: "Tiny", S: "Small", M: "Medium", L: "Large", H: "Huge", G: "Gargantuan" };
+function sizeWords(size) {
+  if (size === void 0) return [];
+  const arr = Array.isArray(size) ? size : [size];
+  return arr.map((s) => {
+    var _a;
+    return (_a = SIZE_CODES[s]) != null ? _a : capitalizeWords(s);
+  });
+}
+function joinOr(words) {
+  if (words.length <= 1) return words.join("");
+  if (words.length === 2) return `${words[0]} or ${words[1]}`;
+  return `${words.slice(0, -1).join(", ")}, or ${words[words.length - 1]}`;
+}
+function formatSize(size, note) {
+  const text = joinOr(sizeWords(size));
+  return note ? `${text} ${note}` : text;
+}
+function sizeWord(size) {
+  const first = sizeWords(size)[0];
+  return (first != null ? first : "Medium").toLowerCase();
+}
+var ALIGNMENT_CODES = {
+  L: "lawful",
+  N: "neutral",
+  NX: "neutral",
+  NY: "neutral",
+  C: "chaotic",
+  G: "good",
+  E: "evil",
+  U: "unaligned",
+  A: "any alignment"
+};
+var ALIGNMENT_SETS = {
+  "C,E,L,NX,NY": "any non-good alignment",
+  "C,E,G,NX,NY": "any non-lawful alignment",
+  "C,E,L,NX": "any evil alignment",
+  "C,E,G,NY": "any chaotic alignment",
+  "N,NX,NY": "any neutral alignment"
+};
+function decodeCodes(codes) {
+  const key = [...codes].sort().join(",");
+  if (ALIGNMENT_SETS[key]) return ALIGNMENT_SETS[key];
+  return codes.map((c) => {
+    var _a;
+    return (_a = ALIGNMENT_CODES[c]) != null ? _a : c;
+  }).join(" ");
+}
+function alignmentText(alignment, prefix) {
+  if (alignment === void 0) return "";
+  let body;
+  if (typeof alignment === "string") body = alignment;
+  else if (alignment.every((a) => typeof a === "string")) body = decodeCodes(alignment);
+  else {
+    body = alignment.map((a) => {
+      var _a, _b;
+      if (typeof a === "string") return (_a = ALIGNMENT_CODES[a]) != null ? _a : a;
+      if (a.special) return a.special;
+      let t = decodeCodes((_b = a.alignment) != null ? _b : []);
+      if (a.chance !== void 0) t += ` (${a.chance}%)`;
+      if (a.note) t += ` (${a.note})`;
+      return t;
+    }).join(" or ");
+  }
+  return `${prefix != null ? prefix : ""}${body}`;
+}
+function formatAlignment(alignment, prefix) {
+  return capitalizeWords(alignmentText(alignment, prefix));
+}
+function alignmentWords(alignment) {
+  return alignmentText(alignment).toLowerCase();
+}
+var IRREGULAR_PLURALS = { fey: "fey", undead: "undead" };
+function plural(word) {
+  var _a;
+  return (_a = IRREGULAR_PLURALS[word.toLowerCase()]) != null ? _a : `${word}s`;
+}
+function formatType(type, level) {
+  var _a, _b;
+  if (type === void 0) return "";
+  if (typeof type === "string") return capitalizeWords(type);
+  const baseText = typeof type.type === "string" ? capitalizeWords(type.type) : type.type.choose.map(capitalizeWords).join(" or ");
+  let text = type.swarm_size !== void 0 ? `Swarm of ${(_a = SIZE_CODES[type.swarm_size]) != null ? _a : capitalizeWords(type.swarm_size)} ${capitalizeWords(plural(typeof type.type === "string" ? type.type : type.type.choose.join(" or ")))}` : baseText;
+  const tags = ((_b = type.tags) != null ? _b : []).map((t) => typeof t === "string" ? t : t.prefix_hidden ? t.tag : `${t.prefix} ${t.tag}`);
+  if (tags.length > 0) text += ` (${tags.map(capitalizeWords).join(", ")})`;
+  if (type.sidekick_type && !type.sidekick_hidden) {
+    text += `, ${capitalizeWords(type.sidekick_type)} Sidekick`;
+    if (type.sidekick_tags && type.sidekick_tags.length > 0) text += ` (${type.sidekick_tags.map(capitalizeWords).join(", ")})`;
+    if (level !== void 0) text += ` (level ${level})`;
+  }
+  return text;
+}
+var CR_DECIMAL_KEYS = { "0.125": "1/8", "0.25": "1/4", "0.5": "1/2" };
+function hasOwn(table, key) {
+  return Object.prototype.hasOwnProperty.call(table, key);
+}
+function crKey(text) {
+  return hasOwn(CR_DECIMAL_KEYS, text) ? CR_DECIMAL_KEYS[text] : text;
+}
+function xpFor(cr) {
+  const key = crKey(cr);
+  return hasOwn(CR_TO_XP, key) ? CR_TO_XP[key] : 0;
+}
+function formatCR(cr) {
+  var _a;
+  if (cr === void 0 || cr === null) return void 0;
+  const obj = typeof cr === "object" ? cr : { cr: String(cr) };
+  const text = String(obj.cr);
+  const key = crKey(text);
+  const tableMiss = !hasOwn(CR_TO_XP, key);
+  return {
+    crText: text,
+    xp: (_a = obj.xp) != null ? _a : xpFor(text),
+    pb: getProficiencyBonus(key),
+    tableMiss,
+    lair: obj.lair,
+    coven: obj.coven,
+    xpLair: obj.xp_lair,
+    xpOverride: obj.xp
+  };
+}
+function formatXP(xp) {
+  return String(xp).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function crString(cr) {
+  var _a;
+  return (_a = formatCR(cr)) == null ? void 0 : _a.crText;
+}
+function challengeLine(cr, pbNote) {
+  const f = formatCR(cr);
+  if (!f) return void 0;
+  const pbText = pbNote ? `PB ${pbNote}` : `PB +${f.pb}`;
+  if (f.tableMiss && f.xpOverride === void 0) return `${f.crText} (${pbText})`;
+  const xpText = `${formatXP(f.xp)} XP`;
+  if (f.xpLair !== void 0) return `${f.crText} (${xpText}, or ${formatXP(f.xpLair)} XP in its lair; ${pbText})`;
+  let line = `${f.crText} (${xpText}; ${pbText})`;
+  if (f.lair !== void 0) line += `, or ${f.lair} (${formatXP(xpFor(f.lair))} XP) in its lair`;
+  if (f.coven !== void 0) line += `, or ${f.coven} (${formatXP(xpFor(f.coven))} XP) as a coven`;
+  return line;
+}
+function formatAC(ac) {
+  const parts = [];
+  for (const entry of ac != null ? ac : []) {
+    if (entry.special !== void 0) {
+      parts.push({ text: entry.special, braced: false });
+      continue;
+    }
+    if (entry.ac === void 0) continue;
+    let text = String(entry.ac);
+    if (entry.from && entry.from.length > 0) text += ` (${entry.from.map(capitalizeOutsideLinks).join(", ")})`;
+    if (entry.condition) text += ` ${entry.condition}`;
+    parts.push(entry.braces ? { text: `(${text})`, braced: true } : { text, braced: false });
+  }
+  if (parts.length === 0) return "10";
+  return parts.reduce((acc, p, i) => i === 0 ? p.text : `${acc}${p.braced ? " " : ", "}${p.text}`, "");
+}
+function formatHP(hp) {
+  if (!hp) return { text: "0" };
+  if (hp.special !== void 0) return { text: hp.special };
+  if (hp.average === void 0) return { text: "0" };
+  return hp.formula ? { text: String(hp.average), formula: hp.formula } : { text: String(hp.average) };
+}
+var SPEED_MODES = ["walk", "fly", "swim", "climb", "burrow"];
+function speedEntry(mode, value, hoverAppend) {
+  if (value === void 0 || value === null) return void 0;
+  const n = typeof value === "number" ? value : value.number;
+  if (!n) return void 0;
+  let text = `${capitalizeWords(mode)} ${n} ft.`;
+  const cond = typeof value === "number" ? void 0 : value.condition;
+  if (cond) text += ` ${cond}`;
+  if (hoverAppend && !(cond != null ? cond : "").toLowerCase().includes("hover")) text += " (hover)";
+  return text;
+}
+function formatSpeed(speed) {
+  var _a;
+  if (!speed) return "0 ft.";
+  const parts = [];
+  for (const mode of SPEED_MODES) {
+    const e = speedEntry(mode, speed[mode], mode === "fly" && speed.can_hover === true);
+    if (e) parts.push(e);
+  }
+  for (const [mode, entries] of Object.entries((_a = speed.alternate) != null ? _a : {})) {
+    for (const alt of entries) {
+      const e = speedEntry(mode, alt, false);
+      if (e) parts.push(e);
+    }
+  }
+  if (speed.choose) {
+    let t = `${speed.choose.amount} ft. ${speed.choose.from.join(" or ")}`;
+    if (speed.choose.note) t += ` ${speed.choose.note}`;
+    parts.push(t);
+  }
+  return parts.join(", ");
+}
+function speedNumber(speed, mode) {
+  const v = speed == null ? void 0 : speed[mode];
+  if (v === void 0 || v === null) return 0;
+  return typeof v === "number" ? v : v.number;
+}
+function qualifierText(q) {
+  var _a;
+  if (typeof q === "string") return capitalizeWords(q);
+  if (q.special !== void 0) return q.special;
+  const inner = ((_a = q.types) != null ? _a : []).map(qualifierText).join(", ");
+  let text = inner;
+  if (q.pre_note) text = `${q.pre_note} ${text}`;
+  if (q.note) text = `${text} ${q.note}`;
+  return text;
+}
+function formatQualifiers(list) {
+  return (list != null ? list : []).map(qualifierText);
+}
+function qualifierStrings(list) {
+  return (list != null ? list : []).filter((q) => typeof q === "string");
+}
+var INITIATIVE_MODES = { advantage: "advantage", adv: "advantage", disadvantage: "disadvantage", dis: "disadvantage" };
+function formatInitiative(initiative, abilities, pb) {
+  var _a;
+  if (initiative === void 0 || initiative === null) return void 0;
+  const dex = abilities ? abilityModifier(abilities.dex) : 0;
+  const bonus = typeof initiative === "number" ? initiative : dex + ((_a = initiative.proficiency) != null ? _a : 0) * pb;
+  const sign = bonus >= 0 ? `+${bonus}` : `${bonus}`;
+  let text = `${sign} (${10 + bonus})`;
+  const mode = typeof initiative === "number" ? void 0 : initiative.advantage_mode;
+  if (mode && INITIATIVE_MODES[mode]) text += ` (${INITIATIVE_MODES[mode]})`;
+  return text;
+}
+function itemName(uid) {
+  return capitalizeWords(uid.split("|")[0]);
+}
+function formatGear(gear) {
+  return (gear != null ? gear : []).map((g) => {
+    var _a;
+    if (typeof g === "string") return itemName(g);
+    const name = (_a = g.displayName) != null ? _a : itemName(g.item);
+    return g.quantity !== void 0 && g.quantity > 1 ? `${name} \xD7 ${g.quantity}` : name;
+  }).join(", ");
+}
+function formatLanguages(list) {
+  return (list != null ? list : []).map((entry) => entry.replace(/([\d,]*\d[\d,]*\s+)?\b(\w)/g, (m, amount, ch) => amount ? m : ch.toUpperCase())).join(", ");
+}
+var SKILL_DISPLAY = new Map(ALL_SKILLS.map((s) => [s.toLowerCase(), s]));
+function skillDisplayName(key) {
+  var _a;
+  return (_a = SKILL_DISPLAY.get(key.replace(/[_-]+/g, " ").trim().toLowerCase())) != null ? _a : capitalizeWords(key);
+}
+function formatSkillsOther(list) {
+  if (!list || list.length === 0) return void 0;
+  const parts = [];
+  for (const entry of list) {
+    const oneOf = entry == null ? void 0 : entry.one_of;
+    if (!oneOf) continue;
+    parts.push(Object.entries(oneOf).map(([k, v]) => `${skillDisplayName(k)} ${String(v)}`).join(", "));
+  }
+  return parts.length > 0 ? `plus one of: ${parts.join("; ")}` : void 0;
+}
+function shortNameOfNamed(name) {
+  return name.includes(",") ? name.split(",")[0].trim() : name;
+}
+function legendaryIntro(m, count) {
+  const subject = m.is_named_creature ? typeof m.short_name === "string" ? m.short_name : m.short_name === void 0 ? shortNameOfNamed(m.name) : m.name : `the ${m.name.toLowerCase()}`;
+  const Subject = m.is_named_creature ? subject : `The ${m.name.toLowerCase()}`;
+  const lair = m.legendary_actions_lair_count !== void 0 ? ` (${m.legendary_actions_lair_count} in its lair)` : "";
+  return `${Subject} can take ${count} legendary actions${lair}, choosing from the options below. Only one legendary action option can be used at a time and only at the end of another creature's turn. ${Subject} regains spent legendary actions at the start of its turn.`;
+}
+function sectionHeader(m, section) {
+  var _a;
+  const entry = ((_a = m.section_headers) != null ? _a : []).find((h) => h.section === section);
+  if (entry) return entry.header;
+  if (section === "mythic" && m.mythic_header && m.mythic_header.length > 0) return m.mythic_header;
+  return void 0;
+}
+var DISPLAY_AS_SECTION = {
+  action: "actions",
+  bonus: "bonus_actions",
+  reaction: "reactions",
+  legendary: "legendary_actions"
+};
+function displayAsSection(displayAs) {
+  return displayAs !== void 0 && DISPLAY_AS_SECTION[displayAs] || "traits";
+}
+var GROUP_ORDER = ["will", "daily", "rest", "restLong", "recharge", "legendary", "charges", "ritual"];
+var SPELLCASTING_LABELS = {
+  will: { plain: "At Will:" },
+  daily: { plain: "N/Day:", each: "N/Day Each:" },
+  rest: { plain: "N/Rest:", each: "N/Rest Each:" },
+  restLong: { plain: "N/Long Rest:", each: "N/Long Rest Each:" },
+  recharge: { plain: "Recharge N-6:", six: "Recharge 6:" },
+  legendary: { plain: "N/Legendary Action:", each: "N/Legendary Action Each:" },
+  charges: { plain: "N Charges", each: "N Charges Each" },
+  ritual: { plain: "Rituals:" }
+};
+function spellText(e) {
+  if (typeof e === "string") return e;
+  if (!e || typeof e !== "object") return void 0;
+  return e.hidden ? void 0 : e.entry;
+}
+function spellsOf(list) {
+  return (Array.isArray(list) ? list : []).map(spellText).filter((s) => s !== void 0).join(", ");
+}
+function sortedKeys(record) {
+  return Object.keys(record).sort((a, b) => {
+    const na = parseInt(a, 10), nb = parseInt(b, 10);
+    if (na !== nb) return nb - na;
+    return (a.endsWith("e") ? 1 : 0) - (b.endsWith("e") ? 1 : 0);
+  });
+}
+function ordinal(n) {
+  var _a, _b;
+  const s = ["th", "st", "nd", "rd"], v = n % 100;
+  return `${n}${(_b = (_a = s[(v - 20) % 10]) != null ? _a : s[v]) != null ? _b : s[0]}`;
+}
+function spellcastingLines(block) {
+  var _a, _b, _c, _d;
+  const hidden = new Set(Array.isArray(block.hidden) ? block.hidden : []);
+  const lines = Array.isArray(block.headerEntries) ? [...block.headerEntries] : [];
+  for (const group of GROUP_ORDER) {
+    if (hidden.has(group)) continue;
+    const label = SPELLCASTING_LABELS[group];
+    if (group === "will" || group === "ritual") {
+      const s = spellsOf(group === "will" ? block.will : block.ritual);
+      if (s) lines.push(`${label.plain} ${s}`);
+      continue;
+    }
+    if (group === "recharge") {
+      for (const k of sortedKeys((_a = block.recharge) != null ? _a : {})) {
+        const s = spellsOf(block.recharge[k]);
+        if (!s) continue;
+        lines.push(`${(k === "6" ? (_b = label.six) != null ? _b : label.plain : label.plain).replace("N", k)} ${s}`);
+      }
+      continue;
+    }
+    const record = (_c = block[group]) != null ? _c : {};
+    for (const k of sortedKeys(record)) {
+      const s = spellsOf(record[k]);
+      if (!s) continue;
+      const text = (k.endsWith("e") ? (_d = label.each) != null ? _d : label.plain : label.plain).replace("N", String(parseInt(k, 10)));
+      lines.push(group === "charges" ? `${text}${block.chargesItem ? ` (${block.chargesItem})` : ""}: ${s}` : `${text} ${s}`);
+    }
+  }
+  if (!hidden.has("spells") && block.spells) {
+    const levelKeys = Object.keys(block.spells).filter((k) => String(Number(k)) === k).sort((a, b) => Number(a) - Number(b));
+    for (const key of levelKeys) {
+      const level = block.spells[key];
+      if (!level || !Array.isArray(level.spells)) continue;
+      const lvl = Number(key);
+      const s = level.spells.join(", ");
+      if (!s) continue;
+      if (lvl === 0) {
+        lines.push(`Cantrips (At Will): ${s}`);
+        continue;
+      }
+      const plural2 = level.slots === 1 ? "Slot" : "Slots";
+      const slots = level.slots !== void 0 ? level.lower !== void 0 ? `${level.slots} ${ordinal(level.lower)}-Level ${plural2}` : `${level.slots} ${plural2}` : void 0;
+      lines.push(`${ordinal(lvl)} Level${slots ? ` (${slots})` : ""}: ${s}`);
+    }
+  }
+  if (Array.isArray(block.footerEntries)) lines.push(...block.footerEntries);
+  return lines;
+}
+function inline(v) {
+  if (typeof v === "string") return v;
+  if (Array.isArray(v)) return v.map(inline).filter(Boolean).join(" ");
+  if (v && typeof v === "object") {
+    const n = v;
+    const parts = [];
+    if (typeof n.name === "string") parts.push(`**${n.name}.**`);
+    if (n.entry !== void 0) parts.push(inline(n.entry));
+    if (n.entries !== void 0) parts.push(inline(n.entries));
+    if (n.items !== void 0) parts.push(inline(n.items));
+    return parts.join(" ");
+  }
+  return v === void 0 || v === null ? "" : String(v);
+}
+function blocksOf(v) {
+  if (typeof v === "string") return [v];
+  if (Array.isArray(v)) return v.flatMap(blocksOf);
+  if (!v || typeof v !== "object") return [];
+  const n = v;
+  const type = typeof n.type === "string" ? n.type : "entries";
+  switch (type) {
+    case "entries":
+    case "section": {
+      const body = blocksOf(n.entries);
+      if (typeof n.name === "string" && body.length > 0) body[0] = `**${n.name}.** ${body[0]}`;
+      else if (typeof n.name === "string") body.push(`**${n.name}.**`);
+      return body;
+    }
+    case "list": {
+      const items = Array.isArray(n.items) ? n.items : [];
+      return [items.map((it) => `- ${inline(it)}`).join("\n")];
+    }
+    case "item":
+      return [inline(n)];
+    case "table": {
+      const out = [];
+      if (typeof n.caption === "string") out.push(`**${n.caption}**`);
+      const cell = (v2) => inline(v2).replace(/\\?\|/g, "\\|");
+      const styles = Array.isArray(n.colStyles) ? n.colStyles.map((x) => String(x)) : [];
+      const alignment = (i) => {
+        var _a;
+        const s = (_a = styles[i]) != null ? _a : "";
+        if (/\btext-center\b/.test(s)) return ":---:";
+        if (/\btext-right\b/.test(s)) return "---:";
+        return "---";
+      };
+      const cols = Array.isArray(n.colLabels) ? n.colLabels.map(cell) : [];
+      const rows = Array.isArray(n.rows) ? n.rows : [];
+      const table = [`| ${cols.join(" | ")} |`, `| ${cols.map((_, i) => alignment(i)).join(" | ")} |`];
+      for (const r of rows) table.push(`| ${(Array.isArray(r) ? r : [r]).map(cell).join(" | ")} |`);
+      out.push(table.join("\n"));
+      return out;
+    }
+    case "inset":
+    case "variant":
+    case "variantInner":
+    case "variantSub": {
+      const body = blocksOf(n.entries).map((b) => b.split("\n").map((l) => `> ${l}`).join("\n"));
+      const head = typeof n.name === "string" ? [`> **${n.name}**`] : [];
+      return [[...head, ...body].join("\n>\n")];
+    }
+    case "spellcasting":
+      return [spellcastingLines(n).join("\n")];
+    default:
+      return [...blocksOf(n.entries), ...blocksOf(n.items), ...blocksOf(n.entry)];
+  }
+}
+function entriesToMarkdown(tree) {
+  return blocksOf(tree).filter((b) => b.length > 0).join("\n\n");
+}
+
+export {
+  capitalizeWords,
+  capitalizeOutsideLinks,
+  SIZE_CODES,
+  formatSize,
+  sizeWord,
+  ALIGNMENT_CODES,
+  ALIGNMENT_SETS,
+  formatAlignment,
+  alignmentWords,
+  IRREGULAR_PLURALS,
+  formatType,
+  formatCR,
+  formatXP,
+  crString,
+  challengeLine,
+  formatAC,
+  formatHP,
+  SPEED_MODES,
+  formatSpeed,
+  speedNumber,
+  formatQualifiers,
+  qualifierStrings,
+  INITIATIVE_MODES,
+  formatInitiative,
+  formatGear,
+  formatLanguages,
+  skillDisplayName,
+  formatSkillsOther,
+  legendaryIntro,
+  sectionHeader,
+  DISPLAY_AS_SECTION,
+  displayAsSection,
+  SPELLCASTING_LABELS,
+  spellcastingLines,
+  entriesToMarkdown
+};

package/dist/chunk-4FWNK4FD.js

@@ -0,0 +1,159 @@
+import {
+  durationSchema
+} from "./chunk-WYGD2UGN.js";
+import {
+  actionCostEnum,
+  resourceConsumptionSchema,
+  resourceSchema
+} from "./chunk-YLL2QXY2.js";
+import {
+  choiceSchema
+} from "./chunk-T26ZVCL5.js";
+import {
+  featureEffectSchema
+} from "./chunk-WPWOHGPI.js";
+
+// src/schemas/feature-schema.ts
+import { z as z2 } from "zod";
+
+// src/schemas/attack-schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var attackSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["melee", "ranged", "spell"]),
+  ability: z.union([abilityEnum, z.array(abilityEnum).nonempty()]).optional(),
+  damage: z.string().optional(),
+  damage_type: z.string().optional(),
+  action: z.enum(["action", "bonus-action", "reaction"]).optional(),
+  properties: z.array(z.string()).optional(),
+  range: z.object({
+    normal: z.number().int().nonnegative().optional(),
+    long: z.number().int().nonnegative().optional(),
+    reach: z.number().int().nonnegative().optional()
+  }).optional(),
+  condition: z.string().optional(),
+  // R4-G6 §5: declared on the `Attack` interface since the monster port, stripped by this schema until now.
+  // Monsters are the only carriers (8,176 bonuses, 1,796 extra-damage riders in the converter corpus).
+  bonus: z.number().optional(),
+  extra_damage: z.object({ dice: z.string(), type: z.string() }).optional()
+});
+
+// src/schemas/feature-schema.ts
+var companionSchema = z2.object({
+  statblock: z2.string().optional(),
+  statblock_wikilink: z2.string().nullable().optional(),
+  count: z2.string().optional(),
+  count_scaling: z2.array(z2.object({
+    level: z2.number().optional(),
+    count: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  shares_action_economy: z2.boolean().optional(),
+  turn_order: z2.string().optional(),
+  turn_order_source_quote: z2.string().nullable().optional(),
+  proficiency_bonus_scaled: z2.array(z2.object({
+    stat: z2.string().optional(),
+    formula: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  lifecycle: z2.object({
+    created_by: z2.string().optional(),
+    recreate_on: z2.string().nullable().optional(),
+    previous_instance_perishes: z2.boolean().nullable().optional(),
+    vanishes_if_owner_dies: z2.boolean().nullable().optional(),
+    vanishes_after: z2.string().nullable().optional(),
+    source_quote: z2.string().optional()
+  }).nullable().optional(),
+  autonomy: z2.object({
+    when: z2.string().optional(),
+    behaviour: z2.string().optional(),
+    source_quote: z2.string().optional()
+  }).nullable().optional(),
+  variants: z2.array(z2.object({
+    axis: z2.string().optional(),
+    choices: z2.array(z2.string()).optional(),
+    chosen_at: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  base_statblock: z2.string().nullable().optional(),
+  overrides: z2.array(z2.object({
+    field: z2.string().optional(),
+    value: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  source_quote: z2.string().optional()
+});
+var featureObjectSchema = z2.lazy(
+  () => z2.object({
+    id: z2.string().min(1).optional(),
+    name: z2.string().min(1),
+    description: z2.string().optional(),
+    entries: z2.array(z2.string()).optional(),
+    choices: z2.array(choiceSchema).optional(),
+    grants_resource: z2.string().optional(),
+    consumes: resourceConsumptionSchema.optional(),
+    attacks: z2.array(attackSchema).optional(),
+    action: z2.enum(["action", "bonus-action", "reaction", "free", "special"]).optional(),
+    trigger: z2.string().optional(),
+    dc_formula: z2.string().optional(),
+    effects: z2.array(featureEffectSchema).optional(),
+    sub_features: z2.array(featureSchemaTyped).optional(),
+    resources: z2.array(resourceSchema).optional(),
+    // Phase 3 activatable buffs: a feature flagged `activatable` folds its effects
+    // only while its id is present in state.active_buffs. `passive` renders a tag;
+    // `duration` is a static label (no live countdown this phase).
+    activatable: z2.boolean().optional(),
+    passive: z2.boolean().optional(),
+    duration: durationSchema.optional(),
+    // Converter feature-level keys (164 census strip rows, class 80 + subclass 84; counts per finding 2):
+    class_source: z2.string().min(1).optional(),
+    // class 646 + subclass 1616 leaves
+    rendering_hint: z2.string().optional(),
+    // always "" — NEVER .min(1)
+    subclass_short_name: z2.string().min(1).optional(),
+    // 1616
+    subclass_source: z2.string().min(1).optional(),
+    // 1616
+    header: z2.number().optional(),
+    // 1,237 carriers, ALL numbers
+    is_class_feature_variant: z2.boolean().optional(),
+    gain_subclass_feature: z2.boolean().optional(),
+    gain_subclass_feature_has_content: z2.boolean().optional(),
+    type: z2.string().min(1).optional(),
+    // values {"inset","item"}
+    recharge: z2.object({
+      // ONE class doc (UA Mystic), FOUR features, ALL
+      type: z2.enum(["recharge_on_roll", "per_day", "per_short_rest", "per_long_rest"]),
+      // {type:"per_day",param:1..4}
+      param: z2.number()
+      // tree-wide nested-recharge type census: exactly these
+    }).optional(),
+    // four members (gate1-r1 f9) = the EXISTING FeatureRecharge type
+    // SRD-BUNDLE-side keys (the converter emits NEITHER at feature level; finding 14 — our own
+    // generator emits them and featureSchema strips them, losing the SRD Dragonborn Breath Weapon's
+    // action cost and save DC). MAPPED since R4-G3a §10: `action_cost` is aliased onto `action` by
+    // the race / class / subclass parsers, and `save` renders as the feature card's Save line
+    // (`dc_formula` is echoed as TEXT, never evaluated).
+    action_cost: actionCostEnum.optional(),
+    // ONE vocabulary, imported from schemas/resource-schema
+    // (no cycle: resource-schema imports neither; two spellings of a closed enum is the G1a
+    // "fifth enum consumer" drift — gate1-r2 NEW-12)
+    save: z2.object({ ability: z2.string().min(1), dc_formula: z2.string().min(1) }).optional(),
+    // R4-G5 §7 (ruling G5-UR2): DECLARED so the class / subclass / race parsers stop stripping it on the day the
+    // G7 re-emit lands. The converter withholds it today (`P9_NOT_EMITTED_FIELDS`), so 0 converted and 0 bundle
+    // documents carry it and the census cannot see this key in either state (§12.1); the 47-block cache
+    // round-trip in `tests/feature-schema-widening.test.ts` is its instrument.
+    companion: companionSchema.optional()
+  })
+);
+var featureSchemaTyped = featureObjectSchema.refine(
+  (f) => f.description !== void 0 || f.entries !== void 0 && f.entries.length > 0,
+  { message: "feature requires either description or non-empty entries" }
+);
+var featureSchema = featureSchemaTyped;
+
+export {
+  featureObjectSchema,
+  featureSchema
+};

package/dist/chunk-4U55VNC7.js

@@ -0,0 +1,22 @@
+// src/schemas/feature-alias.ts
+function aliasFeatureActionCost(f) {
+  if (f.action === void 0 && typeof f.action_cost === "string") f.action = f.action_cost;
+}
+function aliasFeatureListActionCost(list) {
+  if (Array.isArray(list)) {
+    for (const f of list) if (f && typeof f === "object") aliasFeatureActionCost(f);
+  }
+}
+function aliasFeaturesByLevelActionCost(byLevel) {
+  if (byLevel && typeof byLevel === "object")
+    for (const list of Object.values(byLevel)) aliasFeatureListActionCost(list);
+}
+function withResolvedActionCost(f) {
+  return f.action === void 0 && typeof f.action_cost === "string" ? { ...f, action: f.action_cost } : f;
+}
+
+export {
+  aliasFeatureListActionCost,
+  aliasFeaturesByLevelActionCost,
+  withResolvedActionCost
+};

package/dist/{chunk-4JHOHWBI.js → chunk-4XTNPNQB.js}

@@ -1,6 +1,6 @@
 import {
   parseItem
-} from "./chunk-7VJ6BOA5.js";
+} from "./chunk-SMLXZUBH.js";
 
 // src/item/item.codec.ts
 import yaml from "js-yaml";