@archivist-gg/dnd5e 0.1.0

package/dist/chunk-6PXE7T7C.js

@@ -0,0 +1,79 @@
+import {
+  readTableColumn
+} from "./chunk-5XUXXAQJ.js";
+import {
+  bareEntitySlug,
+  wikilinkTailSlug
+} from "./chunk-TJCNX6UZ.js";
+
+// src/pc/pc.pools.ts
+function levelPrereqMax(d) {
+  var _a;
+  return ((_a = d.prerequisites) != null ? _a : []).filter((p) => p.kind === "level").reduce((m, p) => Math.max(m, p.min), 0);
+}
+function resolvePool(rc, classIndex, pool, registry) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const entity = rc.entity;
+  const level = rc.level;
+  const ownerBare = bareEntitySlug(entity.slug);
+  const col = pool.count.column;
+  const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
+  let anchorLevel = 1;
+  for (let l = 1; l <= 20; l++) {
+    const c = readTableColumn(entity.table, l, [col]);
+    if (c != null && c >= 1) {
+      anchorLevel = l;
+      break;
+    }
+  }
+  const ft = pool.source.where.feature_type;
+  const all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY);
+  const byBare = /* @__PURE__ */ new Map();
+  const available = [];
+  for (const e of all) {
+    const d = e.data;
+    const entry = { slug: e.slug, entity: d };
+    byBare.set(bareEntitySlug(e.slug), entry);
+    if (d.feature_type !== ft) continue;
+    if (!((_b = d.available_to) != null ? _b : []).some((l) => wikilinkTailSlug(l) === ownerBare)) continue;
+    if (levelPrereqMax(d) > level) continue;
+    available.push(entry);
+  }
+  const grantDecls = [
+    ...(_d = (_c = rc.entity) == null ? void 0 : _c.pool_grants) != null ? _d : [],
+    ...(_f = (_e = rc.subclass) == null ? void 0 : _e.pool_grants) != null ? _f : []
+  ];
+  const grantsRaw = grantDecls.filter((g) => g.pool === pool.id).flatMap((g) => g.grants).filter((g) => g.at_level <= level).map((g) => byBare.get(wikilinkTailSlug(g.feature))).filter((e) => e != null);
+  const grantedBare = /* @__PURE__ */ new Set();
+  const grants = grantsRaw.filter((e) => {
+    const key = bareEntitySlug(e.slug);
+    if (grantedBare.has(key)) return false;
+    grantedBare.add(key);
+    return true;
+  });
+  const raw = (_g = rc.choices[anchorLevel]) == null ? void 0 : _g[pool.id];
+  const selectedSlugs = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+  const selected = selectedSlugs.map((s) => byBare.get(bareEntitySlug(s))).filter((e) => e != null).filter((e) => !grantedBare.has(bareEntitySlug(e.slug)));
+  return { id: pool.id, label: pool.label, classIndex, count, anchorLevel, selected, available, grants };
+}
+function resolveAllPools(resolved, registry) {
+  const out = [];
+  resolved.classes.forEach((rc, classIndex) => {
+    var _a, _b, _c;
+    if (!rc.entity) return;
+    const decls = [...(_a = rc.entity.selection_pools) != null ? _a : [], ...(_c = (_b = rc.subclass) == null ? void 0 : _b.selection_pools) != null ? _c : []];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pool of decls) {
+      if (seen.has(pool.id)) continue;
+      seen.add(pool.id);
+      out.push(resolvePool(rc, classIndex, pool, registry));
+    }
+  });
+  return out;
+}
+
+export {
+  levelPrereqMax,
+  resolvePool,
+  resolveAllPools
+};

package/dist/chunk-7P65Q426.js

