playlist-data-engine 1.1.0

package/dist/utils/constants.d.ts

@@ -0,0 +1,439 @@
+/**
+ * D&D 5e data constants
+ */
+import type { Race, Class, Ability, Skill } from '../core/types/Character.js';
+import type { Spell, SpellPrerequisite } from '../core/spells/SpellTypes.js';
+import type { EquipmentType, EquipmentRarity, EquipmentProperty, EquipmentMiniFeature, BoxContents } from '../core/types/Equipment.js';
+export type { Spell, SpellPrerequisite };
+export type { RaceDataEntry, CustomRaceDataEntry } from '../constants/DefaultRaces.js';
+export type { ClassSpellListData } from '../constants/DefaultSpells.js';
+/**
+ * Class data entry interface
+ *
+ * Defines the structure for class data including primary ability, hit die,
+ * saving throws, spellcasting, skills, expertise, and optional audio preferences.
+ *
+ * ## Template-Based Class System
+ *
+ * This interface supports creating custom classes that extend (inherit from) existing
+ * D&D 5e base classes through the `baseClass` property. This enables rapid creation
+ * of specialized classes (e.g., "Necromancer" extending "Wizard") without duplicating
+ * all base class properties.
+ *
+ * ### How Template Inheritance Works
+ *
+ * When `baseClass` is specified in a custom class registration:
+ *
+ * 1. **Base class lookup**: The system retrieves the base class data from CLASS_DATA
+ * 2. **Property merging**: Base class properties are merged with custom class properties
+ * 3. **Override behavior**: Custom properties take precedence over base class properties
+ * 4. **Special handling for available_skills**: Custom skill list replaces base skill list
+ *    (not merged), allowing complete customization of class skills
+ *
+ * ### Example Usage
+ *
+ * ```typescript
+ * import { ExtensionManager } from './core/extensions/ExtensionManager.js';
+ *
+ * const manager = ExtensionManager.getInstance();
+ *
+ * // Register a custom "Necromancer" class based on Wizard
+ * manager.register('classes.data', [{
+ *     name: 'Necromancer',
+ *     baseClass: 'Wizard',  // Inherits from Wizard by default
+ *     primary_ability: 'INT',  // Same as Wizard (could omit to inherit)
+ *     hit_die: 8,  // Same as Wizard (could omit to inherit)
+ *     saving_throws: ['INT', 'WIS'],  // Same as Wizard (could omit to inherit)
+ *     is_spellcaster: true,  // Same as Wizard (could omit to inherit)
+ *     skill_count: 2,  // Same as Wizard (could omit to inherit)
+ *     // Override available_skills to include custom skill
+ *     available_skills: ['arcana', 'medicine', 'religion', 'necromancy'],
+ *     has_expertise: false  // Same as Wizard (could omit to inherit)
+ * }]);
+ * ```
+ *
+ * ### Complete Custom Classes
+ *
+ * Classes without `baseClass` are standalone and must specify all required properties:
+ *
+ * ```typescript
+ * manager.register('classes.data', [{
+ *     name: 'Runecaster',
+ *     // No baseClass - must specify all properties
+ *     primary_ability: 'WIS',
+ *     hit_die: 8,
+ *     saving_throws: ['WIS', 'CON'],
+ *     is_spellcaster: true,
+ *     skill_count: 3,
+ *     available_skills: ['arcana', 'nature', 'religion', 'insight', 'medicine'],
+ *     has_expertise: false
+ * }]);
+ * ```
+ *
+ * ### Integration with Other Extension Categories
+ *
+ * Custom classes can be further customized with:
+ *
+ * - **Custom skills**: Register via `skills.${ABILITY}` categories
+ * - **Custom features**: Register via `classFeatures.${ClassName}` categories
+ * - **Custom spell lists**: Register via `classSpellLists.${ClassName}` categories
+ * - **Custom spell slots**: Register via `classSpellSlots` category
+ * - **Custom equipment**: Register via `classStartingEquipment.${ClassName}` categories
+ *
+ */
+export interface ClassDataEntry {
+    /** Class name (required for custom classes, optional for built-in classes where the key serves as the name) */
+    name?: string;
+    /** Primary ability score for this class */
+    primary_ability: Ability;
+    /** Hit die size for this class */
+    hit_die: number;
+    /** Saving throw proficiencies */
+    saving_throws: Ability[];
+    /** Whether this class can cast spells */
+    is_spellcaster: boolean;
+    /** Number of skills to choose from */
+    skill_count: number;
+    /** Available skills for this class (includes custom skills) */
+    available_skills: string[];
+    /** Whether this class has expertise */
+    has_expertise: boolean;
+    /** Number of expertise choices (if has_expertise is true) */
+    expertise_count?: number;
+    /**
+     * For template-based classes: the base class to inherit from
+     *
+     * When specified, the custom class will inherit properties from the base class,
+     * with custom properties overriding inherited ones. This enables rapid creation
+     * of specialized classes (e.g., "Necromancer" extending "Wizard").
+     *
+     * The base class must be a valid D&D 5e class name (one of: Barbarian, Bard,
+     * Cleric, Druid, Fighter, Monk, Paladin, Ranger, Rogue, Sorcerer, Warlock, Wizard).
+     *
+     * @example
+     * // Necromancer extends Wizard
+     * baseClass: 'Wizard'
+     */
+    baseClass?: Class;
+    /** Optional: Audio preferences for class affinity calculation */
+    audio_preferences?: {
+        primary: 'bass' | 'treble' | 'mid' | 'amplitude' | 'chaos';
+        secondary?: 'bass' | 'treble' | 'mid' | 'amplitude' | 'chaos';
+        tertiary?: 'bass' | 'treble' | 'mid' | 'amplitude' | 'chaos';
+        bass?: number;
+        treble?: number;
+        mid?: number;
+        amplitude?: number;
+    };
+    /** Optional: User-facing description of this class */
+    description?: string;
+    /** Optional icon URL for small UI display */
+    icon?: string;
+    /** Optional image URL for larger display */
+    image?: string;
+}
+/**
+ * Get class data (default or custom)
+ *
+ * This helper function retrieves class data from either:
+ * 1. The default CLASS_DATA constant (for built-in classes)
+ * 2. The ExtensionManager (for custom classes registered via 'classes.data')
+ *
+ * For template-based custom classes (those with a baseClass property),
+ * the base class data is merged with custom data, with custom properties
+ * taking precedence.
+ *
+ * @param className - The class name to look up
+ * @returns Class data entry or undefined if not found
+ *
+ * @example
+ * // Get default class data
+ * const wizardData = getClassData('Wizard');
+ * console.log(wizardData.hit_die); // 6
+ *
+ * // Get custom class data (if registered via ExtensionManager)
+ * const necromancerData = getClassData('Necromancer');
+ * if (necromancerData) {
+ *     console.log(necromancerData.baseClass); // 'Wizard'
+ *     console.log(necromancerData.primary_ability); // 'INT'
+ * }
+ */
+/**
+ * Get class data (default or custom) - asynchronous version
+ *
+ * This helper function retrieves class data from either:
+ * 1. The default CLASS_DATA constant (for built-in classes)
+ * 2. The ExtensionManager (for custom classes registered via 'classes.data')
+ *
+ * ## Template-Based Class Inheritance
+ *
+ * For template-based custom classes (those with a baseClass property),
+ * the base class data is merged with custom data following these rules:
+ *
+ * 1. **Base class lookup**: Retrieves the base class data from CLASS_DATA
+ * 2. **Shallow merge**: Base properties are spread first, then custom properties
+ * 3. **Override behavior**: Custom properties take precedence over base properties
+ * 4. **Special handling for available_skills**: The custom skill list completely replaces
+ *    the base skill list (not merged), allowing complete customization
+ *
+ * The merge logic is:
+ * ```typescript
+ * {
+ *     ...baseData,        // Base class properties first
+ *     ...classEntry,      // Custom properties override base
+ *     available_skills: classEntry.available_skills || baseData.available_skills
+ * }
+ * ```
+ *
+ * ### Usage Flow for Custom Classes
+ *
+ * 1. Register class data via `ExtensionManager.register('classes.data', [...])`
+ * 2. Register class name via `ExtensionManager.register('classes', [asClass('Necromancer')])`
+ * 3. Optionally register custom features, skills, spells, equipment
+ * 4. Use `CharacterGenerator.generate()` with `forceClass: asClass('Necromancer')`
+ *
+ * @param className - The class name to look up
+ * @returns Class data entry or undefined if not found
+ *
+ * @example
+ * // Get default class data
+ * const wizardData = await getClassDataAsync('Wizard');
+ * console.log(wizardData.hit_die); // 6
+ *
+ * // Get custom class data (if registered via ExtensionManager)
+ * const necromancerData = await getClassDataAsync('Necromancer');
+ * if (necromancerData) {
+ *     console.log(necromancerData.baseClass); // 'Wizard'
+ *     console.log(necromancerData.primary_ability); // 'INT' (inherited from Wizard)
+ *     console.log(necromancerData.available_skills); // ['arcana', 'medicine', 'religion', 'necromancy'] (custom)
+ * }
+ */
+export declare function getClassDataAsync(className: string): Promise<ClassDataEntry | undefined>;
+/**
+ * Get class data (default or custom)
+ *
+ * This helper function retrieves class data from either:
+ * 1. The default CLASS_DATA constant (for built-in classes)
+ * 2. The ExtensionManager (for custom classes registered via 'classes.data')
+ *
+ * ## Template-Based Class Inheritance
+ *
+ * For template-based custom classes (those with a baseClass property),
+ * the base class data is merged with custom data following these rules:
+ *
+ * 1. **Base class lookup**: Retrieves the base class data from CLASS_DATA
+ * 2. **Shallow merge**: Base properties are spread first, then custom properties
+ * 3. **Override behavior**: Custom properties take precedence over base properties
+ * 4. **Special handling for available_skills**: The custom skill list completely replaces
+ *    the base skill list (not merged), allowing complete customization
+ *
+ * The merge logic is:
+ * ```typescript
+ * {
+ *     ...baseData,        // Base class properties first
+ *     ...classEntry,      // Custom properties override base
+ *     available_skills: classEntry.available_skills || baseData.available_skills
+ * }
+ * ```
+ *
+ * ### Usage Flow for Custom Classes
+ *
+ * 1. Register class data via `ExtensionManager.register('classes.data', [...])`
+ * 2. Register class name via `ExtensionManager.register('classes', [asClass('Necromancer')])`
+ * 3. Optionally register custom features, skills, spells, equipment
+ * 4. Use `CharacterGenerator.generate()` with `forceClass: asClass('Necromancer')`
+ *
+ * @param className - The class name to look up
+ * @returns Class data entry or undefined if not found
+ *
+ * @example
+ * // Get default class data
+ * const wizardData = getClassData('Wizard');
+ * console.log(wizardData.hit_die); // 6
+ *
+ * // Get custom class data (if registered via ExtensionManager)
+ * const necromancerData = getClassData('Necromancer');
+ * if (necromancerData) {
+ *     console.log(necromancerData.baseClass); // 'Wizard'
+ *     console.log(necromancerData.primary_ability); // 'INT' (inherited from Wizard)
+ *     console.log(necromancerData.available_skills); // ['arcana', 'medicine', 'religion', 'necromancy'] (custom)
+ * }
+ */
+export declare function getClassData(className: string): ClassDataEntry | undefined;
+export declare const XP_THRESHOLDS: Record<number, number>;
+export declare const PROFICIENCY_BONUS: Record<number, number>;
+export declare const ALL_RACES: Race[];
+/**
+ * Centralized naming data for character name generation
+ * Contains adjectives, descriptors, and word pools for various naming formats
+ */
+export declare const NAMING_DATA: {
+    adjectives: {
+        techno: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        rock: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        metal: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        ambient: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        classical: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        jazz: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        'hip hop': {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        pop: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        electronic: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+        default: {
+            bass: string[];
+            treble: string[];
+            mid: string[];
+            quiet: string[];
+            loud: string[];
+        };
+    };
+    descriptors: string[];
+    classAspects: Record<Class, string[]>;
+    prefixes: string[];
+    suffixes: string[];
+    occupations: string[];
+    realms: string[];
+    subtitlePrefixes: string[];
+};
+export declare const SKILL_ABILITY_MAP: Record<Skill, Ability>;
+/**
+ * Equipment data structure
+ *
+ * This interface now uses the same types as EnhancedEquipment for consistency.
+ * The 'source' field is optional for backward compatibility but defaults to 'default'.
+ */
+export interface Equipment {
+    name: string;
+    type: EquipmentType;
+    rarity: EquipmentRarity;
+    weight: number;
+    properties?: EquipmentProperty[];
+    grantsFeatures?: Array<string | EquipmentMiniFeature>;
+    grantsSkills?: Array<{
+        skillId: string;
+        level: 'proficient' | 'expertise';
+    }>;
+    grantsSpells?: Array<{
+        spellId: string;
+        level?: number;
+        uses?: number;
+        recharge?: string;
+    }>;
+    damage?: {
+        dice: string;
+        damageType: string;
+        versatile?: string;
+    };
+    acBonus?: number;
+    weaponProperties?: string[];
+    spawnWeight?: number;
+    templateId?: string;
+    source?: 'default' | 'custom';
+    tags?: string[];
+    /** Optional: User-facing description of this equipment */
+    description?: string;
+    /** Optional icon URL for small UI display */
+    icon?: string;
+    /** Optional image URL for larger display */
+    image?: string;
+    /** Box contents (only for type: 'box') */
+    boxContents?: BoxContents;
+}
+/**
+ * Get spell list for a class (default or custom)
+ *
+ * First checks the default CLASS_SPELL_LISTS constant, then checks
+ * the ExtensionManager for custom spell lists registered via 'classSpellLists.${ClassName}'.
+ *
+ * @param className - The class name to get spell list for
+ * @returns The spell list with cantrips and spells_by_level, or undefined if not found
+ */
+export declare function getClassSpellList(className: string): {
+    cantrips: string[];
+    spells_by_level: Record<number, string[]>;
+} | undefined;
+/**
+ * Get spell slots for a class at a specific level (default or custom)
+ *
+ * First checks the default SPELL_SLOTS_BY_CLASS constant, then checks
+ * the ExtensionManager for custom spell slot progressions registered via 'classSpellSlots'.
+ *
+ * The 'classSpellSlots' category expects an array of ClassSpellSlotsData objects,
+ * each containing a class name and a slots_by_level record mapping character levels
+ * to spell slot counts per spell level.
+ *
+ * @param className - The class name to get spell slots for
+ * @param characterLevel - The character level (1-20)
+ * @returns Record mapping spell level (1-9) to slot count, or undefined if not found
+ *
+ * @example
+ * // Register custom spell slots for a "Necromancer" class
+ * manager.register('classSpellSlots', [{
+ *     class: 'Necromancer',
+ *     slots_by_level: {
+ *         1: { 1: 2 },
+ *         2: { 1: 3 },
+ *         3: { 1: 4, 2: 2 },
+ *         // ... more levels
+ *     }
+ * }]);
+ */
+export declare function getSpellSlotsForClass(className: string, characterLevel: number): Record<number, number> | undefined;
+/** Minimum listen count to achieve track mastery */
+export declare const MASTERY_THRESHOLD = 10;
+/** Bonus XP awarded for mastered tracks */
+export declare const MASTERY_BONUS_XP = 50;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"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"}

