@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/chunk-TOM66P2P.js

@@ -0,0 +1,38 @@
+import {
+  ALL_SKILL_SLUGS
+} from "./chunk-KU3YLF6D.js";
+import {
+  normalizeAbility
+} from "./chunk-WELIKLZF.js";
+
+// src/pc/roll-scope.ts
+var NOUNS = /\b(saving throws?|saves?|ability checks?|checks?|attack rolls?)\b/gi;
+var QUANTIFIERS = /\b(all|any|other|the next|you make|that you make)\b/gi;
+var slug = (s) => s.toLowerCase().trim().replace(/[^a-z]+/g, "-").replace(/(^-|-$)/g, "");
+function normalizeRollScope(raw, _roll) {
+  if (raw == null) return void 0;
+  const cleaned = raw.replace(NOUNS, " ").replace(QUANTIFIERS, " ").replace(/\s+/g, " ").trim();
+  const parts = cleaned.split(/\s*(?:,|\/|\band\b|\bor\b)\s*/i).map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0 || parts.length > 3) return void 0;
+  const out = [];
+  for (let p of parts) {
+    const m = p.match(/^(?:[a-z]+\s*)?\(\s*([a-z -]+)\s*\)$/i);
+    if (m) p = m[1];
+    const s = slug(p);
+    if (ALL_SKILL_SLUGS.includes(s)) {
+      out.push(s);
+      continue;
+    }
+    const ab = normalizeAbility(p);
+    if (ab) {
+      out.push(ab);
+      continue;
+    }
+    return void 0;
+  }
+  return out;
+}
+
+export {
+  normalizeRollScope
+};

package/dist/chunk-UA5KS2PL.js

@@ -0,0 +1,26 @@
+// src/schemas/entity-extras-schema.ts
+import { z } from "zod";
+var imageField = z.union([z.string().min(1), z.array(z.string().min(1))]).optional();
+var additionalSpellsEntrySchema = z.object({
+  name: z.string().min(1).optional(),
+  ability: z.union([z.string().min(1), z.object({ choose: z.array(z.string().min(1)) })]).optional(),
+  known: z.unknown().optional(),
+  innate: z.unknown().optional(),
+  prepared: z.unknown().optional(),
+  expanded: z.unknown().optional(),
+  resourceName: z.string().min(1).optional()
+});
+var progressionSchema = z.object({
+  name: z.string().min(1),
+  progression: z.union([z.record(z.string(), z.number()), z.array(z.number())]),
+  feature_type: z.array(z.string().min(1)).optional(),
+  featureType: z.array(z.string().min(1)).optional(),
+  category: z.array(z.string().min(1)).optional(),
+  required: z.record(z.string(), z.array(z.string())).optional()
+});
+
+export {
+  imageField,
+  additionalSpellsEntrySchema,
+  progressionSchema
+};

package/dist/{chunk-N6N74K6X.js → chunk-UBBKSYBY.js}

@@ -1,6 +1,6 @@
 import {
   resolveBaseItem
-} from "./chunk-4LZJXJJS.js";
+} from "./chunk-WXWPK3LI.js";
 
 // src/pc/pc.slotting.ts
 function isItemEntity(e) {

package/dist/{chunk-353WXS6S.js → chunk-UIRMA5KM.js}

@@ -1,6 +1,6 @@
 import {
   bareEntitySlug
-} from "./chunk-LV4SNWZQ.js";
+} from "./chunk-6X4KUDMU.js";
 
 // src/weapon/weapon.classify.ts
 var PURE_RANGED_THROWN_SLUGS = /* @__PURE__ */ new Set(["dart", "net"]);

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

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

package/dist/{chunk-2BWAID3Y.js → chunk-UMWIPLLM.js}

@@ -1,9 +1,13 @@
 import {
   featureSchema
-} from "./chunk-CZPMTQOY.js";
+} from "./chunk-W74BCA7V.js";
 import {
   choiceSchema
-} from "./chunk-NXSWH3AE.js";
+} from "./chunk-IWRVOCT5.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField
+} from "./chunk-UA5KS2PL.js";
 
 // src/race/race.schema.ts
 import { z } from "zod";
