@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/chunk-KPEJMNRD.js

@@ -0,0 +1,302 @@
+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,
+    attunement_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 "attunement-limit": {
+      out.attunement_set = Math.max(out.attunement_set, scaled(eff.value, "value", eff.scales_at, level));
+      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-KU3YLF6D.js

@@ -0,0 +1,106 @@
+// src/types/choice.ts
+var ALL_SKILL_SLUGS = [
+  "acrobatics",
+  "animal-handling",
+  "arcana",
+  "athletics",
+  "deception",
+  "history",
+  "insight",
+  "intimidation",
+  "investigation",
+  "medicine",
+  "nature",
+  "perception",
+  "performance",
+  "persuasion",
+  "religion",
+  "sleight-of-hand",
+  "stealth",
+  "survival"
+];
+var STANDARD_LANGUAGES = [
+  "common",
+  "dwarvish",
+  "elvish",
+  "giant",
+  "gnomish",
+  "goblin",
+  "halfling",
+  "orc"
+];
+var EXOTIC_LANGUAGES = [
+  "abyssal",
+  "celestial",
+  "deep-speech",
+  "draconic",
+  "infernal",
+  "primordial",
+  "sylvan",
+  "undercommon"
+];
+var SECRET_LANGUAGES = ["druidic", "thieves'-cant"];
+var ALL_LANGUAGES = [
+  ...STANDARD_LANGUAGES,
+  ...EXOTIC_LANGUAGES,
+  ...SECRET_LANGUAGES
+];
+var ARTISANS_TOOLS = [
+  "alchemist's-supplies",
+  "brewer's-supplies",
+  "calligrapher's-supplies",
+  "carpenter's-tools",
+  "cartographer's-tools",
+  "cobbler's-tools",
+  "cook's-utensils",
+  "glassblower's-tools",
+  "jeweler's-tools",
+  "leatherworker's-tools",
+  "mason's-tools",
+  "painter's-supplies",
+  "potter's-tools",
+  "smith's-tools",
+  "tinker's-tools",
+  "weaver's-tools",
+  "woodcarver's-tools"
+];
+var MUSICAL_INSTRUMENTS = [
+  "bagpipes",
+  "drum",
+  "dulcimer",
+  "flute",
+  "horn",
+  "lute",
+  "lyre",
+  "pan-flute",
+  "shawm",
+  "viol"
+];
+var GAMING_SETS = ["dice-set", "playing-cards"];
+var OTHER_TOOLS = [
+  "disguise-kit",
+  "forgery-kit",
+  "herbalism-kit",
+  "navigator's-tools",
+  "poisoner's-kit",
+  "thieves'-tools"
+];
+var ALL_TOOLS = [
+  ...ARTISANS_TOOLS,
+  ...MUSICAL_INSTRUMENTS,
+  ...GAMING_SETS,
+  ...OTHER_TOOLS
+];
+
+export {
+  ALL_SKILL_SLUGS,
+  STANDARD_LANGUAGES,
+  EXOTIC_LANGUAGES,
+  SECRET_LANGUAGES,
+  ALL_LANGUAGES,
+  ARTISANS_TOOLS,
+  MUSICAL_INSTRUMENTS,
+  GAMING_SETS,
+  OTHER_TOOLS,
+  ALL_TOOLS
+};

package/dist/{chunk-5INR4NSL.js → chunk-LDDCNPHD.js}

@@ -1,6 +1,6 @@
 import {
   parseWeapon
-} from "./chunk-6NK2MUD3.js";
+} from "./chunk-HZA7OE7N.js";
 
 // src/weapon/weapon.codec.ts
 import yaml from "js-yaml";

package/dist/chunk-LVQLWRCU.js

@@ -0,0 +1,15 @@
+// src/dnd/warn-once.ts
+var seen = /* @__PURE__ */ new Set();
+function warnOnce(key, msg) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  console.warn(msg);
+}
+function __resetWarnOnceForTests() {
+  seen.clear();
+}
+
+export {
+  warnOnce,
+  __resetWarnOnceForTests
+};

package/dist/chunk-MI7P3NX3.js

