@octoseq/mir 0.1.0-main.994cb4e → 0.1.0-main.9ea6d2e

package/dist/index.d.ts

@@ -1,8 +1,30 @@
-import { B as BeatCandidate, T as TempoHypothesis, P as PhaseAlignmentConfig, a as PhaseHypothesis, M as MusicalTimeSegment, b as BeatPosition, c as MusicalTimeStructure, d as BeatGrid, F as FrequencySegment, e as FrequencyBand, f as FrequencyBandStructure, g as FrequencyBoundsAtTime, h as FrequencyKeyframe, i as BandMirFunctionId, j as BandMir1DResult, C as CqtConfig, k as CqtSpectrogram, l as MirRunMeta, m as CqtSignalResult, n as CqtSignalId, o as BandProposalConfig, p as BandProposalResult } from './types-D6eBRofe.js';
-export { I as BandMirDiagnostics, K as BandProposal, J as BandProposalSource, y as BeatCandidateSource, z as BeatCandidatesResult, H as FrequencyBandProvenance, G as FrequencyBandTimeScope, s as Mir1DResult, t as Mir2DResult, x as MirAudioPayload, q as MirBackend, v as MirFunctionId, u as MirResult, w as MirRunRequest, r as MirRunTimings, E as MusicalTimeProvenance, D as TempoHypothesesResult, A as TempoHypothesisEvidence } from './types-D6eBRofe.js';
-import { S as Spectrogram, M as MirGPU, A as AudioBufferLike$1 } from './runMir-CWsxri61.js';
-export { a as SpectrogramConfig, r as runMir, s as spectrogram } from './runMir-CWsxri61.js';
+import { B as BeatCandidate, T as TempoHypothesis, P as PhaseAlignmentConfig, a as PhaseHypothesis, M as MusicalTimeSegment, b as BeatPosition, c as MusicalTimeStructure, d as BeatGrid, F as FrequencySegment, e as FrequencyBand, f as FrequencyBandStructure, g as FrequencyBoundsAtTime, h as FrequencyKeyframe, i as BandMirFunctionId, j as BandMir1DResult, k as BandEventFunctionId, l as BandEventsResult, C as CqtConfig, m as BandCqtFunctionId, n as BandCqt1DResult, o as CqtSpectrogram, p as MirRunMeta, q as CqtSignalResult, r as CqtSignalId, s as BandProposalConfig, t as BandProposalResult } from './types-ifqndzu7.js';
+export { Q as BandEventDiagnostics, N as BandMirDiagnostics, O as BandMirEvent, S as BandProposal, R as BandProposalSource, E as BeatCandidateSource, G as BeatCandidatesResult, L as FrequencyBandProvenance, K as FrequencyBandTimeScope, w as Mir1DResult, x as Mir2DResult, D as MirAudioPayload, u as MirBackend, z as MirFunctionId, y as MirResult, A as MirRunRequest, v as MirRunTimings, J as MusicalTimeProvenance, I as TempoHypothesesResult, H as TempoHypothesisEvidence } from './types-ifqndzu7.js';
+import { S as Spectrogram, M as MirGPU, A as AudioBufferLike$1 } from './runMir-D4t7WsN0.js';
+export { a as SpectrogramConfig, r as runMir, s as spectrogram } from './runMir-D4t7WsN0.js';
 
+type AmplitudeEnvelopeConfig = {
+    /** Hop size in samples (determines time resolution). Default: 512 */
+    hopSize?: number;
+    /** Window size for RMS calculation. Default: same as hopSize */
+    windowSize?: number;
+};
+type AmplitudeEnvelopeResult = {
+    times: Float32Array;
+    values: Float32Array;
+};
+/**
+ * Amplitude envelope from raw audio samples.
+ *
+ * Computes RMS amplitude over windows of the time-domain signal.
+ * More efficient than spectrogram-based computation for full spectrum.
+ *
+ * @param samples - Mono audio samples
+ * @param sampleRate - Sample rate of the audio
+ * @param config - Configuration options
+ * @returns Times (seconds) and RMS amplitude values
+ */
+declare function amplitudeEnvelope(samples: Float32Array, sampleRate: number, config?: AmplitudeEnvelopeConfig): AmplitudeEnvelopeResult;
 /**
  * Spectral centroid per frame (Hz).
  *
@@ -279,6 +301,95 @@ declare function computePhaseHypotheses(bpm: number, candidates: BeatCandidate[]
  */
 declare function generateBeatTimes(bpm: number, phaseOffset: number, userNudge: number, audioDuration: number): number[];
 