@@ -55,9 +59,31 @@ var raceEntitySchema = z.object({
   variant_label: z.string().min(1),
   traits: z.array(featureSchema),
   choices: z.array(choiceSchema).optional(),
-  subspecies_of: z.string().regex(wikilinkRegex).optional()
+  subspecies_of: z.string().regex(wikilinkRegex).optional(),
+  rendering_hint: z.string().optional(),
+  has_fluff: z.boolean().optional(),
+  has_fluff_images: z.boolean().optional(),
+  creature_type: z.array(z.string().min(1)).optional(),
+  // guarded non-empty at the emitter (finding 24)
+  creature_type_tags: z.array(z.string().min(1)).optional(),
+  additional_spells: z.union([
+    z.array(additionalSpellsEntrySchema),
+    // converter form, 109 docs
+    additionalSpellsEntrySchema
+    // SHIPPED-BUNDLE bare-object form, 3 docs (§2.8)
+  ]).optional(),
+  // The four RAW 5etools PASSTHROUGHS (race-mapper.ts D13 block copies them VERBATIM, no shape
+  // guard — finding 24): today's variant set is a snapshot, not a contract (lineage is already
+  // string|null|boolean), and NO G row ever reads them. Maximally loose by ruling; the guard
+  // test §9.5 pins today's variant classes since the census goes blind under z.unknown().
+  trait_tags: z.unknown().optional(),
+  lineage: z.unknown().optional(),
+  height_and_weight: z.unknown().optional(),
+  sound_clip: z.unknown().optional(),
+  image: imageField
 });
 
 export {
+  fixedAsiSchema,
   raceEntitySchema
 };

package/dist/chunk-UQ3ZFCWD.js

