@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/chunk-YBLDE5CG.js

@@ -0,0 +1,42 @@
+// src/feat/feat.category-codes.ts
+var FEAT_CATEGORY_CODE_LABELS = {
+  D: "Dragonmark",
+  G: "General",
+  O: "Origin",
+  FS: "Fighting Style",
+  EB: "Epic Boon",
+  DG: "Dark Gift",
+  "FS:P": "Fighting Style",
+  "FS:R": "Fighting Style"
+};
+function featCategoryLabel(code) {
+  var _a;
+  return (_a = FEAT_CATEGORY_CODE_LABELS[code]) != null ? _a : code;
+}
+var FEAT_PROGRESSION_CATEGORY = {
+  FS: "fighting-style",
+  "FS:P": "fighting-style",
+  "FS:R": "fighting-style",
+  EB: "epic-boon",
+  O: "origin",
+  G: "general"
+};
+var FEATURE_TYPE_FOR_CATEGORY = {
+  "fighting-style": "fighting_style"
+};
+function featProgressionCategory(codes) {
+  for (const code of codes != null ? codes : []) {
+    if (Object.prototype.hasOwnProperty.call(FEAT_PROGRESSION_CATEGORY, code)) {
+      return FEAT_PROGRESSION_CATEGORY[code];
+    }
+  }
+  return void 0;
+}
+
+export {
+  FEAT_CATEGORY_CODE_LABELS,
+  featCategoryLabel,
+  FEAT_PROGRESSION_CATEGORY,
+  FEATURE_TYPE_FOR_CATEGORY,
+  featProgressionCategory
+};

package/dist/{chunk-JEYQU3JT.js → chunk-YHYTW5QA.js}

@@ -1,24 +1,8 @@
 // src/pc/decision-recognizer.ts
 var DECISION_SIGNAL = [/\bchoose (one|two|three|a|an)\b/i, /\bof your choice\b/i, /\byour choice of\b/i];
-var ASI_OR_FEAT = {
-  kind: "select-inline",
-  id: "asi-or-feat",
-  count: 1,
-  options: [
-    {
-      value: "asi",
-      label: "Ability Score Increase",
-      choices: [{ kind: "ability-points", id: "asi", points: 2, max_per: 2 }]
-    },
-    {
-      value: "feat",
-      label: "Feat",
-      choices: [{ kind: "select-entity", id: "feat", entity_type: "feat", count: 1 }]
-    }
-  ]
-};
+var ASI_FEAT = { kind: "select-entity", id: "feat", entity_type: "feat", count: 1 };
 var TABLE = {
-  "ability-score-improvement": [ASI_OR_FEAT],
+  "ability-score-improvement": [ASI_FEAT],
   "expertise": [{ kind: "select-proficiency", id: "expertise", count: 2, domain: "skill", from_proficient: true, expertise: true }],
   "fighting-style": [{ kind: "select-entity", id: "fighting-style", count: 1, entity_type: "optional-feature", where: { feature_type: "fighting_style", available_to: "self" } }]
 };

package/dist/{chunk-TLYDBT5F.js → chunk-YJJTISBN.js}

@@ -2,17 +2,28 @@ import {
   poolGrantSchema,
   selectionPoolSchema,
   tabDeclSchema
-} from "./chunk-4TIJKN6O.js";
+} from "./chunk-23LZLBJK.js";
+import {
+  casterTypeEnum
+} from "./chunk-CJYCVNW2.js";
 import {
   featureSchema
-} from "./chunk-CZPMTQOY.js";
+} from "./chunk-4FWNK4FD.js";
 import {
   resourceSchema
-} from "./chunk-PZOWBI3B.js";
+} from "./chunk-YLL2QXY2.js";
 import {
   startingEquipmentEntrySchema,
   startingGoldSchema
-} from "./chunk-3DZ74AKK.js";
+} from "./chunk-IN4M4X7P.js";
+import {
+  choiceSchema
+} from "./chunk-T26ZVCL5.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.js";
 
 // src/class/class.schema.ts
 import { z } from "zod";
@@ -67,7 +78,6 @@ var toolProficiencySchema = z.object({
 }, {
   message: "tool proficiency must declare fixed or choice"
 });
