@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/{chunk-NXSWH3AE.js → chunk-T26ZVCL5.js}

@@ -1,6 +1,6 @@
 import {
   featureEffectSchema
-} from "./chunk-NXR3BD2V.js";
+} from "./chunk-WPWOHGPI.js";
 
 // src/schemas/choice-schema.ts
 import { z } from "zod";

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-GE4TLPWM.js → chunk-US5IKYCW.js}

@@ -1,6 +1,6 @@
 import {
   parseClass
-} from "./chunk-42Y5IJKT.js";
+} from "./chunk-5U5FFFA3.js";
 
 // src/class/class.codec.ts
 import yaml from "js-yaml";

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-VQAXTIBW.js

@@ -0,0 +1,100 @@
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
+// src/spell/spell.schema.ts
+import { z } from "zod";
+var castingOptionSchema = z.object({
+  type: z.string(),
+  damage_roll: z.string().optional(),
+  target_count: z.number().optional(),
+  duration: z.string().optional(),
+  range: z.number().optional(),
+  concentration: z.boolean().optional(),
+  shape_size: z.number().optional(),
+  desc: z.string().optional()
+});
+var spellMaterialSchema = z.union([
+  z.boolean(),
+  z.string(),
+  z.strictObject({
+    text: z.string(),
+    cost: z.number().optional(),
+    consume: z.union([z.boolean(), z.string()]).optional()
+  })
+]);
+var spellComponentsObjectSchema = z.strictObject({
+  v: z.boolean().optional(),
+  s: z.boolean().optional(),
+  m: spellMaterialSchema.optional(),
+  r: z.boolean().optional()
+});
+var spellDurationEntrySchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("permanent"),
+    ends: z.array(z.enum(["dispel", "trigger"])).nonempty()
+  }),
+  z.strictObject({
+    type: z.literal("timed"),
+    duration: z.strictObject({
+      type: z.enum(["minute", "hour"]),
+      amount: z.number().int().positive(),
+      up_to: z.boolean().optional()
+    })
+  })
+]);
+var spellEntitySchema = z.object({
+  name: z.string().min(1),
+  level: z.number().int().min(0).optional(),
+  school: z.string().optional(),
+  casting_time: z.string().optional(),
+  range: z.string().optional(),
+  // Union arms per §3.2; `parseSpell` normalises the structured arms back to the corpus's own
+  // string form, so `Spell.components` / `Spell.duration` stay `string` and no consumer changes.
+  components: z.union([z.string(), spellComponentsObjectSchema]).optional(),
+  duration: z.union([z.string(), z.array(spellDurationEntrySchema).nonempty()]).optional(),
+  concentration: z.boolean().optional(),
+  ritual: z.boolean().optional(),
+  classes: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  at_higher_levels: z.array(z.string()).optional(),
+  damage: z.object({ types: z.array(z.string()) }).optional(),
+  saving_throw: z.object({ ability: z.string() }).optional(),
+  casting_options: z.array(castingOptionSchema).optional(),
+  // §2 · the fourteen converter keys this root refused before R4-G2. Doc counts are MEASURED over
+  // the frozen tree; the two zero-carrier keys are declared because the root is `.strict()` and an
+  // images-ON run (`image`) or a non-images-gated fluff flag (`has_fluff_images`) would otherwise
+  // refuse the whole document. Declared-only: NO rendering this phase (booked to G8 by name).
+  rendering_hint: z.string().optional(),
+  // 1,048 docs — NEVER .min(1): every value is ''
+  misc_tags: z.array(z.string()).optional(),
+  // 769
+  area_tags: z.array(z.string()).optional(),
+  // 707
+  condition_inflict: z.array(z.string()).optional(),
+  // 194
+  affects_creature_type: z.array(z.string()).optional(),
+  // 87
+  spell_attack: z.enum(["melee", "ranged"]).optional(),
+  // 77 (ranged 44 / melee 33)
+  ability_check: z.array(z.string()).optional(),
+  // 61
+  damage_resist: z.array(z.string()).optional(),
+  // 35
+  damage_immune: z.array(z.string()).optional(),
+  // 21
+  condition_immune: z.array(z.string()).optional(),
+  // 11
+  damage_vulnerable: z.array(z.string()).optional(),
+  // 2
+  has_fluff: z.boolean().optional(),
+  // 1
+  image: imageField,
+  // 0 today; `imageField` already ends .optional()
+  has_fluff_images: z.boolean().optional()
+  // 0 today
+}).strict();
+
+export {
+  spellEntitySchema
+};

