@archivist-gg/dnd5e 0.1.0

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

@@ -0,0 +1,67 @@
+import { z } from "zod";
+export declare const monsterInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    size: z.ZodEnum<{
+        Tiny: "Tiny";
+        Small: "Small";
+        Medium: "Medium";
+        Large: "Large";
+        Huge: "Huge";
+        Gargantuan: "Gargantuan";
+    }>;
+    type: z.ZodString;
+    subtype: z.ZodOptional<z.ZodString>;
+    alignment: z.ZodString;
+    cr: z.ZodString;
+    abilities: z.ZodObject<{
+        str: z.ZodNumber;
+        dex: z.ZodNumber;
+        con: z.ZodNumber;
+        int: z.ZodNumber;
+        wis: z.ZodNumber;
+        cha: z.ZodNumber;
+    }, z.core.$strip>;
+    ac: z.ZodArray<z.ZodObject<{
+        ac: z.ZodNumber;
+        from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    hp: z.ZodObject<{
+        average: z.ZodNumber;
+        formula: z.ZodString;
+    }, z.core.$strip>;
+    speed: z.ZodObject<{
+        walk: z.ZodOptional<z.ZodNumber>;
+        fly: z.ZodOptional<z.ZodNumber>;
+        swim: z.ZodOptional<z.ZodNumber>;
+        climb: z.ZodOptional<z.ZodNumber>;
+        burrow: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    saves: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    skills: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    damage_vulnerabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage_resistances: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    damage_immunities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    condition_immunities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    senses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    passive_perception: z.ZodOptional<z.ZodNumber>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    traits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entries: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entries: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entries: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    legendary_actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entries: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    legendary_action_uses: z.ZodOptional<z.ZodNumber>;
+    legendary_resistance: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;

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

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

package/dist/monster/monster.codec.d.ts

@@ -0,0 +1,13 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { Monster } from "./monster.types.js";
+/** Deprecated alias kept for the barrel re-export (`index.ts:7`) + `monster.resolve.ts:2`. */
+export type MonsterRaw = Monster;
+/**
+ * Normalizing codec (0c.1a B8). `parse` delegates to `parseMonster`, which maps
+ * the `legendary` alias and extracts Legendary-Resistance from trait text into the
+ * canonical `legendary_resistance` field. This canonicalization is intended and
+ * persists on save (B3); resolve-derived PB/XP are NOT added here. `serialize` stays
+ * `yaml.dump` (the edit-save path uses obsidian's separate `editableToYaml` — document
+ * that two-serializer split here; gate (d) Step 6 verifies `yaml.dump` round-trips).
+ */
+export declare const monsterCodec: DocCodec<Monster>;

package/dist/monster/monster.enrichment.d.ts

@@ -0,0 +1,10 @@
+import type { Monster } from "./monster.types.js";
+export declare const CR_TO_XP: Record<string, number>;
+export declare function parseCR(cr: string): number;
+export declare function getChallengeRatingXP(cr: string): number;
+export declare function getProficiencyBonus(cr: string): number;
+export declare function enrichMonster(raw: Record<string, unknown>): Monster & {
+    xp?: number;
+    proficiency_bonus?: number;
+};
+export declare function convertMonsterEntries(monster: Monster & Record<string, unknown>, cr: string): void;

package/dist/monster/monster.enrichment.js

@@ -0,0 +1,19 @@
+import {
+  CR_TO_XP,
+  convertMonsterEntries,
+  enrichMonster,
+  getChallengeRatingXP,
+  getProficiencyBonus,
+  parseCR
+} from "../chunk-66XXW2Z2.js";
+import "../chunk-RAWJTA45.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  CR_TO_XP,
+  convertMonsterEntries,
+  enrichMonster,
+  getChallengeRatingXP,
+  getProficiencyBonus,
+  parseCR
+};

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

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

package/dist/monster/monster.generatable.d.ts

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

package/dist/monster/monster.parser.d.ts

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

package/dist/monster/monster.parser.js

@@ -0,0 +1,6 @@
+import {
+  parseMonster
+} from "../chunk-7P65Q426.js";
+export {
+  parseMonster
+};

package/dist/monster/monster.resolve.d.ts

@@ -0,0 +1,10 @@
+import type { ResolveContext } from "@archivist-gg/core";
+import type { MonsterRaw } from "./monster.codec.js";
+/**
+ * Light, non-mutating derivation: computes proficiency bonus and XP from the
+ * monster's challenge rating. Returns a new object; the input `raw` is untouched.
+ */
+export declare function resolveMonster(raw: MonsterRaw, _ctx: ResolveContext): MonsterRaw & {
+    proficiency_bonus: number;
+    xp: number;
+};

package/dist/monster/monster.types.d.ts

@@ -0,0 +1,29 @@
+import type { Abilities, AC, HP, Speed, Feature } from "../types/index.js";
+export interface Monster {
+    name: string;
+    size?: string;
+    type?: string;
+    subtype?: string;
+    alignment?: string;
+    cr?: string;
+    ac?: AC[];
+    hp?: HP;
+    speed?: Speed;
+    abilities?: Abilities;
+    saves?: Partial<Record<string, number>>;
+    skills?: Record<string, number>;
+    senses?: string[];
+    passive_perception?: number;
+    languages?: string[];
+    damage_vulnerabilities?: string[];
+    damage_resistances?: string[];
+    damage_immunities?: string[];
+    condition_immunities?: string[];
+    traits?: Feature[];
+    actions?: Feature[];
+    reactions?: Feature[];
+    legendary_actions?: Feature[];
+    legendary_action_uses?: number;
+    legendary_resistance?: number;
+    columns?: number;
+}

package/dist/monster/monster.types.js

@@ -0,0 +1 @@
+import "../chunk-IKSMX4TN.js";

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const npcInputSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodString>;
+    race: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

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

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

package/dist/npc/npc.generatable.d.ts

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

package/dist/optional-feature/optional-feature.codec.d.ts

@@ -0,0 +1,14 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseOptionalFeature`, which
+ * seeds the `edition: "2014"` default and validates against
+ * `optionalFeatureEntitySchema`. `serialize` stays `yaml.dump` (the edit-save
+ * path uses obsidian's separate serializer; gate (d) verifies `yaml.dump`
+ * round-trips through `parseOptionalFeature`).
+ *
+ * SPECIAL (0c.1a Task 7): the entity type already lives at
+ * `@archivist-gg/dnd5e/types/optional-feature.types` (moved in 0c.0), so the codec
+ * imports it from there rather than a sibling `./optional-feature.types`.
+ */
+export declare const optionalFeatureCodec: DocCodec<OptionalFeatureEntity>;

package/dist/optional-feature/optional-feature.codec.js

@@ -0,0 +1,11 @@
+import {
+  optionalFeatureCodec
+} from "../chunk-RSDRMH54.js";
+import "../chunk-4F6AIZ36.js";
+import "../chunk-MDEJHMKK.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  optionalFeatureCodec
+};

package/dist/optional-feature/optional-feature.entity-type.d.ts

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

package/dist/optional-feature/optional-feature.parser.d.ts

@@ -0,0 +1,3 @@
+import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
+import { ParseResult } from "@archivist-gg/core";
+export declare function parseOptionalFeature(source: string): ParseResult<OptionalFeatureEntity>;

package/dist/optional-feature/optional-feature.parser.js

@@ -0,0 +1,10 @@
+import {
+  parseOptionalFeature
+} from "../chunk-4F6AIZ36.js";
+import "../chunk-MDEJHMKK.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  parseOptionalFeature
+};

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

@@ -0,0 +1,236 @@
+import { z } from "zod";
+export declare const optionalFeatureEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    feature_type: z.ZodString;
+    description: z.ZodString;
+    prerequisites: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"level">;
+        min: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"spell-known">;
+        spell: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"pact">;
+        pact: z.ZodEnum<{
+            tome: "tome";
+            blade: "blade";
+            chain: "chain";
+            talisman: "talisman";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"class">;
+        class: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"ability">;
+        ability: z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>;
+        min: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"other">;
+        detail: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    available_to: z.ZodArray<z.ZodString>;
+    effects: z.ZodArray<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">>;
+    action_cost: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        action: "action";
+        "bonus-action": "bonus-action";
+        reaction: "reaction";
+        free: "free";
+        special: "special";
+    }>>>;
+    uses: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        recharge: z.ZodEnum<{
+            "short-rest": "short-rest";
+            "long-rest": "long-rest";
+            dawn: "dawn";
+            dusk: "dusk";
+            turn: "turn";
+            round: "round";
+            custom: "custom";
+        }>;
+    }, z.core.$strip>>>;
+    consumes: z.ZodOptional<z.ZodNullable<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>>>;
+    duration: z.ZodOptional<z.ZodNullable<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>]>>>;
+    passive: z.ZodOptional<z.ZodBoolean>;
+    activatable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OptionalFeatureSchemaInput = z.input<typeof optionalFeatureEntitySchema>;
+export type OptionalFeatureSchemaOutput = z.output<typeof optionalFeatureEntitySchema>;

package/dist/optional-feature/optional-feature.schema.js

@@ -0,0 +1,9 @@
+import {
+  optionalFeatureEntitySchema
+} from "../chunk-MDEJHMKK.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  optionalFeatureEntitySchema
+};

package/dist/pack.d.ts

@@ -0,0 +1,11 @@
+import type { SystemPack } from "@archivist-gg/core";
+/**
+ * The real `dnd5e` SystemPack. It owns the parse/resolve/generate contract for
+ * D&D 5e entity types via their {@link EntityType} definitions; presentation
+ * (renderer/edit/modal) stays in the obsidian package. It is the only pack the
+ * kernel registers.
+ *
+ * All 11 authored types are ported, plus the two generate-only types (npc and
+ * encounter); a new entity type joins by appending its EntityType here.
+ */
+export declare const dnd5ePack: SystemPack;

package/dist/pc/conditions.constants.d.ts

@@ -0,0 +1,3 @@
+export type ConditionSlug = "blinded" | "charmed" | "deafened" | "frightened" | "grappled" | "incapacitated" | "invisible" | "paralyzed" | "petrified" | "poisoned" | "prone" | "restrained" | "stunned" | "unconscious";
+export declare const CONDITION_SLUGS: readonly ["blinded", "charmed", "deafened", "frightened", "grappled", "incapacitated", "invisible", "paralyzed", "petrified", "poisoned", "prone", "restrained", "stunned", "unconscious"];
+export declare const CONDITION_DISPLAY_NAMES: Record<ConditionSlug, string>;

package/dist/pc/conditions.constants.js

@@ -0,0 +1,8 @@
+import {
+  CONDITION_DISPLAY_NAMES,
+  CONDITION_SLUGS
+} from "../chunk-TZK36BU7.js";
+export {
+  CONDITION_DISPLAY_NAMES,
+  CONDITION_SLUGS
+};

package/dist/pc/decision-recognizer.d.ts

@@ -0,0 +1,4 @@
+import type { Feature } from "@archivist-gg/dnd5e/types/feature";
+import type { Choice } from "@archivist-gg/dnd5e/types/choice";
+export declare const DECISION_SIGNAL: RegExp[];
+export declare function recognizeDecision(feature: Feature): Choice[] | "informational" | null;

package/dist/pc/decision-recognizer.js

@@ -0,0 +1,8 @@
+import {
+  DECISION_SIGNAL,
+  recognizeDecision
+} from "../chunk-JEYQU3JT.js";
+export {
+  DECISION_SIGNAL,
+  recognizeDecision
+};

package/dist/pc/pc.conditions.d.ts

@@ -0,0 +1,3 @@
+import type { CharacterState, Edition, ConditionEffects } from "./pc.types.js";
+import type { Ability } from "@archivist-gg/dnd5e";
+export declare function computeConditionEffects(state: CharacterState, edition: Edition, _scores: Record<Ability, number>): ConditionEffects;

package/dist/pc/pc.conditions.js

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

package/dist/pc/pc.decision-engine.d.ts

@@ -0,0 +1,97 @@
+import type { Choice, EntityFilter, Ability } from "@archivist-gg/dnd5e/types/choice";
+import type { ResolvedCharacter, ChoiceValue, FeatureSource } from "./pc.types.js";
+import type { RegisteredEntity } from "@archivist-gg/core";
+export interface DecisionRegistry {
+    search(query: string, entityType: string, limit: number): RegisteredEntity[];
+    getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
+}
+export interface ResolvedOption {
+    value: string;
+    label: string;
+    entity?: RegisteredEntity;
+    /** The option's own prose (a select-inline InlineOption may supply one — e.g. each
+     *  Combat Mastery describes what it does). Surfaced by the strip near the chips. */
+    description?: string;
+    /** True when a `from` slug has no entity behind it — render visible-but-inert. */
+    missing?: boolean;
+}
+/**
+ * Status contract: over-selection (n > need) reports `resolved` — the engine
+ * never reports an error for too many picks; the picker UI owns cap enforcement.
+ * Likewise for ability-points `max_per`: the engine only sums total points
+ * allocated, so per-ability caps are picker-enforced, not reflected here.
+ */
+export type DecisionStatus = "resolved" | "partial" | "unresolved" | "informational";
+export interface DecisionItem {
+    key: string;
+    source: FeatureSource;
+    level: number;
+    featureName: string;
+    /**
+     * The source feature/trait's own description (race trait, background feature,
+     * class feature) — threaded through from the walk that emits the item so the
+     * decision strip can render it as a quiet markdown block at the top of the
+     * row's nest (smoke r7). Top-level rows only; a child inherits NOTHING from
+     * its parent — it carries the sub-choice option's own `description` (when the
+     * authored InlineOption supplies one) or none.
+     */
+    description?: string;
+    /**
+     * When `status === "informational"` this is a placeholder sentinel and MUST
+     * NOT be rendered — informational items render from `featureName` only
+     * (Task 16 contract). For every other status it is the real choice to render.
+     */
+    choice: Choice;
+    options: ResolvedOption[];
+    selected: ChoiceValue | undefined;
+    status: DecisionStatus;
+    /**
+     * Populated only for the selected branch of a select-inline (the
+     * revealed-on-selection rule): a child decision becomes visible once its
+     * parent option is chosen. An unresolved child downgrades the parent's
+     * status to "partial".
+     */
+    children?: DecisionItem[];
+}
+export interface DecisionLedger {
+    classes: Array<{
+        classIndex: number;
+        levels: Array<{
+            level: number;
+            items: DecisionItem[];
+        }>;
+    }>;
+    origin: DecisionItem[];
+}
+export interface DecisionContext {
+    registry: DecisionRegistry;
+}
+/** "[[SRD 2024/Classes/Fighter]]" → "fighter" (tail segment, slugified). */
+export declare function wikilinkTailSlug(link: string): string;
+/** "srd-2024_fighter" → "fighter". Tolerates a nullish slug (degrades to "") so a
+ *  malformed entity can't hard-crash the builder; the resolver backfills real slugs. */
+export declare function bareEntitySlug(slug: string | null | undefined): string;
+declare function matchesFilter(e: RegisteredEntity, where: EntityFilter, ownerBare: string): boolean;
+/** Test-only export of {@link matchesFilter} (Task B2). */
+export declare const __matchesFilterForTest: typeof matchesFilter;
+/** Walk every decision definition + persisted selection and collect chosen
+ *  proficiencies. Pure; called by recalc. Values are validated against the
+ *  decision's option pool — stale slugs (outside `from`) are ignored. */
+export declare function collectChosenProficiencies(resolved: ResolvedCharacter): {
+    skills: string[];
+    expertise: string[];
+    languages: string[];
+    tools: string[];
+};
+export interface OriginAbilityPoints {
+    race: Partial<Record<Ability, number>>;
+    background: Partial<Record<Ability, number>>;
+}
+/** Pure: folds ORIGIN (race/background) `ability-points` decisions out of
+ *  origin_choices into per-namespace totals. Values are clamped picker-side
+ *  already, but clamp again defensively: per-ability max_per, then stop at the
+ *  points total walking ABILITY_KEYS order. Class-level ASI stays on the
+ *  legacy choices[lvl].asi path recalc already folds — do not double-count. */
+export declare function collectChosenAbilityPoints(resolved: ResolvedCharacter): OriginAbilityPoints;
+export declare function buildDecisionLedger(resolved: ResolvedCharacter, ctx: DecisionContext): DecisionLedger;
+export {};