@archivist-gg/dnd5e 0.3.19 → 0.3.24

package/dist/monster/monster.enrichment.js

@@ -1,19 +1 @@
-import {
-  CR_TO_XP,
-  convertMonsterEntries,
-  enrichMonster,
-  getChallengeRatingXP,
-  getProficiencyBonus,
-  parseCR
-} from "../chunk-6PXTNCBP.js";
-import "../chunk-DEEHHLAP.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  CR_TO_XP,
-  convertMonsterEntries,
-  enrichMonster,
-  getChallengeRatingXP,
-  getProficiencyBonus,
-  parseCR
-};
+import{CR_TO_XP,convertMonsterEntries,enrichMonster,getChallengeRatingXP,getProficiencyBonus,parseCR}from"../chunk-JXDX2DKF.js";import"../chunk-MGGKZGLG.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{CR_TO_XP,convertMonsterEntries,enrichMonster,getChallengeRatingXP,getProficiencyBonus,parseCR};

package/dist/monster/monster.format.d.ts

@@ -1,26 +1,13 @@
-/**
- * R4-G6 §6 · READ-time decoding of the converter's 5etools-shaped monster leaves. Pure functions; every table is
- * DATA in this module (memory: rendering policy from the schema / data, never a switch on game vocabulary in a
- * renderer). Every function accepts the authored string / number shape AND the structured shape, and on the
- * string / number arms reproduces the plugin renderer's historical output byte for byte (invariant 5: the SRD
- * render pins are the proof).
- */
 import type { Abilities } from "../types/index.js";
 import type { AlignmentEntry, DamageQualifier, MonsterAC, MonsterCRStructured, MonsterGearEntry, MonsterHP, MonsterInitiative, MonsterSectionHeader, MonsterSpeed, MonsterSpellcasting, MonsterTypeStructured } from "./monster.types.js";
-/** The plugin renderer's historical helper, byte for byte (`/\b\w/g`), so `player's` becomes `Player'S`. */
 export declare function capitalizeWords(str: string): string;
-/** `capitalizeWords` applied OUTSIDE wikilink targets: the plain text and the ALIAS of `[[target|alias]]` are
- *  title-cased, the target never is (1,202 `ac[].from` links carry an apostrophe the plain helper mangles). */
 export declare function capitalizeOutsideLinks(str: string): string;
 export declare const SIZE_CODES: Readonly<Record<string, string>>;
 export declare function formatSize(size: string | string[] | undefined, note?: string): string;
-/** The FIRST decoded size word, lower-cased: the hit-die table and the edit-mode size select key on it. */
 export declare function sizeWord(size: string | string[] | undefined): string;
 export declare const ALIGNMENT_CODES: Readonly<Record<string, string>>;
-/** The multi-code SETS 5etools prints as a phrase, keyed by the sorted code set (the measured combos). */
 export declare const ALIGNMENT_SETS: Readonly<Record<string, string>>;
 export declare function formatAlignment(alignment: string | (string | AlignmentEntry)[] | undefined, prefix?: string): string;
-/** The decoded text lower-cased: the edit-mode alignment selects match on it. */
 export declare function alignmentWords(alignment: string | (string | AlignmentEntry)[] | undefined): string;
 export declare const IRREGULAR_PLURALS: Readonly<Record<string, string>>;
 export declare function formatType(type: string | MonsterTypeStructured | undefined, level?: number): string;
@@ -35,17 +22,9 @@ export interface FormattedCR {
     xpOverride?: number;
 }
 export declare function formatCR(cr: string | MonsterCRStructured | undefined): FormattedCR | undefined;
-/** Thousands-separated without `toLocaleString` (ICU-independent, deterministic across Node and Electron). */
 export declare function formatXP(xp: number): string;
-/** The bare `cr` text (today's Challenge value; `formatCR` normalises it before the PB / XP table reads). */
 export declare function crString(cr: string | MonsterCRStructured | undefined): string | undefined;
 export declare function challengeLine(cr: string | MonsterCRStructured | undefined, pbNote?: string): string | undefined;
