playlist-data-engine 1.1.0

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

@@ -0,0 +1,180 @@
+/**
+ * Composite Stream Generator for Procedural Rhythm Generation
+ *
+ * Creates a single composite stream by slicing together the highest-scoring sections
+ * from each band stream.
+ *
+ * Part of the Procedural Rhythm Generation pipeline - Phase 3.2
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - generate composite from scored streams
+ * const generator = new CompositeStreamGenerator();
+ * const composite = generator.generate(quantizedBandStreams, scoringResult, densityAnalysis);
+ *
+ * // Access the composite beats
+ * console.log(`Total beats: ${composite.beats.length}`);
+ * console.log(`Natural difficulty: ${composite.naturalDifficulty}`);
+ *
+ * // Check which band contributed to each section
+ * for (const section of composite.sections) {
+ *   console.log(`Beats ${section.beatRange.start}-${section.beatRange.end}: ${section.sourceBand}`);
+ *   console.log(`  Score: ${section.score.toFixed(2)}, margin: ${section.margin.toFixed(2)}`);
+ * }
+ *
+ * // Check band contribution statistics
+ * console.log('Beats per band:', composite.metadata.beatsPerBand);
+ * console.log('Sections per band:', composite.metadata.sectionsPerBand);
+ * ```
+ */
+import type { GeneratedBeat, QuantizedBandStreams } from './RhythmQuantizer.js';
+import type { StreamScoringResult, Band } from './StreamScorer.js';
+import type { DensityAnalysisResult, NaturalDifficulty } from './DensityAnalyzer.js';
+/**
+ * A section of the composite stream contributed by a single band
+ */
+export interface CompositeSection {
+    /** Beat range for this section */
+    beatRange: {
+        start: number;
+        end: number;
+    };
+    /** Which band contributed this section */
+    sourceBand: Band;
+    /** The winning score for this section */
+    score: number;
+    /** Margin of victory over the runner-up band */
+    margin: number;
+}
+/**
+ * A beat in the composite stream with additional metadata about its source
+ */
+export interface CompositeBeat extends GeneratedBeat {
+    /** Which band this beat originated from */
+    sourceBand: Band;
+    /**
+     * What action the RhythmicBalancer took on this beat, if any.
+     * undefined = balancer did not modify this beat.
+     * Set during the balance() step.
+     */
+    balancerAction?: 'shifted_to_downbeat' | 'empty_measure_fill' | 'proximity_shift';
+}
+/**
+ * Complete composite stream result
+ */
+export interface CompositeStream {
+    /** The composite beat stream (all beats combined from winning sections) */
+    beats: CompositeBeat[];
+    /** Sections showing which band contributed to each part */
+    sections: CompositeSection[];
+    /** Natural difficulty determined by density analysis of the composite */
+    naturalDifficulty: NaturalDifficulty;
+    /** Duration of a quarter note in seconds (derived from beat map) */
+    quarterNoteInterval: number;
+    /** Metadata about the composite generation */
+    metadata: {
+        /** Total number of beats in the composite */
+        totalBeats: number;
+        /** Number of sections */
+        sectionCount: number;
+        /** Count of beats contributed by each band */
+        beatsPerBand: {
+            low: number;
+            mid: number;
+            high: number;
+        };
+        /** Percentage of sections won by each band */
+        sectionsPerBand: {
+            low: number;
+            mid: number;
+            high: number;
+        };
+    };
+}
+/**
+ * Configuration for composite stream generation
+ */
+export interface CompositeStreamConfig {
+    /** Number of beats to overlap at section boundaries for smooth transitions.
+     *  Default: 0 (no overlap, immediate transition) */
+    transitionOverlapBeats: number;
+    /** Whether to preserve the original grid decisions at section boundaries.
+     *  If true, maintains the grid type from the winning band's stream.
+     *  Default: true */
+    preserveGridDecisions: boolean;
+}
+/**
+ * Creates a composite rhythm stream by combining the highest-scoring sections
+ * from each frequency band.
+ *
+ * ## Algorithm Overview
+ *
+ * 1. **Section Selection**: For each section, select the band with the highest
+ *    interest score (determined by StreamScorer).
+ *
+ * 2. **Beat Extraction**: Extract all beats from the winning band's stream
+ *    for each section's beat range.
+ *
+ * 3. **Stream Assembly**: Combine all extracted beats into a single composite
+ *    stream, maintaining temporal order.
+ *
+ * 4. **Natural Difficulty**: Determine the composite's natural difficulty based
+ *    on the density of the combined stream.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const generator = new CompositeStreamGenerator();
+ * const composite = generator.generate(quantizedStreams, scoringResult, densityAnalysis);
+ *
+ * // Access the composite beat stream
+ * const beats = composite.beats;
+ *
+ * // See which band contributed each section
+ * for (const section of composite.sections) {
+ *   console.log(`Beats ${section.beatRange.start}-${section.beatRange.end}: ${section.sourceBand}`);
+ * }
+ *
+ * // Get the natural difficulty
+ * console.log('Natural difficulty:', composite.naturalDifficulty);
+ * ```
+ */
+export declare class CompositeStreamGenerator {
+    private config;
+    constructor(config?: Partial<CompositeStreamConfig>);
+    /**
+     * Generate a composite stream from quantized band streams and scoring results
+     *
+     * @param streams - Quantized band streams from RhythmQuantizer
+     * @param scoringResult - Scoring result from StreamScorer
+     * @param densityAnalysis - Density analysis from DensityAnalyzer
+     * @returns Composite stream with sections and metadata
+     */
+    generate(streams: QuantizedBandStreams, scoringResult: StreamScoringResult, densityAnalysis: DensityAnalysisResult, trackDurationSeconds?: number): CompositeStream;
+    /**
+     * Extract beats from a band stream for a specific beat range
+     */
+    private extractSectionBeats;
+    /**
+     * Remove duplicate beats (same timestamp) keeping the one with highest intensity
+     */
+    private deduplicateBeats;
+    /**
+     * Determine the natural difficulty of the composite stream
+     *
+     * Calculates density based on the merged composite beats (what the player actually hits)
+     * rather than the multi-band density (which counts overlapping beats multiple times).
+     *
+     * Density is measured in notes per second, which accounts for tempo.
+     * A 120 BPM track with 2 notes/beat = 4 notes/sec feels much easier than
+     * a 180 BPM track with 2 notes/beat = 6 notes/sec.
+     *
+     * This gives a more accurate representation of gameplay difficulty.
+     */
+    private determineNaturalDifficulty;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): CompositeStreamConfig;
+}
+//# sourceMappingURL=CompositeStreamGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeStreamGenerator.d.ts","sourceRoot":"","sources":["../../../../src/core/analysis/beat/CompositeStreamGenerator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAsB,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACpG,OAAO,KAAK,EAAE,mBAAmB,EAAiB,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAMrF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,kCAAkC;IAClC,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;IAEF,0CAA0C;IAC1C,UAAU,EAAE,IAAI,CAAC;IAEjB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IAEd,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,aAAa;IAChD,2CAA2C;IAC3C,UAAU,EAAE,IAAI,CAAC;IAEjB;;;;OAIG;IACH,cAAc,CAAC,EAAE,qBAAqB,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;CACrF;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,2EAA2E;IAC3E,KAAK,EAAE,aAAa,EAAE,CAAC;IAEvB,2DAA2D;IAC3D,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAE7B,yEAAyE;IACzE,iBAAiB,EAAE,iBAAiB,CAAC;IAErC,oEAAoE;IACpE,mBAAmB,EAAE,MAAM,CAAC;IAE5B,8CAA8C;IAC9C,QAAQ,EAAE;QACN,6CAA6C;QAC7C,UAAU,EAAE,MAAM,CAAC;QAEnB,yBAAyB;QACzB,YAAY,EAAE,MAAM,CAAC;QAErB,8CAA8C;QAC9C,YAAY,EAAE;YACV,GAAG,EAAE,MAAM,CAAC;YACZ,GAAG,EAAE,MAAM,CAAC;YACZ,IAAI,EAAE,MAAM,CAAC;SAChB,CAAC;QAEF,8CAA8C;QAC9C,eAAe,EAAE;YACb,GAAG,EAAE,MAAM,CAAC;YACZ,GAAG,EAAE,MAAM,CAAC;YACZ,IAAI,EAAE,MAAM,CAAC;SAChB,CAAC;KACL,CAAC;CACL;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC;wDACoD;IACpD,sBAAsB,EAAE,MAAM,CAAC;IAE/B;;wBAEoB;IACpB,qBAAqB,EAAE,OAAO,CAAC;CAClC;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,wBAAwB;IACjC,OAAO,CAAC,MAAM,CAAwB;gBAE1B,MAAM,GAAE,OAAO,CAAC,qBAAqB,CAAM;IAIvD;;;;;;;OAOG;IACH,QAAQ,CACJ,OAAO,EAAE,oBAAoB,EAC7B,aAAa,EAAE,mBAAmB,EAClC,eAAe,EAAE,qBAAqB,EACtC,oBAAoB,CAAC,EAAE,MAAM,GAC9B,eAAe;IAyFlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,SAAS,IAAI,qBAAqB;CAGrC"}

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