@@ -0,0 +1,158 @@
+// src/monster/monster.parser.ts
+import { parseYaml, toStringSafe } from "@archivist-gg/core";
+var VALID_RECHARGE_TYPES = /* @__PURE__ */ new Set([
+  "recharge_on_roll",
+  "per_day",
+  "per_short_rest",
+  "per_long_rest"
+]);
+function parseMonster(source) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const result = parseYaml(source, ["name"]);
+  if (!result.success) return result;
+  const raw = result.data;
+  const monster = {
+    name: toStringSafe(raw.name)
+  };
+  if (raw.size != null) monster.size = toStringSafe(raw.size);
+  if (raw.type != null) monster.type = toStringSafe(raw.type);
+  if (raw.subtype != null) monster.subtype = toStringSafe(raw.subtype);
+  if (raw.alignment != null) monster.alignment = toStringSafe(raw.alignment);
+  if (raw.cr != null) monster.cr = toStringSafe(raw.cr);
+  if (Array.isArray(raw.ac)) {
+    monster.ac = raw.ac.map((entry) => ({
+      ac: Number(entry.ac),
+      from: Array.isArray(entry.from) ? entry.from.map(String) : void 0
+    }));
+  }
+  if (raw.hp && typeof raw.hp === "object") {
+    const hp = raw.hp;
+    monster.hp = {
+      average: Number(hp.average),
+      formula: hp.formula != null ? toStringSafe(hp.formula) : void 0
+    };
+  }
+  if (raw.speed && typeof raw.speed === "object") {
+    const speed = raw.speed;
+    monster.speed = {};
+    for (const key of ["walk", "fly", "swim", "climb", "burrow"]) {
+      if (speed[key] != null) monster.speed[key] = Number(speed[key]);
+    }
+  }
+  if (raw.abilities && typeof raw.abilities === "object") {
+    const ab = raw.abilities;
+    monster.abilities = {
+      str: Number((_a = ab.str) != null ? _a : 10),
+      dex: Number((_b = ab.dex) != null ? _b : 10),
+      con: Number((_c = ab.con) != null ? _c : 10),
+      int: Number((_d = ab.int) != null ? _d : 10),
+      wis: Number((_e = ab.wis) != null ? _e : 10),
+      cha: Number((_f = ab.cha) != null ? _f : 10)
+    };
+  }
+  if (raw.saves && typeof raw.saves === "object") {
+    const saves = {};
+    for (const [key, val] of Object.entries(raw.saves)) {
+      saves[key] = Number(val);
+    }
+    monster.saves = saves;
+  }
+  if (raw.skills && typeof raw.skills === "object") {
+    const skills = {};
+    for (const [key, val] of Object.entries(raw.skills)) {
+      skills[key] = Number(val);
+    }
+    monster.skills = skills;
+  }
+  if (Array.isArray(raw.senses)) monster.senses = raw.senses.map(String);
+  if (raw.passive_perception != null) monster.passive_perception = Number(raw.passive_perception);
+  if (Array.isArray(raw.languages)) monster.languages = raw.languages.map(String);
+  if (Array.isArray(raw.damage_vulnerabilities)) monster.damage_vulnerabilities = raw.damage_vulnerabilities.map(String);
+  if (Array.isArray(raw.damage_resistances)) monster.damage_resistances = raw.damage_resistances.map(String);
+  if (Array.isArray(raw.damage_immunities)) monster.damage_immunities = raw.damage_immunities.map(String);
+  if (Array.isArray(raw.condition_immunities)) monster.condition_immunities = raw.condition_immunities.map(String);
+  const parseAttack = (raw2) => {
+    const a = {
+      name: toStringSafe(raw2.name),
+      type: toStringSafe(raw2.type)
+    };
+    if (typeof raw2.bonus === "number") a.bonus = raw2.bonus;
+    if (typeof raw2.damage === "string") a.damage = raw2.damage;
+    if (typeof raw2.damage_type === "string") a.damage_type = raw2.damage_type;
+    if (typeof raw2.action === "string") a.action = raw2.action;
+    if (Array.isArray(raw2.properties)) a.properties = raw2.properties.map(String);
+    if (raw2.range && typeof raw2.range === "object") {
+      const r = raw2.range;
+      a.range = {};
+      if (typeof r.normal === "number") a.range.normal = r.normal;
+      if (typeof r.long === "number") a.range.long = r.long;
+      if (typeof r.reach === "number") a.range.reach = r.reach;
+    }
+    if (raw2.extra_damage && typeof raw2.extra_damage === "object") {
+      const ed = raw2.extra_damage;
+      if (typeof ed.dice === "string" && typeof ed.type === "string") {
+        a.extra_damage = { dice: ed.dice, type: ed.type };
+      }
+    }
+    if (typeof raw2.condition === "string") a.condition = raw2.condition;
+    return a;
+  };
+  const parseFeatures = (arr) => {
+    if (!Array.isArray(arr)) return void 0;
+    return arr.map((f) => {
+      const feature = {
+        name: toStringSafe(f.name),
+        // Always set entries to an array so downstream renderers/editors
+        // (which call .join/.map directly) keep working.
+        entries: Array.isArray(f.entries) ? f.entries.map(String) : []
+      };
+      if (typeof f.description === "string") feature.description = f.description;
+      if (Array.isArray(f.attacks)) {
+        feature.attacks = f.attacks.map(parseAttack);
+      }
+      if (typeof f.action === "string") feature.action = f.action;
+      if (f.recharge && typeof f.recharge === "object") {
+        const r = f.recharge;
+        if (typeof r.type === "string" && VALID_RECHARGE_TYPES.has(r.type) && typeof r.param === "number") {
+          feature.recharge = {
+            type: r.type,
+            param: r.param
+          };
+        }
+      }
+      return feature;
+    });
+  };
+  monster.traits = parseFeatures(raw.traits);
+  monster.actions = parseFeatures(raw.actions);
+  monster.reactions = parseFeatures(raw.reactions);
+  const legendaryArrayRaw = Array.isArray(raw.legendary_actions) ? raw.legendary_actions : raw.legendary;
+  monster.legendary_actions = parseFeatures(legendaryArrayRaw);
+  if (raw.legendary_action_uses != null) {
+    monster.legendary_action_uses = Number(raw.legendary_action_uses);
+  } else if (raw.legendary_actions != null && !Array.isArray(raw.legendary_actions) && typeof raw.legendary_actions !== "object") {
+    monster.legendary_action_uses = Number(raw.legendary_actions);
+  }
+  if (raw.legendary_resistance != null) monster.legendary_resistance = Number(raw.legendary_resistance);
+  if (raw.columns != null) monster.columns = Number(raw.columns);
+  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 = (_g = monster.traits[lrIndex].name) == null ? void 0 : _g.match(/\((\d+)\/Day\)/i);
+      if (match) {
+        monster.legendary_resistance = parseInt(match[1], 10);
+        monster.traits.splice(lrIndex, 1);
+      }
+    }
+  }
+  return { success: true, data: monster };
+}
+
+export {
+  parseMonster
+};