package/dist/utils/equipmentConstants.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Equipment Constants Library
+ *
+ * This file consolidates all equipment-related constants into a single location,
+ * providing a single source of truth for equipment data throughout the Playlist Data Engine.
+ *
+ * Contents:
+ * - DEFAULT_EQUIPMENT: Base equipment database (re-exported from src/constants/DefaultEquipment.ts)
+ * - CLASS_STARTING_EQUIPMENT: Starting equipment by class (D&D 5e standard)
+ * - ITEM_CREATION_TEMPLATES: Templates for enchanting base equipment (9 templates)
+ * - ENCHANTMENT_LIBRARY: All enchantments and curses organized by category
+ *
+ * Access Patterns:
+ * - Direct access: Import specific constants (e.g., `DEFAULT_EQUIPMENT`, `CLASS_STARTING_EQUIPMENT`)
+ * - Enchantment categories: `ENCHANTMENT_LIBRARY.WEAPON_ENCHANTMENTS.plusOne`
+ * - Flat enchantments: `ENCHANTMENT_LIBRARY.ALL_ENCHANTMENTS.plusOne`
+ * - Helper function: `getClassStartingEquipment('Fighter')` - checks both default and custom
+ *
+ * @module utils/equipmentConstants
+ */
+import type { Equipment } from './constants.js';
+import type { EquipmentModification, EquipmentMiniFeature, EquipmentType, EquipmentRarity, EquipmentProperty, EquipmentPropertyType, EquipmentCondition, EnhancedEquipment } from '../core/types/Equipment.js';
+export type { Equipment, EquipmentModification, EquipmentMiniFeature, EquipmentType, EquipmentRarity, EquipmentProperty, EquipmentPropertyType, EquipmentCondition, EnhancedEquipment };
+/**
+ * Starting equipment by class - D&D 5e standard
+ */
+export declare const CLASS_STARTING_EQUIPMENT: Record<string, {
+    weapons: string[];
+    armor: string[];
+    items: string[];
+}>;
+/**
+ * Get starting equipment for a class (default or custom)
+ *
+ * First checks the default CLASS_STARTING_EQUIPMENT constant, then checks
+ * the ExtensionManager for custom equipment registered via 'classStartingEquipment.${ClassName}'.
+ *
+ * The 'classStartingEquipment.${ClassName}' category expects an array of ClassStartingEquipmentData objects,
+ * each containing a class name and the equipment (weapons, armor, items).
+ *
+ * This function is used by EquipmentGenerator during character creation.
+ *
+ * @param className - The class name to get starting equipment for
+ * @returns Object with weapons, armor, and items arrays, or undefined if not found
+ *
+ * @example
+ * // Register custom starting equipment for a "Necromancer" class
+ * manager.register('classStartingEquipment.Necromancer', [{
+ *     class: 'Necromancer',
+ *     weapons: ['Bone Staff', 'Dagger'],
+ *     armor: ['No Armor'],
+ *     items: ['Arcane Focus', 'Skeleton Key', 'Dark Robes']
+ * }]);
+ */
+export declare function getClassStartingEquipment(className: string): {
+    weapons: string[];
+    armor: string[];
+    items: string[];
+} | undefined;
+//# sourceMappingURL=equipmentConstants.d.ts.map

