@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/schemas/feature-effect-schema.d.ts

@@ -2,16 +2,23 @@ import { z } from "zod";
 export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"initiative-bonus">;
     value: z.ZodNumber;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"immune-condition">;
     condition: z.ZodString;
     while: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"resistance">;
     damage_type: z.ZodString;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"hp-per-level-bonus">;
     value: z.ZodNumber;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"speed-bonus">;
     mode: z.ZodEnum<{
@@ -23,6 +30,12 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     value: z.ZodNumber;
     set: z.ZodOptional<z.ZodBoolean>;
+    scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodNumber;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"sense">;
     type: z.ZodEnum<{
@@ -32,6 +45,8 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         truesight: "truesight";
     }>;
     range: z.ZodNumber;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"apply-condition">;
     condition: z.ZodString;
@@ -41,6 +56,7 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         ability: z.ZodString;
         timing: z.ZodString;
     }, z.core.$strip>>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"damage-bonus">;
     damage_type: z.ZodString;
@@ -51,6 +67,7 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         all: "all";
     }>>;
     condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"proficiency">;
     proficiency_type: z.ZodEnum<{
@@ -62,10 +79,15 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         armor: "armor";
     }>;
     value: z.ZodString;
+    expertise: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"ac-bonus">;
     value: z.ZodNumber;
     requires_armor: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"unarmored-ac">;
     abilities: z.ZodArray<z.ZodEnum<{
@@ -78,6 +100,23 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>>;
     base: z.ZodOptional<z.ZodNumber>;
     allow_shield: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unarmed-strike">;
+    dice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+    }, z.core.$strip>]>>;
+    abilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"weapon-ability">;
     ability: z.ZodUnion<readonly [z.ZodEnum<{
@@ -89,22 +128,34 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         cha: "cha";
     }>, z.ZodLiteral<"spellcasting">]>;
     weapons: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chosen">, z.ZodString, z.ZodArray<z.ZodString>]>>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"roll-modifier">;
     mode: z.ZodEnum<{
         advantage: "advantage";
         disadvantage: "disadvantage";
+        reroll: "reroll";
+        "add-d4": "add-d4";
     }>;
     roll: z.ZodEnum<{
         "saving-throw": "saving-throw";
         "ability-check": "ability-check";
         attack: "attack";
+        any: "any";
     }>;
     scope: z.ZodOptional<z.ZodString>;
     condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"extra-attack">;
     count: z.ZodNumber;
+    scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodNumber;
+        count: z.ZodNumber;
+    }, z.core.$strip>>>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"crit-range">;
     min_roll: z.ZodNumber;
@@ -114,6 +165,7 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         all: "all";
     }>>;
     condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"reroll-damage">;
     max_reroll: z.ZodNumber;
@@ -123,9 +175,81 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         all: "all";
     }>>;
     once_per_die: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"attack-rule">;
     flag: z.ZodEnum<{
         "no-ranged-in-melee-disadvantage": "no-ranged-in-melee-disadvantage";
     }>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"immunity">;
+    damage_type: z.ZodString;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"vulnerability">;
+    damage_type: z.ZodString;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"temp-hp">;
+    amount: z.ZodString;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"heal">;
+    amount: z.ZodString;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ability-score-increase">;
+    abilities: z.ZodUnion<readonly [z.ZodLiteral<"chosen">, z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>]>;
+    amount: z.ZodNumber;
+    choose: z.ZodNullable<z.ZodNumber>;
+    max: z.ZodNullable<z.ZodNumber>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"extra-action">;
+    count: z.ZodNumber;
+    action_type: z.ZodEnum<{
+        action: "action";
+        "bonus-action": "bonus-action";
+        reaction: "reaction";
+    }>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"save-outcome">;
+    ability: z.ZodUnion<readonly [z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>, z.ZodLiteral<"any">]>;
+    on_success: z.ZodEnum<{
+        none: "none";
+        half: "half";
+        full: "full";
+    }>;
+    on_failure: z.ZodEnum<{
+        none: "none";
+        half: "half";
+        full: "full";
+    }>;
+    applies_to: z.ZodNullable<z.ZodString>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "kind">;

package/dist/schemas/feature-effect-schema.js

