@archivist-gg/dnd5e 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Archivist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSES/SRD.md

@@ -0,0 +1,37 @@
+# SRD Attribution (CC-BY-4.0)
+
+This repository bundles content from the Dungeons & Dragons **System Reference Document**,
+both the 5.1 (2014) and 5.2 (2024) editions, released by Wizards of the Coast under the
+Creative Commons Attribution 4.0 International License (CC-BY-4.0).
+
+## Required attribution
+
+This work includes material from the System Reference Document 5.1 ("SRD 5.1") by Wizards of
+the Coast LLC and available at https://dnd.wizards.com/resources/systems-reference-document.
+The SRD 5.1 is licensed under the Creative Commons Attribution 4.0 International License,
+available at https://creativecommons.org/licenses/by/4.0/legalcode.
+
+This work includes material from the System Reference Document 5.2 ("SRD 5.2") by Wizards of
+the Coast LLC and available at https://www.dndbeyond.com/srd. The SRD 5.2 is licensed under
+the Creative Commons Attribution 4.0 International License, available at
+https://creativecommons.org/licenses/by/4.0/legalcode.
+
+Copyright © Wizards of the Coast LLC. "Dungeons & Dragons" is a trademark of Wizards of the
+Coast. This project is unofficial and not affiliated with or endorsed by Wizards of the Coast.
+
+## Bundled SRD locations
+
+- `src/srd/data/` — canonical structured SRD data (SRD 5.1 + 5.2)
+- `src/data-srd/` — verbatim SRD prose (markdown: classes, species, subclasses, backgrounds, feats)
+- `tools/srd-canonical/` — the SRD converter/build tooling
+
+## Provenance and changes made (CC-BY "indicate if changes were made")
+
+The shipped SRD data is a MERGE, assembled by `tools/srd-canonical/` from: the **Open5e** v2
+API (the immediate redistribution source of the SRD content), a structured-rules dump, and
+supplemental activation data, combined with a hand-curated overlay. Content is transformed
+structurally (reformatted to this project's schema and to Markdown) and normalized; narrative
+prose is preserved. **No non-SRD content is bundled** — every shipped entry's `source` field is
+`SRD 5.1` or `SRD 5.2` (verified: see the repository's SRD-content assertion).
+
+Credit to **Open5e** (https://open5e.com) as the immediate SRD-redistribution source.

package/README.md

@@ -0,0 +1,65 @@
+# @archivist-gg/dnd5e
+
+The D&D 5e (2014 & 2024) rules pack for Archivist: parsers, schemas, codecs, and
+types for every entity type, the dice/formula/tag machinery, the player-character
+engine, and the bundled SRD content. Built on [`@archivist-gg/core`](https://github.com/archivist-gg/archivist-core).
+
+## What's inside
+
+- **Entity types** — armor, background, class, subclass, race, feat,
+  optional-feature, item, weapon, monster, npc, and spell. Each has a parser, a
+  [zod](https://zod.dev) schema, a codec, and TypeScript types, exposed as
+  `@archivist-gg/dnd5e/<entity>/*` subpath exports.
+- **Rules engine** (`dnd/*`) — ability math, proficiency/XP, the formula and
+  inline-tag grammar, resource dice, and SRD tag conversion.
+- **Player characters** (`pc/*`) — parse → resolve → recalc a character into
+  derived stats (AC, saves, skills, attacks, spellcasting, resources, rest), plus
+  the decision engine, equipment/slotting, and conditions.
+- **SRD data** — System Reference Document 5.1 and 5.2 as `.md` sources plus
+  canonical/runtime JSON, loadable through `srd-store`.
+
+Common entry points are re-exported from the package root; everything else is
+available via subpath exports.
+
+## Usage
+
+Distributed as TypeScript source (no build step). It depends on `@archivist-gg/core`
+via a sibling path dependency, so clone both repos side by side:
+
+```
+archivist-core/
+archivist-dnd5e/
+```
+
+```jsonc
+// package.json
+"dependencies": {
+  "@archivist-gg/core": "file:../archivist-core",
+  "@archivist-gg/dnd5e": "file:../archivist-dnd5e"
+}
+```
+
+Running `npm install` in `archivist-dnd5e` then resolves the sibling.
+
+```ts
+import { parseMonster, dnd5ePack } from "@archivist-gg/dnd5e";
+import { parsePC } from "@archivist-gg/dnd5e/pc/pc.parser";
+```
+
+## Scripts
+
+- `npm run typecheck` — type-check the pack and its tools.
+- `npm test` — run the test suite with vitest (regenerates the SRD md-index first).
+- `npm run generate` — regenerate `src/data-srd/index.generated.ts` from the `.md` sources.
+- `npm run build:srd-canonical[:refresh]` — dev tool that rebuilds the canonical SRD
+  JSON from an external 5etools structured-rules dump (`STRUCTURED_RULES_PATH`). Not
+  part of the test gate; the committed `src/srd/data/{canonical,runtime}` JSON is the
+  consumer contract.
+
+## License
+
+- **Code:** MIT — see [LICENSE](./LICENSE).
+- **Bundled SRD data** (`src/srd/data/`, `src/data-srd/`): System Reference Document
+  5.1 and 5.2 by Wizards of the Coast LLC, licensed under
+  [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/legalcode). See
+  [LICENSES/SRD.md](./LICENSES/SRD.md).

package/dist/armor/armor.codec.d.ts

@@ -0,0 +1,10 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { ArmorEntity } from "./armor.types.js";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseArmor`, which validates
+ * against `armorEntitySchema` (injecting the `ac.flat`/`ac.add_con`/`ac.add_wis`
+ * defaults) and captures any unknown top-level keys into `entity.raw`.
+ * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
+ * serializer; gate (d) verifies `yaml.dump` round-trips through `parseArmor`).
+ */
+export declare const armorCodec: DocCodec<ArmorEntity>;

package/dist/armor/armor.codec.js

@@ -0,0 +1,8 @@
+import {
+  armorCodec
+} from "../chunk-ZMR77DDL.js";
+import "../chunk-HCP3GMHS.js";
+import "../chunk-XJNECUPT.js";
+export {
+  armorCodec
+};

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

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

package/dist/armor/armor.parser.d.ts

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

package/dist/armor/armor.parser.js

@@ -0,0 +1,7 @@
+import {
+  parseArmor
+} from "../chunk-HCP3GMHS.js";
+import "../chunk-XJNECUPT.js";
+export {
+  parseArmor
+};

package/dist/armor/armor.schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const armorEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    category: z.ZodString;
+    ac: z.ZodObject<{
+        base: z.ZodNumber;
+        flat: z.ZodDefault<z.ZodNumber>;
+        add_dex: z.ZodDefault<z.ZodBoolean>;
+        dex_max: z.ZodOptional<z.ZodNumber>;
+        add_con: z.ZodDefault<z.ZodBoolean>;
+        add_wis: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    strength_requirement: z.ZodOptional<z.ZodNumber>;
+    stealth_disadvantage: z.ZodOptional<z.ZodBoolean>;
+    weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    cost: z.ZodOptional<z.ZodString>;
+    rarity: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    edition: z.ZodOptional<z.ZodString>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;

package/dist/armor/armor.schema.js

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

package/dist/armor/armor.types.d.ts

@@ -0,0 +1,26 @@
+export type { Ability } from "@archivist-gg/dnd5e/types/choice";
+export type ArmorCategory = "light" | "medium" | "heavy" | "shield" | "natural" | "feature" | "spell" | string;
+export interface ArmorEntity {
+    name: string;
+    slug: string;
+    category: ArmorCategory;
+    ac: {
+        base: number;
+        flat?: number;
+        add_dex: boolean;
+        dex_max?: number;
+        add_con: boolean;
+        add_wis: boolean;
+        description?: string;
+    };
+    strength_requirement?: number;
+    stealth_disadvantage?: boolean;
+    weight?: number | string;
+    cost?: string;
+    rarity?: string;
+    source?: string;
+    page?: number;
+    edition?: "2014" | "2024" | string;
+    entries?: unknown[];
+    raw?: Record<string, unknown>;
+}

package/dist/background/background.codec.d.ts

@@ -0,0 +1,9 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { BackgroundEntity } from "./background.types.js";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseBackground`, which seeds
+ * the `edition: "2014"` default and validates against `backgroundEntitySchema`.
+ * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
+ * serializer; gate (d) verifies `yaml.dump` round-trips through `parseBackground`).
+ */
+export declare const backgroundCodec: DocCodec<BackgroundEntity>;

package/dist/background/background.codec.js

@@ -0,0 +1,11 @@
+import {
+  backgroundCodec
+} from "../chunk-Z4TL2V7S.js";
+import "../chunk-DRNZJNJP.js";
+import "../chunk-A7T5L7SS.js";
+import "../chunk-3DZ74AKK.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  backgroundCodec
+};

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

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

package/dist/background/background.parser.d.ts

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

package/dist/background/background.parser.js

@@ -0,0 +1,10 @@
+import {
+  parseBackground
+} from "../chunk-DRNZJNJP.js";
+import "../chunk-A7T5L7SS.js";
+import "../chunk-3DZ74AKK.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  parseBackground
+};

package/dist/background/background.schema.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const backgroundEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    description: z.ZodString;
+    skill_proficiencies: 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";
+    }>>;
+    tool_proficiencies: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"fixed">;
+        items: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"choice">;
+        count: z.ZodNumber;
+        from: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+    language_proficiencies: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"fixed">;
+        languages: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"choice">;
+        count: z.ZodNumber;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    }, z.core.$strip>], "kind">>;
+    equipment: z.ZodArray<z.ZodType<import("../types/equipment-grant.js").StartingEquipmentEntry, unknown, z.core.$ZodTypeInternals<import("../types/equipment-grant.js").StartingEquipmentEntry, unknown>>>;
+    feature: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>;
+    ability_score_increases: z.ZodNullable<z.ZodObject<{
+        pool: z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>;
+    }, z.core.$strip>>;
+    origin_feat: z.ZodNullable<z.ZodString>;
+    suggested_characteristics: z.ZodNullable<z.ZodObject<{
+        personality_traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        ideals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            desc: z.ZodString;
+            alignment: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        bonds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        flaws: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>>;
+}, z.core.$strip>;