@@ -0,0 +1,178 @@
+import {
+  featureObjectSchema
+} from "./chunk-W74BCA7V.js";
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
+// src/monster/monster.schema.ts
+import { z } from "zod";
+var str = z.string();
+var num = z.number();
+var bool = z.boolean();
+var strArr = z.array(z.string());
+var damageQualifierSchema = z.object({
+  get types() {
+    return z.array(z.union([str, damageQualifierSchema])).optional();
+  },
+  note: str.optional(),
+  pre_note: str.optional(),
+  cond: bool.optional(),
+  special: str.optional()
+});
+var qualifierList = z.array(z.union([str, damageQualifierSchema])).optional();
+var speedValue = z.union([num, z.object({ number: num, condition: str.optional() })]);
+var monsterSpeedSchema = z.object({
+  walk: speedValue.optional(),
+  fly: speedValue.optional(),
+  swim: speedValue.optional(),
+  climb: speedValue.optional(),
+  burrow: speedValue.optional(),
+  hover: bool.optional(),
+  can_hover: bool.optional(),
+  alternate: z.record(str, z.array(z.object({ number: num, condition: str.optional() }))).optional(),
+  choose: z.object({ from: strArr, amount: num, note: str.optional() }).optional()
+});
+var monsterTypeSchema = z.object({
+  type: z.union([str, z.object({ choose: strArr })]),
+  tags: z.array(z.union([str, z.object({ tag: str, prefix: str, prefix_hidden: bool.optional() })])).optional(),
+  sidekick_type: str.optional(),
+  sidekick_tags: strArr.optional(),
+  swarm_size: str.optional(),
+  sidekick_hidden: bool.optional()
+});
+var monsterCRSchema = z.object({ cr: str, lair: str.optional(), coven: str.optional(), xp: num.optional(), xp_lair: num.optional() });
+var monsterACSchema = z.object({ ac: num.optional(), from: strArr.optional(), condition: str.optional(), braces: bool.optional(), special: str.optional() });
+var monsterHPSchema = z.object({ average: num.optional(), formula: str.optional(), special: str.optional() });
+var alignmentEntrySchema = z.object({ alignment: strArr.optional(), chance: num.optional(), note: str.optional(), special: str.optional() });
+var spellEntry = z.union([str, z.object({ entry: str, hidden: bool.optional() })]);
+var spellList = z.array(spellEntry);
+var spellLevel = z.object({ slots: num.optional(), lower: num.optional(), spells: strArr });
+var monsterSpellcastingSchema = z.object({
+  name: str.optional(),
+  type: str.optional(),
+  headerEntries: strArr.optional(),
+  footerEntries: strArr.optional(),
+  ability: str.optional(),
+  displayAs: str.optional(),
+  hidden: strArr.optional(),
+  spells: z.record(str, spellLevel).optional(),
+  will: spellList.optional(),
+  ritual: spellList.optional(),
+  daily: z.record(str, spellList).optional(),
+  rest: z.record(str, spellList).optional(),
+  restLong: z.record(str, spellList).optional(),
+  recharge: z.record(str, spellList).optional(),
+  legendary: z.record(str, spellList).optional(),
+  charges: z.record(str, spellList).optional(),
+  chargesItem: str.optional()
+});
+var initiativeSchema = z.union([num, z.object({ proficiency: num.optional(), advantage_mode: str.optional() })]);
+var gearEntrySchema = z.union([str, z.object({ item: str, quantity: num.optional(), displayName: str.optional() })]);
+var featureArr = z.array(featureObjectSchema).optional();
+var monsterSchema = z.object({
+  name: str.min(1),
+  size: z.union([str, strArr]).optional(),
+  size_note: str.optional(),
+  type: z.union([str, monsterTypeSchema]).optional(),
+  subtype: str.optional(),
+  alignment: z.union([str, z.array(z.union([str, alignmentEntrySchema]))]).optional(),
+  alignment_prefix: str.optional(),
+  cr: z.union([str, monsterCRSchema]).optional(),
+  pb_note: str.optional(),
+  ac: z.array(monsterACSchema).optional(),
+  hp: monsterHPSchema.optional(),
+  speed: monsterSpeedSchema.optional(),
+  abilities: z.object({ str: num, dex: num, con: num, int: num, wis: num, cha: num }).optional(),
+  saves: z.record(str, num).optional(),
+  skills: z.record(str, num).optional(),
+  skills_other: z.array(z.unknown()).optional(),
+  senses: strArr.nullable().optional(),
+  passive_perception: num.optional(),
+  languages: strArr.nullable().optional(),
+  damage_vulnerabilities: qualifierList,
+  damage_resistances: qualifierList,
+  damage_immunities: qualifierList,
+  condition_immunities: qualifierList,
+  traits: featureArr,
+  actions: featureArr,
+  bonus_actions: featureArr,
+  reactions: featureArr,
+  legendary_actions: featureArr,
+  mythic: featureArr,
+  mythic_header: strArr.optional(),
+  legendary_action_uses: num.optional(),
+  legendary_resistance: num.optional(),
+  legendary_actions_lair_count: num.optional(),
+  section_headers: z.array(z.object({ section: str, header: strArr })).optional(),
+  action_note: str.optional(),
+  reaction_note: str.optional(),
+  spellcasting: z.array(monsterSpellcastingSchema).optional(),
+  legendary_group: z.object({ name: str, source: str }).optional(),
+  lair_actions: z.array(z.unknown()).optional(),
+  regional_actions: z.array(z.unknown()).optional(),
+  variant: z.array(z.unknown()).optional(),
+  initiative: initiativeSchema.optional(),
+  gear: z.array(gearEntrySchema).optional(),
+  is_named_creature: bool.optional(),
+  is_npc: bool.optional(),
+  familiar: bool.optional(),
+  short_name: z.union([str, bool]).optional(),
+  level: num.optional(),
+  dragon_age: str.optional(),
+  dragon_casting_color: str.optional(),
+  environment: strArr.optional(),
+  treasure: strArr.optional(),
+  attached_items: strArr.optional(),
+  group: strArr.nullable().optional(),
+  summoned_by_spell: str.optional(),
+  summoned_by_spell_level: num.optional(),
+  summoned_by_class: str.optional(),
+  trait_tags: strArr.optional(),
+  action_tags: strArr.optional(),
+  sense_tags: strArr.optional(),
+  language_tags: strArr.optional(),
+  spellcasting_tags: strArr.optional(),
+  misc_tags: strArr.optional(),
+  damage_tags: strArr.optional(),
+  damage_tags_spell: strArr.optional(),
+  damage_tags_legendary: strArr.optional(),
+  condition_inflict: strArr.optional(),
+  condition_inflict_spell: strArr.optional(),
+  condition_inflict_legendary: strArr.optional(),
+  saving_throw_forced: strArr.optional(),
+  saving_throw_forced_spell: strArr.optional(),
+  saving_throw_forced_legendary: strArr.optional(),
+  has_fluff: bool.optional(),
+  has_fluff_images: bool.optional(),
+  has_token: bool.optional(),
+  token_credit: str.optional(),
+  token_custom: bool.optional(),
+  foundry_token_scale: num.optional(),
+  sound_clip: z.object({ type: str, path: str }).optional(),
+  alt_art: z.array(z.object({ name: str, source: str.optional(), page: num.optional() })).optional(),
+  image: imageField,
+  thumbnail: imageField,
+  rendering_hint: str.optional(),
+  columns: num.optional(),
+  slug: str.optional(),
+  edition: str.optional(),
+  source: str.optional(),
+  raw: z.record(str, z.unknown()).optional()
+});
+var MONSTER_KNOWN_KEYS = new Set(Object.keys(monsterSchema.shape));
+
+export {
+  damageQualifierSchema,
+  monsterSpeedSchema,
+  monsterTypeSchema,
+  monsterCRSchema,
+  monsterACSchema,
+  monsterHPSchema,
+  alignmentEntrySchema,
+  monsterSpellcastingSchema,
+  initiativeSchema,
+  gearEntrySchema,
+  monsterSchema,
+  MONSTER_KNOWN_KEYS
+};

