playlist-data-engine 1.1.0

package/dist/core/generation/SkillAssigner.d.ts

@@ -0,0 +1,78 @@
+/**
+ * SkillAssigner - Assigns D&D 5e skill proficiencies based on character class
+ */
+import type { Class, ProficiencyLevel, CharacterSheet } from '../types/Character.js';
+import type { SeededRNG } from '../../utils/random.js';
+export declare class SkillAssigner {
+    /**
+     * Get skill list definition for a class from ExtensionManager
+     *
+     * Checks the 'skillLists' category for a matching class entry.
+     * Returns undefined if no custom skill list is registered.
+     *
+     * @param characterClass - The class to get skill list data for
+     * @returns SkillListDefinition or undefined
+     */
+    private static getSkillListDefinition;
+    /**
+     * Assign skill proficiencies based on character class
+     *
+     * Now uses SkillQuery to support custom skills and validates all skill IDs.
+     * Supports weighted skill selection via ExtensionManager integration.
+     * Filters skills by prerequisites when a character is provided.
+     *
+     * @param characterClass - The character's class
+     * @param rng - Seeded random number generator for deterministic selection
+     * @param character - Optional character sheet for prerequisite validation
+     * @returns Record of all skills with their proficiency levels (supports custom skills)
+     */
+    static assignSkills(characterClass: Class, rng: SeededRNG, character?: CharacterSheet): Record<string, ProficiencyLevel>;
+    /**
+     * Validate skills against the SkillQuery
+     *
+     * Filters out any skill IDs that are not registered in the SkillQuery.
+     * This prevents invalid skill IDs from being assigned.
+     *
+     * @param skillIds - Array of skill IDs to validate
+     * @param registry - SkillQuery instance
+     * @returns Array of valid skill IDs
+     */
+    private static validateSkills;
+    /**
+     * Filter skills by prerequisites
+     *
+     * Removes skills that have unmet prerequisites for the given character.
+     * Skills without prerequisites are always included.
+     *
+     * @param skillIds - Array of skill IDs to filter
+     * @param registry - SkillQuery instance
+     * @param character - Character sheet to validate prerequisites against
+     * @returns Array of skill IDs whose prerequisites are met
+     */
+    private static filterSkillsByPrerequisites;
+    /**
+     * Deterministically select N random skills from a list
+     *
+     * Uses Fisher-Yates shuffle with seeded RNG for deterministic selection.
+     * Supports weighted selection via selectionWeights parameter.
+     *
+     * @param availableSkills - Array of skill IDs to choose from
+     * @param count - Number of skills to select
+     * @param rng - Seeded random number generator
+     * @param selectionWeights - Optional weights for skill selection
+     * @returns Array of selected skill IDs
+     */
+    private static selectSkills;
+    /**
+     * Select N random skills using equal weights
+     *
+     * Uses Fisher-Yates shuffle with seeded RNG for deterministic selection.
+     *
+     * @param availableSkills - Array of skill IDs to choose from
+     * @param count - Number of skills to select
+     * @param rng - Seeded random number generator
+     * @returns Array of selected skill IDs
+     */
+    private static selectSkillsEqualWeight;
+}
+//# sourceMappingURL=SkillAssigner.d.ts.map

package/dist/core/generation/SkillAssigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkillAssigner.d.ts","sourceRoot":"","sources":["../../../src/core/generation/SkillAssigner.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAqBvD,qBAAa,aAAa;IACtB;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAerC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,YAAY,CACf,cAAc,EAAE,KAAK,EACrB,GAAG,EAAE,SAAS,EACd,SAAS,CAAC,EAAE,cAAc,GAC3B,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;IA8DnC;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAc7B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM,CAAC,2BAA2B;IA0B1C;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAwE3B;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;CAiBzC"}

package/dist/core/generation/SpellManager.d.ts