package/dist/background/background.schema.js

@@ -0,0 +1,9 @@
+import {
+  backgroundEntitySchema
+} from "../chunk-A7T5L7SS.js";
+import "../chunk-3DZ74AKK.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  backgroundEntitySchema
+};

package/dist/background/background.types.d.ts

@@ -0,0 +1,52 @@
+import type { Ability, SkillSlug, Choice } from "@archivist-gg/dnd5e";
+import type { Edition } from "@archivist-gg/dnd5e/types/edition";
+import type { Resource } from "@archivist-gg/dnd5e/types/resource";
+import type { StartingEquipmentEntry } from "@archivist-gg/dnd5e/types/equipment-grant";
+export type BackgroundToolProficiency = {
+    kind: "fixed";
+    items: string[];
+} | {
+    kind: "choice";
+    count: number;
+    from: string[];
+};
+export type BackgroundLanguageProficiency = {
+    kind: "fixed";
+    languages: string[];
+} | {
+    kind: "choice";
+    count: number;
+    from: string | string[];
+};
+export interface SuggestedCharacteristics {
+    personality_traits?: Record<string, string>;
+    ideals?: Record<string, {
+        name?: string;
+        desc: string;
+        alignment?: string;
+    }>;
+    bonds?: Record<string, string>;
+    flaws?: Record<string, string>;
+}
+export interface BackgroundEntity {
+    slug: string;
+    name: string;
+    edition: Edition;
+    source: string;
+    description: string;
+    skill_proficiencies: SkillSlug[];
+    tool_proficiencies: BackgroundToolProficiency[];
+    language_proficiencies: BackgroundLanguageProficiency[];
+    equipment: StartingEquipmentEntry[];
+    feature: {
+        name: string;
+        description: string;
+        resources?: Resource[];
+    };
+    ability_score_increases: {
+        pool: Ability[];
+    } | null;
+    origin_feat: string | null;
+    suggested_characteristics: SuggestedCharacteristics | null;
+    choices?: Choice[];
+}

