@archivist-gg/dnd5e 0.1.0

package/dist/schemas/attack-schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const attackSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        spell: "spell";
+        melee: "melee";
+        ranged: "ranged";
+    }>;
+    ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>, z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>]>>;
+    damage: z.ZodOptional<z.ZodString>;
+    damage_type: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodEnum<{
+        action: "action";
+        "bonus-action": "bonus-action";
+        reaction: "reaction";
+    }>>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    range: z.ZodOptional<z.ZodObject<{
+        normal: z.ZodOptional<z.ZodNumber>;
+        long: z.ZodOptional<z.ZodNumber>;
+        reach: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/schemas/choice-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+import type { Choice } from "../types/choice.js";
+export declare const choiceSchema: z.ZodType<Choice>;
+export type ChoiceInput = z.input<typeof choiceSchema>;
+export type ChoiceOutput = z.output<typeof choiceSchema>;

package/dist/schemas/choice-schema.js

@@ -0,0 +1,7 @@
+import {
+  choiceSchema
+} from "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  choiceSchema
+};

package/dist/schemas/duration-schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+/** A buff/effect duration. Parsed in Phase 2 and rendered as a static label;
+ *  Phase 3's activatable-buff toggle consumes the structured form. */
+export declare const durationSchema: z.ZodUnion<readonly [z.ZodLiteral<"instantaneous">, z.ZodLiteral<"until-dispelled">, z.ZodObject<{
+    amount: z.ZodNumber;
+    unit: z.ZodEnum<{
+        round: "round";
+        minute: "minute";
+        hour: "hour";
+        day: "day";
+    }>;
+}, z.core.$strict>]>;
+export type Duration = z.infer<typeof durationSchema>;

package/dist/schemas/duration-schema.js

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

package/dist/schemas/equipment-grant-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import type { EquipmentGrant, EquipmentOption, StartingEquipmentEntry, StartingGold } from "../types/equipment-grant.js";
+export declare const equipmentGrantSchema: z.ZodType<EquipmentGrant>;
+export declare const equipmentOptionSchema: z.ZodType<EquipmentOption>;
+export declare const startingEquipmentEntrySchema: z.ZodType<StartingEquipmentEntry>;
+export declare const startingGoldSchema: z.ZodType<StartingGold>;

package/dist/schemas/equipment-grant-schema.js

@@ -0,0 +1,12 @@
+import {
+  equipmentGrantSchema,
+  equipmentOptionSchema,
+  startingEquipmentEntrySchema,
+  startingGoldSchema
+} from "../chunk-3DZ74AKK.js";
+export {
+  equipmentGrantSchema,
+  equipmentOptionSchema,
+  startingEquipmentEntrySchema,
+  startingGoldSchema
+};

package/dist/schemas/feature-effect-schema.d.ts

@@ -0,0 +1,131 @@
+import { z } from "zod";
+export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"initiative-bonus">;
+    value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"immune-condition">;
+    condition: z.ZodString;
+    while: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"resistance">;
+    damage_type: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"hp-per-level-bonus">;
+    value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"speed-bonus">;
+    mode: z.ZodEnum<{
+        walk: "walk";
+        fly: "fly";
+        swim: "swim";
+        climb: "climb";
+        burrow: "burrow";
+    }>;
+    value: z.ZodNumber;
+    set: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sense">;
+    type: z.ZodEnum<{
+        darkvision: "darkvision";
+        blindsight: "blindsight";
+        tremorsense: "tremorsense";
+        truesight: "truesight";
+    }>;
+    range: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"apply-condition">;
+    condition: z.ZodString;
+    duration: z.ZodOptional<z.ZodString>;
+    ends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    save_repeat: z.ZodOptional<z.ZodObject<{
+        ability: z.ZodString;
+        timing: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"damage-bonus">;
+    damage_type: z.ZodString;
+    amount: z.ZodString;
+    applies_to: z.ZodOptional<z.ZodEnum<{
+        weapon: "weapon";
+        spell: "spell";
+        all: "all";
+    }>>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"proficiency">;
+    proficiency_type: z.ZodEnum<{
+        weapon: "weapon";
+        skill: "skill";
+        tool: "tool";
+        language: "language";
+        "saving-throw": "saving-throw";
+        armor: "armor";
+    }>;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ac-bonus">;
+    value: z.ZodNumber;
+    requires_armor: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unarmored-ac">;
+    abilities: z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>;
+    base: z.ZodOptional<z.ZodNumber>;
+    allow_shield: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"weapon-ability">;
+    ability: z.ZodUnion<readonly [z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>, z.ZodLiteral<"spellcasting">]>;
+    weapons: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chosen">, z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"roll-modifier">;
+    mode: z.ZodEnum<{
+        advantage: "advantage";
+        disadvantage: "disadvantage";
+    }>;
+    roll: z.ZodEnum<{
+        "saving-throw": "saving-throw";
+        "ability-check": "ability-check";
+        attack: "attack";
+    }>;
+    scope: z.ZodOptional<z.ZodString>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"extra-attack">;
+    count: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"crit-range">;
+    min_roll: z.ZodNumber;
+    applies_to: z.ZodOptional<z.ZodEnum<{
+        weapon: "weapon";
+        spell: "spell";
+        all: "all";
+    }>>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"reroll-damage">;
+    max_reroll: z.ZodNumber;
+    applies_to: z.ZodOptional<z.ZodEnum<{
+        weapon: "weapon";
+        spell: "spell";
+        all: "all";
+    }>>;
+    once_per_die: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"attack-rule">;
+    flag: z.ZodEnum<{
+        "no-ranged-in-melee-disadvantage": "no-ranged-in-melee-disadvantage";
+    }>;
+}, z.core.$strip>], "kind">;