-/** R4 {G5, G6} live rider N-3-3: a BRACED entry joins with a SPACE, every other with ", ". The braces
- *  flag marks an entry that reads as a parenthetical on the one before it ("15 (17 with mage armor)"),
- *  so emitting the list comma as well gave the Archmage and the converter's Feonor
- *  `Armor Class. 12, (15 with mage armor)`. The separator therefore belongs to the entry that FOLLOWS
- *  it, not to the list, which is why this joins by hand rather than with `Array.join`. A braced entry
- *  that opens the line still stands alone, and two unbraced entries still take the comma. */
 export declare function formatAC(ac: MonsterAC[] | undefined): string;
 export declare function formatHP(hp: MonsterHP | undefined): {
     text: string;
@@ -54,53 +33,15 @@ export declare function formatHP(hp: MonsterHP | undefined): {
 export declare const SPEED_MODES: readonly ["walk", "fly", "swim", "climb", "burrow"];
 export type SpeedMode = (typeof SPEED_MODES)[number];
 export declare function formatSpeed(speed: MonsterSpeed | undefined): string;
-/** The numeric part of a speed value, or 0 (the edit-mode number inputs and the `> 0` gates read this). */
 export declare function speedNumber(speed: MonsterSpeed | undefined, mode: SpeedMode): number;
 export declare function formatQualifiers(list: (string | DamageQualifier)[] | null | undefined): string[];
-/** The STRING entries only (the edit-mode multi-selects are `string[]`; structured entries are merged back on save). */
 export declare function qualifierStrings(list: (string | DamageQualifier)[] | null | undefined): string[];
 export declare const INITIATIVE_MODES: Readonly<Record<string, string>>;
 export declare function formatInitiative(initiative: number | MonsterInitiative | undefined, abilities: Abilities | undefined, pb: number): string | undefined;
 export declare function formatGear(gear: (string | MonsterGearEntry)[] | undefined): string;
-/**
- * The Languages line (R4 {G5, G6} live rider 3, Z-9-9). Each entry is title-cased, as this line has always
- * been, EXCEPT that the word immediately following an amount keeps the case it was authored in: that word is
- * the amount's unit. `capitalizeWords` reached it too, so a block read `Deep Speech; Telepathy 120 Ft.` while
- * the Senses line right above printed its own `darkvision 120 ft.` verbatim (Aboleth, Baphomet).
- *
- * The rule is a SHAPE, not a list of unit words: no vocabulary table enters this formatter. Measured over the
- * converter corpus' 4,042 monster notes that carry a `languages` block, the words that follow an amount there
- * are `ft` (527), `mile` (10), `miles` (7), `feet` (1), the conjunctions `and` (7) and `or` (2), and NINE
- * language names already authored with a capital (`Elvish`, `Common`, `Terran`, `Druidic`, `Ignan`, `Sylvan`,
- * `Celestial`, `Draconic`, `Auran`). Keeping the AUTHORED case rather than lower-casing is what leaves those
- * language names alone; the two conjunctions stop being title-cased, which is correct English and reaches no
- * SRD bundle document (there, `ft` is the only word that ever follows an amount).
- *
- * What this does NOT change: the rest of an entry's free prose is still title-cased, so
- * "understands Common and Deep Speech but can't speak" still renders with each word capitalised. That is the
- * line's shipped register and a separate copy question, recorded rather than changed here.
- */
 export declare function formatLanguages(list: string[] | undefined): string;
-/**
- * A monster's `skills` (and `skills_other.one_of`) KEY to the name a reader sees (R4 {G5, G6} live rider 3,
- * Z-9-8). Those keys are written with a separator · the SRD bundle's Donkey carries `animal_handling` and
- * `sleight_of_hand` · and `capitalizeWords` only upper-cases the first letter of each WORD, so the separator
- * survived and the line read `Animal_handling +0`. The separator is normalised and the CANONICAL list answers;
- * a key the list does not know keeps `capitalizeWords`, which is byte for byte what every key rendered before
- * (invariant 5: the sixteen one-word skills already agreed with the list, so only the two-word two move).
- */
 export declare function skillDisplayName(key: string): string;
 export declare function formatSkillsOther(list: unknown[] | undefined): string | undefined;
-/**
- * The generated legendary-action sentence (R4-G6 spec §6), used only when the document authors no
- * `section_headers` row for the section (plugin `monster.sections.ts`).
- *
- * `short_name` is read exactly as authored: a STRING is the subject verbatim; `true` and `false` both say "this
- * document has no separate short name", so the whole name prints; only an ABSENT key derives one through
- * `shortNameOfNamed`. Measured over the two shipped corpora (`g7-t8-wE-f1-d9-corpus.txt`): 24 monster documents carry
- * a `short_name` (11 `true`, 13 a string) and NONE carries `false`, so the false arm is a contract read from the type,
- * not an observed rendering.
- */
 export declare function legendaryIntro(m: {
     name: string;
     is_named_creature?: boolean;
@@ -112,24 +53,14 @@ export declare function sectionHeader(m: {
     mythic_header?: string[];
 }, section: "legendary_actions" | "mythic" | "reactions"): string[] | undefined;
 export type PlacedSection = "traits" | "actions" | "bonus_actions" | "reactions" | "legendary_actions";
-/** ONE object: the 5etools `displayAs` vocabulary to the stat-block section (the plugin never switches on it). */
 export declare const DISPLAY_AS_SECTION: Readonly<Record<string, Exclude<PlacedSection, "traits">>>;
 export declare function displayAsSection(displayAs: string | undefined): PlacedSection;
 declare const GROUP_ORDER: readonly ["will", "daily", "rest", "restLong", "recharge", "legendary", "charges", "ritual"];
-/** ONE label table: EVERY group of `GROUP_ORDER` owns its label text here, so the eight FREQUENCY-group labels are
- *  DATA; the slot-table wording (`Cantrips (At Will):`, `N Level (N Slots):`) is generated in `spellcastingLines`
- *  and deliberately outside this table. Title-cased to match the SRD 2024 statblock prose the vault already
- *  shows beside these entries. `plain` is a plain sub-key's label, and the whole label of the two count-less groups
- *  `will` and `ritual`; `each` is its `Ne` twin, absent where a group has no twin; `six` is `recharge`'s
- *  already-at-6 form. `N` stands for the sub-key's count. `charges` alone ends without a colon: `spellcastingLines`
- *  appends ` (chargesItem):` after it (§8.2). The KEY type is `GROUP_ORDER`'s union, so a ninth group without a row
- *  is a compile error rather than a runtime `undefined`. */
 export declare const SPELLCASTING_LABELS: Readonly<Record<(typeof GROUP_ORDER)[number], {
     plain: string;
     each?: string;
     six?: string;
 }>>;
 export declare function spellcastingLines(block: MonsterSpellcasting): string[];
-/** The measured node vocabulary to markdown; never throws; an unknown type recurses into its children only. */
 export declare function entriesToMarkdown(tree: unknown): string;
 export {};

package/dist/monster/monster.format.js

@@ -1,78 +1 @@
-import {
-  ALIGNMENT_CODES,
-  ALIGNMENT_SETS,
-  DISPLAY_AS_SECTION,
-  INITIATIVE_MODES,
-  IRREGULAR_PLURALS,
-  SIZE_CODES,
-  SPEED_MODES,
-  SPELLCASTING_LABELS,
-  alignmentWords,
-  capitalizeOutsideLinks,
-  capitalizeWords,
-  challengeLine,
-  crString,
-  displayAsSection,
-  entriesToMarkdown,
-  formatAC,
-  formatAlignment,
-  formatCR,
-  formatGear,
-  formatHP,
-  formatInitiative,
-  formatLanguages,
-  formatQualifiers,
-  formatSize,
-  formatSkillsOther,
-  formatSpeed,
-  formatType,
-  formatXP,
-  legendaryIntro,
-  qualifierStrings,
-  sectionHeader,
-  sizeWord,
-  skillDisplayName,
-  speedNumber,
-  spellcastingLines
-} from "../chunk-2FRUSVZS.js";
-import "../chunk-6PXTNCBP.js";
-import "../chunk-DEEHHLAP.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  ALIGNMENT_CODES,
-  ALIGNMENT_SETS,
-  DISPLAY_AS_SECTION,
-  INITIATIVE_MODES,
-  IRREGULAR_PLURALS,
-  SIZE_CODES,
-  SPEED_MODES,
-  SPELLCASTING_LABELS,
-  alignmentWords,
-  capitalizeOutsideLinks,
-  capitalizeWords,
-  challengeLine,
-  crString,
-  displayAsSection,
-  entriesToMarkdown,
-  formatAC,
-  formatAlignment,
-  formatCR,
-  formatGear,
-  formatHP,
-  formatInitiative,
-  formatLanguages,
-  formatQualifiers,
-  formatSize,
-  formatSkillsOther,
-  formatSpeed,
-  formatType,
-  formatXP,
-  legendaryIntro,
-  qualifierStrings,
-  sectionHeader,
-  sizeWord,
-  skillDisplayName,
-  speedNumber,
-  spellcastingLines
-};
+import{ALIGNMENT_CODES,ALIGNMENT_SETS,DISPLAY_AS_SECTION,INITIATIVE_MODES,IRREGULAR_PLURALS,SIZE_CODES,SPEED_MODES,SPELLCASTING_LABELS,alignmentWords,capitalizeOutsideLinks,capitalizeWords,challengeLine,crString,displayAsSection,entriesToMarkdown,formatAC,formatAlignment,formatCR,formatGear,formatHP,formatInitiative,formatLanguages,formatQualifiers,formatSize,formatSkillsOther,formatSpeed,formatType,formatXP,legendaryIntro,qualifierStrings,sectionHeader,sizeWord,skillDisplayName,speedNumber,spellcastingLines}from"../chunk-BCXGB4HP.js";import"../chunk-JXDX2DKF.js";import"../chunk-MGGKZGLG.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{ALIGNMENT_CODES,ALIGNMENT_SETS,DISPLAY_AS_SECTION,INITIATIVE_MODES,IRREGULAR_PLURALS,SIZE_CODES,SPEED_MODES,SPELLCASTING_LABELS,alignmentWords,capitalizeOutsideLinks,capitalizeWords,challengeLine,crString,displayAsSection,entriesToMarkdown,formatAC,formatAlignment,formatCR,formatGear,formatHP,formatInitiative,formatLanguages,formatQualifiers,formatSize,formatSkillsOther,formatSpeed,formatType,formatXP,legendaryIntro,qualifierStrings,sectionHeader,sizeWord,skillDisplayName,speedNumber,spellcastingLines};

package/dist/monster/monster.parser.d.ts

@@ -1,8 +1,4 @@
 import type { Monster } from "./monster.types.js";
 import type { ParseResult } from "@archivist-gg/core";
-/**
- * R4-G6 §4.1 · the hand parser's tolerances made explicit, BEFORE `safeParse`. Each step rewrites only a shape the
- * old parser already rewrote, coerced or dropped; the converter corpora are untouched by it (0 / 0 / 0 measured).
- */
 export declare function migrateLegacy(raw: Record<string, unknown>): void;
 export declare function parseMonster(source: string): ParseResult<Monster>;

package/dist/monster/monster.parser.js

@@ -1,15 +1 @@
-import {
-  migrateLegacy,
-  parseMonster
-} from "../chunk-BJWSOQUC.js";
-import "../chunk-VP5TIXDK.js";
-import "../chunk-B2QHP6UF.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  migrateLegacy,
-  parseMonster
-};
+import{migrateLegacy,parseMonster}from"../chunk-6ASJ3MVB.js";import"../chunk-QFIGPOFW.js";import"../chunk-V6NQ547U.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{migrateLegacy,parseMonster};

package/dist/monster/monster.resolve.d.ts

@@ -1,9 +1,5 @@
 import type { ResolveContext } from "@archivist-gg/core";
 import type { MonsterRaw } from "./monster.codec.js";
-/**
- * Light, non-mutating derivation: computes proficiency bonus and XP from the
- * monster's challenge rating. Returns a new object; the input `raw` is untouched.
- */
 export declare function resolveMonster(raw: MonsterRaw, _ctx: ResolveContext): MonsterRaw & {
     proficiency_bonus: number;
     xp: number;

package/dist/monster/monster.schema.d.ts

@@ -1,11 +1,3 @@
-/**
- * R4-G6 §3 · the monster schema. Every key the converter and the SRD bundle emit is DECLARED (79 converter keys +
- * `name`, `subtype`, `columns`, `slug` / `edition` / `source`, `image` / `thumbnail`, `raw`). An undeclared TOP-LEVEL key
- * relocates to `raw` (the parser's extras copy); an undeclared NESTED key is stripped and the converter census reports
- * it (plain `z.object` on every nested container: Gate 0 Q1). No `.default()`; no `.min(1)` on `rendering_hint`
- * (always `""`); one nullable spelling. `satisfies` (never an annotation) keeps `.shape`, which `MONSTER_KNOWN_KEYS`
- * and the parity test read.
- */
 import { z } from "zod";
 import type { DamageQualifier } from "./monster.types.js";
 export declare const damageQualifierSchema: z.ZodType<DamageQualifier>;
@@ -347,7 +339,6 @@ export declare const monsterSchema: z.ZodObject<{
     has_token: z.ZodOptional<z.ZodBoolean>;
     token_credit: z.ZodOptional<z.ZodString>;
     token_custom: z.ZodOptional<z.ZodBoolean>;
-    foundry_token_scale: z.ZodOptional<z.ZodNumber>;
     sound_clip: z.ZodOptional<z.ZodObject<{
         type: z.ZodString;
         path: z.ZodString;

package/dist/monster/monster.schema.js

@@ -1,34 +1 @@
-import {
-  MONSTER_KNOWN_KEYS,
-  alignmentEntrySchema,
-  damageQualifierSchema,
-  gearEntrySchema,
-  initiativeSchema,
-  monsterACSchema,
-  monsterCRSchema,
-  monsterHPSchema,
-  monsterSchema,
-  monsterSpeedSchema,
-  monsterSpellcastingSchema,
-  monsterTypeSchema
-} from "../chunk-VP5TIXDK.js";
-import "../chunk-B2QHP6UF.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  MONSTER_KNOWN_KEYS,
-  alignmentEntrySchema,
-  damageQualifierSchema,
-  gearEntrySchema,
-  initiativeSchema,
-  monsterACSchema,
-  monsterCRSchema,
-  monsterHPSchema,
-  monsterSchema,
-  monsterSpeedSchema,
-  monsterSpellcastingSchema,
-  monsterTypeSchema
-};
+import{MONSTER_KNOWN_KEYS,alignmentEntrySchema,damageQualifierSchema,gearEntrySchema,initiativeSchema,monsterACSchema,monsterCRSchema,monsterHPSchema,monsterSchema,monsterSpeedSchema,monsterSpellcastingSchema,monsterTypeSchema}from"../chunk-QFIGPOFW.js";import"../chunk-V6NQ547U.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{MONSTER_KNOWN_KEYS,alignmentEntrySchema,damageQualifierSchema,gearEntrySchema,initiativeSchema,monsterACSchema,monsterCRSchema,monsterHPSchema,monsterSchema,monsterSpeedSchema,monsterSpellcastingSchema,monsterTypeSchema};

package/dist/monster/monster.types.d.ts

@@ -77,7 +77,6 @@ export interface Monster {
     has_token?: boolean;
     token_credit?: string;
     token_custom?: boolean;
-    foundry_token_scale?: number;
     sound_clip?: MonsterSoundClip;
     alt_art?: MonsterAltArt[];
     image?: string | string[];
@@ -185,8 +184,6 @@ export interface MonsterSpellcasting {
     charges?: Record<string, MonsterSpellEntry[]>;
     chargesItem?: string;
 }
-/** `advantage_mode` is a STRING, decoded by `INITIATIVE_MODES` in monster.format.ts (never a closed enum: a hand-typed
- *  5etools `adv` must not refuse the document). */
 export interface MonsterInitiative {
     proficiency?: number;
     advantage_mode?: string;

package/dist/monster/monster.types.js

@@ -1 +1 @@
-import "../chunk-IKSMX4TN.js";
+import"../chunk-IKSMX4TN.js";

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

@@ -1,14 +1,3 @@
 import type { DocCodec } from "@archivist-gg/core";
 import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
-/**
- * Normalizing codec (0c.1a). `parse` delegates to `parseOptionalFeature`, which
- * seeds the `edition: "2014"` default and validates against
- * `optionalFeatureEntitySchema`. `serialize` stays `yaml.dump` (the edit-save
- * path uses obsidian's separate serializer; gate (d) verifies `yaml.dump`
- * round-trips through `parseOptionalFeature`).
- *
- * SPECIAL (0c.1a Task 7): the entity type already lives at
- * `@archivist-gg/dnd5e/types/optional-feature.types` (moved in 0c.0), so the codec
- * imports it from there rather than a sibling `./optional-feature.types`.
- */
 export declare const optionalFeatureCodec: DocCodec<OptionalFeatureEntity>;

package/dist/optional-feature/optional-feature.codec.js

@@ -1,13 +1 @@
-import {
-  optionalFeatureCodec
-} from "../chunk-FVXLP7P3.js";
-import "../chunk-FMUD3LDV.js";
-import "../chunk-VN5DLURA.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  optionalFeatureCodec
-};
+import{optionalFeatureCodec}from"../chunk-GIOV6JW7.js";import"../chunk-DZKSXSJF.js";import"../chunk-I4O2FIDT.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{optionalFeatureCodec};

package/dist/optional-feature/optional-feature.parser.js

@@ -1,12 +1 @@
-import {
-  parseOptionalFeature
-} from "../chunk-FMUD3LDV.js";
-import "../chunk-VN5DLURA.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  parseOptionalFeature
-};
+import{parseOptionalFeature}from"../chunk-DZKSXSJF.js";import"../chunk-I4O2FIDT.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{parseOptionalFeature};

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

@@ -166,7 +166,8 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
     available_to: z.ZodArray<z.ZodString>;
     effects: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"initiative-bonus">;
-        value: z.ZodNumber;
+        value: z.ZodOptional<z.ZodNumber>;
+        amount: z.ZodOptional<z.ZodString>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
@@ -293,6 +294,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             unarmed: "unarmed";
             finesse: "finesse";
             thrown: "thrown";
+            "pact-weapon": "pact-weapon";
         }>, z.ZodArray<z.ZodEnum<{
             weapon: "weapon";
             melee: "melee";
@@ -300,6 +302,7 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             unarmed: "unarmed";
             finesse: "finesse";
             thrown: "thrown";
+            "pact-weapon": "pact-weapon";
         }>>]>>;
         spell_scope: z.ZodOptional<z.ZodObject<{
             list: z.ZodOptional<z.ZodString>;
@@ -398,6 +401,23 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
             level: z.ZodNumber;
             count: z.ZodNumber;
         }, z.core.$strip>>>;
+        applies_to: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            weapon: "weapon";
+            melee: "melee";
+            ranged: "ranged";
+            unarmed: "unarmed";
+            finesse: "finesse";
+            thrown: "thrown";
+            "pact-weapon": "pact-weapon";
+        }>, z.ZodArray<z.ZodEnum<{
+            weapon: "weapon";
+            melee: "melee";
+            ranged: "ranged";
+            unarmed: "unarmed";
+            finesse: "finesse";
+            thrown: "thrown";
+            "pact-weapon": "pact-weapon";
+        }>>]>>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{

package/dist/optional-feature/optional-feature.schema.js

@@ -1,15 +1 @@
-import {
-  infuseBlockSchema,
-  optionRowSchema,
-  optionalFeatureEntitySchema
-} from "../chunk-VN5DLURA.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  infuseBlockSchema,
-  optionRowSchema,
-  optionalFeatureEntitySchema
-};
+import{infuseBlockSchema,optionRowSchema,optionalFeatureEntitySchema}from"../chunk-I4O2FIDT.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{infuseBlockSchema,optionRowSchema,optionalFeatureEntitySchema};

package/dist/pack.d.ts

@@ -1,11 +1,2 @@
 import type { SystemPack } from "@archivist-gg/core";
-/**
- * The real `dnd5e` SystemPack. It owns the parse/resolve/generate contract for
- * D&D 5e entity types via their {@link EntityType} definitions; presentation
- * (renderer/edit/modal) stays in the obsidian package. It is the only pack the
- * kernel registers.
- *
- * All 12 authored types are ported, plus the two generate-only types (npc and
- * encounter); a new entity type joins by appending its EntityType here.
- */
 export declare const dnd5ePack: SystemPack;

package/dist/pc/conditions.constants.js

@@ -1,6 +1 @@
-import {
-  CONDITION_SLUGS
-} from "../chunk-S7REMWW4.js";
-export {
-  CONDITION_SLUGS
-};
+import{CONDITION_SLUGS}from"../chunk-KM75CC6Q.js";export{CONDITION_SLUGS};

package/dist/pc/decision-recognizer.js

@@ -1,8 +1 @@
-import {
-  DECISION_SIGNAL,
-  recognizeDecision
-} from "../chunk-YHYTW5QA.js";
-export {
-  DECISION_SIGNAL,
-  recognizeDecision
-};
+import{DECISION_SIGNAL,recognizeDecision}from"../chunk-3LWOVRLA.js";export{DECISION_SIGNAL,recognizeDecision};