@@ -1,6 +1,6 @@
 import {
   featureEffectSchema
-} from "../chunk-NXR3BD2V.js";
+} from "../chunk-WPWOHGPI.js";
 export {
   featureEffectSchema
 };

package/dist/schemas/feature-schema.d.ts

@@ -1,2 +1,10 @@
 import { z } from "zod";
+import type { Feature } from "../types/feature.js";
+/**
+ * The feature OBJECT, declared once (R4-G6 §4.2). Typed against the `Feature` interface so a wrong leaf fails
+ * `tsc`; exported UN-REFINED for the monster schema, whose name-only authored traits the hand parser accepted.
+ * The recursion runs through the REFINED schema so a nested class sub_feature keeps the description-or-entries
+ * rule; the refined `featureSchema` below keeps its exported `z.ZodType<unknown>` for every other root.
+ */
+export declare const featureObjectSchema: z.ZodType<Feature>;
 export declare const featureSchema: z.ZodType<unknown>;

package/dist/schemas/feature-schema.js

@@ -1,10 +1,12 @@
 import {
+  featureObjectSchema,
   featureSchema
-} from "../chunk-CZPMTQOY.js";
+} from "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
 export {
+  featureObjectSchema,
   featureSchema
 };

package/dist/schemas/resource-schema.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 declare const resetTriggerEnum: z.ZodEnum<{
     "short-rest": "short-rest";
     "long-rest": "long-rest";
+    either: "either";
     dawn: "dawn";
     dusk: "dusk";
     turn: "turn";
@@ -30,6 +31,7 @@ export declare const resourceSchema: z.ZodObject<{
     reset: z.ZodEnum<{
         "short-rest": "short-rest";
         "long-rest": "long-rest";
+        either: "either";
         dawn: "dawn";
         dusk: "dusk";
         turn: "turn";
@@ -55,14 +57,53 @@ export declare const resourceSchema: z.ZodObject<{
         reset: z.ZodEnum<{
             "short-rest": "short-rest";
             "long-rest": "long-rest";
+            either: "either";
             dawn: "dawn";
             dusk: "dusk";
             turn: "turn";
             round: "round";
             custom: "custom";
         }>;
+        restores: z.ZodOptional<z.ZodEnum<{
+            uses: "uses";
+            "spell-slots": "spell-slots";
+        }>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+/** A feature's / optional feature's resource spend.
+ *
+ *  `amount` is the MINIMUM spend. When `amount_max` is present the spend is a
+ *  RANGE (`amount` .. `amount_max`). Readers of `consumes.resource`, re-measured
+ *  2026-09-05 across both repos' `src` after plugin task T4 landed: the ENGINE still has
+ *  exactly one, `pc/pc.pools.ts`'s pool vote (R4-G4 §4.2.3, whose owner-aware form T2 shipped;
+ *  the `consumes.resource` key itself PREDATES T2, measured on `821f80d`), which reads the
+ *  id to pick `ResolvedPool.resource` and never spends it; the PLUGIN now has SEVEN FUNCTIONS over
+ *  EIGHT code lines in four files (the unit matters: `grep -rn "consumes\.resource\|consumes?\.resource"
+ *  packages/obsidian/src` returns NINE lines, one of them docblock prose, and `consumeCost` reads the
+ *  field on two of the eight). They are: `renderSpendControl` (`components/actions/spend-control.ts`),
+ *  which SPENDS it; the four row sites that gate that call, `PoolTab.row`, `PoolTab.grantedRow` and
+ *  `PoolTab.blockCard` (`components/pool-tab.ts`) and `renderBoonRow`
+ *  (`components/actions/boon-rows.ts`). Their gates, measured 2026-09-05 with `grep -n` on
+ *  `pool-tab.ts`, are NOT the same test, because their callers differ: `row` is gated on the entry
+ *  being SELECTED (`renderSpellLike` sends it every available candidate), `blockCard` on the entry
+ *  being GRANTED OR SELECTED (`renderBlocks` sends it the available candidates, then the stranded
+ *  picks, then the grants), and `grantedRow` is UNCONDITIONAL because it is reached only by the loop
+ *  over `pool.grants`, as is `renderBoonRow`, which the plugin's `section-renderer.ts` reaches only
+ *  with a `kind` of "selected" or "granted". One rule, KNOWN entries only, expressed four ways;
+ *  `renderFeatureRow` (`components/actions/feature-rows.ts`), whose owner-and-spender rule
+ *  decides between the row slot, the expand card and no control at all; and `consumeCost`
+ *  (`components/pool-tab.ts`), the ONE Cost label the row sub-line and the block card now
+ *  share, which prints the resource's NAME from the index and keeps the raw id only as the
+ *  fallback for an id the character does not own (it no longer singularizes or capitalizes
+ *  it). The field IS spent as of R4-G4 T4: §3's control spends `amount` exactly through
+ *  `CharacterEditState.spendFeatureUse`, the clamped quantity-taking primitive the plugin
+ *  already had. What R4-G4 does NOT do (§15): the HOW-MUCH UI for a range spend
+ *  and its validation rule stay G8, and the converter un-withhold that would emit
+ *  `amount_max` at all is a G7 handoff. So `amount_max` stays DECLARED here only, with
+ *  zero emitted carriers, and the refine is undefined-safe by construction so the
+ *  corpus that ships without the key keeps parsing: 294 `Feature.consumes` carriers
+ *  over 161 documents, plus 70 `OptionalFeature.consumes` documents (R4-G3a §9; an
+ *  unguarded refine refuses all 231, measured). */
 export declare const resourceConsumptionSchema: z.ZodObject<{
     source: z.ZodOptional<z.ZodEnum<{
         resource: "resource";
@@ -72,6 +113,7 @@ export declare const resourceConsumptionSchema: z.ZodObject<{
     resource: z.ZodOptional<z.ZodString>;
     column: z.ZodOptional<z.ZodString>;
     amount: z.ZodNumber;
+    amount_max: z.ZodOptional<z.ZodNumber>;
     expend_condition: z.ZodOptional<z.ZodEnum<{
         roll_succeeds: "roll_succeeds";
         roll_fails: "roll_fails";
@@ -83,6 +125,7 @@ export declare const resourceConsumptionSchema: z.ZodObject<{
         reset: z.ZodEnum<{
             "short-rest": "short-rest";
             "long-rest": "long-rest";
+            either: "either";
             dawn: "dawn";
             dusk: "dusk";
             turn: "turn";

package/dist/schemas/resource-schema.js

@@ -3,7 +3,7 @@ import {
   resetTriggerEnum,
   resourceConsumptionSchema,
   resourceSchema
-} from "../chunk-PZOWBI3B.js";
+} from "../chunk-YLL2QXY2.js";
 export {
   actionCostEnum,
   resetTriggerEnum,

package/dist/schemas/selection-pool-schema.d.ts

@@ -29,6 +29,8 @@ export declare const tabDeclSchema: z.ZodObject<{
         layout: z.ZodOptional<z.ZodEnum<{
             "spell-like": "spell-like";
             blocks: "blocks";
+            "dice-pool": "dice-pool";
+            "point-pool": "point-pool";
         }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;

package/dist/schemas/selection-pool-schema.js

@@ -2,7 +2,7 @@ import {
   poolGrantSchema,
   selectionPoolSchema,
   tabDeclSchema
-} from "../chunk-4TIJKN6O.js";
+} from "../chunk-23LZLBJK.js";
 export {
   poolGrantSchema,
   selectionPoolSchema,

package/dist/spell/spell.access.js

@@ -3,10 +3,29 @@ import {
 } from "../chunk-VTTA2ALZ.js";
 
 // src/spell/spell.access.ts
+var LISTED_CLASS_NAMES = /* @__PURE__ */ new WeakMap();
+function listedClassNames(registry) {
+  const count = registry.count();
+  const cached = LISTED_CLASS_NAMES.get(registry);
+  if (cached && cached.count === count) return cached.names;
+  const names = /* @__PURE__ */ new Set();
+  for (const e of registry.search("", "spell", Number.POSITIVE_INFINITY)) {
+    const classes = e.data.classes;
+    if (!Array.isArray(classes)) continue;
+    for (const c of classes) names.add(baseClassName(String(c)));
+  }
+  LISTED_CLASS_NAMES.set(registry, { count, names });
+  return names;
+}
 function classSpellCandidates(registry, classSlugs, maxLevel, knownSlugs, showAll = false, query = "") {
-  const all = registry.search(query, "spell", 1e3);
+  const all = registry.search(query, "spell", Number.POSITIVE_INFINITY);
   const q = query.toLowerCase();
   const classSet = new Set(classSlugs.map((s) => baseClassName(s)));
+  let unlistable = false;
+  if (!showAll && classSet.size > 0) {
+    const listed = listedClassNames(registry);
+    unlistable = [...classSet].some((n) => !listed.has(n));
+  }
   return all.filter((e) => !knownSlugs.has(e.slug)).map((e) => {
     var _a;
     const entity = e.data;
@@ -15,9 +34,10 @@ function classSpellCandidates(registry, classSlugs, maxLevel, knownSlugs, showAl
     var _a;
     if (q && !c.name.toLowerCase().includes(q)) return false;
     if (showAll) return true;
+    if (c.level > maxLevel) return false;
+    if (unlistable) return true;
     const classes = ((_a = c.entity.classes) != null ? _a : []).map((x) => baseClassName(x));
-    const inClass = classes.some((x) => classSet.has(x));
-    return inClass && c.level <= maxLevel;
+    return classes.some((x) => classSet.has(x));
   }).sort((a, b) => a.level - b.level || a.name.localeCompare(b.name));
 }
 export {

package/dist/spell/spell.codec.js

@@ -1,8 +1,9 @@
 import {
   spellCodec
-} from "../chunk-24GFQU7T.js";
-import "../chunk-N2JE7BWL.js";
-import "../chunk-Y4I74YEG.js";
+} from "../chunk-JSZ4H6AQ.js";
+import "../chunk-OZP6JFGT.js";
+import "../chunk-VQAXTIBW.js";
+import "../chunk-UA5KS2PL.js";
 export {
   spellCodec
 };

package/dist/spell/spell.enrichment.js

@@ -1,9 +1,9 @@
 import {
   enrichSpell
-} from "../chunk-GZ46OVGZ.js";
-import "../chunk-RAWJTA45.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-WSVMLNTO.js";
+import "../chunk-DEEHHLAP.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   enrichSpell
 };

package/dist/spell/spell.parser.d.ts

@@ -1,3 +1,33 @@
 import { Spell } from "./spell.types.js";
 import { ParseResult } from "@archivist-gg/core";
+/**
+ * §3.3 · collapse the converter's structured `components` object to the corpus's own string form
+ * (`V, S, M (a coin), R`), leaving a string input byte-unchanged. Letter order is V, S, M, R;
+ * `m` object -> `M (<text>)` (the text already carries the cost prose), `m` string -> `M (<value>)`,
+ * `m: true` -> a bare `M`. A boolean flag contributes its letter only when it is exactly `true`.
+ * Casing follows the 862 string-form carriers (uppercase letters); `R` has no precedent among them
+ * and is an invented-but-decided literal (Gate 0 B-5).
+ *
+ * The parameter is `unknown` on purpose: `spellComponentsObjectSchema` stays local and unexported,
+ * so this function narrows structurally instead of importing the schema's type. `toStringSafe` is
+ * the unreachable-shape fallback (the schema has already accepted the value by the time we run).
+ */
+export declare function normalizeSpellComponents(value: unknown): string;
+/**
+ * §3.3 · collapse the converter's structured `duration` array to the corpus's own lowercase string
+ * form (`until dispelled`, `up to 1 hour`), leaving a string input byte-unchanged. Concentration is
+ * NEVER synthesised here — the separate `concentration` boolean drives the sheet's `Conc · ` prefix.
+ * Zero docs carry more than one entry; the `; ` join is the defensive path for the day one does.
+ */
+export declare function normalizeSpellDuration(value: unknown): string;
+/**
+ * R4-G7 §7.5 · the RESOLVE-time twin of the two normalisations `parseSpell` performs below. The PC pipeline
+ * reads RAW registry entities (`reg.data as unknown as Spell`), so a converter spell reaches the sheet with a
+ * structured `components` object and `duration` array unless it passes through here; `componentLetters`
+ * (the sheet) and the add drawer's duration cell both read strings. The `!= null` guards MIRROR `parseSpell`'s
+ * own, so a spell that authors neither key keeps neither. Lives HERE, beside the normalisers, and not in
+ * `pc.resolver.ts`, which already imports `pc.additional-spells` and would make the two a value cycle
+ * [G2-I-2]. Returns a fresh object; the shared registry entity is never mutated.
+ */
+export declare function mirrorSpellShapes(entity: Spell): Spell;
 export declare function parseSpell(source: string): ParseResult<Spell>;

package/dist/spell/spell.parser.js

@@ -1,7 +1,14 @@
 import {
+  mirrorSpellShapes,
+  normalizeSpellComponents,
+  normalizeSpellDuration,
   parseSpell
-} from "../chunk-N2JE7BWL.js";
-import "../chunk-Y4I74YEG.js";
+} from "../chunk-OZP6JFGT.js";
+import "../chunk-VQAXTIBW.js";
+import "../chunk-UA5KS2PL.js";
 export {
+  mirrorSpellShapes,
+  normalizeSpellComponents,
+  normalizeSpellDuration,
   parseSpell
 };

package/dist/spell/spell.scaling.d.ts

@@ -1,14 +1,35 @@
 import type { Spell } from "./spell.types.js";
 /** A spell repeats under higher levels only if it has a real upcast benefit. */
 export declare function spellScales(spell: Spell): boolean;
+/** The `casting_options` field a scaled value was read from (R4-G7 T8 RIDER-16). */
+export type SpellEffectField = "damage_roll" | "target_count" | "duration" | "desc";
+/** A scaled value and the FIELD it came from, so a renderer decides where it prints from the field. */
+export interface SpellEffectParts {
+    field: SpellEffectField;
+    /** As printed: the roll, `"<N> targets"`, the duration, or the authored sentence verbatim. */
+    value: string;
+}
 /**
- * At-a-glance scaled effect for casting `spell` with a slot of `slotLevel`,
- * read from structured `casting_options` (`type: "slot_level_<N>"`). Returns
- * null when absent or untrustworthy. `damage_roll` is shown as-is; a
- * `target_count` that equals the slot level is the known SRD-2014 bad encoding
- * (e.g. Magic Missile 2nd->2 instead of 4) and is suppressed. This errs toward
- * showing nothing rather than a wrong number.
+ * At-a-glance scaled effect for casting a LEVELLED `spell` with a slot of `slotLevel`,
+ * read from structured `casting_options` (`type: "slot_level_<N>"`), WITH the field it
+ * came from. Returns null when absent or untrustworthy. The FIRST present field wins, in
+ * this order: `damage_roll`, `target_count`, `duration`, `desc` (so an option carrying a
+ * roll AND a sentence yields the roll). A `target_count` that equals the slot level is
+ * the known SRD-2014 bad encoding (e.g. Magic Missile 2nd->2 instead of 4) and is
+ * suppressed. This errs toward showing nothing rather than a wrong number.
  */
+export declare function spellEffectPartsAtSlot(spell: Spell, slotLevel: number): SpellEffectParts | null;
+/** The value of `spellEffectPartsAtSlot`, without its field. */
 export declare function spellEffectAtSlot(spell: Spell, slotLevel: number): string | null;
+/**
+ * R4-G7 T8 RIDER-15 (F-NODICE (a)): a CANTRIP's damage roll at the character's total level, read from structured
+ * `casting_options` (`type: "player_level_<N>"`). The roll of the HIGHEST `N <= characterLevel` wins: SRD 5e authors
+ * one option per level from 5 to 20, SRD 2024 and the converter author only 5 / 11 / 17. An option with no roll or an
+ * EMPTY one never qualifies (SRD 5e Acid Splash and Poison Spray open with `player_level_2..4` carrying
+ * `damage_roll: ''`; Eldritch Blast 2024 authors `target_count` only). Null for a levelled spell, for a level that is
+ * not a finite number (a fixture-built `derived` omits `totalLevel`), and when nothing qualifies: no corpus authors
+ * `player_level_1`, so a cantrip's base roll below level 5 is not in the data and nothing is invented here.
+ */
+export declare function spellEffectAtCharacterLevel(spell: Spell, characterLevel: number): string | null;
 /** Owned slot levels strictly above the spell's base level (scaling spells only). */
 export declare function upcastLevelsFor(spell: Spell, ownedSlotLevels: number[]): number[];

package/dist/spell/spell.scaling.js

@@ -3,17 +3,34 @@ function spellScales(spell) {
   var _a, _b, _c, _d;
   return ((_b = (_a = spell.casting_options) == null ? void 0 : _a.length) != null ? _b : 0) > 0 || ((_d = (_c = spell.at_higher_levels) == null ? void 0 : _c.length) != null ? _d : 0) > 0;
 }
-function spellEffectAtSlot(spell, slotLevel) {
-  var _a, _b;
+function spellEffectPartsAtSlot(spell, slotLevel) {
+  var _a;
   const opt = ((_a = spell.casting_options) != null ? _a : []).find((o) => o.type === `slot_level_${slotLevel}`);
   if (!opt) return null;
-  if (opt.damage_roll) return opt.damage_roll;
+  if (opt.damage_roll) return { field: "damage_roll", value: opt.damage_roll };
   if (typeof opt.target_count === "number") {
     if (opt.target_count === slotLevel) return null;
-    return `${opt.target_count} targets`;
+    return { field: "target_count", value: `${opt.target_count} targets` };
+  }
+  if (opt.duration) return { field: "duration", value: opt.duration };
+  return opt.desc != null ? { field: "desc", value: opt.desc } : null;
+}
+function spellEffectAtSlot(spell, slotLevel) {
+  var _a, _b;
+  return (_b = (_a = spellEffectPartsAtSlot(spell, slotLevel)) == null ? void 0 : _a.value) != null ? _b : null;
+}
+var PLAYER_LEVEL_TYPE = /^player_level_(\d+)$/;
+function spellEffectAtCharacterLevel(spell, characterLevel) {
+  var _a, _b, _c;
+  if (((_a = spell.level) != null ? _a : 0) !== 0 || !Number.isFinite(characterLevel)) return null;
+  let best = null;
+  for (const opt of (_b = spell.casting_options) != null ? _b : []) {
+    const m = PLAYER_LEVEL_TYPE.exec(String((_c = opt.type) != null ? _c : ""));
+    if (!m || typeof opt.damage_roll !== "string" || opt.damage_roll.trim() === "") continue;
+    const n = Number(m[1]);
+    if (n <= characterLevel && (best === null || n > best.n)) best = { n, roll: opt.damage_roll };
   }
-  if (opt.duration) return opt.duration;
-  return (_b = opt.desc) != null ? _b : null;
+  return best ? best.roll : null;
 }
 function upcastLevelsFor(spell, ownedSlotLevels) {
   var _a;
@@ -22,7 +39,9 @@ function upcastLevelsFor(spell, ownedSlotLevels) {
   return ownedSlotLevels.filter((l) => l > base).sort((a, b) => a - b);
 }
 export {
+  spellEffectAtCharacterLevel,
   spellEffectAtSlot,
+  spellEffectPartsAtSlot,
   spellScales,
   upcastLevelsFor
 };

package/dist/spell/spell.schema.d.ts

@@ -5,8 +5,33 @@ export declare const spellEntitySchema: z.ZodObject<{
     school: z.ZodOptional<z.ZodString>;
     casting_time: z.ZodOptional<z.ZodString>;
     range: z.ZodOptional<z.ZodString>;
-    components: z.ZodOptional<z.ZodString>;
-    duration: z.ZodOptional<z.ZodString>;
+    components: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        v: z.ZodOptional<z.ZodBoolean>;
+        s: z.ZodOptional<z.ZodBoolean>;
+        m: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodObject<{
+            text: z.ZodString;
+            cost: z.ZodOptional<z.ZodNumber>;
+            consume: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        }, z.core.$strict>]>>;
+        r: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>]>>;
+    duration: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"permanent">;
+        ends: z.ZodArray<z.ZodEnum<{
+            trigger: "trigger";
+            dispel: "dispel";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"timed">;
+        duration: z.ZodObject<{
+            type: z.ZodEnum<{
+                minute: "minute";
+                hour: "hour";
+            }>;
+            amount: z.ZodNumber;
+            up_to: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>]>>;
     concentration: z.ZodOptional<z.ZodBoolean>;
     ritual: z.ZodOptional<z.ZodBoolean>;
     classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -28,4 +53,21 @@ export declare const spellEntitySchema: z.ZodObject<{
         shape_size: z.ZodOptional<z.ZodNumber>;
         desc: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    misc_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    area_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    condition_inflict: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    affects_creature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    spell_attack: z.ZodOptional<z.ZodEnum<{
+        melee: "melee";
+        ranged: "ranged";
+    }>>;
+    ability_check: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage_resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage_immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    condition_immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage_vulnerable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;