@dawcore/components 0.0.4 → 0.0.7

package/dist/index.mjs

@@ -755,7 +755,12 @@ DawStopButtonElement = __decorateClass([
 // src/elements/daw-editor.ts
 import { LitElement as LitElement8, html as html7, css as css7 } from "lit";
 import { customElement as customElement10, property as property6, state as state3 } from "lit/decorators.js";
-import { createClipFromSeconds as createClipFromSeconds2, createTrack as createTrack2, clipPixelWidth } from "@waveform-playlist/core";
+import {
+  createClip as createClip2,
+  createClipFromSeconds as createClipFromSeconds2,
+  createTrack as createTrack2,
+  clipPixelWidth
+} from "@waveform-playlist/core";
 
 // src/workers/peaksWorker.ts
 import WaveformData from "waveform-data";
@@ -1617,18 +1622,22 @@ var ViewportController = class {
 };
 
 // src/controllers/audio-resume-controller.ts
-import { resumeGlobalAudioContext } from "@waveform-playlist/playout";
 var AudioResumeController = class {
   constructor(host) {
     this._target = null;
     this._attached = false;
     this._generation = 0;
     this._onGesture = (e) => {
-      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
@@ -1696,13 +1705,12 @@ var AudioResumeController = class {
 };
 
 // src/controllers/recording-controller.ts
-import { getGlobalContext } from "@waveform-playlist/playout";
 import { recordingProcessorUrl } from "@waveform-playlist/worklets";
 import { appendPeaks, concatenateAudioData, createAudioBuffer } from "@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);
   }
@@ -1712,6 +1720,7 @@ var RecordingController = class {
     for (const trackId of [...this._sessions.keys()]) {
       this._cleanupSession(trackId);
     }
+    this._workletLoadedCtx = null;
   }
   get isRecording() {
     return this._sessions.size > 0;
@@ -1730,21 +1739,25 @@ var RecordingController = class {
       return;
     }
     const bits = options.bits ?? 16;
-    const context = 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(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"
       });
@@ -1845,8 +1858,7 @@ var RecordingController = class {
       );
       return;
     }
-    const context = getGlobalContext();
-    const stopCtx = context.rawContext;
+    const stopCtx = this._host.audioContext;
     const channelData = session.chunks.map((chunkArr) => concatenateAudioData(chunkArr));
     const audioBuffer = createAudioBuffer(
       stopCtx,
@@ -2818,6 +2830,9 @@ var DawEditorElement = class extends LitElement8 {
     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,6 +2978,31 @@ var DawEditorElement = class extends LitElement8 {
     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;
   }
@@ -3068,6 +3108,12 @@ var DawEditorElement = class extends LitElement8 {
     } 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")) {
@@ -3171,7 +3217,15 @@ var DawEditorElement = class extends LitElement8 {
         let waveformData = null;
         if (waveformDataPromise) {
           try {
-            waveformData = await waveformDataPromise;
+            const wd = await waveformDataPromise;
+            const contextRate = this.audioContext.sampleRate;
+            if (wd.sample_rate === contextRate) {
+              waveformData = wd;
+            } else {
+              console.warn(
+                "[dawcore] Pre-computed peaks at " + wd.sample_rate + " Hz do not match AudioContext at " + contextRate + " Hz \u2014 ignoring " + clipDesc.peaksSrc + ", generating from audio"
+              );
+            }
           } catch (err) {
             console.warn(
               "[dawcore] Failed to load peaks from " + clipDesc.peaksSrc + ": " + String(err) + " \u2014 falling back to AudioBuffer generation"
@@ -3179,15 +3233,16 @@ var DawEditorElement = class extends LitElement8 {
           }
         }
         if (waveformData) {
-          const clip2 = createClipFromSeconds2({
+          const wdRate = waveformData.sample_rate;
+          const clip2 = createClip2({
             waveformData,
-            startTime: clipDesc.start,
-            duration: clipDesc.duration || waveformData.duration,
-            offset: clipDesc.offset,
+            startSample: Math.round(clipDesc.start * wdRate),
+            durationSamples: Math.round((clipDesc.duration || waveformData.duration) * wdRate),
+            offsetSamples: Math.round(clipDesc.offset * wdRate),
             gain: clipDesc.gain,
             name: clipDesc.name,
-            sampleRate: waveformData.sample_rate,
-            sourceDuration: waveformData.duration
+            sampleRate: wdRate,
+            sourceDurationSamples: Math.ceil(waveformData.duration * wdRate)
           });
           const effectiveScale = Math.max(this.samplesPerPixel, waveformData.scale);
           const peakData2 = extractPeaks(
@@ -3307,8 +3362,7 @@ var DawEditorElement = class extends LitElement8 {
         );
       }
       const arrayBuffer = await response.arrayBuffer();
-      const { getGlobalAudioContext } = await import("@waveform-playlist/playout");
-      return getGlobalAudioContext().decodeAudioData(arrayBuffer);
+      return this.audioContext.decodeAudioData(arrayBuffer);
     })();
     this._audioCache.set(src, promise);
     try {
@@ -3349,11 +3403,11 @@ var DawEditorElement = class extends LitElement8 {
     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,