@archivist-gg/dnd5e 0.3.11 → 0.3.17

package/dist/{chunk-MQ747UCR.js → chunk-DOXSFYLH.js}

@@ -6,9 +6,12 @@ import {
   resetTriggerEnum,
   resourceConsumptionSchema
 } from "./chunk-ZJXSXVFP.js";
+import {
+  choiceSchema
+} from "./chunk-5MXFW4O3.js";
 import {
   featureEffectSchema
-} from "./chunk-XTRDCSJB.js";
+} from "./chunk-2JSQE3DD.js";
 import {
   additionalSpellsEntrySchema,
   imageField,
@@ -46,6 +49,58 @@ var usesSchema = z.object({
     restores: z.enum(["uses", "spell-slots"]).optional()
   })).optional()
 });
+var filterSpecSchema = z.object({
+  rarity: z.array(z.string().min(1)).min(1),
+  types: z.array(z.string().min(1)).optional(),
+  exclude_types: z.array(z.string().min(1)).optional(),
+  cursed: z.literal(false).optional()
+}).strict();
+var optionCreatesSchema = z.object({
+  item: z.string().regex(wikilinkRegex).optional(),
+  variant: z.object({ candidates: z.array(z.string().regex(wikilinkRegex)).min(1) }).strict().optional(),
+  filter: filterSpecSchema.optional()
+}).strict().refine((c) => [c.item, c.variant, c.filter].filter((a) => a !== void 0).length === 1, { message: "creates needs exactly one of item, variant, filter" });
+var optionRowSchema = z.object({
+  key: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/, "an option key is lower-case, with no '#' and no whitespace"),
+  name: z.string().min(1),
+  min_level: z.number().int().min(1).max(20),
+  attunement: z.boolean().optional(),
+  creates: optionCreatesSchema
+}).strict();
+var infuseItemSchema = z.object({
+  bonuses: z.object({
+    ac: z.number().int().optional(),
+    weapon_attack: z.number().int().optional(),
+    weapon_damage: z.number().int().optional(),
+    spell_attack: z.number().int().optional(),
+    saving_throws: z.number().int().optional(),
+    speed: z.object({ walk: z.number().int().optional(), fly: z.number().int().optional(), swim: z.number().int().optional(), climb: z.number().int().optional() }).strict().optional()
+  }).strict().optional(),
+  resist: z.array(z.string().min(1)).optional(),
+  charges: z.object({ max: z.number().int().min(1), dice: z.string().optional(), recharge: z.string().optional(), recharge_amount: z.string().optional() }).strict().optional(),
+  action: actionCostEnum.optional(),
+  // ART-c1 (R-3 a): the Actions row's range, as data (B-8.4 draws "Self").
+  range: z.string().min(1).optional()
+}).strict();
+var infuseBlockSchema = z.object({
+  targets: z.array(z.object({
+    kind: z.enum(["armor", "shield", "weapon", "gear"]),
+    category: z.array(z.string().min(1)).min(1).optional(),
+    property: z.string().min(1).optional(),
+    name_any: z.array(z.string().min(1)).min(1).optional()
+  }).strict()).min(1),
+  targets_label: z.string().min(1).optional(),
+  new_object: z.string().min(1).optional(),
+  rarity: z.string().min(1).optional(),
+  attunement: z.object({ required: z.literal(true) }).strict().optional(),
+  // ART-c1 (R-3 b): the damage types the choice offers (v1 U-4 draws the TCE ten); absent keeps dnd5e's canonical list.
+  choice: z.object({ kind: z.literal("damage-type"), options: z.array(z.string().min(1)).min(1).optional() }).strict().optional(),
+  item: infuseItemSchema.optional(),
+  scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), item: infuseItemSchema }).strict()).optional()
+}).strict().refine((b) => {
+  var _a;
+  return ((_a = b.scales_at) != null ? _a : []).every((r, i, a) => i === 0 || a[i - 1].level < r.level);
+}, { message: "scales_at levels ascend" });
 var optionalFeatureEntitySchema = z.object({
   slug: z.string().min(1),
   name: z.string().min(1),
@@ -82,9 +137,22 @@ var optionalFeatureEntitySchema = z.object({
   // 1
   optionalfeature_progression: z.array(progressionSchema).optional(),
   // 1
-  image: imageField
+  image: imageField,
+  repeatable: z.literal(true).optional(),
+  item_choice: z.enum(["learn", "create"]).optional(),
+  options: z.array(optionRowSchema).optional(),
+  infuse: infuseBlockSchema.optional(),
+  // D2b-A (design §2.2 step 1): a pool member's own choices, the vocabulary features and feats use.
+  choices: z.array(choiceSchema).optional()
+}).superRefine((d, ctx) => {
+  var _a;
+  if (d.repeatable && (!d.options || !d.item_choice)) ctx.addIssue({ code: "custom", message: "a repeatable note needs options and item_choice" });
+  const keys = ((_a = d.options) != null ? _a : []).map((o) => o.key);
+  if (new Set(keys).size !== keys.length) ctx.addIssue({ code: "custom", message: "option keys are unique" });
 });
 
 export {
+  optionRowSchema,
+  infuseBlockSchema,
   optionalFeatureEntitySchema
 };

package/dist/chunk-EJP263OP.js

@@ -0,0 +1,186 @@
+import {
+  resolveBaseItem
+} from "./chunk-CM5CWO4K.js";
+import {
+  bareEntitySlug,
+  slugify,
+  wikilinkTailSlug
+} from "./chunk-ZCTUYGNV.js";
+
+// src/pc/pc.containment.ts
+function nonEmptyRef(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function isContainerItem(entity) {
+  if (!entity || typeof entity !== "object") return false;
+  const c = entity.container;
+  if (!c || typeof c !== "object") return false;
+  const container = c;
+  if (typeof container.holds_items === "boolean") return container.holds_items;
+  if (typeof container.capacity_weight === "number" && container.capacity_weight > 0) return true;
+  const cap = container.capacity;
+  if (!cap || typeof cap !== "object") return false;
+  const k = cap;
+  if (Array.isArray(k.weight) && k.weight.length > 0) return true;
+  if (Array.isArray(k.item) && k.item.length > 0) return true;
+  return k.weightless === true;
+}
+function idOwners(equipment) {
+  const ownerOfId = /* @__PURE__ */ new Map();
+  const duplicateIds = [];
+  equipment.forEach((entry, i) => {
+    const id = nonEmptyRef(entry.id);
+    if (id === null) return;
+    if (ownerOfId.has(id)) duplicateIds.push(i);
+    else ownerOfId.set(id, i);
+  });
+  return { ownerOfId, duplicateIds };
+}
+function entityOfEntry(entry, registry) {
+  var _a, _b;
+  if (!registry) return null;
+  return (_b = (_a = resolveBaseItem(entry.item, registry)) == null ? void 0 : _a.data) != null ? _b : null;
+}
+function resolveContainment(equipment, registry) {
+  const n = equipment.length;
+  const { ownerOfId, duplicateIds } = idOwners(equipment);
+  const entities = equipment.map((entry) => entityOfEntry(entry, registry));
+  const isContainer = entities.map((entity) => isContainerItem(entity));
+  const parentOf = new Array(n).fill(null);
+  const broken = [];
+  const closesCycle = (child, owner) => {
+    for (let cur = owner; cur !== null; cur = parentOf[cur]) if (cur === child) return true;
+    return false;
+  };
+  for (let i = 0; i < n; i++) {
+    const target = nonEmptyRef(equipment[i].in);
+    if (target === null) continue;
+    const owner = ownerOfId.get(target);
+    let reason = null;
+    if (equipment[i].equipped === true) reason = "equipped";
+    else if (owner === void 0) reason = "missing";
+    else if (owner === i) reason = "self";
+    else if (entities[owner] === null) reason = "unresolved";
+    else if (!isContainer[owner]) reason = "not-container";
+    else if (closesCycle(i, owner)) reason = "cycle";
+    if (reason !== null) {
+      broken.push({ index: i, reason });
+      continue;
+    }
+    parentOf[i] = owner;
+  }
+  const childrenOf = Array.from({ length: n }, () => []);
+  parentOf.forEach((p, i) => {
+    if (p !== null) childrenOf[p].push(i);
+  });
+  return { parentOf, childrenOf, isContainer, ownerOfId, duplicateIds, broken };
+}
+function mintBase(entry, registry) {
+  var _a, _b, _c;
+  const found = registry ? resolveBaseItem(entry.item, registry) : null;
+  const byName = found ? slugify((_a = found.name) != null ? _a : "") : "";
+  if (byName) return byName;
+  const inner = (_c = (_b = /^\[\[(.+?)\]\]$/.exec(entry.item.trim())) == null ? void 0 : _b[1]) != null ? _c : entry.item.trim();
+  const ref = inner.split("|")[0].trim();
+  const byRef = ref.includes("/") ? wikilinkTailSlug(ref) : slugify(bareEntitySlug(ref));
+  return byRef || "item";
+}
+function ensureEntryId(equipment, index, registry) {
+  const { ownerOfId } = idOwners(equipment);
+  const own = nonEmptyRef(equipment[index].id);
+  if (own !== null && ownerOfId.get(own) === index) return own;
+  const taken = /* @__PURE__ */ new Set();
+  for (const entry of equipment) {
+    const a = nonEmptyRef(entry.id);
+    if (a !== null) taken.add(a);
+    const b = nonEmptyRef(entry.in);
+    if (b !== null) taken.add(b);
+  }
+  const base = mintBase(equipment[index], registry);
+  let id = base;
+  for (let k = 2; taken.has(id); k++) id = `${base}-${k}`;
+  equipment[index].id = id;
+  return id;
+}
+function canMoveInto(equipment, index, target, registry) {
+  var _a;
+  const inRange = (i) => Number.isInteger(i) && i >= 0 && i < equipment.length;
+  if (!inRange(index) || target !== null && !inRange(target)) return { ok: false, reason: "out-of-range" };
+  if (target === null) return { ok: true };
+  if (equipment[index].equipped === true) return { ok: false, reason: "equipped" };
+  if (target === index) return { ok: false, reason: "self" };
+  const view = resolveContainment(equipment, registry);
+  const unresolvedLink = new Set(view.broken.filter((b) => b.reason === "unresolved").map((b) => b.index));
+  const seen = /* @__PURE__ */ new Set();
+  for (let cur = target; cur !== null && !seen.has(cur); ) {
+    if (cur === index) return { ok: false, reason: "descendant" };
+    seen.add(cur);
+    const up = view.parentOf[cur];
+    if (up !== null) {
+      cur = up;
+      continue;
+    }
+    if (unresolvedLink.has(cur)) {
+      const raw = nonEmptyRef(equipment[cur].in);
+      cur = raw === null ? null : (_a = view.ownerOfId.get(raw)) != null ? _a : null;
+      continue;
+    }
+    cur = null;
+  }
+  const entity = entityOfEntry(equipment[target], registry);
+  if (entity === null) return { ok: false, reason: "unresolved" };
+  if (!isContainerItem(entity)) return { ok: false, reason: "not-container" };
+  return { ok: true };
+}
+function moveInto(equipment, index, target, registry) {
+  const check = canMoveInto(equipment, index, target, registry);
+  if (!check.ok) return check;
+  const entry = equipment[index];
+  if (target === null) {
+    const had = entry.in !== void 0;
+    delete entry.in;
+    return { ok: true, changed: had };
+  }
+  const wasHonoured = resolveContainment(equipment, registry).parentOf[index] === target;
+  const idBefore = equipment[target].id;
+  const id = ensureEntryId(equipment, target, registry);
+  entry.in = id;
+  return { ok: true, changed: idBefore !== id || !wasHonoured };
+}
+function repairContainment(equipment, registry) {
+  if (!registry) return 0;
+  let removed = 0;
+  for (const entry of equipment) {
+    if (entry.id === "") {
+      delete entry.id;
+      removed++;
+    }
+    if (entry.in === "") {
+      delete entry.in;
+      removed++;
+    }
+  }
+  const view = resolveContainment(equipment, registry);
+  for (const b of view.broken) {
+    if (b.reason === "unresolved") continue;
+    delete equipment[b.index].in;
+    removed++;
+  }
+  for (const i of view.duplicateIds) {
+    delete equipment[i].id;
+    removed++;
+  }
+  return removed;
+}
+
+export {
+  nonEmptyRef,
+  isContainerItem,
+  idOwners,
+  entityOfEntry,
+  resolveContainment,
+  ensureEntryId,
+  canMoveInto,
+  moveInto,
+  repairContainment
+};

package/dist/{chunk-SMLXZUBH.js → chunk-EYX4JMAU.js}

@@ -1,6 +1,6 @@
 import {
   itemEntitySchema
-} from "./chunk-GFZ7PITJ.js";
+} from "./chunk-S3YUXDSC.js";
 
 // src/item/item.parser.ts
 import { parseYaml } from "@archivist-gg/core";
@@ -25,6 +25,8 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "sentient",
   "focus",
   "tier",
+  "tattoo",
+  // declared I2a; the converter emits it (27 carriers)
   "damage",
   "weapon_category",
   "armor_category",
@@ -46,6 +48,7 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   // copied into `raw` as well, so the two lists must move together.
   "modify_speed",
   "rendering_hint",
+  "icon",
   "has_fluff",
   "has_fluff_images",
   "image",

package/dist/{chunk-V6LJFP4R.js → chunk-FANQVQ3D.js}

@@ -1,9 +1,9 @@
 import {
   featureSchema
-} from "./chunk-PI4LLJG4.js";
+} from "./chunk-YD2VAHA6.js";
 import {
   choiceSchema
-} from "./chunk-2M34FLAY.js";
+} from "./chunk-5MXFW4O3.js";
 import {
   additionalSpellsEntrySchema,
   imageField

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

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

package/dist/{chunk-23LZLBJK.js → chunk-G6MHJDVT.js}

@@ -11,8 +11,12 @@ var selectionPoolSchema = z.object({
       available_to: z.literal("self")
     })
   }),