+/**
+ * Peak Picking Algorithm
+ *
+ * Detects local maxima in a 1D signal that exceed a threshold.
+ * Used to create event streams from continuous signals.
+ */
+interface PeakPickingParams {
+    /** Minimum normalized value (0-1) for a peak to be considered. Default: 0.3 */
+    threshold: number;
+    /** Minimum time between peaks in seconds. Default: 0.1 */
+    minDistance: number;
+    /** Number of samples to look back for local max comparison. Default: 2 */
+    preMax?: number;
+    /** Number of samples to look forward for local max comparison. Default: 2 */
+    postMax?: number;
+}
+interface PeakPickingResult {
+    /** Times of detected peaks (seconds) */
+    times: Float32Array;
+    /** Normalized strength of each peak (0-1, based on normalized value) */
+    strengths: Float32Array;
+}
+/**
+ * Default peak picking parameters
+ */
+declare const DEFAULT_PEAK_PICKING_PARAMS: Required<PeakPickingParams>;
+/**
+ * Pick peaks from a continuous signal.
+ *
+ * @param times - Time values in seconds (Float32Array)
+ * @param values - Signal values (Float32Array)
+ * @param params - Peak picking parameters
+ * @returns Detected peaks with times and strengths
+ */
+declare function pickPeaks(times: Float32Array, values: Float32Array, params?: Partial<PeakPickingParams>): PeakPickingResult;
+/**
+ * Result from adaptive peak picking, including the threshold curve for visualization.
+ */
+interface AdaptivePeakPickingResult extends PeakPickingResult {
+    /** The adaptive threshold curve (normalized 0-1) for visualization */
+    thresholdCurve: Float32Array;
+    /** Time values corresponding to threshold curve samples */
+    thresholdTimes: Float32Array;
+}
+/**
+ * Compute the adaptive threshold curve for visualization.
+ * This is the normalized threshold that would be used by pickPeaksAdaptive.
+ *
+ * @param values - Signal values (Float32Array)
+ * @param windowSize - Window size for local statistics (in samples)
+ * @param thresholdMultiplier - Multiplier for local std (default 1.5)
+ * @returns Normalized threshold curve (0-1 range)
+ */
+declare function computeAdaptiveThreshold(values: Float32Array, windowSize?: number, thresholdMultiplier?: number): Float32Array;
+/**
+ * Pick peaks with adaptive threshold based on local statistics.
+ *
+ * @param times - Time values in seconds
+ * @param values - Signal values
+ * @param windowSize - Window size for local statistics (in samples)
+ * @param params - Base peak picking parameters (threshold used as multiplier of local std)
+ * @param includeThresholdCurve - If true, returns the threshold curve for visualization
+ */
+declare function pickPeaksAdaptive(times: Float32Array, values: Float32Array, windowSize?: number, params?: Partial<PeakPickingParams>, includeThresholdCurve?: boolean): PeakPickingResult | AdaptivePeakPickingResult;
+/**
+ * Hysteresis gate parameters for peak filtering.
+ */
+interface HysteresisGateParams {
+    /** Upper threshold (0-1) - signal must exceed this to trigger "on" state */
+    onThreshold: number;
+    /** Lower threshold (0-1) - signal must fall below this to trigger "off" state */
+    offThreshold: number;
+    /** Minimum time between peaks in seconds */
+    minDistance: number;
+}
+/**
+ * Apply hysteresis gating to peaks.
+ * Peaks are only kept if the signal has dropped below offThreshold since the last peak.
+ * This prevents multiple triggers during sustained high-value regions.
+ *
+ * @param times - Time values of the original signal
+ * @param values - Values of the original signal (for checking hysteresis)
+ * @param peakTimes - Times of detected peaks
+ * @param peakStrengths - Strengths of detected peaks
+ * @param params - Hysteresis gate parameters
+ * @returns Filtered peaks after hysteresis gating
+ */
+declare function applyHysteresisGate(times: Float32Array, values: Float32Array, peakTimes: Float32Array, peakStrengths: Float32Array, params: HysteresisGateParams): PeakPickingResult;
+
 /**
  * Musical Time utilities for B4.
  *
@@ -419,6 +530,8 @@ declare function createConstantBand(label: string, lowHz: number, highHz: number
     enabled?: boolean;
     sortOrder?: number;
     id?: string;
+    /** The audio source this band belongs to. Defaults to "mixdown". */
+    sourceId?: string;
 }): FrequencyBand;
 /**
  * Create a sectioned band (applies only to a time range).
@@ -435,6 +548,8 @@ declare function createSectionedBand(label: string, lowHz: number, highHz: numbe
     enabled?: boolean;
     sortOrder?: number;
     id?: string;
+    /** The audio source this band belongs to. Defaults to "mixdown". */
+    sourceId?: string;
 }): FrequencyBand;
 /**
  * Create standard frequency bands for a track.
@@ -448,9 +563,10 @@ declare function createSectionedBand(label: string, lowHz: number, highHz: numbe
  * - Highs: 4000-20000 Hz
  *
  * @param duration - Track duration in seconds
+ * @param sourceId - The audio source these bands belong to. Defaults to "mixdown".
  * @returns Array of FrequencyBand objects
  */