package/dist/chunk-UXPGW4TI.js

@@ -0,0 +1,101 @@
+import {
+  resolveSpellcasting
+} from "./chunk-DPUJDOKV.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  isValidMaxFormula
+} from "./chunk-EVMUJYUD.js";
+
+// src/pc/pc.resources.ts
+function resourceLevelFor(source, resolved) {
+  var _a, _b, _c, _d;
+  if (source.kind === "class") {
+    return (_b = (_a = resolved.classes.find((c) => {
+      var _a2;
+      return ((_a2 = c.entity) == null ? void 0 : _a2.slug) === source.slug;
+    })) == null ? void 0 : _a.level) != null ? _b : resolved.totalLevel;
+  }
+  if (source.kind === "subclass") {
+    return (_d = (_c = resolved.classes.find((c) => {
+      var _a2;
+      return ((_a2 = c.subclass) == null ? void 0 : _a2.slug) === source.slug;
+    })) == null ? void 0 : _c.level) != null ? _d : resolved.totalLevel;
+  }
+  return resolved.totalLevel;
+}
+function resolveRecovery(entry) {
+  var _a;
+  const kind = (_a = entry.restores) != null ? _a : "uses";
+  const restTriggered = (entry.reset === "short-rest" || entry.reset === "long-rest") && !entry.action;
+  const flavour = kind === "spell-slots" ? "manual" : restTriggered ? "rest" : "manual";
+  return { entry, kind, flavour };
+}
+function toResolvedResource(r, fallbackName, owner) {
+  var _a, _b;
+  return {
+    id: r.id,
+    name: (_a = r.name) != null ? _a : fallbackName,
+    reset: r.reset,
+    maxFormula: r.max_formula,
+    ...r.die ? { die: r.die } : {},
+    ...r.scales_at ? { scalesAt: r.scales_at } : {},
+    ...((_b = r.recovery) == null ? void 0 : _b.length) ? { recovery: r.recovery.map(resolveRecovery) } : {},
+    owner
+  };
+}
+function resolveFeatureResources(features) {
+  var _a, _b;
+  const out = /* @__PURE__ */ new Map();
+  for (const rf of features) {
+    for (const r of (_a = rf.feature.resources) != null ? _a : []) {
+      if (out.has(r.id)) continue;
+      const owner = { kind: "feature", featureId: (_b = rf.feature.id) != null ? _b : rf.feature.name, featureName: rf.feature.name, source: rf.source };
+      out.set(r.id, toResolvedResource(r, rf.feature.name, owner));
+    }
+  }
+  return out;
+}
+function resolveResourceIndex(resolved) {
+  var _a, _b, _c, _d, _e;
+  const out = new Map(resolveFeatureResources((_a = resolved.features) != null ? _a : []));
+  for (const pool of (_b = resolved.pools) != null ? _b : []) {
+    const rc = resolved.classes[pool.classIndex];
+    const classSlug = (_c = rc == null ? void 0 : rc.entity) == null ? void 0 : _c.slug;
+    if (!classSlug) continue;
+    for (const entry of [...(_d = pool.selected) != null ? _d : [], ...(_e = pool.grants) != null ? _e : []]) {
+      const uses = entry.entity.uses;
+      if (!uses || out.has(entry.slug)) continue;
+      const maxFormula = String(uses.max);
+      if (!isValidMaxFormula(maxFormula)) {
+        warnOnce(`pool-uses:${entry.slug}`, `optional feature "${entry.slug}" has a prose uses.max (${JSON.stringify(uses.max)}); no tracker`);
+        continue;
+      }
+      out.set(entry.slug, {
+        id: entry.slug,
+        name: entry.entity.name,
+        reset: uses.recharge,
+        maxFormula,
+        owner: { kind: "pool", poolId: pool.id, poolLabel: pool.label, source: { kind: "class", slug: classSlug, level: pool.anchorLevel } }
+      });
+    }
+  }
+  return out;
+}
+function poolSaveDC(resolved, derived, pool) {
+  var _a, _b;
+  const rc = resolved.classes[pool.classIndex];
+  const ability = (_b = (_a = rc == null ? void 0 : rc.subclass) == null ? void 0 : _a.spellcasting) == null ? void 0 : _b.ability;
+  if (!rc || !ability) return null;
+  if (resolveSpellcasting(rc) !== null) return null;
+  return 8 + derived.proficiencyBonus + derived.mods[ability];
+}
+
+export {
+  resourceLevelFor,
+  resolveRecovery,
+  resolveFeatureResources,
+  resolveResourceIndex,
+  poolSaveDC
+};

