@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/chunk-O4SRD3J5.js

@@ -0,0 +1,165 @@
+import {
+  derivePoolLayout
+} from "./chunk-PP2UHLBA.js";
+import {
+  readTableColumn
+} from "./chunk-IUAAXXNO.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  bareEntitySlug,
+  wikilinkTailSlug
+} from "./chunk-6X4KUDMU.js";
+
+// src/pc/pc.pools.ts
+function levelPrereqMax(d) {
+  var _a;
+  return ((_a = d.prerequisites) != null ? _a : []).filter((p) => p.kind === "level").reduce((m, p) => Math.max(m, p.min), 0);
+}
+function resolvePool(rc, classIndex, pool, registry, index) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const entity = rc.entity;
+  const level = rc.level;
+  const ownerBare = bareEntitySlug(entity.slug);
+  const ownerPrefix = entity.slug.split("_")[0];
+  const col = pool.count.column;
+  const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
+  let anchorLevel = 1;
+  let columnSeen = false;
+  for (let l = 1; l <= 20; l++) {
+    const c = readTableColumn(entity.table, l, [col]);
+    if (c != null) columnSeen = true;
+    if (c != null && c >= 1) {
+      anchorLevel = l;
+      break;
+    }
+  }
+  if (!columnSeen) {
+    warnOnce(
+      `pool-column:${pool.id}`,
+      `Archivist: pool "${pool.id}" declares count column "${col}", which "${entity.slug}"'s class table carries at no level; the pool resolves count 0 at anchor level 1`
+    );
+  }
+  const ft = pool.source.where.feature_type;
+  const all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY).slice().sort((a, b) => a.name.localeCompare(b.name) || a.slug.localeCompare(b.slug));
+  const byBare = /* @__PURE__ */ new Map();
+  const candidates = /* @__PURE__ */ new Map();
+  for (const e of all) {
+    const d = e.data;
+    const entry = { slug: e.slug, entity: d, ...e.compendium ? { compendium: e.compendium } : {} };
+    const bare = bareEntitySlug(e.slug);
+    byBare.set(bare, entry);
+    if (d.feature_type !== ft) continue;
+    if (!((_b = d.available_to) != null ? _b : []).some((l) => wikilinkTailSlug(l) === ownerBare)) continue;
+    if (levelPrereqMax(d) > level) continue;
+    const group = candidates.get(bare);
+    if (group) group.push(entry);
+    else candidates.set(bare, [entry]);
+  }
+  const available = [];
+  for (const [bare, group] of candidates) {
+    if (group.length === 1) {
+      available.push(group[0]);
+      continue;
+    }
+    const owned = group.find((e) => e.slug.split("_")[0] === ownerPrefix);
+    if (!owned) {
+      warnOnce(
+        `pool-collapse:${bare}`,
+        `Archivist: pool "${pool.id}" holds ${group.length} cross-edition entries for "${bare}" and none shares the owner's compendium prefix "${ownerPrefix}"; keeping "${group[0].slug}"`
+      );
+    }
+    available.push(owned != null ? owned : group[0]);
+  }
+  const grantDecls = [
+    ...(_d = (_c = rc.entity) == null ? void 0 : _c.pool_grants) != null ? _d : [],
+    ...(_f = (_e = rc.subclass) == null ? void 0 : _e.pool_grants) != null ? _f : []
+  ];
+  const grantsRaw = grantDecls.filter((g) => g.pool === pool.id).flatMap((g) => g.grants).filter((g) => g.at_level <= level).map((g) => byBare.get(wikilinkTailSlug(g.feature))).filter((e) => e != null);
+  const grantedBare = /* @__PURE__ */ new Set();
+  const grants = grantsRaw.filter((e) => {
+    const key = bareEntitySlug(e.slug);
+    if (grantedBare.has(key)) return false;
+    grantedBare.add(key);
+    return true;
+  });
+  const bySlugAvailable = new Map(available.map((e) => [e.slug, e]));
+  const byBareAvailable = new Map(available.map((e) => [bareEntitySlug(e.slug), e]));
+  const resolveStored = (s) => {
+    const exact = bySlugAvailable.get(s);
+    if (exact) return exact;
+    const survivor = byBareAvailable.get(bareEntitySlug(s));
+    if (survivor) return survivor;
+    const full = registry.getByTypeAndSlug("optional-feature", s);
+    if (full) {
+      const d = full.data;
+      return { slug: full.slug, entity: d, ...full.compendium ? { compendium: full.compendium } : {} };
+    }
+    return byBare.get(bareEntitySlug(s));
+  };
+  const raw = (_g = rc.choices[anchorLevel]) == null ? void 0 : _g[pool.id];
+  const selectedSlugs = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+  const selected = [];
+  const seenBare = /* @__PURE__ */ new Set();
+  for (const s of selectedSlugs) {
+    const entry = resolveStored(s);
+    if (!entry) continue;
+    const bare = bareEntitySlug(entry.slug);
+    if (grantedBare.has(bare) || seenBare.has(bare)) continue;
+    seenBare.add(bare);
+    selected.push(entry);
+  }
+  const members = [...available, ...grants];
+  const layout = derivePoolLayout(members);
+  const votes = /* @__PURE__ */ new Map();
+  for (const e of members) {
+    const id = (_h = e.entity.consumes) == null ? void 0 : _h.resource;
+    if (!id || !index.has(id)) continue;
+    votes.set(id, ((_i = votes.get(id)) != null ? _i : 0) + 1);
+  }
+  let resource;
+  let bestN = 0;
+  for (const [id, n] of votes) if (n > bestN) {
+    resource = id;
+    bestN = n;
+  }
+  return {
+    id: pool.id,
+    label: pool.label,
+    classIndex,
+    count,
+    anchorLevel,
+    selected,
+    available,
+    grants,
+    ...layout ? { layout } : {},
+    ...resource ? { resource } : {}
+  };
+}
+function resolveAllPools(resolved, registry, index) {
+  const out = [];
+  resolved.classes.forEach((rc, classIndex) => {
+    var _a, _b, _c;
+    if (!rc.entity) return;
+    const decls = [...(_a = rc.entity.selection_pools) != null ? _a : [], ...(_c = (_b = rc.subclass) == null ? void 0 : _b.selection_pools) != null ? _c : []];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pool of decls) {
+      if (seen.has(pool.id)) continue;
+      seen.add(pool.id);
+      out.push(resolvePool(rc, classIndex, pool, registry, index));
+    }
+  });
+  return out;
+}
+function strandedPicks(pool) {
+  const inAvailable = new Set(pool.available.map((e) => e.slug));
+  return pool.selected.filter((e) => !inAvailable.has(e.slug));
+}
+
+export {
+  levelPrereqMax,
+  resolvePool,
+  resolveAllPools,
+  strandedPicks
+};