-  count: z.object({ column: z.string().min(1) }),
-  replaceable: z.boolean().optional()
+  // ART-a (spec §4.5): `count.label`, `active` and `head_resource` carry NO zod default: the defaults are applied at
+  // read by `poolCountLabel` / `poolActiveWords`, so a parse never adds a key (the importer's round trip).
+  count: z.object({ column: z.string().min(1), label: z.string().min(1).optional() }),
+  replaceable: z.boolean().optional(),
+  active: z.object({ column: z.string().min(1), label: z.string().min(1), verb: z.string().min(1), counter_label: z.string().min(1).optional(), create_label: z.string().min(1).optional(), create_verb: z.string().min(1).optional() }).optional(),
+  head_resource: z.string().min(1).optional()
 });
 var poolGrantSchema = z.object({
   pool: z.string().min(1),

package/dist/{chunk-JANNRGJC.js → chunk-G6PBI2BU.js}

@@ -1,6 +1,6 @@
 import {
   parseOptionalFeature
-} from "./chunk-PJMG5XV3.js";
+} from "./chunk-PQZ4LM4Z.js";
 
 // src/optional-feature/optional-feature.codec.ts
 import yaml from "js-yaml";

package/dist/chunk-H5PTKYXL.js

@@ -0,0 +1,101 @@
+import {
+  ALL_TOOLS,
+  ARTISANS_TOOLS,
+  GAMING_SETS,
+  MUSICAL_INSTRUMENTS
+} from "./chunk-KU3YLF6D.js";
+import {
+  toProfSlug
+} from "./chunk-RLGQ5PZZ.js";
+
+// src/pc/pc.tool-picks.ts
+var TOOL_CATEGORIES = {
+  "musical-instrument": { pool: MUSICAL_INSTRUMENTS, itemType: "instrument", label: "a musical instrument" },
+  "artisan's-tools": { pool: ARTISANS_TOOLS, itemType: "artisan's tools", label: "artisan's tools" },
+  "gaming-set": { pool: GAMING_SETS, itemType: "gaming set", label: "a gaming set" }
+};
+function categoryWords(token) {
+  return token.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase().replace(/['’ʼ]/g, "").split(/[\s_-]+/).filter(Boolean).map((w) => w.length > 3 && w.endsWith("s") && !w.endsWith("ss") ? w.slice(0, -1) : w);
+}
+var CATEGORY_BY_WORDS = /* @__PURE__ */ new Map([
+  ["musical instrument", "musical-instrument"],
+  ["artisan tool", "artisan's-tools"],
+  ["gaming set", "gaming-set"]
+]);
+function toolCategoriesOf(token) {
+  const parts = [[]];
+  for (const w of categoryWords(token)) {
+    if (w === "or") parts.push([]);
+    else parts[parts.length - 1].push(w);
+  }
+  const out = [];
+  for (const p of parts) {
+    const c = CATEGORY_BY_WORDS.get(p.filter((w) => w !== "any" && w !== "one").join(" "));
+    if (!c) return void 0;
+    if (!out.includes(c)) out.push(c);
+  }
+  return out;
+}
+function expandToolPool(from) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (v) => {
+    const k = toProfSlug(v);
+    if (seen.has(k)) return;
+    seen.add(k);
+    out.push(v);
+  };
+  for (const v of from) {
+    const cats = toolCategoriesOf(v);
+    if (cats) for (const c of cats) for (const t of TOOL_CATEGORIES[c].pool) add(t);
+    else add(v);
+  }
+  return out;
+}
+var EMPTY = { decisions: [], grants: [] };
+var poolOf = (from) => Array.isArray(from) ? from.filter((v) => typeof v === "string" && v.length > 0) : typeof from === "string" && from.length > 0 ? [from] : [];
+var countOf = (count) => {
+  const n = Number(count != null ? count : 1);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 1;
+};
+var KNOWN_TOOLS = new Set(ALL_TOOLS.map(toProfSlug));
+var namesToolsOutright = (from) => from.every((v) => !toolCategoriesOf(v) && KNOWN_TOOLS.has(toProfSlug(v)));
+var authorsToolPick = (choices) => Array.isArray(choices) && choices.some((c) => !!c && typeof c === "object" && c.kind === "select-proficiency" && c.domain === "tool");
+function toolPick(count, from, id, allowDecision) {
+  const authored = poolOf(from);
+  const pool = expandToolPool(authored);
+  const n = countOf(count);
+  if (pool.length === 0) return EMPTY;
+  if (n >= pool.length && namesToolsOutright(authored)) return { decisions: [], grants: pool };
+  if (!allowDecision) return EMPTY;
+  return { decisions: [{ kind: "select-proficiency", id, count: n, domain: "tool", from: pool }], grants: [] };
+}
+function classToolPicks(entity) {
+  var _a;
+  const tools = (_a = entity == null ? void 0 : entity.proficiencies) == null ? void 0 : _a.tools;
+  const choice = tools == null ? void 0 : tools.choice;
+  if (!choice || typeof choice !== "object") return EMPTY;
+  return toolPick(choice.count, choice.from, "tool", !authorsToolPick(entity == null ? void 0 : entity.choices));
+}
+function backgroundToolPicks(bg) {
+  const entries = Array.isArray(bg == null ? void 0 : bg.tool_proficiencies) ? bg.tool_proficiencies : [];
+  const allowDecision = !authorsToolPick(bg == null ? void 0 : bg.choices);
+  const out = { decisions: [], grants: [] };
+  for (const e of entries) {
+    if (!e || typeof e !== "object" || e.kind !== "choice") continue;
+    const id = out.decisions.length === 0 ? "tool" : `tool-${out.decisions.length + 1}`;
+    const r = toolPick(e.count, e.from, id, allowDecision);
+    out.decisions.push(...r.decisions);
+    out.grants.push(...r.grants);
+  }
+  return out;
+}
+
+export {
+  TOOL_CATEGORIES,
+  categoryWords,
+  toolCategoriesOf,
+  expandToolPool,
+  classToolPicks,
+  backgroundToolPicks
+};

package/dist/{chunk-LWFTHJIE.js → chunk-HHBD4SQ6.js}

@@ -1,6 +1,6 @@
 import {
   evaluateConditions
-} from "./chunk-DNAJRMNN.js";
+} from "./chunk-A54HHCWW.js";
 
 // src/item/item.bonuses.ts
 function isConditionalBonus(x) {

package/dist/{chunk-JC5UNIVM.js → chunk-HS6FIOLP.js}

@@ -32,6 +32,8 @@ var armorEntitySchema = z.object({
   // string today, so `.min(1)` is forbidden here.
   rendering_hint: z.string().optional(),
   // 27
+  // The icon key (I3): a key of the renderer's icon set or a Lucide name; itemIconKey reads it first.
+  icon: z.string().optional(),
   has_fluff: z.boolean().optional(),
   // 0 carriers — symmetry with weapon
   has_fluff_images: z.boolean().optional(),