-declare function createStandardBands(duration: number): FrequencyBand[];
+declare function createStandardBands(duration: number, sourceId?: string): FrequencyBand[];
 /**
  * Get all bands active at a given time.
  *
@@ -460,9 +576,10 @@ declare function createStandardBands(duration: number): FrequencyBand[];
  *
  * @param structure - Frequency band structure (can be null)
  * @param time - Time in seconds
+ * @param sourceId - Optional: filter to a specific audio source
  * @returns Array of active bands
  */
-declare function bandsActiveAt(structure: FrequencyBandStructure | null, time: number): FrequencyBand[];
+declare function bandsActiveAt(structure: FrequencyBandStructure | null, time: number, sourceId?: string): FrequencyBand[];
 /**
  * Get frequency bounds for a band at a given time.
  *
@@ -755,6 +872,18 @@ declare function bandOnsetStrength(spec: Spectrogram, band: FrequencyBand, optio
  * @returns Band MIR result with spectral flux
  */
 declare function bandSpectralFlux(spec: Spectrogram, band: FrequencyBand, options?: BandMirOptions): BandMir1DResult;
+/**
+ * Compute spectral centroid for a frequency band.
+ *
+ * Returns the weighted average of frequency bins within the band (center of mass).
+ * Output is in Hz per frame.
+ *
+ * @param spec - Source spectrogram
+ * @param band - Frequency band to analyze
+ * @param options - Computation options
+ * @returns Band MIR result with spectral centroid in Hz
+ */
+declare function bandSpectralCentroid(spec: Spectrogram, band: FrequencyBand, options?: BandMirOptions): BandMir1DResult;
 type BandMirBatchRequest = {
     bands: FrequencyBand[];
     functions: BandMirFunctionId[];
@@ -788,6 +917,187 @@ declare function runBandMirBatch(spec: Spectrogram, request: BandMirBatchRequest
  */
 declare function getBandMirFunctionLabel(fn: BandMirFunctionId): string;
 
+/**
+ * Band Event Extraction for F3.
+ *
+ * These functions extract discrete events (onset peaks, beat candidates)
+ * from band-scoped 1D signals.
+ */
+
+type BandOnsetPeaksOptions = {
+    /** Minimum inter-peak interval in seconds. Default: 0.0625 (~0.125 beats at 120 BPM). */
+    minIntervalSec?: number;
+    /** Adaptive threshold factor. Default: 0.8 (conservative for bands). */
+    adaptiveFactor?: number;
+    /** Use strict peak detection (> neighbors). Default: true. */
+    strict?: boolean;
+};
+type BandBeatCandidatesOptions = {
+    /** Minimum inter-candidate interval in seconds. Default: 0.1. */
+    minIntervalSec?: number;
+    /** Threshold factor for adaptive detection. Lower = more candidates. Default: 0.5. */
+    thresholdFactor?: number;
+};
+/**
+ * Extract onset peaks from a band MIR 1D signal.
+ *
+ * Uses peak picking with conservative defaults optimized for band-scoped
+ * extraction. Typically applied to bandOnsetStrength or bandAmplitudeEnvelope.
+ *
+ * @param signal - The band MIR 1D result to extract peaks from
+ * @param options - Peak picking options
+ * @returns Band events result with onset peaks
+ */
+declare function bandOnsetPeaks(signal: BandMir1DResult, options?: BandOnsetPeaksOptions): BandEventsResult;
+/**
+ * Extract beat candidates from a band's onset peaks.
+ *
+ * Similar to full-track beat candidate detection but simplified for
+ * single-band input. Uses the onset peaks to identify beat-like events.
+ *
+ * @param onsetPeaks - Band onset peaks result
+ * @param options - Beat candidate options
+ * @returns Band events result with beat candidates
+ */
+declare function bandBeatCandidates(onsetPeaks: BandEventsResult, options?: BandBeatCandidatesOptions): BandEventsResult;
+type BandEventsBatchRequest = {
+    /** Band MIR results to extract events from (keyed by bandId) */
+    bandMirResults: Map<string, BandMir1DResult[]>;
+    /** Event functions to run */
+    functions: BandEventFunctionId[];
+    /** Source signal function to use for onset peaks. Default: bandOnsetStrength */
+    sourceFunction?: "bandOnsetStrength" | "bandAmplitudeEnvelope";
+    /** Options for onset peaks extraction */
+    onsetPeaksOptions?: BandOnsetPeaksOptions;
+    /** Options for beat candidates extraction */
+    beatCandidatesOptions?: BandBeatCandidatesOptions;
+};
+type BandEventsBatchResult = {
+    /** Results keyed by bandId, each containing results for requested functions */
+    results: Map<string, BandEventsResult[]>;
+    /** Total computation time in ms */
+    totalTimingMs: number;
+};
+/**
+ * Run band event extraction for multiple bands.
+ *
+ * @param request - Batch request specifying bands, functions, and options
+ * @returns Map of results by band ID
+ */
+declare function runBandEventsBatch(request: BandEventsBatchRequest): Promise<BandEventsBatchResult>;
+/**
+ * Get a human-readable label for a band event function.
+ *
+ * @param fn - Band event function ID
+ * @returns Human-readable label
+ */
+declare function getBandEventFunctionLabel(fn: BandEventFunctionId): string;
+
+/**
+ * Band-Scoped CQT utilities for F3.
+ *
+ * These functions compute CQT-derived features (harmonic energy, bass pitch motion,
+ * tonal stability) for frequency bands by applying spectral masks to a CQT
+ * spectrogram.
+ *
+ * CQT uses log-frequency bins, so band masking requires mapping Hz ranges
+ * to CQT bin indices using hzToCqtBin().
+ */
+
+type BandCqtOptions = {
+    /** Soft edge width in bins for mask transitions. Default: 0 */
+    edgeSmoothBins?: number;
+    /** Optional cancellation hook */
+    isCancelled?: () => boolean;
+};
+type MaskedCqtSpectrogram = {
+    /** Original CQT times */
+    times: Float32Array;
+    /** Masked CQT magnitudes */
+    magnitudes: Float32Array[];
+    /** CQT config */
+    config: CqtConfig;
+    /** Energy retained per frame (0-1) */
+    energyRetainedPerFrame: Float32Array;
+    /** CQT bin frequencies */
+    binFrequencies: Float32Array;
+};
+/**
+ * Apply a frequency band mask to a CQT spectrogram.
+ *
+ * Maps the band's Hz range to CQT bin indices and masks accordingly.
+ *
+ * @param cqt - Source CQT spectrogram
+ * @param band - Frequency band to apply
+ * @param options - Masking options
+ * @returns Masked CQT spectrogram with energy retention diagnostics
+ */
+declare function applyBandMaskToCqt(cqt: CqtSpectrogram, band: FrequencyBand, options?: BandCqtOptions): MaskedCqtSpectrogram;
+/**
+ * Compute harmonic energy for a frequency band using CQT.
+ *
+ * Measures the ratio of energy at harmonic intervals within the band.
+ * Adapted from cqtSignals.ts:harmonicEnergy.
+ *
+ * @param cqt - Source CQT spectrogram
+ * @param band - Frequency band to analyze
+ * @param options - Computation options
+ * @returns Band CQT result with harmonic energy
+ */
+declare function bandCqtHarmonicEnergy(cqt: CqtSpectrogram, band: FrequencyBand, options?: BandCqtOptions): BandCqt1DResult;
+/**
+ * Compute bass pitch motion for a frequency band using CQT.
+ *
+ * Measures pitch movement in bass-range CQT bins within the band.
+ * Most meaningful for bands overlapping the bass range (20-300 Hz).
+ *
+ * @param cqt - Source CQT spectrogram
+ * @param band - Frequency band to analyze
+ * @param options - Computation options
+ * @returns Band CQT result with bass pitch motion
+ */
+declare function bandCqtBassPitchMotion(cqt: CqtSpectrogram, band: FrequencyBand, options?: BandCqtOptions): BandCqt1DResult;
+/**
+ * Compute tonal stability for a frequency band using CQT.
+ *
+ * Measures consistency of chroma distribution over time within the band.
+ * Adapted from cqtSignals.ts:tonalStability.
+ *
+ * @param cqt - Source CQT spectrogram
+ * @param band - Frequency band to analyze
+ * @param options - Computation options
+ * @returns Band CQT result with tonal stability
+ */
+declare function bandCqtTonalStability(cqt: CqtSpectrogram, band: FrequencyBand, options?: BandCqtOptions): BandCqt1DResult;
+type BandCqtBatchRequest = {
+    bands: FrequencyBand[];
+    functions: BandCqtFunctionId[];
+    /** Maximum number of bands to process concurrently. Default: 4 */
+    maxConcurrent?: number;
+};
+type BandCqtBatchResult = {
+    /** Results keyed by bandId */
+    results: Map<string, BandCqt1DResult[]>;
+    /** Total computation time in ms */
+    totalTimingMs: number;
+};
+/**
+ * Run band CQT analysis for multiple bands.
+ *
+ * @param cqt - Source CQT spectrogram
+ * @param request - Batch request specifying bands and functions
+ * @param options - Computation options
+ * @returns Map of results by band ID
+ */
+declare function runBandCqtBatch(cqt: CqtSpectrogram, request: BandCqtBatchRequest, options?: BandCqtOptions): Promise<BandCqtBatchResult>;
+/**
+ * Get a human-readable label for a band CQT function.
+ *
+ * @param fn - Band CQT function ID
+ * @returns Human-readable label
+ */
+declare function getBandCqtFunctionLabel(fn: BandCqtFunctionId): string;
+
 type SpectrogramLike2D = {
     times: Float32Array;
     bins: number;
@@ -981,6 +1291,164 @@ type BandProposalOptions = {
  */
 declare function generateBandProposals(audio: AudioBufferLike$1, duration: number, options?: BandProposalOptions): Promise<BandProposalResult>;
 
+/**
+ * Custom Signal Reduction
+ *
+ * Provides algorithms for reducing 2D spectral data (mel spectrogram, HPSS,
+ * MFCC, etc.) to 1D signals with configurable bin ranges and reduction methods.
+ */
+/**
+ * Input format for 2D time-aligned data.
+ * Shape: data[timeIndex][featureIndex]
+ */
+interface ReductionInput {
+    /** 2D data: data[timeIndex][featureIndex] */
+    data: Float32Array[];
+    /** Time in seconds for each frame */
+    times: Float32Array;
+}
+/**
+ * Reduction algorithm identifiers.
+ */
+type ReductionAlgorithmId = "mean" | "max" | "sum" | "variance" | "amplitude" | "spectralFlux" | "spectralCentroid" | "onsetStrength";
+/**
+ * Options for bin range selection.
+ */
+interface BinRangeOptions {
+    /** Low bin index (inclusive). Default: 0 */
+    lowBin?: number;
+    /** High bin index (exclusive). Default: all bins */
+    highBin?: number;
+}
+/**
+ * Options for onset strength algorithm.
+ */
+interface OnsetStrengthOptions {
+    /** Smoothing window in milliseconds. Default: 10 */
+    smoothMs?: number;
+    /** Whether to log-compress before differencing. Default: true */
+    useLog?: boolean;
+    /** Difference method. Default: "rectified" */
+    diffMethod?: "rectified" | "abs";
+}
+/**
+ * Options for spectral flux algorithm.
+ */
+interface SpectralFluxOptions {
+    /** Whether to normalize frames before computing flux. Default: true */
+    normalized?: boolean;
+}
+/**
+ * Combined options for reduction.
+ */
+interface ReductionOptions {
+    /** Bin range selection */
+    binRange?: BinRangeOptions;
+    /** Onset strength parameters */
+    onsetStrength?: OnsetStrengthOptions;
+    /** Spectral flux parameters */
+    spectralFlux?: SpectralFluxOptions;
+}
+/**
+ * Result of a reduction operation.
+ */
+interface ReductionResult {
+    /** Frame times in seconds */
+    times: Float32Array;
+    /** Reduced values per frame */
+    values: Float32Array;
+    /** Value range for normalization */
+    valueRange: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Reduce 2D time-aligned data to a 1D signal using the specified algorithm.
+ *
+ * @param input - 2D input data (frames x bins)
+ * @param algorithm - Reduction algorithm to use
+ * @param options - Algorithm options including bin range selection
+ * @returns Reduction result with times, values, and value range
+ */
+declare function reduce2DToSignal(input: ReductionInput, algorithm: ReductionAlgorithmId, options?: ReductionOptions): ReductionResult;
+/**
+ * Get human-readable label for a reduction algorithm.
+ */
+declare function getReductionAlgorithmLabel(algorithm: ReductionAlgorithmId): string;
+/**
+ * Get description for a reduction algorithm.
+ */
+declare function getReductionAlgorithmDescription(algorithm: ReductionAlgorithmId): string;
+/**
+ * Polarity interpretation mode.
+ * - "signed": Preserve direction (signal can be positive or negative)
+ * - "magnitude": Activity level only (always positive, uses absolute value)
+ */
+type PolarityMode = "signed" | "magnitude";
+/**
+ * Apply polarity interpretation to a signal.
+ * Called after reduction, before stabilization.
+ *
+ * @param values - Input signal values
+ * @param mode - Polarity mode to apply
+ * @returns Transformed signal values
+ */
+declare function applyPolarity(values: Float32Array, mode: PolarityMode): Float32Array;
+/**
+ * Stabilization mode presets.
+ */
+type StabilizationMode = "none" | "light" | "medium" | "heavy";
+/**
+ * Envelope mode for signal shaping.
+ */
+type EnvelopeMode = "raw" | "attackRelease";
+/**
+ * Options for signal stabilization.
+ */
+interface StabilizationOptions {
+    /** Smoothing intensity preset. */
+    mode: StabilizationMode;
+    /** Envelope shaping mode. */
+    envelopeMode: EnvelopeMode;
+    /** Attack time in seconds (only for attackRelease mode). */
+    attackTimeSec?: number;
+    /** Release time in seconds (only for attackRelease mode). */
+    releaseTimeSec?: number;
+}
+/**
+ * Apply stabilization to a signal.
+ *
+ * @param values - Input signal values
+ * @param times - Frame times in seconds
+ * @param options - Stabilization options
+ * @returns Stabilized signal values
+ */
+declare function stabilizeSignal(values: Float32Array, times: Float32Array, options: StabilizationOptions): Float32Array;
+/**
+ * Compute percentile values from a signal.
+ *
+ * @param values - Signal values
+ * @param percentiles - Array of percentiles to compute (0-100)
+ * @returns Object mapping percentile to value
+ */
+declare function computePercentiles(values: Float32Array, percentiles: number[]): Record<number, number>;
+/**
+ * Compute local (viewport) statistics for a signal.
+ *
+ * @param values - Signal values
+ * @param times - Frame times in seconds
+ * @param startTime - Viewport start time
+ * @param endTime - Viewport end time
+ * @returns Statistics within the viewport
+ */
+declare function computeLocalStats(values: Float32Array, times: Float32Array, startTime: number, endTime: number): {
+    min: number;
+    max: number;
+    p5: number;
+    p95: number;
+};
+
 type NormaliseForWaveformOptions = {
     min?: number;
     max?: number;
@@ -1296,4 +1764,4 @@ type AudioBufferLike = {
  */
 declare function helloMir(name?: string): string;
 
-export { type AudioBufferLike, type BandMaskOptions, BandMir1DResult, type BandMirBatchRequest, type BandMirBatchResult, BandMirFunctionId, type BandMirOptions, BandProposalConfig, type BandProposalOptions, BandProposalResult, BeatCandidate, type BeatCandidatesOptions, type BeatCandidatesOutput, BeatGrid, BeatPosition, type BeatSalienceSignal, CQT_DEFAULTS, CqtConfig, type CqtOptions, CqtSignalId, CqtSignalResult, CqtSpectrogram, type DeltaOptions, type Features2D, FrequencyBand, FrequencyBandStructure, FrequencyBoundsAtTime, FrequencyKeyframe, FrequencySegment, type HpssOptions, MIR_VERSION, type MaskedSpectrogram, type MelConfig, type MelConversionConfig, type MelSpectrogram, type MfccOptions, type MfccResult, type MinMax, type MirFingerprintV1, type MirFingerprintVectorWeights, MirGPU, type MirRefinementCandidateLabelV1, MirRunMeta, type MirSearchCandidate, type MirSearchCurveKindV1, type MirSearchGuidedOptionsV1, type MirSearchOptionsV1, type MirSearchResultV1, type MirSearchResultV1Guided, type MirVersion, MusicalTimeSegment, MusicalTimeStructure, type OnsetEnvelope, type OnsetEnvelopeGpuResult, type OnsetEnvelopeOptions, type PeakPickEvent, type PeakPickOptions, PhaseAlignmentConfig, PhaseHypothesis, Spectrogram, type Spectrogram2D, type SpectrogramLike2D, type SpectrogramToDbOptions, type TempoHypothesesOptions, type TempoHypothesesOutput, TempoHypothesis, addBandToStructure, allFrequencyBoundsAt, applyBandMaskToSpectrogram, bandAmplitudeEnvelope, bandOnsetStrength, bandSpectralFlux, bandsActiveAt, bassPitchMotion, beatSalienceFromMel, binToHz, clampDb, computeAllCqtSignals, computeBandMaskAtTime, computeBeatPosition, computeBeatPositionFromStructure, computeCqt, computeCqtSignal, computeFrameAmplitude, computeFrameEnergy, computePhaseHypotheses, cqtBinToHz, cqtSpectrogram, createBandStructure, createConstantBand, createMusicalTimeStructure, createSectionedBand, createSegmentFromGrid, createStandardBands, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, findBandById, findSegmentAtTime, fingerprintToVectorV1, fingerprintV1, frequencyBoundsAt, generateBandId, generateBandProposals, generateBeatTimes, generateSegmentBeatTimes, generateSegmentId, generateTempoHypotheses, getBandMirFunctionLabel, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, helloMir, hpss, hzToBin, hzToCqtBin, hzToFeatureIndex, hzToMel, keyframesFromBand, melSpectrogram, melToHz, mergeAdjacentSegments, mfcc, minMax, moveKeyframeTime, normaliseForWaveform, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, removeBandFromStructure, removeKeyframe, runBandMirBatch, searchTrackV1, searchTrackV1Guided, segmentsFromKeyframes, similarityFingerprintV1, sortBands, sortFrequencySegments, sortSegments, spectralCentroid, spectralFlux, spectrogramToDb, splitBandSegmentAt, splitSegment, tonalStability, touchStructure, updateBandInStructure, updateKeyframe, validateBandStructure, validateFrequencyBand, validateFrequencySegments, validateSegments, withCqtDefaults };
+export { type AdaptivePeakPickingResult, type AmplitudeEnvelopeConfig, type AmplitudeEnvelopeResult, type AudioBufferLike, type BandBeatCandidatesOptions, BandCqt1DResult, type BandCqtBatchRequest, type BandCqtBatchResult, BandCqtFunctionId, type BandCqtOptions, BandEventFunctionId, type BandEventsBatchRequest, type BandEventsBatchResult, BandEventsResult, type BandMaskOptions, BandMir1DResult, type BandMirBatchRequest, type BandMirBatchResult, BandMirFunctionId, type BandMirOptions, type BandOnsetPeaksOptions, BandProposalConfig, type BandProposalOptions, BandProposalResult, BeatCandidate, type BeatCandidatesOptions, type BeatCandidatesOutput, BeatGrid, BeatPosition, type BeatSalienceSignal, type BinRangeOptions, CQT_DEFAULTS, CqtConfig, type CqtOptions, CqtSignalId, CqtSignalResult, CqtSpectrogram, DEFAULT_PEAK_PICKING_PARAMS, type DeltaOptions, type EnvelopeMode, type Features2D, FrequencyBand, FrequencyBandStructure, FrequencyBoundsAtTime, FrequencyKeyframe, FrequencySegment, type HpssOptions, type HysteresisGateParams, MIR_VERSION, type MaskedCqtSpectrogram, type MaskedSpectrogram, type MelConfig, type MelConversionConfig, type MelSpectrogram, type MfccOptions, type MfccResult, type MinMax, type MirFingerprintV1, type MirFingerprintVectorWeights, MirGPU, type MirRefinementCandidateLabelV1, MirRunMeta, type MirSearchCandidate, type MirSearchCurveKindV1, type MirSearchGuidedOptionsV1, type MirSearchOptionsV1, type MirSearchResultV1, type MirSearchResultV1Guided, type MirVersion, MusicalTimeSegment, MusicalTimeStructure, type OnsetEnvelope, type OnsetEnvelopeGpuResult, type OnsetEnvelopeOptions, type OnsetStrengthOptions, type PeakPickEvent, type PeakPickOptions, type PeakPickingParams, type PeakPickingResult, PhaseAlignmentConfig, PhaseHypothesis, type PolarityMode, type ReductionAlgorithmId, type ReductionInput, type ReductionOptions, type ReductionResult, type SpectralFluxOptions, Spectrogram, type Spectrogram2D, type SpectrogramLike2D, type SpectrogramToDbOptions, type StabilizationMode, type StabilizationOptions, type TempoHypothesesOptions, type TempoHypothesesOutput, TempoHypothesis, addBandToStructure, allFrequencyBoundsAt, amplitudeEnvelope, applyBandMaskToCqt, applyBandMaskToSpectrogram, applyHysteresisGate, applyPolarity, bandAmplitudeEnvelope, bandBeatCandidates, bandCqtBassPitchMotion, bandCqtHarmonicEnergy, bandCqtTonalStability, bandOnsetPeaks, bandOnsetStrength, bandSpectralCentroid, bandSpectralFlux, bandsActiveAt, bassPitchMotion, beatSalienceFromMel, binToHz, clampDb, computeAdaptiveThreshold, computeAllCqtSignals, computeBandMaskAtTime, computeBeatPosition, computeBeatPositionFromStructure, computeCqt, computeCqtSignal, computeFrameAmplitude, computeFrameEnergy, computeLocalStats, computePercentiles, computePhaseHypotheses, cqtBinToHz, cqtSpectrogram, createBandStructure, createConstantBand, createMusicalTimeStructure, createSectionedBand, createSegmentFromGrid, createStandardBands, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, findBandById, findSegmentAtTime, fingerprintToVectorV1, fingerprintV1, frequencyBoundsAt, generateBandId, generateBandProposals, generateBeatTimes, generateSegmentBeatTimes, generateSegmentId, generateTempoHypotheses, getBandCqtFunctionLabel, getBandEventFunctionLabel, getBandMirFunctionLabel, getCqtBinFrequencies, getNumBins, getNumOctaves, getReductionAlgorithmDescription, getReductionAlgorithmLabel, harmonicEnergy, helloMir, hpss, hzToBin, hzToCqtBin, hzToFeatureIndex, hzToMel, keyframesFromBand, melSpectrogram, melToHz, mergeAdjacentSegments, mfcc, minMax, moveKeyframeTime, normaliseForWaveform, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, pickPeaks, pickPeaksAdaptive, reduce2DToSignal, removeBandFromStructure, removeKeyframe, runBandCqtBatch, runBandEventsBatch, runBandMirBatch, searchTrackV1, searchTrackV1Guided, segmentsFromKeyframes, similarityFingerprintV1, sortBands, sortFrequencySegments, sortSegments, spectralCentroid, spectralFlux, spectrogramToDb, splitBandSegmentAt, splitSegment, stabilizeSignal, tonalStability, touchStructure, updateBandInStructure, updateKeyframe, validateBandStructure, validateFrequencyBand, validateFrequencySegments, validateSegments, withCqtDefaults };