package/dist/schemas/feature-effect-schema.js

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

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const featureSchema: z.ZodType<unknown>;

package/dist/schemas/feature-schema.js

@@ -0,0 +1,10 @@
+import {
+  featureSchema
+} from "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  featureSchema
+};

package/dist/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export { choiceSchema } from "./choice-schema.js";
+export type { ChoiceInput, ChoiceOutput } from "./choice-schema.js";
+export { resourceSchema, resourceConsumptionSchema } from "./resource-schema.js";
+export { attackSchema } from "./attack-schema.js";
+export { featureEffectSchema } from "./feature-effect-schema.js";
+export { featureSchema } from "./feature-schema.js";

package/dist/schemas/resource-schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+declare const resetTriggerEnum: z.ZodEnum<{
+    "short-rest": "short-rest";
+    "long-rest": "long-rest";
+    dawn: "dawn";
+    dusk: "dusk";
+    turn: "turn";
+    round: "round";
+    custom: "custom";
+}>;
+declare const actionCostEnum: z.ZodEnum<{
+    action: "action";
+    "bonus-action": "bonus-action";
+    reaction: "reaction";
+    free: "free";
+    special: "special";
+}>;
+export declare const resourceSchema: 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>;
+export declare const resourceConsumptionSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodEnum<{
+        resource: "resource";
+        "class-column": "class-column";
+        "attack-dice": "attack-dice";
+    }>>;
+    resource: z.ZodOptional<z.ZodString>;
+    column: z.ZodOptional<z.ZodString>;
+    amount: z.ZodNumber;
+    expend_condition: z.ZodOptional<z.ZodEnum<{
+        roll_succeeds: "roll_succeeds";
+        roll_fails: "roll_fails";
+        target_takes_damage: "target_takes_damage";
+        always: "always";
+    }>>;
+    free_uses: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodNumber;
+        reset: z.ZodEnum<{
+            "short-rest": "short-rest";
+            "long-rest": "long-rest";
+            dawn: "dawn";
+            dusk: "dusk";
+            turn: "turn";
+            round: "round";
+            custom: "custom";
+        }>;
+        state_key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export { resetTriggerEnum, actionCostEnum };

package/dist/schemas/resource-schema.js

@@ -0,0 +1,12 @@
+import {
+  actionCostEnum,
+  resetTriggerEnum,
+  resourceConsumptionSchema,
+  resourceSchema
+} from "../chunk-PZOWBI3B.js";
+export {
+  actionCostEnum,
+  resetTriggerEnum,
+  resourceConsumptionSchema,
+  resourceSchema
+};

