@dawcore/components 0.0.5 → 0.0.8

package/dist/index.js

@@ -1668,18 +1668,22 @@ var ViewportController = class {
 };
 
 // src/controllers/audio-resume-controller.ts
-var import_playout = require("@waveform-playlist/playout");
 var AudioResumeController = class {
   constructor(host) {
     this._target = null;
     this._attached = false;
     this._generation = 0;
     this._onGesture = (e) => {
-      (0, import_playout.resumeGlobalAudioContext)().catch((err) => {
-        console.warn(
-          "[dawcore] AudioResumeController: eager resume failed, will retry on play: " + String(err)
-        );
-      });
+      const ctx = this._host.audioContext;
+      if (ctx.state === "closed") {
+        console.warn("[dawcore] AudioResumeController: AudioContext is closed, cannot resume.");
+      } else if (ctx.state === "suspended") {
+        ctx.resume().catch((err) => {
+          console.warn(
+            "[dawcore] AudioResumeController: eager resume failed, will retry on play: " + String(err)
+          );
+        });
+      }
       const otherType = e.type === "pointerdown" ? "keydown" : "pointerdown";
       this._target?.removeEventListener(otherType, this._onGesture, {
         capture: true
@@ -1747,13 +1751,12 @@ var AudioResumeController = class {
 };
 
 // src/controllers/recording-controller.ts
-var import_playout2 = require("@waveform-playlist/playout");
 var import_worklets = require("@waveform-playlist/worklets");
 var import_recording = require("@waveform-playlist/recording");
 var RecordingController = class {
   constructor(host) {
     this._sessions = /* @__PURE__ */ new Map();
-    this._workletLoaded = false;
+    this._workletLoadedCtx = null;
     this._host = host;
     host.addController(this);
   }
@@ -1763,6 +1766,7 @@ var RecordingController = class {
     for (const trackId of [...this._sessions.keys()]) {
       this._cleanupSession(trackId);
     }
+    this._workletLoadedCtx = null;
   }
   get isRecording() {
     return this._sessions.size > 0;
@@ -1781,21 +1785,25 @@ var RecordingController = class {
       return;
     }
     const bits = options.bits ?? 16;
-    const context = (0, import_playout2.getGlobalContext)();
-    const rawCtx = context.rawContext;
-    this._host.resolveAudioContextSampleRate(rawCtx.sampleRate);
     try {
-      if (!this._workletLoaded) {
+      const rawCtx = this._host.audioContext;
+      this._host.resolveAudioContextSampleRate(rawCtx.sampleRate);
+      if (!this._workletLoadedCtx || this._workletLoadedCtx !== rawCtx) {
         await rawCtx.audioWorklet.addModule(import_worklets.recordingProcessorUrl);
-        this._workletLoaded = true;
+        this._workletLoadedCtx = rawCtx;
       }
-      const channelCount = stream.getAudioTracks()[0]?.getSettings()?.channelCount ?? 1;
+      const detectedChannelCount = stream.getAudioTracks()[0]?.getSettings()?.channelCount;
+      if (detectedChannelCount === void 0 && options.channelCount !== void 0) {
+        console.warn(
+          "[dawcore] Could not detect stream channel count, using fallback: " + options.channelCount
+        );
+      }
+      const channelCount = detectedChannelCount ?? options.channelCount ?? 1;
       const startSample = options.startSample ?? Math.floor(this._host._currentTime * this._host.effectiveSampleRate);
       const outputLatency = rawCtx.outputLatency ?? 0;
-      const lookAhead = context.lookAhead ?? 0;
-      const latencySamples = Math.floor((outputLatency + lookAhead) * rawCtx.sampleRate);
-      const source = context.createMediaStreamSource(stream);
-      const workletNode = context.createAudioWorkletNode("recording-processor", {
+      const latencySamples = Math.floor(outputLatency * rawCtx.sampleRate);
+      const source = rawCtx.createMediaStreamSource(stream);
+      const workletNode = new AudioWorkletNode(rawCtx, "recording-processor", {
         channelCount,
         channelCountMode: "explicit"
       });
@@ -1896,8 +1904,7 @@ var RecordingController = class {
       );
       return;
     }
-    const context = (0, import_playout2.getGlobalContext)();
-    const stopCtx = context.rawContext;
+    const stopCtx = this._host.audioContext;
     const channelData = session.chunks.map((chunkArr) => (0, import_recording.concatenateAudioData)(chunkArr));
     const audioBuffer = (0, import_recording.createAudioBuffer)(
       stopCtx,
@@ -2869,6 +2876,9 @@ var DawEditorElement = class extends import_lit12.LitElement {
     this._selectionStartTime = 0;
     this._selectionEndTime = 0;
     this._currentTime = 0;
+    /** Consumer-provided AudioContext. When set, used for decode, playback, and recording. */
+    this._externalAudioContext = null;
+    this._ownedAudioContext = null;
     this._engine = null;
     this._enginePromise = null;
     this._audioCache = /* @__PURE__ */ new Map();
@@ -2963,7 +2973,6 @@ var DawEditorElement = class extends import_lit12.LitElement {
         this._onTrackRemoved(trackId);
       }
     };
-    this._contextConfigurePromise = null;
     // --- File Drop ---
     this._onDragOver = (e) => {
       if (!this.fileDrop) return;
@@ -3015,6 +3024,31 @@ var DawEditorElement = class extends import_lit12.LitElement {
     this._samplesPerPixel = clamped;
     this.requestUpdate("samplesPerPixel", old);
   }
+  /** Set an AudioContext to use for all audio operations. Must be set before tracks load. */
+  set audioContext(ctx) {
+    if (ctx && ctx.state === "closed") {
+      console.warn("[dawcore] Provided AudioContext is already closed. Ignoring.");
+      return;
+    }
+    if (this._engine) {
+      console.warn(
+        "[dawcore] audioContext set after engine is built. The engine will continue using the previous context."
+      );
+    }
+    this._externalAudioContext = ctx;
+  }
+  get audioContext() {
+    if (this._externalAudioContext) return this._externalAudioContext;
+    if (!this._ownedAudioContext) {
+      this._ownedAudioContext = new AudioContext({ sampleRate: this.sampleRate });
+      if (this._ownedAudioContext.sampleRate !== this.sampleRate) {
+        console.warn(
+          "[dawcore] Requested sampleRate " + this.sampleRate + " but AudioContext is running at " + this._ownedAudioContext.sampleRate
+        );
+      }
+    }
+    return this._ownedAudioContext;
+  }
   get _clipHandler() {
     return this.interactiveClips ? this._clipPointer : null;
   }
@@ -3115,12 +3149,17 @@ var DawEditorElement = class extends import_lit12.LitElement {
     this._clipOffsets.clear();
     this._peakPipeline.terminate();
     this._minSamplesPerPixel = 0;
-    this._contextConfigurePromise = null;
     try {
       this._disposeEngine();
     } catch (err) {
       console.warn("[dawcore] Error disposing engine: " + String(err));
     }
+    if (this._ownedAudioContext) {
+      this._ownedAudioContext.close().catch((err) => {
+        console.warn("[dawcore] Error closing AudioContext: " + String(err));
+      });
+      this._ownedAudioContext = null;
+    }
   }
   willUpdate(changedProperties) {
     if (changedProperties.has("eagerResume")) {
@@ -3225,9 +3264,7 @@ var DawEditorElement = class extends import_lit12.LitElement {
         if (waveformDataPromise) {
           try {
             const wd = await waveformDataPromise;
-            await this._ensureContextConfigured();
-            const { getGlobalAudioContext } = await import("@waveform-playlist/playout");
-            const contextRate = getGlobalAudioContext().sampleRate;
+            const contextRate = this.audioContext.sampleRate;
             if (wd.sample_rate === contextRate) {
               waveformData = wd;
             } else {
@@ -3359,30 +3396,6 @@ var DawEditorElement = class extends import_lit12.LitElement {
       );
     }
   }
-  /**
-   * Ensure the global AudioContext is configured with the editor's sample-rate hint
-   * before the first audio operation. Idempotent — concurrent callers await the
-   * same promise so no one proceeds to getGlobalAudioContext() before configuration.
-   */
-  _ensureContextConfigured() {
-    if (!this._contextConfigurePromise) {
-      this._contextConfigurePromise = (async () => {
-        const { configureGlobalContext } = await import("@waveform-playlist/playout");
-        const actualRate = configureGlobalContext({
-          sampleRate: this.sampleRate
-        });
-        if (actualRate !== this.sampleRate) {
-          console.warn(
-            "[dawcore] Requested sampleRate " + this.sampleRate + " but AudioContext is running at " + actualRate
-          );
-        }
-      })().catch((err) => {
-        this._contextConfigurePromise = null;
-        throw err;
-      });
-    }
-    return this._contextConfigurePromise;
-  }
   async _fetchAndDecode(src) {
     if (this._audioCache.has(src)) {
       return this._audioCache.get(src);
@@ -3395,9 +3408,7 @@ var DawEditorElement = class extends import_lit12.LitElement {
         );
       }
       const arrayBuffer = await response.arrayBuffer();
-      await this._ensureContextConfigured();
-      const { getGlobalAudioContext } = await import("@waveform-playlist/playout");
-      return getGlobalAudioContext().decodeAudioData(arrayBuffer);
+      return this.audioContext.decodeAudioData(arrayBuffer);
     })();
     this._audioCache.set(src, promise);
     try {
@@ -3438,11 +3449,11 @@ var DawEditorElement = class extends import_lit12.LitElement {
     return this._enginePromise;
   }
   async _buildEngine() {
-    const [{ PlaylistEngine }, { createToneAdapter }] = await Promise.all([
+    const [{ PlaylistEngine }, { NativePlayoutAdapter }] = await Promise.all([
       import("@waveform-playlist/engine"),
-      import("@waveform-playlist/playout")
+      import("@dawcore/transport")
     ]);
-    const adapter = createToneAdapter();
+    const adapter = new NativePlayoutAdapter(this.audioContext);
     const engine = new PlaylistEngine({
       adapter,
       sampleRate: this.effectiveSampleRate,
@@ -3640,8 +3651,12 @@ var DawEditorElement = class extends import_lit12.LitElement {
     const playhead = this._getPlayhead();
     if (!playhead || !this._engine) return;
     const engine = this._engine;
+    const ctx = this.audioContext;
     playhead.startAnimation(
-      () => engine.getCurrentTime(),
+      () => {
+        const latency = "outputLatency" in ctx ? ctx.outputLatency : 0;
+        return Math.max(0, engine.getCurrentTime() - latency);
+      },
       this.effectiveSampleRate,
       this.samplesPerPixel
     );