package/dist/chunk-OAXWSVJB.js

@@ -0,0 +1,81 @@
+import {
+  poolGrantSchema,
+  selectionPoolSchema,
+  tabDeclSchema
+} from "./chunk-23LZLBJK.js";
+import {
+  casterTypeEnum
+} from "./chunk-CJYCVNW2.js";
+import {
+  featureSchema
+} from "./chunk-W74BCA7V.js";
+import {
+  resourceSchema
+} from "./chunk-YLL2QXY2.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.js";
+
+// src/subclass/subclass.schema.ts
+import { z } from "zod";
+var editionEnum = z.enum(["2014", "2024"]);
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var spellcastingSchema = z.object({
+  caster_type: casterTypeEnum.optional(),
+  ability: abilityEnum,
+  preparation: z.enum(["known", "prepared"]).optional(),
+  spell_list: z.string().min(1).optional()
+});
+var subclassTableRowSchema = z.object({
+  columns: z.record(z.string(), z.union([z.string(), z.number()])).optional()
+});
+var subclassEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  parent_class: z.string().regex(wikilinkRegex, "parent_class must be a wikilink like [[rogue]]"),
+  edition: editionEnum,
+  source: z.string().min(1),
+  description: z.string(),
+  spellcasting: spellcastingSchema.nullable().optional(),
+  table: z.record(z.string(), subclassTableRowSchema).optional(),
+  features_by_level: z.record(z.string(), z.array(featureSchema)),
+  resources: z.array(resourceSchema),
+  selection_pools: z.array(selectionPoolSchema).optional(),
+  pool_grants: z.array(poolGrantSchema).optional(),
+  tabs: z.array(tabDeclSchema).optional(),
+  rendering_hint: z.string().optional(),
+  // 346
+  short_name: z.string().min(1).optional(),
+  // 346
+  has_fluff: z.boolean().optional(),
+  // 50
+  has_fluff_images: z.boolean().optional(),
+  // 346
+  fluff: z.unknown().optional(),
+  // 62 docs, single key-set {_subclassFluff:{...}} — 5etools-internal
+  table_col_labels: z.array(z.string().min(1)).optional(),
+  // 8
+  cantrip_progression: z.array(z.number()).optional(),
+  // 6
+  prepared_spells_change: z.string().min(1).optional(),
+  // 2
+  prepared_spells_progression: z.array(z.number()).optional(),
+  // 2
+  spells_known_progression: z.array(z.number()).optional(),
+  // 4
+  feat_progression: z.array(progressionSchema).optional(),
+  // 1
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 13 carriers; featureType
+  // on all 13, required on 2
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 212
+  image: imageField
+});
+
+export {
+  subclassEntitySchema
+};

