playlist-data-engine 1.1.0

package/dist/core/analysis/EssentiaPitchDetector.d.ts

@@ -0,0 +1,282 @@
+/**
+ * EssentiaPitchDetector - Pitch detection using Essentia.js algorithms
+ *
+ * This module provides pitch detection using the Essentia.js WebAssembly library,
+ * offering 6 different algorithms including industry-standard options for
+ * polyphonic music (predominant_melodia) and neural network models (CREPE).
+ *
+ * ## Algorithm Categories
+ *
+ * ### Built-in WASM Algorithms (5 of 6)
+ * These are compiled directly into the essentia-wasm.wasm binary and require
+ * no external model files.
+ *
+ * | Algorithm | Best For | Returns Confidence? | Polyphonic? |
+ * |-----------|----------|-------------------|-------------|
+ * | `predominant_melodia` | Lead melody in polyphonic music **(Recommended)** | Yes | Single F0 |
+ * | `pitch_melodia` | Standard monophonic melody extraction | Yes | Single F0 |
+ * | `pitch_yin_probabilistic` | WASM-accelerated pYIN | Yes | Single F0 |
+ * | `multipitch_melodia` | Multiple simultaneous F0 contours | No | Multi F0 |
+ * | `multipitch_klapuri` | Harmonic summation multi-pitch | No | Multi F0 |
+ *
+ * ### External Model Algorithm (1 of 6)
+ * `pitch_crepe` - Neural network pitch detection using TensorFlow.js.
+ * Requires external TFJS model file loaded via `crepeModelUrl` config.
+ *
+ * @example
+ * ```typescript
+ * const detector = await EssentiaPitchDetector.create({
+ *   algorithm: 'predominant_melodia',
+ *   minFrequency: 80,
+ *   maxFrequency: 20000,
+ * });
+ *
+ * const results = detector.detectSignal(audioSignal, 44100);
+ *
+ * for (const result of results) {
+ *   if (result.isVoiced) {
+ *     console.log(`${result.timestamp.toFixed(3)}s: ${result.noteName} (${result.frequency.toFixed(1)} Hz)`);
+ *   }
+ * }
+ * ```
+ */
+import type { PitchResult } from './PitchDetector.js';
+/**
+ * Available Essentia pitch detection algorithms.
+ *
+ * Built-in WASM algorithms (no external model required):
+ * - `predominant_melodia`: Extracts the lead melody from polyphonic music (Recommended default)
+ * - `pitch_melodia`: Standard monophonic melody extraction
+ * - `pitch_yin_probabilistic`: WASM-accelerated pYIN (same algorithm as PitchDetector, C++ speed)
+ * - `multipitch_melodia`: Extracts multiple simultaneous F0 contours
+ * - `multipitch_klapuri`: Harmonic summation polyphonic pitch detection
+ *
+ * External model algorithm:
+ * - `pitch_crepe`: Neural network pitch detection using TensorFlow.js (requires crepeModelUrl)
+ */
+export type EssentiaPitchAlgorithm = 'predominant_melodia' | 'pitch_melodia' | 'pitch_yin_probabilistic' | 'multipitch_melodia' | 'multipitch_klapuri' | 'pitch_crepe';
+/**
+ * Unified pitch detection algorithm selection.
+ *
+ * Includes the built-in pYIN detector (`pyin_legacy`) alongside all
+ * Essentia.js WASM algorithms. Used by `PitchBeatLinker` to select
+ * which pitch detection backend to use.
+ *
+ * @default 'pitch_melodia'
+ */
+export type PitchAlgorithm = 'pyin_legacy' | EssentiaPitchAlgorithm;
+/**
+ * Configuration for the EssentiaPitchDetector.
+ */
+export interface EssentiaPitchDetectorConfig {
+    /**
+     * The pitch detection algorithm to use.
+     * @default 'pitch_melodia'
+     */
+    algorithm: EssentiaPitchAlgorithm;
+    /**
+     * Minimum frequency to detect in Hz.
+     * @default 80
+     */
+    minFrequency: number;
+    /**
+     * Maximum frequency to detect in Hz.
+     * @default 20000
+     */
+    maxFrequency: number;
+    /**
+     * Frame size in samples for analysis.
+     * Essentia algorithms typically use 2048.
+     * @default 2048
+     */
+    frameSize: number;
+    /**
+     * Hop size in samples between consecutive frames.
+     * Essentia prefers finer hop sizes (128) than pYIN's 512.
+     * @default 128
+     */
+    hopSize: number;
+    /**
+     * Target sample rate for analysis.
+     * @default 44100
+     */
+    targetSampleRate: number;
+    /**
+     * URL to the CREPE TensorFlow.js model.
+     * Only required when algorithm is 'pitch_crepe'.
+     * Omit to use DEFAULT_CREPE_MODEL_URL.
+     */
+    crepeModelUrl?: string;
+    /**
+     * Optional callback to resolve Arweave URLs before loading models.
+     * Used by the ArweaveGatewayManager to try alternate gateways on failure.
+     */
+    resolveUrl?: (url: string) => Promise<string>;
+}
+/**
+ * Default CREPE TensorFlow.js model URL.
+ *
+ * Used when `crepeModelUrl` is not explicitly provided and algorithm is 'pitch_crepe'.
+ * Update this constant when the model is deployed to Arweave.
+ */
+export declare const DEFAULT_CREPE_MODEL_URL = "https://arweave.net/_HoMwkbF0JUamTiVGWNnCCC5yDjcPry-ENhzN6Xn3U0/model.json";
+/**
+ * Pitch Detector using Essentia.js algorithms
+ *
+ * Provides access to 6 different pitch detection algorithms from Essentia.js,
+ * including industry-standard options for polyphonic music and neural networks.
+ *
+ * Uses the same `PitchResult[]` output format as `PitchDetector` for drop-in
+ * compatibility with `PitchBeatLinker`.
+ */
+export declare class EssentiaPitchDetector {
+    private config;
+    /**
+     * Essentia WASM module reference for algorithm invocation
+     * @internal
+     */
+    private essentiaWASM;
+    /**
+     * Essentia algorithms instance (EssentiaJS)
+     * @internal
+     */
+    private algorithms;
+    /**
+     * CREPE TensorFlow.js model (loaded lazily when pitch_crepe algorithm is used)
+     * @internal
+     */
+    private crepeModel;
+    /**
+     * Whether the WASM module has been initialized
+     * @internal
+     */
+    private initialized;
+    /**
+     * Cache for resolved Arweave URLs.
+     * Avoids repeated gateway resolution calls for the same URL.
+     * @internal
+     */
+    private resolvedUrlCache;
+    /**
+     * Private constructor - use static `create()` factory method instead.
+     *
+     * @param config - Detector configuration
+     */
+    private constructor();
+    /**
+     * Create a new EssentiaPitchDetector instance.
+     *
+     * This factory method handles async WASM module loading.
+     *
+     * @param config - Configuration options (partial, defaults applied)
+     * @returns Promise resolving to initialized EssentiaPitchDetector
+     *
+     * @example
+     * ```typescript
+     * const detector = await EssentiaPitchDetector.create({
+     *   algorithm: 'predominant_melodia',
+     * });
+     * ```
+     */
+    static create(config?: Partial<EssentiaPitchDetectorConfig>): Promise<EssentiaPitchDetector>;
+    /**
+     * Get the current configuration.
+     */
+    getConfig(): EssentiaPitchDetectorConfig;
+    /**
+     * Initialize the Essentia WASM module.
+     * @internal
+     */
+    private initializeEssentia;
+    /**
+     * Load the CREPE TensorFlow.js model from a URL with retry and gateway fallback.
+     * @internal
+     */
+    private loadCrepeModel;
+    /**
+     * Resolves a URL using the resolveUrl callback with caching.
+     * @internal
+     */
+    private resolveUrlWithCache;
+    /**
+     * Detect pitch in an audio signal.
+     *
+     * Processes the signal using the configured Essentia algorithm and returns
+     * pitch estimates in the same format as `PitchDetector.detectSignal()`.
+     *
+     * @param signal - Mono audio signal as Float32Array
+     * @param sampleRate - Sample rate of the signal
+     * @returns Array of pitch results, one per analysis frame
+     */
+    detectSignal(signal: Float32Array, sampleRate: number): PitchResult[];
+    /**
+     * PredominantPitchMelodia — extracts the lead melody from polyphonic music.
+     * Returns pitch + confidence per frame. Output 0 Hz for unvoiced frames.
+     * @internal
+     */
+    private runPredominantMelodia;
+    /**
+     * PitchMelodia — standard monophonic melody extraction.
+     * Returns pitch + confidence per frame. Output 0 Hz for unvoiced frames.
+     * @internal
+     */
+    private runPitchMelodia;
+    /**
+     * PitchYinProbabilistic — WASM-accelerated pYIN algorithm.
+     * Returns pitch + voicedProbabilities per frame. Negative pitch = unvoiced.
+     * @internal
+     */
+    private runPitchYinProbabilistic;
+    /**
+     * MultiPitchMelodia — multiple simultaneous F0 contours via MELODIA.
+     * Returns 2D pitch array (vector of vectors). No confidence output.
+     * @internal
+     */
+    private runMultiPitchMelodia;
+    /**
+     * MultiPitchKlapuri — harmonic summation multi-pitch detection.
+     * Returns 2D pitch array (vector of vectors). No confidence output.
+     * @internal
+     */
+    private runMultiPitchKlapuri;
+    /**
+     * CREPE pitch detection via TensorFlow.js neural network.
+     *
+     * CREPE expects 16kHz audio input with 1024-sample frames.
+     * The model outputs a 360-bin pitch distribution (10 cents per bin,
+     * covering C1 ≈ 32.7 Hz to ~2093 Hz).
+     *
+     * The signal is resampled to 16kHz internally.
+     * @internal
+     */
+    private runCrepe;
+    /**
+     * Map single-F0 algorithm output (pitch + confidence arrays) to PitchResult[].
+     * Voiced frames have freq > 0; unvoiced frames have freq == 0.
+     * @internal
+     */
+    private mapSingleF0;
+    /**
+     * Map multi-pitch algorithm output (VectorVectorFloat) to PitchResult[].
+     * Uses the lowest detected frequency as primary pitch; stores others
+     * in alternativeHypotheses. Defaults probability to 1.0 (no confidence output).
+     * @internal
+     */
+    private mapMultiPitch;
+    /**
+     * Resample a signal from one sample rate to another using linear interpolation.
+     * @internal
+     */
+    private resampleSignal;
+    /**
+     * Convert frequency in Hz to MIDI note number.
+     * @internal
+     */
+    private frequencyToMidi;
+    /**
+     * Convert MIDI note number to note name (e.g., "C4", "F#5").
+     * @internal
+     */
+    private midiToNoteName;
+}
+//# sourceMappingURL=EssentiaPitchDetector.d.ts.map

