@archivist-gg/dnd5e 0.1.0

package/dist/spell/spell.scaling.js

@@ -0,0 +1,28 @@
+// src/spell/spell.scaling.ts
+function spellScales(spell) {
+  var _a, _b, _c, _d;
+  return ((_b = (_a = spell.casting_options) == null ? void 0 : _a.length) != null ? _b : 0) > 0 || ((_d = (_c = spell.at_higher_levels) == null ? void 0 : _c.length) != null ? _d : 0) > 0;
+}
+function spellEffectAtSlot(spell, slotLevel) {
+  var _a, _b;
+  const opt = ((_a = spell.casting_options) != null ? _a : []).find((o) => o.type === `slot_level_${slotLevel}`);
+  if (!opt) return null;
+  if (opt.damage_roll) return opt.damage_roll;
+  if (typeof opt.target_count === "number") {
+    if (opt.target_count === slotLevel) return null;
+    return `${opt.target_count} targets`;
+  }
+  if (opt.duration) return opt.duration;
+  return (_b = opt.desc) != null ? _b : null;
+}
+function upcastLevelsFor(spell, ownedSlotLevels) {
+  var _a;
+  const base = (_a = spell.level) != null ? _a : 0;
+  if (base < 1 || !spellScales(spell)) return [];
+  return ownedSlotLevels.filter((l) => l > base).sort((a, b) => a - b);
+}
+export {
+  spellEffectAtSlot,
+  spellScales,
+  upcastLevelsFor
+};

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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const spellEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    level: z.ZodOptional<z.ZodNumber>;
+    school: z.ZodOptional<z.ZodString>;
+    casting_time: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodString>;
+    components: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodString>;
+    concentration: z.ZodOptional<z.ZodBoolean>;
+    ritual: z.ZodOptional<z.ZodBoolean>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    at_higher_levels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage: z.ZodOptional<z.ZodObject<{
+        types: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    saving_throw: z.ZodOptional<z.ZodObject<{
+        ability: z.ZodString;
+    }, z.core.$strip>>;
+    casting_options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        damage_roll: z.ZodOptional<z.ZodString>;
+        target_count: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodNumber>;
+        concentration: z.ZodOptional<z.ZodBoolean>;
+        shape_size: z.ZodOptional<z.ZodNumber>;
+        desc: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;

package/dist/spell/spell.schema.js

@@ -0,0 +1,6 @@
+import {
+  spellEntitySchema
+} from "../chunk-Y4I74YEG.js";
+export {
+  spellEntitySchema
+};

package/dist/spell/spell.types.d.ts

@@ -0,0 +1,25 @@
+import type { CastingOption } from "@archivist-gg/dnd5e/types/casting-option";
+export type { CastingOption };
+export interface Spell {
+    name: string;
+    level?: number;
+    school?: string;
+    casting_time?: string;
+    range?: string;
+    components?: string;
+    duration?: string;
+    concentration?: boolean;
+    ritual?: boolean;
+    classes?: string[];
+    description?: string;
+    at_higher_levels?: string[];
+    damage?: {
+        types: string[];
+    };
+    saving_throw?: {
+        ability: string;
+    };
+    casting_options?: CastingOption[];
+    source?: string;
+    edition?: "2014" | "2024" | string;
+}

package/dist/srd-store.d.ts

@@ -0,0 +1,53 @@
+export interface SrdEntity {
+    slug: string;
+    name: string;
+    entityType: string;
+    data: Record<string, unknown>;
+}
+export type SrdEntityType = "monster" | "spell" | "item" | "armor" | "weapon" | "feat" | "condition" | "class" | "subclass" | "background" | "race" | "optional-feature";
+export type SrdDataSources = Record<string, Record<string, unknown>[]>;
+export declare class SrdStore {
+    /** slug -> SrdEntity for O(1) lookup */
+    private bySlug;
+    /** entityType -> SrdEntity[] for type-scoped operations */
+    private byType;
+    /**
+     * Load entities from a map of source-key -> raw JSON arrays.
+     * Source keys are resolved through TYPE_MAP (e.g. "monster" -> "monster",
+     * "magicitems" -> "item"). If a key is not in TYPE_MAP it is used as-is.
+     */
+    loadFromData(sources: SrdDataSources): void;
+    /**
+     * Load all bundled SRD JSON files from the canonical pipeline runtime.
+     * Both 2014 and 2024 editions are merged into a single store; entities are
+     * disambiguated by their edition-prefixed slugs (e.g. "srd-5e_aboleth" vs
+     * "srd-2024_aboleth").
+     */
+    loadFromBundledJson(): void;
+    /**
+     * O(1) lookup by slug.
+     */
+    getBySlug(slug: string): SrdEntity | undefined;
+    /**
+     * Ranked search: exact match > starts-with > contains.
+     * Case-insensitive. Optionally filtered by entityType.
+     */
+    search(query: string, entityType?: string, limit?: number): SrdEntity[];
+    /**
+     * Return all entities of a given type.
+     */
+    getAllOfType(entityType: string): SrdEntity[];
+    /**
+     * Return all registered entity type strings.
+     */
+    getTypes(): string[];
+    /**
+     * Total number of entities across all types.
+     */
+    count(): number;
+    /**
+     * @deprecated Use getBySlug() instead. Kept for backward compatibility.
+     * Exact name match (case-insensitive). Searches all types or a specific type.
+     */
+    getByName(name: string, entityType?: string): SrdEntity | null;
+}

package/dist/subclass/subclass.codec.d.ts

@@ -0,0 +1,11 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { SubclassEntity } from "./subclass.types.js";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseSubclass`, which validates
+ * against `subclassEntitySchema`. `subclass.types` is this entity's dnd5e home for
+ * `SubclassEntity` (consumed by the PC resolver/types); its `Edition`/`SpellcastingConfig`
+ * imports resolve dnd5e-internally from `class.types`. `serialize` stays `yaml.dump`
+ * (the edit-save path uses obsidian's separate serializer; gate (d) verifies `yaml.dump`
+ * round-trips through `parseSubclass`).
+ */
+export declare const subclassCodec: DocCodec<SubclassEntity>;

package/dist/subclass/subclass.codec.js

@@ -0,0 +1,14 @@
+import {
+  subclassCodec
+} from "../chunk-SSXBYF3P.js";
+import "../chunk-PMADYMUI.js";
+import "../chunk-B7UXKNLD.js";
+import "../chunk-4TIJKN6O.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  subclassCodec
+};

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

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

package/dist/subclass/subclass.parser.d.ts

@@ -0,0 +1,3 @@
+import type { SubclassEntity } from "./subclass.types.js";
+import { ParseResult } from "@archivist-gg/core";
+export declare function parseSubclass(source: string): ParseResult<SubclassEntity>;

package/dist/subclass/subclass.parser.js

@@ -0,0 +1,13 @@
+import {
+  parseSubclass
+} from "../chunk-PMADYMUI.js";
+import "../chunk-B7UXKNLD.js";
+import "../chunk-4TIJKN6O.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  parseSubclass
+};

package/dist/subclass/subclass.schema.d.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+export declare const subclassEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    parent_class: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    description: z.ZodString;
+    spellcasting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        caster_type: z.ZodEnum<{
+            pact: "pact";
+            full: "full";
+            half: "half";
+            third: "third";
+        }>;
+        ability: z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>;
+        preparation: z.ZodEnum<{
+            known: "known";
+            prepared: "prepared";
+        }>;
+        spell_list: z.ZodString;
+    }, z.core.$strip>>>;
+    table: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strip>>>;
+    features_by_level: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    resources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        max_formula: z.ZodString;
+        scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            max: z.ZodString;
+        }, z.core.$strict>>>;
+        die: z.ZodOptional<z.ZodObject<{
+            base: z.ZodString;
+            scaling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        reset: z.ZodEnum<{
+            "short-rest": "short-rest";
+            "long-rest": "long-rest";
+            dawn: "dawn";
+            dusk: "dusk";
+            turn: "turn";
+            round: "round";
+            custom: "custom";
+        }>;
+        consumes: z.ZodOptional<z.ZodObject<{
+            resource: z.ZodString;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>;
+        recovery: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            amount: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            action: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                "bonus-action": "bonus-action";
+                reaction: "reaction";
+                free: "free";
+                special: "special";
+            }>>;
+            uses: z.ZodOptional<z.ZodNumber>;
+            reset: z.ZodEnum<{
+                "short-rest": "short-rest";
+                "long-rest": "long-rest";
+                dawn: "dawn";
+                dusk: "dusk";
+                turn: "turn";
+                round: "round";
+                custom: "custom";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    selection_pools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        source: z.ZodObject<{
+            entity_type: z.ZodLiteral<"optional-feature">;
+            where: z.ZodObject<{
+                feature_type: z.ZodString;
+                available_to: z.ZodLiteral<"self">;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        count: z.ZodObject<{
+            column: z.ZodString;
+        }, z.core.$strip>;
+        replaceable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    pool_grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pool: z.ZodString;
+        grants: z.ZodArray<z.ZodObject<{
+            feature: z.ZodString;
+            at_level: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    tabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        renders: z.ZodObject<{
+            pool: z.ZodString;
+            layout: z.ZodOptional<z.ZodEnum<{
+                "spell-like": "spell-like";
+                blocks: "blocks";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;

package/dist/subclass/subclass.schema.js

@@ -0,0 +1,12 @@
+import {
+  subclassEntitySchema
+} from "../chunk-B7UXKNLD.js";
+import "../chunk-4TIJKN6O.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  subclassEntitySchema
+};

package/dist/subclass/subclass.types.d.ts

@@ -0,0 +1,20 @@
+import type { Feature, Resource } from "@archivist-gg/dnd5e";
+import type { Edition, SpellcastingConfig } from "@archivist-gg/dnd5e/class/class.types";
+import type { SelectionPool, PoolGrant, TabDecl } from "@archivist-gg/dnd5e/types/selection-pool";
+export interface SubclassEntity {
+    slug: string;
+    name: string;
+    parent_class: string;
+    edition: Edition;
+    source: string;
+    description: string;
+    spellcasting?: SpellcastingConfig | null;
+    table?: Record<number, {
+        columns?: Record<string, string | number>;
+    }>;
+    features_by_level: Record<number, Feature[]>;
+    resources: Resource[];
+    selection_pools?: SelectionPool[];
+    pool_grants?: PoolGrant[];
+    tabs?: TabDecl[];
+}

package/dist/types/abilities.d.ts

@@ -0,0 +1,8 @@
+export interface Abilities {
+    str: number;
+    dex: number;
+    con: number;
+    int: number;
+    wis: number;
+    cha: number;
+}

package/dist/types/ac.d.ts

@@ -0,0 +1,5 @@
+export interface AC {
+    ac: number;
+    from?: string[];
+    condition?: string;
+}

package/dist/types/attack.d.ts

@@ -0,0 +1,22 @@
+import type { Ability } from "./choice.js";
+export interface AttackRange {
+    normal?: number;
+    long?: number;
+    reach?: number;
+}
+export interface Attack {
+    name: string;
+    type: "melee" | "ranged" | "spell";
+    ability?: Ability[] | Ability;
+    bonus?: number;
+    damage?: string;
+    damage_type?: string;
+    extra_damage?: {
+        dice: string;
+        type: string;
+    };
+    action?: "action" | "bonus-action" | "reaction";
+    properties?: string[];
+    range?: AttackRange;
+    condition?: string;
+}

package/dist/types/casting-option.d.ts

@@ -0,0 +1,14 @@
+/** A single alternate casting mode for a spell (e.g. a different shape, range,
+ *  or scaling). Lives in dnd5e so the build-time SRD spell merger can consume
+ *  it without a tools→obsidian reverse edge; obsidian `spell.types` re-exports
+ *  it for the renderer/parser. */
+export interface CastingOption {
+    type: string;
+    damage_roll?: string;
+    target_count?: number;
+    duration?: string;
+    range?: number;
+    concentration?: boolean;
+    shape_size?: number;
+    desc?: string;
+}

package/dist/types/choice.d.ts

@@ -0,0 +1,66 @@
+import type { Abilities } from "./abilities.js";
+import type { FeatureEffect } from "./feature-effect.js";
+export type Ability = keyof Abilities;
+export type SkillSlug = "acrobatics" | "animal-handling" | "arcana" | "athletics" | "deception" | "history" | "insight" | "intimidation" | "investigation" | "medicine" | "nature" | "perception" | "performance" | "persuasion" | "religion" | "sleight-of-hand" | "stealth" | "survival";
+export declare const ALL_SKILL_SLUGS: SkillSlug[];
+export type FeatCategory = "origin" | "general" | "fighting-style" | "epic-boon";
+/** Closed, enumerated registry filter — YAML can never express a query the
+ *  engine would apply unsafely. `"self"` resolves against the owning
+ *  class/subclass at ledger-build time. */
+export interface EntityFilter {
+    feature_type?: string;
+    category?: string;
+    parent_class?: "self";
+    available_to?: "self";
+    /** Weapon proficiency class. Matched against a weapon entity's compound
+     *  `category` (e.g. "martial-melee") by prefix, so "martial" covers both
+     *  martial-melee and martial-ranged. */
+    weapon_category?: "simple" | "martial";
+    /** Armor proficiency class. Matched against an armor entity's `category`
+     *  field exactly; "shield" selects shields. */
+    armor_category?: "light" | "medium" | "heavy" | "shield";
+}
+export interface InlineOption {
+    value: string;
+    label: string;
+    description?: string;
+    /** Applied via a synthesized resolved feature when the option is selected. */
+    effects?: FeatureEffect[];
+    /** Nested decisions revealed when this option is selected (recursive). */
+    choices?: Choice[];
+}
+/** The four game-agnostic decision primitives. All game knowledge (which
+ *  options, which counts) lives in data — authored in the SRD overlay or
+ *  inline in homebrew entity notes. `id` is the persistence key under
+ *  `ClassEntry.choices[level]` / `Character.origin_choices`. */
+export type Choice = {
+    kind: "select-inline";
+    id: string;
+    label?: string;
+    count?: number;
+    options: InlineOption[];
+} | {
+    kind: "select-entity";
+    id: string;
+    label?: string;
+    count?: number;
+    entity_type: string;
+    from?: string[];
+    where?: EntityFilter;
+} | {
+    kind: "select-proficiency";
+    id: string;
+    label?: string;
+    count: number;
+    domain: "skill" | "tool" | "language" | "save";
+    from?: string[];
+    from_proficient?: boolean;
+    expertise?: boolean;
+} | {
+    kind: "ability-points";
+    id: string;
+    label?: string;
+    points: number;
+    max_per: number;
+    pool?: Ability[];
+};

package/dist/types/choice.js

@@ -0,0 +1,6 @@
+import {
+  ALL_SKILL_SLUGS
+} from "../chunk-BH6AMZVY.js";
+export {
+  ALL_SKILL_SLUGS
+};

package/dist/types/edition.d.ts

@@ -0,0 +1,4 @@
+/** The two D&D 5e rules editions Archivist canonicalizes content for.
+ *  Single source of truth — obsidian `class.types` and the dnd5e entity
+ *  types both import it from here. */
+export type Edition = "2014" | "2024";

package/dist/types/equipment-grant.d.ts

@@ -0,0 +1,41 @@
+/** One thing a starting-equipment option grants. `item` is a BARE compendium
+ *  slug (e.g. "chain-mail"); the seeder resolves it to the full edition slug.
+ *  `category` is a player-picked class of item ("martial-weapon",
+ *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield", …) resolved
+ *  by a nested select-entity. `gold` is gp folded into the bundle. */
+export type EquipmentGrant = {
+    item: string;
+    qty?: number;
+} | {
+    category: string;
+    qty?: number;
+} | {
+    gold: number;
+};
+/** One selectable option of a `kind:"choice"` starting-equipment entry. `label`
+ *  is the human display string (the `.pc-cb-eqopt` text); `grants` is what seeds. */
+export interface EquipmentOption {
+    label: string;
+    grants: EquipmentGrant[];
+}
+/** Structured starting equipment. Shared by class + background. A `fixed` entry
+ *  may carry a `label` for the un-parsed (prose fallback) case where `grants`
+ *  is empty — it then displays but seeds nothing (graceful degradation). */
+export type StartingEquipmentEntry = {
+    kind: "choice";
+    options: EquipmentOption[];
+} | {
+    kind: "fixed";
+    label?: string;
+    grants: EquipmentGrant[];
+} | {
+    kind: "gold";
+    amount: number;
+};
+/** Buy-with-Gold budget. `fixed` gp (2024) or a `dice`×`multiplier` roll (2014
+ *  "XdY × 10"); average is derived by the consumer. */
+export interface StartingGold {
+    fixed?: number;
+    dice?: string;
+    multiplier?: number;
+}

package/dist/types/feature-effect.d.ts

@@ -0,0 +1,79 @@
+import type { Ability } from "./choice.js";
+export type SenseType = "darkvision" | "blindsight" | "tremorsense" | "truesight";
+export type FeatureEffect = {
+    kind: "initiative-bonus";
+    value: number;
+} | {
+    kind: "immune-condition";
+    condition: string;
+    while?: string;
+} | {
+    kind: "resistance";
+    damage_type: string;
+} | {
+    kind: "hp-per-level-bonus";
+    value: number;
+} | {
+    kind: "speed-bonus";
+    mode: "walk" | "fly" | "swim" | "climb" | "burrow";
+    value: number;
+    set?: boolean;
+} | {
+    kind: "sense";
+    type: SenseType;
+    range: number;
+} | {
+    kind: "apply-condition";
+    condition: string;
+    duration?: string;
+    ends_on?: string[];
+    save_repeat?: {
+        ability: string;
+        timing: string;
+    };
+} | {
+    kind: "damage-bonus";
+    damage_type: string;
+    amount: string;
+    applies_to?: "weapon" | "spell" | "all";
+    condition?: string;
+} | {
+    kind: "proficiency";
+    proficiency_type: "skill" | "tool" | "language" | "saving-throw" | "armor" | "weapon";
+    value: string;
+} | {
+    kind: "ac-bonus";
+    value: number;
+    requires_armor?: boolean;
+} | {
+    kind: "unarmored-ac";
+    abilities: Ability[];
+    base?: number;
+    allow_shield?: boolean;
+} | {
+    kind: "weapon-ability";
+    ability: Ability | "spellcasting";
+    weapons?: string | string[];
+} | {
+    kind: "roll-modifier";
+    mode: "advantage" | "disadvantage";
+    roll: "ability-check" | "saving-throw" | "attack";
+    scope?: string;
+    condition?: string;
+} | {
+    kind: "crit-range";
+    min_roll: number;
+    applies_to?: "weapon" | "spell" | "all";
+    condition?: string;
+} | {
+    kind: "extra-attack";
+    count: number;
+} | {
+    kind: "reroll-damage";
+    max_reroll: number;
+    applies_to?: "weapon" | "spell" | "all";
+    once_per_die?: boolean;
+} | {
+    kind: "attack-rule";
+    flag: "no-ranged-in-melee-disadvantage";
+};