@archivist-gg/dnd5e 0.1.0

package/dist/pc/pc.schema.d.ts

@@ -0,0 +1,294 @@
+import { z } from "zod";
+export declare const characterSchema: z.ZodObject<{
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    builder: z.ZodOptional<z.ZodBoolean>;
+    alignment: z.ZodOptional<z.ZodString>;
+    age: z.ZodOptional<z.ZodString>;
+    race: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    subrace: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    background: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    class: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        level: z.ZodNumber;
+        subclass: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        choices: z.ZodDefault<z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodCatch<z.ZodRecord<z.ZodString, z.ZodCatch<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>>>>;
+    }, z.core.$strip>>>;
+    origin_choices: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCatch<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>>;
+    abilities: z.ZodObject<{
+        str: z.ZodNumber;
+        dex: z.ZodNumber;
+        con: z.ZodNumber;
+        int: z.ZodNumber;
+        wis: z.ZodNumber;
+        cha: z.ZodNumber;
+    }, z.core.$strip>;
+    ability_method: z.ZodEnum<{
+        "standard-array": "standard-array";
+        "point-buy": "point-buy";
+        "archivist-point-buy": "archivist-point-buy";
+        rolled: "rolled";
+        manual: "manual";
+    }>;
+    builder_rolls: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    builder_equipment_mode: z.ZodOptional<z.ZodEnum<{
+        gold: "gold";
+        starting: "starting";
+        empty: "empty";
+    }>>;
+    skills: z.ZodDefault<z.ZodObject<{
+        proficient: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            acrobatics: "acrobatics";
+            "animal-handling": "animal-handling";
+            arcana: "arcana";
+            athletics: "athletics";
+            deception: "deception";
+            history: "history";
+            insight: "insight";
+            intimidation: "intimidation";
+            investigation: "investigation";
+            medicine: "medicine";
+            nature: "nature";
+            perception: "perception";
+            performance: "performance";
+            persuasion: "persuasion";
+            religion: "religion";
+            "sleight-of-hand": "sleight-of-hand";
+            stealth: "stealth";
+            survival: "survival";
+        }>>>;
+        expertise: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            acrobatics: "acrobatics";
+            "animal-handling": "animal-handling";
+            arcana: "arcana";
+            athletics: "athletics";
+            deception: "deception";
+            history: "history";
+            insight: "insight";
+            intimidation: "intimidation";
+            investigation: "investigation";
+            medicine: "medicine";
+            nature: "nature";
+            perception: "perception";
+            performance: "performance";
+            persuasion: "persuasion";
+            religion: "religion";
+            "sleight-of-hand": "sleight-of-hand";
+            stealth: "stealth";
+            survival: "survival";
+        }>>>;
+    }, z.core.$strip>>;
+    spells: z.ZodDefault<z.ZodObject<{
+        known: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            spell: z.ZodString;
+            class: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodEnum<{
+                domain: "domain";
+                race: "race";
+                item: "item";
+                class: "class";
+                feat: "feat";
+            }>>;
+            prepared: z.ZodOptional<z.ZodBoolean>;
+            always_prepared: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>]>>>;
+        overrides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            slug: z.ZodString;
+            overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        view: z.ZodOptional<z.ZodEnum<{
+            table: "table";
+            "by-level": "by-level";
+        }>>;
+    }, z.core.$strip>>;
+    equipment: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        item: z.ZodString;
+        equipped: z.ZodOptional<z.ZodBoolean>;
+        attuned: z.ZodOptional<z.ZodBoolean>;
+        qty: z.ZodOptional<z.ZodNumber>;
+        notes: z.ZodOptional<z.ZodString>;
+        slot: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            armor: "armor";
+            shield: "shield";
+            mainhand: "mainhand";
+            offhand: "offhand";
+        }>>>;
+        overrides: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            bonus: z.ZodOptional<z.ZodNumber>;
+            damage_bonus: z.ZodOptional<z.ZodNumber>;
+            extra_damage: z.ZodOptional<z.ZodString>;
+            ac_bonus: z.ZodOptional<z.ZodNumber>;
+            action: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                "bonus-action": "bonus-action";
+                reaction: "reaction";
+                free: "free";
+                special: "special";
+            }>>;
+            range: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        state: z.ZodOptional<z.ZodObject<{
+            charges: z.ZodOptional<z.ZodObject<{
+                current: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strip>>;
+            recovery: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodString;
+                reset: z.ZodEnum<{
+                    dawn: "dawn";
+                    special: "special";
+                    long: "long";
+                    short: "short";
+                }>;
+            }, z.core.$strip>>;
+            depletion_risk: z.ZodOptional<z.ZodObject<{
+                trigger: z.ZodString;
+                roll: z.ZodString;
+                threshold: z.ZodNumber;
+                effect: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>;
+        granted_by: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    overrides: z.ZodDefault<z.ZodObject<{
+        scores: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }> & z.core.$partial, z.ZodNumber>>;
+        saves: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }> & z.core.$partial, z.ZodObject<{
+            bonus: z.ZodOptional<z.ZodNumber>;
+            proficient: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        skills: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            acrobatics: "acrobatics";
+            "animal-handling": "animal-handling";
+            arcana: "arcana";
+            athletics: "athletics";
+            deception: "deception";
+            history: "history";
+            insight: "insight";
+            intimidation: "intimidation";
+            investigation: "investigation";
+            medicine: "medicine";
+            nature: "nature";
+            perception: "perception";
+            performance: "performance";
+            persuasion: "persuasion";
+            religion: "religion";
+            "sleight-of-hand": "sleight-of-hand";
+            stealth: "stealth";
+            survival: "survival";
+        }> & z.core.$partial, z.ZodObject<{
+            bonus: z.ZodNumber;
+            proficiency: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                proficient: "proficient";
+                expertise: "expertise";
+            }>>;
+        }, z.core.$strip>>>;
+        passives: z.ZodOptional<z.ZodObject<{
+            perception: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            investigation: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            insight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        hp: z.ZodOptional<z.ZodObject<{
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        ac: z.ZodOptional<z.ZodNumber>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        initiative: z.ZodOptional<z.ZodNumber>;
+        spellcasting: z.ZodOptional<z.ZodObject<{
+            saveDC: z.ZodOptional<z.ZodNumber>;
+            attackBonus: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        spell_slots: z.ZodOptional<z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodNumber>>;
+        attunement_limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    currency: z.ZodOptional<z.ZodObject<{
+        cp: z.ZodNumber;
+        sp: z.ZodNumber;
+        ep: z.ZodNumber;
+        gp: z.ZodNumber;
+        pp: z.ZodNumber;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+    defenses: z.ZodOptional<z.ZodObject<{
+        resistances: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        immunities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        vulnerabilities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        condition_immunities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    state: z.ZodObject<{
+        hp: z.ZodObject<{
+            current: z.ZodNumber;
+            max: z.ZodNumber;
+            temp: z.ZodNumber;
+        }, z.core.$strip>;
+        hit_dice: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            used: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>>>;
+        spell_slots: z.ZodDefault<z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodObject<{
+            used: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>>>;
+        spell_slots_pact: z.ZodOptional<z.ZodObject<{
+            level: z.ZodNumber;
+            used: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>>;
+        concentration: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        conditions: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            poisoned: "poisoned";
+            grappled: "grappled";
+            paralyzed: "paralyzed";
+            petrified: "petrified";
+            prone: "prone";
+            restrained: "restrained";
+            unconscious: "unconscious";
+            charmed: "charmed";
+            frightened: "frightened";
+            blinded: "blinded";
+            deafened: "deafened";
+            stunned: "stunned";
+            incapacitated: "incapacitated";
+            invisible: "invisible";
+        }>>>;
+        exhaustion: z.ZodDefault<z.ZodNumber>;
+        death_saves: z.ZodOptional<z.ZodObject<{
+            successes: z.ZodNumber;
+            failures: z.ZodNumber;
+        }, z.core.$strip>>;
+        inspiration: z.ZodDefault<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodObject<{
+            cp: z.ZodNumber;
+            sp: z.ZodNumber;
+            ep: z.ZodNumber;
+            gp: z.ZodNumber;
+            pp: z.ZodNumber;
+        }, z.core.$strip>>;
+        feature_uses: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            used: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strip>>>;
+        active_buffs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        attuned_items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CharacterInput = z.input<typeof characterSchema>;
+export type CharacterOutput = z.output<typeof characterSchema>;

package/dist/pc/pc.schema.js

@@ -0,0 +1,7 @@
+import {
+  characterSchema
+} from "../chunk-ZLG6FQFB.js";
+import "../chunk-TZK36BU7.js";
+export {
+  characterSchema
+};

package/dist/pc/pc.slotting.d.ts

@@ -0,0 +1,22 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { ItemEntity } from "@archivist-gg/dnd5e/item/item.types";
+import type { ArmorEntity } from "@archivist-gg/dnd5e/armor/armor.types";
+import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
+import type { SlotKey } from "./pc.types.js";
+export declare function isItemEntity(e: unknown): e is ItemEntity;
+export declare function isWeaponEntity(e: unknown): e is WeaponEntity;
+export declare function isArmorEntity(e: unknown): e is ArmorEntity;
+/** Resolve an equipment entry's `item` wikilink (or bare slug) through the shared
+ *  base-item resolver so vault-path wikilinks, alias wikilinks, AND
+ *  compendium-prefixed slugs all resolve consistently. */
+export declare function resolveEntityForEntry(item: string, registry: EntityRegistry): {
+    entity: ArmorEntity | WeaponEntity | ItemEntity | null;
+    entityType: string | null;
+};
+/** Is this armor a shield? Robust to SRD-2024 data where the Shield entity
+ *  carries `category: "heavy"` rather than `"shield"`. */
+export declare function isShieldArmor(armor: ArmorEntity): boolean;
+/** The ArmorEntity whose `ac` block governs a slot: the entity itself when armor,
+ *  or — for a magic item whose `base_item` points at armor — the resolved base. */
+export declare function effectiveArmor(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry: EntityRegistry): ArmorEntity | null;
+export declare function defaultSlotForType(entityType: string | null, entity: ArmorEntity | WeaponEntity | ItemEntity | null, registry: EntityRegistry): SlotKey | null;

package/dist/pc/pc.slotting.js

@@ -0,0 +1,20 @@
+import {
+  defaultSlotForType,
+  effectiveArmor,
+  isArmorEntity,
+  isItemEntity,
+  isShieldArmor,
+  isWeaponEntity,
+  resolveEntityForEntry
+} from "../chunk-UC4FE5X3.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+export {
+  defaultSlotForType,
+  effectiveArmor,
+  isArmorEntity,
+  isItemEntity,
+  isShieldArmor,
+  isWeaponEntity,
+  resolveEntityForEntry
+};

package/dist/pc/pc.spellcasting.d.ts

@@ -0,0 +1,56 @@
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { KnownSpellEntry, ResolvedClass } from "./pc.types.js";
+import type { CasterType } from "@archivist-gg/dnd5e/class/class.types";
+export interface SpellcastingProfile {
+    ability: Ability;
+    casterType: CasterType;
+    preparation: "known" | "prepared";
+    spellList: string;
+    table: Record<number, {
+        columns?: Record<string, string | number>;
+    }>;
+}
+/**
+ * Data-driven spellcasting profile for a resolved class. Reads the subclass
+ * block if the subclass grants casting (e.g. Architect of Ruin), else the class
+ * block. Known/cantrip columns come from whichever entity grants casting
+ * (subclass table preferred, falling back to the class table). Returns null for
+ * non-casters. No hardcoded class knowledge — everything comes from the data.
+ */
+export declare function resolveSpellcasting(rc: ResolvedClass): SpellcastingProfile | null;
+export interface NormalizedKnownSpell {
+    slug: string;
+    classSlug: string | null;
+    source: "class" | "feat" | "item" | "race" | "domain";
+    preparedFlag: boolean | undefined;
+    alwaysPrepared: boolean;
+}
+export declare function normalizeKnownSpell(entry: KnownSpellEntry): NormalizedKnownSpell;
+export interface CasterClassInput {
+    casterType: CasterType;
+    level: number;
+}
+export interface DerivedSpellSlots {
+    /** spell level (1..9) → total slots. Levels with 0 slots are omitted. */
+    standard: Record<number, number>;
+    /** Warlock Pact Magic, or null. */
+    pact: {
+        level: number;
+        total: number;
+    } | null;
+}
+export declare function deriveSpellSlots(classes: CasterClassInput[]): DerivedSpellSlots;
+export interface LimitClassInput {
+    classSlug: string;
+    level: number;
+    profile: SpellcastingProfile;
+    /** Ability score for this class's spellcasting ability. */
+    abilityScore: number;
+}
+export interface SpellLimit {
+    classSlug: string;
+    kind: "known" | "prepared";
+    cantripsKnown: number | null;
+    preparedOrKnown: number | null;
+}
+export declare function computeSpellLimits(inputs: LimitClassInput[]): SpellLimit[];

package/dist/pc/pc.spellcasting.js

@@ -0,0 +1,16 @@
+import {
+  computeSpellLimits,
+  deriveSpellSlots,
+  normalizeKnownSpell,
+  resolveSpellcasting
+} from "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-J2RYSZMQ.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  computeSpellLimits,
+  deriveSpellSlots,
+  normalizeKnownSpell,
+  resolveSpellcasting
+};

package/dist/pc/pc.table-column.d.ts

@@ -0,0 +1,12 @@
+/** Read a numeric value from a (sub)class table column at a given level, trying
+ *  each candidate key in order. Returns null when absent or non-numeric. Shared
+ *  by spellcasting (Cantrips/Spells Known) and the pool engine (pick counts). */
+export declare function readTableColumn(table: Record<number, {
+    columns?: Record<string, string | number>;
+}> | undefined, level: number, keys: string[]): number | null;
+/** All numeric columns of a (sub)class table row at `level`, keyed by column
+ *  name. Non-numeric / missing cells are omitted. Backs `column('Name')` in the
+ *  resource max-formula DSL. */
+export declare function numericColumnsAt(table: Record<number, {
+    columns?: Record<string, string | number>;
+}> | undefined, level: number): Record<string, number>;

package/dist/pc/pc.table-column.js

@@ -0,0 +1,8 @@
+import {
+  numericColumnsAt,
+  readTableColumn
+} from "../chunk-5XUXXAQJ.js";
+export {
+  numericColumnsAt,
+  readTableColumn
+};