package/dist/chunk-OZP6JFGT.js

@@ -0,0 +1,162 @@
+import {
+  spellEntitySchema
+} from "./chunk-VQAXTIBW.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",
+  // §2 · the fourteen converter keys. This gate and `spellEntitySchema` are independent: a key
+  // missing here is refused BEFORE zod ever sees it, so both must learn every new key.
+  "rendering_hint",
+  "misc_tags",
+  "area_tags",
+  "condition_inflict",
+  "affects_creature_type",
+  "spell_attack",
+  "ability_check",
+  "damage_resist",
+  "damage_immune",
+  "condition_immune",
+  "damage_vulnerable",
+  "has_fluff",
+  "image",
+  "has_fluff_images",
+  // Body-only metadata that's emitted to YAML but ignored at runtime — accept silently.
+  "slug",
+  "edition",
+  "source"
+]);
+var DURATION_END_WORDS = { dispel: "dispelled", trigger: "triggered" };
+function normalizeSpellComponents(value) {
+  if (typeof value === "string") return value;
+  if (value == null || typeof value !== "object" || Array.isArray(value)) return toStringSafe(value);
+  const c = value;
+  const parts = [];
+  if (c.v === true) parts.push("V");
+  if (c.s === true) parts.push("S");
+  if (typeof c.m === "string") parts.push(`M (${c.m})`);
+  else if (c.m === true) parts.push("M");
+  else if (c.m != null && typeof c.m === "object") {
+    const text = c.m.text;
+    parts.push(typeof text === "string" ? `M (${text})` : "M");
+  }
+  if (c.r === true) parts.push("R");
+  return parts.join(", ");
+}
+function normalizeSpellDurationEntry(entry) {
+  if (entry == null || typeof entry !== "object") return toStringSafe(entry);
+  const e = entry;
+  if (e.type === "permanent" && Array.isArray(e.ends)) {
+    return "until " + e.ends.map((w) => {
+      var _a;
+      return (_a = DURATION_END_WORDS[String(w)]) != null ? _a : String(w);
+    }).join(" or ");
+  }
+  if (e.type === "timed" && e.duration != null) {
+    const unit = e.duration.type;
+    const amount = e.duration.amount;
+    if (typeof unit === "string" && typeof amount === "number") {
+      const prefix = e.duration.up_to === true ? "up to " : "";
+      return `${prefix}${amount} ${unit}${amount > 1 ? "s" : ""}`;
+    }
+  }
+  return toStringSafe(entry);
+}
+function normalizeSpellDuration(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return toStringSafe(value);
+  return value.map((entry) => normalizeSpellDurationEntry(entry)).join("; ");
+}
+function mirrorSpellShapes(entity) {
+  return {
+    ...entity,
+    ...entity.components != null ? { components: normalizeSpellComponents(entity.components) } : {},
+    ...entity.duration != null ? { duration: normalizeSpellDuration(entity.duration) } : {}
+  };
+}
+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 = normalizeSpellComponents(raw.components);
+  if (raw.duration != null) spell.duration = normalizeSpellDuration(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 (raw.rendering_hint != null) spell.rendering_hint = raw.rendering_hint;
+  if (raw.misc_tags != null) spell.misc_tags = raw.misc_tags;
+  if (raw.area_tags != null) spell.area_tags = raw.area_tags;
+  if (raw.condition_inflict != null) spell.condition_inflict = raw.condition_inflict;
+  if (raw.affects_creature_type != null) spell.affects_creature_type = raw.affects_creature_type;
+  if (raw.spell_attack != null) spell.spell_attack = raw.spell_attack;
+  if (raw.ability_check != null) spell.ability_check = raw.ability_check;
+  if (raw.damage_resist != null) spell.damage_resist = raw.damage_resist;
+  if (raw.damage_immune != null) spell.damage_immune = raw.damage_immune;
+  if (raw.condition_immune != null) spell.condition_immune = raw.condition_immune;
+  if (raw.damage_vulnerable != null) spell.damage_vulnerable = raw.damage_vulnerable;
+  if (raw.has_fluff != null) spell.has_fluff = raw.has_fluff;
+  if (raw.image != null) spell.image = raw.image;
+  if (raw.has_fluff_images != null) spell.has_fluff_images = raw.has_fluff_images;
+  if (meta.source) spell.source = meta.source;
+  if (meta.edition) spell.edition = meta.edition;
+  return { success: true, data: spell };
+}
+
+export {
+  normalizeSpellComponents,
+  normalizeSpellDuration,
+  mirrorSpellShapes,
+  parseSpell
+};