@@ -0,0 +1,161 @@
+import {
+  RACE_STRUCTURAL_PSEUDO
+} from "./chunk-PVCEA4HZ.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  slugify
+} from "./chunk-6X4KUDMU.js";
+import {
+  mirrorSpellShapes
+} from "./chunk-OZP6JFGT.js";
+import {
+  ABILITY_KEYS
+} from "./chunk-WELIKLZF.js";
+
+// src/pc/pc.additional-spells.ts
+var entriesOf = (a) => Array.isArray(a) ? a : a && typeof a === "object" ? [a] : [];
+var editionOf = (x) => {
+  const e = x == null ? void 0 : x.edition;
+  return typeof e === "string" ? e : void 0;
+};
+var prefixOf = (slug) => {
+  var _a;
+  return (_a = slug.split("_")[0]) != null ? _a : slug;
+};
+function normalizeSpellRef(ref) {
+  var _a, _b, _c;
+  if (typeof ref !== "string") return null;
+  let s = ref.trim();
+  const wl = /^\[\[(.+)\]\]$/.exec(s);
+  if (wl) {
+    const target = (_a = wl[1].split("|")[0]) != null ? _a : "";
+    const tail = (_b = target.split("/").pop()) != null ? _b : target;
+    const w = slugify(tail.replace(/#.*$/, "").trim());
+    return w.length > 0 ? w : null;
+  }
+  s = s.replace(/#.*$/, "");
+  s = (_c = s.split("|")[0]) != null ? _c : "";
+  const out = slugify(s.trim());
+  return out.length > 0 ? out : null;
+}
+function buildSpellNameIndex(entities) {
+  var _a;
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of entities.search("", "spell", Number.POSITIVE_INFINITY)) {
+    const raw = e.data.name;
+    const key = slugify(typeof raw === "string" ? raw : e.name);
+    const list = (_a = byName.get(key)) != null ? _a : [];
+    list.push(e);
+    byName.set(key, list);
+  }
+  return { byName };
+}
+function resolveSpellByName(opts) {
+  var _a;
+  const { entities, index, nameSlug, carrierSlug, carrierEdition, alreadyCollected } = opts;
+  const own = alreadyCollected.find((s) => {
+    var _a2;
+    return slugify(String((_a2 = s.entity.name) != null ? _a2 : "")) === nameSlug;
+  });
+  if (own) return { entity: own.entity, slug: own.slug };
+  const exact = entities.getByTypeAndSlug("spell", `${prefixOf(carrierSlug)}_spell_${nameSlug}`);
+  if (exact) return { entity: mirrorSpellShapes(exact.data), slug: exact.slug };
+  const cands = (_a = index.byName.get(nameSlug)) != null ? _a : [];
+  if (cands.length === 0) {
+    warnOnce(`addspells:miss:${nameSlug}`, `archivist: additional_spells ref "${nameSlug}" matches no spell in the compendium`);
+    return null;
+  }
+  const prefix = prefixOf(carrierSlug);
+  let pool = cands.filter((e) => prefixOf(e.slug) === prefix);
+  if (pool.length === 0) pool = cands;
+  if (carrierEdition !== void 0) {
+    const same = pool.filter((e) => editionOf(e.data) === carrierEdition);
+    if (same.length > 0) pool = same;
+  }
+  pool = [...pool].sort((a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  if (pool.length > 1) warnOnce(`addspells:multi:${nameSlug}`, `archivist: additional_spells ref "${nameSlug}" matches ${cands.length} spells; using "${pool[0].slug}"`);
+  return { entity: mirrorSpellShapes(pool[0].data), slug: pool[0].slug };
+}
+var hasContentSelectInline = (choices) => Array.isArray(choices) && choices.some((c) => (c == null ? void 0 : c.kind) === "select-inline" && typeof c.id === "string" && !RACE_STRUCTURAL_PSEUDO.has(c.id) || Array.isArray(c == null ? void 0 : c.options) && c.options.some((o) => hasContentSelectInline(o == null ? void 0 : o.choices)));
+function raceIsUngated(race) {
+  var _a;
+  const r = race;
+  if (hasContentSelectInline(r.choices)) return false;
+  return !((_a = r.traits) != null ? _a : []).some((t) => hasContentSelectInline(t == null ? void 0 : t.choices));
+}
+var readAbility = (v, own) => {
+  if (v && typeof v === "object" && "choose" in v) return "choose";
+  if (typeof v !== "string") return void 0;
+  if (v === "inherit") return own != null ? own : void 0;
+  return ABILITY_KEYS.includes(v) ? v : void 0;
+};
+var entryHasInSliceLeaf = (e, comparand, own) => readAbility(e.ability, own) !== "choose" && ["known", "prepared"].some((b) => {
+  const lv = e[b];
+  return !!lv && typeof lv === "object" && !Array.isArray(lv) && Object.entries(lv).some(([k, v]) => (k === "_" || Number(k) <= comparand) && Array.isArray(v) && v.some((x) => typeof x === "string"));
+});
+function collectAdditionalSpells(args) {
+  const { race, feats, classes, totalLevel, ownAbility, alreadyCollected, entities, warnings } = args;
+  let index = null;
+  const indexOf = () => index != null ? index : index = buildSpellNameIndex(entities);
+  const out = [];
+  const carriers = [];
+  const asRaw = (x) => x == null ? void 0 : x.additional_spells;
+  if (race && raceIsUngated(race)) carriers.push({ root: "race", slug: race.slug, edition: editionOf(race), entries: entriesOf(asRaw(race)), comparand: totalLevel, classSlug: null });
+  for (const f of feats) carriers.push({ root: "feat", slug: f.slug, edition: editionOf(f), entries: entriesOf(asRaw(f)), comparand: totalLevel, classSlug: null });
+  for (const c of classes) {
+    if (!c.entity) continue;
+    carriers.push({ root: "class", slug: c.entity.slug, edition: editionOf(c.entity), entries: entriesOf(asRaw(c.entity)), comparand: c.level, classSlug: c.entity.slug });
+    if (c.subclass) carriers.push({ root: "subclass", slug: c.subclass.slug, edition: editionOf(c.subclass), entries: entriesOf(asRaw(c.subclass)), comparand: c.level, classSlug: c.entity.slug });
+  }
+  for (const car of carriers) {
+    if (car.entries.length === 0) continue;
+    if (car.entries.length > 1) {
+      if (car.entries.some((e) => entryHasInSliceLeaf(e, car.comparand, ownAbility))) warnOnce(`addspells:siblings:${car.slug}`, `archivist: additional_spells on "${car.slug}" has ${car.entries.length} sibling entries (a choose-one grant); skipped`);
+      continue;
+    }
+    const entry = car.entries[0];
+    const ability = readAbility(entry.ability, ownAbility);
+    if (ability === "choose") continue;
+    for (const bucket of ["known", "prepared"]) {
+      const levels = entry[bucket];
+      if (!levels || typeof levels !== "object" || Array.isArray(levels)) continue;
+      for (const [k, v] of Object.entries(levels)) {
+        if (!(k === "_" || Number(k) <= car.comparand)) continue;
+        if (!Array.isArray(v)) {
+          warnOnce(`addspells:usage:${car.slug}:${bucket}:${k}`, `archivist: additional_spells on "${car.slug}" ${bucket}.${k} is a usage economy (skipped; G8)`);
+          continue;
+        }
+        for (const leaf of v) {
+          const nameSlug = normalizeSpellRef(leaf);
+          if (!nameSlug) continue;
+          const hit = resolveSpellByName({ entities, index: indexOf(), nameSlug, carrierSlug: car.slug, carrierEdition: car.edition, alreadyCollected: [...alreadyCollected, ...out] });
+          if (!hit) {
+            warnings.push(`additional_spells ref "${String(leaf)}" on ${car.slug} not found in compendium.`);
+            continue;
+          }
+          out.push({
+            entity: hit.entity,
+            slug: hit.slug,
+            classSlug: car.classSlug,
+            source: car.root === "race" ? "race" : car.root === "feat" ? "feat" : "class",
+            prepared: true,
+            alwaysPrepared: true,
+            ...ability ? { ability } : {}
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  prefixOf,
+  normalizeSpellRef,
+  buildSpellNameIndex,
+  resolveSpellByName,
+  raceIsUngated,
+  collectAdditionalSpells
+};

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

@@ -1,12 +1,16 @@
 import {
   raceEntitySchema
-} from "./chunk-2BWAID3Y.js";
+} from "./chunk-UMWIPLLM.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}` };