package/dist/{chunk-WP2CX2JO.js → chunk-WELIKLZF.js}

@@ -203,6 +203,10 @@ var CONDITIONS = [
   "Unconscious"
 ];
 var STANDARD_SENSES = ["Blindsight", "Darkvision", "Tremorsense", "Truesight"];
+var STANDARD_ACTIONS = {
+  "2014": ["Attack", "Cast a Spell", "Dash", "Disengage", "Dodge", "Help", "Hide", "Ready", "Search", "Use an Object"],
+  "2024": ["Attack", "Dash", "Disengage", "Dodge", "Help", "Hide", "Influence", "Magic", "Ready", "Search", "Study", "Utilize"]
+};
 var ALIGNMENT_ETHICAL = ["Lawful", "Neutral", "Chaotic", "Unaligned", "Any"];
 var ALIGNMENT_MORAL = ["Good", "Neutral", "Evil"];
 var ALL_SECTIONS = [
@@ -214,6 +218,20 @@ var ALL_SECTIONS = [
   "Lair Actions",
   "Mythic Actions"
 ];
+var ABILITY_NAME_TO_KEY = {
+  strength: "str",
+  dexterity: "dex",
+  constitution: "con",
+  intelligence: "int",
+  wisdom: "wis",
+  charisma: "cha"
+};
+function normalizeAbility(value) {
+  var _a;
+  const k = value.trim().toLowerCase();
+  if (ABILITY_KEYS.includes(k)) return k;
+  return (_a = ABILITY_NAME_TO_KEY[k]) != null ? _a : null;
+}
 
 export {
   CR_PROFICIENCY,
@@ -229,7 +247,10 @@ export {
   DAMAGE_NONMAGICAL_VARIANTS,
   CONDITIONS,
   STANDARD_SENSES,
+  STANDARD_ACTIONS,
   ALIGNMENT_ETHICAL,
   ALIGNMENT_MORAL,
-  ALL_SECTIONS
+  ALL_SECTIONS,
+  ABILITY_NAME_TO_KEY,
+  normalizeAbility
 };

package/dist/chunk-WPWOHGPI.js

@@ -0,0 +1,172 @@
+// src/schemas/feature-effect-schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var subjectField = z.string().min(1).optional();
+var conditionField = z.string().optional();
+var featureEffectSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("initiative-bonus"), value: z.number().int(), condition: conditionField, subject: subjectField }),
+  // `condition` here is the condition NAME (frightened, poisoned); the qualifier is `while`.
+  z.object({ kind: z.literal("immune-condition"), condition: z.string().min(1), while: z.string().optional(), subject: subjectField }),
+  z.object({ kind: z.literal("resistance"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({ kind: z.literal("hp-per-level-bonus"), value: z.number().int(), condition: conditionField, subject: subjectField }),
+  z.object({
+    kind: z.literal("speed-bonus"),
+    mode: z.enum(["walk", "fly", "swim", "climb", "burrow"]),
+    value: z.number().int(),
+    // when true, value is an absolute floor (Math.max), not additive; currently
+    // only surfaced for mode:"walk" · other modes have no derived speed yet.
+    set: z.boolean().optional(),
+    // R4-G7 §7.3: the WHOLE progression lives inside the effect, because the overlay's `class_features`
+    // map is keyed `<class>:<feature-slug>` with no level component and, after §7.1's fold, the sheet
+    // reads exactly ONE copy of a repeated feature. The engine takes the highest entry at or below the
+    // effect's OWN source level (`levelFor`), and applies it to the additive bonus and to a `set` floor
+    // alike. The Monk's Unarmored Movement is the shipped carrier shape.
+    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), value: z.number().int() })).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("sense"),
+    type: z.enum(["darkvision", "blindsight", "tremorsense", "truesight"]),
+    range: z.number().int().nonnegative(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  // `condition` here is the condition NAME being applied.
+  z.object({
+    kind: z.literal("apply-condition"),
+    condition: z.string().min(1),
+    duration: z.string().optional(),
+    ends_on: z.array(z.string()).optional(),
+    save_repeat: z.object({ ability: z.string().min(1), timing: z.string().min(1) }).optional(),
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("damage-bonus"),
+    // intentionally an open string, NOT a damage-type enum: must accept the
+    // literal "chosen" (player-selected damage type at action time) alongside
+    // canonical damage types. Do not tighten to an enum.
+    damage_type: z.string().min(1),
+    amount: z.string().min(1),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("proficiency"),
+    proficiency_type: z.enum(["skill", "tool", "language", "saving-throw", "armor", "weapon"]),
+    value: z.string().min(1),
+    expertise: z.boolean().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({ kind: z.literal("ac-bonus"), value: z.number().int(), requires_armor: z.boolean().optional(), condition: conditionField, subject: subjectField }),
+  z.object({
+    kind: z.literal("unarmored-ac"),
+    abilities: z.array(abilityEnum),
+    base: z.number().int().optional(),
+    allow_shield: z.boolean().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("unarmed-strike"),
+    // R4-G7 §7.2: a bare die expression, `<count>d<faces>`. `resolveUnarmedStrike` averages the flat arm with
+    // /^(\d+)d(\d+)$/ and silently averages anything else as 1, so a modifier tail ("1d6+1") or a missing
+    // half ("d6", "1d") must refuse here rather than mis-average there. The `i` arm keeps an authored `1D6`.
+    dice: z.union([z.string().regex(/^\d+d\d+$/i), z.object({ column: z.string().min(1) })]).optional(),
+    abilities: z.array(abilityEnum).nonempty().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("weapon-ability"),
+    ability: z.union([abilityEnum, z.literal("spellcasting")]),
+    weapons: z.union([z.literal("chosen"), z.string(), z.array(z.string())]).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("roll-modifier"),
+    mode: z.enum(["advantage", "disadvantage", "reroll", "add-d4"]),
+    roll: z.enum(["ability-check", "saving-throw", "attack", "any"]),
+    scope: z.string().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("extra-attack"),
+    // `count` is EXTRA attacks, never total attacks: the engine renders `1 + count`.
+    count: z.number().int().positive(),
+    // R4-G7 §7.3, the `speed-bonus` twin: the SRD 5e Fighter's one Extra Attack feature carries its whole
+    // 5 / 11 / 20 progression here, because `bucketFeaturesByLevel` emits one overlay record into every
+    // `gained_at` bucket and a per-copy count cannot be authored.
+    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), count: z.number().int().positive() })).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("crit-range"),
+    min_roll: z.number().int().min(2).max(20),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("reroll-damage"),
+    max_reroll: z.number().int().positive(),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    once_per_die: z.boolean().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({ kind: z.literal("attack-rule"), flag: z.enum(["no-ranged-in-melee-disadvantage"]), condition: conditionField, subject: subjectField }),
+  // R4-G1a declared these seven converter-emitted arms with the engine folding NOTHING for them
+  // (spec D3). R4-G3a §3-§7 gives SIX of them semantics: immunity / vulnerability FOLD (defenses
+  // pane); temp-hp / heal / extra-action are still NOT folded, the plugin reads them raw as
+  // row-local captions; save-outcome FOLDS (save-chip tag rail).
+  // `ability-score-increase` folds FLAT at the fold since R4-G3b §4 (fixed-list arms only; `chosen` arms
+  // are the ASI slot's second encoding; `max` is unread by user ruling).
+  // Damage immunity / vulnerability. NOT `immune-condition`, which is condition immunity.
+  z.object({ kind: z.literal("immunity"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({ kind: z.literal("vulnerability"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
+  // `amount` is the open non-empty STRING `damage-bonus.amount` already uses: "2d6", "5", "your Artificer level".
+  z.object({ kind: z.literal("temp-hp"), amount: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({ kind: z.literal("heal"), amount: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({
+    kind: z.literal("ability-score-increase"),
+    // "chosen" follows `weapon-ability.weapons`; the list follows `unarmored-ac.abilities`.
+    abilities: z.union([z.literal("chosen"), z.array(abilityEnum).min(1)]),
+    amount: z.number().int().positive(),
+    // Required-WITH-NULL, never optional: "the prose stated no cap" and "the extractor forgot" must not look alike.
+    choose: z.number().int().positive().nullable(),
+    max: z.number().int().positive().nullable(),
+    condition: conditionField,
+    subject: subjectField
+  }).refine((e) => e.abilities === "chosen" === (e.choose !== null), {
+    path: ["choose"],
+    message: 'choose is required IFF abilities is "chosen": a fixed LIST is its own count'
+  }),
+  // `extra-action` is an additional ACTION on your turn; `extra-attack` is attacks WITHIN the Attack action.
+  z.object({
+    kind: z.literal("extra-action"),
+    count: z.number().int().positive(),
+    action_type: z.enum(["action", "bonus-action", "reaction"]),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  // `save-outcome` remaps the OUTCOME; `roll-modifier` modifies the ROLL.
+  z.object({
+    kind: z.literal("save-outcome"),
+    ability: z.union([abilityEnum, z.literal("any")]),
+    on_success: z.enum(["none", "half", "full"]),
+    on_failure: z.enum(["none", "half", "full"]),
+    applies_to: z.string().nullable(),
+    condition: conditionField,
+    subject: subjectField
+  })
+]);
+
+export {
+  featureEffectSchema
+};

package/dist/{chunk-GZ46OVGZ.js → chunk-WSVMLNTO.js}

@@ -1,7 +1,7 @@
 import {
   STATIC_FALLBACK_CONTEXT,
   convertDescToTags
-} from "./chunk-RAWJTA45.js";
+} from "./chunk-DEEHHLAP.js";
 
 // src/spell/spell.enrichment.ts
 function enrichSpell(raw) {

package/dist/{chunk-4LZJXJJS.js → chunk-WXWPK3LI.js}

@@ -1,6 +1,6 @@
 import {
   slugify
-} from "./chunk-LV4SNWZQ.js";
+} from "./chunk-6X4KUDMU.js";
 
 // src/entities/base-item-resolver.ts
 function unwrapWikilink(input) {
@@ -10,7 +10,11 @@ function unwrapWikilink(input) {
   const pipe = inner.indexOf("|");
   return pipe === -1 ? inner : inner.slice(0, pipe);
 }
-var FOLDER_TO_TYPE = { Weapons: "weapon", Armor: "armor" };
+var FOLDER_TO_TYPE = {
+  Weapons: "weapon",
+  Armor: "armor",
+  "Magic Items": "item"
+};
 function vaultPathToSlug(target) {
   const segments = target.split("/").map((s) => s.trim()).filter((s) => s.length > 0);
   if (segments.length === 0) return "";

package/dist/{chunk-ZZGEVJKX.js → chunk-XBQMCEI2.js}

@@ -1,6 +1,6 @@
 import {
   parseRace
-} from "./chunk-PHQRGDRQ.js";
+} from "./chunk-XGOFP7AQ.js";
 
 // src/race/race.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-PHQRGDRQ.js → chunk-XGOFP7AQ.js}

@@ -1,12 +1,16 @@
 import {
   raceEntitySchema
-} from "./chunk-2BWAID3Y.js";
+} from "./chunk-FDBWYMZK.js";
+import {
+  aliasFeatureListActionCost
+} from "./chunk-4U55VNC7.js";
 
 // src/race/race.parser.ts
 import { parseYaml } from "@archivist-gg/core";
 function parseRace(source) {
   const raw = parseYaml(source, ["name", "slug"]);
   if (!raw.success) return raw;
+  aliasFeatureListActionCost(raw.data.traits);
   const result = raceEntitySchema.safeParse({ edition: "2014", ...raw.data });
   if (!result.success) {
     return { success: false, error: `race schema validation failed: ${result.error.message}` };

package/dist/chunk-XJ2F2WO6.js

@@ -0,0 +1,8 @@
+// src/pc/pc.defense-normalize.ts
+function toDefenseSlug(s) {
+  return s.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+export {
+  toDefenseSlug
+};