@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/types/feature.d.ts

@@ -1,5 +1,5 @@
 import type { Choice } from "./choice.js";
-import type { Resource, ResourceConsumption } from "./resource.js";
+import type { Resource, ResourceConsumption, ActionCost } from "./resource.js";
 import type { Attack } from "./attack.js";
 import type { FeatureEffect } from "./feature-effect.js";
 import type { Duration } from "../schemas/duration-schema.js";
@@ -15,6 +15,56 @@ export interface FeatureRecharge {
     type: "recharge_on_roll" | "per_day" | "per_short_rest" | "per_long_rest";
     param: number;
 }
+/** The converter's 14-key companion binding (R4-G5 §7, ruling G5-UR2 "declare now, card after the G7 re-emit").
+ *  DECLARED, not read: the converter withholds the key today (`P9_NOT_EMITTED_FIELDS`), 0 converted and 0 bundle
+ *  notes carry it, and the Passive-tab card is a G8 booking. Every closed-vocabulary leaf is a plain `string` and
+ *  every position the converter can emit as null is `| null`, for the reason the schema mirror states: a class,
+ *  subclass or race parser refuses a WHOLE document on one nested leaf failure, so a mirror stricter than the
+ *  emitter is a total-loss risk on the day the re-emit lands. */
+export interface FeatureCompanion {
+    statblock?: string;
+    statblock_wikilink?: string | null;
+    count?: string;
+    count_scaling?: Array<{
+        level?: number;
+        count?: string;
+        source_quote?: string;
+    }>;
+    shares_action_economy?: boolean;
+    turn_order?: string;
+    turn_order_source_quote?: string | null;
+    proficiency_bonus_scaled?: Array<{
+        stat?: string;
+        formula?: string;
+        source_quote?: string;
+    }>;
+    lifecycle?: {
+        created_by?: string;
+        recreate_on?: string | null;
+        previous_instance_perishes?: boolean | null;
+        vanishes_if_owner_dies?: boolean | null;
+        vanishes_after?: string | null;
+        source_quote?: string;
+    } | null;
+    autonomy?: {
+        when?: string;
+        behaviour?: string;
+        source_quote?: string;
+    } | null;
+    variants?: Array<{
+        axis?: string;
+        choices?: string[];
+        chosen_at?: string;
+        source_quote?: string;
+    }>;
+    base_statblock?: string | null;
+    overrides?: Array<{
+        field?: string;
+        value?: string;
+        source_quote?: string;
+    }>;
+    source_quote?: string;
+}
 export interface Feature {
     id?: string;
     name: string;
@@ -38,4 +88,23 @@ export interface Feature {
     passive?: boolean;
     /** How long the buff lasts; rendered as a static label (no live countdown). */
     duration?: Duration;
+    class_source?: string;
+    /** Always "" on every measured carrier — never constrain it non-empty. */
+    rendering_hint?: string;
+    subclass_short_name?: string;
+    subclass_source?: string;
+    header?: number;
+    is_class_feature_variant?: boolean;
+    gain_subclass_feature?: boolean;
+    gain_subclass_feature_has_content?: boolean;
+    /** 5etools entry type; values {"inset","item"}. */
+    type?: string;
+    action_cost?: ActionCost;
+    save?: {
+        ability: string;
+        dc_formula: string;
+    };
+    /** The companion this feature binds (R4-G5 §7). Declared so the class / subclass / race parsers stop stripping
+     *  it on the day the G7 re-emit lands; nothing reads it in G5. */
+    companion?: FeatureCompanion;
 }

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.5",
+  "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
-};