@archivist-gg/dnd5e 0.3.13 → 0.3.19

package/dist/class/class.codec.js

@@ -1,17 +1,17 @@
 import {
   classCodec
-} from "../chunk-XJRNEQPD.js";
-import "../chunk-G7ED5H2G.js";
+} from "../chunk-GVWEFECG.js";
+import "../chunk-XTEFPUSN.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-PLOSP4XQ.js";
+import "../chunk-UJCK5IW4.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-FPGXFD2M.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
 import "../chunk-IN4M4X7P.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   classCodec

package/dist/class/class.parser.js

@@ -1,16 +1,16 @@
 import {
   parseClass
-} from "../chunk-G7ED5H2G.js";
+} from "../chunk-XTEFPUSN.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-PLOSP4XQ.js";
+import "../chunk-UJCK5IW4.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-FPGXFD2M.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
 import "../chunk-IN4M4X7P.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseClass

package/dist/class/class.schema.d.ts

@@ -22,6 +22,14 @@ export declare const classEntitySchema: z.ZodObject<{
         wis: "wis";
         cha: "cha";
     }>>;
+    standard_array: z.ZodOptional<z.ZodObject<{
+        str: z.ZodNumber;
+        dex: z.ZodNumber;
+        con: z.ZodNumber;
+        int: z.ZodNumber;
+        wis: z.ZodNumber;
+        cha: z.ZodNumber;
+    }, z.core.$strict>>;
     saving_throws: z.ZodArray<z.ZodEnum<{
         str: "str";
         dex: "dex";

package/dist/class/class.schema.js

@@ -1,14 +1,14 @@
 import {
   classEntitySchema
-} from "../chunk-PLOSP4XQ.js";
+} from "../chunk-UJCK5IW4.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-FPGXFD2M.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
 import "../chunk-IN4M4X7P.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   classEntitySchema

package/dist/class/class.standard-array.d.ts

@@ -0,0 +1,16 @@
+/**
+ * D2b-A (A-1, user pick A) · the class's recommended Standard Array, which the Builder's Abilities step suggests.
+ */
+import type { Ability } from "@archivist-gg/dnd5e/types/choice";
+import type { ClassEntity } from "./class.types.js";
+/** Structural subset of the registry this reads. */
+export interface StandardArrayRegistry {
+    search(query: string, entityType: string, limit: number): Array<{
+        slug: string;
+        data: Record<string, unknown>;
+    }>;
+}
+/** The class's own `standard_array`; else, for a 2024 class that carries none (a book class imported before the table
+ *  was data), the table of its 2024 twin in the registry (the same bare slug, e.g. the SRD 2024 Fighter for the PHB
+ *  2024 Fighter). Null for a 2014 class and for a class with no 2024 twin (homebrew): the Builder then suggests nothing. */
+export declare function standardArrayFor(entity: Pick<ClassEntity, "slug" | "edition" | "standard_array">, registry: StandardArrayRegistry | null | undefined): Record<Ability, number> | null;

package/dist/class/class.standard-array.js

@@ -0,0 +1,20 @@
+import {
+  bareEntitySlug
+} from "../chunk-ZCTUYGNV.js";
+
+// src/class/class.standard-array.ts
+var isArray = (v) => !!v && typeof v === "object" && ["str", "dex", "con", "int", "wis", "cha"].every((k) => typeof v[k] === "number");
+function standardArrayFor(entity, registry) {
+  if (isArray(entity.standard_array)) return entity.standard_array;
+  if (entity.edition !== "2024" || !registry) return null;
+  const bare = bareEntitySlug(entity.slug);
+  for (const e of registry.search("", "class", Number.POSITIVE_INFINITY)) {
+    if (e.slug === entity.slug || bareEntitySlug(e.slug) !== bare) continue;
+    const d = e.data;
+    if (d.edition === "2024" && isArray(d.standard_array)) return d.standard_array;
+  }
+  return null;
+}
+export {
+  standardArrayFor
+};

package/dist/class/class.types.d.ts