package/dist/{chunk-NAEPSZAM.js → chunk-PDJSUH24.js}

@@ -2,8 +2,9 @@ import {
   ABILITY_KEYS,
   CR_PROFICIENCY,
   CR_XP,
+  DAMAGE_TYPES,
   SIZE_HIT_DICE
-} from "./chunk-WP2CX2JO.js";
+} from "./chunk-WELIKLZF.js";
 
 // src/dnd/math.ts
 function abilityModifier(score) {
@@ -68,6 +69,22 @@ function abilityNameToKey(name) {
   }
   return null;
 }
+var CANONICAL_DAMAGE_TYPES = new Set(DAMAGE_TYPES.map((t) => t.toLowerCase()));
+function isCanonicalDamageType(type) {
+  return CANONICAL_DAMAGE_TYPES.has(type.trim().toLowerCase());
+}
+var CHOSEN_DAMAGE_TYPE = "chosen";
+var CHOSEN_DAMAGE_TYPE_NOTE = "damage type of your choice";
+function isChosenDamageType(type) {
+  return type !== void 0 && type.trim().toLowerCase() === CHOSEN_DAMAGE_TYPE;
+}
+function isRenderableDamageText(text) {
+  var _a;
+  const m = /^(?:\d*d\d+(?:\s*[+-]\s*\d+)?|[+-]?\d+)(?:\s+(.*))?$/i.exec(text.trim());
+  if (!m) return false;
+  const type = ((_a = m[1]) != null ? _a : "").trim();
+  return type === "" || isCanonicalDamageType(type);
+}
 
 export {
   abilityModifier,
@@ -84,5 +101,10 @@ export {
   passivePerception,
   attackBonus,
   saveDC,
-  abilityNameToKey
+  abilityNameToKey,
+  isCanonicalDamageType,
+  CHOSEN_DAMAGE_TYPE,
+  CHOSEN_DAMAGE_TYPE_NOTE,
+  isChosenDamageType,
+  isRenderableDamageText
 };

package/dist/chunk-PP2UHLBA.js

@@ -0,0 +1,50 @@
+// src/pc/pool-layout.ts
+var RENDERING_HINT_LAYOUT = {
+  "dice-pool": "dice-pool",
+  "point-pool": "point-pool"
+};
+function derivePoolLayout(entries) {
+  var _a, _b;
+  const votes = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const hint = (_a = e.entity.rendering_hint) != null ? _a : "";
+    if (!Object.prototype.hasOwnProperty.call(RENDERING_HINT_LAYOUT, hint)) continue;
+    const layout = RENDERING_HINT_LAYOUT[hint];
+    votes.set(layout, ((_b = votes.get(layout)) != null ? _b : 0) + 1);
+  }
+  let best;
+  let bestN = 0;
+  let tied = false;
+  for (const [layout, n] of votes) {
+    if (n > bestN) {
+      best = layout;
+      bestN = n;
+      tied = false;
+    } else if (n === bestN) tied = true;
+  }
+  return tied ? void 0 : best;
+}
+var RENDERING_HINT_AFFORDANCE = {
+  "granted-die-to-ally": "granted-die"
+};
+function deriveEntryAffordance(entity) {
+  var _a;
+  const hint = (_a = entity.rendering_hint) != null ? _a : "";
+  if (!Object.prototype.hasOwnProperty.call(RENDERING_HINT_AFFORDANCE, hint)) return void 0;
+  return RENDERING_HINT_AFFORDANCE[hint];
+}
+var AFFORDANCE_CAPTIONS = {
+  "granted-die": "{amount}{die} to an ally"
+};
+function formatAffordanceCaption(affordance, values) {
+  return AFFORDANCE_CAPTIONS[affordance].replace(/\{(\w+)\}/g, (whole, key) => Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : whole);
+}
+
+export {
+  RENDERING_HINT_LAYOUT,
+  derivePoolLayout,
+  RENDERING_HINT_AFFORDANCE,
+  deriveEntryAffordance,
+  AFFORDANCE_CAPTIONS,
+  formatAffordanceCaption
+};