package/dist/chunk-24GFQU7T.js

@@ -0,0 +1,18 @@
+import {
+  parseSpell
+} from "./chunk-N2JE7BWL.js";
+
+// src/spell/spell.codec.ts
+import yaml from "js-yaml";
+var spellCodec = {
+  parse(doc) {
+    return parseSpell(doc.body);
+  },
+  serialize(spell) {
+    return yaml.dump(spell, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  spellCodec
+};

package/dist/chunk-3DZ74AKK.js

@@ -0,0 +1,28 @@
+// src/schemas/equipment-grant-schema.ts
+import { z } from "zod";
+var equipmentGrantSchema = z.union([
+  z.object({ item: z.string().min(1), qty: z.number().int().positive().optional() }).strict(),
+  z.object({ category: z.string().min(1), qty: z.number().int().positive().optional() }).strict(),
+  z.object({ gold: z.number().int().positive() }).strict()
+]);
+var equipmentOptionSchema = z.object({
+  label: z.string().min(1),
+  grants: z.array(equipmentGrantSchema)
+}).strict();
+var startingEquipmentEntrySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("choice"), options: z.array(equipmentOptionSchema).nonempty() }).strict(),
+  z.object({ kind: z.literal("fixed"), label: z.string().min(1).optional(), grants: z.array(equipmentGrantSchema) }).strict(),
+  z.object({ kind: z.literal("gold"), amount: z.number().int().positive() }).strict()
+]);
+var startingGoldSchema = z.object({
+  fixed: z.number().int().nonnegative().optional(),
+  dice: z.string().min(1).optional(),
+  multiplier: z.number().int().positive().optional()
+}).strict();
+
+export {
+  equipmentGrantSchema,
+  equipmentOptionSchema,
+  startingEquipmentEntrySchema,
+  startingGoldSchema
+};

package/dist/chunk-3TM34RSJ.js

@@ -0,0 +1,23 @@
+// src/inline-tag-parser.ts
+var VALID_PREFIXES = ["dice", "damage", "dc", "atk", "mod", "check"];
+var PREFIX_ALIASES = {
+  roll: "dice",
+  d: "dice",
+  attack: "atk",
+  dmg: "damage"
+};
+function parseInlineTag(text) {
+  var _a;
+  const colonIndex = text.indexOf(":");
+  if (colonIndex === -1) return null;
+  const prefix = text.slice(0, colonIndex).trim().toLowerCase();
+  const resolved = (_a = PREFIX_ALIASES[prefix]) != null ? _a : prefix;
+  if (!VALID_PREFIXES.includes(resolved)) return null;
+  const content = text.slice(colonIndex + 1).trim();
+  if (content.length === 0) return null;
+  return { type: resolved, content, formula: null };
+}
+
+export {
+  parseInlineTag
+};

package/dist/chunk-3TRGRSCH.js

@@ -0,0 +1,8 @@
+// src/entities/slug.ts
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/[\s]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+
+export {
+  slugify
+};