playlist-data-engine 1.1.0

package/dist/core/playback/SubdivisionPlaybackController.d.ts

@@ -0,0 +1,333 @@
+/**
+ * Subdivision Playback Controller
+ *
+ * Real-time subdivision controller for practice mode. Enables instant
+ * switching between subdivision types during playback.
+ *
+ * Key features:
+ * - Real-time beat generation based on current subdivision type
+ * - Instant subdivision switching with configurable transition modes
+ * - Continuity across subdivision changes
+ * - Integration with Web Audio API for precise timing
+ *
+ * @example
+ * ```typescript
+ * const controller = new SubdivisionPlaybackController(unifiedMap, audioContext, {
+ *   initialSubdivision: 'quarter',
+ *   transitionMode: 'next-downbeat',
+ *   onSubdivisionChange: (oldType, newType) => {
+ *     console.log(`Switched from ${oldType} to ${newType}`);
+ *   },
+ * });
+ *
+ * // Subscribe to beat events
+ * controller.subscribe((event) => {
+ *   if (event.type === 'exact') {
+ *     playBeatSound(event.beat);
+ *   }
+ * });
+ *
+ * controller.play();
+ *
+ * // User clicks "Eighth Notes" button in practice mode
+ * controller.setSubdivision('eighth');  // Switches in real-time!
+ * ```
+ */
+import type { UnifiedBeatMap, SubdividedBeat, SubdividedBeatMap, SubdivisionType, SubdivisionPlaybackOptions, SubdivisionTransitionMode, SubdivisionCallback, AccuracyThresholds, ButtonPressResult } from '../types/BeatMap.js';
+/**
+ * Subdivision Playback Controller
+ *
+ * Provides real-time subdivision switching for practice mode.
+ * Wraps a UnifiedBeatMap and generates beats on-the-fly based on
+ * the current subdivision type.
+ */
+export declare class SubdivisionPlaybackController {
+    private unifiedMap;
+    private audioContext;
+    private options;
+    private state;
+    private subscribers;
+    private subdivider;
+    /**
+     * Create a new SubdivisionPlaybackController
+     *
+     * @param unifiedMap - The unified beat map to use for subdivision
+     * @param audioContext - The Web Audio API AudioContext for timing
+     * @param options - Configuration options
+     *
+     * @example
+     * ```typescript
+     * const beatMap = await generator.generateBeatMap('song.mp3', 'track-1');
+     * const interpolatedMap = interpolator.interpolate(beatMap);
+     * const unifiedMap = unifyBeatMap(interpolatedMap);
+     *
+     * const controller = new SubdivisionPlaybackController(
+     *   unifiedMap,
+     *   audioContext,
+     *   {
+     *     initialSubdivision: 'quarter',
+     *     transitionMode: 'next-downbeat',
+     *   }
+     * );
+     * ```
+     */
+    constructor(unifiedMap: UnifiedBeatMap, audioContext: AudioContext, options?: SubdivisionPlaybackOptions);
+    /**
+     * Get the current subdivision type
+     */
+    get subdivision(): SubdivisionType;
+    /**
+     * Get the unified beat map
+     */
+    get beatMap(): UnifiedBeatMap;
+    /**
+     * Get the current playback options
+     */
+    getOptions(): Required<SubdivisionPlaybackOptions>;
+    /**
+     * Subscribe to beat events
+     *
+     * @param callback - Function to call when beat events occur
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = controller.subscribe((event) => {
+     *   if (event.type === 'upcoming') {
+     *     // Pre-render beat visual
+     *   } else if (event.type === 'exact') {
+     *     // Beat is happening now
+     *   }
+     * });
+     *
+     * // Later, to unsubscribe
+     * unsubscribe();
+     * ```
+     */
+    subscribe(callback: SubdivisionCallback): () => void;
+    /**
+     * Change subdivision type in real-time
+     *
+     * The transition behavior depends on the transitionMode option:
+     * - 'immediate': Switch instantly at the current position
+     * - 'next-downbeat': Wait for the next downbeat before switching
+     * - 'next-measure': Wait for the next measure before switching
+     *
+     * @param type - The new subdivision type
+     *
+     * @example
+     * ```typescript
+     * // Switch to eighth notes immediately
+     * controller.setSubdivision('eighth');
+     *
+     * // Switch to half notes
+     * controller.setSubdivision('half');
+     * ```
+     */
+    setSubdivision(type: SubdivisionType): void;
+    /**
+     * Set the transition mode for subdivision changes.
+     * Updates how pending subdivision changes are applied.
+     *
+     * @param mode - The transition mode ('immediate', 'next-downbeat', 'next-measure')
+     *
+     * @example
+     * ```typescript
+     * // Change to immediate mode during playback
+     * controller.setTransitionMode('immediate');
+     *
+     * // Any pending subdivision change will apply immediately
+     * controller.setSubdivision('eighth');
+     * ```
+     */
+    setTransitionMode(mode: SubdivisionTransitionMode): void;
+    /**
+     * Apply the subdivision change immediately
+     */
+    private applySubdivisionChange;
+    /**
+     * Regenerate beats for the current subdivision.
+     * When fromTimestamp is provided, only regenerates beats from that point onwards,
+     * preserving old beats before the transition point for smooth visual transitions.
+     *
+     * @param fromTimestamp - Optional timestamp to start regeneration from. Beats before this
+     *                        timestamp are preserved. Used for deferred transitions.
+     */
+    private regenerateBeats;
+    /**
+     * Get a unique key for a beat
+     */
+    private getBeatKey;
+    /**
+     * Start streaming beat events
+     *
+     * Begins emitting events synchronized with audio playback.
+     * Should be called when audio starts playing.
+     */
+    play(): void;
+    /**
+     * Stop streaming beat events
+     *
+     * Stops all event emission and resets state.
+     */
+    stop(): void;
+    /**
+     * Pause the playback
+     *
+     * Temporarily stops event emission but preserves position.
+     */
+    pause(): void;
+    /**
+     * Resume a paused playback
+     */
+    resume(): void;
+    /**
+     * Seek to a specific time position
+     *
+     * @param time - Time in seconds to seek to
+     */
+    seek(time: number): void;
+    /**
+     * Get beats for a time range (generated on-the-fly)
+     *
+     * This method generates beats based on the current subdivision type
+     * within the specified time range.
+     *
+     * @param startTime - Start time in seconds
+     * @param endTime - End time in seconds
+     * @returns Array of subdivided beats in the range
+     *
+     * @example
+     * ```typescript
+     * // Get beats for the next 5 seconds
+     * const beats = controller.getBeatsInRange(currentTime, currentTime + 5);
+     * ```
+     */
+    getBeatsInRange(startTime: number, endTime: number): SubdividedBeat[];
+    /**
+     * Get upcoming beats for pre-rendering
+     *
+     * Returns beats that will occur within the anticipation window.
+     *
+     * @param count - Maximum number of beats to return
+     * @returns Array of upcoming beats
+     */
+    getUpcomingBeats(count: number): SubdividedBeat[];
+    /**
+     * Get the beat at a specific time
+     *
+     * Returns the beat closest to the given time within the timing tolerance.
+     *
+     * @param time - Time in seconds
+     * @returns Beat at the time, or null if no beat is near
+     */
+    getBeatAtTime(time: number): SubdividedBeat | null;
+    /**
+     * Get the current beat (the beat that is currently playing or most recently passed)
+     *
+     * @returns Current beat, or null if before first beat
+     */
+    getCurrentBeat(): SubdividedBeat | null;
+    /**
+     * Get the next beat (the beat that will occur next)
+     *
+     * @returns Next beat, or null if after last beat
+     */
+    getNextBeat(): SubdividedBeat | null;
+    /**
+     * Get the current audio time with latency compensation
+     *
+     * @returns Current audio time in seconds
+     */
+    private getCurrentAudioTime;
+    /**
+     * Get total latency compensation in seconds
+     *
+     * Combines output latency, base latency, and user offset
+     */
+    private getTotalLatencyCompensation;
+    /**
+     * Schedule the next update frame
+     */
+    private scheduleUpdate;
+    /**
+     * Main update loop - checks for beat events to emit
+     */
+    private update;
+    /**
+     * Check for pending subdivision changes
+     */
+    private checkPendingSubdivisionChange;
+    /**
+     * Emit a beat event to all subscribers
+     */
+    private emitEvent;
+    /**
+     * Check if the controller is currently running
+     */
+    isRunning(): boolean;
+    /**
+     * Check if the controller is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Get the current playback position
+     *
+     * @returns Current time in seconds
+     */
+    getCurrentTime(): number;
+    /**
+     * Get the beat map duration
+     */
+    getDuration(): number;
+    /**
+     * Check a button press against the current subdivision's beats.
+     *
+     * This method evaluates tap accuracy against the subdivided beat grid,
+     * not the original quarter notes. Use this when real-time subdivision
+     * is active to ensure tap feedback matches the visual beat positions.
+     *
+     * Note: Key matching is not supported in subdivision mode - all beats are
+     * treated as tap-only. This differs from BeatStream.checkButtonPress which
+     * supports key-matching beats.
+     *
+     * @param timestamp - The time of the button press (audio time in seconds)
+     * @param thresholds - Optional accuracy thresholds to override defaults
+     * @returns Button press result with accuracy level and matched beat
+     */
+    checkButtonPress(timestamp: number, thresholds?: AccuracyThresholds): ButtonPressResult;
+    /**
+     * Update the unified beat map (e.g., after re-analysis)
+     *
+     * @param unifiedMap - New unified beat map to use
+     */
+    setBeatMap(unifiedMap: UnifiedBeatMap): void;
+    /**
+     * Force an update cycle (primarily for testing).
+     *
+     * This manually triggers the update loop which checks for pending
+     * subdivision changes and emits beat events. Useful in tests where
+     * the animation frame loop doesn't run automatically.
+     */
+    forceUpdate(): void;
+    /**
+     * Get the current SubdividedBeatMap with partial regeneration applied.
+     *
+     * This returns a SubdividedBeatMap containing all beats from the
+     * scheduled beats map. When a deferred transition has occurred,
+     * this will include:
+     * - Beats before the transition point with the OLD subdivision
+     * - Beats from the transition point onwards with the NEW subdivision
+     *
+     * Use this for visualization when you need to show the actual beat
+     * grid that the player will encounter, including partial transitions.
+     *
+     * @returns A SubdividedBeatMap with all scheduled beats
+     */
+    getSubdividedBeatMap(): SubdividedBeatMap;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=SubdivisionPlaybackController.d.ts.map

package/dist/core/playback/SubdivisionPlaybackController.d.ts.map

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

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

@@ -0,0 +1,5 @@
+/**
+ * Playback module exports
+ */
+export { SubdivisionPlaybackController, } from './SubdivisionPlaybackController.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/playback/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,6BAA6B,GAChC,MAAM,oCAAoC,CAAC"}

package/dist/core/progression/CharacterUpdater.d.ts

@@ -0,0 +1,203 @@
+import type { CharacterSheet, Ability } from '../types/Character.js';
+import type { ListeningSession, LevelUpDetail, ApplyPendingStatIncreaseResult } from '../types/Progression.js';
+import type { PlaylistTrack } from '../types/Playlist.js';
+import type { PrestigeLevel, PrestigeResult } from '../types/Prestige.js';
+import type { AudioProfile } from '../types/AudioProfile.js';
+import type { ISessionTracker } from '../types/ISessionTracker.js';
+import type { RhythmXPResult } from '../types/RhythmXP.js';
+import { StatManager } from './stat/StatManager.js';
+import { PrestigeSystem } from './PrestigeSystem.js';
+export type { ApplyPendingStatIncreaseResult } from '../types/Progression.js';
+export interface CharacterUpdateResult {
+    character: CharacterSheet;
+    xpEarned: number;
+    leveledUp: boolean;
+    newLevel?: number;
+    masteredTrack: boolean;
+    masteryBonusXP: number;
+    /** Detailed breakdown of each level-up (NEW) */
+    levelUpDetails?: LevelUpDetail[];
+}
+/**
+ * Result type for rhythm XP additions (excludes track mastery fields)
+ * Rhythm game XP doesn't involve track mastery mechanics
+ */
+export type RhythmXPUpdateResult = Omit<CharacterUpdateResult, 'masteredTrack' | 'masteryBonusXP'>;
+/**
+ * CharacterUpdater - Orchestrates character updates from listening sessions
+ */
+export declare class CharacterUpdater {
+    private xpCalculator;
+    private statManager?;
+    constructor(statManager?: StatManager);
+    /**
+     * Add XP from any source (combat, quests, custom activities)
+     * Triggers level-up system with detailed breakdowns
+     *
+     * @param character - The character to update
+     * @param xpAmount - Amount of XP to add
+     * @param source - Source of the XP (for tracking)
+     * @returns Result object containing updated character and level-up details
+     *
+     * @example
+     * ```typescript
+     * // Combat victory XP
+     * const result = updater.addXP(character, 500, 'combat');
+     *
+     * // Quest completion XP
+     * const questResult = updater.addXP(character, 1000, 'quest');
+     *
+     * // Custom activity XP
+     * const customResult = updater.addXP(character, 250, 'exploration');
+     *
+     * if (result.leveledUp) {
+     *   console.log(`🎉 LEVELED UP to ${result.newLevel}!`);
+     *   for (const detail of result.levelUpDetails) {
+     *     console.log(`HP: +${detail.hpIncrease}`);
+     *     console.log(`Stats:`, detail.statIncreases);
+     *   }
+     * }
+     * ```
+     */
+    addXP(character: CharacterSheet, xpAmount: number, _source?: string): Omit<CharacterUpdateResult, 'masteredTrack' | 'masteryBonusXP'>;
+    /**
+     * Add XP from rhythm game button presses.
+     * Triggers level-up system just like addXP() does.
+     *
+     * This method is designed to work with RhythmXPCalculator results.
+     * Rhythm XP doesn't involve track mastery mechanics.
+     *
+     * @param character - The character to update
+     * @param xpResult - Result from RhythmXPCalculator.calculateButtonPressXP()
+     * @param source - Source label for tracking (default: 'rhythm_game')
+     * @returns Result object containing updated character and level-up details
+     *
+     * @example
+     * ```typescript
+     * const calculator = new RhythmXPCalculator();
+     * const xpResult = calculator.calculateButtonPressXP('perfect', { comboLength: 50 });
+     *
+     * const updateResult = updater.addRhythmXP(character, xpResult);
+     *
+     * if (updateResult.leveledUp) {
+     *   console.log(`LEVELED UP to ${updateResult.newLevel}!`);
+     *   for (const detail of updateResult.levelUpDetails ?? []) {
+     *     console.log(`HP: +${detail.hpIncrease}`);
+     *   }
+     * }
+     * ```
+     */
+    addRhythmXP(character: CharacterSheet, xpResult: RhythmXPResult, source?: string): RhythmXPUpdateResult;
+    /**
+     * Helper method to check if a level grants stat increases
+     */
+    private isStatIncreaseLevel;
+    /**
+     * Updates a character based on a completed listening session
+     * Calculates XP, checks for level ups, and handles track mastery
+     *
+     * @param character - The character to update
+     * @param session - The completed listening session
+     * @param track - The track that was listened to (optional, but needed for mastery/completion bonus)
+     * @param options - Optional parameters for mastery calculation
+     * @param options.previousListenCount - Listen count before this session (defaults to 0)
+     * @param options.previousXP - Total track XP before this session (defaults to 0)
+     * @param options.prestigeLevel - Character's prestige level (defaults to character's prestige_level or 0)
+     * @returns Result object containing updated character and event details
+     */
+    updateCharacterFromSession(character: CharacterSheet, session: ListeningSession, track?: PlaylistTrack, options?: {
+        previousListenCount?: number;
+        previousXP?: number;
+        prestigeLevel?: PrestigeLevel;
+    }): CharacterUpdateResult;
+    /**
+     * Apply pending stat increase with user-selected stats
+     * Only works if pendingStatIncreases counter > 0
+     *
+     * @param character - Character with pending stat increases
+     * @param primaryStat - The stat to get +2 (or one of the +1s if using two stats)
+     * @param secondaryStats - Optional array of 1 additional stat for +1/+1 distribution
+     * @returns Result with updated character
+     *
+     * @example
+     * ```typescript
+     * // +2 to STR only
+     * const result = updater.applyPendingStatIncrease(character, 'STR');
+     *
+     * // +1 to STR and +1 to DEX
+     * const result = updater.applyPendingStatIncrease(character, 'STR', ['DEX']);
+     * ```
+     */
+    applyPendingStatIncrease(character: CharacterSheet, primaryStat: Ability, secondaryStats?: Ability[]): ApplyPendingStatIncreaseResult;
+    /**
+     * Check if character has pending stat increases
+     *
+     * @param character - Character to check
+     * @returns true if character has pending stat increases
+     */
+    hasPendingStatIncreases(character: CharacterSheet): boolean;
+    /**
+     * Get the count of pending stat increases
+     *
+     * @param character - Character to check
+     * @returns Number of pending stat increases
+     */
+    getPendingStatIncreaseCount(character: CharacterSheet): number;
+    /**
+     * Reset a character for prestige after mastering a track.
+     *
+     * This is the main prestige execution function that handles the full prestige operation:
+     * 1. Validates: Check can prestige (not at max, meets thresholds)
+     * 2. Preserves equipment
+     * 3. Clears track sessions (calls sessionTracker.clearTrackSessions(trackUuid))
+     * 4. Regenerates base level 1 character from seed
+     * 5. Restores equipment
+     * 6. Re-applies equipment effects
+     * 7. Increments prestige_level
+     * 8. Returns result with success/failure info
+     *
+     * @param character - The character to prestige
+     * @param sessionTracker - SessionTracker instance to clear track sessions
+     * @param trackUuid - UUID of the track being prestiged
+     * @param audioProfile - Audio profile for character regeneration
+     * @param track - Track metadata for character regeneration
+     * @returns PrestigeResult indicating success/failure and new prestige level
+     *
+     * @example
+     * ```typescript
+     * const result = updater.resetCharacterForPrestige(
+     *   character,
+     *   sessionTracker,
+     *   trackUuid,
+     *   audioProfile,
+     *   track
+     * );
+     *
+     * if (result.success) {
+     *   console.log(result.message); // "Successfully prestiged to level I! ..."
+     * } else {
+     *   console.log(result.message); // "Prestige failed: ..."
+     * }
+     * ```
+     */
+    resetCharacterForPrestige(character: CharacterSheet, sessionTracker: ISessionTracker, trackUuid: string, audioProfile: AudioProfile, track: PlaylistTrack): PrestigeResult;
+    /**
+     * Check if a character can prestige for a specific track.
+     *
+     * @param character - The character to check
+     * @param sessionTracker - SessionTracker instance for getting track stats
+     * @param trackUuid - UUID of the track to check
+     * @returns True if the character can prestige
+     */
+    canPrestige(character: CharacterSheet, sessionTracker: ISessionTracker, trackUuid: string): boolean;
+    /**
+     * Get prestige info for a character and track combination.
+     *
+     * @param character - The character to get info for
+     * @param sessionTracker - SessionTracker instance for getting track stats
+     * @param trackUuid - UUID of the track
+     * @returns PrestigeInfo object with current progress
+     */
+    getPrestigeInfo(character: CharacterSheet, sessionTracker: ISessionTracker, trackUuid: string): ReturnType<typeof PrestigeSystem.getPrestigeInfo>;
+}
+//# sourceMappingURL=CharacterUpdater.d.ts.map

package/dist/core/progression/CharacterUpdater.d.ts.map

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