package/dist/chunk-A7T5L7SS.js

@@ -0,0 +1,83 @@
+import {
+  startingEquipmentEntrySchema
+} from "./chunk-3DZ74AKK.js";
+import {
+  choiceSchema
+} from "./chunk-CDW7R2QT.js";
+
+// src/background/background.schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var editionEnum = z.enum(["2014", "2024"]);
+var skillEnum = z.enum([
+  "acrobatics",
+  "animal-handling",
+  "arcana",
+  "athletics",
+  "deception",
+  "history",
+  "insight",
+  "intimidation",
+  "investigation",
+  "medicine",
+  "nature",
+  "perception",
+  "performance",
+  "persuasion",
+  "religion",
+  "sleight-of-hand",
+  "stealth",
+  "survival"
+]);
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var toolProfSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("fixed"), items: z.array(z.string()).nonempty() }),
+  z.object({
+    kind: z.literal("choice"),
+    count: z.number().int().positive(),
+    from: z.array(z.string()).nonempty()
+  })
+]);
+var langProfSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("fixed"), languages: z.array(z.string()).nonempty() }),
+  z.object({
+    kind: z.literal("choice"),
+    count: z.number().int().positive(),
+    from: z.union([z.string(), z.array(z.string())])
+  })
+]);
+var suggestedCharSchema = z.object({
+  personality_traits: z.record(z.string(), z.string()).optional(),
+  ideals: z.record(z.string(), z.object({
+    name: z.string().optional(),
+    desc: z.string(),
+    alignment: z.string().optional()
+  })).optional(),
+  bonds: z.record(z.string(), z.string()).optional(),
+  flaws: z.record(z.string(), z.string()).optional()
+});
+var backgroundEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  edition: editionEnum,
+  source: z.string().min(1),
+  description: z.string(),
+  skill_proficiencies: z.array(skillEnum),
+  tool_proficiencies: z.array(toolProfSchema),
+  language_proficiencies: z.array(langProfSchema),
+  equipment: z.array(startingEquipmentEntrySchema),
+  feature: z.object({
+    name: z.string().min(1),
+    description: z.string().min(1)
+  }),
+  ability_score_increases: z.object({
+    pool: z.array(abilityEnum).length(3)
+  }).nullable(),
+  origin_feat: z.string().regex(wikilinkRegex).nullable(),
+  suggested_characteristics: suggestedCharSchema.nullable(),
+  choices: z.array(choiceSchema).optional()
+});
+
+export {
+  backgroundEntitySchema
+};