package/dist/utils/equipmentConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equipmentConstants.d.ts","sourceRoot":"","sources":["../../src/utils/equipmentConstants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD,OAAO,KAAK,EACR,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,4BAA4B,CAAC;AAMpC,YAAY,EACR,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACpB,CAAC;AAYF;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;CACnB,CA6DA,CAAC;AAgBF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;CACnB,GAAG,SAAS,CA2BZ"}

package/dist/utils/hash.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Deterministic seed generation using MurmurHash
+ */
+/**
+ * Generate a deterministic seed from blockchain data
+ * @param chainName - Blockchain name (e.g., "ethereum", "polygon")
+ * @param tokenAddress - Contract address
+ * @param tokenId - Token ID
+ * @returns Deterministic seed string
+ */
+export declare function generateSeed(chainName: string, tokenAddress: string, tokenId: string): string;
+/**
+ * Hash a seed string to a float between 0.0 and 1.0
+ * @param seed - Seed string
+ * @returns Float between 0.0 and 1.0
+ */
+export declare function hashSeedToFloat(seed: string): number;
+/**
+ * Hash a seed string to an integer within a range
+ * @param seed - Seed string
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (exclusive)
+ * @returns Integer in range [min, max)
+ */
+export declare function hashSeedToInt(seed: string, min: number, max: number): number;
+/**
+ * Create a derived seed by appending a suffix
+ * @param baseSeed - Base seed string
+ * @param suffix - Suffix to append
+ * @returns New seed string
+ */
+export declare function deriveSeed(baseSeed: string, suffix: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/utils/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;GAMG;AACH,wBAAgB,YAAY,CACxB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GAChB,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnE"}