@songram/songram-daw-engine 3.3.1 → 3.4.0

package/dist/index.d.ts

@@ -1,13 +1,167 @@
+import { Abs } from 'tone';
+import { Add } from 'tone';
+import { AMOscillator } from 'tone';
+import { AmplitudeEnvelope } from 'tone';
+import { AMSynth } from 'tone';
+import { AMSynthOptions } from 'tone';
+import { Analyser } from 'tone';
+import { AutoFilter } from 'tone';
+import { AutoFilterOptions } from 'tone';
+import { AutoPanner } from 'tone';
+import { AutoPannerOptions } from 'tone';
+import { AutoWah } from 'tone';
+import { AutoWahOptions } from 'tone';
 import { BaseContext } from 'tone';
+import { BiquadFilter } from 'tone';
+import { BiquadFilterOptions as BiquadFilterOptions_2 } from 'tone';
+import { BitCrusher } from 'tone';
+import { Channel } from 'tone';
+import { ChannelOptions } from 'tone';
+import { Chebyshev } from 'tone';
+import { ChebyshevOptions } from 'tone';
+import { Chorus } from 'tone';
+import { ChorusOptions } from 'tone';
+import { Compressor } from 'tone';
+import { CompressorOptions } from 'tone';
 import { Context } from 'tone';
+import { Convolver } from 'tone';
+import { ConvolverOptions as ConvolverOptions_2 } from 'tone';
+import { CrossFade } from 'tone';
+import { DCMeter } from 'tone';
+import { Destination } from 'tone';
+import { Distortion } from 'tone';
+import { DistortionOptions } from 'tone';
+import { Draw } from 'tone';
+import { DuoSynth } from 'tone';
+import { Envelope } from 'tone';
+import { EQ3 } from 'tone';
+import { FatOscillator } from 'tone';
+import { FeedbackDelay } from 'tone';
+import { FeedbackDelayOptions } from 'tone';
+import { FFT } from 'tone';
+import { Filter } from 'tone';
+import { FilterOptions } from 'tone';
+import { FMOscillator } from 'tone';
+import { FMSynth } from 'tone';
+import { FMSynthOptions } from 'tone';
+import { Freeverb } from 'tone';
+import { FreeverbOptions } from 'tone';
+import { Frequency } from 'tone';
+import { FrequencyEnvelope } from 'tone';
+import { FrequencyShifter } from 'tone';
+import { FrequencyShifterOptions } from 'tone';
 import { Gain } from 'tone';
+import { Gate } from 'tone';
+import { GateOptions } from 'tone';
 import { Generator as Generator_2 } from 'soundfont2';
 import { GeneratorType } from 'soundfont2';
+import { getDraw } from 'tone';
+import { getTransport } from 'tone';
+import { GrainPlayer } from 'tone';
+import { GreaterThan } from 'tone';
+import { GreaterThanZero } from 'tone';
+import { immediate } from 'tone';
+import { InputNode as InputNode_2 } from 'tone';
+import { JCReverb } from 'tone';
+import { JCReverbOptions } from 'tone';
+import { LFO } from 'tone';
+import { Limiter } from 'tone';
+import { LimiterOptions } from 'tone';
+import { Loop } from 'tone';
+import { LoopOptions } from 'tone';
+import { LowpassCombFilter } from 'tone';
+import { MembraneSynth } from 'tone';
+import { MembraneSynthOptions } from 'tone';
+import { Merge } from 'tone';
+import { MetalSynth } from 'tone';
+import { MetalSynthOptions } from 'tone';
+import { Meter } from 'tone';
+import { Midi } from 'tone';
+import { MidSideCompressor } from 'tone';
+import { MidSideMerge } from 'tone';
+import { MidSideSplit } from 'tone';
+import { MidSideSplitOptions } from 'tone';
+import { Mono } from 'tone';
+import { MonoSynth } from 'tone';
+import { MonoSynthOptions } from 'tone';
+import { MultibandCompressor } from 'tone';
+import { MultibandCompressorOptions } from 'tone';
+import { MultibandSplit } from 'tone';
+import { Multiply } from 'tone';
+import { Negate } from 'tone';
+import { NoiseSynth } from 'tone';
+import { NoiseSynthOptions } from 'tone';
+import { now } from 'tone';
+import { OnePoleFilter } from 'tone';
+import { Oscillator } from 'tone';
+import { Panner } from 'tone';
+import { Panner3D } from 'tone';
+import { Panner3DOptions } from 'tone';
+import { PanVol } from 'tone';
+import { PanVolOptions } from 'tone';
+import { Part } from 'tone';
+import { Pattern } from 'tone';
+import { PatternOptions } from 'tone';
+import { Phaser } from 'tone';
+import { PhaserOptions } from 'tone';
+import { PingPongDelay } from 'tone';
+import { PingPongDelayOptions } from 'tone';
+import { PitchShift } from 'tone';
+import { PitchShiftOptions } from 'tone';
+import { Player } from 'tone';
+import { PlayerOptions } from 'tone';
+import { Players } from 'tone';
+import { PluckSynth } from 'tone';
+import { PluckSynthOptions } from 'tone';
+import { PolySynth } from 'tone';
+import { Pow } from 'tone';
+import { PulseOscillator } from 'tone';
+import { PWMOscillator } from 'tone';
+import { Reverb } from 'tone';
+import { ReverbOptions } from 'tone';
+import { Sampler } from 'tone';
+import { SamplerOptions } from 'tone';
+import { Scale } from 'tone';
+import { ScaleExp } from 'tone';
+import { Sequence } from 'tone';
+import { Signal } from 'tone';
+import { Solo } from 'tone';
+import { SoloOptions } from 'tone';
+import { Split } from 'tone';
+import { StereoWidener } from 'tone';
+import { StereoWidenerOptions } from 'tone';
+import { Subtract } from 'tone';
+import { Synth } from 'tone';
 import { SynthOptions } from 'tone';
+import { Ticks } from 'tone';
+import { Time } from 'tone';
 import { ToneAudioNode } from 'tone';
+import { ToneEvent } from 'tone';
+import { Transport as ToneTransport } from 'tone';
+import { TransportTime } from 'tone';
+import { Tremolo } from 'tone';
+import { TremoloOptions } from 'tone';
+import { Vibrato } from 'tone';
+import { VibratoOptions } from 'tone';
 import { Volume } from 'tone';
+import { Waveform } from 'tone';
+import { WaveShaper } from 'tone';
 import { ZoneMap } from 'soundfont2';
 
+export { Abs }
+
+export { Add }
+
+export { AMOscillator }
+
+export { AmplitudeEnvelope }
+
+export { AMSynth }
+
+export { AMSynthOptions }
+
+export { Analyser }
+
 /**
  * An action control shown on annotation items (e.g., delete, split).
  */
@@ -183,11 +337,103 @@ export declare interface AudioClip {
     midiProgram?: number;
 }
 