@@ -0,0 +1,132 @@
+/**
+ * SpellManager - Manages spell assignment, spell slots, and cantrips for spellcasting classes
+ */
+import type { Class, CharacterSheet } from '../types/Character.js';
+export interface SpellSlots {
+    /** Record of spell slots by spell level (0-9) */
+    spell_slots: Record<number, {
+        total: number;
+        used: number;
+    }>;
+    /** Array of known spell names */
+    known_spells: string[];
+    /** Array of cantrip names */
+    cantrips: string[];
+}
+export declare class SpellManager {
+    /**
+     * Check if a class is a spellcaster
+     *
+     * @param characterClass - The character's class
+     * @returns true if the class can cast spells
+     */
+    static isSpellcaster(characterClass: Class): boolean;
+    /**
+     * Get spell slots for a class at a given level
+     *
+     * Uses the getSpellSlotsForClass() helper to get spell slot progression (default or custom).
+     * This supports custom classes registered via the 'classSpellSlots' category in ExtensionManager.
+     *
+     * @param characterClass - The character's class
+     * @param characterLevel - The character's level (1-20)
+     * @returns Record of spell slots by spell level with total and used counts
+     */
+    static getSpellSlots(characterClass: Class, characterLevel: number): Record<number, {
+        total: number;
+        used: number;
+    }>;
+    /**
+     * Get cantrips known by a spellcaster at a given level
+     *
+     * Uses the getClassSpellList() helper to get spell lists (default or custom).
+     * Also checks ExtensionManager for extended spell data via `spells.${ClassName}`.
+     *
+     * @param characterClass - The character's class
+     * @returns Array of cantrip names
+     */
+    static getCantrips(characterClass: Class): string[];
+    /**
+     * Get spells known by a spellcaster at a given level
+     *
+     * Uses the getClassSpellList() helper to get spell lists (default or custom).
+     * Also checks ExtensionManager for extended spell data via `spells.${ClassName}`.
+     * Filters spells by prerequisites when a character is provided.
+     *
+     * @param characterClass - The character's class
+     * @param characterLevel - The character's level (1-20)
+     * @param character - Optional character sheet for prerequisite validation
+     * @returns Array of spell names that the character knows
+     */
+    static getKnownSpells(characterClass: Class, characterLevel: number, character?: CharacterSheet): string[];
+    /**
+     * Filter spells by prerequisites
+     *
+     * Removes spells that have unmet prerequisites for the given character.
+     * Spells without prerequisites are always included.
+     *
+     * @param spellNames - Array of spell names to filter
+     * @param character - Character sheet to validate prerequisites against
+     * @returns Array of spell names whose prerequisites are met
+     */
+    private static filterSpellsByPrerequisites;
+    /**
+     * Initialize complete spell configuration for a spellcaster
+     *
+     * @param characterClass - The character's class
+     * @param characterLevel - The character's level (1-20)
+     * @param character - Optional character sheet for prerequisite validation
+     * @returns SpellSlots object with spell slots, known spells, and cantrips
+     */
+    static initializeSpells(characterClass: Class, characterLevel: number, character?: CharacterSheet): SpellSlots;
+    /**
+     * Get spell count at a given spell level that a character knows
+     *
+     * @param spellLevel - The spell level (0-9)
+     * @param spellSlots - The spell slots record from a character
+     * @returns Number of spells known at that level
+     */
+    static getSpellCountAtLevel(spellLevel: number, spellSlots: Record<number, {
+        total: number;
+        used: number;
+    }>): number;
+    /**
+     * Use a spell slot at a given level
+     *
+     * @param spellSlots - The spell slots record from a character
+     * @param spellLevel - The spell level (1-9, not 0 for cantrips)
+     * @returns Updated spell slots with one slot used
+     */
+    static useSpellSlot(spellSlots: Record<number, {
+        total: number;
+        used: number;
+    }>, spellLevel: number): Record<number, {
+        total: number;
+        used: number;
+    }>;
+    /**
+     * Restore all spell slots at a given level
+     *
+     * @param spellSlots - The spell slots record from a character
+     * @param spellLevel - The spell level (1-9) or undefined to restore all
+     * @returns Updated spell slots with slots restored
+     */
+    static restoreSpellSlots(spellSlots: Record<number, {
+        total: number;
+        used: number;
+    }>, spellLevel?: number): Record<number, {
+        total: number;
+        used: number;
+    }>;
+    /**
+     * Filter character's spells by prerequisites
+     *
+     * Updates a character's known_spells array to only include spells whose
+     * prerequisites are met by the character. Used during character generation
+     * and when validating characters with custom spells.
+     *
+     * @param character - The character sheet whose spells should be filtered
+     * @returns Updated character with filtered spells
+     */
+    static filterCharacterSpells(character: CharacterSheet): CharacterSheet;
+}
+//# sourceMappingURL=SpellManager.d.ts.map

package/dist/core/generation/SpellManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpellManager.d.ts","sourceRoot":"","sources":["../../../src/core/generation/SpellManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAiBnE,MAAM,WAAW,UAAU;IACzB,iDAAiD;IACjD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,iCAAiC;IACjC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,cAAc,EAAE,KAAK,GAAG,OAAO;IAKpD;;;;;;;;;OASG;IACH,MAAM,CAAC,aAAa,CAClB,cAAc,EAAE,KAAK,EACrB,cAAc,EAAE,MAAM,GACrB,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA0BlD;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,CAChB,cAAc,EAAE,KAAK,GACpB,MAAM,EAAE;IAiCX;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,cAAc,CACnB,cAAc,EAAE,KAAK,EACrB,cAAc,EAAE,MAAM,EACtB,SAAS,CAAC,EAAE,cAAc,GACzB,MAAM,EAAE;IA+EX;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,CAAC,2BAA2B;IA6B1C;;;;;;;OAOG;IACH,MAAM,CAAC,gBAAgB,CACrB,cAAc,EAAE,KAAK,EACrB,cAAc,EAAE,MAAM,EACtB,SAAS,CAAC,EAAE,cAAc,GACzB,UAAU;IAQb;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,CACzB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,GAC1D,MAAM;IAIT;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAC3D,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAelD;;;;;;OAMG;IACH,MAAM,CAAC,iBAAiB,CACtB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAC3D,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAqBlD;;;;;;;;;OASG;IACH,MAAM,CAAC,qBAAqB,CAAC,SAAS,EAAE,cAAc,GAAG,cAAc;CAwBxE"}

package/dist/core/generation/SpellcastingGenerator.d.ts