@@ -69,6 +69,9 @@ export interface ClassEntity {
     description: string;
     hit_die: string;
     primary_abilities: Ability[];
+    /** D2b-A (A-1): the recommended Standard Array for the class, one score per ability (SRD 5.2 "Standard Array by
+     *  Class"). Absent on 2014 classes and homebrew; the Builder then suggests nothing. */
+    standard_array?: Record<Ability, number>;
     saving_throws: Ability[];
     proficiencies: ClassProficiencies;
     skill_choices: SkillChoices;

package/dist/dnd/amount-text.d.ts

@@ -0,0 +1,42 @@
+/**
+ * D2b-A · an AMOUNT that names a modifier prints the number (design §1.2 A, user rulings 2026-09-27).
+ *
+ * An effect amount, a rider amount or a save DC formula is written in the book's words ("1d8 plus your Wisdom
+ * modifier", "your spell save DC") or with a `{token}` ("2d4 + {spell_mod}"). Nothing rendered it as a number: the
+ * resource DSL (`resource-formula.ts`) has no dice production and no spellcasting idents. This module reads both at
+ * READ time, so existing notes and homebrew need no re-import:
+ *   1. `normalizeAmountPhrases` turns the closed phrase table below into tokens;
+ *   2. `resolveAmountText` substitutes each `{ident}` with its number and folds: a pure numeric result is evaluated by
+ *      the resource DSL (so `floor`, `max`, `ceil` keep working) and a trailing "(minimum of N)" is applied;
+ *      `<dice> +/- <numbers>` folds to one roll ("1d8+3"); anything else keeps its words with the numbers in place
+ *      ("one roll of your Martial Arts die + 3").
+ * The phrase table is the ONE place the book's English is read; an unmapped phrase stays as written.
+ */
+import { type FormulaBindings } from "./resource-formula.js";
+/** The DSL bindings plus the owner's spellcasting modifier and save DC (absent when the owner casts no spells). */
+export interface AmountBindings extends FormulaBindings {
+    spell_mod?: number;
+    spell_dc?: number;
+}
+/** The book phrases of `text` as tokens, "plus" as "+"; text with no mapped phrase comes back unchanged. */
+export declare function normalizeAmountPhrases(text: string): string;
+/**
+ * The amount as the sheet prints it: the phrases and tokens of `text` resolved against `b`. A pure number is
+ * evaluated ("13"); a roll plus numbers folds ("1d8+3"); other words keep their place with the numbers in ("the roll + 2
+ * (minimum of 1)"). An UNBOUND token prints its short label when the note wrote the token, and a book phrase whose
+ * token is unbound keeps the note's own words. Text with no phrase and no token comes back unchanged.
+ */
+export declare function resolveAmountText(text: string, b: AmountBindings): string;
+/** `roll` with each RESOLVED amount added (a spell's damage riders, already resolved against their owners): dice plus
+ *  numbers fold to one roll ("2d4+5" and "2" read "2d4+7", "1d10" and "-1" read "1d10-1"); anything that does not fold
+ *  keeps its words, joined by " + ". No amount returns `roll` unchanged. */
+export declare function addToRoll(roll: string, amounts: readonly string[]): string;
+/** The leading dice roll of a resolved amount ("1d8+3" of "1d8+3 (minimum of 1)"), which the sheet makes rollable; null
+ *  when the amount does not open with a roll. */
+export declare function diceRollOf(resolved: string): string | null;
+/** The leading roll of `text` as the RAW characters it spans (`raw`, which the caller cuts the text by) and as a notation
+ *  with no spaces (`notation`, which the roller reads): "2d4 + 2 more" is { raw: "2d4 + 2", notation: "2d4+2" }. */
+export declare function diceRollPrefix(text: string): {
+    raw: string;
+    notation: string;
+} | null;

package/dist/dnd/amount-text.js

@@ -0,0 +1,15 @@
+import {
+  addToRoll,
+  diceRollOf,
+  diceRollPrefix,
+  normalizeAmountPhrases,
+  resolveAmountText
+} from "../chunk-WOHX7YTH.js";
+import "../chunk-EVMUJYUD.js";
+export {
+  addToRoll,
+  diceRollOf,
+  diceRollPrefix,
+  normalizeAmountPhrases,
+  resolveAmountText
+};

package/dist/dnd/resource-words.d.ts

@@ -0,0 +1,4 @@
+/** The resource's name worded for `amount`: the last word singular for one, plural otherwise, when it is a count noun. */
+export declare function resourceCountWord(name: string, amount: number): string;
+/** "<amount> <name worded for it>" ("1 Superiority Die"). */
+export declare function countedResource(amount: number, name: string): string;

package/dist/dnd/resource-words.js

@@ -0,0 +1,30 @@
+// src/dnd/resource-words.ts
+var COUNT_NOUNS = [
+  ["Die", "Dice"],
+  ["Point", "Points"],
+  ["Use", "Uses"],
+  ["Seal", "Seals"],
+  ["Rage", "Rages"],
+  ["Cast", "Casts"],
+  ["Casting", "Castings"],
+  ["Scroll", "Scrolls"],
+  ["Charge", "Charges"],
+  ["Token", "Tokens"],
+  ["Slot", "Slots"]
+];
+var BY_WORD = new Map(
+  COUNT_NOUNS.flatMap((pair) => [[pair[0], pair], [pair[1], pair]])
+);
+function resourceCountWord(name, amount) {
+  const at = name.lastIndexOf(" ") + 1;
+  const pair = BY_WORD.get(name.slice(at));
+  if (!pair) return name;
+  return name.slice(0, at) + (amount === 1 ? pair[0] : pair[1]);
+}
+function countedResource(amount, name) {
+  return `${amount} ${resourceCountWord(name, amount)}`;
+}
+export {
+  countedResource,
+  resourceCountWord
+};

package/dist/entities/registry-revision.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A registry's change generation (PERF, Edgar 2026-09-28): a number that moves on every register, unregister and clear.
+ * Core's `EntityRegistry` carries none; the plugin's registry does (`RevisionedEntityRegistry`). Registry-derived data
+ * that does not depend on the character (an item index, a sorted bucket) is memoised per (registry, revision), so a
+ * write that changes only the character reads the registry zero times.
+ *
+ * The rule is strict: a registry WITHOUT a numeric `revision` is never cached, so a mock, a plain core registry or any
+ * other host always computes afresh and can never read stale data. (The older `registry.count()` memos in
+ * `pc.spellcasting.ts` and `spell.access.ts` carry a known gap, an in-place re-registration; this key has none.)
+ */
+export declare function registryRevision(registry: unknown): number | undefined;
+/** `compute()` once per (registry, revision), kept in `cache`; every call when the registry has no revision. */
+export declare function memoByRevision<T>(cache: WeakMap<object, {
+    revision: number;
+    value: T;
+}>, registry: object, compute: () => T): T;
+/** The registry surface a bucket read needs (structurally core's `EntityRegistry` and every narrower registry type). */
+interface BucketSource<T> {
+    search(query: string, entityType: string, limit: number): T[];
+}
+/** `registry.search("", type, Infinity)`, the whole bucket in the registry's own order, read ONCE per registry state
+ *  (every call when the registry has no revision). The array is SHARED by every caller until the revision moves: read
+ *  it, never sort or splice it in place. */
+export declare function bucketOf<T>(registry: BucketSource<T>, type: string): readonly T[];
+export {};

package/dist/entities/registry-revision.js

@@ -0,0 +1,10 @@
+import {
+  bucketOf,
+  memoByRevision,
+  registryRevision
+} from "../chunk-4J6DS3EJ.js";
+export {
+  bucketOf,
+  memoByRevision,
+  registryRevision
+};

package/dist/feat/feat.codec.js

@@ -1,11 +1,11 @@
 import {
   featCodec
-} from "../chunk-6ZY3U6BQ.js";
-import "../chunk-4SLOJXJ4.js";
-import "../chunk-LVX6TQ3R.js";
+} from "../chunk-ZOWKWMD2.js";
+import "../chunk-3SFGWFVQ.js";
+import "../chunk-FMYWORTP.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   featCodec