package/dist/chunk-V2MJE6NC.js

@@ -0,0 +1,133 @@
+import {
+  MONSTER_KNOWN_KEYS,
+  monsterSchema
+} from "./chunk-UQ3ZFCWD.js";
+
+// src/monster/monster.parser.ts
+import { parseYaml } from "@archivist-gg/core";
+var VALID_RECHARGE_TYPES = /* @__PURE__ */ new Set([
+  "recharge_on_roll",
+  "per_day",
+  "per_short_rest",
+  "per_long_rest"
+]);
+var NUMERIC_STRING = /^[+-]?\d+(\.\d+)?$/;
+var FEATURE_ARRAYS = ["traits", "actions", "reactions", "legendary_actions", "bonus_actions", "mythic"];
+var SPEED_MODES = ["walk", "fly", "swim", "climb", "burrow"];
+var ABILITY_KEYS = ["str", "dex", "con", "int", "wis", "cha"];
+var NULL_KEPT = /* @__PURE__ */ new Set(["senses", "languages", "group"]);
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function coerceNumeric(obj, key) {
+  const v = obj[key];
+  if (typeof v === "string" && NUMERIC_STRING.test(v.trim())) obj[key] = Number(v);
+}
+function scrubNulls(v, top) {
+  if (Array.isArray(v)) {
+    for (let i = v.length - 1; i >= 0; i--) {
+      if (v[i] === null) v.splice(i, 1);
+      else scrubNulls(v[i], false);
+    }
+    return;
+  }
+  if (!isRecord(v)) return;
+  for (const [k, x] of Object.entries(v)) {
+    if (x === null) {
+      if (!(top && NULL_KEPT.has(k))) delete v[k];
+    } else scrubNulls(x, false);
+  }
+}
+function scrubNonFinite(v) {
+  if (Array.isArray(v)) {
+    for (const x of v) scrubNonFinite(x);
+    return;
+  }
+  if (!isRecord(v)) return;
+  for (const [k, x] of Object.entries(v)) {
+    if (typeof x === "number" && !Number.isFinite(x)) delete v[k];
+    else scrubNonFinite(x);
+  }
+}
+function migrateLegacy(raw) {
+  scrubNulls(raw, true);
+  if (raw.legendary_actions != null && !Array.isArray(raw.legendary_actions) && typeof raw.legendary_actions !== "object") {
+    if (raw.legendary_action_uses == null) raw.legendary_action_uses = Number(raw.legendary_actions);
+    delete raw.legendary_actions;
+  }
+  if (!Array.isArray(raw.legendary_actions) && Array.isArray(raw.legendary)) raw.legendary_actions = raw.legendary;
+  delete raw.legendary;
+  if (typeof raw.ac === "number") raw.ac = [{ ac: raw.ac }];
+  if (Array.isArray(raw.ac)) raw.ac = raw.ac.map((e) => typeof e === "number" ? { ac: e } : e);
+  if (typeof raw.hp === "number") raw.hp = { average: raw.hp };
+  if (typeof raw.cr === "number") raw.cr = String(raw.cr);
+  for (const k of ["passive_perception", "legendary_action_uses", "legendary_resistance", "columns", "initiative"]) coerceNumeric(raw, k);
+  if (isRecord(raw.initiative)) coerceNumeric(raw.initiative, "proficiency");
+  for (const k of ["saves", "skills"]) {
+    const o = raw[k];
+    if (isRecord(o)) for (const m of Object.keys(o)) coerceNumeric(o, m);
+  }
+  if (isRecord(raw.hp)) coerceNumeric(raw.hp, "average");
+  if (Array.isArray(raw.ac)) {
+    for (const e of raw.ac) if (isRecord(e)) coerceNumeric(e, "ac");
+  }
+  if (isRecord(raw.abilities)) for (const k of ABILITY_KEYS) coerceNumeric(raw.abilities, k);
+  if (isRecord(raw.speed)) for (const k of SPEED_MODES) {
+    coerceNumeric(raw.speed, k);
+    const v = raw.speed[k];
+    if (isRecord(v)) coerceNumeric(v, "number");
+  }
+  scrubNonFinite(raw);
+  if (isRecord(raw.abilities)) {
+    for (const k of ABILITY_KEYS) if (raw.abilities[k] == null) raw.abilities[k] = 10;
+  }
+  if (typeof raw.senses === "string") raw.senses = [raw.senses];
+  if (typeof raw.languages === "string") raw.languages = [raw.languages];
+  for (const k of FEATURE_ARRAYS) {
+    const arr = raw[k];
+    if (!Array.isArray(arr)) continue;
+    for (const f of arr) {
+      if (!isRecord(f)) continue;
+      if (typeof f.desc === "string" && f.description === void 0 && !Array.isArray(f.entries)) {
+        f.description = f.desc;
+        delete f.desc;
+      }
+      const r = f.recharge;
+      if (r !== void 0 && !(isRecord(r) && typeof r.param === "number" && VALID_RECHARGE_TYPES.has(r.type))) delete f.recharge;
+    }
+  }
+}
+function parseMonster(source) {
+  var _a, _b;
+  const result = parseYaml(source, ["name"]);
+  if (!result.success) return result;
+  const raw = result.data;
+  migrateLegacy(raw);
+  const parsed = monsterSchema.safeParse(raw);
+  if (!parsed.success) {
+    return { success: false, error: `monster schema validation failed: ${parsed.error.message}` };
+  }
+  const monster = parsed.data;
+  const extras = {};
+  for (const [k, v] of Object.entries(raw)) if (!MONSTER_KNOWN_KEYS.has(k)) extras[k] = v;
+  if (Object.keys(extras).length > 0) monster.raw = { ...(_a = monster.raw) != null ? _a : {}, ...extras };
+  if (!monster.legendary_resistance && monster.traits) {
+    const lrIndex = monster.traits.findIndex((t) => {
+      var _a2;
+      return /^Legendary Resistance\s*\(/i.test((_a2 = t.name) != null ? _a2 : "");
+    });
+    if (lrIndex !== -1) {
+      const match = (_b = monster.traits[lrIndex].name) == null ? void 0 : _b.match(/\((\d+)\/Day\)/i);
+      if (match) {
+        monster.legendary_resistance = parseInt(match[1], 10);
+        monster.traits.splice(lrIndex, 1);
+      }
+    }
+  }
+  return { success: true, data: monster };
+}
+
+export {
+  migrateLegacy,
+  parseMonster
+};

package/dist/{chunk-D3CLOBE3.js → chunk-V373TRJE.js}

@@ -1,25 +1,25 @@
 import {
   classifyWeaponRange
-} from "./chunk-353WXS6S.js";
-import {
-  normKey
-} from "./chunk-O5EYMKFH.js";
+} from "./chunk-UIRMA5KM.js";
 import {
   defaultSlotForType,
   effectiveArmor,
   isItemEntity,
   isWeaponEntity,
   resolveEntityForEntry
-} from "./chunk-N6N74K6X.js";
+} from "./chunk-UBBKSYBY.js";
+import {
+  normKey
+} from "./chunk-RLGQ5PZZ.js";
 import {
   readNumericBonus
 } from "./chunk-LWFTHJIE.js";
 import {
   resolveBaseItem
-} from "./chunk-4LZJXJJS.js";
+} from "./chunk-WXWPK3LI.js";
 import {
   bareEntitySlug
-} from "./chunk-LV4SNWZQ.js";
+} from "./chunk-6X4KUDMU.js";
 
 // src/weapon/weapon-mastery.ts
 var MASTERY = {
@@ -405,7 +405,7 @@ function magicBonusesForWeaponEntry(entry, registry, ctx) {
     itemRiders = Array.isArray(entity.damage_riders) ? entity.damage_riders.filter((r) => {
       var _a2;
       return ((_a2 = r.applies_to) != null ? _a2 : "weapon") !== "spell";
-    }).map((r) => ({ amount: r.amount, damage_type: r.damage_type, source: entity.name })) : [];
+    }).map((r) => ({ amount: r.amount, damage_type: r.damage_type, source: entity.name, ...r.condition ? { condition: r.condition } : {} })) : [];
   }
   return {
     atk: itemAttack + entryAttack,
@@ -482,6 +482,40 @@ function buildAttackRow(args) {
   }
   return row;
 }