package/dist/chunk-AFKTJXRA.js

@@ -0,0 +1,39 @@
+// src/weapon/weapon.schema.ts
+import { z } from "zod";
+var conditionalPropertySchema = z.object({
+  kind: z.literal("conditional"),
+  uid: z.string(),
+  note: z.string()
+});
+var propertySchema = z.union([z.string(), conditionalPropertySchema]);
+var editionEnum = z.enum(["2014", "2024"]);
+var weaponEntitySchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  category: z.string(),
+  damage: z.object({
+    dice: z.string(),
+    type: z.string(),
+    versatile_dice: z.string().optional()
+  }),
+  properties: z.array(propertySchema).default([]),
+  range: z.object({
+    normal: z.number().int().nonnegative(),
+    long: z.number().int().nonnegative()
+  }).optional(),
+  reload: z.number().int().nonnegative().optional(),
+  mastery: z.array(z.string()).optional(),
+  type_tags: z.array(z.string()).optional(),
+  ammo_type: z.string().optional(),
+  weight: z.union([z.number(), z.string()]).optional(),
+  cost: z.string().optional(),
+  source: z.string().optional(),
+  page: z.number().int().optional(),
+  edition: editionEnum,
+  entries: z.array(z.unknown()).optional(),
+  raw: z.record(z.string(), z.unknown()).optional()
+}).loose();
+
+export {
+  weaponEntitySchema
+};

package/dist/chunk-B7UXKNLD.js

@@ -0,0 +1,46 @@
+import {
+  poolGrantSchema,
+  selectionPoolSchema,
+  tabDeclSchema
+} from "./chunk-4TIJKN6O.js";
+import {
+  featureSchema
+} from "./chunk-DABBCYTT.js";
+import {
+  resourceSchema
+} from "./chunk-PZOWBI3B.js";
+
+// src/subclass/subclass.schema.ts
+import { z } from "zod";
+var editionEnum = z.enum(["2014", "2024"]);
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var casterTypeEnum = z.enum(["full", "half", "third", "pact"]);
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var spellcastingSchema = z.object({
+  caster_type: casterTypeEnum,
+  ability: abilityEnum,
+  preparation: z.enum(["known", "prepared"]),
+  spell_list: z.string().min(1)
+});
+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()
+});
+
+export {
+  subclassEntitySchema
+};

package/dist/chunk-BAXWWGFJ.js