package/dist/schemas/selection-pool-schema.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const selectionPoolSchema: 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>;
+export declare const poolGrantSchema: z.ZodObject<{
+    pool: z.ZodString;
+    grants: z.ZodArray<z.ZodObject<{
+        feature: z.ZodString;
+        at_level: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const tabDeclSchema: 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>;

package/dist/schemas/selection-pool-schema.js

@@ -0,0 +1,10 @@
+import {
+  poolGrantSchema,
+  selectionPoolSchema,
+  tabDeclSchema
+} from "../chunk-4TIJKN6O.js";
+export {
+  poolGrantSchema,
+  selectionPoolSchema,
+  tabDeclSchema
+};

package/dist/spell/spell.access.d.ts

@@ -0,0 +1,15 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { Spell } from "./spell.types.js";
+export interface SpellCandidate {
+    slug: string;
+    name: string;
+    level: number;
+    entity: Spell;
+}
+/**
+ * Pure spell-picker filter. Enumerates all `spell` entities from the registry
+ * (an empty query returns every spell of the type), drops already-known slugs,
+ * then applies the name search and — unless `showAll` is set — the class/level
+ * gate. Results are sorted by level then name.
+ */
+export declare function classSpellCandidates(registry: EntityRegistry, classSlugs: string[], maxLevel: number, knownSlugs: Set<string>, showAll?: boolean, query?: string): SpellCandidate[];

package/dist/spell/spell.access.js

@@ -0,0 +1,25 @@
+import {
+  baseClassName
+} from "../chunk-J2RYSZMQ.js";
+
+// src/spell/spell.access.ts
+function classSpellCandidates(registry, classSlugs, maxLevel, knownSlugs, showAll = false, query = "") {
+  const all = registry.search(query, "spell", 1e3);
+  const q = query.toLowerCase();
+  const classSet = new Set(classSlugs.map((s) => baseClassName(s)));
+  return all.filter((e) => !knownSlugs.has(e.slug)).map((e) => {
+    var _a;
+    const entity = e.data;
+    return { slug: e.slug, name: e.name, entity, level: (_a = entity.level) != null ? _a : 0 };
+  }).filter((c) => {
+    var _a;
+    if (q && !c.name.toLowerCase().includes(q)) return false;
+    if (showAll) return true;
+    const classes = ((_a = c.entity.classes) != null ? _a : []).map((x) => baseClassName(x));
+    const inClass = classes.some((x) => classSet.has(x));
+    return inClass && c.level <= maxLevel;
+  }).sort((a, b) => a.level - b.level || a.name.localeCompare(b.name));
+}
+export {
+  classSpellCandidates
+};

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const spellInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    level: z.ZodNumber;
+    school: z.ZodEnum<{
+        abjuration: "abjuration";
+        conjuration: "conjuration";
+        divination: "divination";
+        enchantment: "enchantment";
+        evocation: "evocation";
+        illusion: "illusion";
+        necromancy: "necromancy";
+        transmutation: "transmutation";
+    }>;
+    casting_time: z.ZodString;
+    range: z.ZodString;
+    components: z.ZodString;
+    duration: z.ZodString;
+    description: z.ZodArray<z.ZodString>;
+    at_higher_levels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ritual: z.ZodOptional<z.ZodBoolean>;
+    concentration: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/spell/spell.ai-schema.js

@@ -0,0 +1,6 @@
+import {
+  spellInputSchema
+} from "../chunk-656QCX4U.js";
+export {
+  spellInputSchema
+};

package/dist/spell/spell.codec.d.ts

@@ -0,0 +1,3 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { Spell } from "./spell.types.js";
+export declare const spellCodec: DocCodec<Spell>;

package/dist/spell/spell.codec.js

@@ -0,0 +1,8 @@
+import {
+  spellCodec
+} from "../chunk-24GFQU7T.js";
+import "../chunk-N2JE7BWL.js";
+import "../chunk-Y4I74YEG.js";
+export {
+  spellCodec
+};

package/dist/spell/spell.enrichment.d.ts

@@ -0,0 +1,2 @@
+import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
+export declare function enrichSpell(raw: Record<string, unknown>): Spell;

package/dist/spell/spell.enrichment.js

@@ -0,0 +1,9 @@
+import {
+  enrichSpell
+} from "../chunk-GZ46OVGZ.js";
+import "../chunk-RAWJTA45.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  enrichSpell
+};

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

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

package/dist/spell/spell.filter.d.ts

@@ -0,0 +1,15 @@
+import type { SpellCandidate } from "./spell.access.js";
+export type CastTimeCat = "action" | "bonus" | "reaction" | "long" | "special";
+export type RangeCat = "self" | "touch" | "ranged" | "special";
+/** Cast-time bucket from the stored token (mirrors compactCastingTime's set).
+ *  Rounds/minutes/hours fold into "long"; null/unknown → "special". */
+export declare function castTimeCategory(token: string | undefined): CastTimeCat;
+/** Range bucket from the human range string. Honest read, documented buckets:
+ *  "Self…"→self, "Touch…"→touch, "<n> feet|ft"→ranged, else (mile/Sight/…)→special. */
+export declare function rangeCategory(range: string | undefined): RangeCat;
+export type SortKey = "name" | "level" | "time" | "school" | "range" | "damage" | "save" | "source";
+export type SortDir = "asc" | "desc";
+export declare function castTimeRank(token: string | undefined): number;
+/** Numeric sort weight for a range string: Self=0, Touch=1, "<n> feet"=n, else large. */
+export declare function rangeSortValue(range: string | undefined): number;
+export declare function compareCandidates(a: SpellCandidate, b: SpellCandidate, key: SortKey, dir: SortDir): number;

package/dist/spell/spell.filter.js

@@ -0,0 +1,87 @@
+// src/spell/spell.filter.ts
+function castTimeCategory(token) {
+  switch (token) {
+    case "action":
+      return "action";
+    case "bonus-action":
+      return "bonus";
+    case "reaction":
+      return "reaction";
+    case "minute":
+    case "1minute":
+    case "10minutes":
+    case "hour":
+    case "1hour":
+    case "8hours":
+    case "12hours":
+    case "24hours":
+      return "long";
+    default:
+      return "special";
+  }
+}
+function rangeCategory(range) {
+  if (!range) return "special";
+  if (/^self/i.test(range)) return "self";
+  if (/^touch/i.test(range)) return "touch";
+  if (/\d+\s*(feet|ft)\b/i.test(range)) return "ranged";
+  return "special";
+}
+var CAST_RANK = { action: 0, bonus: 1, reaction: 2, long: 3, special: 4 };
+function castTimeRank(token) {
+  return CAST_RANK[castTimeCategory(token)];
+}
+function rangeSortValue(range) {
+  if (!range) return 99999;
+  if (/^self/i.test(range)) return 0;
+  if (/^touch/i.test(range)) return 1;
+  const m = range.match(/(\d+)\s*(feet|ft)\b/i);
+  return m ? Number(m[1]) : 99999;
+}
+var EDITION_RANK = { "2014": 0, "2024": 1 };
+function cmpMaybe(a, b) {
+  if (a && b) return a.localeCompare(b);
+  if (a) return -1;
+  if (b) return 1;
+  return 0;
+}
+function compareCandidates(a, b, key, dir) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const mul = dir === "asc" ? 1 : -1;
+  let r = 0;
+  switch (key) {
+    case "name":
+      r = a.name.localeCompare(b.name);
+      break;
+    case "level":
+      r = a.level - b.level;
+      break;
+    case "time":
+      r = castTimeRank(a.entity.casting_time) - castTimeRank(b.entity.casting_time);
+      break;
+    case "school":
+      r = cmpMaybe(a.entity.school, b.entity.school);
+      break;
+    case "range":
+      r = rangeSortValue(a.entity.range) - rangeSortValue(b.entity.range);
+      break;
+    case "damage":
+      r = cmpMaybe((_b = (_a = a.entity.damage) == null ? void 0 : _a.types) == null ? void 0 : _b[0], (_d = (_c = b.entity.damage) == null ? void 0 : _c.types) == null ? void 0 : _d[0]);
+      break;
+    case "save":
+      r = cmpMaybe((_e = a.entity.saving_throw) == null ? void 0 : _e.ability, (_f = b.entity.saving_throw) == null ? void 0 : _f.ability);
+      break;
+    case "source":
+      r = ((_h = EDITION_RANK[(_g = a.entity.edition) != null ? _g : ""]) != null ? _h : 9) - ((_j = EDITION_RANK[(_i = b.entity.edition) != null ? _i : ""]) != null ? _j : 9);
+      break;
+  }
+  if (r === 0 && key !== "name") r = a.name.localeCompare(b.name);
+  return r * mul;
+}
+export {
+  castTimeCategory,
+  castTimeRank,
+  compareCandidates,
+  rangeCategory,
+  rangeSortValue
+};

