fix: isolate native transport clocks

Author: ChuxiJ

src/engine/bridge/TauriBackend.ts

@@ -282,6 +282,11 @@ export class TauriBackend implements AudioBridge {
   // ── Metering ──────────────────────────────────────────────────────
 
   getTrackMeter(_trackId: string): MeterData {
+    const scheduledClipMeter = this.getScheduledClipTrackMeter(_trackId);
+    if (scheduledClipMeter) {
+      this._trackMeters.set(_trackId, scheduledClipMeter);
+      return scheduledClipMeter;
+    }
     const entry = this._trackEntries.get(_trackId);
     if (entry?.handle && this.shouldRefreshTrackMeter(_trackId)) {
       invoke<NativeMeterReading>('audio_get_track_meter', { handle: entry.handle })
@@ -407,6 +412,49 @@ export class TauriBackend implements AudioBridge {
       .filter((clip): clip is NativeClipSource => clip !== null);
   }
 
+  private getScheduledClipTrackMeter(trackId: string): MeterData | null {
+    const trackClips = this._lastScheduledClips.filter((clip) => clip.trackId === trackId);
+    if (trackClips.length === 0) return null;
+
+    const params = this._trackEntries.get(trackId)?.params ?? {
+      volume: 1,
+      pan: 0,
+      mute: false,
+      solo: false,
+    };
+    const anySoloed = Array.from(this._trackEntries.values()).some((entry) => entry.params.solo);
+    if (params.mute || (anySoloed && !params.solo)) return ZERO_METER;
+
+    const currentTime = this.getCurrentTime();
+    const pan = getPanGains(params.pan);
+    const volume = Math.max(0, Math.min(1, Number.isFinite(params.volume) ? params.volume : 1));
+    let leftLevel = 0;
+    let rightLevel = 0;
+
+    for (const clip of trackClips) {
+      const clipEndTime = clip.startTime + clip.clipDuration;
+      if (currentTime < clip.startTime || currentTime >= clipEndTime) continue;
+      const sourceRate = clip.buffer.sampleRate || this.sampleRate;
+      const sourceTime = clip.audioOffset + (currentTime - clip.startTime);
+      const sampleIndex = Math.min(
+        clip.buffer.length - 1,
+        Math.max(0, Math.round(sourceTime * sourceRate)),
+      );
+      const left = clip.buffer.getChannelData(0);
+      const right = clip.buffer.numberOfChannels > 1 ? clip.buffer.getChannelData(1) : left;
+      leftLevel = Math.max(leftLevel, Math.abs(left[sampleIndex] ?? 0) * volume * pan.left);
+      rightLevel = Math.max(rightLevel, Math.abs(right[sampleIndex] ?? 0) * volume * pan.right);
+    }
+
+    const level = Math.max(leftLevel, rightLevel);
+    return {
+      level,
+      leftLevel,
+      rightLevel,
+      clipped: level >= 1,
+    };
+  }
+
   private meterNowMs(): number {
     return typeof performance !== 'undefined' ? performance.now() : Date.now();
   }

src/engine/bridge/__tests__/TauriBackend.test.ts

@@ -477,6 +477,27 @@ describe('TauriBackend', () => {
     expect(invokeMock).toHaveBeenCalledWith('audio_get_track_meter', expect.any(Object));
   });
 
+  it('reflects active native clip audio in track meters', () => {
+    const buffer = createMockAudioBuffer([0.5]);
+    const centerPan = equalPowerPan(0);
+
+    backend.schedulePlayback([
+      {
+        clipId: 'clip-1',
+        trackId: 'track-1',
+        startTime: 0,
+        buffer,
+        audioOffset: 0,
+        clipDuration: 1 / 48000,
+      },
+    ], 0, 1);
+
+    const meter = backend.getTrackMeter('track-1');
+    expect(meter.level).toBeCloseTo(0.5 * Math.max(centerPan.left, centerPan.right));
+    expect(meter.leftLevel).toBeCloseTo(0.5 * centerPan.left);
+    expect(meter.rightLevel).toBeCloseTo(0.5 * centerPan.right);
+  });
+
   it('throttles track meter refreshes while a native request is in flight', async () => {
     invokeMock.mockResolvedValueOnce({ slot: 0, generation: 1 });
     backend.ensureTrack('track-1');

src/hooks/__tests__/useAudioEngine.test.ts

@@ -34,7 +34,14 @@ vi.mock('../../engine/bridge', () => ({
   getAudioBridge: vi.fn(() => mockBridge),
 }));
 
-import { getAudioEngine, getExistingAudioEngine, _setAudioResumed, useAudioEngine } from '../useAudioEngine';
+import {
+  getAudioEngine,
+  getExistingAudioEngine,
+  getTauriPlaybackClockOwner,
+  setTauriPlaybackClockOwner,
+  _setAudioResumed,
+  useAudioEngine,
+} from '../useAudioEngine';
 import { useTransportStore } from '../../store/transportStore';
 import { useProjectStore } from '../../store/projectStore';
 
@@ -48,6 +55,7 @@ describe('useAudioEngine', () => {
     mockBridge.backend = 'web-audio';
     mockBridge.resume.mockReset();
     mockBridge.setTimeUpdateCallback.mockReset();
+    setTauriPlaybackClockOwner('web-audio');
   });
 
   afterEach(() => {
@@ -94,6 +102,22 @@ describe('useAudioEngine', () => {
     engineCallback(2.25);
     expect(useTransportStore.getState().currentTime).toBe(2.25);
 
+    bridgeCallback(3.5);
+    expect(useTransportStore.getState().currentTime).toBe(2.25);
+    expect(getTauriPlaybackClockOwner()).toBe('web-audio');
+  });
+
+  it('uses the Tauri bridge clock when native playback owns transport', () => {
+    mockBridge.backend = 'tauri';
+    setTauriPlaybackClockOwner('native');
+    renderHook(() => useAudioEngine());
+
+    const engineCallback = mockSetTimeUpdateCallback.mock.calls[0][0];
+    const bridgeCallback = mockBridge.setTimeUpdateCallback.mock.calls[0][0];
+
+    engineCallback(2.25);
+    expect(useTransportStore.getState().currentTime).toBe(0);
+
     bridgeCallback(3.5);
     expect(useTransportStore.getState().currentTime).toBe(3.5);
   });

src/hooks/__tests__/useTransport.strudel.test.ts

@@ -18,6 +18,10 @@ const mocks = vi.hoisted(() => ({
     masterVolume: 1,
     playing: false,
   },
+  tauriClock: { owner: 'web-audio' as 'native' | 'web-audio' },
+  setTauriPlaybackClockOwner: vi.fn((owner: 'native' | 'web-audio') => {
+    mocks.tauriClock.owner = owner;
+  }),
   stopRecording: vi.fn(async () => {}),
   onLoopCycle: vi.fn(async () => {}),
   stopAllStrudelTracks: vi.fn(),
@@ -27,6 +31,8 @@ const mocks = vi.hoisted(() => ({
 vi.mock('tone', () => ({}));
 vi.mock('../useAudioEngine', () => ({
   getAudioEngine: () => mocks.engine,
+  getTauriPlaybackClockOwner: () => mocks.tauriClock.owner,
+  setTauriPlaybackClockOwner: (owner: 'native' | 'web-audio') => mocks.setTauriPlaybackClockOwner(owner),
 }));
 vi.mock('../useRecording', () => ({
   useRecording: () => ({
@@ -83,6 +89,7 @@ import { useUIStore } from '../../store/uiStore';
 describe('useTransport strudel controls', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    mocks.tauriClock.owner = 'web-audio';
     useProjectStore.getState().createProject('Transport Test');
     useTransportStore.setState({
       isPlaying: true,

src/hooks/__tests__/useTransport.test.ts

@@ -34,6 +34,10 @@ const mocks = vi.hoisted(() => ({
     setTrackMute: vi.fn(),
     setTrackSolo: vi.fn(),
   },
+  tauriClock: { owner: 'web-audio' as 'native' | 'web-audio' },
+  setTauriPlaybackClockOwner: vi.fn((owner: 'native' | 'web-audio') => {
+    mocks.tauriClock.owner = owner;
+  }),
   stopRecording: vi.fn(async () => {}),
   onLoopCycle: vi.fn(async () => {}),
   stopAllStrudelTracks: vi.fn(),
@@ -49,6 +53,8 @@ vi.mock('tone', () => ({
 }));
 vi.mock('../useAudioEngine', () => ({
   getAudioEngine: () => mocks.engine,
+  getTauriPlaybackClockOwner: () => mocks.tauriClock.owner,
+  setTauriPlaybackClockOwner: (owner: 'native' | 'web-audio') => mocks.setTauriPlaybackClockOwner(owner),
 }));
 vi.mock('../useRecording', () => ({
   useRecording: () => ({
@@ -138,6 +144,7 @@ describe('useTransport', () => {
     useProjectStore.getState().createProject({ name: 'Transport Test' });
     useUIStore.setState({ mainView: 'arrangement' });
     mocks.engine.playing = false;
+    mocks.tauriClock.owner = 'web-audio';
   });
 
   // ── play() ──

src/hooks/useAudioEngine.ts

@@ -6,12 +6,21 @@ import { getAudioBridge } from '../engine/bridge';
 
 let _engineInstance: AudioEngine | null = null;
 let _audioResumed = false;
+let _tauriPlaybackClockOwner: 'native' | 'web-audio' = 'web-audio';
 
 /** @internal Set audio-resumed flag — for tests only */
 export function _setAudioResumed(value: boolean) {
   _audioResumed = value;
 }
 
+export function setTauriPlaybackClockOwner(owner: 'native' | 'web-audio') {
+  _tauriPlaybackClockOwner = owner;
+}
+
+export function getTauriPlaybackClockOwner(): 'native' | 'web-audio' {
+  return _tauriPlaybackClockOwner;
+}
+
 export function getAudioEngine(): AudioEngine {
   if (!_engineInstance) {
     _engineInstance = new AudioEngine();
@@ -30,10 +39,12 @@ export function useAudioEngine() {
     const engine = engineRef.current;
     const bridge = getAudioBridge(engine);
     engine.setTimeUpdateCallback((time) => {
+      if (bridge.backend === 'tauri' && _tauriPlaybackClockOwner === 'native') return;
       useTransportStore.getState().setCurrentTime(time);
     });
     if (bridge.backend === 'tauri') {
       bridge.setTimeUpdateCallback((time) => {
+        if (_tauriPlaybackClockOwner !== 'native') return;
         useTransportStore.getState().setCurrentTime(time);
       });
     }

src/hooks/useTransport.ts

@@ -2,8 +2,13 @@ import { useCallback, useEffect, useRef } from 'react';
 import { useTransportStore } from '../store/transportStore';
 import { useProjectStore } from '../store/projectStore';
 import { useUIStore } from '../store/uiStore';
-import { getAudioEngine } from './useAudioEngine';
+import {
+  getAudioEngine,
+  getTauriPlaybackClockOwner,
+  setTauriPlaybackClockOwner,
+} from './useAudioEngine';
 import { getAudioBridge } from '../engine/bridge';
+import type { AudioBridge } from '../engine/bridge/types';
 import { loadAudioBlobByKey } from '../services/audioFileManager';
 import { synthEngine } from '../engine/SynthEngine';
 import { subtractiveEngine } from '../engine/SubtractiveEngine';
@@ -117,6 +122,19 @@ function canUseNativeClipPlayback(project: Project, entries: NativePlaybackEntry
   return !project.tracks.some(trackNeedsWebAudio);
 }
 
+function getActivePlaybackTime(
+  engine: ReturnType<typeof getAudioEngine>,
+  bridge: AudioBridge,
+): number {
+  if (!useTransportStore.getState().isPlaying) {
+    return useTransportStore.getState().currentTime;
+  }
+  if (bridge.backend === 'tauri' && getTauriPlaybackClockOwner() === 'native') {
+    return bridge.getCurrentTime();
+  }
+  return engine.getCurrentTime();
+}
+
 /**
  * Trim an AudioBuffer to a specific project-time region.
  * The input buffer may cover the full project duration; the output covers only
@@ -453,15 +471,18 @@ export function useTransport() {
       && canUseNativeClipPlayback(nextProject, clipBuffers);
 
     if (useNativeClipPlayback) {
+      setTauriPlaybackClockOwner('native');
       bridge.schedulePlayback(clipBuffers, startFrom, effectiveEnd);
       // The native backend owns audio clip playback, but MIDI, synth,
       // sequencer, automation, and Strudel still use AudioEngine's
       // RAF clock until the Rust engine reaches full feature parity.
       engine.schedulePlayback([], startFrom, effectiveEnd);
     } else if (bridge.backend === 'tauri') {
+      setTauriPlaybackClockOwner('web-audio');
       bridge.stopAllSources();
       engine.schedulePlayback(clipBuffers, startFrom, effectiveEnd);
     } else {
+      setTauriPlaybackClockOwner('web-audio');
       // Playback reads from stretchedBufferCache (populated on clip stretch mouseup).
       // If Signalsmith/Rubber Band already finished → high quality buffer used.
       // If neither finished yet → legacy fallback via _getProcessedBuffer.
@@ -835,11 +856,12 @@ export function useTransport() {
     }
     const engine = getAudioEngine();
     const bridge = getAudioBridge(engine);
-    const time = bridge.getCurrentTime();
+    const time = getActivePlaybackTime(engine, bridge);
     finalizeSessionArrangementRecording(time);
     stopStrudelEditorPlayback();
     stopAllStrudelTracks();
     engine.stop();
+    setTauriPlaybackClockOwner('web-audio');
     bridge.pauseAllSources();
     synthEngine.releaseAll();
     subtractiveEngine.releaseAll();
@@ -859,12 +881,11 @@ export function useTransport() {
     }
     const engine = getAudioEngine();
     const bridge = getAudioBridge(engine);
-    const time = engine.playing || bridge.backend === 'tauri'
-      ? bridge.getCurrentTime()
-      : useTransportStore.getState().currentTime;
+    const time = getActivePlaybackTime(engine, bridge);
     finalizeSessionArrangementRecording(time);
     stopStrudelEditorPlayback();
     engine.stop();
+    setTauriPlaybackClockOwner('web-audio');
     bridge.stopAllSources();
     synthEngine.releaseAll();
     subtractiveEngine.releaseAll();
@@ -884,6 +905,7 @@ export function useTransport() {
     stopAllStrudelTracks();
     if (engine.playing || (bridge.backend === 'tauri' && useTransportStore.getState().isPlaying)) {
       engine.stop();
+      setTauriPlaybackClockOwner('web-audio');
       bridge.stopAllSources();
       synthEngine.releaseAll();
       subtractiveEngine.releaseAll();

tests/unit/useTransportScrubLifecycle.test.tsx

@@ -42,6 +42,8 @@ const engineMock = {
 
 vi.mock('../../src/hooks/useAudioEngine', () => ({
   getAudioEngine: () => engineMock,
+  getTauriPlaybackClockOwner: () => 'web-audio',
+  setTauriPlaybackClockOwner: vi.fn(),
 }));
 
 vi.mock('../../src/engine/SynthEngine', () => ({