@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/{chunk-HCP3GMHS.js → chunk-5N2GW72F.js}

@@ -1,6 +1,6 @@
 import {
   armorEntitySchema
-} from "./chunk-XJNECUPT.js";
+} from "./chunk-JC5UNIVM.js";
 
 // src/armor/armor.parser.ts
 import { parseYaml } from "@archivist-gg/core";
@@ -18,12 +18,25 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "page",
   "edition",
   "entries",
-  "raw"
+  "raw",
+  // Root extras declared on armorEntitySchema (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",
+  // The alias is a KNOWN key so it is never copied into `raw` alongside the mapped
+  // `strength_requirement` — that duplicate is the census row this fix empties.
+  "strength_required"
 ]);
 function parseArmor(source) {
   var _a;
   const raw = parseYaml(source, ["name", "slug", "category", "ac"]);
   if (!raw.success) return raw;
+  if (raw.data.strength_requirement === void 0 && typeof raw.data.strength_required === "number") {
+    raw.data.strength_requirement = raw.data.strength_required;
+  }
   const result = armorEntitySchema.safeParse(raw.data);
   if (!result.success) {
     return { success: false, error: `armor schema validation failed: ${result.error.message}` };

package/dist/{chunk-42Y5IJKT.js → chunk-5U5FFFA3.js}

@@ -1,12 +1,16 @@
+import {
+  aliasFeaturesByLevelActionCost
+} from "./chunk-4U55VNC7.js";
 import {
   classEntitySchema
-} from "./chunk-TLYDBT5F.js";
+} from "./chunk-YJJTISBN.js";
 
 // src/class/class.parser.ts
 import { parseYaml } from "@archivist-gg/core";
 function parseClass(source) {
   const raw = parseYaml(source, ["name", "slug"]);
   if (!raw.success) return raw;
+  aliasFeaturesByLevelActionCost(raw.data.features_by_level);
   const result = classEntitySchema.safeParse({ edition: "2014", ...raw.data });
   if (!result.success) {
     return { success: false, error: `class schema validation failed: ${result.error.message}` };

package/dist/{chunk-4F6AIZ36.js → chunk-5XMQPTHD.js}

@@ -1,6 +1,6 @@
 import {
   optionalFeatureEntitySchema
-} from "./chunk-MDEJHMKK.js";
+} from "./chunk-ZONJ66NE.js";
 
 // src/optional-feature/optional-feature.parser.ts
 import { parseYaml } from "@archivist-gg/core";

package/dist/{chunk-GJOI2GHP.js → chunk-6GNXYAYP.js}

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

package/dist/chunk-6PKV5V2H.js

@@ -0,0 +1,178 @@
+import {
+  featureObjectSchema
+} from "./chunk-4FWNK4FD.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-66XXW2Z2.js → chunk-6PXTNCBP.js}

@@ -1,10 +1,10 @@
 import {
   convertDescToTags,
   detectSpellcastingAbility
-} from "./chunk-RAWJTA45.js";
+} from "./chunk-DEEHHLAP.js";
 import {
   abilityModifier
-} from "./chunk-NAEPSZAM.js";
+} from "./chunk-PDJSUH24.js";
 
 // src/monster/monster.enrichment.ts
 import { toStringSafe } from "@archivist-gg/core";

package/dist/chunk-6X2NV665.js

@@ -0,0 +1,33 @@
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
+// src/condition/condition.parser.ts
+import { parseYaml } from "@archivist-gg/core";
+
+// src/condition/condition.schema.ts
+import { z } from "zod";
+var conditionEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  edition: z.enum(["2014", "2024"]),
+  source: z.string().min(1),
+  description: z.string(),
+  has_fluff_images: z.boolean().optional(),
+  image: imageField
+});
+
+// src/condition/condition.parser.ts
+function parseCondition(source) {
+  const raw = parseYaml(source, ["name", "slug"]);
+  if (!raw.success) return raw;
+  const result = conditionEntitySchema.safeParse({ edition: "2014", ...raw.data });
+  if (!result.success) {
+    return { success: false, error: `condition schema validation failed: ${result.error.message}` };
+  }
+  return { success: true, data: result.data };
+}
+
+export {
+  parseCondition
+};

package/dist/{chunk-LV4SNWZQ.js → chunk-6X4KUDMU.js}

@@ -7,8 +7,15 @@ function bareEntitySlug(slug) {
   const p = slug.split("_");
   return p.length >= 3 ? p.slice(2).join("_") : p[p.length - 1];
 }
+function wikilinkTailSlug(link) {
+  var _a;
+  const inner = link.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const tail = (_a = inner.split("/").pop()) != null ? _a : inner;
+  return slugify(tail);
+}
 
 export {
   slugify,
-  bareEntitySlug
+  bareEntitySlug,
+  wikilinkTailSlug
 };

package/dist/{chunk-ZMR77DDL.js → chunk-AW3EHF3L.js}

@@ -1,6 +1,6 @@
 import {
   parseArmor
-} from "./chunk-HCP3GMHS.js";
+} from "./chunk-5N2GW72F.js";
 
 // src/armor/armor.codec.ts
 import yaml from "js-yaml";

package/dist/chunk-CJYCVNW2.js

@@ -0,0 +1,7 @@
+// src/schemas/caster-type-schema.ts
+import { z } from "zod";
+var casterTypeEnum = z.enum(["full", "half", "third", "pact", "artificer"]);
+
+export {
+  casterTypeEnum
+};

package/dist/chunk-COEOOQX2.js

@@ -0,0 +1,133 @@
+import {
+  MONSTER_KNOWN_KEYS,
+  monsterSchema
+} from "./chunk-6PKV5V2H.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-XTIQWSFM.js → chunk-D5U7GMPX.js}

@@ -1,6 +1,6 @@
 import {
   featEntitySchema
-} from "./chunk-Q5K6LWBZ.js";
+} from "./chunk-RIXI5D3R.js";
 
 // src/feat/feat.parser.ts
 import { parseYaml } from "@archivist-gg/core";

package/dist/{chunk-RAWJTA45.js → chunk-DEEHHLAP.js}

@@ -1,6 +1,6 @@
 import {
   abilityModifier
-} from "./chunk-NAEPSZAM.js";
+} from "./chunk-PDJSUH24.js";
 
 // src/dnd/srd-tag-converter.ts
 var ABILITY_KEYS = ["str", "dex", "con", "int", "wis", "cha"];