@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/chunk-OZP6JFGT.js

@@ -0,0 +1,162 @@
+import {
+  spellEntitySchema
+} from "./chunk-VQAXTIBW.js";
+
+// src/spell/spell.parser.ts
+import { parseYaml, toStringSafe } from "@archivist-gg/core";
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "level",
+  "school",
+  "casting_time",
+  "range",
+  "components",
+  "duration",
+  "concentration",
+  "ritual",
+  "classes",
+  "description",
+  "at_higher_levels",
+  "damage",
+  "saving_throw",
+  "casting_options",
+  // §2 · the fourteen converter keys. This gate and `spellEntitySchema` are independent: a key
+  // missing here is refused BEFORE zod ever sees it, so both must learn every new key.
+  "rendering_hint",
+  "misc_tags",
+  "area_tags",
+  "condition_inflict",
+  "affects_creature_type",
+  "spell_attack",
+  "ability_check",
+  "damage_resist",
+  "damage_immune",
+  "condition_immune",
+  "damage_vulnerable",
+  "has_fluff",
+  "image",
+  "has_fluff_images",
+  // Body-only metadata that's emitted to YAML but ignored at runtime — accept silently.
+  "slug",
+  "edition",
+  "source"
+]);
+var DURATION_END_WORDS = { dispel: "dispelled", trigger: "triggered" };
+function normalizeSpellComponents(value) {
+  if (typeof value === "string") return value;
+  if (value == null || typeof value !== "object" || Array.isArray(value)) return toStringSafe(value);
+  const c = value;
+  const parts = [];
+  if (c.v === true) parts.push("V");
+  if (c.s === true) parts.push("S");
+  if (typeof c.m === "string") parts.push(`M (${c.m})`);
+  else if (c.m === true) parts.push("M");
+  else if (c.m != null && typeof c.m === "object") {
+    const text = c.m.text;
+    parts.push(typeof text === "string" ? `M (${text})` : "M");
+  }
+  if (c.r === true) parts.push("R");
+  return parts.join(", ");
+}
+function normalizeSpellDurationEntry(entry) {
+  if (entry == null || typeof entry !== "object") return toStringSafe(entry);
+  const e = entry;
+  if (e.type === "permanent" && Array.isArray(e.ends)) {
+    return "until " + e.ends.map((w) => {
+      var _a;
+      return (_a = DURATION_END_WORDS[String(w)]) != null ? _a : String(w);
+    }).join(" or ");
+  }
+  if (e.type === "timed" && e.duration != null) {
+    const unit = e.duration.type;
+    const amount = e.duration.amount;
+    if (typeof unit === "string" && typeof amount === "number") {
+      const prefix = e.duration.up_to === true ? "up to " : "";
+      return `${prefix}${amount} ${unit}${amount > 1 ? "s" : ""}`;
+    }
+  }
+  return toStringSafe(entry);
+}
+function normalizeSpellDuration(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return toStringSafe(value);
+  return value.map((entry) => normalizeSpellDurationEntry(entry)).join("; ");
+}
+function mirrorSpellShapes(entity) {
+  return {
+    ...entity,
+    ...entity.components != null ? { components: normalizeSpellComponents(entity.components) } : {},
+    ...entity.duration != null ? { duration: normalizeSpellDuration(entity.duration) } : {}
+  };
+}
+function parseSpell(source) {
+  const result = parseYaml(source, ["name"]);
+  if (!result.success) return result;
+  const meta = {};
+  if (typeof result.data.source === "string") meta.source = result.data.source;
+  if (typeof result.data.edition === "string") meta.edition = result.data.edition;
+  const filtered = {};
+  for (const [k, v] of Object.entries(result.data)) {
+    if (k === "slug" || k === "edition" || k === "source") continue;
+    if (!KNOWN_KEYS.has(k)) {
+      return { success: false, error: `Unknown spell field: ${k}` };
+    }
+    filtered[k] = v;
+  }
+  const parsed = spellEntitySchema.safeParse(filtered);
+  if (!parsed.success) {
+    return { success: false, error: `spell schema validation failed: ${parsed.error.message}` };
+  }
+  const raw = parsed.data;
+  const spell = { name: raw.name };
+  if (raw.level != null) spell.level = raw.level;
+  if (raw.school != null) spell.school = toStringSafe(raw.school);
+  if (raw.casting_time != null) spell.casting_time = toStringSafe(raw.casting_time);
+  if (raw.range != null) spell.range = toStringSafe(raw.range);
+  if (raw.components != null) spell.components = normalizeSpellComponents(raw.components);
+  if (raw.duration != null) spell.duration = normalizeSpellDuration(raw.duration);
+  if (raw.concentration != null) spell.concentration = Boolean(raw.concentration);
+  if (raw.ritual != null) spell.ritual = Boolean(raw.ritual);
+  if (raw.classes) spell.classes = raw.classes.map(String);
+  if (raw.description) spell.description = raw.description;
+  if (raw.at_higher_levels) spell.at_higher_levels = raw.at_higher_levels.map(String);
+  if (raw.damage) spell.damage = { types: raw.damage.types.map(String) };
+  if (raw.saving_throw) spell.saving_throw = { ability: raw.saving_throw.ability };
+  if (raw.casting_options) {
+    spell.casting_options = raw.casting_options.map((opt) => {
+      const co = { type: opt.type };
+      if (opt.damage_roll !== void 0) co.damage_roll = opt.damage_roll;
+      if (opt.target_count !== void 0) co.target_count = opt.target_count;
+      if (opt.duration !== void 0) co.duration = opt.duration;
+      if (opt.range !== void 0) co.range = opt.range;
+      if (opt.concentration !== void 0) co.concentration = opt.concentration;
+      if (opt.shape_size !== void 0) co.shape_size = opt.shape_size;
+      if (opt.desc !== void 0) co.desc = opt.desc;
+      return co;
+    });
+  }
+  if (raw.rendering_hint != null) spell.rendering_hint = raw.rendering_hint;
+  if (raw.misc_tags != null) spell.misc_tags = raw.misc_tags;
+  if (raw.area_tags != null) spell.area_tags = raw.area_tags;
+  if (raw.condition_inflict != null) spell.condition_inflict = raw.condition_inflict;
+  if (raw.affects_creature_type != null) spell.affects_creature_type = raw.affects_creature_type;
+  if (raw.spell_attack != null) spell.spell_attack = raw.spell_attack;
+  if (raw.ability_check != null) spell.ability_check = raw.ability_check;
+  if (raw.damage_resist != null) spell.damage_resist = raw.damage_resist;
+  if (raw.damage_immune != null) spell.damage_immune = raw.damage_immune;
+  if (raw.condition_immune != null) spell.condition_immune = raw.condition_immune;
+  if (raw.damage_vulnerable != null) spell.damage_vulnerable = raw.damage_vulnerable;
+  if (raw.has_fluff != null) spell.has_fluff = raw.has_fluff;
+  if (raw.image != null) spell.image = raw.image;
+  if (raw.has_fluff_images != null) spell.has_fluff_images = raw.has_fluff_images;
+  if (meta.source) spell.source = meta.source;
+  if (meta.edition) spell.edition = meta.edition;
+  return { success: true, data: spell };
+}
+
+export {
+  normalizeSpellComponents,
+  normalizeSpellDuration,
+  mirrorSpellShapes,
+  parseSpell
+};

