@dawcore/transport 0.0.3 → 0.0.5

package/README.md

@@ -7,7 +7,8 @@ Native Web Audio transport for multi-track audio scheduling, looping, tempo, and
 - **Native Web Audio** — No Tone.js, no `standardized-audio-context`. Direct `AudioContext` with full `sampleRate` and `latencyHint` control.
 - **Sliding window scheduler** — Schedules audio 200ms ahead via `requestAnimationFrame` for glitch-free playback.
 - **Dual timeline** — Sample-absolute positions for audio clips, PPQN tick positions for metronome/MIDI.
-- **Built-in metronome** — Beat-grid click scheduling with accent on beat 1. Just another scheduler listener.
+- **Built-in metronome** — Beat-grid click scheduling with accent on beat 1. Default synthesized click sounds out of the box.
+- **Count-in (pre-roll)** — Configurable bars of click sounds before playback begins. Beat-by-beat events for UI countdown.
 - **Per-track signal chain** — Native GainNode (volume) → StereoPannerNode → GainNode (mute) → effects hook → master output.
 - **Effects plugin hook** — `connectTrackOutput(trackId, node)` inserts any `AudioNode` chain (Tone.js effects, WAM plugins, native nodes).
 - **Type-safe coordinates** — Branded `Tick` and `Sample` types prevent accidentally passing seconds where ticks or samples are expected. Zero runtime cost.
@@ -71,9 +72,31 @@ const transport = new Transport(audioContext, {
   denominator: 4,
 });
 
+// Default click sounds are built in — just enable and play
 transport.setMetronomeEnabled(true);
-transport.setMetronomeClickSounds(accentBuffer, normalBuffer);
 transport.play();
+
+// Override with custom click sounds
+transport.setMetronomeClickSounds(accentBuffer, normalBuffer);
+```
+
+### Count-In
+
+```typescript
+transport.setCountIn(true);
+transport.setCountInBars(1);           // 1–8 bars, default 1
+transport.setCountInMode('always');    // 'always' | 'recording-only' (default)
+
+// Beat-by-beat events for UI countdown
+transport.on('countIn', ({ beat, totalBeats }) => {
+  console.log(beat + ' / ' + totalBeats);  // "1 / 4", "2 / 4", ...
+});
+
+transport.on('countInEnd', () => {
+  console.log('Playback starting');
+});
+
+transport.play();  // Plays count-in clicks, then starts playback
 ```
 
 ### Mixed Meter
@@ -92,6 +115,38 @@ transport.setMetronomeEnabled(true);
 transport.play();
 ```
 