@@ -0,0 +1,255 @@
+/**
+ * SpellcastingGenerator - Generates spellcasting abilities for enemies
+ *
+ * Provides innate spellcasting system for enemies that can cast spells.
+ * Unlike player spellcasting, enemies use a simplified "innate" system
+ * where they have predefined spells they can use.
+ *
+ * Spell selection is based on:
+ * - Enemy archetype (support, archer, brute)
+ * - Rarity tier (bosses get more spells than commons)
+ * - Challenge Rating (determines spell slot count)
+ *
+ * @example
+ * ```typescript
+ * // Generate spell list for an elite shaman
+ * const spellcasting = SpellcastingGenerator.generateSpellList({
+ *   archetype: 'support',
+ *   rarity: 'elite',
+ *   cr: 2,
+ *   seed: 'elite-shaman'
+ * });
+ * // Returns: { cantrips: [...], spells: [...], slots: { 1: 3, 2: 1 } }
+ * ```
+ */
+import { SeededRNG } from '../../utils/random.js';
+import type { EnemyArchetype, EnemyRarity } from '../types/Enemy.js';
+import type { Spell } from '../types/Character.js';
+/**
+ * Innate Spell - A spell available to an enemy
+ *
+ * Represents a single spell that an enemy can cast.
+ * Simplified compared to player spells - enemies have predefined spell lists.
+ */
+export interface InnateSpell extends Spell {
+    /** Unique identifier for this spell */
+    id: string;
+    /** Spell level (0 = cantrip, 1-9 = spell level) */
+    level: number;
+    /** Magical school of the spell */
+    school: string;
+    /** Description of what the spell does */
+    effect: string;
+}
+/**
+ * Spell List - All spells available to an archetype
+ *
+ * Organized by spell level (0 = cantrips, 1-9 = spell levels).
+ * Each archetype has access to different spell themes.
+ */
+export interface SpellList {
+    /** Archetype this spell list belongs to */
+    archetype: EnemyArchetype;
+    /** Cantrips (level 0 spells) - always available */
+    cantrips: InnateSpell[];
+    /** Level 1 spells */
+    level1: InnateSpell[];
+    /** Level 2 spells */
+    level2: InnateSpell[];
+    /** Level 3 spells */
+    level3: InnateSpell[];
+    /** Level 4 spells (rare, mostly for bosses) */
+    level4?: InnateSpell[];
+}
+/**
+ * Spellcasting Config - Result of spell list generation
+ *
+ * Contains the selected spells and slot counts for an enemy.
+ */
+export interface SpellcastingConfig {
+    /** Cantrips the enemy knows (always available) */
+    cantrips: InnateSpell[];
+    /** Spells the enemy knows (may have limited slots) */
+    spells: InnateSpell[];
+    /** Spell slots available per level { level: count } */
+    slots: Record<number, number>;
+}
+/**
+ * SPELL_SLOTS_BY_CR - Spell slot progression by Challenge Rating
+ *
+ * Maps CR values to the number of spell slots available.
+ * Higher CR enemies have more spell slots and higher level spells.
+ *
+ * Slot format: { level1: slots, level2: slots, ... }
+ *
+ * CR 0-0.5: No spellcasting (minions)
+ * CR 1-2: Level 1 only (basic casters)
+ * CR 3-4: Levels 1-2 (moderate casters)
+ * CR 5-7: Levels 1-3 (strong casters)
+ * CR 8+: Levels 1-4 (boss casters)
+ */
+export declare const SPELL_SLOTS_BY_CR: Record<number, Record<number, number>>;
+/**
+ * Spellcasting generation options
+ */
+export interface SpellcastingGenerationOptions {
+    /** Enemy archetype for spell selection */
+    archetype: EnemyArchetype;
+    /** Enemy rarity for spell count and level limits */
+    rarity: EnemyRarity;
+    /** Challenge Rating for slot determination */
+    cr: number;
+    /** Seed for deterministic spell selection */
+    seed: string;
+}
+/**
+ * Spellcasting generation options with RNG
+ *
+ * Same as SpellcastingGenerationOptions but accepts SeededRNG directly.
+ */
+export interface SpellcastingGenerationOptionsWithRNG {
+    /** Enemy archetype for spell selection */
+    archetype: EnemyArchetype;
+    /** Enemy rarity for spell count and level limits */
+    rarity: EnemyRarity;
+    /** Challenge Rating for slot determination */
+    cr: number;
+    /** RNG instance for deterministic spell selection */
+    rng: SeededRNG;
+}
+/**
+ * SpellcastingGenerator - Static class for generating enemy spellcasting
+ *
+ * Generates spell lists and slot configurations for enemy casters.
+ * Uses deterministic seeded selection for reproducibility.
+ */
+export declare class SpellcastingGenerator {
+    /**
+     * Generate a spell list for an enemy
+     *
+     * Selects spells based on archetype, rarity, and CR.
+     * Higher rarity enemies get more spells and higher level access.
+     *
+     * @param options - Spell generation options
+     * @returns Spell configuration with spells and slots
+     *
+     * @example
+     * ```typescript
+     * const spellcasting = SpellcastingGenerator.generateSpellList({
+     *   archetype: 'support',
+     *   rarity: 'elite',
+     *   cr: 3,
+     *   seed: 'shaman-1'
+     * });
+     * // Returns: { cantrips: [...], spells: [...], slots: { 1: 4, 2: 2 } }
+     * ```
+     */
+    static generateSpellList(options: SpellcastingGenerationOptions): SpellcastingConfig;
+    /**
+     * Generate a spell list for an enemy using provided RNG
+     *
+     * Same as generateSpellList but accepts SeededRNG directly.
+     * Useful when you already have a seeded RNG instance.
+     *
+     * @param options - Spell generation options with RNG
+     * @returns Spell configuration with spells and slots
+     *
+     * @example
+     * ```typescript
+     * const spellcasting = SpellcastingGenerator.generateSpellListWithRNG({
+     *   archetype: 'support',
+     *   rarity: 'elite',
+     *   cr: 3,
+     *   rng: seededRNG
+     * });
+     * // Returns: { cantrips: [...], spells: [...], slots: { 1: 4, 2: 2 } }
+     * ```
+     */
+    static generateSpellListWithRNG(options: SpellcastingGenerationOptionsWithRNG): SpellcastingConfig;
+    /**
+     * Get spell slot configuration for a CR
+     *
+     * Returns the number of spell slots available per level.
+     * Handles fractional CR by rounding up to nearest slot tier.
+     *
+     * @param cr - Challenge rating
+     * @returns Spell slots per level { level: count }
+     *
+     * @example
+     * ```typescript
+     * getSpellSlotsForCR(3); // Returns: { 1: 4, 2: 2 }
+     * getSpellSlotsForCR(0.5); // Returns: {}
+     * ```
+     */
+    static getSpellSlotsForCR(cr: number): Record<number, number>;
+    /**
+     * Check if an archetype can cast spells
+     *
+     * Currently all archetypes have spell lists available.
+     * This is a utility method for future expansion.
+     *
+     * @param archetype - Enemy archetype to check
+     * @returns True if archetype has spellcasting capability
+     */
+    static archetypeCanCast(archetype: EnemyArchetype): boolean;
+    /**
+     * Get all spells for an archetype
+     *
+     * Returns the complete spell list for an archetype.
+     *
+     * @param archetype - Enemy archetype
+     * @returns Complete spell list or undefined
+     */
+    static getSpellListForArchetype(archetype: EnemyArchetype): SpellList | undefined;
+    /**
+     * Convert a spell to a Feature object
+     *
+     * Creates a ClassFeature-compatible object from an InnateSpell.
+     * Used to add spells to enemy ability lists.
+     *
+     * @param spell - The spell to convert
+     * @returns Feature object with isSpell property
+     *
+     * @example
+     * ```typescript
+     * const spellFeature = SpellcastingGenerator.spellToFeature(blessSpell);
+     * // Returns: { id: 'support_bless', name: 'Bless', ..., isSpell: true }
+     * ```
+     */
+    static spellToFeature(spell: InnateSpell): Record<string, unknown> & {
+        isSpell: boolean;
+    };
+    /**
+     * Convert all spellcasting config to feature objects
+     *
+     * Converts cantrips and spells to an array of Feature objects.
+     *
+     * @param config - Spell configuration from generateSpellList
+     * @returns Array of feature objects with isSpell property
+     *
+     * @example
+     * ```typescript
+     * const config = generateSpellList(...);
+     * const features = SpellcastingGenerator.spellsToFeatures(config);
+     * // Returns: [feature1, feature2, ...] all with isSpell: true
+     * ```
+     */
+    static spellsToFeatures(config: SpellcastingConfig): Array<Record<string, unknown> & {
+        isSpell: boolean;
+    }>;
+    /**
+     * Check if an enemy should have spellcasting
+     *
+     * Enemies with the "support" archetype or those with specific
+     * template flags would have spellcasting.
+     *
+     * This is a heuristic - the template may also have a
+     * "spellcaster" flag in V2 enhancements.
+     *
+     * @param archetype - Enemy archetype
+     * @param rarity - Enemy rarity
+     * @returns True if enemy should get spellcasting
+     */
+    static shouldHaveSpellcasting(archetype: EnemyArchetype, rarity: EnemyRarity): boolean;
+}
+//# sourceMappingURL=SpellcastingGenerator.d.ts.map

package/dist/core/generation/SpellcastingGenerator.d.ts.map

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

package/dist/core/generation/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Character Generation Module
+ *
+ * Exports all character generation utilities including:
+ * - CharacterGenerator: Main character generation from playlists
+ * - EnemyGenerator: Enemy and encounter generation
+ * - NamingEngine: Procedural name generation
+ * - ClassSuggester: Class suggestion from audio profiles
+ * - RaceSelector: Race selection from audio profiles
+ * - AppearanceGenerator: Physical appearance generation
+ * - EquipmentGenerator: Equipment generation
+ * - SkillAssigner: Skill proficiency assignment
+ * - SpellManager: Spell selection and management
+ */
+export { CharacterGenerator } from './CharacterGenerator.js';
+export { EnemyGenerator } from './EnemyGenerator.js';
+export { NamingEngine } from './NamingEngine.js';
+export { ClassSuggester } from './ClassSuggester.js';
+export { RaceSelector } from './RaceSelector.js';
+export { AppearanceGenerator } from './AppearanceGenerator.js';
+export { EquipmentGenerator } from './EquipmentGenerator.js';
+export { SkillAssigner } from './SkillAssigner.js';
+export { SpellManager } from './SpellManager.js';
+export { crToLevel, levelToCR, roundLevel, roundCR, formatLevel, formatCR, createCRTuning, DEFAULT_CR_TUNING } from './CRLevelConverter.js';
+export type { CRTuningConfig } from './CRLevelConverter.js';
+export { SpellcastingGenerator, SPELL_SLOTS_BY_CR } from './SpellcastingGenerator.js';
+export type { InnateSpell, SpellList, SpellcastingConfig, SpellcastingGenerationOptions, SpellcastingGenerationOptionsWithRNG } from './SpellcastingGenerator.js';
+export { LegendaryGenerator, LEGENDARY_ACTIONS, LEGENDARY_RESISTANCES, LEGENDARY_ACTION_COUNT } from './LegendaryGenerator.js';
+export type { LegendaryAction, LegendaryConfig } from './LegendaryGenerator.js';
+export type { EnemyCategory, EnemyRarity, EnemyArchetype, EnemyMixMode, EncounterDifficulty, SignatureAbility, AudioPreference, EnemyTemplate, RarityConfig, EnemyGenerationOptions, EncounterGenerationOptions, EnemyMetadata, EnemyFeature } from '../types/Enemy.js';
+export { isValidEnemyCategory, isValidEnemyRarity, isValidEnemyArchetype, isValidEncounterDifficulty } from '../types/Enemy.js';
+export { RhythmGenerator } from './RhythmGenerator.js';
+export type { RhythmGenerationOptions, GeneratedRhythm, RhythmMetadata, OutputMode, ProgressCallback, } from './RhythmGenerator.js';
+export { PitchBeatLinker } from './PitchBeatLinker.js';
+export type { PitchAtBeat, PitchBandName, IntervalCategory, PitchDirection, PitchBeatLinkerConfig, } from './PitchBeatLinker.js';
+export { DDR_PATTERN_LIBRARY, GUITAR_HERO_PATTERN_LIBRARY, getPatternLibrary, getPatternsByCategory, getPatternsByDifficulty, getPatternsByTags, getPatternsByKeyCount, getRandomPattern, getPatternById, getPatternLibraryStats, } from './ButtonPatternLibrary.js';
+export { ButtonMapper } from './ButtonMapper.js';
+export type { MappedLevelResult, ButtonMappingMetadata, } from './ButtonMapper.js';
+export { LevelGenerator } from './LevelGenerator.js';
+export type { LevelGenerationOptions, LevelMetadata, GeneratedLevel, AllDifficultiesResult, LevelProgressCallback, } from './LevelGenerator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/generation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/generation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,EACH,SAAS,EACT,SAAS,EACT,UAAU,EACV,OAAO,EACP,WAAW,EACX,QAAQ,EACR,cAAc,EACd,iBAAiB,EACpB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,EACH,qBAAqB,EACrB,iBAAiB,EACpB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACR,WAAW,EACX,SAAS,EACT,kBAAkB,EAClB,6BAA6B,EAC7B,oCAAoC,EACvC,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EACH,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACzB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACR,eAAe,EACf,eAAe,EAClB,MAAM,yBAAyB,CAAC;AAGjC,YAAY,EACR,aAAa,EACb,WAAW,EACX,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,sBAAsB,EACtB,0BAA0B,EAC1B,aAAa,EACb,YAAY,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACH,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,0BAA0B,EAC7B,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EACR,uBAAuB,EACvB,eAAe,EACf,cAAc,EACd,UAAU,EACV,gBAAgB,GACnB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EACR,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,qBAAqB,GACxB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACH,mBAAmB,EACnB,2BAA2B,EAC3B,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,sBAAsB,GACzB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EACR,iBAAiB,EACjB,qBAAqB,GACxB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EACR,sBAAsB,EACtB,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,qBAAqB,GACxB,MAAM,qBAAqB,CAAC"}