package/dist/{chunk-NAEPSZAM.js → chunk-PDJSUH24.js}

@@ -2,8 +2,9 @@ import {
   ABILITY_KEYS,
   CR_PROFICIENCY,
   CR_XP,
+  DAMAGE_TYPES,
   SIZE_HIT_DICE
-} from "./chunk-WP2CX2JO.js";
+} from "./chunk-WELIKLZF.js";
 
 // src/dnd/math.ts
 function abilityModifier(score) {
@@ -68,6 +69,22 @@ function abilityNameToKey(name) {
   }
   return null;
 }
+var CANONICAL_DAMAGE_TYPES = new Set(DAMAGE_TYPES.map((t) => t.toLowerCase()));
+function isCanonicalDamageType(type) {
+  return CANONICAL_DAMAGE_TYPES.has(type.trim().toLowerCase());
+}
+var CHOSEN_DAMAGE_TYPE = "chosen";
+var CHOSEN_DAMAGE_TYPE_NOTE = "damage type of your choice";
+function isChosenDamageType(type) {
+  return type !== void 0 && type.trim().toLowerCase() === CHOSEN_DAMAGE_TYPE;
+}
+function isRenderableDamageText(text) {
+  var _a;
+  const m = /^(?:\d*d\d+(?:\s*[+-]\s*\d+)?|[+-]?\d+)(?:\s+(.*))?$/i.exec(text.trim());
+  if (!m) return false;
+  const type = ((_a = m[1]) != null ? _a : "").trim();
+  return type === "" || isCanonicalDamageType(type);
+}
 
 export {
   abilityModifier,
@@ -84,5 +101,10 @@ export {
   passivePerception,
   attackBonus,
   saveDC,
-  abilityNameToKey
+  abilityNameToKey,
+  isCanonicalDamageType,
+  CHOSEN_DAMAGE_TYPE,
+  CHOSEN_DAMAGE_TYPE_NOTE,
+  isChosenDamageType,
+  isRenderableDamageText
 };

package/dist/chunk-PP2UHLBA.js

@@ -0,0 +1,50 @@
+// src/pc/pool-layout.ts
+var RENDERING_HINT_LAYOUT = {
+  "dice-pool": "dice-pool",
+  "point-pool": "point-pool"
+};
+function derivePoolLayout(entries) {
+  var _a, _b;
+  const votes = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const hint = (_a = e.entity.rendering_hint) != null ? _a : "";
+    if (!Object.prototype.hasOwnProperty.call(RENDERING_HINT_LAYOUT, hint)) continue;
+    const layout = RENDERING_HINT_LAYOUT[hint];
+    votes.set(layout, ((_b = votes.get(layout)) != null ? _b : 0) + 1);
+  }
+  let best;
+  let bestN = 0;
+  let tied = false;
+  for (const [layout, n] of votes) {
+    if (n > bestN) {
+      best = layout;
+      bestN = n;
+      tied = false;
+    } else if (n === bestN) tied = true;
+  }
+  return tied ? void 0 : best;
+}
+var RENDERING_HINT_AFFORDANCE = {
+  "granted-die-to-ally": "granted-die"
+};
+function deriveEntryAffordance(entity) {
+  var _a;
+  const hint = (_a = entity.rendering_hint) != null ? _a : "";
+  if (!Object.prototype.hasOwnProperty.call(RENDERING_HINT_AFFORDANCE, hint)) return void 0;
+  return RENDERING_HINT_AFFORDANCE[hint];
+}
+var AFFORDANCE_CAPTIONS = {
+  "granted-die": "{amount}{die} to an ally"
+};
+function formatAffordanceCaption(affordance, values) {
+  return AFFORDANCE_CAPTIONS[affordance].replace(/\{(\w+)\}/g, (whole, key) => Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : whole);
+}
+
+export {
+  RENDERING_HINT_LAYOUT,
+  derivePoolLayout,
+  RENDERING_HINT_AFFORDANCE,
+  deriveEntryAffordance,
+  AFFORDANCE_CAPTIONS,
+  formatAffordanceCaption
+};

package/dist/chunk-PVCEA4HZ.js

@@ -0,0 +1,6 @@
+// src/race/race.structural.ts
+var RACE_STRUCTURAL_PSEUDO = /* @__PURE__ */ new Set(["size", "speed", "darkvision"]);
+
+export {
+  RACE_STRUCTURAL_PSEUDO
+};

package/dist/{chunk-XLSVNUTK.js → chunk-R3VAKWKW.js}

@@ -1,6 +1,6 @@
 import {
   parseSubclass
-} from "./chunk-L7E2UT5A.js";
+} from "./chunk-HB7XZXDK.js";
 
 // src/subclass/subclass.codec.ts
 import yaml from "js-yaml";

package/dist/chunk-RIXI5D3R.js

@@ -0,0 +1,89 @@
+import {
+  actionCostEnum,
+  resourceSchema
+} from "./chunk-YLL2QXY2.js";
+import {
+  choiceSchema
+} from "./chunk-T26ZVCL5.js";
+import {
+  featureEffectSchema
+} from "./chunk-WPWOHGPI.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.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) }),
+  // The exclusive-feat-category and feat-category arms carry a raw 5etools category code, not a
+  // slug; featCategoryLabel names it. The rest carry slugs the renderer humanizes, except other,
+  // which carries free prose that prereqText returns verbatim.
+  z.object({ kind: z.literal("feat"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("campaign"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("exclusive-feat-category"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("feature"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("other"), detail: z.string().min(1) }),
+  z.object({ kind: z.literal("feat-category"), slug: z.string().min(1) }),
+  z.object({ kind: z.literal("background"), 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),
+  rendering_hint: z.string().optional(),
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 71
+  has_fluff: z.boolean().optional(),
+  // 0 carriers — symmetry, §9.4
+  has_fluff_images: z.boolean().optional(),
+  // 41
+  trait_tags: z.unknown().optional(),
+  // 7, nullable measured — same passthrough family
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 4
+  resources: z.array(resourceSchema).optional(),
+  // closes the feat.types.ts `Feat.resources` schema/type asymmetry (C);
+  // ZERO converter/bundle carriers (no census row) — the only behaviour delta is AUTHORED feats,
+  // where the type has promised the field all along. Import resourceSchema.
+  action_cost: actionCostEnum.optional(),
+  // ruling R-G1b-5 (gate1-r1 f1): a TOP-LEVEL bundle key on ONE
+  // feat (`SRD 2024/Feats/Boon of the Night Spirit.md`, `action_cost: bonus-action` at entity top
+  // level) — the ninth SRD-control non-kept row: top-level on the ENTITY, not featureSchema-shaped
+  // (finding 14's nine rows split 4 featureSchema / 4 §2.8-arity / this one, which needed its own
+  // declaration — gate1-r4 R4-1). `actionCostEnum` is exported from
+  // `schemas/resource-schema.ts` (optionalFeatureEntitySchema already imports it). MAPPED since
+  // R4-G3a §10.2.3: the resolver aliases it onto the resolved feature's `action`, which is what
+  // draws the feat note's Action line and files the row under that economy.
+  image: imageField
+});
+
+export {
+  featEntitySchema
+};

package/dist/chunk-RLGQ5PZZ.js

@@ -0,0 +1,16 @@
+// src/pc/pc.proficiency-normalize.ts
+var normKey = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).map((w) => w.endsWith("s") ? w.slice(0, -1) : w).sort().join(" ");
+var toProfSlug = (s) => s.toLowerCase().replace(/’/g, "'").trim().replace(/\s+/g, "-");
+var humanizeProficiency = (s) => s.replace(/-/g, " ").replace(/(^|\s)\w/g, (c) => c.toUpperCase());
+var proficiencyLabel = (raw) => {
+  const text = raw.replace(/’/g, "'").trim().replace(/\s+/g, " ");
+  if (!/\s/.test(text) || text === text.toLowerCase()) return humanizeProficiency(toProfSlug(raw));
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+
+export {
+  normKey,
+  toProfSlug,
+  humanizeProficiency,
+  proficiencyLabel
+};

package/dist/chunk-S7REMWW4.js

@@ -0,0 +1,21 @@
+// src/pc/conditions.constants.ts
+var CONDITION_SLUGS = [
+  "blinded",
+  "charmed",
+  "deafened",
+  "frightened",
+  "grappled",
+  "incapacitated",
+  "invisible",
+  "paralyzed",
+  "petrified",
+  "poisoned",
+  "prone",
+  "restrained",
+  "stunned",
+  "unconscious"
+];
+
+export {
+  CONDITION_SLUGS
+};

package/dist/{chunk-7VJ6BOA5.js → chunk-SMLXZUBH.js}

@@ -1,6 +1,6 @@
 import {
   itemEntitySchema
-} from "./chunk-K6Q5OUGK.js";
+} from "./chunk-GFZ7PITJ.js";
 
 // src/item/item.parser.ts
 import { parseYaml } from "@archivist-gg/core";
@@ -41,6 +41,14 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "scroll_level",
   "unidentified",
   "masked_category",
+  // Modelled top-level converter keys (spec §4). 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.
+  "modify_speed",
+  "rendering_hint",
+  "has_fluff",
+  "has_fluff_images",
+  "image",
   // Legacy fields kept (removed in Slice 7 after grep verifies no consumer)
   "damage_dice",
   "damage_type",

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
+};