playlist-data-engine 1.1.0

package/dist/core/analysis/beat/DifficultyVariantGenerator.d.ts.map

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

package/dist/core/analysis/beat/GrooveAnalyzer.d.ts

@@ -0,0 +1,192 @@
+/**
+ * GrooveAnalyzer - A "groove meter" system for rhythm games
+ *
+ * Rewards consistency in timing feel rather than proximity to perfect center.
+ * Inspired by Devil May Cry's style meter - it's not about being mechanically
+ * perfect, it's about establishing and maintaining a consistent "pocket."
+ *
+ * Core Philosophy:
+ * - Hitting consistently 30ms behind the beat = GOOD (you're in a pocket)
+ * - Hitting perfectly on beat after establishing a behind-beat pocket = BAD (you broke the feel)
+ * - The meter charges when you maintain consistency to YOUR established pocket,
+ *   not to absolute perfection
+ */
+import type { GrooveResult, GrooveState, GrooveAnalyzerOptions, BeatAccuracy, DifficultyPreset, GroovePenaltyConfig } from '../../types/BeatMap.js';
+import type { GrooveStats } from '../../types/RhythmXP.js';
+/**
+ * Analyzes groove/feel consistency in rhythm game play
+ *
+ * The GrooveAnalyzer tracks timing patterns and rewards players for maintaining
+ * a consistent "pocket" - whether that's ahead of the beat (push), behind (pull),
+ * or centered (neutral).
+ *
+ * @example
+ * ```typescript
+ * const grooveAnalyzer = new GrooveAnalyzer();
+ *
+ * // On each button press during gameplay
+ * const buttonResult = beatStream.checkButtonPress(timestamp);
+ * const grooveResult = grooveAnalyzer.recordHit(buttonResult.offset, beatStream.getCurrentBpm());
+ *
+ * // When user misses a beat (doesn't press)
+ * grooveAnalyzer.recordMiss();
+ *
+ * // Read the groove state for UI display
+ * if (grooveResult.pocketDirection !== 'neutral') {
+ *   console.log(`${grooveResult.pocketDirection} groove: ${grooveResult.hotness}%`);
+ * }
+ * ```
+ */
+export declare class GrooveAnalyzer {
+    private options;
+    private recentOffsets;
+    private establishedOffset;
+    private pocketDirection;
+    private hotness;
+    private streakLength;
+    private hitCount;
+    private lastBpm;
+    private grooveStartTime;
+    private maxHotness;
+    private maxGrooveStreak;
+    private hotnessSamples;
+    private grooveHitCount;
+    private previousDirection;
+    /**
+     * Create a new GrooveAnalyzer instance
+     *
+     * @param options - Optional configuration to customize groove analysis behavior
+     */
+    constructor(options?: Partial<GrooveAnalyzerOptions>);
+    /**
+     * Set difficulty level for groove penalties.
+     *
+     * Updates the penalty values (hotnessLossOnMiss, hotnessLossOnBreak) based on
+     * a difficulty preset. This allows dynamic difficulty changes during gameplay.
+     *
+     * @param options - Difficulty configuration
+     * @param options.preset - The difficulty preset ('easy', 'medium', 'hard', or 'custom')
+     * @param options.customPenalties - Custom penalties to use when preset is 'custom'
+     *
+     * @example
+     * ```typescript
+     * // Set to hard difficulty
+     * grooveAnalyzer.setDifficulty({ preset: 'hard' });
+     *
+     * // Set to custom difficulty with specific penalty values
+     * grooveAnalyzer.setDifficulty({
+     *     preset: 'custom',
+     *     customPenalties: { hotnessLossOnMiss: 30, hotnessLossOnBreak: 25 }
+     * });
+     * ```
+     */
+    setDifficulty(options: {
+        preset: DifficultyPreset;
+        customPenalties?: Partial<GroovePenaltyConfig>;
+    }): void;
+    /**
+     * Record a button press hit and get groove analysis
+     *
+     * This is the main method called after each button press during gameplay.
+     * It updates the pocket tracking, calculates consistency, and adjusts hotness.
+     *
+     * IMPORTANT: When accuracy is 'miss' or 'wrongKey', this method will:
+     * - NOT update the pocket tracking (the offset is not valid for groove)
+     * - Decrease hotness by hotnessLossOnMiss
+     * - Reset the streak
+     * - Return inPocket: false
+     *
+     * This ensures that missed beats and wrong key presses hurt the groove score
+     * rather than contributing to it.
+     *
+     * @param offset - Timing offset in seconds (negative = early/push, positive = late/pull)
+     * @param bpm - Current BPM of the song (used for BPM-aware window calculation)
+     * @param currentTime - Current audio time for groove duration tracking (use buttonResult.matchedBeat.time)
+     * @param accuracy - Accuracy level from BeatStream.checkButtonPress(). When 'miss' or 'wrongKey', treats as a miss.
+     * @returns GrooveResult with current groove state and hit analysis
+     */
+    recordHit(offset: number, bpm: number, currentTime?: number, accuracy?: BeatAccuracy): GrooveResult;
+    /**
+     * Record a missed beat (user didn't press)
+     *
+     * Reduces hotness by configured miss penalty (default: 10).
+     * Resets streak but does NOT clear the established pocket.
+     * Captures endedGrooveStats if the miss ends the groove (hotness drops to 0).
+     *
+     * @param currentTime - Current audio time for groove duration tracking (optional)
+     * @returns GrooveResult representing current state after miss
+     */
+    recordMiss(currentTime?: number): GrooveResult;
+    /**
+     * Get current groove analyzer state snapshot
+     *
+     * @returns GrooveState with all current values including lifetime statistics
+     */
+    getState(): GrooveState;
+    /**
+     * Reset the analyzer to initial state
+     *
+     * Clears all tracking data including established pocket,
+     * hotness, streak, and hit count.
+     */
+    reset(): void;
+    /**
+     * Get groove statistics for end bonus calculation.
+     * Call this when hotness drops to 0 or at session end.
+     *
+     * @param currentAudioTime - Current audio time for duration calculation (defaults to hitCount-based estimation)
+     * @returns GrooveStats or null if no groove was active
+     */
+    getGrooveStats(currentAudioTime?: number): GrooveStats | null;
+    /**
+     * Reset groove lifetime tracking.
+     * Called internally when hotness drops to 0 or direction changes.
+     * Can also be called externally to force a reset (e.g., at session end).
+     */
+    resetGrooveStats(): void;
+    /**
+     * Check if a pocket has been established
+     *
+     * A pocket is established after minHitsForPocket consistent hits.
+     *
+     * @returns true if pocket is established
+     */
+    private hasPocket;
+    /**
+     * Calculate the current pocket window size
+     *
+     * Uses tier-based window sizes with BPM scaling.
+     * Window shrinks as you climb tiers (D → C → B → A → S → SS).
+     *
+     * @param bpm - Current BPM
+     * @returns Pocket window size in seconds
+     */
+    private calculatePocketWindow;
+    /**
+     * Update the running average of recent offsets
+     *
+     * Uses simple moving average of recent hits within the averaging window.
+     */
+    private updateRunningAverage;
+    /**
+     * Calculate consistency score using quadratic falloff
+     *
+     * Returns 1.0 at pocket center, 0.0 at or beyond window edge.
+     * Uses quadratic falloff for more forgiving feel near center.
+     *
+     * @param distanceFromPocket - Absolute distance from pocket center in seconds
+     * @param pocketWindow - Current pocket window size in seconds
+     * @returns Consistency score (0.0 - 1.0)
+     */
+    private calculateConsistency;
+    /**
+     * Determine groove direction from offset
+     *
+     * Uses configurable dead zone (±10ms by default = 20ms total) for neutral classification.
+     *
+     * @param offset - Timing offset in seconds
+     * @returns GrooveDirection ('push', 'pull', or 'neutral')
+     */
+    private determineDirection;
+}
+//# sourceMappingURL=GrooveAnalyzer.d.ts.map

package/dist/core/analysis/beat/GrooveAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrooveAnalyzer.d.ts","sourceRoot":"","sources":["../../../../src/core/analysis/beat/GrooveAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAER,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EAEtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAQ3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,OAAO,CAAe;IAG9B,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,iBAAiB,CAA8B;IAEvD;;;;OAIG;gBACS,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC;IAIpD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,aAAa,CAAC,OAAO,EAAE;QACnB,MAAM,EAAE,gBAAgB,CAAC;QACzB,eAAe,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;KAClD,GAAG,IAAI;IAMR;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,GAAE,MAAU,EAAE,QAAQ,GAAE,YAAwB,GAAG,YAAY;IAyHjH;;;;;;;;;OASG;IACH,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY;IAgD9C;;;;OAIG;IACH,QAAQ,IAAI,WAAW;IAuBvB;;;;;OAKG;IACH,KAAK,IAAI,IAAI;IAWb;;;;;;OAMG;IACH,cAAc,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAqB7D;;;;OAIG;IACH,gBAAgB,IAAI,IAAI;IAQxB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAIjB;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAK5B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;CAI7B"}

package/dist/core/analysis/beat/OnsetStrengthEnvelope.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Onset Strength Envelope (OSE) Calculator
+ *
+ * Implements the perceptual onset strength envelope extraction as described in
+ * Ellis, D.P.W. (2007) "Beat Tracking by Dynamic Programming"
+ *
+ * The onset strength envelope is a time series that peaks at moments where
+ * new sonic events (notes, drum hits, etc.) are likely to occur. This is
+ * the foundation for the Ellis beat tracking algorithm.
+ *
+ * Reference: https://www.ee.columbia.edu/~dpwe/pubs/Ellis07-beattrack.pdf
+ */
+import type { OSEConfig } from '../../types/BeatMap.js';
+/**
+ * Result of onset strength envelope calculation
+ */
+export interface OSEResult {
+    /** Onset strength envelope values (one per frame) */
+    envelope: Float32Array;
+    /** Number of frames */
+    numFrames: number;
+    /** Hop size in seconds */
+    hopSizeSeconds: number;
+    /** Effective sample rate after resampling */
+    effectiveSampleRate: number;
+    /** Original audio duration in seconds */
+    duration: number;
+}
+/**
+ * Onset Strength Envelope Calculator
+ *
+ * Calculates the perceptual onset strength envelope from audio,
+ * following the Ellis 2007 algorithm.
+ *
+ * @example
+ * ```typescript
+ * const ose = new OnsetStrengthEnvelope({
+ *   targetSampleRate: 8000,
+ *   melBands: 40,
+ * });
+ *
+ * const result = ose.calculate(audioBuffer);
+ * // result.envelope contains the onset strength values
+ * // Peaks in the envelope correspond to likely beat positions
+ * ```
+ */
+export declare class OnsetStrengthEnvelope {
+    private config;
+    /**
+     * Create a new Onset Strength Envelope calculator
+     *
+     * ## Configuration Options
+     *
+     * OSE parameters can be configured using either mode-based configs or direct numeric values.
+     *
+     * **Precedence**: When both mode and direct value are provided, mode takes precedence.
+     * For example, if both `hopSizeMode` and `hopSizeMs` are set, `hopSizeMode` wins.
+     *
+     * @param config - Configuration options (all optional, defaults provided)
+     *
+     * @example
+     * ```typescript
+     * // Using mode-based configuration (recommended)
+     * const ose = new OnsetStrengthEnvelope({
+     *   hopSizeMode: { mode: 'standard' },     // 4ms (Ellis 2007 paper spec)
+     *   melBandsMode: { mode: 'detailed' },    // 64 bands
+     *   gaussianSmoothMode: { mode: 'smooth' } // 40ms
+     * });
+     *
+     * // Using direct numeric values (backward compatible)
+     * const ose = new OnsetStrengthEnvelope({
+     *   hopSizeMs: 4,
+     *   melBands: 40,
+     *   gaussianSmoothMs: 20
+     * });
+     *
+     * // Mixed - mode takes precedence (hopSizeMs is ignored)
+     * const ose = new OnsetStrengthEnvelope({
+     *   hopSizeMode: { mode: 'hq' },  // Uses 2ms
+     *   hopSizeMs: 10                  // Ignored because hopSizeMode is set
+     * });
+     * ```
+     */
+    constructor(config?: OSEConfig);
+    /**
+     * Calculate the onset strength envelope from an audio buffer
+     *
+     * Implements the Ellis algorithm:
+     * 1. Resample to 8kHz (reduces computation, focuses on beat-relevant frequencies)
+     * 2. Compute Mel spectrogram using STFT
+     * 3. Convert to dB, take first-order difference, half-wave rectify
+     * 4. Sum across Mel bands to get onset strength
+     * 5. Apply high-pass filter (removes DC)
+     * 6. Smooth with Gaussian window
+     * 7. Normalize by standard deviation (critical for DP balance)
+     *
+     * @param audioBuffer - Web Audio API AudioBuffer to analyze
+     * @returns Onset strength envelope result
+     */
+    calculate(audioBuffer: AudioBuffer): OSEResult;
+    /**
+     * Get the current configuration
+     *
+     * @returns The current configuration
+     */
+    getConfig(): Required<OSEConfig>;
+    /**
+     * Find peaks in the onset strength envelope
+     * Useful for debugging and visualization
+     *
+     * @param envelope - Onset strength envelope
+     * @param threshold - Minimum peak height (default: 0.5)
+     * @returns Array of frame indices where peaks occur
+     */
+    findPeaks(envelope: Float32Array, threshold?: number): number[];
+    /**
+     * Convert frame index to time in seconds
+     *
+     * @param frameIndex - Frame index
+     * @param hopSizeSeconds - Hop size in seconds
+     * @returns Time in seconds
+     */
+    frameToTime(frameIndex: number, hopSizeSeconds: number): number;
+    /**
+     * Convert time in seconds to frame index
+     *
+     * @param time - Time in seconds
+     * @param hopSizeSeconds - Hop size in seconds
+     * @returns Frame index (rounded)
+     */
+    timeToFrame(time: number, hopSizeSeconds: number): number;
+}
+//# sourceMappingURL=OnsetStrengthEnvelope.d.ts.map

package/dist/core/analysis/beat/OnsetStrengthEnvelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnsetStrengthEnvelope.d.ts","sourceRoot":"","sources":["../../../../src/core/analysis/beat/OnsetStrengthEnvelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACR,SAAS,EAIZ,MAAM,wBAAwB,CAAC;AA8BhC;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,qDAAqD;IACrD,QAAQ,EAAE,YAAY,CAAC;IACvB,uBAAuB;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,6CAA6C;IAC7C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAAsB;IAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;gBACS,MAAM,GAAE,SAAc;IA0BlC;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS;IAmH9C;;;;OAIG;IACH,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC;IAIhC;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,EAAE,YAAY,EAAE,SAAS,GAAE,MAAY,GAAG,MAAM,EAAE;IAepE;;;;;;OAMG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;IAI/D;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;CAG5D"}

package/dist/core/analysis/beat/PhraseAnalyzer.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Phrase Analyzer for Procedural Rhythm Generation
+ *
+ * Analyzes quantized rhythm streams to detect duplicate multi-beat phrases.
+ * These detected phrases form a song-specific pattern library used for:
+ * - Density enhancement (prefer inserting detected patterns over interpolation)
+ * - Pitch detection integration (via sourceBand and timestamps)
+ *
+ * Part of the Procedural Rhythm Generation pipeline - Phase 2.1
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - analyze phrases in quantized streams
+ * const analyzer = new PhraseAnalyzer();
+ * const result = analyzer.analyze(quantizedBandStreams);
+ *
+ * // Access all detected phrases
+ * console.log(`Found ${result.phrases.length} unique phrases`);
+ *
+ * // Get the most significant phrases (best patterns to reuse)
+ * for (const phrase of result.mostSignificantPhrases) {
+ *   console.log(`Phrase: ${phrase.sizeInBeats} beats, ${phrase.occurrences.length} occurrences`);
+ *   console.log(`  Source band: ${phrase.sourceBand}`);
+ *   console.log(`  Significance: ${phrase.significance.toFixed(2)}`);
+ * }
+ *
+ * // Access phrases by band for targeted analysis
+ * const lowBandPhrases = result.phrasesByBand.get('low');
+ * ```
+ */
+import type { GeneratedBeat, GeneratedRhythmMap } from './RhythmQuantizer.js';
+/**
+ * A single occurrence of a rhythmic phrase within the song
+ */
+export interface PhraseOccurrence {
+    /** Index into UnifiedBeatMap.beats[] where this occurrence starts */
+    beatIndex: number;
+    /** Start time in seconds (for pitch analysis reference) */
+    startTimestamp: number;
+    /** End time in seconds (for pitch analysis reference) */
+    endTimestamp: number;
+}
+/**
+ * A detected rhythmic phrase with all its occurrences
+ */
+export interface RhythmicPhrase {
+    /** Unique identifier for this phrase (hash of pattern) */
+    id: string;
+    /** The actual rhythm pattern (array of GeneratedBeat, relative to phrase start) */
+    pattern: GeneratedBeat[];
+    /** Size in beats: 1, 2, 4, or 8 */
+    sizeInBeats: number;
+    /** Which frequency band this phrase was detected in */
+    sourceBand: 'low' | 'mid' | 'high';
+    /** All locations where this pattern occurs */
+    occurrences: PhraseOccurrence[];
+    /** Weighted significance score (larger size + more occurrences = higher) */
+    significance: number;
+    /** Whether the pattern has rhythmic variation (excludes straight quarters/eighths) */
+    hasVariation: boolean;
+    /** Whether this phrase can be inserted elsewhere for density enhancement */
+    availableForReuse: boolean;
+}
+/**
+ * Result of phrase analysis for a single band
+ */
+export interface BandPhraseAnalysis {
+    /** Band name */
+    band: 'low' | 'mid' | 'high';
+    /** All phrases detected in this band */
+    phrases: RhythmicPhrase[];
+    /** Phrases grouped by size (1, 2, 4, 8 beats) */
+    phrasesBySize: Map<number, RhythmicPhrase[]>;
+    /** Phrases that have variation (excludes straight quarters/eighths) */
+    phrasesWithVariation: RhythmicPhrase[];
+}
+/**
+ * Complete phrase analysis result for all bands
+ */
+export interface PhraseAnalysisResult {
+    /** All phrases across all bands */
+    phrases: RhythmicPhrase[];
+    /** Phrases grouped by source band */
+    phrasesByBand: Map<'low' | 'mid' | 'high', RhythmicPhrase[]>;
+    /** Top N phrases by significance score */
+    mostSignificantPhrases: RhythmicPhrase[];
+    /** Phrases grouped by size (1, 2, 4, 8 beats) */
+    phrasesBySize: Map<number, RhythmicPhrase[]>;
+    /** Phrases available for density enhancement (hasVariation && availableForReuse) */
+    patternLibrary: RhythmicPhrase[];
+    /** Per-band analysis details */
+    bandAnalysis: {
+        low: BandPhraseAnalysis;
+        mid: BandPhraseAnalysis;
+        high: BandPhraseAnalysis;
+    };
+}
+/**
+ * Configuration for phrase analysis
+ */
+export interface PhraseAnalyzerConfig {
+    /** Phrase sizes to check (in beats). Default: [1, 2, 4, 8] */
+    phraseSizes: number[];
+    /** Minimum number of occurrences for a phrase to be considered significant. Default: 3 */
+    minOccurrences: number;
+    /** Number of top significant phrases to include in mostSignificantPhrases. Default: 10 */
+    topSignificantCount: number;
+    /** Whether to include phrases without variation in results. Default: false */
+    includePhrasesWithoutVariation: boolean;
+    /**
+     * Minimum number of notes a phrase pattern must contain.
+     * Can be a static number or a function of phrase size in beats.
+     * Default: (sizeInBeats) => 1 + sizeInBeats
+     *
+     * Examples:
+     * - 1-beat phrase needs ≥2 notes
+     * - 2-beat phrase needs ≥3 notes
+     * - 4-beat phrase needs ≥5 notes
+     */
+    minNotesPerPhrase?: number | ((sizeInBeats: number) => number);
+}
+/**
+ * Analyzes quantized rhythm streams to detect duplicate multi-beat phrases.
+ *
+ * ## Algorithm Overview
+ *
+ * 1. For each band (low/mid/high) and each phrase size (1/2/4/8 beats):
+ *    - Extract all phrases of that size from the stream
+ *    - Normalize the phrases (reset beatIndex to 0, preserve gridPosition)
+ *    - Create a hash of each normalized pattern
+ *    - Group identical patterns by hash
+ *
+ * 2. Filter out uninteresting patterns:
+ *    - Straight quarter notes (single note at gridPosition 0, straight_16th)
+ *    - Straight eighth notes (notes at gridPosition 0 and 2 only, straight_16th)
+ *
+ * 3. Calculate significance scores:
+ *    - Larger phrases are more significant (8-beat > 1-beat)
+ *    - More occurrences increases significance
+ *    - Significance = sizeWeight * occurrenceWeight
+ *
+ * 4. Build pattern library for density enhancement
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const analyzer = new PhraseAnalyzer();
+ * const result = analyzer.analyze(quantizedStreams);
+ *
+ * // Access pattern library for density enhancement
+ * const patterns = result.patternLibrary;
+ *
+ * // Find phrases for a specific band
+ * const lowBandPhrases = result.phrasesByBand.get('low');
+ *
+ * // Get top significant phrases
+ * const topPhrases = result.mostSignificantPhrases;
+ * ```
+ */
+export declare class PhraseAnalyzer {
+    private config;
+    constructor(config?: Partial<PhraseAnalyzerConfig>);
+    /**
+     * Analyze quantized band streams for rhythmic phrases
+     *
+     * @param streams - Quantized band streams from RhythmQuantizer
+     * @returns Complete phrase analysis result
+     */
+    analyze(streams: {
+        low: GeneratedRhythmMap;
+        mid: GeneratedRhythmMap;
+        high: GeneratedRhythmMap;
+    }): PhraseAnalysisResult;
+    /**
+     * Resolve the minimum notes required for a given phrase size
+     */
+    private getMinNotes;
+    /**
+     * Analyze a single band for phrases
+     */
+    private analyzeBand;
+    /**
+     * Extract a phrase candidate starting at a given beat index
+     */
+    private extractPhraseCandidate;
+    /**
+     * Create a hash of a pattern for comparison
+     *
+     * The hash includes:
+     * - Beat indices (relative to phrase start)
+     * - Grid positions
+     * - Grid types
+     *
+     * NOTE: Intensity is deliberately excluded from the hash. Identical rhythms
+     * with different intensities should be recognized as the same pattern.
+     * Intensity varies naturally between occurrences of the same rhythm.
+     */
+    private hashPattern;
+    /**
+     * Check if a pattern has rhythmic variation
+     *
+     * Uninteresting patterns (excluded):
+     * - Straight quarter notes: single note at beat 0, gridPosition 0, straight_16th
+     * - Straight eighth notes: notes at gridPosition 0 and 2 only, straight_16th
+     *
+     * Interesting patterns (included):
+     * - Any pattern with gridPosition 1 or 3 (16th note subdivisions)
+     * - Any pattern with triplet grid
+     * - Any pattern with varying intensity
+     * - Any syncopated pattern
+     */
+    private hasPatternVariation;
+    /**
+     * Count how many beats have exactly the specified note count
+     */
+    private countBeatsWithNoteCount;
+    /**
+     * Calculate significance score for a phrase
+     *
+     * Significance is weighted by:
+     * - Size: Larger phrases are more significant (8-beat > 1-beat)
+     * - Occurrences: More occurrences increases significance
+     *
+     * Formula: significance = sizeWeight * occurrenceWeight
+     * - sizeWeight = sizeInBeats (linear weight)
+     * - occurrenceWeight = log2(occurrences) (logarithmic to avoid over-weighting)
+     */
+    private calculateSignificance;
+}
+//# sourceMappingURL=PhraseAnalyzer.d.ts.map

package/dist/core/analysis/beat/PhraseAnalyzer.d.ts.map

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