-var casterTypeEnum = z.enum(["full", "half", "third", "pact"]);
 var spellcastingSchema = z.object({
   caster_type: casterTypeEnum,
   ability: abilityEnum,
@@ -75,7 +85,16 @@ var spellcastingSchema = z.object({
   spell_list: z.string().min(1)
 });
 var weaponMasterySchema = z.object({
-  starting_count: z.number().int().nonnegative(),
+  // §2.7's ONE deliberate relaxation, and the phase's only non-additive edit. Measured: `starting_count`
+  // has ZERO read sites in either repo, all 24 SRD class records are `weapon_mastery: null`, and the
+  // converter population is zero too (26 of 28 class docs null; both object carriers DO carry the count).
+  // It exists so the converter can re-emit a countless mastery object later. R4-G5 did NOT make it read: §6 takes
+  // the count from the class TABLE COLUMN instead (`COUNT_COLUMNS` in `pc.table-column.ts`), because the column
+  // is the truth on BOTH corpora, and `count.column` on the choice itself is booked to the G7 converter handoff.
+  // `starting_count` therefore still has ZERO read sites.
+  // A THREE-declaration edit (finding 11): here, `class.types.ts`, and the generator's COPIED
+  // `interface WeaponMasteryConfig` in tools/srd-canonical/merger-rules/class-merge.ts.
+  starting_count: z.number().int().nonnegative().optional(),
   scaling: z.record(z.string(), z.number().int().nonnegative()).optional()
 });
 var classTableRowSchema = z.object({
@@ -101,6 +120,10 @@ var classEntitySchema = z.object({
     count: z.number().int().positive(),
     from: z.array(skillEnum).nonempty()
   }),
+  // Zod strips unknown keys by default, so without this declaration an authored
+  // `choices:` block is silently deleted by `parseClass`. Same spelling as
+  // `raceEntitySchema` / `backgroundEntitySchema`.
+  choices: z.array(choiceSchema).optional(),
   starting_equipment: z.array(startingEquipmentEntrySchema),
   starting_gold: startingGoldSchema.optional(),
   spellcasting: spellcastingSchema.nullable(),
@@ -113,7 +136,41 @@ var classEntitySchema = z.object({
   resources: z.array(resourceSchema),
   selection_pools: z.array(selectionPoolSchema).optional(),
   pool_grants: z.array(poolGrantSchema).optional(),
-  tabs: z.array(tabDeclSchema).optional()
+  tabs: z.array(tabDeclSchema).optional(),
+  rendering_hint: z.string().optional(),
+  // 28
+  has_fluff: z.boolean().optional(),
+  // 28
+  has_fluff_images: z.boolean().optional(),
+  // 27
+  table_col_labels: z.array(z.string().min(1)).optional(),
+  // 28
+  starting_equipment_additional_from_background: z.boolean().optional(),
+  // 28
+  multiclassing: z.unknown().optional(),
+  // FOUR arities measured incl. {} ×3; free-form 5etools keys
+  // ("thieves' tools", requirements.or[].{dex,str}) — Q1 ruling
+  cantrip_progression: z.array(z.number()).optional(),
+  // 15
+  prepared_spells: z.string().min(1).optional(),
+  // formula string "<$level$> / 2 + <$int_mod$>"
+  prepared_spells_change: z.string().min(1).optional(),
+  // "restLong"
+  prepared_spells_progression: z.array(z.number()).optional(),
+  spells_known_progression: z.array(z.number()).optional(),
+  spells_known_progression_fixed: z.array(z.number()).optional(),
+  spells_known_progression_fixed_allow_lower_level: z.boolean().optional(),
+  // ⚠️ BOOLEAN (finding 1)
+  spells_known_progression_fixed_by_level: z.record(z.string(), z.record(z.string(), z.number())).optional(),
+  // ⚠️ two-deep record (finding 1)
+  feat_progression: z.array(progressionSchema).optional(),
+  // 13
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 9 carriers; the ARRAY
+  // progression arm rides 4 of them
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 7
+  image: imageField
 });
 
 export {

package/dist/{chunk-PZOWBI3B.js → chunk-YLL2QXY2.js}

@@ -1,6 +1,6 @@
 // src/schemas/resource-schema.ts
 import { z } from "zod";
-var resetTriggerEnum = z.enum(["short-rest", "long-rest", "dawn", "dusk", "turn", "round", "custom"]);
+var resetTriggerEnum = z.enum(["short-rest", "long-rest", "either", "dawn", "dusk", "turn", "round", "custom"]);
 var actionCostEnum = z.enum(["action", "bonus-action", "reaction", "free", "special"]);
 var resourceSchema = z.object({
   id: z.string().min(1),
@@ -25,7 +25,8 @@ var resourceSchema = z.object({
     amount: z.union([z.number(), z.string()]),
     action: actionCostEnum.optional(),
     uses: z.number().int().nonnegative().optional(),
-    reset: resetTriggerEnum
+    reset: resetTriggerEnum,
+    restores: z.enum(["uses", "spell-slots"]).optional()
   })).optional()
 });
 var resourceConsumptionSchema = z.object({
@@ -33,12 +34,16 @@ var resourceConsumptionSchema = z.object({
   resource: z.string().optional(),
   column: z.string().optional(),
   amount: z.number().int().positive(),
+  amount_max: z.number().int().positive().optional(),
   expend_condition: z.enum(["roll_succeeds", "roll_fails", "target_takes_damage", "always"]).optional(),
   free_uses: z.object({
     amount: z.number().int().positive(),
     reset: resetTriggerEnum,
     state_key: z.string().optional()
   }).optional()
+}).refine((c) => c.amount_max === void 0 || c.amount_max >= c.amount, {
+  path: ["amount_max"],
+  message: "amount_max must be >= amount"
 });
 
 export {

package/dist/{chunk-MDEJHMKK.js → chunk-ZONJ66NE.js}

@@ -5,23 +5,31 @@ import {
   actionCostEnum,
   resetTriggerEnum,
   resourceConsumptionSchema
-} from "./chunk-PZOWBI3B.js";
+} from "./chunk-YLL2QXY2.js";
 import {
   featureEffectSchema
-} from "./chunk-NXR3BD2V.js";
+} from "./chunk-WPWOHGPI.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.js";
 
 // src/optional-feature/optional-feature.schema.ts
 import { z } from "zod";
 var editionEnum = z.enum(["2014", "2024"]);
 var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
 var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var namedRefSchema = z.object({ name: z.string().min(1), source: z.string().min(1).optional(), visible_stats: z.boolean().optional() });
 var prerequisiteSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("level"), min: z.number().int().positive() }),
+  z.object({ kind: z.literal("level"), min: z.number().int().positive(), class: namedRefSchema.optional(), subclass: namedRefSchema.optional() }),
   z.object({ kind: z.literal("spell-known"), spell: z.string().regex(wikilinkRegex) }),
   z.object({ kind: z.literal("pact"), pact: z.enum(["tome", "blade", "chain", "talisman"]) }),
   z.object({ kind: z.literal("class"), class: z.string().regex(wikilinkRegex) }),
   z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
-  z.object({ kind: z.literal("other"), detail: z.string() })
+  z.object({ kind: z.literal("other"), detail: z.string() }),
+  z.object({ kind: z.literal("optionalfeature"), optionalfeature: z.string().regex(wikilinkRegex) }),
+  z.object({ kind: z.literal("spell-choose"), choose: z.string().min(1), entry: z.string().optional(), entry_summary: z.string().optional() })
 ]);
 var usesSchema = z.object({
   max: z.union([z.number(), z.string()]),
@@ -44,7 +52,20 @@ var optionalFeatureEntitySchema = z.object({
   passive: z.boolean().optional(),
   // Phase 3 activatable buffs: an activatable boon folds its effects only while
   // its slug is present in state.active_buffs (toggled in the PoolTab).
-  activatable: z.boolean().optional()
+  activatable: z.boolean().optional(),
+  rendering_hint: z.string().optional(),
+  // the ONE root with load-bearing VALUES (88 records, G4's)
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 54
+  is_class_feature_variant: z.boolean().optional(),
+  // 25
+  has_fluff_images: z.boolean().optional(),
+  // 2
+  feat_progression: z.array(progressionSchema).optional(),
+  // 1
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 1
+  image: imageField
 });
 
 export {

package/dist/class/class.codec.js

@@ -1,15 +1,18 @@
 import {
   classCodec
-} from "../chunk-GE4TLPWM.js";
-import "../chunk-42Y5IJKT.js";
-import "../chunk-TLYDBT5F.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-US5IKYCW.js";
+import "../chunk-5U5FFFA3.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-YJJTISBN.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.js";
+import "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-3DZ74AKK.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IN4M4X7P.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   classCodec
 };

package/dist/class/class.parser.js

@@ -1,14 +1,17 @@
 import {
   parseClass
-} from "../chunk-42Y5IJKT.js";
-import "../chunk-TLYDBT5F.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-5U5FFFA3.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-YJJTISBN.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.js";
+import "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-3DZ74AKK.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IN4M4X7P.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseClass
 };

package/dist/class/class.schema.d.ts

@@ -82,14 +82,16 @@ export declare const classEntitySchema: z.ZodObject<{
             survival: "survival";
         }>>;
     }, z.core.$strip>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>>;
     starting_equipment: z.ZodArray<z.ZodType<import("./class.types.js").StartingEquipmentEntry, unknown, z.core.$ZodTypeInternals<import("./class.types.js").StartingEquipmentEntry, unknown>>>;
     starting_gold: z.ZodOptional<z.ZodType<import("./class.types.js").StartingGold, unknown, z.core.$ZodTypeInternals<import("./class.types.js").StartingGold, unknown>>>;
     spellcasting: z.ZodNullable<z.ZodObject<{
         caster_type: z.ZodEnum<{
-            pact: "pact";
-            full: "full";
             half: "half";
+            full: "full";
+            pact: "pact";
             third: "third";
+            artificer: "artificer";
         }>;
         ability: z.ZodEnum<{
             str: "str";
@@ -108,7 +110,7 @@ export declare const classEntitySchema: z.ZodObject<{
     subclass_level: z.ZodNumber;
     subclass_feature_name: z.ZodString;
     weapon_mastery: z.ZodNullable<z.ZodObject<{
-        starting_count: z.ZodNumber;
+        starting_count: z.ZodOptional<z.ZodNumber>;
         scaling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strip>>;
     epic_boon_level: z.ZodNullable<z.ZodNumber>;
@@ -133,6 +135,7 @@ export declare const classEntitySchema: z.ZodObject<{
         reset: z.ZodEnum<{
             "short-rest": "short-rest";
             "long-rest": "long-rest";
+            either: "either";
             dawn: "dawn";
             dusk: "dusk";
             turn: "turn";
@@ -158,12 +161,17 @@ export declare const classEntitySchema: z.ZodObject<{
             reset: z.ZodEnum<{
                 "short-rest": "short-rest";
                 "long-rest": "long-rest";
+                either: "either";
                 dawn: "dawn";
                 dusk: "dusk";
                 turn: "turn";
                 round: "round";
                 custom: "custom";
             }>;
+            restores: z.ZodOptional<z.ZodEnum<{
+                uses: "uses";
+                "spell-slots": "spell-slots";
+            }>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     selection_pools: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -196,7 +204,51 @@ export declare const classEntitySchema: z.ZodObject<{
             layout: z.ZodOptional<z.ZodEnum<{
                 "spell-like": "spell-like";
                 blocks: "blocks";
+                "dice-pool": "dice-pool";
+                "point-pool": "point-pool";
             }>>;
         }, z.core.$strip>;
     }, z.core.$strip>>>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    table_col_labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    starting_equipment_additional_from_background: z.ZodOptional<z.ZodBoolean>;
+    multiclassing: z.ZodOptional<z.ZodUnknown>;
+    cantrip_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    prepared_spells: z.ZodOptional<z.ZodString>;
+    prepared_spells_change: z.ZodOptional<z.ZodString>;
+    prepared_spells_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression_fixed: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression_fixed_allow_lower_level: z.ZodOptional<z.ZodBoolean>;
+    spells_known_progression_fixed_by_level: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    feat_progression: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+        feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    optionalfeature_progression: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+        feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    additional_spells: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            choose: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>]>>;
+        known: z.ZodOptional<z.ZodUnknown>;
+        innate: z.ZodOptional<z.ZodUnknown>;
+        prepared: z.ZodOptional<z.ZodUnknown>;
+        expanded: z.ZodOptional<z.ZodUnknown>;
+        resourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strip>;

package/dist/class/class.schema.js

@@ -1,13 +1,15 @@
 import {
   classEntitySchema
-} from "../chunk-TLYDBT5F.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-YJJTISBN.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.js";
+import "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-3DZ74AKK.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IN4M4X7P.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   classEntitySchema
 };

package/dist/class/class.types.d.ts

@@ -1,7 +1,8 @@
-import type { Feature, Ability, SkillSlug, Resource } from "@archivist-gg/dnd5e";
+import type { Feature, Ability, SkillSlug, Resource, Choice } from "@archivist-gg/dnd5e";
 import type { StartingEquipmentEntry, StartingGold } from "@archivist-gg/dnd5e/types/equipment-grant";
 export type { StartingEquipmentEntry, StartingGold } from "@archivist-gg/dnd5e/types/equipment-grant";
 import type { SelectionPool, PoolGrant, TabDecl } from "@archivist-gg/dnd5e/types/selection-pool";
+import type { AdditionalSpellsEntry, ProgressionEntry } from "@archivist-gg/dnd5e/schemas/entity-extras-schema";
 import type { Edition } from "@archivist-gg/dnd5e/types/edition";
 export type { Edition };
 export type ArmorCategory = "light" | "medium" | "heavy" | "shield";
@@ -30,7 +31,8 @@ export interface SkillChoices {
     count: number;
     from: SkillSlug[];
 }
-export type CasterType = "full" | "half" | "third" | "pact";
+import type { CasterType } from "@archivist-gg/dnd5e/schemas/caster-type-schema";
+export type { CasterType };
 export type SpellcastingPreparation = "known" | "prepared";
 export interface SpellcastingConfig {
     caster_type: CasterType;
@@ -38,8 +40,20 @@ export interface SpellcastingConfig {
     preparation: SpellcastingPreparation;
     spell_list: string;
 }
+/** A SUBCLASS spellcasting block is a partial (R4-G1a D7): the converter emits {ability} alone on subclasses that
+ *  only name a save ability (Path of the Giant, Four Elements) and {ability, caster_type} on the third-casters
+ *  (Eldritch Knight, Arcane Trickster). The CLASS block stays fully required. */
+export interface SubclassSpellcastingConfig {
+    ability: Ability;
+    caster_type?: CasterType;
+    preparation?: SpellcastingPreparation;
+    spell_list?: string;
+}
 export interface WeaponMasteryConfig {
-    starting_count: number;
+    /** OPTIONAL since R4-G1b (§2.7): the converter must be able to re-emit a countless mastery object
+     *  (G5 owns counts-from-prose). Declaration 2 of 3 — the schema and the generator's COPIED
+     *  `interface WeaponMasteryConfig` in tools/srd-canonical/merger-rules/class-merge.ts are the others. */
+    starting_count?: number;
     scaling?: Record<number, number>;
 }
 export interface ClassTableRow {
@@ -58,6 +72,14 @@ export interface ClassEntity {
     saving_throws: Ability[];
     proficiencies: ClassProficiencies;
     skill_choices: SkillChoices;
+    /**
+     * Entity-level decisions the class grants at L1, mirroring the long-standing
+     * `RaceEntity.choices` / `BackgroundEntity.choices` precedent. Classes were the
+     * sole holdout: a tool pick like the Bard's "three musical instruments of your
+     * choice" belongs to the CLASS, not to any one of its L1 features, so before
+     * this there was nowhere to author it.
+     */
+    choices?: Choice[];
     starting_equipment: StartingEquipmentEntry[];
     starting_gold?: StartingGold;
     spellcasting: SpellcastingConfig | null;
@@ -71,4 +93,27 @@ export interface ClassEntity {
     selection_pools?: SelectionPool[];
     pool_grants?: PoolGrant[];
     tabs?: TabDecl[];
+    /** Converter/bundle extras declared by class.schema.ts §2.7; all optional, none read today. */
+    rendering_hint?: string;
+    has_fluff?: boolean;
+    has_fluff_images?: boolean;
+    table_col_labels?: string[];
+    starting_equipment_additional_from_background?: boolean;
+    /** RAW 5etools passthrough (four measured arities incl. `{}`): `unknown` mirrors `z.unknown()`. */
+    multiclassing?: unknown;
+    cantrip_progression?: number[];
+    prepared_spells?: string;
+    prepared_spells_change?: string;
+    prepared_spells_progression?: number[];
+    spells_known_progression?: number[];
+    spells_known_progression_fixed?: number[];
+    /** ⚠️ BOOLEAN, not an array (finding 1). */
+    spells_known_progression_fixed_allow_lower_level?: boolean;
+    /** ⚠️ TWO-DEEP record: level -> spell level -> count (finding 1). */
+    spells_known_progression_fixed_by_level?: Record<string, Record<string, number>>;
+    feat_progression?: ProgressionEntry[];
+    optionalfeature_progression?: ProgressionEntry[];
+    additional_spells?: AdditionalSpellsEntry[];
+    /** One wikilink, or an array of them for the multi-fluff-image emit. */
+    image?: string | string[];
 }

package/dist/condition/condition.codec.d.ts

@@ -0,0 +1,9 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { ConditionEntity } from "./condition.types.js";
+/**
+ * Normalizing codec. `parse` delegates to `parseCondition`, which seeds the
+ * `edition: "2014"` default and validates against `conditionEntitySchema`.
+ * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
+ * serializer), mirroring every sibling entity codec.
+ */
+export declare const conditionCodec: DocCodec<ConditionEntity>;

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

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

package/dist/condition/condition.parser.d.ts

@@ -0,0 +1,13 @@
+import type { ConditionEntity } from "./condition.types.js";
+import { ParseResult } from "@archivist-gg/core";
+/**
+ * The RACE pattern (spec §6): required keys enforced by `parseYaml`, the
+ * `edition: "2014"` default seeded BEFORE validation (a declared edition wins —
+ * the spread order is load-bearing), and `result.data` returned DIRECTLY. That
+ * keeps `slug` on the output — the spell parser's slug strip is what mints its
+ * 1,048-row census row — and, because the measured corpus carries exactly the two
+ * declared key-sets, `z.object`'s strip removes nothing. The absence of a
+ * KNOWN_KEYS gate and a `raw` bag is why there is no *relocated* or *duplicated*
+ * row either.
+ */
+export declare function parseCondition(source: string): ParseResult<ConditionEntity>;

package/dist/condition/condition.parser.js

@@ -0,0 +1,7 @@
+import {
+  parseCondition
+} from "../chunk-6X2NV665.js";
+import "../chunk-UA5KS2PL.js";
+export {
+  parseCondition
+};

package/dist/condition/condition.schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * The `condition` entity (spec §6). Measured corpus at design time: 89 documents
+ * (59 converter over 4 books + 30 bundle) in exactly TWO key-sets — with
+ * `has_fluff_images` (39) and without (50) — over 15 distinct names that are
+ * BYTE-IDENTICAL across every book that ships them. Editions: converter 44/15,
+ * bundle 15/15, so the closed enum is safe. NOT every book ships all 15
+ * (`Hunt for the Thessalhydra` has no Exhaustion): completeness is never assumed.
+ *
+ * Plain `z.object` on purpose — no `.loose()`, no raw bag, no KNOWN_KEYS list: the
+ * corpus has no keys beyond these, and the parser returns the validated object
+ * directly (see `condition.parser.ts`), so nothing is relocated or duplicated.
+ *
+ * `edition` is REQUIRED here; the parser seeds `"2014"` BEFORE validation, so an
+ * authored note without the key still parses (all 89 corpus docs carry it).
+ * `image` is already `.optional()` at its source — never append a second one.
+ */
+export declare const conditionEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    description: z.ZodString;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;

package/dist/condition/condition.types.d.ts

@@ -0,0 +1,15 @@
+import type { imageField } from "../schemas/entity-extras-schema.js";
+import type { Edition } from "../types/edition.js";
+import type { z } from "zod";
+/** A 5e condition document (spec §6). Mirrors `conditionEntitySchema` exactly. */
+export interface ConditionEntity {
+    slug: string;
+    name: string;
+    edition: Edition;
+    source: string;
+    /** Markdown; wikilinks to sibling conditions ride through verbatim. */
+    description: string;
+    has_fluff_images?: boolean;
+    /** One wikilink, or an array for >= 2 fluff images (images-ON emit). */
+    image?: z.infer<typeof imageField>;
+}