@@ -0,0 +1,246 @@
+/**
+ * Density Analyzer for Procedural Rhythm Generation
+ *
+ * Analyzes quantized rhythm streams to measure density (in notes per second)
+ * and determine natural difficulty.
+ *
+ * Part of the Procedural Rhythm Generation pipeline - Phase 2.2
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - analyze density of quantized streams
+ * const analyzer = new DensityAnalyzer();
+ * const result = analyzer.analyze(quantizedBandStreams, 120);
+ *
+ * // Check combined metrics for overall density
+ * console.log(`Combined density: ${result.combinedMetrics.notesPerSecond.toFixed(2)} notes/sec`);
+ * console.log(`Natural difficulty: ${result.combinedMetrics.naturalDifficulty}`);
+ *
+ * // Access per-band metrics
+ * for (const [band, metrics] of Object.entries(result.bandMetrics)) {
+ *   console.log(`${band}: ${metrics.densityCategory} (${metrics.notesPerSecond.toFixed(2)} n/s)`);
+ * }
+ *
+ * // Check section-level density for dynamic difficulty
+ * for (const section of result.sections) {
+ *   console.log(`Beats ${section.startBeat}-${section.endBeat}: ${section.densityCategory}`);
+ * }
+ * ```
+ */
+import type { QuantizedBandStreams } from './RhythmQuantizer.js';
+/**
+ * Density category for a stream
+ */
+export type DensityCategory = 'sparse' | 'moderate' | 'dense';
+/**
+ * Natural difficulty based on density
+ */
+export type NaturalDifficulty = 'easy' | 'medium' | 'hard';
+/**
+ * Density metrics for a single beat
+ */
+export interface BeatDensityMetrics {
+    /** Beat index in the UnifiedBeatMap */
+    beatIndex: number;
+    /** Number of transients in this beat */
+    transientCount: number;
+    /** Which band(s) contributed to this beat */
+    bands: ('low' | 'mid' | 'high')[];
+    /** Average intensity of transients in this beat */
+    averageIntensity: number;
+}
+/**
+ * Density metrics for a section (multiple beats)
+ */
+export interface SectionDensityMetrics {
+    /** Starting beat index (inclusive) */
+    startBeat: number;
+    /** Ending beat index (inclusive) */
+    endBeat: number;
+    /** Number of beats in this section */
+    beatCount: number;
+    /** Total transients in this section */
+    totalTransients: number;
+    /** Average notes per second in this section */
+    notesPerSecond: number;
+    /** Minimum notes per second in any single beat of this section */
+    minNotesPerSecond: number;
+    /** Maximum notes per second in any single beat of this section */
+    maxNotesPerSecond: number;
+    /** Density category for this section */
+    densityCategory: DensityCategory;
+    /** Natural difficulty for this section */
+    naturalDifficulty: NaturalDifficulty;
+}
+/**
+ * Density metrics for a single band stream
+ */
+export interface BandDensityMetrics {
+    /** Band name */
+    band: 'low' | 'mid' | 'high';
+    /** Total number of beats in the stream */
+    totalBeats: number;
+    /** Total transients across all beats */
+    totalTransients: number;
+    /** Average notes per second */
+    notesPerSecond: number;
+    /** Minimum notes per second in any single beat */
+    minNotesPerSecond: number;
+    /** Maximum notes per second in any single beat */
+    maxNotesPerSecond: number;
+    /** Variance in notes per second */
+    variance: number;
+    /** Density category */
+    densityCategory: DensityCategory;
+    /** Natural difficulty */
+    naturalDifficulty: NaturalDifficulty;
+    /** Per-beat density breakdown */
+    perBeatDensity: BeatDensityMetrics[];
+}
+/**
+ * Complete density analysis result for all bands
+ */
+export interface DensityAnalysisResult {
+    /** Per-band density metrics */
+    bandMetrics: {
+        low: BandDensityMetrics;
+        mid: BandDensityMetrics;
+        high: BandDensityMetrics;
+    };
+    /** Combined density across all bands */
+    combinedMetrics: {
+        /** Total transients across all bands */
+        totalTransients: number;
+        /** Average notes per second (across all bands) */
+        notesPerSecond: number;
+        /** Overall density category */
+        densityCategory: DensityCategory;
+        /** Overall natural difficulty */
+        naturalDifficulty: NaturalDifficulty;
+    };
+    /** Section-based density analysis (2-measure sections = 8 beats) */
+    sections: SectionDensityMetrics[];
+    /** Per-beat density for all bands combined */
+    perBeatDensity: BeatDensityMetrics[];
+}
+/**
+ * Configuration for density analysis
+ */
+export interface DensityAnalyzerConfig {
+    /** Number of beats per section for section analysis. Default: 8 (2 measures in 4/4 time) */
+    beatsPerSection: number;
+    /** Threshold for sparse density (notes per second below this = sparse). Default: 1.0 */
+    sparseThreshold: number;
+    /** Threshold for dense density (notes per second above this = dense). Default: 1.5 */
+    denseThreshold: number;
+}
+/**
+ * Notes per second thresholds for density categorization
+ *
+ * Sparse: < 1.0 notes/sec (mostly quarter notes at moderate tempo)
+ * Moderate: 1.0 - 1.5 notes/sec (eighth notes, some sixteenths)
+ * Dense: > 1.5 notes/sec (heavy sixteenth notes, triplets)
+ */
+/**
+ * Analyzes quantized rhythm streams for density and natural difficulty.
+ *
+ * Density is measured in notes per second (n/s), which accounts for BPM.
+ * A 120 BPM track with 2 notes/beat = 4 notes/sec feels much easier than
+ * a 180 BPM track with 2 notes/beat = 6 notes/sec.
+ *
+ * ## Algorithm Overview
+ *
+ * 1. **Per-Beat Density Calculation**:
+ *    - Count transients in each beat across all bands
+ *    - Track which bands contribute to each beat
+ *
+ * 2. **Notes/Second Conversion**:
+ *    - Convert per-beat transient counts to notes/sec: `transientsPerBeat * (bpm / 60)`
+ *
+ * 3. **Density Categorization**:
+ *    - Sparse: < 1.0 notes/sec (mostly quarter notes at moderate tempo)
+ *    - Moderate: 1.0 - 1.5 notes/sec (eighth notes, some sixteenths)
+ *    - Dense: > 1.5 notes/sec (heavy sixteenth notes, triplets)
+ *
+ * 4. **Natural Difficulty Determination**:
+ *    - High density (dense) → Hard
+ *    - Medium density (moderate) → Medium
+ *    - Low density (sparse) → Easy
+ *
+ * 5. **Section Analysis**:
+ *    - Divide track into sections (default: 8 beats = 2 measures)
+ *    - Calculate density per section for granular analysis
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const analyzer = new DensityAnalyzer();
+ * const result = analyzer.analyze(quantizedStreams, 150);
+ *
+ * // Access per-band metrics
+ * const lowDensity = result.bandMetrics.low;
+ *
+ * // Get overall natural difficulty
+ * const difficulty = result.combinedMetrics.naturalDifficulty;
+ *
+ * // Access section-based analysis
+ * const sections = result.sections;
+ * ```
+ */
+export declare class DensityAnalyzer {
+    private config;
+    constructor(config?: Partial<DensityAnalyzerConfig>);
+    /**
+     * Analyze quantized band streams for density
+     *
+     * @param streams - Quantized band streams from RhythmQuantizer
+     * @param bpm - Tempo in beats per minute, used to convert to notes/second
+     * @returns Complete density analysis result
+     */
+    analyze(streams: QuantizedBandStreams, bpm: number, trackDurationSeconds?: number): DensityAnalysisResult;
+    /**
+     * Analyze a single band for density metrics
+     */
+    private analyzeBand;
+    /**
+     * Calculate combined per-beat density across all bands
+     */
+    private calculateCombinedPerBeatDensity;
+    /**
+     * Helper to add beat data to the aggregation map
+     */
+    private addToBeatData;
+    /**
+     * Calculate combined metrics from per-beat density
+     */
+    private calculateCombinedMetrics;
+    /**
+     * Calculate section-based metrics
+     */
+    private calculateSectionMetrics;
+    /**
+     * Categorize density based on notes per second
+     *
+     * Sparse: < sparseThreshold (mostly quarter notes at moderate tempo)
+     * Moderate: sparseThreshold - denseThreshold (eighth notes, some sixteenths)
+     * Dense: > denseThreshold (heavy sixteenth notes, triplets)
+     */
+    categorizeDensity(notesPerSecond: number): DensityCategory;
+    /**
+     * Determine natural difficulty from density category
+     *
+     * High density (dense) → Hard
+     * Medium density (moderate) → Medium
+     * Low density (sparse) → Easy
+     */
+    determineNaturalDifficulty(densityCategory: DensityCategory): NaturalDifficulty;
+    /**
+     * Calculate variance of an array of numbers
+     */
+    private calculateVariance;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): DensityAnalyzerConfig;
+}
+//# sourceMappingURL=DensityAnalyzer.d.ts.map

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

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