package/dist/core/analysis/EssentiaPitchDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EssentiaPitchDetector.d.ts","sourceRoot":"","sources":["../../../src/core/analysis/EssentiaPitchDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAQtD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,sBAAsB,GAC5B,qBAAqB,GACrB,eAAe,GACf,yBAAyB,GACzB,oBAAoB,GACpB,oBAAoB,GACpB,aAAa,CAAC;AAEpB;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,sBAAsB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,2BAA2B;IACxC;;;OAGG;IACH,SAAS,EAAE,sBAAsB,CAAC;IAElC;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACjD;AAMD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,+EAA+E,CAAC;AA4BpH;;;;;;;;GAQG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAA8B;IAE5C;;;OAGG;IAEH,OAAO,CAAC,YAAY,CAAa;IAEjC;;;OAGG;IAEH,OAAO,CAAC,UAAU,CAAa;IAE/B;;;OAGG;IAEH,OAAO,CAAC,UAAU,CAAa;IAE/B;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAkB;IAErC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAAkC;IAE1D;;;;OAIG;IACH,OAAO;IAIP;;;;;;;;;;;;;;OAcG;WACU,MAAM,CACf,MAAM,GAAE,OAAO,CAAC,2BAA2B,CAAM,GAClD,OAAO,CAAC,qBAAqB,CAAC;IAqBjC;;OAEG;IACH,SAAS,IAAI,2BAA2B;IAIxC;;;OAGG;YACW,kBAAkB;IAehC;;;OAGG;YACW,cAAc;IAmC5B;;;OAGG;YACW,mBAAmB;IA2BjC;;;;;;;;;OASG;IACH,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,EAAE;IA+BrE;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAiC7B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IA+BvB;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IA+ChC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IA2B5B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAwB5B;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ;IA4FhB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IA+BnB;;;;;OAKG;IAEH,OAAO,CAAC,aAAa;IAkDrB;;;OAGG;IACH,OAAO,CAAC,cAAc;IA0BtB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAIvB;;;OAGG;IACH,OAAO,CAAC,cAAc;CAKzB"}