+### Tempo Automation
+
+```typescript
+const transport = new Transport(audioContext, { tempo: 100 });
+
+// Linear ramp from 100 to 160 BPM over 8 bars
+transport.setTempo(160, transport.barToTick(9), { interpolation: 'linear' });
+
+// Query interpolated BPM at any position
+transport.getTempo(transport.barToTick(5)); // 130 BPM (midway through ramp)
+
+// Curved ramp: ease-in (slow start, fast end)
+transport.clearTempos();
+transport.setTempo(80);
+transport.setTempo(160, transport.barToTick(9), {
+  interpolation: { type: 'curve', slope: 0.2 },  // concave
+});
+
+// Curved ramp: ease-out (fast start, slow end)
+transport.clearTempos();
+transport.setTempo(80);
+transport.setTempo(160, transport.barToTick(9), {
+  interpolation: { type: 'curve', slope: 0.8 },  // convex
+});
+
+// Mix step and linear: jump to 80 BPM at bar 4, ramp to 140 at bar 8
+transport.clearTempos();
+transport.setTempo(120);
+transport.setTempo(80, transport.barToTick(5));  // step (instant jump)
+transport.setTempo(140, transport.barToTick(9), { interpolation: 'linear' });  // ramp
+```
+
 ### Effects
 
 ```typescript
@@ -123,6 +178,8 @@ new Transport(audioContext: AudioContext, options?: TransportOptions)
 | `numerator` | `4` | Beats per bar (time signature numerator) |
 | `denominator` | `4` | Beat unit (time signature denominator) |
 | `schedulerLookahead` | `0.2` | How far ahead to schedule (seconds) |
+| `accentFrequency` | `1000` | Default accent click frequency (Hz) |
+| `normalFrequency` | `800` | Default normal click frequency (Hz) |
 
 **Playback:**
 - `play(startTime?, endTime?)` — Start or resume playback
@@ -151,7 +208,7 @@ new Transport(audioContext: AudioContext, options?: TransportOptions)
 - `setLoopSamples(enabled, startSample: Sample, endSample: Sample)` — Set loop region in samples (convenience)
 
 **Tempo & Meter:**
-- `setTempo(bpm, atTick?)` / `getTempo(atTick?)`
+- `setTempo(bpm, atTick?, options?)` / `getTempo(atTick?: Tick)` — options: `{ interpolation: 'step' | 'linear' | { type: 'curve', slope } }`
 - `clearTempos()` — remove all tempo entries
 - `setMeter(numerator, denominator, atTick?: Tick)` / `getMeter(atTick?: Tick)`
 - `removeMeter(atTick: Tick)` / `clearMeters()`
@@ -160,7 +217,14 @@ new Transport(audioContext: AudioContext, options?: TransportOptions)
 
 **Metronome:**
 - `setMetronomeEnabled(enabled)`
-- `setMetronomeClickSounds(accent, normal)`
+- `setMetronomeClickSounds(accent, normal)` — overrides default synthesized sounds
+
+**Count-In:**
+- `setCountIn(enabled)` — enable/disable count-in
+- `setCountInBars(bars)` — number of bars (1–8, default 1)
+- `setCountInMode(mode)` — `'recording-only'` (default) or `'always'`
+- `setRecording(recording)` — consumer signals recording state (for `'recording-only'` mode)
+- `isCountingIn()` — whether count-in is active
 
 **Effects:**
 - `connectTrackOutput(trackId, node)` — Insert effects chain
@@ -168,7 +232,10 @@ new Transport(audioContext: AudioContext, options?: TransportOptions)
 
 **Events:**
 - `on(event, callback)` / `off(event, callback)`
-- Events: `play`, `pause`, `stop`, `loop`, `tempochange`
+- Events: `play`, `pause`, `stop`, `loop`, `tempochange`, `meterchange`, `countIn`, `countInEnd`
+- `tempochange` payload: `{ bpm: number, atTick: Tick }`
+- `meterchange` payload: `{ numerator: number, denominator: number, atTick: Tick }`
+- `countIn` payload: `{ beat: number, totalBeats: number }`
 
 **Cleanup:**
 - `dispose()` — Stop playback, disconnect all nodes, remove listeners
@@ -187,6 +254,10 @@ Implements `PlayoutAdapter` from `@waveform-playlist/engine`. All methods delega
 
 See [TRANSPORT.md](./TRANSPORT.md) for the full architecture guide.
 
+## How It Works
+
+See [EDUCATIONAL.md](./EDUCATIONAL.md) for an in-depth explanation of the math and timing models behind audio transport systems.
+
 ## License
 
 MIT

package/dist/index.d.mts

@@ -40,6 +40,10 @@ interface TransportOptions {
     denominator?: number;
     /** How far ahead to schedule audio, in seconds. Default: 0.2 */
     schedulerLookahead?: number;
+    /** Accent click frequency in Hz. Default: 1000 */
+    accentFrequency?: number;
+    /** Normal click frequency in Hz. Default: 800 */
+    normalFrequency?: number;
 }
 /** Public return type for getMeter() */
 interface MeterSignature {
@@ -57,11 +61,20 @@ interface MeterEntry {
     /** Cached cumulative bar count from tick 0 to this entry. Derived — do not set manually. */
     readonly barAtTick: number;
 }
+/** How to interpolate tempo from the previous entry to this one.
+ *  'step' = instant jump (default). 'linear' = linear ramp.
+ *  { type: 'curve', slope } = Möbius-Ease curve (slope 0-1 exclusive). */
+type TempoInterpolation = 'step' | 'linear' | {
+    type: 'curve';
+    slope: number;
+};
 interface TempoEntry {
     /** Tick position where this tempo starts */
     tick: Tick;
     /** Beats per minute */
     bpm: number;
+    /** How to arrive at this BPM from the previous entry */
+    readonly interpolation: TempoInterpolation;
     /** Cached cumulative seconds up to this tick (for O(log n) lookup). Derived — do not set manually. */
     readonly secondsAtTick: number;
 }
@@ -75,6 +88,33 @@ interface TransportPosition {
      *  Not branded Tick — a remainder within a beat, not an absolute position. */
     subTick: number;
 }
+/** Count-in mode: 'always' plays count-in on every play(), 'recording-only' only when recording. */
+type CountInMode = 'always' | 'recording-only';
+/** Payload emitted with the 'countIn' transport event.
+ *  Example: beat=1, totalBeats=4 means "first of four beats". */
+interface CountInEventData {
+    /** Current beat number (1-indexed) */
+    beat: number;
+    /** Total number of beats in the count-in */
+    totalBeats: number;
+}
+/** Payload emitted with the 'tempochange' transport event. */
+interface TempoChangeEventData {
+    /** The new BPM value */
+    bpm: number;
+    /** Tick position where the tempo was set */
+    atTick: Tick;
+}
+/** Payload emitted with the 'meterchange' transport event.
+ *  After removeMeter/clearMeters, reflects the resulting meter at that position. */
+interface MeterChangeEventData {
+    /** Time signature numerator */
+    numerator: number;
+    /** Time signature denominator */
+    denominator: number;
+    /** Tick position where the meter was set or removed */
+    atTick: Tick;
+}
 
 declare class Clock {
     private _audioContext;
@@ -95,19 +135,52 @@ declare class Clock {
     isRunning(): boolean;
 }
 
+interface SetTempoOptions {
+    interpolation?: TempoInterpolation;
+}
 declare class TempoMap {
     private _ppqn;
     private _entries;
     constructor(ppqn?: number, initialBpm?: number);
     getTempo(atTick?: Tick): number;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     ticksToSeconds(ticks: Tick): number;
     secondsToTicks(seconds: number): Tick;
     beatsToSeconds(beats: number): number;
     secondsToBeats(seconds: number): number;
     clearTempos(): void;
+    /** Get the interpolated BPM at a tick position */
+    private _getTempoAt;
     private _ticksToSecondsInternal;
-    private _entryAt;
+    /**
+     * Exact integration for a linear BPM ramp using the logarithmic formula.
+     * For bpm(t) = bpm0 + r*t where r = (bpm1-bpm0)/T:
+     *   seconds = (T * 60) / (ppqn * (bpm1-bpm0)) * ln(bpmAtTick / bpm0)
+     */
+    private _ticksToSecondsLinear;
+    /**
+     * Inverse of _ticksToSecondsLinear: given seconds, return ticks.
+     * Closed-form via exponential: bpmAtTick = bpm0 * exp(seconds * deltaBpm * ppqn / (60 * T))
+     * then ticks = (bpmAtTick - bpm0) * T / deltaBpm
+     *
+     * Note: exp(log(x)) has ~1 ULP floating-point error, so round-trips depend on
+     * Math.round() in the caller (secondsToTicks). This is sufficient for all tested
+     * BPM ranges (10–300 BPM) but is not algebraically exact like the previous
+     * trapezoidal/quadratic approach was.
+     */
+    private _secondsToTicksLinear;
+    /**
+     * Subdivided trapezoidal integration for a Möbius-Ease tempo curve.
+     * The BPM at progress p is: bpm0 + curveNormalizedAt(p, slope) * (bpm1 - bpm0).
+     * We subdivide into CURVE_SUBDIVISIONS intervals and apply trapezoidal rule.
+     */
+    private _ticksToSecondsCurve;
+    /**
+     * Inverse of _ticksToSecondsCurve: given seconds into a curved segment,
+     * return ticks. Uses binary search since there's no closed-form inverse.
+     */
+    private _secondsToTicksCurve;
+    private _entryIndexAt;
     private _recomputeCache;
 }
 
@@ -287,13 +360,29 @@ declare class MetronomePlayer implements SchedulerListener<MetronomeEvent> {
     silence(): void;
 }
 
+interface CountInEvent extends SchedulerEvent {
+    isAccent: boolean;
+    buffer: AudioBuffer;
+    beat: number;
+    totalBeats: number;
+}
+
+interface ClickSoundOptions {
+    /** Frequency for accent click (beat 1). Default: 1000 Hz */
+    accentFrequency?: number;
+    /** Frequency for normal click (other beats). Default: 800 Hz */
+    normalFrequency?: number;
+}
+
 interface TransportEvents {
     play: () => void;
     pause: () => void;
     stop: () => void;
     loop: () => void;
-    tempochange: () => void;
-    meterchange: () => void;
+    tempochange: (event: TempoChangeEventData) => void;
+    meterchange: (event: MeterChangeEventData) => void;
+    countIn: (event: CountInEventData) => void;
+    countInEnd: () => void;
 }
 type TransportEventType = keyof TransportEvents;
 declare class Transport {
@@ -314,8 +403,22 @@ declare class Transport {
     private _playing;
     private _endTime;
     private _loopEnabled;
+    private _loopStartTick;
     private _loopStartSeconds;
     private _listeners;
+    private _countInEnabled;
+    private _countInBars;
+    private _countInMode;
+    private _recording;
+    private _countingIn;
+    private _countInStartPosition;
+    private _countInDuration;
+    private _countInPlayer;
+    private _countInScheduler;
+    private _accentBuffer;
+    private _normalBuffer;
+    private _schedulerLookahead;
+    private _ppqn;
     constructor(audioContext: AudioContext, options?: TransportOptions);
     get audioContext(): AudioContext;
     play(startTime?: number, endTime?: number): void;
@@ -339,7 +442,7 @@ declare class Transport {
     setLoopSeconds(enabled: boolean, startSec: number, endSec: number): void;
     /** Convenience — sets loop in samples */
     setLoopSamples(enabled: boolean, startSample: Sample, endSample: Sample): void;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     getTempo(atTick?: Tick): number;
     setMeter(numerator: number, denominator: number, atTick?: Tick): void;
     getMeter(atTick?: Tick): MeterSignature;
@@ -354,6 +457,13 @@ declare class Transport {
     tickToTime(tick: Tick): number;
     setMetronomeEnabled(enabled: boolean): void;
     setMetronomeClickSounds(accent: AudioBuffer, normal: AudioBuffer): void;
+    static readonly MIN_COUNT_IN_BARS = 1;
+    static readonly MAX_COUNT_IN_BARS = 8;
+    setCountIn(enabled: boolean): void;
+    setCountInBars(bars: number): void;
+    setCountInMode(mode: CountInMode): void;
+    setRecording(recording: boolean): void;
+    isCountingIn(): boolean;
     connectTrackOutput(trackId: string, node: AudioNode): void;
     disconnectTrackOutput(trackId: string): void;
     on<K extends TransportEventType>(event: K, cb: TransportEvents[K]): void;
@@ -361,6 +471,11 @@ declare class Transport {
     dispose(): void;
     private static _validateOptions;
     private _initAudioGraph;
+    private _initCountIn;
+    private _shouldCountIn;
+    private _startCountIn;
+    private _finishCountIn;
+    private _cancelCountIn;
     private _silenceAll;
     private _applyMuteState;
     private _emit;
@@ -388,7 +503,12 @@ declare class NativePlayoutAdapter implements PlayoutAdapter {
     setTrackSolo(trackId: string, soloed: boolean): void;
     setTrackPan(trackId: string, pan: number): void;
     setLoop(enabled: boolean, start: number, end: number): void;
+    setCountIn(enabled: boolean): void;
+    setCountInBars(bars: number): void;
+    setCountInMode(mode: CountInMode): void;
+    setRecording(recording: boolean): void;
+    isCountingIn(): boolean;
     dispose(): void;
 }
 
-export { type ClipEvent, ClipPlayer, Clock, MasterNode, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type TempoEntry, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };
+export { type ClickSoundOptions, type ClipEvent, ClipPlayer, Clock, type CountInEvent, type CountInEventData, type CountInMode, MasterNode, type MeterChangeEventData, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type SetTempoOptions, type TempoChangeEventData, type TempoEntry, type TempoInterpolation, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };

package/dist/index.d.ts

@@ -40,6 +40,10 @@ interface TransportOptions {
     denominator?: number;
     /** How far ahead to schedule audio, in seconds. Default: 0.2 */
     schedulerLookahead?: number;
+    /** Accent click frequency in Hz. Default: 1000 */
+    accentFrequency?: number;
+    /** Normal click frequency in Hz. Default: 800 */
+    normalFrequency?: number;
 }
 /** Public return type for getMeter() */
 interface MeterSignature {
@@ -57,11 +61,20 @@ interface MeterEntry {
     /** Cached cumulative bar count from tick 0 to this entry. Derived — do not set manually. */
     readonly barAtTick: number;
 }
+/** How to interpolate tempo from the previous entry to this one.
+ *  'step' = instant jump (default). 'linear' = linear ramp.
+ *  { type: 'curve', slope } = Möbius-Ease curve (slope 0-1 exclusive). */
+type TempoInterpolation = 'step' | 'linear' | {
+    type: 'curve';
+    slope: number;
+};
 interface TempoEntry {
     /** Tick position where this tempo starts */
     tick: Tick;
     /** Beats per minute */
     bpm: number;
+    /** How to arrive at this BPM from the previous entry */
+    readonly interpolation: TempoInterpolation;
     /** Cached cumulative seconds up to this tick (for O(log n) lookup). Derived — do not set manually. */
     readonly secondsAtTick: number;
 }
@@ -75,6 +88,33 @@ interface TransportPosition {
      *  Not branded Tick — a remainder within a beat, not an absolute position. */
     subTick: number;
 }
+/** Count-in mode: 'always' plays count-in on every play(), 'recording-only' only when recording. */
+type CountInMode = 'always' | 'recording-only';
+/** Payload emitted with the 'countIn' transport event.
+ *  Example: beat=1, totalBeats=4 means "first of four beats". */
+interface CountInEventData {
+    /** Current beat number (1-indexed) */
+    beat: number;
+    /** Total number of beats in the count-in */
+    totalBeats: number;
+}
+/** Payload emitted with the 'tempochange' transport event. */
+interface TempoChangeEventData {
+    /** The new BPM value */
+    bpm: number;
+    /** Tick position where the tempo was set */
+    atTick: Tick;
+}
+/** Payload emitted with the 'meterchange' transport event.
+ *  After removeMeter/clearMeters, reflects the resulting meter at that position. */
+interface MeterChangeEventData {
+    /** Time signature numerator */
+    numerator: number;
+    /** Time signature denominator */
+    denominator: number;
+    /** Tick position where the meter was set or removed */
+    atTick: Tick;
+}
 
 declare class Clock {
     private _audioContext;
@@ -95,19 +135,52 @@ declare class Clock {
     isRunning(): boolean;
 }
 
+interface SetTempoOptions {
+    interpolation?: TempoInterpolation;
+}
 declare class TempoMap {
     private _ppqn;
     private _entries;
     constructor(ppqn?: number, initialBpm?: number);
     getTempo(atTick?: Tick): number;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     ticksToSeconds(ticks: Tick): number;
     secondsToTicks(seconds: number): Tick;
     beatsToSeconds(beats: number): number;
     secondsToBeats(seconds: number): number;
     clearTempos(): void;
+    /** Get the interpolated BPM at a tick position */
+    private _getTempoAt;
     private _ticksToSecondsInternal;
-    private _entryAt;
+    /**
+     * Exact integration for a linear BPM ramp using the logarithmic formula.
+     * For bpm(t) = bpm0 + r*t where r = (bpm1-bpm0)/T:
+     *   seconds = (T * 60) / (ppqn * (bpm1-bpm0)) * ln(bpmAtTick / bpm0)
+     */
+    private _ticksToSecondsLinear;
+    /**
+     * Inverse of _ticksToSecondsLinear: given seconds, return ticks.
+     * Closed-form via exponential: bpmAtTick = bpm0 * exp(seconds * deltaBpm * ppqn / (60 * T))
+     * then ticks = (bpmAtTick - bpm0) * T / deltaBpm
+     *
+     * Note: exp(log(x)) has ~1 ULP floating-point error, so round-trips depend on
+     * Math.round() in the caller (secondsToTicks). This is sufficient for all tested
+     * BPM ranges (10–300 BPM) but is not algebraically exact like the previous
+     * trapezoidal/quadratic approach was.
+     */
+    private _secondsToTicksLinear;
+    /**
+     * Subdivided trapezoidal integration for a Möbius-Ease tempo curve.
+     * The BPM at progress p is: bpm0 + curveNormalizedAt(p, slope) * (bpm1 - bpm0).
+     * We subdivide into CURVE_SUBDIVISIONS intervals and apply trapezoidal rule.
+     */
+    private _ticksToSecondsCurve;
+    /**
+     * Inverse of _ticksToSecondsCurve: given seconds into a curved segment,
+     * return ticks. Uses binary search since there's no closed-form inverse.
+     */
+    private _secondsToTicksCurve;
+    private _entryIndexAt;
     private _recomputeCache;
 }
 
@@ -287,13 +360,29 @@ declare class MetronomePlayer implements SchedulerListener<MetronomeEvent> {
     silence(): void;
 }
 
+interface CountInEvent extends SchedulerEvent {
+    isAccent: boolean;
+    buffer: AudioBuffer;
+    beat: number;
+    totalBeats: number;
+}
+
+interface ClickSoundOptions {
+    /** Frequency for accent click (beat 1). Default: 1000 Hz */
+    accentFrequency?: number;
+    /** Frequency for normal click (other beats). Default: 800 Hz */
+    normalFrequency?: number;
+}
+
 interface TransportEvents {
     play: () => void;
     pause: () => void;
     stop: () => void;
     loop: () => void;
-    tempochange: () => void;
-    meterchange: () => void;
+    tempochange: (event: TempoChangeEventData) => void;
+    meterchange: (event: MeterChangeEventData) => void;
+    countIn: (event: CountInEventData) => void;
+    countInEnd: () => void;
 }
 type TransportEventType = keyof TransportEvents;
 declare class Transport {
@@ -314,8 +403,22 @@ declare class Transport {
     private _playing;
     private _endTime;
     private _loopEnabled;
+    private _loopStartTick;
     private _loopStartSeconds;
     private _listeners;
+    private _countInEnabled;
+    private _countInBars;
+    private _countInMode;
+    private _recording;
+    private _countingIn;
+    private _countInStartPosition;
+    private _countInDuration;
+    private _countInPlayer;
+    private _countInScheduler;
+    private _accentBuffer;
+    private _normalBuffer;
+    private _schedulerLookahead;
+    private _ppqn;
     constructor(audioContext: AudioContext, options?: TransportOptions);
     get audioContext(): AudioContext;
     play(startTime?: number, endTime?: number): void;
@@ -339,7 +442,7 @@ declare class Transport {
     setLoopSeconds(enabled: boolean, startSec: number, endSec: number): void;
     /** Convenience — sets loop in samples */
     setLoopSamples(enabled: boolean, startSample: Sample, endSample: Sample): void;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     getTempo(atTick?: Tick): number;
     setMeter(numerator: number, denominator: number, atTick?: Tick): void;
     getMeter(atTick?: Tick): MeterSignature;
@@ -354,6 +457,13 @@ declare class Transport {
     tickToTime(tick: Tick): number;
     setMetronomeEnabled(enabled: boolean): void;
     setMetronomeClickSounds(accent: AudioBuffer, normal: AudioBuffer): void;
+    static readonly MIN_COUNT_IN_BARS = 1;
+    static readonly MAX_COUNT_IN_BARS = 8;
+    setCountIn(enabled: boolean): void;
+    setCountInBars(bars: number): void;
+    setCountInMode(mode: CountInMode): void;
+    setRecording(recording: boolean): void;
+    isCountingIn(): boolean;
     connectTrackOutput(trackId: string, node: AudioNode): void;
     disconnectTrackOutput(trackId: string): void;
     on<K extends TransportEventType>(event: K, cb: TransportEvents[K]): void;
@@ -361,6 +471,11 @@ declare class Transport {
     dispose(): void;
     private static _validateOptions;
     private _initAudioGraph;
+    private _initCountIn;
+    private _shouldCountIn;
+    private _startCountIn;
+    private _finishCountIn;
+    private _cancelCountIn;
     private _silenceAll;
     private _applyMuteState;
     private _emit;
@@ -388,7 +503,12 @@ declare class NativePlayoutAdapter implements PlayoutAdapter {
     setTrackSolo(trackId: string, soloed: boolean): void;
     setTrackPan(trackId: string, pan: number): void;
     setLoop(enabled: boolean, start: number, end: number): void;
+    setCountIn(enabled: boolean): void;
+    setCountInBars(bars: number): void;
+    setCountInMode(mode: CountInMode): void;
+    setRecording(recording: boolean): void;
+    isCountingIn(): boolean;
     dispose(): void;
 }
 
-export { type ClipEvent, ClipPlayer, Clock, MasterNode, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type TempoEntry, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };
+export { type ClickSoundOptions, type ClipEvent, ClipPlayer, Clock, type CountInEvent, type CountInEventData, type CountInMode, MasterNode, type MeterChangeEventData, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type SetTempoOptions, type TempoChangeEventData, type TempoEntry, type TempoInterpolation, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };