@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/chunk-H7KBLR4X.js

@@ -0,0 +1,81 @@
+import {
+  poolGrantSchema,
+  selectionPoolSchema,
+  tabDeclSchema
+} from "./chunk-23LZLBJK.js";
+import {
+  casterTypeEnum
+} from "./chunk-CJYCVNW2.js";
+import {
+  featureSchema
+} from "./chunk-4FWNK4FD.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-L7E2UT5A.js → chunk-HB7XZXDK.js}

@@ -1,12 +1,16 @@
 import {
   subclassEntitySchema
-} from "./chunk-W7HWMMBF.js";
+} from "./chunk-H7KBLR4X.js";
+import {
+  aliasFeaturesByLevelActionCost
+} from "./chunk-4U55VNC7.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;
+  aliasFeaturesByLevelActionCost(raw.data.features_by_level);
   const result = subclassEntitySchema.safeParse({ edition: "2014", ...raw.data });
   if (!result.success) {
     return { success: false, error: `subclass schema validation failed: ${result.error.message}` };

package/dist/{chunk-BIK4DFWK.js → chunk-HJ5EEZ47.js}

@@ -1,6 +1,6 @@
 import {
   parseBackground
-} from "./chunk-5ZBE4CWV.js";
+} from "./chunk-LMBAEIP6.js";
 
 // src/background/background.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-6NK2MUD3.js → chunk-HZA7OE7N.js}

@@ -1,6 +1,6 @@
 import {
   weaponEntitySchema
-} from "./chunk-AFKTJXRA.js";
+} from "./chunk-2DFENQIJ.js";
 
 // src/weapon/weapon.parser.ts
 import { parseYaml } from "@archivist-gg/core";
@@ -21,7 +21,14 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "page",
   "edition",
   "entries",