package/dist/pc/pc.additional-spells.d.ts

@@ -5,21 +5,11 @@ import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
 import type { Ability } from "@archivist-gg/dnd5e";
 import type { ChoiceValue, ResolvedClass, ResolvedPool, ResolvedSpell } from "./pc.types.js";
 export declare const prefixOf: (slug: string) => string;
-/** §5.2.2 · a raw 5etools / bundle spell ref → the bare NAME slug. The path tail is taken ONLY for a wikilink; a bare
- *  name may legally contain "/" ("blindness/deafness" → "blindnessdeafness", the converter's own slug tail · Gate 0 B1).
- *  The "|source" token is DISCARDED (no abbreviation table exists anywhere); "#c"/"#2" are redundant with entity.level. */
 export declare function normalizeSpellRef(ref: unknown): string | null;
 export interface SpellNameIndex {
     byName: Map<string, RegisteredEntity[]>;
 }
-/** At most ONE scan of the spell bucket per resolve(), keyed on slugify(entity name) · NEVER on the slug tail (Gate 0
- *  B2: the generators hyphenate "/" where dnd5e's slugify deletes it, so three bundle spells differ). Built LAZILY by
- *  its caller, on the first leaf that CALLS `resolveSpellByName` (the argument is evaluated whatever step then
- *  resolves it), so a character with no `additional_spells` leaf pays nothing for it. */
 export declare function buildSpellNameIndex(entities: EntityRegistry): SpellNameIndex;