package/dist/core/parser/MetadataExtractor.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Metadata extraction with priority queue logic
+ * Based on specs/001-core-engine/SPEC.md
+ */
+export declare class MetadataExtractor {
+    /**
+     * Extract primary (compressed) audio URL with priority:
+     * 1. mp3_url (Standard web audio - preferred)
+     * 2. lossy_audio (Compressed)
+     * 3. audio_url (Explicit audio field)
+     * 4. lossless_audio (High fidelity - larger files)
+     * 5. animation_url (OpenSea standard - often audio, but could be video)
+     */
+    static extractAudioUrl(data: Record<string, unknown>): string | null;
+    /**
+     * Extract optional lossless audio URL (uncompressed/high-fidelity source).
+     * Returns a lossless URL only if it differs from the primary audio URL.
+     * Priority: lossless_audio > animation_url (only if it looks like a lossless format)
+     */
+    static extractAudioUrlLossless(data: Record<string, unknown>): string | null;
+    /**
+     * Extract image URL with priority (see specs/001-core-engine/SPEC.md):
+     * 1. image_small (Preferred for performance)
+     * 2. image (Standard)
+     * 3. image_large (Fallback)
+     * 4. image_thumb (Last resort)
+     */
+    static extractImageUrl(data: Record<string, unknown>): string | null;
+    /**
+     * Extract thumbnail image URL directly from image_thumb fields.
+     * Unlike extractImageUrl, this specifically targets thumbnail fields only.
+     * Priority: image_thumb_url > image_thumb
+     */
+    static extractImageThumbUrl(data: Record<string, unknown>): string | null;
+    /**
+     * Extract name/title with priority (see specs/001-core-engine/SPEC.md):
+     * 1. name
+     * 2. title
+     */
+    static extractTitle(data: Record<string, unknown>): string | null;
+    /**
+     * Extract artist with priority (see specs/001-core-engine/SPEC.md):
+     * 1. artist
+     * 2. created_by
+     * 3. minter
+     */
+    static extractArtist(data: Record<string, unknown>): string | null;
+    /**
+     * Parse metadata string to JSON object
+     * Handles stringified JSON with error handling
+     */
+    static parseMetadata(metadata: unknown): Record<string, unknown> | null;
+    /**
+     * Extract genre with support for string or array formats
+     * - If genre is a string, returns it directly
+     * - If genre is an array, returns the first element
+     * - Also checks OpenSea attributes array for "Genre" trait_type
+     */
+    static extractGenre(data: Record<string, unknown>): string;
+    /**
+     * Convert OpenSea-style attributes array to key-value object
+     * Example: [{ trait_type: "BPM", value: 120 }] => { BPM: 120 }
+     */
+    static convertAttributes(attributes: unknown): Record<string, string | number> | null;
+}
+//# sourceMappingURL=MetadataExtractor.d.ts.map