package/dist/spell/spell.generatable.d.ts

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

package/dist/spell/spell.parser.d.ts

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

package/dist/spell/spell.parser.js

@@ -0,0 +1,7 @@
+import {
+  parseSpell
+} from "../chunk-N2JE7BWL.js";
+import "../chunk-Y4I74YEG.js";
+export {
+  parseSpell
+};

package/dist/spell/spell.scaling.d.ts

@@ -0,0 +1,14 @@
+import type { Spell } from "./spell.types.js";
+/** A spell repeats under higher levels only if it has a real upcast benefit. */
+export declare function spellScales(spell: Spell): boolean;
+/**
+ * At-a-glance scaled effect for casting `spell` with a slot of `slotLevel`,
+ * read from structured `casting_options` (`type: "slot_level_<N>"`). Returns
+ * null when absent or untrustworthy. `damage_roll` is shown as-is; a
+ * `target_count` that equals the slot level is the known SRD-2014 bad encoding
+ * (e.g. Magic Missile 2nd->2 instead of 4) and is suppressed. This errs toward
+ * showing nothing rather than a wrong number.
+ */
+export declare function spellEffectAtSlot(spell: Spell, slotLevel: number): string | null;
+/** Owned slot levels strictly above the spell's base level (scaling spells only). */
+export declare function upcastLevelsFor(spell: Spell, ownedSlotLevels: number[]): number[];