+export declare class AudioMeter {
+    private meter;
+    private peakLevel;
+    private peakHoldTime;
+    private peakDecayTime;
+    private peakTimestamp;
+    private callbacks;
+    private pollInterval;
+    private isClipping;
+    private clipTimeout;
+    constructor(options?: AudioMeterOptions);
+    /**
+     * Connect an audio source to meter
+     */
+    connect(source: ToneAudioNode | InputNode_3): this;
+    /**
+     * Disconnect source from meter
+     */
+    disconnect(source?: ToneAudioNode): this;
+    /**
+     * Get the current meter reading
+     */
+    getReading(): MeterReading;
+    /**
+     * Get current level in dB
+     */
+    getLevel(): Decibels;
+    /**
+     * Reset peak level
+     */
+    resetPeak(): this;
+    /**
+     * Clear clipping indicator
+     */
+    clearClip(): this;
+    /**
+     * Start polling meter values
+     */
+    startPolling(intervalMs?: number): this;
+    /**
+     * Stop polling
+     */
+    stopPolling(): this;
+    /**
+     * Subscribe to meter readings
+     */
+    subscribe(callback: (reading: MeterReading) => void): () => void;
+    /**
+     * Set smoothing factor
+     */
+    setSmoothing(smoothing: number): this;
+    /**
+     * Set peak hold time in ms
+     */
+    setPeakHoldTime(time: number): this;
+    /**
+     * Dispose of the meter
+     */
+    dispose(): void;
+}
+
+declare interface AudioMeterOptions {
+    /** Smoothing factor 0-1 (default: 0.8) */
+    smoothing?: number;
+    /** Peak hold time in ms (default: 1500) */
+    peakHoldTime?: number;
+    /** Peak decay time in ms (default: 3000) */
+    peakDecayTime?: number;
+    /** Whether to measure in RMS or peak (default: true) */
+    normalRange?: boolean;
+}
+
+export { AutoFilter }
+
+export { AutoFilterOptions }
+
+export { AutoPanner }
+
+export { AutoPannerOptions }
+
+export { AutoWah }
+
+export { AutoWahOptions }
+
+export { BiquadFilter }
+
+export { BiquadFilterOptions_2 as BiquadFilterOptions }
+
+export { BitCrusher }
+
 /**
  * Bits type - number of bits for peak data
  */
 export declare type Bits = 8 | 16;
 
+declare type BPM = number;
+
 /**
  * Calculate total timeline duration in seconds from all tracks/clips.
  * Iterates all clips, finds the furthest clip end (startSample + durationSamples),
@@ -272,6 +518,18 @@ export declare function calculateZoomScrollPosition(oldSamplesPerPixel: number,
  */
 export declare function canSplitAt(clip: AudioClip, sample: number, minDurationSamples: number): boolean;
 
+export { Channel }
+
+export { ChannelOptions }
+
+export { Chebyshev }
+
+export { ChebyshevOptions }
+
+export { Chorus }
+
+export { ChorusOptions }
+
 /**
  * Clamp a seek position to the valid range [0, duration].
  *
@@ -363,6 +621,10 @@ export declare type ColorMapName = 'viridis' | 'magma' | 'inferno' | 'grayscale'
 /** Color map can be a named preset or a custom array of [r, g, b, a?] entries */
 export declare type ColorMapValue = ColorMapName | ColorMapEntry[];
 
+export { Compressor }
+
+export { CompressorOptions }
+
 /**
  * Constrain boundary trim delta for left or right edge of a clip.
  *
@@ -394,6 +656,15 @@ export declare function constrainBoundaryTrim(clip: AudioClip, deltaSamples: num
  */
 export declare function constrainClipDrag(clip: AudioClip, deltaSamples: number, sortedClips: AudioClip[], clipIndex: number): number;
 
+export { Convolver }
+
+export { ConvolverOptions_2 as ConvolverOptions }
+
+/**
+ * Create an audio meter
+ */
+export declare function createAudioMeter(options?: AudioMeterOptions): AudioMeter;
+
 /**
  * Creates a new AudioClip with sensible defaults (using sample counts)
  *
@@ -480,6 +751,26 @@ export declare interface CreateClipOptionsSeconds {
  */
 export declare function createControlChange(channel: number, cc: number, value: number): number[];
 
+/**
+ * Create an effect chain from configuration
+ */
+export declare function createEffectChain(options: EffectChainOptions): EffectChain;
+
+/**
+ * Create an effect rack
+ */
+export declare function createEffectRack(options?: EffectRackOptions): EffectRack;
+
+/**
+ * Create an envelope follower
+ */
+export declare function createEnvelopeFollower(options?: EnvelopeFollowerOptions): EnvelopeFollower;
+
+/**
+ * Create an LFO modulator
+ */
+export declare function createLFOModulator(options?: LFOModulatorOptions): LFOModulator;
+
 /**
  * Create a note off message
  */
