@dawcore/components 0.0.3 → 0.0.4

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import * as lit from 'lit';
 import { LitElement, PropertyValues, ReactiveController, ReactiveControllerHost } from 'lit';
 import { Peaks, Bits, FadeType, PeakData, ClipTrack, KeyboardShortcut } from '@waveform-playlist/core';
+import WaveformData from 'waveform-data';
 import { PlaylistEngine } from '@waveform-playlist/engine';
 
 declare class DawClipElement extends LitElement {
@@ -184,6 +185,7 @@ interface TrackDescriptor {
 }
 interface ClipDescriptor {
     src: string;
+    peaksSrc: string;
     start: number;
     duration: number;
     offset: number;
@@ -213,6 +215,11 @@ declare class PeakPipeline {
     private _baseScale;
     private _bits;
     constructor(baseScale?: number, bits?: 8 | 16);
+    /**
+     * Inject externally-loaded WaveformData (e.g., from a .dat file) into the cache.
+     * Prevents worker generation for this AudioBuffer on all subsequent calls.
+     */
+    cacheWaveformData(audioBuffer: AudioBuffer, waveformData: WaveformData): void;
     /**
      * Generate PeakData for a clip from its AudioBuffer.
      * Uses cached WaveformData when available; otherwise generates via worker.
@@ -221,14 +228,26 @@ declare class PeakPipeline {
     generatePeaks(audioBuffer: AudioBuffer, samplesPerPixel: number, isMono: boolean, offsetSamples?: number, durationSamples?: number): Promise<PeakData>;
     /**
      * Re-extract peaks for all clips at a new zoom level using cached WaveformData.
-     * Only works for zoom levels coarser than (or equal to) the cached base scale.
-     * Returns a new Map of clipId → PeakData. Clips without cached data or where
-     * the target scale is finer than the cached base are skipped.
+     * Returns a new Map of clipId → PeakData. Clips without cached data are skipped.
+     * When the requested scale is finer than cached data, peaks are clamped to the
+     * cached scale and a single summary warning is logged.
      */
     reextractPeaks(clipBuffers: ReadonlyMap<string, AudioBuffer>, samplesPerPixel: number, isMono: boolean, clipOffsets?: ReadonlyMap<string, {
         offsetSamples: number;
         durationSamples: number;
     }>): Map<string, PeakData>;
+    /**
+     * Clamp requested scale to cached WaveformData scale.
+     * WaveformData.resample() can only go coarser — if the requested zoom is
+     * finer than the cached data, use the cached scale. Set warn=true to log
+     * (default); reextractPeaks passes false and logs a single summary instead.
+     */
+    private _clampScale;
+    /**
+     * Return the coarsest (largest) scale among cached WaveformData entries
+     * that correspond to the given clip buffers. Returns 0 if none are cached.
+     */
+    getMaxCachedScale(clipBuffers: ReadonlyMap<string, AudioBuffer>): number;
     terminate(): void;
     private _getWaveformData;
 }
@@ -516,7 +535,9 @@ interface LoadFilesResult {
 }
 
 declare class DawEditorElement extends LitElement {
-    samplesPerPixel: number;
+    get samplesPerPixel(): number;
+    set samplesPerPixel(value: number);
+    private _samplesPerPixel;
     waveHeight: number;
     timescale: boolean;
     mono: boolean;
@@ -543,12 +564,15 @@ declare class DawEditorElement extends LitElement {
     _engine: PlaylistEngine | null;
     private _enginePromise;
     _audioCache: Map<string, Promise<AudioBuffer>>;
+    private _peaksCache;
     _clipBuffers: Map<string, AudioBuffer>;
     _clipOffsets: Map<string, {
         offsetSamples: number;
         durationSamples: number;
     }>;
     _peakPipeline: PeakPipeline;
+    /** Coarsest scale from pre-computed peaks — zoom cannot go finer than this. 0 = no limit. */
+    private _minSamplesPerPixel;
     private _trackElements;
     private _childObserver;
     private _audioResume;
@@ -588,6 +612,7 @@ declare class DawEditorElement extends LitElement {
     private _readTrackDescriptor;
     private _loadTrack;
     _fetchAndDecode(src: string): Promise<AudioBuffer>;
+    private _fetchPeaks;
     _recomputeDuration(): void;
     _ensureEngine(): Promise<PlaylistEngine>;
     private _buildEngine;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as lit from 'lit';
 import { LitElement, PropertyValues, ReactiveController, ReactiveControllerHost } from 'lit';
 import { Peaks, Bits, FadeType, PeakData, ClipTrack, KeyboardShortcut } from '@waveform-playlist/core';
+import WaveformData from 'waveform-data';
 import { PlaylistEngine } from '@waveform-playlist/engine';
 
 declare class DawClipElement extends LitElement {
@@ -184,6 +185,7 @@ interface TrackDescriptor {
 }
 interface ClipDescriptor {
     src: string;
+    peaksSrc: string;
     start: number;
     duration: number;
     offset: number;
@@ -213,6 +215,11 @@ declare class PeakPipeline {
     private _baseScale;
     private _bits;
     constructor(baseScale?: number, bits?: 8 | 16);
+    /**
+     * Inject externally-loaded WaveformData (e.g., from a .dat file) into the cache.
+     * Prevents worker generation for this AudioBuffer on all subsequent calls.
+     */
+    cacheWaveformData(audioBuffer: AudioBuffer, waveformData: WaveformData): void;
     /**
      * Generate PeakData for a clip from its AudioBuffer.
      * Uses cached WaveformData when available; otherwise generates via worker.
@@ -221,14 +228,26 @@ declare class PeakPipeline {
     generatePeaks(audioBuffer: AudioBuffer, samplesPerPixel: number, isMono: boolean, offsetSamples?: number, durationSamples?: number): Promise<PeakData>;
     /**
      * Re-extract peaks for all clips at a new zoom level using cached WaveformData.
-     * Only works for zoom levels coarser than (or equal to) the cached base scale.
-     * Returns a new Map of clipId → PeakData. Clips without cached data or where
-     * the target scale is finer than the cached base are skipped.
+     * Returns a new Map of clipId → PeakData. Clips without cached data are skipped.
+     * When the requested scale is finer than cached data, peaks are clamped to the
+     * cached scale and a single summary warning is logged.
      */
     reextractPeaks(clipBuffers: ReadonlyMap<string, AudioBuffer>, samplesPerPixel: number, isMono: boolean, clipOffsets?: ReadonlyMap<string, {
         offsetSamples: number;
         durationSamples: number;
     }>): Map<string, PeakData>;
+    /**
+     * Clamp requested scale to cached WaveformData scale.
+     * WaveformData.resample() can only go coarser — if the requested zoom is
+     * finer than the cached data, use the cached scale. Set warn=true to log
+     * (default); reextractPeaks passes false and logs a single summary instead.
+     */
+    private _clampScale;
+    /**
+     * Return the coarsest (largest) scale among cached WaveformData entries
+     * that correspond to the given clip buffers. Returns 0 if none are cached.
+     */
+    getMaxCachedScale(clipBuffers: ReadonlyMap<string, AudioBuffer>): number;
     terminate(): void;
     private _getWaveformData;
 }
@@ -516,7 +535,9 @@ interface LoadFilesResult {
 }
 
 declare class DawEditorElement extends LitElement {
-    samplesPerPixel: number;
+    get samplesPerPixel(): number;
+    set samplesPerPixel(value: number);
+    private _samplesPerPixel;
     waveHeight: number;
     timescale: boolean;
     mono: boolean;
@@ -543,12 +564,15 @@ declare class DawEditorElement extends LitElement {
     _engine: PlaylistEngine | null;
     private _enginePromise;
     _audioCache: Map<string, Promise<AudioBuffer>>;
+    private _peaksCache;
     _clipBuffers: Map<string, AudioBuffer>;
     _clipOffsets: Map<string, {
         offsetSamples: number;
         durationSamples: number;
     }>;
     _peakPipeline: PeakPipeline;
+    /** Coarsest scale from pre-computed peaks — zoom cannot go finer than this. 0 = no limit. */
+    private _minSamplesPerPixel;
     private _trackElements;
     private _childObserver;
     private _audioResume;
@@ -588,6 +612,7 @@ declare class DawEditorElement extends LitElement {
     private _readTrackDescriptor;
     private _loadTrack;
     _fetchAndDecode(src: string): Promise<AudioBuffer>;
+    private _fetchPeaks;
     _recomputeDuration(): void;
     _ensureEngine(): Promise<PlaylistEngine>;
     private _buildEngine;

package/dist/index.js

@@ -1134,6 +1134,13 @@ var PeakPipeline = class {
     this._baseScale = baseScale;
     this._bits = bits;
   }
+  /**
+   * Inject externally-loaded WaveformData (e.g., from a .dat file) into the cache.
+   * Prevents worker generation for this AudioBuffer on all subsequent calls.
+   */
+  cacheWaveformData(audioBuffer, waveformData) {
+    this._cache.set(audioBuffer, waveformData);
+  }
   /**
    * Generate PeakData for a clip from its AudioBuffer.
    * Uses cached WaveformData when available; otherwise generates via worker.
@@ -1141,8 +1148,9 @@ var PeakPipeline = class {
    */
   async generatePeaks(audioBuffer, samplesPerPixel, isMono, offsetSamples, durationSamples) {
     const waveformData = await this._getWaveformData(audioBuffer);
+    const effectiveScale = this._clampScale(waveformData, samplesPerPixel);
     try {
-      return extractPeaks(waveformData, samplesPerPixel, isMono, offsetSamples, durationSamples);
+      return extractPeaks(waveformData, effectiveScale, isMono, offsetSamples, durationSamples);
     } catch (err) {
       console.warn("[dawcore] extractPeaks failed: " + String(err));
       throw err;
@@ -1150,23 +1158,29 @@ var PeakPipeline = class {
   }
   /**
    * Re-extract peaks for all clips at a new zoom level using cached WaveformData.
-   * Only works for zoom levels coarser than (or equal to) the cached base scale.
-   * Returns a new Map of clipId → PeakData. Clips without cached data or where
-   * the target scale is finer than the cached base are skipped.
+   * Returns a new Map of clipId → PeakData. Clips without cached data are skipped.
+   * When the requested scale is finer than cached data, peaks are clamped to the
+   * cached scale and a single summary warning is logged.
    */
   reextractPeaks(clipBuffers, samplesPerPixel, isMono, clipOffsets) {
     const result = /* @__PURE__ */ new Map();
+    let clampedCount = 0;
+    let clampedScale = 0;
     for (const [clipId, audioBuffer] of clipBuffers) {
       const cached = this._cache.get(audioBuffer);
       if (cached) {
-        if (samplesPerPixel < cached.scale) continue;
+        const effectiveScale = this._clampScale(cached, samplesPerPixel, false);
+        if (effectiveScale !== samplesPerPixel) {
+          clampedCount++;
+          clampedScale = effectiveScale;
+        }
         try {
           const offsets = clipOffsets?.get(clipId);
           result.set(
             clipId,
             extractPeaks(
               cached,
-              samplesPerPixel,
+              effectiveScale,
               isMono,
               offsets?.offsetSamples,
               offsets?.durationSamples
@@ -1177,8 +1191,42 @@ var PeakPipeline = class {
         }
       }
     }
+    if (clampedCount > 0) {
+      console.warn(
+        "[dawcore] Requested zoom " + samplesPerPixel + " spp is finer than pre-computed peaks (" + clampedScale + " spp) \u2014 " + clampedCount + " clip(s) using available resolution"
+      );
+    }
     return result;
   }
+  /**
+   * Clamp requested scale to cached WaveformData scale.
+   * WaveformData.resample() can only go coarser — if the requested zoom is
+   * finer than the cached data, use the cached scale. Set warn=true to log
+   * (default); reextractPeaks passes false and logs a single summary instead.
+   */
+  _clampScale(waveformData, requestedScale, warn = true) {
+    if (requestedScale < waveformData.scale) {
+      if (warn) {
+        console.warn(
+          "[dawcore] Requested zoom " + requestedScale + " spp is finer than pre-computed peaks (" + waveformData.scale + " spp) \u2014 using available resolution"
+        );
+      }
+      return waveformData.scale;
+    }
+    return requestedScale;
+  }
+  /**
+   * Return the coarsest (largest) scale among cached WaveformData entries
+   * that correspond to the given clip buffers. Returns 0 if none are cached.
+   */
+  getMaxCachedScale(clipBuffers) {
+    let max = 0;
+    for (const audioBuffer of clipBuffers.values()) {
+      const cached = this._cache.get(audioBuffer);
+      if (cached && cached.scale > max) max = cached.scale;
+    }
+    return max;
+  }
   terminate() {
     this._worker?.terminate();
     this._worker = null;
@@ -2487,6 +2535,7 @@ async function loadFiles(host, files) {
         clips: [
           {
             src: "",
+            peaksSrc: "",
             start: 0,
             duration: audioBuffer.duration,
             offset: 0,
@@ -2572,6 +2621,7 @@ function addRecordedClip(host, trackId, buf, startSample, durSamples, offsetSamp
       const sr = host.effectiveSampleRate;
       const clipDesc = {
         src: "",
+        peaksSrc: "",
         start: startSample / sr,
         duration: durSamples / sr,
         offset: 0,
@@ -2773,11 +2823,29 @@ function findAudioBufferForClip(host, clip, track) {
   return null;
 }
 
+// src/interactions/peaks-loader.ts
+var import_waveform_data2 = __toESM(require("waveform-data"));
+async function loadWaveformDataFromUrl(src) {
+  const response = await fetch(src);
+  if (!response.ok) {
+    throw new Error("[dawcore] Failed to fetch peaks data: " + response.statusText);
+  }
+  const { pathname } = new URL(src, globalThis.location?.href ?? "http://localhost");
+  const isBinary = pathname.toLowerCase().endsWith(".dat");
+  if (isBinary) {
+    const arrayBuffer = await response.arrayBuffer();
+    return import_waveform_data2.default.create(arrayBuffer);
+  } else {
+    const json = await response.json();
+    return import_waveform_data2.default.create(json);
+  }
+}
+
 // src/elements/daw-editor.ts
 var DawEditorElement = class extends import_lit12.LitElement {
   constructor() {
     super(...arguments);
-    this.samplesPerPixel = 1024;
+    this._samplesPerPixel = 1024;
     this.waveHeight = 128;
     this.timescale = false;
     this.mono = false;
@@ -2804,9 +2872,12 @@ var DawEditorElement = class extends import_lit12.LitElement {
     this._engine = null;
     this._enginePromise = null;
     this._audioCache = /* @__PURE__ */ new Map();
+    this._peaksCache = /* @__PURE__ */ new Map();
     this._clipBuffers = /* @__PURE__ */ new Map();
     this._clipOffsets = /* @__PURE__ */ new Map();
     this._peakPipeline = new PeakPipeline();
+    /** Coarsest scale from pre-computed peaks — zoom cannot go finer than this. 0 = no limit. */
+    this._minSamplesPerPixel = 0;
     this._trackElements = /* @__PURE__ */ new Map();
     this._childObserver = null;
     this._audioResume = new AudioResumeController(this);
@@ -2928,6 +2999,21 @@ var DawEditorElement = class extends import_lit12.LitElement {
     // --- Recording ---
     this.recordingStream = null;
   }
+  get samplesPerPixel() {
+    return this._samplesPerPixel;
+  }
+  set samplesPerPixel(value) {
+    const old = this._samplesPerPixel;
+    if (!Number.isFinite(value) || value <= 0) return;
+    const clamped = this._minSamplesPerPixel > 0 && value < this._minSamplesPerPixel ? this._minSamplesPerPixel : value;
+    if (clamped !== value) {
+      console.warn(
+        "[dawcore] Zoom " + value + " spp rejected \u2014 pre-computed peaks limit is " + this._minSamplesPerPixel + " spp"
+      );
+    }
+    this._samplesPerPixel = clamped;
+    this.requestUpdate("samplesPerPixel", old);
+  }
   get _clipHandler() {
     return this.interactiveClips ? this._clipPointer : null;
   }
@@ -3023,9 +3109,11 @@ var DawEditorElement = class extends import_lit12.LitElement {
     this._childObserver = null;
     this._trackElements.clear();
     this._audioCache.clear();
+    this._peaksCache.clear();
     this._clipBuffers.clear();
     this._clipOffsets.clear();
     this._peakPipeline.terminate();
+    this._minSamplesPerPixel = 0;
     try {
       this._disposeEngine();
     } catch (err) {
@@ -3075,6 +3163,7 @@ var DawEditorElement = class extends import_lit12.LitElement {
     if (this._engine) {
       this._engine.removeTrack(trackId);
     }
+    this._minSamplesPerPixel = this._peakPipeline.getMaxCachedScale(this._clipBuffers);
     if (nextEngine.size === 0) {
       this._currentTime = 0;
       this._stopPlayhead();
@@ -3086,6 +3175,7 @@ var DawEditorElement = class extends import_lit12.LitElement {
     if (clipEls.length === 0 && trackEl.src) {
       clips.push({
         src: trackEl.src,
+        peaksSrc: "",
         start: 0,
         duration: 0,
         offset: 0,
@@ -3099,6 +3189,7 @@ var DawEditorElement = class extends import_lit12.LitElement {
       for (const clipEl of clipEls) {
         clips.push({
           src: clipEl.src,
+          peaksSrc: clipEl.peaksSrc,
           start: clipEl.start,
           duration: clipEl.duration,
           offset: clipEl.offset,
@@ -3126,7 +3217,77 @@ var DawEditorElement = class extends import_lit12.LitElement {
       const clips = [];
       for (const clipDesc of descriptor.clips) {
         if (!clipDesc.src) continue;
-        const audioBuffer = await this._fetchAndDecode(clipDesc.src);
+        const waveformDataPromise = clipDesc.peaksSrc ? this._fetchPeaks(clipDesc.peaksSrc) : null;
+        const audioPromise = this._fetchAndDecode(clipDesc.src);
+        let waveformData = null;
+        if (waveformDataPromise) {
+          try {
+            waveformData = await waveformDataPromise;
+          } catch (err) {
+            console.warn(
+              "[dawcore] Failed to load peaks from " + clipDesc.peaksSrc + ": " + String(err) + " \u2014 falling back to AudioBuffer generation"
+            );
+          }
+        }
+        if (waveformData) {
+          const clip2 = (0, import_core4.createClipFromSeconds)({
+            waveformData,
+            startTime: clipDesc.start,
+            duration: clipDesc.duration || waveformData.duration,
+            offset: clipDesc.offset,
+            gain: clipDesc.gain,
+            name: clipDesc.name,
+            sampleRate: waveformData.sample_rate,
+            sourceDuration: waveformData.duration
+          });
+          const effectiveScale = Math.max(this.samplesPerPixel, waveformData.scale);
+          const peakData2 = extractPeaks(
+            waveformData,
+            effectiveScale,
+            this.mono,
+            clip2.offsetSamples,
+            clip2.durationSamples
+          );
+          this._clipOffsets.set(clip2.id, {
+            offsetSamples: clip2.offsetSamples,
+            durationSamples: clip2.durationSamples
+          });
+          this._peaksData = new Map(this._peaksData).set(clip2.id, peakData2);
+          this._minSamplesPerPixel = Math.max(this._minSamplesPerPixel, waveformData.scale);
+          const previewTrack = (0, import_core4.createTrack)({
+            name: descriptor.name,
+            clips: [clip2],
+            volume: descriptor.volume,
+            pan: descriptor.pan,
+            muted: descriptor.muted,
+            soloed: descriptor.soloed
+          });
+          previewTrack.id = trackId;
+          this._engineTracks = new Map(this._engineTracks).set(trackId, previewTrack);
+          this._recomputeDuration();
+          let audioBuffer2;
+          try {
+            audioBuffer2 = await audioPromise;
+          } catch (audioErr) {
+            const nextPeaks = new Map(this._peaksData);
+            nextPeaks.delete(clip2.id);
+            this._peaksData = nextPeaks;
+            this._clipOffsets.delete(clip2.id);
+            const nextEngine = new Map(this._engineTracks);
+            nextEngine.delete(trackId);
+            this._engineTracks = nextEngine;
+            this._minSamplesPerPixel = this._peakPipeline.getMaxCachedScale(this._clipBuffers);
+            this._recomputeDuration();
+            throw audioErr;
+          }
+          this._resolvedSampleRate = audioBuffer2.sampleRate;
+          const updatedClip = { ...clip2, audioBuffer: audioBuffer2 };
+          this._clipBuffers = new Map(this._clipBuffers).set(clip2.id, audioBuffer2);
+          this._peakPipeline.cacheWaveformData(audioBuffer2, waveformData);
+          clips.push(updatedClip);
+          continue;
+        }
+        const audioBuffer = await audioPromise;
         this._resolvedSampleRate = audioBuffer.sampleRate;
         const clip = (0, import_core4.createClipFromSeconds)({
           audioBuffer,
@@ -3208,6 +3369,16 @@ var DawEditorElement = class extends import_lit12.LitElement {
       throw err;
     }
   }
+  _fetchPeaks(src) {
+    const cached = this._peaksCache.get(src);
+    if (cached) return cached;
+    const promise = loadWaveformDataFromUrl(src).catch((err) => {
+      this._peaksCache.delete(src);
+      throw err;
+    });
+    this._peaksCache.set(src, promise);
+    return promise;
+  }
   _recomputeDuration() {
     let maxSample = 0;
     for (const track of this._engineTracks.values()) {
@@ -3620,8 +3791,8 @@ DawEditorElement.styles = [
 ];
 DawEditorElement._CONTROL_PROPS = /* @__PURE__ */ new Set(["volume", "pan", "muted", "soloed"]);
 __decorateClass([
-  (0, import_decorators10.property)({ type: Number, attribute: "samples-per-pixel" })
-], DawEditorElement.prototype, "samplesPerPixel", 2);
+  (0, import_decorators10.property)({ type: Number, attribute: "samples-per-pixel", noAccessor: true })
+], DawEditorElement.prototype, "samplesPerPixel", 1);
 __decorateClass([
   (0, import_decorators10.property)({ type: Number, attribute: "wave-height" })
 ], DawEditorElement.prototype, "waveHeight", 2);