package/dist/chunk-PVCEA4HZ.js

@@ -0,0 +1,6 @@
+// src/race/race.structural.ts
+var RACE_STRUCTURAL_PSEUDO = /* @__PURE__ */ new Set(["size", "speed", "darkvision"]);
+
+export {
+  RACE_STRUCTURAL_PSEUDO
+};

package/dist/{chunk-RSDRMH54.js → chunk-RF4TYCA2.js}

@@ -1,6 +1,6 @@
 import {
   parseOptionalFeature
-} from "./chunk-4F6AIZ36.js";
+} from "./chunk-6BFWZW6T.js";
 
 // src/optional-feature/optional-feature.codec.ts
 import yaml from "js-yaml";

package/dist/chunk-RLGQ5PZZ.js

@@ -0,0 +1,16 @@
+// src/pc/pc.proficiency-normalize.ts
+var normKey = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).map((w) => w.endsWith("s") ? w.slice(0, -1) : w).sort().join(" ");
+var toProfSlug = (s) => s.toLowerCase().replace(/’/g, "'").trim().replace(/\s+/g, "-");
+var humanizeProficiency = (s) => s.replace(/-/g, " ").replace(/(^|\s)\w/g, (c) => c.toUpperCase());
+var proficiencyLabel = (raw) => {
+  const text = raw.replace(/’/g, "'").trim().replace(/\s+/g, " ");
+  if (!/\s/.test(text) || text === text.toLowerCase()) return humanizeProficiency(toProfSlug(raw));
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+
+export {
+  normKey,
+  toProfSlug,
+  humanizeProficiency,
+  proficiencyLabel
+};

package/dist/chunk-RVXC6ZHY.js

@@ -0,0 +1,89 @@
+import {
+  actionCostEnum,
+  resourceSchema
+} from "./chunk-YLL2QXY2.js";
+import {
+  choiceSchema
+} from "./chunk-IWRVOCT5.js";
+import {
+  featureEffectSchema
+} from "./chunk-X3D6LXUU.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.js";
+
+// src/feat/feat.schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var editionEnum = z.enum(["2014", "2024"]);
+var categoryEnum = z.enum(["origin", "general", "fighting-style", "epic-boon"]);
+var prerequisiteSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
+  z.object({ kind: z.literal("level"), min: z.number().int().positive() }),
+  z.object({ kind: z.literal("spellcaster") }),
+  z.object({
+    kind: z.literal("proficiency"),
+    proficiency_type: z.enum(["armor", "weapon", "tool", "skill", "saving-throw"]),
+    value: z.string().min(1)
+  }),
+  z.object({ kind: z.literal("race"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("class"), slug: z.string().min(1) }),
+  // The exclusive-feat-category and feat-category arms carry a raw 5etools category code, not a
+  // slug; featCategoryLabel names it. The rest carry slugs the renderer humanizes, except other,
+  // which carries free prose that prereqText returns verbatim.
+  z.object({ kind: z.literal("feat"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("campaign"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("exclusive-feat-category"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("feature"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("other"), detail: z.string().min(1) }),
+  z.object({ kind: z.literal("feat-category"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("background"), slug: z.string().min(1) })
+]);
+var featEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  edition: editionEnum,
+  source: z.string().min(1),
+  category: categoryEnum,
+  description: z.string(),
+  prerequisites: z.array(prerequisiteSchema),
+  benefits: z.array(z.string()),
+  effects: z.array(featureEffectSchema),
+  grants_asi: z.object({
+    amount: z.number().int().positive(),
+    pool: z.array(abilityEnum).optional()
+  }).nullable(),
+  repeatable: z.boolean(),
+  choices: z.array(choiceSchema),
+  rendering_hint: z.string().optional(),
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 71
+  has_fluff: z.boolean().optional(),
+  // 0 carriers — symmetry, §9.4
+  has_fluff_images: z.boolean().optional(),
+  // 41
+  trait_tags: z.unknown().optional(),
+  // 7, nullable measured — same passthrough family
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 4
+  resources: z.array(resourceSchema).optional(),
+  // closes the feat.types.ts `Feat.resources` schema/type asymmetry (C);
+  // ZERO converter/bundle carriers (no census row) — the only behaviour delta is AUTHORED feats,
+  // where the type has promised the field all along. Import resourceSchema.
+  action_cost: actionCostEnum.optional(),
+  // ruling R-G1b-5 (gate1-r1 f1): a TOP-LEVEL bundle key on ONE
+  // feat (`SRD 2024/Feats/Boon of the Night Spirit.md`, `action_cost: bonus-action` at entity top
+  // level) — the ninth SRD-control non-kept row: top-level on the ENTITY, not featureSchema-shaped
+  // (finding 14's nine rows split 4 featureSchema / 4 §2.8-arity / this one, which needed its own
+  // declaration — gate1-r4 R4-1). `actionCostEnum` is exported from
+  // `schemas/resource-schema.ts` (optionalFeatureEntitySchema already imports it). MAPPED since
+  // R4-G3a §10.2.3: the resolver aliases it onto the resolved feature's `action`, which is what
+  // draws the feat note's Action line and files the row under that economy.
+  image: imageField
+});
+
+export {
+  featEntitySchema
+};

package/dist/chunk-S7REMWW4.js

@@ -0,0 +1,21 @@
+// src/pc/conditions.constants.ts
+var CONDITION_SLUGS = [
+  "blinded",
+  "charmed",
+  "deafened",
+  "frightened",
+  "grappled",
+  "incapacitated",
+  "invisible",
+  "paralyzed",
+  "petrified",
+  "poisoned",
+  "prone",
+  "restrained",
+  "stunned",
+  "unconscious"
+];
+
+export {
+  CONDITION_SLUGS
+};

package/dist/{chunk-7VJ6BOA5.js → chunk-SMLXZUBH.js}

@@ -1,6 +1,6 @@
 import {
   itemEntitySchema
-} from "./chunk-K6Q5OUGK.js";
+} from "./chunk-GFZ7PITJ.js";
 
 // src/item/item.parser.ts
 import { parseYaml } from "@archivist-gg/core";
@@ -41,6 +41,14 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "scroll_level",
   "unidentified",
   "masked_category",
+  // Modelled top-level converter keys (spec §4). The schema declaring them is NOT
+  // enough: this set is the second, independent gate — a key missing here is
+  // copied into `raw` as well, so the two lists must move together.
+  "modify_speed",
+  "rendering_hint",
+  "has_fluff",
+  "has_fluff_images",
+  "image",
   // Legacy fields kept (removed in Slice 7 after grep verifies no consumer)
   "damage_dice",
   "damage_type",