-/** §5.2.3 · deterministic, no minted vocabulary: (0) the character's own copy · (a) the carrier's compendium exactly ·
- *  (b) same compendium → same edition (skipped when either side lacks one) → lowest full slug · (c) MISS → null + warnOnce ·
- *  (d) ambiguity after (i)+(ii) → (iii) decides AND warnOnce (the decision-engine byBare precedent). */
 export declare function resolveSpellByName(opts: {
     entities: EntityRegistry;
     index: SpellNameIndex;
@@ -31,19 +21,8 @@ export declare function resolveSpellByName(opts: {
     entity: Spell;
     slug: string;
 } | null;
-/** §5.2.9 · fold a race's entries ONLY when no select-inline on race.choices[] / traits[].choices[] / nested option.choices[]
- *  carries an id outside the structural set (nested: zero carriers, defensive). */
 export declare function raceIsUngated(race: RaceEntity): boolean;
-/** SRD-G T4: the slugs (value and label) of every option the character CHOSE on a race's content select-inlines
- *  (`race.choices[]` and `traits[].choices[]`, the structural set excluded), read through `read(<choice id>)`. */
 export declare function chosenRaceOptionKeys(race: RaceEntity, read: (id: string) => ChoiceValue | undefined): Set<string>;
-/** §5.2.1 · the reader. Every object it receives is the RAW registry entity; nothing is mutated.
- *
- *  SRD-G T4 (audit §3a): the RACE root also reads (1) a race whose lineage select-inline GATES it: the entry NAMED like
- *  the option the character chose folds (the SRD 5.2 Tiefling's legacy, the Elf's and Gnome's lineage); an unnamed
- *  entry on a gated race still folds nothing (it may belong to any lineage); (2) an `ability: {choose}` entry, when
- *  `raceChoice("spellcasting-ability")` answers one of its abilities (unanswered, the entry waits for the pick);
- *  (3) the `innate` level spells (the level 3 / 5 once-per-Long-Rest spells), folded always prepared like `known`. */
 export declare function collectAdditionalSpells(args: {
     race: RaceEntity | null;
     feats: FeatEntity[];
@@ -53,9 +32,6 @@ export declare function collectAdditionalSpells(args: {
     alreadyCollected: ResolvedSpell[];
     entities: EntityRegistry;
     warnings: string[];
-    /** SRD-G T4: the character's answer to a race choice, by choice id (`origin_choices["race:<id>"]`). */
     raceChoice?: (id: string) => ChoiceValue | undefined;
-    /** User report 2026-09-28: the RESOLVED pools. Every member the character has (a pick or a grant; an item-bound one's
-     *  subject is its item) is a root, read at the owning class's level, its spells that class's. */
     pools?: ReadonlyArray<ResolvedPool>;
 }): ResolvedSpell[];

package/dist/pc/pc.additional-spells.js

@@ -1,26 +1 @@
-import {
-  buildSpellNameIndex,
-  chosenRaceOptionKeys,
-  collectAdditionalSpells,
-  normalizeSpellRef,
-  prefixOf,
-  raceIsUngated,
-  resolveSpellByName
-} from "../chunk-LICYHPI3.js";
-import "../chunk-PVCEA4HZ.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-4J6DS3EJ.js";
-import "../chunk-ZCTUYGNV.js";
-import "../chunk-7Q2VPKCD.js";
-import "../chunk-ZDAEGJH4.js";
-import "../chunk-WELIKLZF.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  buildSpellNameIndex,
-  chosenRaceOptionKeys,
-  collectAdditionalSpells,
-  normalizeSpellRef,
-  prefixOf,
-  raceIsUngated,
-  resolveSpellByName
-};
+import{buildSpellNameIndex,chosenRaceOptionKeys,collectAdditionalSpells,normalizeSpellRef,prefixOf,raceIsUngated,resolveSpellByName}from"../chunk-A7H6LX47.js";import"../chunk-UBUKCRZ3.js";import"../chunk-DY6FVAGA.js";import"../chunk-CMIEZQL4.js";import"../chunk-BGX36NPE.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-63YJPWTM.js";import"../chunk-4KVVAENP.js";import"../chunk-7EL3GWWJ.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";import"../chunk-I26FHSI6.js";export{buildSpellNameIndex,chosenRaceOptionKeys,collectAdditionalSpells,normalizeSpellRef,prefixOf,raceIsUngated,resolveSpellByName};

package/dist/pc/pc.amount-bindings.d.ts

@@ -1,41 +1,16 @@
-/**
- * D2b-A · the numbers an amount resolves against (design §1.2 A). The modifier and the save DC are those of the class
- * that OWNS the feature or grants the spell (multiclass: the granting class, user ruling 2026-09-27).
- */
 import type { Ability } from "@archivist-gg/dnd5e/types/choice";
 import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
 import { type AmountBindings } from "@archivist-gg/dnd5e/dnd/amount-text";
 import type { DerivedStats, FeatureSource, ResolvedCharacter, ResolvedSpell, SpellDamageRider } from "./pc.types.js";
-/** The derived fields the bindings read (recalc builds them before its return; the sheet passes `ctx.derived`). */
 export type AmountDerived = Pick<DerivedStats, "proficiencyBonus" | "mods" | "spellcastingClasses"> & Partial<Pick<DerivedStats, "abilitySpellcasting">>;
-/** The class slug that owns `source`: a class by its slug, a subclass by the class that holds it, a feat through the
- *  slot it was taken at (`via`), a pool member through its pool's class. Null for race, background and campaign. */
 export declare function ownerClassSlug(source: FeatureSource | undefined, resolved: Pick<ResolvedCharacter, "classes">): string | null;
-/** The bindings an amount owned by `owner` resolves against: `class_level` is the OWNING class's level (the total level
- *  for a race, background or unowned source), `spell_mod` / `spell_dc` come from that class's spellcasting row, else
- *  the first caster's, else they stay unbound (the amount prints its words or a label). */
 export declare function amountBindingsFor(owner: FeatureSource | undefined, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
-/** How a spell is cast: its ability, save DC and attack bonus. A grant that carries its OWN ability (a feat's chosen
- *  ability, a race grant, a class-less row) reads `abilitySpellcasting`; every other spell reads its class's row, else
- *  the first caster's. The one lookup the Spells tab's DC, attack and effect cells share. */
 export declare function spellcastingFor(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability">, derived: AmountDerived): {
     ability: Ability;
     saveDC: number;
     attackBonus: number;
 } | null;
-/** The bindings a spell's effect resolves against: its caster's modifier and save DC (see {@link spellcastingFor}). */
 export declare function spellAmountBindings(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability">, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
-/** What a spell adds to its base roll ONCE, in token form: `{spell_mod}` when its text reads "<the base roll> plus (or
- *  +) your spellcasting (ability) modifier" (35 vault notes: Healing Word, Cure Wounds, Spiritual Weapon, ...), else
- *  null. Read from the note's own words at read time; the roll must be the one the phrase follows, so a spell whose
- *  modifier rides a different roll (a heal beside a damage roll) adds nothing. */
 export declare function spellRollBonus(spell: Pick<Spell, "damage_roll" | "description">): string | null;
-/** The spell's printed roll with every spell damage rider that reaches it added INSIDE the one roll (bonus damage prints
- *  in the damage cell, user ruling): Agonizing Blast's Charisma on its cantrip reads "1d10+3" (found live 2026-09-28),
- *  Potent Spellcasting's Wisdom on Sacred Flame "1d8+3". A conditional rider, or one of another canonical damage type
- *  than the spell's own, is not added here: it is a line of its own (`spellDamageRiderLines`). */
 export declare function addSpellDamageRiders(roll: string, spell: Pick<ResolvedSpell, "slug" | "entity">, derived: Partial<Pick<DerivedStats, "spellDamageRiders">>): string;
-/** The spell damage riders that reach `spell` but do not fold into its roll, each its own line in the damage cell, the
- *  way a conditional weapon rider is (Power Surge's "+ 5 force" once a surge is spent; Arcane Firearm's "+ 1d8" through
- *  the firearm): a `condition`, or another canonical damage type. `spells` and `once` are the engine's, not the line's. */
 export declare function spellDamageRiderLines(spell: Pick<ResolvedSpell, "slug" | "entity">, derived: Partial<Pick<DerivedStats, "spellDamageRiders">>): Array<Pick<SpellDamageRider, "amount" | "damage_type" | "source" | "condition">>;