@@ -0,0 +1,45 @@
+import {
+  choiceSchema
+} from "./chunk-CDW7R2QT.js";
+import {
+  featureEffectSchema
+} from "./chunk-NXR3BD2V.js";
+
+// src/feat/feat.schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var editionEnum = z.enum(["2014", "2024"]);
+var categoryEnum = z.enum(["origin", "general", "fighting-style", "epic-boon"]);
+var prerequisiteSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
+  z.object({ kind: z.literal("level"), min: z.number().int().positive() }),
+  z.object({ kind: z.literal("spellcaster") }),
+  z.object({
+    kind: z.literal("proficiency"),
+    proficiency_type: z.enum(["armor", "weapon", "tool", "skill", "saving-throw"]),
+    value: z.string().min(1)
+  }),
+  z.object({ kind: z.literal("race"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("class"), slug: z.string().min(1) })
+]);
+var featEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  edition: editionEnum,
+  source: z.string().min(1),
+  category: categoryEnum,
+  description: z.string(),
+  prerequisites: z.array(prerequisiteSchema),
+  benefits: z.array(z.string()),
+  effects: z.array(featureEffectSchema),
+  grants_asi: z.object({
+    amount: z.number().int().positive(),
+    pool: z.array(abilityEnum).optional()
+  }).nullable(),
+  repeatable: z.boolean(),
+  choices: z.array(choiceSchema)
+});
+
+export {
+  featEntitySchema
+};

package/dist/chunk-BH6AMZVY.js

@@ -0,0 +1,25 @@
+// 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"
+];
+
+export {
+  ALL_SKILL_SLUGS
+};

package/dist/chunk-CDW7R2QT.js

@@ -0,0 +1,62 @@
+import {
+  featureEffectSchema
+} from "./chunk-NXR3BD2V.js";
+
+// src/schemas/choice-schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var entityFilterSchema = z.object({
+  feature_type: z.string().min(1).optional(),
+  category: z.string().min(1).optional(),
+  parent_class: z.literal("self").optional(),
+  available_to: z.literal("self").optional(),
+  weapon_category: z.enum(["simple", "martial"]).optional(),
+  armor_category: z.enum(["light", "medium", "heavy", "shield"]).optional()
+}).strict();
+var inlineOptionSchema = z.lazy(() => z.object({
+  value: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+  effects: z.array(featureEffectSchema).optional(),
+  choices: z.array(choiceSchema).optional()
+}).strict());
+var choiceSchema = z.lazy(() => z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("select-inline"),
+    id: z.string().min(1),
+    label: z.string().optional(),
+    count: z.number().int().positive().optional(),
+    options: z.array(inlineOptionSchema).nonempty()
+  }).strict(),
+  z.object({
+    kind: z.literal("select-entity"),
+    id: z.string().min(1),
+    label: z.string().optional(),
+    count: z.number().int().positive().optional(),
+    entity_type: z.string().min(1),
+    from: z.array(z.string().min(1)).nonempty().optional(),
+    where: entityFilterSchema.optional()
+  }).strict(),
+  z.object({
+    kind: z.literal("select-proficiency"),
+    id: z.string().min(1),
+    label: z.string().optional(),
+    count: z.number().int().positive(),
+    domain: z.enum(["skill", "tool", "language", "save"]),
+    from: z.array(z.string().min(1)).nonempty().optional(),
+    from_proficient: z.boolean().optional(),
+    expertise: z.boolean().optional()
+  }).strict(),
+  z.object({
+    kind: z.literal("ability-points"),
+    id: z.string().min(1),
+    label: z.string().optional(),
+    points: z.number().int().positive(),
+    max_per: z.number().int().positive(),
+    pool: z.array(abilityEnum).nonempty().optional()
+  }).strict()
+]));
+
+export {
+  choiceSchema
+};

package/dist/chunk-DABBCYTT.js

