@archivist-gg/dnd5e 0.3.17 → 0.3.24

package/dist/chunk-2JSQE3DD.js

@@ -1,206 +0,0 @@
-// src/schemas/feature-effect-schema.ts
-import { z } from "zod";
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var subjectField = z.string().min(1).optional();
-var conditionField = z.string().optional();
-var weaponScopeEnum = z.enum(["weapon", "melee", "ranged", "unarmed", "finesse", "thrown"]);
-var featureEffectSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("initiative-bonus"), value: z.number().int(), condition: conditionField, subject: subjectField }),
-  z.object({ kind: z.literal("skill-bonus"), skills: z.array(z.string().min(1)).nonempty(), ability: abilityEnum, minimum: z.number().int().optional(), condition: conditionField, subject: subjectField }),
-  // SL (2026-09-27): the `skill-bonus` twin for saving throws (Aura of Protection). `saves` absent = every save; `inactive_while` turns
-  // the bonus off while the character is incapacitated (any condition that disables actions) or unconscious.
-  z.object({
-    kind: z.literal("save-bonus"),
-    ability: abilityEnum,
-    minimum: z.number().int().optional(),
-    saves: z.array(abilityEnum).nonempty().optional(),
-    inactive_while: z.enum(["incapacitated", "unconscious"]).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  // Jack of All Trades / Remarkable Athlete: half the proficiency bonus, and ONLY on a skill the character is
-  // not already proficient in — the "doesn't otherwise use your Proficiency Bonus" clause is the whole mechanic,
-  // so it is the kind's semantics, not a field. `skills` omitted = every skill (Jack of All Trades); a list
-  // narrows it (Remarkable Athlete). `round` is authored because the two printed features disagree: Jack of All
-  // Trades rounds down, Remarkable Athlete rounds up.
-  z.object({ kind: z.literal("half-proficiency"), skills: z.array(z.string().min(1)).nonempty().optional(), round: z.enum(["down", "up"]).optional(), condition: conditionField, subject: subjectField }),
-  // `condition` here is the condition NAME (frightened, poisoned); the qualifier is `while`.
-  z.object({ kind: z.literal("immune-condition"), condition: z.string().min(1), while: z.string().optional(), subject: subjectField }),
-  z.object({ kind: z.literal("resistance"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
-  z.object({ kind: z.literal("hp-per-level-bonus"), value: z.number().int(), condition: conditionField, subject: subjectField }),
-  z.object({
-    kind: z.literal("speed-bonus"),
-    mode: z.enum(["walk", "fly", "swim", "climb", "burrow"]),
-    value: z.number().int(),
-    // when true, value is an absolute floor (Math.max), not additive; currently
-    // only surfaced for mode:"walk" · other modes have no derived speed yet.
-    set: z.boolean().optional(),
-    // R4-G7 §7.3: the WHOLE progression lives inside the effect, because the overlay's `class_features`
-    // map is keyed `<class>:<feature-slug>` with no level component and, after §7.1's fold, the sheet
-    // reads exactly ONE copy of a repeated feature. The engine takes the highest entry at or below the
-    // effect's OWN source level (`levelFor`), and applies it to the additive bonus and to a `set` floor
-    // alike. The Monk's Unarmored Movement is the shipped carrier shape.
-    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), value: z.number().int() })).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    // The attunement CAP, as data. `value` is an absolute cap ("you can now attune to up to four"),
-    // never an increment, so two grants MAX rather than sum and a grant can never lower the cap:
-    // recalc folds it as Math.max(3, granted). `scales_at` carries a whole progression on ONE effect —
-    // the `speed-bonus` / `extra-attack` shape (R4-G7 §7.3) — because the overlay has no level axis and
-    // the Artificer's three steps (10 -> 4, 14 -> 5, 18 -> 6) would otherwise need three separate
-    // features, one of which is embedded prose inside another feature's description.
-    kind: z.literal("attunement-limit"),
-    value: z.number().int().positive(),
-    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), value: z.number().int().positive() })).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("sense"),
-    type: z.enum(["darkvision", "blindsight", "tremorsense", "truesight"]),
-    range: z.number().int().nonnegative(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  // `condition` here is the condition NAME being applied.
-  z.object({
-    kind: z.literal("apply-condition"),
-    condition: z.string().min(1),
-    duration: z.string().optional(),
-    ends_on: z.array(z.string()).optional(),
-    save_repeat: z.object({ ability: z.string().min(1), timing: z.string().min(1) }).optional(),
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("damage-bonus"),
-    // intentionally an open string, NOT a damage-type enum: must accept the
-    // literal "chosen" (player-selected damage type at action time) alongside
-    // canonical damage types. Do not tighten to an enum.
-    damage_type: z.string().min(1),
-    amount: z.string().min(1),
-    // ART-c1 Task 9b: `spell` and `all` as before, or a weapon scope, one word or an any-of list, which the engine
-    // evaluates per attack row (pc.recalc.ts `riderReachesRow`). `weapon`, like an absent value, reaches every row.
-    applies_to: z.union([z.enum(["spell", "all"]), weaponScopeEnum, z.array(weaponScopeEnum).min(1)]).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("proficiency"),
-    proficiency_type: z.enum(["skill", "tool", "language", "saving-throw", "armor", "weapon"]),
-    value: z.string().min(1),
-    expertise: z.boolean().optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({ kind: z.literal("ac-bonus"), value: z.number().int(), requires_armor: z.boolean().optional(), condition: conditionField, subject: subjectField }),
-  z.object({
-    kind: z.literal("unarmored-ac"),
-    abilities: z.array(abilityEnum),
-    base: z.number().int().optional(),
-    allow_shield: z.boolean().optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("unarmed-strike"),
-    // R4-G7 §7.2: a bare die expression, `<count>d<faces>`. `resolveUnarmedStrike` averages the flat arm with
-    // /^(\d+)d(\d+)$/ and silently averages anything else as 1, so a modifier tail ("1d6+1") or a missing
-    // half ("d6", "1d") must refuse here rather than mis-average there. The `i` arm keeps an authored `1D6`.
-    dice: z.union([z.string().regex(/^\d+d\d+$/i), z.object({ column: z.string().min(1) })]).optional(),
-    abilities: z.array(abilityEnum).nonempty().optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("weapon-ability"),
-    ability: z.union([abilityEnum, z.literal("spellcasting")]),
-    weapons: z.union([z.literal("chosen"), z.string(), z.array(z.string())]).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("roll-modifier"),
-    mode: z.enum(["advantage", "disadvantage", "reroll", "add-d4"]),
-    roll: z.enum(["ability-check", "saving-throw", "attack", "any"]),
-    scope: z.string().optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("extra-attack"),
-    // `count` is EXTRA attacks, never total attacks: the engine renders `1 + count`.
-    count: z.number().int().positive(),
-    // R4-G7 §7.3, the `speed-bonus` twin: the SRD 5e Fighter's one Extra Attack feature carries its whole
-    // 5 / 11 / 20 progression here, because `bucketFeaturesByLevel` emits one overlay record into every
-    // `gained_at` bucket and a per-copy count cannot be authored.
-    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), count: z.number().int().positive() })).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("crit-range"),
-    min_roll: z.number().int().min(2).max(20),
-    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({
-    kind: z.literal("reroll-damage"),
-    max_reroll: z.number().int().positive(),
-    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
-    once_per_die: z.boolean().optional(),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  z.object({ kind: z.literal("attack-rule"), flag: z.enum(["no-ranged-in-melee-disadvantage"]), condition: conditionField, subject: subjectField }),
-  // R4-G1a declared these seven converter-emitted arms with the engine folding NOTHING for them
-  // (spec D3). R4-G3a §3-§7 gives SIX of them semantics: immunity / vulnerability FOLD (defenses
-  // pane); temp-hp / heal / extra-action are still NOT folded, the plugin reads them raw as
-  // row-local captions; save-outcome FOLDS (save-chip tag rail).
-  // `ability-score-increase` folds FLAT at the fold since R4-G3b §4 (fixed-list arms only; `chosen` arms
-  // are the ASI slot's second encoding; `max` is unread by user ruling).
-  // Damage immunity / vulnerability. NOT `immune-condition`, which is condition immunity.
-  z.object({ kind: z.literal("immunity"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
-  z.object({ kind: z.literal("vulnerability"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
-  // `amount` is the open non-empty STRING `damage-bonus.amount` already uses: "2d6", "5", "your Artificer level".
-  z.object({ kind: z.literal("temp-hp"), amount: z.string().min(1), condition: conditionField, subject: subjectField }),
-  z.object({ kind: z.literal("heal"), amount: z.string().min(1), condition: conditionField, subject: subjectField }),
-  z.object({
-    kind: z.literal("ability-score-increase"),
-    // "chosen" follows `weapon-ability.weapons`; the list follows `unarmored-ac.abilities`.
-    abilities: z.union([z.literal("chosen"), z.array(abilityEnum).min(1)]),
-    amount: z.number().int().positive(),
-    // Required-WITH-NULL, never optional: "the prose stated no cap" and "the extractor forgot" must not look alike.
-    choose: z.number().int().positive().nullable(),
-    max: z.number().int().positive().nullable(),
-    condition: conditionField,
-    subject: subjectField
-  }).refine((e) => e.abilities === "chosen" === (e.choose !== null), {
-    path: ["choose"],
-    message: 'choose is required IFF abilities is "chosen": a fixed LIST is its own count'
-  }),
-  // `extra-action` is an additional ACTION on your turn; `extra-attack` is attacks WITHIN the Attack action.
-  z.object({
-    kind: z.literal("extra-action"),
-    count: z.number().int().positive(),
-    action_type: z.enum(["action", "bonus-action", "reaction"]),
-    condition: conditionField,
-    subject: subjectField
-  }),
-  // `save-outcome` remaps the OUTCOME; `roll-modifier` modifies the ROLL.
-  z.object({
-    kind: z.literal("save-outcome"),
-    ability: z.union([abilityEnum, z.literal("any")]),
-    on_success: z.enum(["none", "half", "full"]),
-    on_failure: z.enum(["none", "half", "full"]),
-    applies_to: z.string().nullable(),
-    condition: conditionField,
-    subject: subjectField
-  })
-]);
-
-export {
-  featureEffectSchema
-};

package/dist/chunk-2LULMQTF.js

@@ -1,14 +0,0 @@
-// src/types/equipment-grant.ts
-function isCategoryGrant(g) {
-  return !!g && typeof g === "object" && typeof g.category === "string" && g.category.length > 0;
-}
-var equipmentCategoryKey = (i, j, k) => `equipment-${i}-opt-${j}-cat-${k}`;
-var equipmentCategoryKeys = (grants, i, j) => grants.flatMap((g, k) => isCategoryGrant(g) ? [equipmentCategoryKey(i, j, k)] : []);
-var isStartingEquipmentKey = (key) => key.startsWith("equipment-");
-
-export {
-  isCategoryGrant,
-  equipmentCategoryKey,
-  equipmentCategoryKeys,
-  isStartingEquipmentKey
-};

package/dist/chunk-2UDSN6VW.js

@@ -1,18 +0,0 @@
-import {
-  parseBackground
-} from "./chunk-6EI737IO.js";
-
-// src/background/background.codec.ts
-import yaml from "js-yaml";
-var backgroundCodec = {
-  parse(doc) {
-    return parseBackground(doc.body);
-  },
-  serialize(entity) {
-    return yaml.dump(entity, { lineWidth: -1, sortKeys: false });
-  }
-};
-
-export {
-  backgroundCodec
-};

package/dist/chunk-3LWMFYKS.js

@@ -1,57 +0,0 @@
-import {
-  classifyWeaponRange
-} from "./chunk-YDGMBMYI.js";
-
-// src/pc/pc.weapon-grant.ts
-var PROPERTY_KEY = {
-  "2h": "two_handed",
-  "two-handed": "two_handed",
-  "two handed": "two_handed",
-  h: "heavy",
-  l: "light",
-  f: "finesse",
-  t: "thrown",
-  v: "versatile",
-  r: "reach",
-  a: "ammunition",
-  ld: "loading",
-  s: "special"
-};
-var propertyKey = (word) => {
-  var _a;
-  const w = word.trim().toLowerCase();
-  return (_a = PROPERTY_KEY[w]) != null ? _a : w.replace(/[\s-]+/g, "_");
-};
-var GRANT_RE = new RegExp(
-  "^(?:all\\s+)?(?:(melee|ranged)\\s+)?(simple|martial)(?:\\s+(melee|ranged))?\\s+weapons?\\s+(?:that|which)\\s+(have|has|don'?t\\s+have|do\\s+not\\s+have|doesn'?t\\s+have|does\\s+not\\s+have)\\s+the\\s+(.+?)\\s+propert(?:y|ies)\\.?$",
-  "i"
-);
-function parseQualifiedWeaponGrant(text) {
-  var _a, _b;
-  const m = GRANT_RE.exec(text.replace(/’/g, "'").trim().replace(/\s+/g, " "));
-  if (!m) return null;
-  const range = (_b = (_a = m[1]) != null ? _a : m[3]) == null ? void 0 : _b.toLowerCase();
-  const properties = m[5].split(/\s*,\s*|\s+or\s+|\s+and\s+/i).map((w) => w.trim()).filter(Boolean).map(propertyKey);
-  if (properties.length === 0) return null;
-  return {
-    category: m[2].toLowerCase(),
-    ...range ? { range } : {},
-    properties,
-    without: /n'?t|not/i.test(m[4])
-  };
-}
-function qualifiedGrantCovers(text, weapon) {
-  const g = parseQualifiedWeaponGrant(text);
-  if (!g || typeof weapon.category !== "string") return false;
-  if (!new RegExp(`^${g.category}\\b`).test(weapon.category)) return false;
-  if (g.range) {
-    const melee = classifyWeaponRange(weapon).melee !== null;
-    if (g.range === "melee" !== melee) return false;
-  }
-  const has = g.properties.some((p) => weapon.properties.some((x) => x === p));
-  return g.without ? !has : has;
-}
-
-export {
-  qualifiedGrantCovers
-};

package/dist/chunk-3MGQFFNE.js

@@ -1,110 +0,0 @@
-import {
-  startingEquipmentEntrySchema
-} from "./chunk-IN4M4X7P.js";
-import {
-  choiceSchema
-} from "./chunk-5MXFW4O3.js";
-import {
-  additionalSpellsEntrySchema,
-  imageField
-} from "./chunk-UA5KS2PL.js";
-
-// src/background/background.schema.ts
-import { z } from "zod";
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var editionEnum = z.enum(["2014", "2024"]);
-var skillEnum = z.enum([
-  "acrobatics",
-  "animal-handling",
-  "arcana",
-  "athletics",
-  "deception",
-  "history",
-  "insight",
-  "intimidation",
-  "investigation",
-  "medicine",
-  "nature",
-  "perception",
-  "performance",
-  "persuasion",
-  "religion",
-  "sleight-of-hand",
-  "stealth",
-  "survival"
-]);
-var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
-var toolProfSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("fixed"), items: z.array(z.string()).nonempty() }),
-  z.object({
-    kind: z.literal("choice"),
-    count: z.number().int().positive(),
-    from: z.array(z.string()).nonempty()
-  })
-]);
-var langProfSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("fixed"), languages: z.array(z.string()).nonempty() }),
-  z.object({
-    kind: z.literal("choice"),
-    count: z.number().int().positive(),
-    from: z.union([z.string(), z.array(z.string())])
-  })
-]);
-var suggestedCharSchema = z.object({
-  personality_traits: z.record(z.string(), z.string()).optional(),
-  ideals: z.record(z.string(), z.object({
-    name: z.string().optional(),
-    desc: z.string(),
-    alignment: z.string().optional()
-  })).optional(),
-  bonds: z.record(z.string(), z.string()).optional(),
-  flaws: z.record(z.string(), z.string()).optional()
-});
-var backgroundEntitySchema = z.object({
-  slug: z.string().min(1),
-  name: z.string().min(1),
-  edition: editionEnum,
-  source: z.string().min(1),
-  description: z.string(),
-  skill_proficiencies: z.array(skillEnum),
-  tool_proficiencies: z.array(toolProfSchema),
-  language_proficiencies: z.array(langProfSchema),
-  equipment: z.array(startingEquipmentEntrySchema),
-  feature: z.object({
-    name: z.string().min(1),
-    description: z.string().min(1)
-  }),
-  ability_score_increases: z.object({
-    pool: z.array(abilityEnum).length(3)
-  }).nullable(),
-  origin_feat: z.string().regex(wikilinkRegex).nullable(),
-  suggested_characteristics: suggestedCharSchema.nullable(),
-  choices: z.array(choiceSchema).optional(),
-  rendering_hint: z.string().optional(),
-  // 175
-  has_fluff_images: z.boolean().optional(),
-  // 87
-  tables: z.array(z.object({
-    // 88 tables / 67 docs; key-sets EXACT (finding 6)
-    name: z.string().min(1),
-    dice: z.string().min(1),
-    rows: z.array(z.object({ roll: z.string(), text: z.string() }))
-  })).optional(),
-  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
-  // 15
-  prerequisites: z.array(z.object({
-    // 4 docs; kind CLOSED AT THE EMITTER
-    kind: z.literal("campaign"),
-    slug: z.string().min(1)
-    // (background-mapper.ts pushes
-  })).optional(),
-  //  {kind:"campaign", slug} literally — finding 24)
-  // The one-arm union STAYS (§2.6 adjudication): it is closed by CONSTRUCTION at the converter's
-  // only push site, and a future kind turns into a visible census REFUSAL — the correct loud failure.
-  image: imageField
-});
-
-export {
-  langProfSchema,
-  backgroundEntitySchema
-};

package/dist/chunk-3TM34RSJ.js

@@ -1,23 +0,0 @@
-// 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
-};