package/dist/feat/feat.parser.js

@@ -1,10 +1,10 @@
 import {
   parseFeat
-} from "../chunk-4SLOJXJ4.js";
-import "../chunk-LVX6TQ3R.js";
+} from "../chunk-3SFGWFVQ.js";
+import "../chunk-FMYWORTP.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseFeat

package/dist/feat/feat.schema.d.ts

@@ -88,6 +88,31 @@ export declare const featEntitySchema: z.ZodObject<{
         minimum: z.ZodOptional<z.ZodNumber>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"save-bonus">;
+        ability: z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>;
+        minimum: z.ZodOptional<z.ZodNumber>;
+        saves: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>>;
+        inactive_while: z.ZodOptional<z.ZodEnum<{
+            incapacitated: "incapacitated";
+            unconscious: "unconscious";
+        }>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"half-proficiency">;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -181,6 +206,15 @@ export declare const featEntitySchema: z.ZodObject<{
             finesse: "finesse";
             thrown: "thrown";
         }>>]>>;
+        spell_scope: z.ZodOptional<z.ZodObject<{
+            list: z.ZodOptional<z.ZodString>;
+            level: z.ZodOptional<z.ZodNumber>;
+            school: z.ZodOptional<z.ZodString>;
+            damage_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            damage_type_pick: z.ZodOptional<z.ZodString>;
+            spells: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            once: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{

package/dist/feat/feat.schema.js

@@ -1,9 +1,9 @@
 import {
   featEntitySchema
-} from "../chunk-LVX6TQ3R.js";
+} from "../chunk-FMYWORTP.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-BRGLDWUP.js";
-import "../chunk-ZMJQUZQH.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   featEntitySchema