@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/{chunk-PZOWBI3B.js → chunk-YLL2QXY2.js}

@@ -1,6 +1,6 @@
 // src/schemas/resource-schema.ts
 import { z } from "zod";
-var resetTriggerEnum = z.enum(["short-rest", "long-rest", "dawn", "dusk", "turn", "round", "custom"]);
+var resetTriggerEnum = z.enum(["short-rest", "long-rest", "either", "dawn", "dusk", "turn", "round", "custom"]);
 var actionCostEnum = z.enum(["action", "bonus-action", "reaction", "free", "special"]);
 var resourceSchema = z.object({
   id: z.string().min(1),
@@ -25,7 +25,8 @@ var resourceSchema = z.object({
     amount: z.union([z.number(), z.string()]),
     action: actionCostEnum.optional(),
     uses: z.number().int().nonnegative().optional(),
-    reset: resetTriggerEnum
+    reset: resetTriggerEnum,
+    restores: z.enum(["uses", "spell-slots"]).optional()
   })).optional()
 });
 var resourceConsumptionSchema = z.object({
@@ -33,12 +34,16 @@ var resourceConsumptionSchema = z.object({
   resource: z.string().optional(),
   column: z.string().optional(),
   amount: z.number().int().positive(),
+  amount_max: z.number().int().positive().optional(),
   expend_condition: z.enum(["roll_succeeds", "roll_fails", "target_takes_damage", "always"]).optional(),
   free_uses: z.object({
     amount: z.number().int().positive(),
     reset: resetTriggerEnum,
     state_key: z.string().optional()
   }).optional()
+}).refine((c) => c.amount_max === void 0 || c.amount_max >= c.amount, {
+  path: ["amount_max"],
+  message: "amount_max must be >= amount"
 });
 
 export {

package/dist/class/class.codec.js

@@ -1,15 +1,18 @@
 import {
   classCodec
-} from "../chunk-GE4TLPWM.js";
-import "../chunk-42Y5IJKT.js";
-import "../chunk-TLYDBT5F.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-EHDATXP7.js";
+import "../chunk-5RKLL2AD.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-CGRLQ34U.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.js";
+import "../chunk-W74BCA7V.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-3DZ74AKK.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IN4M4X7P.js";
+import "../chunk-IWRVOCT5.js";
+import "../chunk-X3D6LXUU.js";
+import "../chunk-UA5KS2PL.js";
 export {
   classCodec
 };

package/dist/class/class.parser.js

@@ -1,14 +1,17 @@
 import {
   parseClass
-} from "../chunk-42Y5IJKT.js";
-import "../chunk-TLYDBT5F.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-5RKLL2AD.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-CGRLQ34U.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.js";
+import "../chunk-W74BCA7V.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-3DZ74AKK.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IN4M4X7P.js";
+import "../chunk-IWRVOCT5.js";
+import "../chunk-X3D6LXUU.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseClass
 };

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

@@ -82,14 +82,16 @@ export declare const classEntitySchema: z.ZodObject<{
             survival: "survival";
         }>>;
     }, z.core.$strip>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>>;
     starting_equipment: z.ZodArray<z.ZodType<import("./class.types.js").StartingEquipmentEntry, unknown, z.core.$ZodTypeInternals<import("./class.types.js").StartingEquipmentEntry, unknown>>>;
     starting_gold: z.ZodOptional<z.ZodType<import("./class.types.js").StartingGold, unknown, z.core.$ZodTypeInternals<import("./class.types.js").StartingGold, unknown>>>;
     spellcasting: z.ZodNullable<z.ZodObject<{
         caster_type: z.ZodEnum<{
-            pact: "pact";
-            full: "full";
             half: "half";
+            full: "full";
+            pact: "pact";
             third: "third";
+            artificer: "artificer";
         }>;
         ability: z.ZodEnum<{
             str: "str";
@@ -108,7 +110,7 @@ export declare const classEntitySchema: z.ZodObject<{
     subclass_level: z.ZodNumber;
     subclass_feature_name: z.ZodString;
     weapon_mastery: z.ZodNullable<z.ZodObject<{
-        starting_count: z.ZodNumber;
+        starting_count: z.ZodOptional<z.ZodNumber>;
         scaling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strip>>;
     epic_boon_level: z.ZodNullable<z.ZodNumber>;
@@ -133,6 +135,7 @@ export declare const classEntitySchema: z.ZodObject<{
         reset: z.ZodEnum<{
             "short-rest": "short-rest";
             "long-rest": "long-rest";
+            either: "either";
             dawn: "dawn";
             dusk: "dusk";
             turn: "turn";
@@ -158,12 +161,17 @@ export declare const classEntitySchema: 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>>;
     selection_pools: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -196,7 +204,51 @@ export declare const classEntitySchema: 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>>>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    table_col_labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    starting_equipment_additional_from_background: z.ZodOptional<z.ZodBoolean>;
+    multiclassing: z.ZodOptional<z.ZodUnknown>;
+    cantrip_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    prepared_spells: z.ZodOptional<z.ZodString>;
+    prepared_spells_change: z.ZodOptional<z.ZodString>;
+    prepared_spells_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression_fixed: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression_fixed_allow_lower_level: z.ZodOptional<z.ZodBoolean>;
+    spells_known_progression_fixed_by_level: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    feat_progression: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+        feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    optionalfeature_progression: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+        feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    additional_spells: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            choose: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>]>>;
+        known: z.ZodOptional<z.ZodUnknown>;
+        innate: z.ZodOptional<z.ZodUnknown>;
+        prepared: z.ZodOptional<z.ZodUnknown>;
+        expanded: z.ZodOptional<z.ZodUnknown>;
+        resourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strip>;

package/dist/class/class.schema.js

@@ -1,13 +1,15 @@
 import {
   classEntitySchema
-} from "../chunk-TLYDBT5F.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-CGRLQ34U.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.js";
+import "../chunk-W74BCA7V.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-3DZ74AKK.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IN4M4X7P.js";
+import "../chunk-IWRVOCT5.js";
+import "../chunk-X3D6LXUU.js";
+import "../chunk-UA5KS2PL.js";
 export {
   classEntitySchema
 };

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

@@ -1,7 +1,8 @@
-import type { Feature, Ability, SkillSlug, Resource } from "@archivist-gg/dnd5e";
+import type { Feature, Ability, SkillSlug, Resource, Choice } from "@archivist-gg/dnd5e";
 import type { StartingEquipmentEntry, StartingGold } from "@archivist-gg/dnd5e/types/equipment-grant";
 export type { StartingEquipmentEntry, StartingGold } from "@archivist-gg/dnd5e/types/equipment-grant";
 import type { SelectionPool, PoolGrant, TabDecl } from "@archivist-gg/dnd5e/types/selection-pool";
+import type { AdditionalSpellsEntry, ProgressionEntry } from "@archivist-gg/dnd5e/schemas/entity-extras-schema";
 import type { Edition } from "@archivist-gg/dnd5e/types/edition";
 export type { Edition };
 export type ArmorCategory = "light" | "medium" | "heavy" | "shield";
@@ -30,7 +31,8 @@ export interface SkillChoices {
     count: number;
     from: SkillSlug[];
 }
-export type CasterType = "full" | "half" | "third" | "pact";
+import type { CasterType } from "@archivist-gg/dnd5e/schemas/caster-type-schema";
+export type { CasterType };
 export type SpellcastingPreparation = "known" | "prepared";
 export interface SpellcastingConfig {
     caster_type: CasterType;
@@ -38,8 +40,20 @@ export interface SpellcastingConfig {
     preparation: SpellcastingPreparation;
     spell_list: string;
 }
+/** A SUBCLASS spellcasting block is a partial (R4-G1a D7): the converter emits {ability} alone on subclasses that
+ *  only name a save ability (Path of the Giant, Four Elements) and {ability, caster_type} on the third-casters
+ *  (Eldritch Knight, Arcane Trickster). The CLASS block stays fully required. */
+export interface SubclassSpellcastingConfig {
+    ability: Ability;
+    caster_type?: CasterType;
+    preparation?: SpellcastingPreparation;
+    spell_list?: string;
+}
 export interface WeaponMasteryConfig {
-    starting_count: number;
+    /** OPTIONAL since R4-G1b (§2.7): the converter must be able to re-emit a countless mastery object
+     *  (G5 owns counts-from-prose). Declaration 2 of 3 — the schema and the generator's COPIED
+     *  `interface WeaponMasteryConfig` in tools/srd-canonical/merger-rules/class-merge.ts are the others. */
+    starting_count?: number;
     scaling?: Record<number, number>;
 }
 export interface ClassTableRow {
@@ -58,6 +72,14 @@ export interface ClassEntity {
     saving_throws: Ability[];
     proficiencies: ClassProficiencies;
     skill_choices: SkillChoices;
+    /**
+     * Entity-level decisions the class grants at L1, mirroring the long-standing
+     * `RaceEntity.choices` / `BackgroundEntity.choices` precedent. Classes were the
+     * sole holdout: a tool pick like the Bard's "three musical instruments of your
+     * choice" belongs to the CLASS, not to any one of its L1 features, so before
+     * this there was nowhere to author it.
+     */
+    choices?: Choice[];
     starting_equipment: StartingEquipmentEntry[];
     starting_gold?: StartingGold;
     spellcasting: SpellcastingConfig | null;
@@ -71,4 +93,27 @@ export interface ClassEntity {
     selection_pools?: SelectionPool[];
     pool_grants?: PoolGrant[];
     tabs?: TabDecl[];
+    /** Converter/bundle extras declared by class.schema.ts §2.7; all optional, none read today. */
+    rendering_hint?: string;
+    has_fluff?: boolean;
+    has_fluff_images?: boolean;
+    table_col_labels?: string[];
+    starting_equipment_additional_from_background?: boolean;
+    /** RAW 5etools passthrough (four measured arities incl. `{}`): `unknown` mirrors `z.unknown()`. */
+    multiclassing?: unknown;
+    cantrip_progression?: number[];
+    prepared_spells?: string;
+    prepared_spells_change?: string;
+    prepared_spells_progression?: number[];
+    spells_known_progression?: number[];
+    spells_known_progression_fixed?: number[];
+    /** ⚠️ BOOLEAN, not an array (finding 1). */
+    spells_known_progression_fixed_allow_lower_level?: boolean;
+    /** ⚠️ TWO-DEEP record: level -> spell level -> count (finding 1). */
+    spells_known_progression_fixed_by_level?: Record<string, Record<string, number>>;
+    feat_progression?: ProgressionEntry[];
+    optionalfeature_progression?: ProgressionEntry[];
+    additional_spells?: AdditionalSpellsEntry[];
+    /** One wikilink, or an array of them for the multi-fluff-image emit. */
+    image?: string | string[];
 }

package/dist/condition/condition.codec.d.ts

@@ -0,0 +1,9 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { ConditionEntity } from "./condition.types.js";
+/**
+ * Normalizing codec. `parse` delegates to `parseCondition`, which seeds the
+ * `edition: "2014"` default and validates against `conditionEntitySchema`.
+ * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
+ * serializer), mirroring every sibling entity codec.
+ */
+export declare const conditionCodec: DocCodec<ConditionEntity>;

package/dist/condition/condition.entity-type.d.ts

@@ -0,0 +1,2 @@
+import type { EntityType } from "@archivist-gg/core";
+export declare const conditionEntityType: EntityType;

package/dist/condition/condition.parser.d.ts

@@ -0,0 +1,13 @@
+import type { ConditionEntity } from "./condition.types.js";
+import { ParseResult } from "@archivist-gg/core";
+/**
+ * The RACE pattern (spec §6): required keys enforced by `parseYaml`, the
+ * `edition: "2014"` default seeded BEFORE validation (a declared edition wins —
+ * the spread order is load-bearing), and `result.data` returned DIRECTLY. That
+ * keeps `slug` on the output — the spell parser's slug strip is what mints its
+ * 1,048-row census row — and, because the measured corpus carries exactly the two
+ * declared key-sets, `z.object`'s strip removes nothing. The absence of a
+ * KNOWN_KEYS gate and a `raw` bag is why there is no *relocated* or *duplicated*
+ * row either.
+ */
+export declare function parseCondition(source: string): ParseResult<ConditionEntity>;

package/dist/condition/condition.parser.js

@@ -0,0 +1,7 @@
+import {
+  parseCondition
+} from "../chunk-6X2NV665.js";
+import "../chunk-UA5KS2PL.js";
+export {
+  parseCondition
+};

package/dist/condition/condition.schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * The `condition` entity (spec §6). Measured corpus at design time: 89 documents
+ * (59 converter over 4 books + 30 bundle) in exactly TWO key-sets — with
+ * `has_fluff_images` (39) and without (50) — over 15 distinct names that are
+ * BYTE-IDENTICAL across every book that ships them. Editions: converter 44/15,
+ * bundle 15/15, so the closed enum is safe. NOT every book ships all 15
+ * (`Hunt for the Thessalhydra` has no Exhaustion): completeness is never assumed.
+ *
+ * Plain `z.object` on purpose — no `.loose()`, no raw bag, no KNOWN_KEYS list: the
+ * corpus has no keys beyond these, and the parser returns the validated object
+ * directly (see `condition.parser.ts`), so nothing is relocated or duplicated.
+ *
+ * `edition` is REQUIRED here; the parser seeds `"2014"` BEFORE validation, so an
+ * authored note without the key still parses (all 89 corpus docs carry it).
+ * `image` is already `.optional()` at its source — never append a second one.
+ */
+export declare const conditionEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    description: z.ZodString;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;

package/dist/condition/condition.types.d.ts

@@ -0,0 +1,15 @@
+import type { imageField } from "../schemas/entity-extras-schema.js";
+import type { Edition } from "../types/edition.js";
+import type { z } from "zod";
+/** A 5e condition document (spec §6). Mirrors `conditionEntitySchema` exactly. */
+export interface ConditionEntity {
+    slug: string;
+    name: string;
+    edition: Edition;
+    source: string;
+    /** Markdown; wikilinks to sibling conditions ride through verbatim. */
+    description: string;
+    has_fluff_images?: boolean;
+    /** One wikilink, or an array for >= 2 fluff images (images-ON emit). */
+    image?: z.infer<typeof imageField>;
+}

package/dist/dnd/constants.d.ts

@@ -1,3 +1,4 @@
+import type { Edition } from "../types/edition.js";
 export declare const CR_PROFICIENCY: Record<string, number>;
 export declare const CR_XP: Record<string, number>;
 export declare const ALL_CR_VALUES: string[];
@@ -11,6 +12,27 @@ export declare const DAMAGE_TYPES: string[];
 export declare const DAMAGE_NONMAGICAL_VARIANTS: string[];
 export declare const CONDITIONS: string[];
 export declare const STANDARD_SENSES: string[];
+/** R4-G7 T8 RIDER-22 (F-STDACT) · the standard combat actions any character can take, per rules edition, in the book's
+ *  alphabetical order. The plugin's Actions tab reads the character's edition, so this is rendering data, never a
+ *  renderer constant (it printed ONE union of both editions). 2014 is the PHB chapter 9 list; 2024 is the 2024 action
+ *  list, which drops Cast a Spell (now Magic) and Use an Object (now Utilize) and adds Influence and Study. No rules
+ *  glossary ships in the SRD 2024 bundle; its prose names ten of the twelve as "the <X> action" and none of the 2014-only
+ *  names (measured 2026-09-15 over the plugin repo's `.compendium-bundle/SRD 2024`). */
+export declare const STANDARD_ACTIONS: Record<Edition, readonly string[]>;
 export declare const ALIGNMENT_ETHICAL: string[];
 export declare const ALIGNMENT_MORAL: string[];
 export declare const ALL_SECTIONS: string[];
+/**
+ * Full ability NAME (lower-case) → canonical three-letter key. Distinct from `ABILITY_NAMES`
+ * above, which is the OTHER direction and yields the display casing ("str" → "STR").
+ *
+ * Moved here from `pc/pc.feature-effects.ts` in R4-G3a §6.2.3, where it was private: the scope
+ * normaliser (`pc/roll-scope.ts`) needs exactly the same vocabulary, and a second copy is the
+ * defect class this phase exists to remove. `src/dnd/*` imports nothing from `src/pc/*`, so the
+ * move introduces no cycle; the type is spelled `(typeof ABILITY_KEYS)[number]` rather than the
+ * `Ability` alias so this module keeps its zero imports.
+ */
+export declare const ABILITY_NAME_TO_KEY: Record<string, (typeof ABILITY_KEYS)[number]>;
+/** Accepts a canonical key ("dex") or a full ability name ("Dexterity"), any casing / padding;
+ *  returns the canonical key, or null when the value is neither. */
+export declare function normalizeAbility(value: string): (typeof ABILITY_KEYS)[number] | null;

package/dist/dnd/constants.js

@@ -1,6 +1,7 @@
 import {
   ABILITY_KEYS,
   ABILITY_NAMES,
+  ABILITY_NAME_TO_KEY,
   ALIGNMENT_ETHICAL,
   ALIGNMENT_MORAL,
   ALL_CR_VALUES,
@@ -14,11 +15,14 @@ import {
   DAMAGE_TYPES,
   SIZE_HIT_DICE,
   SKILL_ABILITY,
-  STANDARD_SENSES
-} from "../chunk-WP2CX2JO.js";
+  STANDARD_ACTIONS,
+  STANDARD_SENSES,
+  normalizeAbility
+} from "../chunk-WELIKLZF.js";
 export {
   ABILITY_KEYS,
   ABILITY_NAMES,
+  ABILITY_NAME_TO_KEY,
   ALIGNMENT_ETHICAL,
   ALIGNMENT_MORAL,
   ALL_CR_VALUES,
@@ -32,5 +36,7 @@ export {
   DAMAGE_TYPES,
   SIZE_HIT_DICE,
   SKILL_ABILITY,
-  STANDARD_SENSES
+  STANDARD_ACTIONS,
+  STANDARD_SENSES,
+  normalizeAbility
 };

package/dist/dnd/formula-tags.js

@@ -5,10 +5,10 @@ import {
 import {
   abilityModifier,
   formatModifier
-} from "../chunk-NAEPSZAM.js";
+} from "../chunk-PDJSUH24.js";
 import {
   ABILITY_KEYS
-} from "../chunk-WP2CX2JO.js";
+} from "../chunk-WELIKLZF.js";
 
 // src/dnd/formula-tags.ts
 function resolveSlugForTag(slug, tagType, registry) {

package/dist/dnd/math.d.ts

@@ -22,3 +22,29 @@ export declare function passivePerception(wisScore: number, perceptionProf: "non
 export declare function attackBonus(abilityScore: number, profBonus: number): number;
 export declare function saveDC(abilityScore: number, profBonus: number): number;
 export declare function abilityNameToKey(name: string): (typeof ABILITY_KEYS)[number] | null;
+/** Is `type` one of the canonical damage types, whatever its casing? A rider whose declared type is
+ *  anything else, a sentinel (`weapon`) or prose ("same as the weapon's type"), INHERITS the weapon row's
+ *  own damage type; `pc.recalc.ts` resolves that where the rider is merged onto the row, never in a
+ *  renderer, and never from a list of prose spellings. The ONE exception is the schema's own sentinel
+ *  {@link CHOSEN_DAMAGE_TYPE}, which means the player's choice, not the row's type (R4-G7 T8 RIDER-13). */
+export declare function isCanonicalDamageType(type: string): boolean;
+/** The schema's own damage-type sentinel for a rider whose type the PLAYER picks when the damage is dealt
+ *  (`feature-effect-schema.ts`, the `damage-bonus` arm: "player-selected damage type at action time"). It is a
+ *  declared schema value, not a prose spelling, so it never inherits the weapon row's type: the rider keeps it,
+ *  and the sheet prints the amount with no type and {@link CHOSEN_DAMAGE_TYPE_NOTE} in the row's caption
+ *  (R4-G7 T8 RIDER-13). */
+export declare const CHOSEN_DAMAGE_TYPE = "chosen";
+/** The caption words a renderer prints for a {@link CHOSEN_DAMAGE_TYPE} rider in place of a damage type. One
+ *  constant, so no renderer spells the phrase itself. */
+export declare const CHOSEN_DAMAGE_TYPE_NOTE = "damage type of your choice";
+/** Is `type` the {@link CHOSEN_DAMAGE_TYPE} sentinel, whatever its casing or surrounding space? */
+export declare function isChosenDamageType(type: string | undefined): boolean;
+/** Can a damage rider be printed INSIDE the damage text, as a dice chip? Only when it reads as a dice
+ *  expression or a (signed) number, optionally followed by ONE canonical damage type: `1d6`, `+2`,
+ *  `1d6 fire`. Anything else is prose ("your Wisdom modifier necrotic", "half your fighter level
+ *  slashing") and belongs in the row's caption instead (R4-G7 T6a E-4 (c)).
+ *
+ *  `text` is the rider's PRINTED form, its amount plus its resolved damage type, because a shipped
+ *  rider may carry the type inside the amount itself (`{amount: "1d6 fire"}` with no `damage_type`, the
+ *  migrated manual override of `pc.equipment.ts`). */
+export declare function isRenderableDamageText(text: string): boolean;

package/dist/dnd/math.js

@@ -1,4 +1,6 @@
 import {
+  CHOSEN_DAMAGE_TYPE,
+  CHOSEN_DAMAGE_TYPE_NOTE,
   abilityModifier,
   abilityNameToKey,
   attackBonus,
@@ -6,6 +8,9 @@ import {
   formatModifier,
   hitDiceSizeFromCreatureSize,
   hpFromHitDice,
+  isCanonicalDamageType,
+  isChosenDamageType,
+  isRenderableDamageText,
   parseHitDiceFormula,
   passive,
   passivePerception,
@@ -14,9 +19,11 @@ import {
   saveDC,
   savingThrow,
   skillBonus
-} from "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
+  CHOSEN_DAMAGE_TYPE,
+  CHOSEN_DAMAGE_TYPE_NOTE,
   abilityModifier,
   abilityNameToKey,
   attackBonus,
@@ -24,6 +31,9 @@ export {
   formatModifier,
   hitDiceSizeFromCreatureSize,
   hpFromHitDice,
+  isCanonicalDamageType,
+  isChosenDamageType,
+  isRenderableDamageText,
   parseHitDiceFormula,
   passive,
   passivePerception,

package/dist/dnd/prose-tags.js

@@ -1,6 +1,6 @@
 // src/dnd/prose-tags.ts
 function convert5eToolsTags(text) {
-  const rewritten = text.replace(/\{@atk\s+mw,rw\}/gi, "Melee or Ranged Weapon Attack:").replace(/\{@atk\s+mws\}/gi, "Melee or Ranged Weapon Attack:").replace(/\{@atk\s+msw\}/gi, "Melee or Ranged Spell Attack:").replace(/\{@atk\s+mw\}/gi, "Melee Weapon Attack:").replace(/\{@atk\s+rw\}/gi, "Ranged Weapon Attack:").replace(/\{@atk\s+ms\}/gi, "Melee Spell Attack:").replace(/\{@atk\s+rs\}/gi, "Ranged Spell Attack:").replace(/\{@hit\s+(\d+)\}/gi, "`atk:+$1`").replace(/\{@h\}/gi, "Hit:").replace(/\{@damage\s+([^}]+)\}/gi, "`damage:$1`").replace(/\{@dice\s+([^}]+)\}/gi, "`roll:$1`").replace(/\{@d20\s+([^}]+)\}/gi, "`roll:d20$1`").replace(/\{@dc\s+(\d+)\}/gi, "`dc:$1`").replace(/\{@recharge\s+(\d)\}/gi, "(Recharge $1-6)").replace(/\{@recharge\}/gi, "(Recharge)").replace(/\{@chance\s+(\d+)\}/gi, "$1% chance").replace(/\{@b(?:old)?\s+([^}]+)\}/gi, "**$1**").replace(/\{@i(?:talic)?\s+([^}]+)\}/gi, "_$1_").replace(/\{@s(?:trike)?\s+([^}]+)\}/gi, "~~$1~~").replace(/\{@note\s+([^}]+)\}/gi, "($1)").replace(/\{@spell\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@item\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@creature\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@condition\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@skill\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@sense\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@action\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@status\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@ability\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@class\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@feat\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@background\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@race\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@disease\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@hazard\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@plane\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@language\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@book\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@adventure\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@\w+\s+([^}]+)\}/g, "$1");
+  const rewritten = text.replace(/\{@atk\s+mw,rw\}/gi, "Melee or Ranged Weapon Attack:").replace(/\{@atk\s+mws\}/gi, "Melee or Ranged Weapon Attack:").replace(/\{@atk\s+msw\}/gi, "Melee or Ranged Spell Attack:").replace(/\{@atk\s+mw\}/gi, "Melee Weapon Attack:").replace(/\{@atk\s+rw\}/gi, "Ranged Weapon Attack:").replace(/\{@atk\s+ms\}/gi, "Melee Spell Attack:").replace(/\{@atk\s+rs\}/gi, "Ranged Spell Attack:").replace(/\{@hit\s+(\d+)\}/gi, "`atk:+$1`").replace(/\{@h\}\s*/gi, "Hit: ").replace(/\{@damage\s+([^}]+)\}/gi, "`damage:$1`").replace(/\{@dice\s+([^}]+)\}/gi, "`roll:$1`").replace(/\{@d20\s+([^}]+)\}/gi, "`roll:d20$1`").replace(/\{@dc\s+(\d+)\}/gi, "`dc:$1`").replace(/\{@recharge\s+(\d)\}/gi, "(Recharge $1-6)").replace(/\{@recharge\}/gi, "(Recharge)").replace(/\{@chance\s+(\d+)\}/gi, "$1% chance").replace(/\{@b(?:old)?\s+([^}]+)\}/gi, "**$1**").replace(/\{@i(?:talic)?\s+([^}]+)\}/gi, "_$1_").replace(/\{@s(?:trike)?\s+([^}]+)\}/gi, "~~$1~~").replace(/\{@note\s+([^}]+)\}/gi, "($1)").replace(/\{@spell\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@item\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@creature\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@condition\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@skill\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@sense\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@action\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@status\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@ability\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@class\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@feat\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@background\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@race\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@disease\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@hazard\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@plane\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@language\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@book\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@adventure\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@\w+\s+([^}]+)\}/g, "$1");
   return decorateProseDice(rewritten);
 }
 function decorateProseDice(text) {

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

@@ -1,16 +1,23 @@
 /**
- * Tiny DSL for Resource.max_formula and Resource.recovery[].amount (SP4d). Grammar:
+ * Tiny DSL for Resource.max_formula and Resource.recovery[].amount (SP4d; R4-G4 §6 added max / min). Grammar:
  *   expr   := term (('+' | '-') term)*
  *   term   := factor (('*' | '/') factor)*
- *   factor := number | string-arg-only | ident | '{' ident '}' | fn '(' expr ')'
+ *   factor := number | string-arg-only | ident | '{' ident '}' | fn1 '(' expr ')' | fnN '(' expr (',' expr)+ ')'
  *           | "column" '(' string ')' | '(' expr ')'
- *   fn     := 'ceil' | 'floor'
+ *   fn1    := 'ceil' | 'floor'          (exactly one argument)
+ *   fnN    := 'max' | 'min'             (two or more comma-separated arguments)
  *   ident  := level | class_level | prof | <abil>_mod
- * The single-quoted string literal (e.g. 'Seals') is valid ONLY as the
- * argument to column(...).
- * '*' and '/' bind tighter than '+'/'-'. '/' is real division; wrap in
- * ceil()/floor() for integer results (e.g. "ceil({class_level}/2)").
- * `999` is the at-will sentinel; it evaluates as the literal 999.
+ * The single-quoted string literal (e.g. 'Seals') is valid ONLY as the argument to column(...).
+ * '*' and '/' bind tighter than '+'/'-'. '/' is real division; wrap in ceil()/floor() for integer
+ * results (e.g. "ceil({class_level}/2)"). "max(1, {cha_mod})" is how the data says "a minimum of once".
+ * `AT_WILL_MAX` (999) is the at-will sentinel: it evaluates as the literal 999; R4-G4 T3 (§5) taught
+ * the plugin's charge boxes to render "at will" for it instead of 999 boxes (the `opts.atWill` branch
+ * at the head of `renderChargeBoxes`, fed by the `atWill: fu.max === AT_WILL_MAX` opt its callers
+ * pass). Measured 2026-09-05 on the plugin tree that carries T7b with
+ * `grep -rn "atWill:" packages/obsidian/src`: FOUR lines, the two T3 feature trackers
+ * `renderCardResource` and `renderFirstResourceTracker`, T5's pool-tab dice head `renderPoolHead`,
+ * and T7b's `renderPickTracker`, which draws a pool pick's own `uses` on the pool row, the granted
+ * row and the boon row.
  */
 export interface FormulaBindings {
     level: number;
@@ -27,6 +34,7 @@ export interface FormulaBindings {
      *  Read by the `column('Name')` accessor; missing name → 0. */
     columns: Record<string, number>;
 }
+export declare const AT_WILL_MAX = 999;
 export declare function isValidMaxFormula(formula: string): boolean;
 export declare function evaluateMaxFormula(formula: string, bindings: FormulaBindings): number;
 export interface ScalableResource {
@@ -36,6 +44,24 @@ export interface ScalableResource {
         max: string;
     }[];
 }
-/** The max-formula string in effect at `totalLevel`: the highest `scales_at`
- *  step whose level ≤ totalLevel, else the base `max_formula`. */
+/** The max-formula string in effect at `totalLevel`: the highest `scales_at` step whose level
+ *  ≤ totalLevel (the FIRST declaration wins on a duplicate level; a `level: 0` step is skipped), else
+ *  the base `max_formula`. Parse-free, so a die-string step comes back as the die string. Its one
+ *  production caller, the plugin's `seedFeatureUses` (`pc.resource-seed.ts`), moved to
+ *  `resolveMaxCountAt` in R4-G4 T3, so it is now TEST-ONLY: zero callers in this repo's `src/` and zero
+ *  in the plugin's `packages/obsidian/src/`, pinned by this repo's `tests/resource-formula.test.ts`
+ *  (its Bardic-Die-2024 and duplicate-level-tie cases) and by the plugin's cross-repo file of the same
+ *  name (its `describe("resolveMaxAt")` block). */
 export declare function resolveMaxAt(totalLevel: number, resource: ScalableResource): string;
+/** The max COUNT in effect at `level`: the highest `scales_at` step at or below `level` whose `max`
+ *  PARSES under the DSL, else the base `max_formula` if it parses, else null. Ties break exactly as
+ *  `resolveMaxAt` breaks them (the FIRST declaration at a duplicate level wins, a `level: 0` step is
+ *  skipped), so a duplicate-level pair of PARSING steps cannot make the count and the die label pick
+ *  different steps; where one member of the pair is a die string they DO pick different steps
+ *  (`[{level:3,max:"1d8"},{level:3,max:"3"}]` at 3 reads 3 here and "1d8" there), which is the same
+ *  parse-vs-string divergence described next. A step that does not parse is a die size (Bardic Die
+ *  2024: "1d8" at 5), not a count, and is skipped HERE while `resolveMaxAt` still returns it; a base
+ *  that does not parse (Sneak Attack "1d6") is a damage die, correctly no tracker. `resolveMaxAt`
+ *  keeps the parse-free string lookup; R4-G4 T3 handed its one production caller, the plugin seed, to
+ *  this function (see its docblock), so a null here is what the seed warns on and leaves un-seeded. */
+export declare function resolveMaxCountAt(level: number, resource: ScalableResource, bindings: FormulaBindings): number | null;