@@ -0,0 +1,68 @@
+import {
+  durationSchema
+} from "./chunk-WYGD2UGN.js";
+import {
+  resourceConsumptionSchema,
+  resourceSchema
+} from "./chunk-PZOWBI3B.js";
+import {
+  choiceSchema
+} from "./chunk-CDW7R2QT.js";
+import {
+  featureEffectSchema
+} from "./chunk-NXR3BD2V.js";
+
+// src/schemas/feature-schema.ts
+import { z as z2 } from "zod";
+
+// src/schemas/attack-schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var attackSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["melee", "ranged", "spell"]),
+  ability: z.union([abilityEnum, z.array(abilityEnum).nonempty()]).optional(),
+  damage: z.string().optional(),
+  damage_type: z.string().optional(),
+  action: z.enum(["action", "bonus-action", "reaction"]).optional(),
+  properties: z.array(z.string()).optional(),
+  range: z.object({
+    normal: z.number().int().nonnegative().optional(),
+    long: z.number().int().nonnegative().optional(),
+    reach: z.number().int().nonnegative().optional()
+  }).optional(),
+  condition: z.string().optional()
+});
+
+// src/schemas/feature-schema.ts
+var featureSchema = z2.lazy(
+  () => z2.object({
+    id: z2.string().min(1).optional(),
+    name: z2.string().min(1),
+    description: z2.string().optional(),
+    entries: z2.array(z2.string()).optional(),
+    choices: z2.array(choiceSchema).optional(),
+    grants_resource: z2.string().optional(),
+    consumes: resourceConsumptionSchema.optional(),
+    attacks: z2.array(attackSchema).optional(),
+    action: z2.enum(["action", "bonus-action", "reaction", "free", "special"]).optional(),
+    trigger: z2.string().optional(),
+    dc_formula: z2.string().optional(),
+    effects: z2.array(featureEffectSchema).optional(),
+    sub_features: z2.array(featureSchema).optional(),
+    resources: z2.array(resourceSchema).optional(),
+    // Phase 3 activatable buffs: a feature flagged `activatable` folds its effects
+    // only while its id is present in state.active_buffs. `passive` renders a tag;
+    // `duration` is a static label (no live countdown this phase).
+    activatable: z2.boolean().optional(),
+    passive: z2.boolean().optional(),
+    duration: durationSchema.optional()
+  }).refine(
+    (f) => f.description !== void 0 || f.entries !== void 0 && f.entries.length > 0,
+    { message: "feature requires either description or non-empty entries" }
+  )
+);
+
+export {
+  featureSchema
+};

package/dist/chunk-DC74TZNA.js

@@ -0,0 +1,46 @@
+import {
+  slugify
+} from "./chunk-3TRGRSCH.js";
+
+// src/entities/base-item-resolver.ts
+function unwrapWikilink(input) {
+  const m = /^\[\[([^\]]+)\]\]$/.exec(input.trim());
+  if (!m) return null;
+  const inner = m[1];
+  const pipe = inner.indexOf("|");
+  return pipe === -1 ? inner : inner.slice(0, pipe);
+}
+function vaultPathToSlug(target) {
+  const segments = target.split("/").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (segments.length === 0) return "";
+  if (segments.length === 1) {
+    return slugify(segments[0]);
+  }
+  const compendiumName = segments[0];
+  const basename = segments[segments.length - 1];
+  const prefix = slugify(compendiumName);
+  const nameSlug = slugify(basename);
+  return prefix && nameSlug ? `${prefix}_${nameSlug}` : nameSlug;
+}
+function resolveBaseItem(baseItem, registry) {
+  var _a, _b;
+  if (typeof baseItem !== "string" || baseItem.length === 0) return null;
+  const target = (_a = unwrapWikilink(baseItem)) != null ? _a : baseItem.trim();
+  if (target.length === 0) return null;
+  if (!target.includes("/")) {
+    const direct = registry.getBySlug(target);
+    if (direct) return direct;
+  }
+  const slug = vaultPathToSlug(target);
+  if (!slug) return null;
+  return (_b = registry.getBySlug(slug)) != null ? _b : null;
+}
+function resolveBaseItemOfType(baseItem, entityType, registry) {
+  const found = resolveBaseItem(baseItem, registry);
+  return found && found.entityType === entityType ? found : null;
+}
+
+export {
+  resolveBaseItem,
+  resolveBaseItemOfType
+};