package/dist/core/analysis/LevelSerializer.d.ts

@@ -0,0 +1,265 @@
+/**
+ * Level Serializer - Converts GeneratedLevel to/from export formats
+ *
+ * This class provides serialization and deserialization for procedurally
+ * generated rhythm game levels. It converts between the engine's internal
+ * GeneratedLevel format and the FullBeatMapExportData format that is
+ * compatible with the playlist-data-showcase app.
+ *
+ * Part of the Pitch Detection & Button Mapping pipeline - Phase 4.2.2
+ *
+ * @example
+ * ```typescript
+ * // Export a generated level
+ * const exportData = LevelSerializer.toExportData(generatedLevel);
+ * const json = LevelSerializer.toJSON(generatedLevel);
+ *
+ * // Import a level
+ * const level = LevelSerializer.fromJSON(json);
+ * const level2 = LevelSerializer.fromExportData(exportData);
+ *
+ * // Validate before import
+ * const result = LevelSerializer.validate(unknownData);
+ * if (result.success) {
+ *   const level = LevelSerializer.fromExportData(result.data!);
+ * }
+ * ```
+ */
+import type { GeneratedLevel } from '../generation/LevelGenerator.js';
+import type { FullBeatMapExportData, FullBeatMapImportResult, TrackReference, LevelPackExport } from '../types/LevelExport.js';
+/**
+ * Options for serialization
+ */
+export interface LevelSerializerOptions {
+    /** Include audio title in export (default: false) */
+    includeAudioTitle?: boolean;
+    /** Audio title to include */
+    audioTitle?: string;
+    /** Track reference identifying the song this level was built for */
+    trackReference?: TrackReference;
+}
+/**
+ * Serializer for rhythm game levels
+ *
+ * Converts between GeneratedLevel (engine internal) and FullBeatMapExportData
+ * (export format compatible with playlist-data-showcase app).
+ *
+ * All methods are static - this is a utility class without state.
+ */
+export declare class LevelSerializer {
+    /**
+     * Convert a GeneratedLevel to FullBeatMapExportData format
+     *
+     * @param level - The generated level to export
+     * @param options - Optional serialization options
+     * @returns The export data ready for JSON serialization
+     */
+    static toExportData(level: GeneratedLevel, options?: LevelSerializerOptions): FullBeatMapExportData;
+    /**
+     * Build detected beats array from chart
+     */
+    private static buildDetectedBeats;
+    /**
+     * Build merged beats array from chart
+     */
+    private static buildMergedBeats;
+    /**
+     * Build interpolated metadata from chart
+     */
+    private static buildInterpolatedMetadata;
+    /**
+     * Build subdivision data from chart
+     */
+    private static buildSubdivisionData;
+    /**
+     * Convert a ChartedBeat to export format
+     */
+    private static chartedBeatToExportBeat;
+    /**
+     * Build chart export data from metadata
+     *
+     * Returns null if there are no key assignments (chart is null case)
+     */
+    private static buildChartExportData;
+    /**
+     * Build procedural generation metadata
+     */
+    private static buildGenerationMetadata;
+    /**
+     * Convert FullBeatMapExportData to GeneratedLevel
+     *
+     * Note: The import creates a minimal but functional GeneratedLevel.
+     * Some data (like original rhythm analysis) cannot be fully reconstructed
+     * from the export format.
+     *
+     * @param data - The export data to import
+     * @returns The reconstructed GeneratedLevel
+     */
+    static fromExportData(data: FullBeatMapExportData): GeneratedLevel;
+    /**
+     * Reconstruct ChartedBeatMap from export data
+     *
+     * Handles two cases:
+     * 1. Normal case: subdivision data exists, use it for beats
+     * 2. Edge case: subdivision is null, create beats from mergedBeats (interpolated only)
+     */
+    private static reconstructChart;
+    /**
+     * Reconstruct ChartedBeatMap from mergedBeats when subdivision is null
+     *
+     * This handles the edge case where a level has only interpolated beats
+     * without any subdivision applied. We create ChartedBeats from mergedBeats.
+     */
+    private static reconstructChartFromMergedBeats;
+    /**
+     * Reconstruct downbeat config from beats (using segments format)
+     */
+    private static reconstructDownbeatConfig;
+    /**
+     * Reconstruct chart metadata from export data
+     */
+    private static reconstructChartMetadata;
+    /**
+     * Parse difficulty level from string
+     */
+    private static parseDifficultyLevel;
+    /**
+     * Parse difficulty preset from string
+     */
+    private static parseDifficultyPreset;
+    /**
+     * Reconstruct difficulty variant from export data
+     */
+    private static reconstructVariant;
+    /**
+     * Convert SubdivisionType to GridType
+     */
+    private static subdivisionTypeToGridType;
+    /**
+     * Reconstruct minimal GeneratedRhythm from export data
+     */
+    private static reconstructRhythm;
+    /**
+     * Build full RhythmMetadata for reconstructed rhythm
+     */
+    private static buildFullRhythmMetadata;
+    /**
+     * Build minimal MelodyContour
+     */
+    private static buildMinimalMelodyContour;
+    /**
+     * Reconstruct pitch analysis from export data
+     */
+    private static reconstructPitchAnalysis;
+    /**
+     * Reconstruct level metadata from export data
+     */
+    private static reconstructMetadata;
+    /**
+     * Serialize a GeneratedLevel to JSON string
+     *
+     * @param level - The level to serialize
+     * @param options - Optional serialization options
+     * @returns JSON string
+     */
+    static toJSON(level: GeneratedLevel, options?: LevelSerializerOptions): string;
+    /**
+     * Deserialize a GeneratedLevel from JSON string
+     *
+     * @param json - The JSON string to parse
+     * @returns The deserialized GeneratedLevel
+     * @throws {Error} If the JSON is invalid or doesn't match expected format
+     */
+    static fromJSON(json: string): GeneratedLevel;
+    /**
+     * Save a GeneratedLevel to a file (Node.js only)
+     *
+     * @param level - The level to save
+     * @param filePath - Path to save the file
+     * @param options - Optional serialization options
+     * @throws {Error} If file cannot be written
+     */
+    static saveToFile(level: GeneratedLevel, filePath: string, options?: LevelSerializerOptions): Promise<void>;
+    /**
+     * Load a GeneratedLevel from a file (Node.js only)
+     *
+     * @param filePath - Path to load the file from
+     * @returns The loaded GeneratedLevel
+     * @throws {Error} If file cannot be read or parsed
+     */
+    static loadFromFile(filePath: string): Promise<GeneratedLevel>;
+    /**
+     * Validate unknown data as FullBeatMapExportData
+     *
+     * @param data - Unknown data to validate
+     * @returns Validation result with data if successful
+     */
+    static validate(data: unknown): FullBeatMapImportResult;
+    /**
+     * Serialize multiple difficulty levels into a LevelPackExport.
+     *
+     * Each difficulty is independently serialized as a FullBeatMapExportData.
+     * The pack-level trackReference is shared across all difficulties.
+     *
+     * @param levels - Map of difficulty key to GeneratedLevel
+     * @param options - Serialization options (trackReference applied at pack level)
+     * @returns The level pack ready for JSON serialization
+     */
+    static toPack(levels: {
+        natural?: GeneratedLevel;
+        easy?: GeneratedLevel;
+        medium?: GeneratedLevel;
+        hard?: GeneratedLevel;
+        custom?: GeneratedLevel;
+    }, options?: LevelSerializerOptions): LevelPackExport;
+    /**
+     * Deserialize a LevelPackExport into individual GeneratedLevels.
+     *
+     * @param pack - The level pack to deserialize
+     * @returns Map of difficulty key to GeneratedLevel (only entries that existed in the pack)
+     */
+    static fromPack(pack: LevelPackExport): {
+        natural?: GeneratedLevel;
+        easy?: GeneratedLevel;
+        medium?: GeneratedLevel;
+        hard?: GeneratedLevel;
+        custom?: GeneratedLevel;
+    };
+    /**
+     * Convert a LevelPackExport to JSON string.
+     */
+    static packToJSON(levels: {
+        natural?: GeneratedLevel;
+        easy?: GeneratedLevel;
+        medium?: GeneratedLevel;
+        hard?: GeneratedLevel;
+        custom?: GeneratedLevel;
+    }, options?: LevelSerializerOptions): string;
+    /**
+     * Parse a JSON string as a LevelPackExport and return the GeneratedLevels.
+     *
+     * @throws {Error} If the JSON is invalid or doesn't match the pack format
+     */
+    static packFromJSON(json: string): {
+        natural?: GeneratedLevel;
+        easy?: GeneratedLevel;
+        medium?: GeneratedLevel;
+        hard?: GeneratedLevel;
+        custom?: GeneratedLevel;
+    };
+    /**
+     * Check if data represents a procedurally generated level
+     *
+     * @param data - Export data to check
+     * @returns True if the level was procedurally generated
+     */
+    static isProcedural(data: FullBeatMapExportData): boolean;
+    /**
+     * Get a summary of the level for display purposes
+     *
+     * @param data - Export data to summarize
+     * @returns Human-readable summary
+     */
+    static getSummary(data: FullBeatMapExportData): string;
+}
+//# sourceMappingURL=LevelSerializer.d.ts.map

package/dist/core/analysis/LevelSerializer.d.ts.map

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