@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/types/optional-feature.types.d.ts

@@ -2,15 +2,24 @@ import type { FeatureEffect } from "./feature-effect.js";
 import type { ActionCost, ResetTrigger, ResourceConsumption } from "./resource.js";
 import type { Duration } from "../schemas/duration-schema.js";
 import type { Edition } from "./edition.js";
+import type { AdditionalSpellsEntry, ProgressionEntry } from "../schemas/entity-extras-schema.js";
 /**
  * Documentation-only union of the canonical SRD feature types. The
  * `feature_type` field is now an open string (see {@link OptionalFeatureEntity})
  * so homebrew categories parse; this union is kept purely as a reference list.
  */
 export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion";
+/** A class/subclass named reference carried by a level prerequisite; mirrors namedRefSchema. */
+export type OptionalFeatureNamedRef = {
+    name: string;
+    source?: string;
+    visible_stats?: boolean;
+};
 export type OptionalFeaturePrerequisite = {
     kind: "level";
     min: number;
+    class?: OptionalFeatureNamedRef;
+    subclass?: OptionalFeatureNamedRef;
 } | {
     kind: "spell-known";
     spell: string;
@@ -27,6 +36,14 @@ export type OptionalFeaturePrerequisite = {
 } | {
     kind: "other";
     detail: string;
+} | {
+    kind: "optionalfeature";
+    optionalfeature: string;
+} | {
+    kind: "spell-choose";
+    choose: string;
+    entry?: string;
+    entry_summary?: string;
 };
 export interface OptionalFeatureEntity {
     slug: string;
@@ -57,4 +74,15 @@ export interface OptionalFeatureEntity {
     /** Phase 3 activatable buffs: when true, the boon's effects fold only while its
      *  slug is present in `Character.state.active_buffs` (toggled in the PoolTab). */
     activatable?: boolean;
+    /** Converter extras declared by optional-feature.schema.ts §2.5; all optional.
+     *  `rendering_hint` is the ONE of these whose VALUES are load-bearing (88 records carry a
+     *  real marker such as `dice-pool`); reading it is G4's row, declaring it is this one's. */
+    rendering_hint?: string;
+    additional_spells?: AdditionalSpellsEntry[];
+    is_class_feature_variant?: boolean;
+    has_fluff_images?: boolean;
+    feat_progression?: ProgressionEntry[];
+    optionalfeature_progression?: ProgressionEntry[];
+    /** One wikilink, or an array of them for the multi-fluff-image emit. */
+    image?: string | string[];
 }

package/dist/types/resource.d.ts

@@ -1,4 +1,6 @@
-export type ResetTrigger = "short-rest" | "long-rest" | "dawn" | "dusk" | "turn" | "round" | "custom";
+/** `either` = recovered by a short OR a long rest (R4-G3a §8.2; the 43 "short or
+ *  long rest" rows). Kept in step with `resetTriggerEnum` in schemas/resource-schema.ts. */
+export type ResetTrigger = "short-rest" | "long-rest" | "either" | "dawn" | "dusk" | "turn" | "round" | "custom";
 export type ActionCost = "action" | "bonus-action" | "reaction" | "free" | "special";
 export interface ResourceDie {
     base: string;
@@ -11,6 +13,18 @@ export interface ResourceRecovery {
     action?: ActionCost;
     uses?: number;
     reset: ResetTrigger;
+    /** The recovery KIND; absent = `uses` (R4-G4 §7, UR2), applied by the RESOLVER
+     *  (pc/pc.resources.ts `resolveRecovery`) and never by a schema default, because
+     *  the sheet reads RAW entities. The CARRIERS, re-measured 2026-09-05 after R4-G4
+     *  T2b's regen shipped the bundle (this sentence was authored at T2, BEFORE that
+     *  regen, and said ZERO, which it no longer is): `grep -rl "restores:" --include='*.md'`
+     *  returns the TWO bundle Wizard notes (`SRD 2024/Classes/Wizard.md` and
+     *  `SRD 5e/Classes/Wizard.md`), whose Arcane Recovery rows T2b's overlay stamps
+     *  `spell-slots` and which §7.1 measured as the only spell-slot recoveries in shipped
+     *  data; the embedded `.compendium-bundle/index.json` carries the key on one line for
+     *  the same two rows; the converter corpus carries it on NO note. Kept in step with
+     *  `resourceSchema.recovery` in schemas/resource-schema.ts. */
+    restores?: "uses" | "spell-slots";
 }
 export interface ResourceScaleStep {
     level: number;
@@ -34,7 +48,13 @@ export interface ResourceConsumption {
     source?: "resource" | "class-column" | "attack-dice";
     resource?: string;
     column?: string;
+    /** The MINIMUM spend when `amount_max` is present, otherwise the exact spend. */
     amount: number;
+    /** Upper bound of a RANGE spend (`amount` .. `amount_max`), int and positive.
+     *  DECLARED only in R4-G3a §9: zero emitted carriers, zero readers; spending a
+     *  range is G4's. Kept in step with `resourceConsumptionSchema` in
+     *  schemas/resource-schema.ts, whose refine is undefined-safe. */
+    amount_max?: number;
     expend_condition?: "roll_succeeds" | "roll_fails" | "target_takes_damage" | "always";
     free_uses?: {
         amount: number;

package/dist/types/selection-pool.d.ts

@@ -24,8 +24,23 @@ export interface PoolGrant {
         at_level: number;
     }>;
 }
-/** Presentation hint for a data-declared tab. "text" reserved for later. */
-export type PoolLayout = "spell-like" | "blocks";
+/** Presentation hint for a data-declared tab. `dice-pool` / `point-pool` are DERIVED from the
+ *  members' `rendering_hint` at resolve time onto `ResolvedPool.layout` (pc/pool-layout.ts), and that
+ *  derivation is UNCONDITIONAL: it runs whether or not the declaration carries a `layout`. R4-G4 T5
+ *  LANDED the precedence in the plugin: `TabsContainer`'s dynamic-pool-tab loop reads the AUTHORED
+ *  value first, then `ResolvedPool.layout`, then the `spell-like` default, and `PoolTab`'s `LAYOUTS`
+ *  registry routes all four members (an unknown string degrades to `spell-like` and never throws).
+ *  R4-G5 CLOSED that list, and NOT by adding values: `pool-selection` and `stance` never get a layout value
+ *  (measured, spec §10: the three `stance`-hinted documents are field-identical to three unhinted siblings, and
+ *  `pool-selection`'s meaning is delivered by `spell-like` plus the §5 head), and `granted-die-to-ally` is a
+ *  PER-ROW affordance (`EntryAffordance` below), never a pool layout: mapping it here would bury four maneuvers
+ *  under 39 on one vote of 43. This union keeps its four members and `RENDERING_HINT_LAYOUT` its two keys. */
+export type PoolLayout = "spell-like" | "blocks" | "dice-pool" | "point-pool";
+/** A PER-ENTRY affordance derived from ONE optional feature's own `rendering_hint` (R4-G5 §4.2.1). The sibling of
+ *  `PoolLayout`, and deliberately not part of it: a layout is a POOL-level MAJORITY vote, so a hint carried by
+ *  four of 43 maneuvers could never win one, and mapping it would be a monotone loss for the other 39. The table,
+ *  the derivation and the caption live in `pc/pool-layout.ts`. ONE member today. */
+export type EntryAffordance = "granted-die";
 /** A data-declared tab that renders a pool (one generic pool-tab per declaration). */
 export interface TabDecl {
     id: string;

package/dist/weapon/weapon.classify.js

@@ -1,7 +1,7 @@
 import {
   classifyWeaponRange
-} from "../chunk-353WXS6S.js";
-import "../chunk-LV4SNWZQ.js";
+} from "../chunk-UIRMA5KM.js";
+import "../chunk-6X4KUDMU.js";
 export {
   classifyWeaponRange
 };

package/dist/weapon/weapon.codec.js

@@ -1,8 +1,9 @@
 import {
   weaponCodec
-} from "../chunk-5INR4NSL.js";
-import "../chunk-6NK2MUD3.js";
-import "../chunk-AFKTJXRA.js";
+} from "../chunk-LDDCNPHD.js";
+import "../chunk-HZA7OE7N.js";
+import "../chunk-2DFENQIJ.js";
+import "../chunk-UA5KS2PL.js";
 export {
   weaponCodec
 };

package/dist/weapon/weapon.parser.js

@@ -1,7 +1,8 @@
 import {
   parseWeapon
-} from "../chunk-6NK2MUD3.js";
-import "../chunk-AFKTJXRA.js";
+} from "../chunk-HZA7OE7N.js";
+import "../chunk-2DFENQIJ.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseWeapon
 };

package/dist/weapon/weapon.schema.d.ts

@@ -30,5 +30,9 @@ export declare const weaponEntitySchema: z.ZodObject<{
         2024: "2024";
     }>;
     entries: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$loose>;

package/dist/weapon/weapon.schema.js

@@ -1,6 +1,7 @@
 import {
   weaponEntitySchema
-} from "../chunk-AFKTJXRA.js";
+} from "../chunk-2DFENQIJ.js";
+import "../chunk-UA5KS2PL.js";
 export {
   weaponEntitySchema
 };

package/dist/weapon/weapon.types.d.ts

@@ -1,4 +1,6 @@
 import type { Edition } from "@archivist-gg/dnd5e/types/edition";
+import type { imageField } from "@archivist-gg/dnd5e/schemas/entity-extras-schema";
+import type { z } from "zod";
 export type WeaponCategory = "simple-melee" | "simple-ranged" | "martial-melee" | "martial-ranged" | "natural" | string;
 export type DamageType = "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
 export type ConditionalProperty = {
@@ -32,5 +34,11 @@ export interface WeaponEntity {
     page?: number;
     edition: Edition;
     entries?: unknown[];
+    /** Carried as the empty string on every converter weapon carrier today (98). */
+    rendering_hint?: string;
+    has_fluff?: boolean;
+    has_fluff_images?: boolean;
+    /** One wikilink, or an array for >= 2 fluff images (images-ON emit). */
+    image?: z.infer<typeof imageField>;
     raw?: Record<string, unknown>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@archivist-gg/dnd5e",
-  "version": "0.3.1",
-  "license": "MIT",
+  "version": "0.3.4",
+  "license": "MIT AND CC-BY-4.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/dist/chunk-5XUXXAQJ.js

@@ -1,30 +0,0 @@
-// src/pc/pc.table-column.ts
-function readTableColumn(table, level, keys) {
-  var _a;
-  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
-  if (!cols) return null;
-  for (const k of keys) {
-    const raw = cols[k];
-    if (raw === void 0 || raw === null) continue;
-    const n = typeof raw === "number" ? raw : parseInt(String(raw), 10);
-    if (!Number.isNaN(n)) return n;
-  }
-  return null;
-}
-function numericColumnsAt(table, level) {
-  var _a;
-  const out = {};
-  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
-  if (!cols) return out;
-  for (const [k, raw] of Object.entries(cols)) {
-    if (raw === void 0 || raw === null) continue;
-    const n = typeof raw === "number" ? raw : parseInt(String(raw), 10);
-    if (!Number.isNaN(n)) out[k] = n;
-  }
-  return out;
-}
-
-export {
-  readTableColumn,
-  numericColumnsAt
-};

package/dist/chunk-7P65Q426.js

@@ -1,158 +0,0 @@
-// 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-7TEK5KK7.js

@@ -1,49 +0,0 @@
-// 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 ALL_LANGUAGES = [...STANDARD_LANGUAGES, ...EXOTIC_LANGUAGES];
-
-export {
-  ALL_SKILL_SLUGS,
-  STANDARD_LANGUAGES,
-  EXOTIC_LANGUAGES,
-  ALL_LANGUAGES
-};

package/dist/chunk-AIRFC5NQ.js

@@ -1,143 +0,0 @@
-import {
-  bareEntitySlug
-} from "./chunk-LV4SNWZQ.js";
-import {
-  ABILITY_KEYS
-} from "./chunk-WP2CX2JO.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,
-    senses: { darkvision: 0, blindsight: 0, tremorsense: 0, truesight: 0 },
-    ac_terms: [],
-    resistances: [],
-    condition_immunities: [],
-    proficiencies: { skills: [], tools: [], languages: [], saves: [], armor: [], weapons: [] },
-    weaponAbilities: [],
-    rollModifiers: [],
-    critRange: 20,
-    extraAttack: 0,
-    attackNotes: [],
-    damageBonuses: []
-  };
-}
-var ABILITY_NAME_TO_KEY = {
-  strength: "str",
-  dexterity: "dex",
-  constitution: "con",
-  intelligence: "int",
-  wisdom: "wis",
-  charisma: "cha"
-};
-function normalizeAbility(value) {
-  var _a;
-  const k = value.trim().toLowerCase();
-  if (ABILITY_KEYS.includes(k)) return k;
-  return (_a = ABILITY_NAME_TO_KEY[k]) != null ? _a : null;
-}
-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 computeFeatureEffects(features, opts) {
-  var _a, _b, _c;
-  const out = emptyFeatureEffectTotals();
-  for (const rf of features) {
-    if (rf.feature.activatable === true) {
-      const id = rf.feature.id;
-      if (!id || !((_a = opts == null ? void 0 : opts.activeBuffs) == null ? void 0 : _a.has(id))) continue;
-    }
-    for (const eff of (_b = rf.feature.effects) != null ? _b : []) {
-      applyEffect(out, eff, (_c = rf.feature.name) != null ? _c : "Feature");
-    }
-  }
-  return out;
-}
-function applyEffect(out, eff, label) {
-  var _a, _b;
-  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":
-      if (eff.mode === "walk") {
-        if (eff.set) out.speed_walk_set = Math.max(out.speed_walk_set, eff.value);
-        else out.speed_walk_bonus += eff.value;
-      }
-      break;
-    case "sense":
-      out.senses[eff.type] = Math.max(out.senses[eff.type], eff.range);
-      break;
-    case "resistance":
-      pushUnique(out.resistances, eff.damage_type);
-      break;
-    case "immune-condition":
-      if (!eff.while) pushUnique(out.condition_immunities, eff.condition);
-      break;
-    case "proficiency": {
-      if (eff.proficiency_type === "skill") {
-        pushUnique(out.proficiencies.skills, eff.value.toLowerCase().replace(/\s+/g, "-"));
-      } else if (eff.proficiency_type === "tool") {
-        pushUnique(out.proficiencies.tools, eff.value);
-      } else if (eff.proficiency_type === "language") {
-        pushUnique(out.proficiencies.languages, eff.value);
-      } else if (eff.proficiency_type === "armor") {
-        pushUnique(out.proficiencies.armor, eff.value.toLowerCase());
-      } else if (eff.proficiency_type === "weapon") {
-        pushUnique(out.proficiencies.weapons, eff.value.toLowerCase());
-      } else {
-        const ab = normalizeAbility(eff.value);
-        if (ab && !out.proficiencies.saves.includes(ab)) out.proficiencies.saves.push(ab);
-      }
-      break;
-    }
-    case "ac-bonus":
-      out.ac_terms.push({ value: eff.value, requires_armor: eff.requires_armor === true, label });
-      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":
-      out.rollModifiers.push({ mode: eff.mode, roll: eff.roll, scope: eff.scope, condition: eff.condition, label });
-      break;
-    case "crit-range":
-      if (((_a = eff.applies_to) != null ? _a : "weapon") !== "spell") out.critRange = Math.min(out.critRange, eff.min_roll);
-      break;
-    case "extra-attack":
-      out.extraAttack = Math.max(out.extraAttack, eff.count);
-      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 (((_b = eff.applies_to) != null ? _b : "weapon") !== "spell") {
-        out.damageBonuses.push({ amount: eff.amount, damage_type: eff.damage_type, source: label });
-      }
-      break;
-    default:
-      break;
-  }
-}
-
-export {
-  emptyFeatureEffectTotals,
-  computeFeatureEffects
-};

package/dist/chunk-CZPMTQOY.js

@@ -1,68 +0,0 @@
-import {
-  durationSchema
-} from "./chunk-WYGD2UGN.js";
-import {
-  resourceConsumptionSchema,
-  resourceSchema
-} from "./chunk-PZOWBI3B.js";
-import {
-  choiceSchema
-} from "./chunk-NXSWH3AE.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
-};