+function buildUnarmedRow(mods, proficiencyBonus, spec) {
+  var _a;
+  const candidates = ["str", ...(_a = spec == null ? void 0 : spec.abilities) != null ? _a : []];
+  let ability = "str";
+  for (const ab of candidates) if (mods[ab] >= mods[ability]) ability = ab;
+  const abilityMod = mods[ability];
+  const toHit = abilityMod + proficiencyBonus;
+  const flat = `${abilityMod >= 0 ? "+" : ""}${abilityMod}`.replace(/^\+0$/, "");
+  const damageDice = (spec == null ? void 0 : spec.dice) ? `${spec.dice}${flat}` : String(Math.max(0, 1 + abilityMod));
+  const label = `${ability.toUpperCase()} modifier`;
+  return {
+    id: "unarmed-strike",
+    name: "Unarmed Strike",
+    unarmed: true,
+    range: "5 ft",
+    toHit,
+    damageDice,
+    damageType: "bludgeoning",
+    properties: [],
+    proficient: true,
+    breakdown: {
+      toHit: [
+        { source: label, amount: abilityMod, kind: "ability" },
+        { source: "Proficiency bonus", amount: proficiencyBonus, kind: "ability" }
+      ],
+      damage: [
+        { source: "Base damage", amount: 0, kind: "ability" },
+        { source: label, amount: abilityMod, kind: "ability" }
+      ]
+    },
+    subLabel: "Unarmed",
+    actionCost: "action"
+  };
+}
 function humanizeWeaponToken(s) {
   return s.replace(/[-_]/g, " ").replace(/(^|[\s(])\w/g, (c) => c.toUpperCase());
 }
@@ -571,7 +605,7 @@ function computeCarriedWeight(resolved, registry) {
   }
   return total;
 }
-function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, proficiencyBonus, weaponAbilities = [], weaponMasteries = []) {
+function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, proficiencyBonus, weaponAbilities = [], weaponMasteries = [], attunementFloor = 0) {
   var _a, _b, _c;
   const equippedSlots = assignSlots(resolved, registry, warnings);
   const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
@@ -587,12 +621,16 @@ function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, profi
     carriedWeight: computeCarriedWeight(resolved, registry),
     // Attunement is persistent: an attuned item still occupies a slot even when unequipped (SRD).
     attunementUsed: ((_b = resolved.definition.equipment) != null ? _b : []).filter((e) => e.attuned).length,
-    attunementLimit: (_c = overrides.attunement_limit) != null ? _c : 3
+    // PRECEDENCE: an explicit character override wins outright (a number the player typed is intent);
+    // otherwise the baseline 3 is raised — never lowered — by whatever features granted.
+    attunementLimit: (_c = overrides.attunement_limit) != null ? _c : Math.max(3, attunementFloor)
   };
 }
 
 export {
   emptyAppliedBonuses,
   computeAppliedBonuses,
+  isWeaponSlugProficient,
+  buildUnarmedRow,
   computeSlotsAndAttacks
 };