@@ -490,8 +781,47 @@ export declare function createNoteOff(channel: number, note: number, velocity?:
  */
 export declare function createNoteOn(channel: number, note: number, velocity: number): number[];
 
+/**
+ * Create a quantizer instance
+ */
+export declare function createQuantizer(options?: QuantizeOptions): Quantizer;
+
+/**
+ * Create a SamplerInstrument from a map of sample URLs
+ *
+ * @example
+ * ```ts
+ * const piano = await createSamplerFromUrls({
+ *   'C4': 'C4.mp3',
+ *   'E4': 'E4.mp3',
+ *   'G#4': 'Gs4.mp3',
+ * }, {
+ *   baseUrl: 'https://tonejs.github.io/audio/salamander/',
+ *   release: 1,
+ * });
+ *
+ * piano.triggerAttackRelease('C4', '4n');
+ * ```
+ */
+export declare function createSamplerFromUrls(samples: SampleMap, options?: Omit<SamplerInstrumentOptions, 'samples'>): Promise<SamplerInstrument>;
+
+/**
+ * Create a signal router
+ */
+export declare function createSignalRouter(options?: SignalRouterOptions): SignalRouter;
+
 export declare function createSongramEngine(options?: SongramEngineOptions): SongramEngine;
 
+/**
+ * Create a spectrum analyzer
+ */
+export declare function createSpectrumAnalyzer(options?: SpectrumAnalyzerOptions): SpectrumAnalyzer;
+
+/**
+ * Create a step sequencer
+ */
+export declare function createStepSequencer(options?: StepSequencerOptions): StepSequencer;
+
 /**
  * Creates a new Timeline with sensible defaults
  */
@@ -527,6 +857,18 @@ export declare interface CreateTrackOptions {
     spectrogramColorMap?: ColorMapValue;
 }
 
+/**
+ * Create a transport sync instance
+ */
+export declare function createTransportSync(options?: TransportSyncOptions): TransportSync;
+
+/**
+ * Create a waveform display
+ */
+export declare function createWaveformDisplay(options?: WaveformDisplayOptions): WaveformDisplay;
+
+export { CrossFade }
+
 /**
  * Convert a dB value to a normalized range.
  *
@@ -539,12 +881,203 @@ export declare interface CreateTrackOptions {
  */
 export declare function dBToNormalized(dB: number, floor?: number): number;
 
+export { DCMeter }
+
+declare type Decibels = number;
+
+export { Distortion }
+
+export { DistortionOptions }
+
+export { Draw }
+
+export { DuoSynth }
+
+export declare class EffectChain {
+    private effects;
+    private inputGain;
+    private outputGain;
+    private dryGain;
+    private wetGain;
+    /**
+     * The input node - connect your source to this
+     */
+    get input(): Gain;
+    /**
+     * The output node - this is connected to the destination
+     */
+    get output(): Gain;
+    constructor(options: EffectChainOptions);
+    private rebuildChain;
+    /**
+     * Connect the chain output to a destination
+     */
+    connect(destination: ToneAudioNode): this;
+    /**
+     * Disconnect from destination(s)
+     */
+    disconnect(destination?: ToneAudioNode): this;
+    /**
+     * Set the wet/dry mix for the entire chain
+     * @param mix - 0 = fully dry, 1 = fully wet
+     */
+    setMix(mix: number): void;
+    /**
+     * Update parameters for an effect
+     * @param id - Effect ID or type (if unique)
+     * @param params - Parameters to update
+     */
+    setEffectParams(id: string, params: Record<string, number | boolean>): void;
+    /**
+     * Bypass or enable an effect
+     */
+    setBypass(id: string, bypassed: boolean): void;
+    /**
+     * Get an effect node by ID
+     */
+    getEffect(id: string): ToneAudioNode | undefined;
+    /**
+     * Dispose of all effects
+     */
+    dispose(): void;
+}
+
+export declare interface EffectChainOptions {
+    /** Array of effects to create */
+    effects: EffectConfig[];
+    /** Initial wet/dry mix for the whole chain (0-1) */
+    mix?: number;
+}
+
+/**
+ * Configuration for a single effect
+ */
+export declare interface EffectConfig {
+    /** Effect type */
+    type: EffectType;
+    /** Effect parameters */
+    params?: Record<string, number | boolean>;
+    /** Whether this effect is bypassed */
+    bypassed?: boolean;
+    /** Unique ID for this effect instance */
+    id?: string;
+}
+
 export declare interface EffectPlugin extends EnginePlugin {
     kind: 'effect';
 }
 
+export declare class EffectRack {
+    private slots;
+    private inputGain;
+    private outputGain;
+    private maxSlots;
+    private destination;
+    /**
+     * The input node - connect your source to this
+     */
+    get input(): Gain;
+    /**
+     * The output node
+     */
+    get output(): Gain;
+    /**
+     * Current number of effects
+     */
+    get count(): number;
+    /**
+     * Get all effect slots (read-only)
+     */
+    get effects(): ReadonlyArray<Readonly<EffectSlot>>;
+    constructor(options?: EffectRackOptions);
+    /**
+     * Rebuild the effect chain after changes
+     */
+    private rebuildChain;
+    /**
+     * Insert an effect at the end of the chain
+     * @returns The slot ID
+     */
+    insert(type: EffectType, params?: Record<string, number | boolean>): string;
+    /**
+     * Insert an effect at a specific position
+     * @returns The slot ID
+     */
+    insertAt(index: number, type: EffectType, params?: Record<string, number | boolean>): string;
+    /**
+     * Remove an effect by index or ID
+     */
+    remove(indexOrId: number | string): boolean;
+    /**
+     * Move an effect to a new position
+     */
+    move(fromIndex: number, toIndex: number): boolean;
+    /**
+     * Bypass or enable an effect
+     */
+    bypass(indexOrId: number | string, bypassed: boolean): boolean;
+    /**
+     * Toggle bypass state
+     */
+    toggleBypass(indexOrId: number | string): boolean;
+    /**
+     * Update effect parameters
+     */
+    setParams(indexOrId: number | string, params: Record<string, number | boolean>): boolean;
+    /**
+     * Get effect slot by index or ID
+     */
+    getSlot(indexOrId: number | string): EffectSlot | undefined;
+    /**
+     * Replace an effect with a new one
+     */
+    replace(indexOrId: number | string, type: EffectType, params?: Record<string, number | boolean>): boolean;
+    /**
+     * Clear all effects
+     */
+    clear(): void;
+    /**
+     * Connect to a destination
+     */
+    connect(destination: ToneAudioNode): this;
+    /**
+     * Disconnect from destination(s)
+     */
+    disconnect(destination?: ToneAudioNode): this;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+    /**
+     * Serialize the rack configuration
+     */
+    toJSON(): EffectConfig[];
+    /**
+     * Load configuration from JSON
+     */
+    fromJSON(configs: EffectConfig[]): void;
+}
+
+export declare interface EffectRackOptions {
+    /** Maximum number of effect slots */
+    maxSlots?: number;
+}
+
 export declare type EffectsFunction = (masterGainNode: Volume, destination: ToneAudioNode, isOffline: boolean) => void | (() => void);
 
+export declare interface EffectSlot {
+    id: string;
+    type: EffectType;
+    node: ToneAudioNode;
+    bypassed: boolean;
+    params: Record<string, number | boolean>;
+}
+
+/**
+ * Supported effect types
+ */
+declare type EffectType = 'eq' | 'compressor' | 'reverb' | 'freeverb' | 'delay' | 'pingpong' | 'chorus' | 'distortion' | 'phaser' | 'tremolo' | 'autofilter' | 'bitcrusher' | 'pitchshift';
+
 /**
  * Events emitted by PlaylistEngine.
  */
@@ -592,6 +1125,64 @@ export declare interface EngineState {
     isLoopEnabled: boolean;
 }
 
+export { Envelope }
+
+export declare class EnvelopeFollower {
+    private meter;
+    private input;
+    private callbacks;
+    private pollInterval;
+    private lastValue;
+    constructor(options?: EnvelopeFollowerOptions);
+    /**
+     * Connect an audio source to follow
+     */
+    connect(source: ToneAudioNode | InputNode): this;
+    /**
+     * Disconnect source
+     */
+    disconnect(source?: ToneAudioNode): this;
+    /**
+     * Set smoothing factor (0-1)
+     */
+    setSmoothing(smoothing: number): this;
+    /**
+     * Get the current envelope value in dB
+     */
+    getValue(): number;
+    /**
+     * Get normalized value (0-1)
+     */
+    getNormalizedValue(): number;
+    /**
+     * Start polling the envelope value
+     */
+    startPolling(intervalMs?: number): this;
+    /**
+     * Stop polling
+     */
+    stopPolling(): this;
+    /**
+     * Subscribe to envelope changes
+     */
+    subscribe(callback: (value: number) => void): () => void;
+    /**
+     * Connect the meter output to a destination
+     */
+    connectOutput(destination: ToneAudioNode): this;
+    /**
+     * Dispose of the follower
+     */
+    dispose(): void;
+}
+
+declare interface EnvelopeFollowerOptions {
+    /** Smoothing amount 0-1 (default: 0.8) */
+    smoothing?: number;
+}
+
+export { EQ3 }
+
 export declare class EventBus<TEvents extends object> {
     private readonly emitter;
     on<K extends keyof TEvents>(event: K, listener: TEvents[K]): void;
@@ -638,6 +1229,14 @@ export declare type FadeType = 'linear' | 'logarithmic' | 'exponential' | 'sCurv
 
 declare type FadeType_2 = 'logarithmic' | 'linear' | 'sCurve' | 'exponential';
 
+export { FatOscillator }
+
+export { FeedbackDelay }
+
+export { FeedbackDelayOptions }
+
+export { FFT }
+
 /**
  * Spectrogram Types
  *
@@ -646,6 +1245,12 @@ declare type FadeType_2 = 'logarithmic' | 'linear' | 'sCurve' | 'exponential';
 /** Valid FFT sizes (must be power of 2, 256–8192) */
 export declare type FFTSize = 256 | 512 | 1024 | 2048 | 4096 | 8192;
 
+declare type FFTSize_2 = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384;
+
+export { Filter }
+
+export { FilterOptions }
+
 /**
  * Find the zoom level index closest to a given samplesPerPixel.
  * Returns exact match if found, otherwise the index whose value is
@@ -659,6 +1264,34 @@ export declare function findClosestZoomIndex(targetSamplesPerPixel: number, zoom
 
 export declare function findGaps(track: ClipTrack): Gap[];
 
+export { FMOscillator }
+
+export { FMSynth }
+
+export { FMSynthOptions }
+
+export { Freeverb }
+
+export { FreeverbOptions }
+
+export { Frequency }
+
+declare interface FrequencyBand {
+    frequency: number;
+    magnitude: number;
+    normalized: number;
+}
+
+export { FrequencyEnvelope }
+
+export { FrequencyShifter }
+
+export { FrequencyShifterOptions }
+
+declare type FrequencyValue = number | string;
+
+export { Gain }
+
 /**
  * Convert a linear gain value (0-1+) to normalized 0-1 via dB.
  *
@@ -681,6 +1314,10 @@ export declare interface Gap {
     durationSamples: number;
 }
 
+export { Gate }
+
+export { GateOptions }
+
 /**
  * Utility: Get all clips at a specific sample position
  */
@@ -691,6 +1328,8 @@ export declare function getClipsAtSample(track: ClipTrack, sample: number): Audi
  */
 export declare function getClipsInRange(track: ClipTrack, startSample: number, endSample: number): AudioClip[];
 
+export { getDraw }
+
 /**
  * Get a numeric generator value from a zone map.
  */
@@ -772,6 +1411,8 @@ export declare function getMidiInputs(access: MIDIAccess): MidiInputDevice[];
  */
 export declare function getMidiOutputs(access: MIDIAccess): MidiOutputDevice[];
 
+export { getTransport }
+
 /**
  * Fade utilities for Web Audio API
  *
@@ -795,6 +1436,12 @@ export declare function getUnderlyingAudioParam(signal: unknown): AudioParam | u
  */
 export declare function getVisibleChunkIndices(totalWidth: number, chunkWidth: number, visibleStart: number, visibleEnd: number): number[];
 
+export { GrainPlayer }
+
+export { GreaterThan }
+
+export { GreaterThanZero }
+
 /**
  * Check if a MediaStreamSource exists for the given stream
  *
@@ -803,30 +1450,222 @@ export declare function getVisibleChunkIndices(totalWidth: number, chunkWidth: n
  */
 export declare function hasMediaStreamSource(stream: MediaStream): boolean;
 
-export declare interface InstrumentPlugin extends EnginePlugin {
-    kind: 'instrument';
-}
+export { immediate }
 
-/**
- * Convert Int16Array sample data to Float32Array.
- * SF2 samples are 16-bit signed integers; Web Audio needs Float32 [-1, 1].
- */
-export declare function int16ToFloat32(samples: Int16Array): Float32Array;
+declare type InputNode = ToneAudioNode;
 
-export declare enum InteractionState {
-    Cursor = "cursor",
-    Select = "select",
-    Shift = "shift",
-    FadeIn = "fadein",
-    FadeOut = "fadeout"
+declare type InputNode_3 = ToneAudioNode;
+
+export declare interface InstrumentPlugin extends EnginePlugin {
+    kind: 'instrument';
 }
 
 /**
- * Check if Web MIDI API is supported
+ * A track that plays MIDI data through a Tone.js instrument
  */
-export declare function isWebMidiSupported(): boolean;
-
-/**
+export declare class InstrumentTrack {
+    readonly id: string;
+    readonly startTime: number;
+    private instrument;
+    private scheduledClips;
+    private volumeNode;
+    private panNode;
+    private muteGain;
+    private effectsCleanup?;
+    private _muted;
+    private _duration;
+    get muted(): boolean;
+    get duration(): number;
+    constructor(options: InstrumentTrackOptions);
+    private gainToDb;
+    private calculateDuration;
+    private midiToNoteName;
+    private scheduleClips;
+    /**
+     * Stop all sounds immediately
+     */
+    stopAllSources(): void;
+    /**
+     * Start playback from a specific offset
+     */
+    startMidClipSources(offset: number, time: number): void;
+    /**
+     * Set volume (0-1 gain scale)
+     */
+    setVolume(gain: number): void;
+    /**
+     * Set pan (-1 to 1)
+     */
+    setPan(pan: number): void;
+    /**
+     * Set mute state
+     */
+    setMute(muted: boolean): void;
+    /**
+     * Set solo state (affects mute gain)
+     */
+    setSolo(soloed: boolean): void;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+    setScheduleGuardOffset(_offset: number): void;
+    prepareFades(_when: number, _offset: number): void;
+    cancelFades(): void;
+}
+
+export declare interface InstrumentTrackOptions {
+    /** The Tone.js instrument to use for playback */
+    instrument: TriggerableInstrument;
+    /** MIDI clips with note data */
+    clips: MidiClipData[];
+    /** Track configuration */
+    track: {
+        id: string;
+        gain: number;
+        stereoPan: number;
+        muted: boolean;
+        startTime?: number;
+    };
+    /** Effects function to insert between track output and destination */
+    effects?: (source: ToneAudioNode, destination: ToneAudioNode) => (() => void) | void;
+    /** Destination node (default: main output) */
+    destination?: ToneAudioNode;
+}
+
+/**
+ * Convert Int16Array sample data to Float32Array.
+ * SF2 samples are 16-bit signed integers; Web Audio needs Float32 [-1, 1].
+ */
+export declare function int16ToFloat32(samples: Int16Array): Float32Array;
+
+export declare enum InteractionState {
+    Cursor = "cursor",
+    Select = "select",
+    Shift = "shift",
+    FadeIn = "fadein",
+    FadeOut = "fadeout"
+}
+
+/**
+ * Check if Web MIDI API is supported
+ */
+export declare function isWebMidiSupported(): boolean;
+
+export { JCReverb }
+
+export { JCReverbOptions }
+
+export { LFO }
+
+export declare class LFOModulator {
+    private lfo;
+    private depth;
+    private baseMin;
+    private baseMax;
+    private targets;
+    private isRunning;
+    private isSynced;
+    constructor(options?: LFOModulatorOptions);
+    /**
+     * Start the LFO
+     */
+    start(time?: number): this;
+    /**
+     * Stop the LFO
+     */
+    stop(time?: number): this;
+    /**
+     * Connect the LFO to a parameter
+     */
+    connect(param: Signal | ToneAudioNode): this;
+    /**
+     * Disconnect from a parameter
+     */
+    disconnect(param?: Signal | ToneAudioNode): this;
+    /**
+     * Set LFO frequency
+     */
+    setFrequency(frequency: FrequencyValue): this;
+    /**
+     * Set LFO waveform type
+     */
+    setType(type: LFOWaveform): this;
+    /**
+     * Set modulation depth (0-1)
+     */
+    setDepth(depth: number): this;
+    /**
+     * Set min/max range
+     */
+    setRange(min: number, max: number): this;
+    /**
+     * Update the LFO range based on depth
+     */
+    private updateRange;
+    /**
+     * Set phase offset in degrees
+     */
+    setPhase(phase: number): this;
+    /**
+     * Sync to transport
+     */
+    sync(): this;
+    /**
+     * Unsync from transport
+     */
+    unsync(): this;
+    /**
+     * Get current LFO state
+     */
+    getState(): {
+        frequency: FrequencyValue;
+        type: LFOWaveform;
+        depth: number;
+        min: number;
+        max: number;
+        phase: number;
+        isRunning: boolean;
+        isSynced: boolean;
+    };
+    /**
+     * Get raw LFO output value
+     */
+    getValue(): number;
+    /**
+     * Dispose of the LFO
+     */
+    dispose(): void;
+}
+
+declare interface LFOModulatorOptions {
+    /** LFO frequency in Hz or note value (default: '4n') */
+    frequency?: FrequencyValue;
+    /** Waveform type (default: 'sine') */
+    type?: LFOWaveform;
+    /** Minimum output value (default: 0) */
+    min?: number;
+    /** Maximum output value (default: 1) */
+    max?: number;
+    /** Modulation depth/amount 0-1 (default: 1) */
+    depth?: number;
+    /** Phase offset in degrees (default: 0) */
+    phase?: number;
+    /** Sync to transport (default: true) */
+    sync?: boolean;
+    /** Start immediately (default: false) */
+    autostart?: boolean;
+}
+
+declare type LFOWaveform = 'sine' | 'square' | 'sawtooth' | 'triangle';
+
+export { Limiter }
+
+export { LimiterOptions }
+
+export { Loop }
+
+/**
  * Input parameters for loop and envelope extraction.
  */
 export declare interface LoopAndEnvelopeParams {
@@ -840,6 +1679,10 @@ export declare interface LoopAndEnvelopeParams {
     };
 }
 
+export { LoopOptions }
+
+export { LowpassCombFilter }
+
 /**
  * Maximum width in CSS pixels for a single canvas chunk.
  * Canvas elements are split into chunks of this width to enable
@@ -847,6 +1690,31 @@ export declare interface LoopAndEnvelopeParams {
  */
 export declare const MAX_CANVAS_WIDTH = 1000;
 
+export { MembraneSynth }
+
+export { MembraneSynthOptions }
+
+export { Merge }
+
+export { MetalSynth }
+
+export { MetalSynthOptions }
+
+export { Meter }
+
+declare interface MeterReading {
+    /** Current level in dB */
+    level: number;
+    /** Peak level in dB */
+    peak: number;
+    /** Whether the signal is clipping (> 0dB) */
+    clipping: boolean;
+    /** Level as a normalized value 0-1 */
+    normalized: number;
+}
+
+export { Midi }
+
 export declare const MIDI_CC: {
     readonly MODULATION: 1;
     readonly BREATH: 2;
@@ -872,6 +1740,13 @@ export declare const MIDI_COMMANDS: {
     readonly PITCH_BEND: 14;
 };
 
+declare interface MidiClipData {
+    notes: MidiNoteData[];
+    startTime: number;
+    duration: number;
+    offset: number;
+}
+
 export declare interface MidiClipInfo {
     notes: MidiNoteData[];
     startTime: number;
@@ -1086,6 +1961,34 @@ export declare interface MidiToneTrackOptions {
     synthOptions?: Partial<SynthOptions>;
 }
 
+export { MidSideCompressor }
+
+export { MidSideMerge }
+
+export { MidSideSplit }
+
+export { MidSideSplitOptions }
+
+export { Mono }
+
+export { MonoSynth }
+
+export { MonoSynthOptions }
+
+export { MultibandCompressor }
+
+export { MultibandCompressorOptions }
+
+export { MultibandSplit }
+
+export { Multiply }
+
+export { Negate }
+
+export { NoiseSynth }
+
+export { NoiseSynthOptions }
+
 /**
  * Convert a normalized value back to dB.
  *
@@ -1098,6 +2001,16 @@ export declare interface MidiToneTrackOptions {
  */
 export declare function normalizedToDb(normalized: number, floor?: number): number;
 
+declare type NormalRange = number;
+
+declare type NormalRange_2 = number;
+
+declare interface NoteData {
+    time: number;
+    duration: number;
+    [key: string]: unknown;
+}
+
 /**
  * Convert note name to MIDI note number
  * @param name - Note name like "C4", "F#3", "Bb5"
@@ -1105,6 +2018,24 @@ export declare function normalizedToDb(normalized: number, floor?: number): numb
  */
 export declare function noteNameToMidi(name: string): number;
 
+declare type NoteValue = string | number;
+
+export { now }
+
+export { OnePoleFilter }
+
+export { Oscillator }
+
+export { Panner }
+
+export { Panner3D }
+
+export { Panner3DOptions }
+
+export { PanVol }
+
+export { PanVolOptions }
+
 /**
  * Complete parsed MIDI file result
  */
@@ -1184,6 +2115,12 @@ export declare interface ParseMidiOptions {
  */
 export declare function parseMidiUrl(url: string, options?: ParseMidiOptions, signal?: AbortSignal): Promise<ParsedMidi>;
 
+export { Part }
+
+export { Pattern }
+
+export { PatternOptions }
+
 /**
  * PeakData - result of peak extraction
  */
@@ -1201,6 +2138,18 @@ export declare interface PeakData {
  */
 export declare type Peaks = Int8Array | Int16Array;
 
+export { Phaser }
+
+export { PhaserOptions }
+
+export { PingPongDelay }
+
+export { PingPongDelayOptions }
+
+export { PitchShift }
+
+export { PitchShiftOptions }
+
 export declare function pixelsToSamples(pixels: number, samplesPerPixel: number): number;
 
 export declare function pixelsToSeconds(pixels: number, samplesPerPixel: number, sampleRate: number): number;
@@ -1245,6 +2194,12 @@ export declare interface PlaybackRateParams {
     pitchCorrection: number;
 }
 
+export { Player }
+
+export { PlayerOptions }
+
+export { Players }
+
 export declare interface PlaylistConfig {
     samplesPerPixel?: number;
     waveHeight?: number;
@@ -1369,6 +2324,10 @@ export declare interface PlayoutState {
     duration: number;
 }
 
+export { PluckSynth }
+
+export { PluckSynthOptions }
+
 export declare class PluginHost {
     private readonly plugins;
     private readonly disposers;
@@ -1380,9 +2339,102 @@ export declare class PluginHost {
     dispose(): Promise<void>;
 }
 
+export { PolySynth }
+
+export { Pow }
+
 /** Default PPQN matching Tone.js Transport (192 ticks per quarter note) */
 export declare const PPQN = 192;
 
+export { PulseOscillator }
+
+export { PWMOscillator }
+
+export declare interface QuantizeOptions {
+    /** The grid subdivision to quantize to (default: '16n') */
+    subdivision?: SubdivisionValue_2;
+    /** Quantize strength: 0 = none, 1 = full (default: 1) */
+    strength?: number;
+    /** Named strength preset */
+    preset?: QuantizeStrength;
+    /** Whether to quantize start times (default: true) */
+    quantizeStart?: boolean;
+    /** Whether to quantize end times / durations (default: true) */
+    quantizeEnd?: boolean;
+    /** Swing amount for shuffle feel (0-1, default: 0) */
+    swing?: number;
+    /** Which subdivision to apply swing to (default: '8n') */
+    swingSubdivision?: SubdivisionValue_2;
+}
+
+export declare class Quantizer {
+    private subdivision;
+    private strength;
+    private quantizeStart;
+    private quantizeEnd;
+    private swing;
+    private swingSubdivision;
+    constructor(options?: QuantizeOptions);
+    /**
+     * Get the grid size in seconds for the current subdivision
+     */
+    private getGridSize;
+    /**
+     * Get the swing grid size in seconds
+     */
+    private getSwingGridSize;
+    /**
+     * Quantize a time value to the grid
+     */
+    quantizeTime(time: Seconds_3): Seconds_3;
+    /**
+     * Quantize a single note
+     */
+    quantizeNote<T extends NoteData>(note: T): T;
+    /**
+     * Quantize an array of notes
+     */
+    quantizeNotes<T extends NoteData>(notes: T[]): T[];
+    /**
+     * Set the quantize subdivision
+     */
+    setSubdivision(subdivision: SubdivisionValue_2): void;
+    /**
+     * Set the quantize strength
+     */
+    setStrength(strength: number | QuantizeStrength): void;
+    /**
+     * Set swing amount
+     */
+    setSwing(swing: number): void;
+    /**
+     * Get the nearest grid line to a time value
+     */
+    getGridLine(time: Seconds_3): Seconds_3;
+    /**
+     * Get the previous grid line before a time value
+     */
+    getPreviousGridLine(time: Seconds_3): Seconds_3;
+    /**
+     * Get the next grid line after a time value
+     */
+    getNextGridLine(time: Seconds_3): Seconds_3;
+    /**
+     * Get all grid lines within a time range
+     */
+    getGridLines(startTime: Seconds_3, endTime: Seconds_3): Seconds_3[];
+    /**
+     * Check if a time is on the grid
+     */
+    isOnGrid(time: Seconds_3, tolerance?: number): boolean;
+    /**
+     * Get current settings
+     */
+    getSettings(): Omit<Required<QuantizeOptions>, 'preset'>;
+}
+
+export declare type QuantizeStrength = 'none' | 'soft' | 'medium' | 'hard' | 'full';
+
 /**
  * Manually release a MediaStreamSource
  *
@@ -1420,6 +2472,102 @@ export declare function requestMidiAccess(sysex?: boolean): Promise<MIDIAccess |
  */
 export declare function resumeGlobalAudioContext(): Promise<void>;
 
+export { Reverb }
+
+export { ReverbOptions }
+
+/**
+ * Maps note names or MIDI numbers to sample URLs
+ */
+export declare type SampleMap = Record<string | number, string>;
+
+export { Sampler }
+
+export declare class SamplerInstrument {
+    private sampler;
+    private _loaded;
+    private _loadPromise;
+    /**
+     * Whether all samples have been loaded
+     */
+    get loaded(): boolean;
+    /**
+     * The underlying Tone.Sampler instance
+     */
+    get native(): Sampler;
+    /**
+     * Volume in decibels
+     */
+    get volume(): number;
+    set volume(value: number);
+    constructor(options: SamplerInstrumentOptions);
+    /**
+     * Wait for all samples to load
+     */
+    load(): Promise<void>;
+    /**
+     * Trigger the attack of a note
+     *
+     * @param note - The note to play (e.g., 'C4', 60)
+     * @param time - When to trigger (default: now)
+     * @param velocity - The velocity 0-1 (default: 1)
+     */
+    triggerAttack(note: NoteValue | NoteValue[], time?: TimeValue, velocity?: NormalRange): this;
+    /**
+     * Trigger the release of a note
+     *
+     * @param note - The note to release (e.g., 'C4', 60)
+     * @param time - When to release (default: now)
+     */
+    triggerRelease(note: NoteValue | NoteValue[], time?: TimeValue): this;
+    /**
+     * Trigger attack and release
+     *
+     * @param note - The note(s) to play
+     * @param duration - How long to hold the note
+     * @param time - When to start (default: now)
+     * @param velocity - The velocity 0-1 (default: 1)
+     */
+    triggerAttackRelease(notes: NoteValue | NoteValue[], duration: TimeValue | TimeValue[], time?: TimeValue, velocity?: NormalRange): this;
+    /**
+     * Release all currently held notes
+     *
+     * @param time - When to release (default: now)
+     */
+    releaseAll(time?: TimeValue): this;
+    /**
+     * Connect to a destination
+     */
+    connect(destination: ToneAudioNode): this;
+    /**
+     * Disconnect from destination(s)
+     */
+    disconnect(destination?: ToneAudioNode): this;
+    /**
+     * Dispose of this instrument
+     */
+    dispose(): void;
+}
+
+export declare interface SamplerInstrumentOptions {
+    /** Map of notes to sample URLs */
+    samples: SampleMap;
+    /** Base URL prepended to all sample URLs */
+    baseUrl?: string;
+    /** Release time in seconds (default: 0.1) */
+    release?: Seconds;
+    /** Attack time in seconds (default: 0) */
+    attack?: Seconds;
+    /** Callback when all samples are loaded */
+    onload?: () => void;
+    /** Initial volume in decibels (default: 0) */
+    volume?: number;
+    /** Destination node (default: main output) */
+    destination?: ToneAudioNode;
+}
+
+export { SamplerOptions }
+
 export declare function samplesToPixels(samples: number, samplesPerPixel: number): number;
 
 export declare function samplesToSeconds(samples: number, sampleRate: number): number;
@@ -1427,10 +2575,27 @@ export declare function samplesToSeconds(samples: number, sampleRate: number): n
 /** Convert sample count to PPQN ticks. Inverse of ticksToSamples. */
 export declare function samplesToTicks(samples: number, bpm: number, sampleRate: number, ppqn?: number): number;
 
+export { Scale }
+
+export { ScaleExp }
+
+declare type Seconds = number;
+
+declare type Seconds_2 = number;
+
+/**
+ * Quantizer - Utilities for quantizing time values to a grid
+ *
+ * Used for snapping recorded notes to a musical grid.
+ */
+declare type Seconds_3 = number;
+
 export declare function secondsToPixels(seconds: number, samplesPerPixel: number, sampleRate: number): number;
 
 export declare function secondsToSamples(seconds: number, sampleRate: number): number;
 
+export { Sequence }
+
 /**
  * Determine whether a scroll change is large enough to warrant
  * recalculating the viewport and re-rendering chunks.
@@ -1445,19 +2610,107 @@ export declare function secondsToSamples(seconds: number, sampleRate: number): n
  */
 export declare function shouldUpdateViewport(oldScrollLeft: number, newScrollLeft: number, threshold?: number): boolean;
 
-/** Snap a tick position to the nearest grid line (rounds to nearest). */
-export declare function snapToGrid(ticks: number, gridSizeTicks: number): number;
+export { Signal }
 
-export declare class SongramEngine {
-    readonly events: EventBus<SongramEngineEventMap>;
-    readonly plugins: PluginHost;
-    readonly transport: {
-        play: (startTime?: number, endTime?: number) => void;
-        pause: () => void;
-        stop: () => void;
-        seek: (time: number) => void;
-        getCurrentTime: () => number;
-    };
+export declare class SignalRouter {
+    private input;
+    private channels;
+    private numOutputs;
+    constructor(options?: SignalRouterOptions);
+    /**
+     * Connect a source to the router input
+     */
+    connect(source: ToneAudioNode | InputNode_2): this;
+    /**
+     * Get the input node for external connections
+     */
+    getInput(): Gain;
+    /**
+     * Connect an output channel to a destination
+     */
+    connectOutput(channel: number, destination: ToneAudioNode | typeof Destination): this;
+    /**
+     * Disconnect an output channel from a destination
+     */
+    disconnectOutput(channel: number, destination?: ToneAudioNode | typeof Destination): this;
+    /**
+     * Set gain for an output channel
+     */
+    setGain(channel: number, gain: number): this;
+    /**
+     * Ramp gain for an output channel
+     */
+    rampGain(channel: number, gain: number, rampTime: number): this;
+    /**
+     * Set gains for all channels at once
+     */
+    setGains(gains: number[]): this;
+    /**
+     * Crossfade between two channels
+     */
+    crossfade(fromChannel: number, toChannel: number, position: number, rampTime?: number): this;
+    /**
+     * Mute a channel
+     */
+    mute(channel: number): this;
+    /**
+     * Unmute a channel
+     */
+    unmute(channel: number, gain?: number): this;
+    /**
+     * Solo a channel (mute all others)
+     */
+    solo(channel: number): this;
+    /**
+     * Get current gain values for all channels
+     */
+    getGains(): number[];
+    /**
+     * Get the output node for a channel
+     */
+    getOutput(channel: number): Gain;
+    /**
+     * Add a new output channel
+     */
+    addOutput(initialGain?: number): number;
+    /**
+     * Remove an output channel
+     */
+    removeOutput(channel: number): this;
+    /**
+     * Get output count
+     */
+    getOutputCount(): number;
+    /**
+     * Dispose of the router
+     */
+    dispose(): void;
+}
+
+declare interface SignalRouterOptions {
+    /** Number of output channels (default: 2) */
+    outputs?: number;
+    /** Initial gain for all outputs (default: 1) */
+    initialGain?: number;
+}
+
+/** Snap a tick position to the nearest grid line (rounds to nearest). */
+export declare function snapToGrid(ticks: number, gridSizeTicks: number): number;
+
+export { Solo }
+
+export { SoloOptions }
+
+export declare class SongramEngine {
+    readonly events: EventBus<SongramEngineEventMap>;
+    readonly plugins: PluginHost;
+    readonly transport: {
+        play: (startTime?: number, endTime?: number) => void;
+        pause: () => void;
+        stop: () => void;
+        seek: (time: number) => void;
+        getCurrentTime: () => number;
+    };
     readonly tracks: {
         set: (tracks: ClipTrack[]) => void;
         add: (track: ClipTrack) => void;
@@ -1726,6 +2979,95 @@ export declare interface SpectrogramData {
 /** Subset of SpectrogramConfig fields that only affect display/rendering (not FFT computation) */
 export declare type SpectrogramDisplayConfig = Pick<SpectrogramConfig, 'frequencyScale' | 'minFrequency' | 'maxFrequency' | 'gainDb' | 'rangeDb' | 'labels' | 'labelsColor' | 'labelsBackground'>;
 
+export declare class SpectrumAnalyzer {
+    private fft;
+    private size;
+    private callbacks;
+    private pollInterval;
+    private sampleRate;
+    constructor(options?: SpectrumAnalyzerOptions);
+    /**
+     * Connect an audio source to analyze
+     */
+    connect(source: ToneAudioNode | InputNode_2): this;
+    /**
+     * Disconnect source
+     */
+    disconnect(source?: ToneAudioNode): this;
+    /**
+     * Get the FFT frequency data
+     * Returns values in dB
+     */
+    getFrequencyData(): Float32Array;
+    /**
+     * Get normalized frequency data (0-1 range)
+     */
+    getNormalizedData(): Float32Array;
+    /**
+     * Get frequency bands with magnitudes
+     */
+    getFrequencyBands(): FrequencyBand[];
+    /**
+     * Get the magnitude at a specific frequency
+     */
+    getMagnitudeAtFrequency(frequency: number): number;
+    /**
+     * Get the peak frequency
+     */
+    getPeakFrequency(): {
+        frequency: number;
+        magnitude: number;
+    };
+    /**
+     * Get average magnitude in a frequency range
+     */
+    getAverageInRange(lowFreq: number, highFreq: number): number;
+    /**
+     * Get common frequency band averages
+     */
+    getBandAverages(): {
+        sub: number;
+        bass: number;
+        lowMid: number;
+        mid: number;
+        highMid: number;
+        high: number;
+    };
+    /**
+     * Start polling frequency data
+     */
+    startPolling(intervalMs?: number): this;
+    /**
+     * Stop polling
+     */
+    stopPolling(): this;
+    /**
+     * Subscribe to frequency data
+     */
+    subscribe(callback: (data: Float32Array) => void): () => void;
+    /**
+     * Set smoothing factor
+     */
+    setSmoothing(smoothing: number): this;
+    /**
+     * Get FFT size
+     */
+    getSize(): FFTSize_2;
+    /**
+     * Dispose of the analyzer
+     */
+    dispose(): void;
+}
+
+declare interface SpectrumAnalyzerOptions {
+    /** FFT size (default: 1024) */
+    size?: FFTSize_2;
+    /** Smoothing factor 0-1 (default: 0.8) */
+    smoothing?: number;
+}
+
+export { Split }
+
 /**
  * Split a clip into two clips at the given sample position.
  *
@@ -1742,6 +3084,204 @@ export declare function splitClip(clip: AudioClip, splitSample: number): {
     right: AudioClip;
 };
 
+/**
+ * A single step in the sequencer
+ */
+export declare interface Step {
+    /** Whether this step is active */
+    active: boolean;
+    /** Velocity for this step (0-1) */
+    velocity: number;
+    /** Note or parameter for this step (default: 'C2' for drums) */
+    note?: string | number;
+    /** Optional probability (0-1) for random triggering */
+    probability?: number;
+}
+
+export declare class StepSequencer {
+    private tracks;
+    private numSteps;
+    private subdivision;
+    private _loop;
+    private _swing;
+    private onStep?;
+    private _currentStep;
+    private _isPlaying;
+    /**
+     * Current step index (0-based)
+     */
+    get currentStep(): number;
+    /**
+     * Whether the sequencer is playing
+     */
+    get isPlaying(): boolean;
+    /**
+     * Number of steps in the sequence
+     */
+    get steps(): number;
+    /**
+     * Swing amount (0-1)
+     */
+    get swing(): number;
+    set swing(value: number);
+    constructor(options?: StepSequencerOptions);
+    /**
+     * Add a new track
+     */
+    addTrack(config: StepSequencerTrack): void;
+    /**
+     * Remove a track
+     */
+    removeTrack(id: string): boolean;
+    /**
+     * Create empty steps array
+     */
+    private createEmptySteps;
+    /**
+     * Normalize steps array to match numSteps
+     */
+    private normalizeSteps;
+    /**
+     * Check if any track is soloed
+     */
+    private hasAnySolo;
+    /**
+     * Trigger a step
+     */
+    private triggerStep;
+    /**
+     * Set a step's state
+     */
+    setStep(trackId: string, stepIndex: number, updates: Partial<Step>): boolean;
+    /**
+     * Toggle a step's active state
+     */
+    toggleStep(trackId: string, stepIndex: number): boolean;
+    /**
+     * Get a step's state
+     */
+    getStep(trackId: string, stepIndex: number): Step | undefined;
+    /**
+     * Get all steps for a track
+     */
+    getTrackSteps(trackId: string): Step[] | undefined;
+    /**
+     * Set all steps for a track
+     */
+    setTrackSteps(trackId: string, steps: Step[]): boolean;
+    /**
+     * Clear all steps for a track
+     */
+    clearTrack(trackId: string): boolean;
+    /**
+     * Clear all tracks
+     */
+    clearAll(): void;
+    /**
+     * Set track mute state
+     */
+    setMuted(trackId: string, muted: boolean): boolean;
+    /**
+     * Set track solo state
+     */
+    setSoloed(trackId: string, soloed: boolean): boolean;
+    /**
+     * Set track volume
+     */
+    setVolume(trackId: string, volume: number): boolean;
+    /**
+     * Start the sequencer (synced to transport)
+     */
+    start(time?: TimeValue_3): void;
+    /**
+     * Stop the sequencer
+     */
+    stop(): void;
+    /**
+     * Pause the sequencer (keeps position)
+     */
+    pause(): void;
+    /**
+     * Randomize steps for a track
+     */
+    randomize(trackId: string, density?: number): boolean;
+    /**
+     * Shift all steps in a track
+     */
+    shift(trackId: string, amount: number): boolean;
+    /**
+     * Copy steps from one track to another
+     */
+    copyTrack(fromId: string, toId: string): boolean;
+    /**
+     * Get all track IDs
+     */
+    getTrackIds(): string[];
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+    /**
+     * Export the sequencer state as JSON
+     */
+    toJSON(): Record<string, Step[]>;
+    /**
+     * Import state from JSON
+     */
+    fromJSON(data: Record<string, Step[]>): void;
+}
+
+export declare interface StepSequencerOptions {
+    /** Number of steps in the sequence (default: 16) */
+    steps?: number;
+    /** Note value for each step (default: '16n') */
+    subdivision?: SubdivisionValue;
+    /** Tracks to create */
+    tracks?: StepSequencerTrack[];
+    /** Whether to loop (default: true) */
+    loop?: boolean;
+    /** Swing amount (0-1, default: 0) */
+    swing?: number;
+    /** Callback when a step is triggered */
+    onStep?: (trackId: string, stepIndex: number, time: number) => void;
+}
+
+/**
+ * A track in the sequencer
+ */
+export declare interface StepSequencerTrack {
+    /** Unique identifier for this track */
+    id: string;
+    /** The instrument to trigger */
+    instrument: TriggerableInstrument_2;
+    /** Default note for this track */
+    note?: string | number;
+    /** Steps for this track */
+    steps?: Step[];
+    /** Whether this track is muted */
+    muted?: boolean;
+    /** Whether this track is soloed */
+    soloed?: boolean;
+    /** Track volume (0-1) */
+    volume?: number;
+}
+
+export { StereoWidener }
+
+export { StereoWidenerOptions }
+
+declare type SubdivisionValue = string;
+
+declare type SubdivisionValue_2 = string;
+
+export { Subtract }
+
+export { Synth }
+
+export { SynthOptions }
+
+export { Ticks }
+
 /** Number of PPQN ticks per bar for the given time signature. */
 export declare function ticksPerBar(timeSignature: [number, number], ppqn?: number): number;
 
@@ -1754,6 +3294,8 @@ export declare function ticksToBarBeatLabel(ticks: number, timeSignature: [numbe
 /** Convert PPQN ticks to sample count. Uses Math.round for integer sample alignment. */
 export declare function ticksToSamples(ticks: number, bpm: number, sampleRate: number, ppqn?: number): number;
 
+export { Time }
+
 /**
  * Convert SF2 timecents to seconds.
  * SF2 formula: seconds = 2^(timecents / 1200)
@@ -1787,12 +3329,57 @@ export declare interface TimeSelection {
     end: number;
 }
 
+declare type TimeSignatureValue = number | number[];
+
+declare type TimeValue = number | string;
+
+declare type TimeValue_2 = number | string;
+
+/**
+ * StepSequencer - A traditional step sequencer for drum programming
+ *
+ * This provides a grid-based sequencer similar to those found in DAWs,
+ * with support for multiple tracks, velocity, swing, and transport sync.
+ *
+ * @example
+ * ```ts
+ * const sequencer = new StepSequencer({
+ *   steps: 16,
+ *   subdivision: '16n',
+ *   tracks: [
+ *     { id: 'kick', instrument: kickSynth },
+ *     { id: 'snare', instrument: snareSynth },
+ *     { id: 'hihat', instrument: hihatSynth },
+ *   ],
+ * });
+ *
+ * // Set steps
+ * sequencer.setStep('kick', 0, { active: true, velocity: 1 });
+ * sequencer.setStep('kick', 4, { active: true, velocity: 0.8 });
+ * sequencer.setStep('snare', 4, { active: true, velocity: 1 });
+ *
+ * // Start
+ * sequencer.start();
+ * ```
+ */
+declare type TimeValue_3 = number | string;
+
+/**
+ * TransportSync - Utilities for syncing with Tone.js Transport
+ *
+ * Provides a clean interface for managing transport state and
+ * syncing playback across multiple components.
+ */
+declare type TimeValue_4 = number | string;
+
 export declare interface ToneAdapterOptions {
     effects?: EffectsFunction;
     /** When provided, MIDI clips use SoundFont sample playback instead of PolySynth */
     soundFontCache?: SoundFontCache;
 }
 
+export { ToneEvent }
+
 export declare class TonePlayout {
     private tracks;
     private masterVolume;
@@ -1914,6 +3501,8 @@ export declare interface ToneTrackOptions {
     destination?: ToneAudioNode;
 }
 
+export { ToneTransport }
+
 export declare interface Track {
     id: string;
     name: string;
@@ -1965,6 +3554,160 @@ export declare interface TrackSpectrogramOverrides {
     colorMap?: ColorMapValue;
 }
 
+export declare interface TransportState {
+    /** Whether the transport is playing */
+    isPlaying: boolean;
+    /** Whether the transport is paused */
+    isPaused: boolean;
+    /** Current position in seconds */
+    position: Seconds_2;
+    /** Current position as bars:beats:sixteenths */
+    positionBBS: string;
+    /** Current BPM */
+    bpm: BPM;
+    /** Time signature */
+    timeSignature: number | number[];
+    /** Whether looping is enabled */
+    loop: boolean;
+    /** Loop start position */
+    loopStart: Seconds_2;
+    /** Loop end position */
+    loopEnd: Seconds_2;
+}
+
+export declare class TransportSync {
+    private onStateChange?;
+    private onBeat?;
+    private onBar?;
+    private beatScheduleId;
+    private barScheduleId;
+    private currentBeat;
+    private currentBar;
+    constructor(options?: TransportSyncOptions);
+    private scheduleBeatCallback;
+    private scheduleBarCallback;
+    /**
+     * Get current transport state
+     */
+    getState(): TransportState;
+    /**
+     * Start playback
+     */
+    start(time?: TimeValue_4, offset?: TimeValue_4): void;
+    /**
+     * Pause playback
+     */
+    pause(time?: TimeValue_4): void;
+    /**
+     * Stop playback and reset position
+     */
+    stop(time?: TimeValue_4): void;
+    /**
+     * Toggle between play and pause
+     */
+    toggle(time?: TimeValue_4): boolean;
+    /**
+     * Seek to a position
+     */
+    seek(position: TimeValue_4): void;
+    /**
+     * Set BPM
+     */
+    setBpm(bpm: BPM, rampTime?: TimeValue_4): void;
+    /**
+     * Set time signature
+     */
+    setTimeSignature(signature: TimeSignatureValue): void;
+    /**
+     * Set loop range
+     */
+    setLoop(enabled: boolean, start?: TimeValue_4, end?: TimeValue_4): void;
+    /**
+     * Schedule a callback at a specific time
+     */
+    schedule(callback: (time: number) => void, time: TimeValue_4): number;
+    /**
+     * Schedule a repeating callback
+     */
+    scheduleRepeat(callback: (time: number) => void, interval: TimeValue_4, startTime?: TimeValue_4, duration?: TimeValue_4): number;
+    /**
+     * Clear a scheduled callback
+     */
+    clear(id: number): void;
+    /**
+     * Cancel all scheduled events
+     */
+    cancel(after?: TimeValue_4): void;
+    private notifyStateChange;
+    /**
+     * Convert a time value to seconds
+     */
+    toSeconds(time: TimeValue_4): Seconds_2;
+    /**
+     * Convert seconds to bars:beats:sixteenths
+     */
+    toBBS(time: TimeValue_4): string;
+    /**
+     * Dispose and clean up
+     */
+    dispose(): void;
+}
+
+export declare interface TransportSyncOptions {
+    /** Initial BPM (default: 120) */
+    bpm?: BPM;
+    /** Time signature (default: 4) */
+    timeSignature?: TimeSignatureValue;
+    /** Initial loop setting (default: false) */
+    loop?: boolean;
+    /** Loop start position */
+    loopStart?: TimeValue_4;
+    /** Loop end position */
+    loopEnd?: TimeValue_4;
+    /** Callback when state changes */
+    onStateChange?: (state: TransportState) => void;
+    /** Callback on each beat */
+    onBeat?: (beat: number, time: number) => void;
+    /** Callback on each bar */
+    onBar?: (bar: number, time: number) => void;
+}
+
+export { TransportTime }
+
+export { Tremolo }
+
+export { TremoloOptions }
+
+/**
+ * Interface for any instrument that can trigger notes
+ */
+declare interface TriggerableInstrument {
+    triggerAttackRelease(notes: string | string[] | number | number[], duration: TimeValue_2 | TimeValue_2[], time?: TimeValue_2, velocity?: number): void;
+    triggerAttack?(notes: string | string[] | number | number[], time?: TimeValue_2, velocity?: number): void;
+    triggerRelease?(notes: string | string[] | number | number[], time?: TimeValue_2): void;
+    releaseAll?(time?: TimeValue_2): void;
+    connect(destination: ToneAudioNode): unknown;
+    disconnect(): unknown;
+    dispose(): void;
+}
+
+/**
+ * Interface for instruments that can be triggered
+ */
+declare interface TriggerableInstrument_2 {
+    triggerAttackRelease(note: string | number, duration: TimeValue_3, time?: TimeValue_3, velocity?: NormalRange_2): void;
+    triggerAttack?(note: string | number, time?: TimeValue_3, velocity?: NormalRange_2): void;
+    triggerRelease?(note: string | number, time?: TimeValue_3): void;
+}
+
+export { Vibrato }
+
+export { VibratoOptions }
+
+export { Volume }
+
+export { Waveform }
+
 export declare interface WaveformConfig {
     sampleRate: number;
     samplesPerPixel: number;
@@ -2013,4 +3756,83 @@ export declare interface WaveformDataObject {
     }) => WaveformDataObject;
 }
 
+export declare class WaveformDisplay {
+    private waveform;
+    private size;
+    private callbacks;
+    private pollInterval;
+    constructor(options?: WaveformDisplayOptions);
+    /**
+     * Connect an audio source to visualize
+     */
+    connect(source: ToneAudioNode | InputNode_2): this;
+    /**
+     * Disconnect source
+     */
+    disconnect(source?: ToneAudioNode): this;
+    /**
+     * Get the raw waveform data (-1 to 1 range)
+     */
+    getWaveformData(): Float32Array;
+    /**
+     * Get normalized waveform data (0 to 1 range)
+     */
+    getNormalizedData(): Float32Array;
+    /**
+     * Get statistics about the current waveform
+     */
+    getStats(): WaveformStats;
+    /**
+     * Get downsampled waveform for smaller displays
+     */
+    getDownsampled(targetSize: number): Float32Array;
+    /**
+     * Get min/max pairs for drawing filled waveforms
+     */
+    getMinMaxPairs(targetSize: number): {
+        min: Float32Array;
+        max: Float32Array;
+    };
+    /**
+     * Start polling waveform data
+     */
+    startPolling(intervalMs?: number): this;
+    /**
+     * Stop polling
+     */
+    stopPolling(): this;
+    /**
+     * Subscribe to waveform data
+     */
+    subscribe(callback: (data: Float32Array) => void): () => void;
+    /**
+     * Get buffer size
+     */
+    getSize(): WaveformSize;
+    /**
+     * Dispose of the display
+     */
+    dispose(): void;
+}
+
+declare interface WaveformDisplayOptions {
+    /** Buffer size (default: 1024) */
+    size?: WaveformSize;
+}
+
+declare type WaveformSize = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;
+
+declare interface WaveformStats {
+    /** Peak positive value */
+    peak: number;
+    /** Peak negative value (trough) */
+    trough: number;
+    /** RMS (root mean square) value */
+    rms: number;
+    /** Zero crossing count */
+    zeroCrossings: number;
+}
+
+export { WaveShaper }
+
 export { }