-  "raw"
+  "raw",
+  // Root extras declared on weaponEntitySchema (spec §5). 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.
+  "rendering_hint",
+  "has_fluff",
+  "has_fluff_images",
+  "image"
 ]);
 var FLAG_PROPERTIES = /* @__PURE__ */ new Set([
   "finesse",

package/dist/{chunk-TN6ZLTNU.js → chunk-I2NDWFDD.js}

@@ -1,6 +1,6 @@
 import {
   CONDITION_SLUGS
-} from "./chunk-TZK36BU7.js";
+} from "./chunk-S7REMWW4.js";
 
 // src/pc/pc.schema.ts
 import { z } from "zod";
@@ -79,7 +79,7 @@ var equipmentEntrySchema = z.object({
   // finished file never carries it.
   granted_by: z.string().optional()
 });
-var characterOverridesSchema = z.object({
+var characterOverridesShape = z.object({
   scores: z.partialRecord(abilityEnum, z.number().int()).optional(),
   saves: z.partialRecord(abilityEnum, z.object({
     bonus: z.number().int().optional(),
@@ -107,8 +107,54 @@ var characterOverridesSchema = z.object({
   // Scroll cast by a non-caster). Same ability enum as the per-instance spell_ability.
   spellcasting_ability: abilityEnum.optional(),
   spell_slots: z.record(z.coerce.number().int(), z.number().int().nonnegative()).optional(),
-  attunement_limit: z.number().int().nonnegative().optional()
-}).default({});
+  attunement_limit: z.number().int().nonnegative().optional(),
+  /** Manual proficiency edits. `remove` SUPPRESSES a rules-granted entry ("a dwarf who doesn't know
+   *  dwarvish"). NOTHING here may carry a default, at either level, or an untouched note stops being
+   *  byte-identical:
+   *    - a `.default({})` on `languages`/`tools` materializes the key on every note that carries any
+   *      `overrides` block at all;
+   *    - a `.default([])` on `add`/`remove` materializes the sibling array whenever the parent key IS
+   *      present, which is every add-only entry the mutators write. (It cannot fire while the parent
+   *      is absent, but that is the uninteresting half of the case.)
+   *  That rule covers `tools.proficiency` too: no default at any of its three levels.
+   *  Every reader uses `?? []` (`?? {}` for the record). */
+  languages: z.object({ add: z.array(z.string()).optional(), remove: z.array(z.string()).optional() }).optional(),
+  tools: z.object({
+    add: z.array(z.string()).optional(),
+    remove: z.array(z.string()).optional(),
+    /** R4-G4 §9.3 (UR1): a per-tool tri. An OPEN key space (tool names are not an enum, unlike
+     *  `skillEnum` above); no `bonus` sibling, because tools have no numeric consumer. `expertise`
+     *  beats a data grant, `none` suppresses one, `proficient` clears a data expertise · applied in
+     *  `computeEffectiveProficiencies` (pc.decision-engine.ts). A key a WRITER CREATES is
+     *  `toProfSlug` output with the apostrophe RETAINED ("thieves'-tools"), matching the engine's
+     *  own tool vocabulary in types/choice.ts. The READER is wider: `computeEffectiveProficiencies`
+     *  normalises each key with `toProfSlug` on read, so a hand-typed "Thieves' Tools" also
+     *  matches; and the plugin's two writers (`CharacterEditState.setToolProficiency` and the
+     *  `addProficiency` clearance) match an existing key by slug too, so a key the note ALREADY
+     *  carries is written THROUGH in its own spelling rather than duplicated · nothing here
+     *  re-spells it (review M-4: "repaired in place" read as "normalised", which it is not).
+     *  `languages` gets no such sibling: languages have no tri (§9.3). */
+    proficiency: z.record(z.string(), proficiencyTri).optional()
+  }).optional(),
+  /** Manual defense edits. SUPPRESSION-ONLY, and the missing `add` channel is a DELIBERATE
+   *  asymmetry with `languages`/`tools` above · do not "complete the pattern". The additive
+   *  store is `character.defenses.*`, which already exists and works; a second additive
+   *  channel would recreate exactly the two-writers divergence R4-P5 exists to remove.
+   *  The schema persists what the note wrote, VERBATIM · it neither normalizes nor validates
+   *  the strings. As of this commit the store has NO consumer at all: Task 5 writes the first,
+   *  and the intent it is to implement is that entries be matched with `toDefenseSlug`
+   *  (pc.defense-normalize.ts), so a note may author any spelling.
+   *  The no-defaults rule of the block above applies here at all three levels: a default on
+   *  `defenses`, on a bucket, or on `remove` rewrites an untouched note. Readers should
+   *  therefore treat every level as possibly absent (`?? []`). */
+  defenses: z.object({
+    resistances: z.object({ remove: z.array(z.string()).optional() }).optional(),
+    immunities: z.object({ remove: z.array(z.string()).optional() }).optional(),
+    vulnerabilities: z.object({ remove: z.array(z.string()).optional() }).optional(),
+    condition_immunities: z.object({ remove: z.array(z.string()).optional() }).optional()
+  }).optional()
+});
+var characterOverridesSchema = characterOverridesShape.default({});
 var characterStateSchema = z.object({
   hp: z.object({
     current: z.number().int(),
@@ -249,5 +295,6 @@ var characterSchema = z.object({
 });
 
 export {
+  characterOverridesShape,
   characterSchema
 };

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

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

package/dist/{chunk-3DZ74AKK.js → chunk-IN4M4X7P.js}

@@ -1,8 +1,14 @@
 // src/schemas/equipment-grant-schema.ts
 import { z } from "zod";
 var equipmentGrantSchema = z.union([
-  z.object({ item: z.string().min(1), qty: z.number().int().positive().optional() }).strict(),
-  z.object({ category: z.string().min(1), qty: z.number().int().positive().optional() }).strict(),
+  z.object({
+    item: z.string().min(1),
+    qty: z.number().int().positive().optional(),
+    contains_value: z.number().int().nonnegative().optional(),
+    display_name: z.string().min(1).optional(),
+    worth_value: z.number().int().nonnegative().optional()
+  }).strict(),
+  z.object({ category: z.string().min(1), qty: z.number().int().positive().optional(), display_name: z.string().min(1).optional() }).strict(),
   z.object({ gold: z.number().int().positive() }).strict()
 ]);
 var equipmentOptionSchema = z.object({

package/dist/chunk-IUAAXXNO.js

@@ -0,0 +1,58 @@
+// 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;
+}
+var COUNT_COLUMNS = {
+  "weapon-mastery": ["Weapon Mastery"]
+};
+function countColumnsFor(choiceId) {
+  if (!Object.prototype.hasOwnProperty.call(COUNT_COLUMNS, choiceId)) return void 0;
+  return COUNT_COLUMNS[choiceId];
+}
+function diceColumnAt(table, level, key) {
+  var _a;
+  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
+  if (!cols || !Object.prototype.hasOwnProperty.call(cols, key)) return null;
+  const raw = cols[key];
+  if (typeof raw !== "string") return null;
+  const cell = raw.trim();
+  return /^\d+d\d+$/i.test(cell) ? cell : null;
+}
+var UNARMED_DIE_COLUMNS = {
+  "martial-arts": "Martial Arts"
+};
+function unarmedDieColumnFor(featureSlug) {
+  if (!Object.prototype.hasOwnProperty.call(UNARMED_DIE_COLUMNS, featureSlug)) return void 0;
+  return UNARMED_DIE_COLUMNS[featureSlug];
+}
+
+export {
+  readTableColumn,
+  numericColumnsAt,
+  COUNT_COLUMNS,
+  countColumnsFor,
+  diceColumnAt,
+  UNARMED_DIE_COLUMNS,
+  unarmedDieColumnFor
+};

package/dist/{chunk-XJNECUPT.js → chunk-JC5UNIVM.js}

@@ -1,3 +1,7 @@
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
 // src/armor/armor.schema.ts
 import { z } from "zod";
 var acSchema = z.object({
@@ -23,7 +27,22 @@ var armorEntitySchema = z.object({
   page: z.number().int().optional(),
   edition: z.string().optional(),
   entries: z.array(z.unknown()).optional(),
+  // Root extras the converter and the SRD bundle emit on more than one root (spec §5).
+  // Carrier counts measured on the G1b close census. `rendering_hint` is ALWAYS the empty
+  // string today, so `.min(1)` is forbidden here.
+  rendering_hint: z.string().optional(),
+  // 27
+  has_fluff: z.boolean().optional(),
+  // 0 carriers — symmetry with weapon
+  has_fluff_images: z.boolean().optional(),
+  // 13
+  // Already `.optional()` at its source — never append a second one.
+  image: imageField,
+  // 0 today (images-OFF tree)
   raw: z.record(z.string(), z.unknown()).optional()
+  // `.loose()` is load-bearing for the `strength_required` alias (armor.parser.ts): the alias
+  // rides through onto the typed output as an inert extra, which is what keeps its census
+  // disposal `kept` instead of minting a `stripped` row. See the parser's comment.
 }).loose();
 
 export {

package/dist/chunk-JJ46T5XX.js

@@ -0,0 +1,297 @@
+import {
+  normalizeRollScope
+} from "./chunk-TOM66P2P.js";
+import {
+  toProfSlug
+} from "./chunk-RLGQ5PZZ.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  bareEntitySlug
+} from "./chunk-6X4KUDMU.js";
+import {
+  normalizeAbility
+} from "./chunk-WELIKLZF.js";
+
+// src/pc/pc.feature-effects.ts
+function emptyFeatureEffectTotals() {
+  return {
+    initiative_bonus: 0,
+    hp_per_level_bonus: 0,
+    hp_per_level_terms: [],
+    speed_walk_bonus: 0,
+    speed_walk_set: 0,
+    ability_bonus: {},
+    senses: { darkvision: 0, blindsight: 0, tremorsense: 0, truesight: 0 },
+    ac_terms: [],
+    resistances: [],
+    immunities: [],
+    vulnerabilities: [],
+    condition_immunities: [],
+    proficiencies: { skills: [], skillExpertise: [], tools: [], languages: [], saves: [], armor: [], weapons: [] },
+    weaponAbilities: [],
+    rollModifiers: [],
+    saveOutcomes: [],
+    critRange: 20,
+    extraAttack: 0,
+    attackNotes: [],
+    damageBonuses: []
+  };
+}
+function pushUnique(list, value) {
+  const key = value.trim().toLowerCase();
+  if (!key) return;
+  if (!list.some((v) => v.trim().toLowerCase() === key)) list.push(value.trim());
+}
+function pushDefenseGrant(list, value, source, condition) {
+  const key = value.trim().toLowerCase();
+  if (!key) return;
+  const existing = list.find((g) => g.value.trim().toLowerCase() === key);
+  if (existing) {
+    if (!existing.sources.includes(source)) existing.sources.push(source);
+    if (!existing.condition && condition) existing.condition = condition;
+    return;
+  }
+  list.push({ value: value.trim(), sources: [source], ...condition ? { condition } : {} });
+}
+function foldsNow(rf, activeBuffs) {
+  if (rf.feature.activatable !== true) return true;
+  const id = rf.feature.id;
+  return !!id && activeBuffs.has(id);
+}
+function assembleEffectFeatures(resolved) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const activeBuffs = new Set((_b = (_a = resolved.state) == null ? void 0 : _a.active_buffs) != null ? _b : []);
+  const featureIds = new Set(((_c = resolved.features) != null ? _c : []).map((f) => f.feature.id).filter((id) => !!id));
+  const aliases = [];
+  for (const pool of (_d = resolved.pools) != null ? _d : []) {
+    for (const entry of [...(_e = pool.selected) != null ? _e : [], ...(_f = pool.grants) != null ? _f : []]) {
+      if (activeBuffs.has(entry.slug)) continue;
+      const bare = bareEntitySlug(entry.slug);
+      for (const stored of activeBuffs) {
+        if (featureIds.has(stored)) continue;
+        if (bareEntitySlug(stored) === bare) {
+          aliases.push(entry.slug);
+          break;
+        }
+      }
+    }
+  }
+  for (const a of aliases) activeBuffs.add(a);
+  const buffFeatures = [];
+  const pushBoon = (item, pool) => {
+    var _a2, _b2, _c2, _d2, _e2, _f2, _g2;
+    const e = item.entity;
+    if (!e || ((_b2 = (_a2 = e.effects) == null ? void 0 : _a2.length) != null ? _b2 : 0) === 0) return;
+    buffFeatures.push({
+      feature: { id: item.slug, name: e.name, activatable: (_c2 = e.activatable) != null ? _c2 : false, effects: e.effects },
+      // source is inert for the fold; attribute to the pool's owning class
+      // (never a hardcoded class) so the generic engine carries no homebrew name.
+      source: { kind: "class", slug: (_g2 = (_f2 = (_e2 = (_d2 = resolved.classes) == null ? void 0 : _d2[pool.classIndex]) == null ? void 0 : _e2.entity) == null ? void 0 : _f2.slug) != null ? _g2 : pool.id, level: pool.anchorLevel }
+    });
+  };
+  for (const pool of (_g = resolved.pools) != null ? _g : []) {
+    for (const sel of (_h = pool.selected) != null ? _h : []) pushBoon(sel, pool);
+    for (const g of (_i = pool.grants) != null ? _i : []) pushBoon(g, pool);
+  }
+  return { features: [...(_j = resolved.features) != null ? _j : [], ...buffFeatures], activeBuffs };
+}
+function foldsOnSelf(eff) {
+  if (eff.subject === void 0 || eff.subject === "self") return true;
+  warnOnce(eff.subject, `archivist: unrecognised effect subject "${eff.subject}" (only "self" folds)`);
+  return false;
+}
+function selfEffectsOf(f) {
+  var _a;
+  return ((_a = f.effects) != null ? _a : []).filter(foldsOnSelf);
+}
+function computeFeatureEffects(features, opts) {
+  var _a, _b, _c;
+  const out = emptyFeatureEffectTotals();
+  for (const rf of features) {
+    if (!foldsNow(rf, (_a = opts == null ? void 0 : opts.activeBuffs) != null ? _a : /* @__PURE__ */ new Set())) continue;
+    const level = (_b = opts == null ? void 0 : opts.levelFor) == null ? void 0 : _b.call(opts, rf.source);
+    for (const eff of selfEffectsOf(rf.feature)) {
+      applyEffect(out, eff, (_c = rf.feature.name) != null ? _c : "Feature", level);
+    }
+  }
+  return out;
+}
+function classifyProficiencyEffect(eff) {
+  if (eff.kind !== "proficiency") return null;
+  const raw = eff.value;
+  const expertise = eff.expertise === true;
+  switch (eff.proficiency_type) {
+    case "skill":
+      return { bucket: "skills", value: toProfSlug(raw), raw, expertise };
+    case "tool":
+      return { bucket: "tools", value: toProfSlug(raw), raw, expertise };
+    case "language":
+      return { bucket: "languages", value: toProfSlug(raw), raw, expertise };
+    case "armor":
+      return { bucket: "armor", value: raw.toLowerCase(), raw, expertise };
+    case "weapon":
+      return { bucket: "weapons", value: raw.toLowerCase(), raw, expertise };
+    default: {
+      const ab = normalizeAbility(raw);
+      return ab ? { bucket: "saves", value: ab, raw, expertise } : null;
+    }
+  }
+}
+function collectProficiencyEffectGrants(features, activeBuffs) {
+  const out = {
+    skills: [],
+    tools: [],
+    languages: [],
+    saves: [],
+    armor: [],
+    weapons: []
+  };
+  for (const rf of features) {
+    if (!foldsNow(rf, activeBuffs)) continue;
+    for (const eff of selfEffectsOf(rf.feature)) {
+      const c = classifyProficiencyEffect(eff);
+      if (!c) continue;
+      out[c.bucket].push({
+        value: c.value,
+        raw: c.raw,
+        sourceKind: rf.source.kind,
+        sourceSlug: rf.source.slug,
+        ...c.expertise ? { expertise: true } : {}
+      });
+    }
+  }
+  return out;
+}
+function scaled(base, key, scalesAt, level) {
+  if (level === void 0 || !(scalesAt == null ? void 0 : scalesAt.length)) return base;
+  let best = base;
+  let bestLevel = -1;
+  for (const step of scalesAt) {
+    if (step.level > level || step.level <= bestLevel) continue;
+    const v = step[key];
+    if (typeof v !== "number") continue;
+    best = v;
+    bestLevel = step.level;
+  }
+  return best;
+}
+function applyEffect(out, eff, label, level) {
+  var _a, _b, _c, _d, _e;
+  switch (eff.kind) {
+    case "initiative-bonus":
+      out.initiative_bonus += eff.value;
+      break;
+    case "hp-per-level-bonus":
+      out.hp_per_level_bonus += eff.value;
+      out.hp_per_level_terms.push({ label, value: eff.value });
+      break;
+    case "speed-bonus": {
+      const value = scaled(eff.value, "value", eff.scales_at, level);
+      if (eff.mode === "walk") {
+        if (eff.set) out.speed_walk_set = Math.max(out.speed_walk_set, value);
+        else out.speed_walk_bonus += value;
+      }
+      break;
+    }
+    case "sense":
+      out.senses[eff.type] = Math.max(out.senses[eff.type], eff.range);
+      break;
+    case "resistance":
+      pushDefenseGrant(out.resistances, eff.damage_type, label, eff.condition);
+      break;
+    case "immunity":
+      pushDefenseGrant(out.immunities, eff.damage_type, label, eff.condition);
+      break;
+    case "vulnerability":
+      pushDefenseGrant(out.vulnerabilities, eff.damage_type, label, eff.condition);
+      break;
+    case "immune-condition":
+      if (!eff.while) pushDefenseGrant(out.condition_immunities, eff.condition, label);
+      break;
+    case "proficiency": {
+      const c = classifyProficiencyEffect(eff);
+      if (!c) break;
+      if (c.bucket === "saves") {
+        pushUnique(out.proficiencies.saves, c.value);
+      } else {
+        pushUnique(out.proficiencies[c.bucket], c.value);
+      }
+      if (c.expertise && c.bucket === "skills") pushUnique(out.proficiencies.skillExpertise, c.value);
+      break;
+    }
+    case "ac-bonus":
+      out.ac_terms.push({
+        value: eff.value,
+        requires_armor: eff.requires_armor === true,
+        label,
+        condition: eff.condition
+      });
+      break;
+    case "weapon-ability": {
+      if (eff.ability !== "spellcasting") {
+        const w = eff.weapons;
+        const weaponSlugs = !w || w === "chosen" ? void 0 : Array.isArray(w) ? w.map(bareEntitySlug) : [bareEntitySlug(w)];
+        out.weaponAbilities.push({ ability: eff.ability, weaponSlugs });
+      }
+      break;
+    }
+    case "roll-modifier": {
+      const rolls = eff.roll === "any" ? ["ability-check", "saving-throw", "attack"] : [eff.roll];
+      const scopes = (_a = normalizeRollScope(eff.scope, rolls[0])) != null ? _a : [eff.scope];
+      for (const roll of rolls) for (const scope of scopes)
+        out.rollModifiers.push({ mode: eff.mode, roll, scope, condition: eff.condition, label });
+      break;
+    }
+    case "save-outcome":
+      out.saveOutcomes.push({
+        ability: eff.ability === "any" ? void 0 : eff.ability,
+        on_success: eff.on_success,
+        on_failure: eff.on_failure,
+        appliesTo: (_b = eff.applies_to) != null ? _b : void 0,
+        condition: eff.condition,
+        label
+      });
+      break;
+    case "crit-range":
+      if (((_c = eff.applies_to) != null ? _c : "weapon") !== "spell") out.critRange = Math.min(out.critRange, eff.min_roll);
+      break;
+    case "extra-attack":
+      out.extraAttack = Math.max(out.extraAttack, scaled(eff.count, "count", eff.scales_at, level));
+      break;
+    case "reroll-damage":
+      out.attackNotes.push(`Reroll ${eff.max_reroll}s${eff.once_per_die ? " (once/die)" : ""}`);
+      break;
+    case "attack-rule":
+      if (eff.flag === "no-ranged-in-melee-disadvantage") out.attackNotes.push("No disadvantage firing in melee");
+      break;
+    case "damage-bonus":
+      if (((_d = eff.applies_to) != null ? _d : "weapon") !== "spell") {
+        out.damageBonuses.push({
+          amount: eff.amount,
+          damage_type: eff.damage_type,
+          source: label,
+          ...eff.condition ? { condition: eff.condition } : {}
+        });
+      }
+      break;
+    case "ability-score-increase":
+      if (eff.abilities === "chosen") break;
+      for (const ab of eff.abilities) out.ability_bonus[ab] = ((_e = out.ability_bonus[ab]) != null ? _e : 0) + eff.amount;
+      break;
+    default:
+      break;
+  }
+}
+
+export {
+  emptyFeatureEffectTotals,
+  foldsNow,
+  assembleEffectFeatures,
+  foldsOnSelf,
+  selfEffectsOf,
+  computeFeatureEffects,
+  classifyProficiencyEffect,
+  collectProficiencyEffectGrants
+};

package/dist/{chunk-SE7AZDR3.js → chunk-JRDPUDT5.js}

@@ -1,9 +1,13 @@
 import {
   startingEquipmentEntrySchema
-} from "./chunk-3DZ74AKK.js";
+} from "./chunk-IN4M4X7P.js";
 import {
   choiceSchema
-} from "./chunk-NXSWH3AE.js";
+} from "./chunk-T26ZVCL5.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField
+} from "./chunk-UA5KS2PL.js";
 
 // src/background/background.schema.ts
 import { z } from "zod";
@@ -75,7 +79,29 @@ var backgroundEntitySchema = z.object({
   }).nullable(),
   origin_feat: z.string().regex(wikilinkRegex).nullable(),
   suggested_characteristics: suggestedCharSchema.nullable(),
-  choices: z.array(choiceSchema).optional()
+  choices: z.array(choiceSchema).optional(),
+  rendering_hint: z.string().optional(),
+  // 175
+  has_fluff_images: z.boolean().optional(),
+  // 87
+  tables: z.array(z.object({
+    // 88 tables / 67 docs; key-sets EXACT (finding 6)
+    name: z.string().min(1),
+    dice: z.string().min(1),
+    rows: z.array(z.object({ roll: z.string(), text: z.string() }))
+  })).optional(),
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 15
+  prerequisites: z.array(z.object({
+    // 4 docs; kind CLOSED AT THE EMITTER
+    kind: z.literal("campaign"),
+    slug: z.string().min(1)
+    // (background-mapper.ts pushes
+  })).optional(),
+  //  {kind:"campaign", slug} literally — finding 24)
+  // The one-arm union STAYS (§2.6 adjudication): it is closed by CONSTRUCTION at the converter's
+  // only push site, and a future kind turns into a visible census REFUSAL — the correct loud failure.
+  image: imageField
 });
 
 export {

package/dist/{chunk-24GFQU7T.js → chunk-JSZ4H6AQ.js}

@@ -1,6 +1,6 @@
 import {
   parseSpell
-} from "./chunk-N2JE7BWL.js";
+} from "./chunk-OZP6JFGT.js";
 
 // src/spell/spell.codec.ts
 import yaml from "js-yaml";