package/dist/core/parser/MetadataExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataExtractor.d.ts","sourceRoot":"","sources":["../../../src/core/parser/MetadataExtractor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,iBAAiB;IAC1B;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAYpE;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAY5E;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAYpE;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAczE;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAUjE;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAYlE;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IA0BvE;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAgC1D;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;CAcxF"}

package/dist/core/parser/PlaylistParser.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Playlist parser - converts raw Arweave JSON to ServerlessPlaylist
+ * Based on specs/001-core-engine/SPEC.md
+ */
+import type { ServerlessPlaylist, RawArweavePlaylist } from '../types/Playlist.js';
+export interface PlaylistParserOptions {
+    /** Validate audio URLs (check for 404s) */
+    validateAudioUrls?: boolean;
+    /** Strict mode throws errors on invalid tracks */
+    strict?: boolean;
+    /** Timeout in milliseconds for audio URL validation (default: 5000ms) */
+    audioUrlValidationTimeout?: number;
+    /**
+     * Whether to resolve image URLs (image_url, image_thumb_url) during parsing.
+     * When true, Arweave image URLs will be resolved to working gateways.
+     * Default: false (to maintain backward compatibility - consumers can resolve on-demand)
+     */
+    resolveImageUrls?: boolean;
+}
+export declare class PlaylistParser {
+    private options;
+    constructor(options?: PlaylistParserOptions);
+    /**
+     * Parse raw Arweave playlist data into ServerlessPlaylist
+     * Follows the flattening process from specs/001-core-engine/SPEC.md
+     */
+    parse(data: RawArweavePlaylist): Promise<ServerlessPlaylist>;
+    /**
+     * Resolve Arweave URLs in a track (image_url, image_thumb_url)
+     * Only resolves if resolveImageUrls option is enabled
+     */
+    private resolveTrackUrls;
+    /**
+     * Parse a single track following the flattening process
+     * See specs/001-core-engine/SPEC.md
+     */
+    private parseTrack;
+    /**
+     * Validate that an audio URL is accessible
+     * @param url - The audio URL to validate
+     * @returns Promise<boolean> - true if URL is accessible, false otherwise
+     */
+    private validateAudioUrl;
+}
+//# sourceMappingURL=PlaylistParser.d.ts.map

package/dist/core/parser/PlaylistParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlaylistParser.d.ts","sourceRoot":"","sources":["../../../src/core/parser/PlaylistParser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAiB,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAKlG,MAAM,WAAW,qBAAqB;IAClC,2CAA2C;IAC3C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,kDAAkD;IAClD,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,yEAAyE;IACzE,yBAAyB,CAAC,EAAE,MAAM,CAAC;IAEnC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,qBAAa,cAAc;IACvB,OAAO,CAAC,OAAO,CAAwB;gBAE3B,OAAO,GAAE,qBAA0B;IAU/C;;;OAGG;IACG,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8ClE;;;OAGG;YACW,gBAAgB;IAoB9B;;;OAGG;YACW,UAAU;IAiHxB;;;;OAIG;YACW,gBAAgB;CAqBjC"}