@dawcore/components 0.0.16 → 0.0.18

package/dist/index.mjs

@@ -175,6 +175,7 @@ var DawTrackElement = class extends LitElement2 {
     this.muted = false;
     this.soloed = false;
     this.renderMode = "waveform";
+    this.spectrogramConfig = null;
     this.trackId = crypto.randomUUID();
     // Track removal is detected by the editor's MutationObserver,
     // not by dispatching from disconnectedCallback (detached elements
@@ -202,7 +203,16 @@ var DawTrackElement = class extends LitElement2 {
       this._hasRendered = true;
       return;
     }
-    const trackProps = ["volume", "pan", "muted", "soloed", "src", "name", "renderMode"];
+    const trackProps = [
+      "volume",
+      "pan",
+      "muted",
+      "soloed",
+      "src",
+      "name",
+      "renderMode",
+      "spectrogramConfig"
+    ];
     const hasTrackChange = trackProps.some((p) => changed.has(p));
     if (hasTrackChange) {
       this.dispatchEvent(
@@ -236,6 +246,9 @@ __decorateClass([
 __decorateClass([
   property2({ attribute: "render-mode" })
 ], DawTrackElement.prototype, "renderMode", 2);
+__decorateClass([
+  property2({ attribute: false })
+], DawTrackElement.prototype, "spectrogramConfig", 2);
 DawTrackElement = __decorateClass([
   customElement2("daw-track")
 ], DawTrackElement);
@@ -2708,6 +2721,123 @@ var RecordingController = class {
   }
 };
 
+// src/controllers/spectrogram-controller.ts
+import {
+  SpectrogramOrchestrator
+} from "@dawcore/spectrogram";
+var LIBRARY_DEFAULTS = {
+  fftSize: 2048,
+  windowFunction: "hann",
+  frequencyScale: "mel",
+  minFrequency: 0,
+  gainDb: 20,
+  rangeDb: 80
+};
+var LIBRARY_DEFAULT_COLOR_MAP = "viridis";
+var SpectrogramController = class {
+  constructor(host, workerFactory) {
+    this.orchestrator = null;
+    this.editorConfig = null;
+    this.editorColorMap = null;
+    this.trackConfigs = /* @__PURE__ */ new Map();
+    this.trackColorMaps = /* @__PURE__ */ new Map();
+    this.host = host;
+    this.workerFactory = workerFactory;
+    this.host.addController(this);
+  }
+  hostConnected() {
+  }
+  hostDisconnected() {
+    this.dispose();
+  }
+  setEditorConfig(config) {
+    this.editorConfig = config;
+    this.reapply();
+  }
+  setEditorColorMap(colorMap) {
+    this.editorColorMap = colorMap;
+    this.reapply();
+  }
+  setTrackConfig(trackId, config) {
+    if (config === null) {
+      this.trackConfigs.delete(trackId);
+    } else {
+      this.trackConfigs.set(trackId, config);
+    }
+    this.reapply();
+  }
+  setTrackColorMap(trackId, colorMap) {
+    if (colorMap === null) {
+      this.trackColorMaps.delete(trackId);
+    } else {
+      this.trackColorMaps.set(trackId, colorMap);
+    }
+    this.reapply();
+  }
+  registerClipAudio(reg) {
+    this.ensureOrchestrator().registerClip(reg);
+  }
+  unregisterClipAudio(clipId) {
+    this.orchestrator?.unregisterClip(clipId);
+  }
+  registerCanvas(reg) {
+    this.ensureOrchestrator().registerCanvas(reg);
+  }
+  unregisterCanvas(canvasId) {
+    this.orchestrator?.unregisterCanvas(canvasId);
+  }
+  setViewport(state5) {
+    this.orchestrator?.setViewport(state5);
+  }
+  dispose() {
+    if (this.orchestrator) {
+      this.orchestrator.dispose();
+      this.orchestrator = null;
+    }
+  }
+  ensureOrchestrator() {
+    if (!this.orchestrator) {
+      this.orchestrator = new SpectrogramOrchestrator({
+        workerFactory: this.workerFactory,
+        workerPoolSize: 2,
+        config: this.mergedConfig(),
+        colorMap: this.mergedColorMap()
+      });
+      this.orchestrator.addEventListener("viewport-ready", (e) => {
+        const detail = e.detail;
+        this.host.dispatchEvent(
+          new CustomEvent("daw-spectrogram-ready", {
+            detail,
+            bubbles: true,
+            composed: true
+          })
+        );
+      });
+      this.reapply();
+    }
+    return this.orchestrator;
+  }
+  reapply() {
+    if (!this.orchestrator) return;
+    this.orchestrator.setConfig(this.mergedConfig());
+    this.orchestrator.setColorMap(this.mergedColorMap());
+  }
+  mergedConfig() {
+    let track = null;
+    for (const c of this.trackConfigs.values()) {
+      track = c;
+      break;
+    }
+    return { ...LIBRARY_DEFAULTS, ...this.editorConfig ?? {}, ...track ?? {} };
+  }
+  mergedColorMap() {
+    for (const c of this.trackColorMaps.values()) {
+      return c ?? LIBRARY_DEFAULT_COLOR_MAP;
+    }
+    return this.editorColorMap ?? LIBRARY_DEFAULT_COLOR_MAP;
+  }
+};
+
 // src/interactions/pointer-handler.ts
 import { pixelsToSeconds, snapTickToGrid } from "@waveform-playlist/core";
 
@@ -3603,6 +3733,8 @@ var DawEditorElement = class extends LitElement10 {
     this.clipHeaderHeight = 20;
     this.interactiveClips = false;
     this.indefinitePlayback = false;
+    this._spectrogramConfig = null;
+    this._spectrogramColorMap = null;
     this.scaleMode = "temporal";
     this._ticksPerPixel = 24;
     this._bpm = 120;
@@ -3638,6 +3770,7 @@ var DawEditorElement = class extends LitElement10 {
     this._childObserver = null;
     this._audioResume = new AudioResumeController(this);
     this._recordingController = new RecordingController(this);
+    this._spectrogramController = null;
     this._clipPointer = new ClipPointerHandler(this);
     this._pointer = new PointerHandler(this);
     this._viewport = (() => {
@@ -3645,6 +3778,15 @@ var DawEditorElement = class extends LitElement10 {
       v.scrollSelector = ".scroll-area";
       return v;
     })();
+    /**
+     * Cache of the last ViewportState forwarded to the spectrogram controller.
+     * Lit's `updated()` fires on every reactive state change (`_isPlaying`,
+     * `_selectedTrackId`, etc.) — most of which don't affect the spectrogram
+     * viewport. Skip the cross-controller call when nothing changed.
+     *
+     * The orchestrator dedupes too, but this avoids the call entirely.
+     */
+    this._lastSpectrogramViewport = null;
     // --- Track Events ---
     this._onTrackConnected = (e) => {
       const trackId = e.detail?.trackId;
@@ -3678,6 +3820,26 @@ var DawEditorElement = class extends LitElement10 {
       if (oldDescriptor?.src !== descriptor.src) {
         this._loadTrack(trackId, descriptor);
       }
+      if (descriptor.renderMode === "spectrogram" && oldDescriptor?.renderMode !== "spectrogram") {
+        const engineTrack = this._engineTracks.get(trackId);
+        if (engineTrack) {
+          for (const clip of engineTrack.clips) {
+            this._maybeRegisterSpectrogramClipAudio(trackId, clip);
+          }
+        }
+      }
+      if (descriptor.renderMode !== "spectrogram" && oldDescriptor?.renderMode === "spectrogram") {
+        const engineTrack = this._engineTracks.get(trackId);
+        if (engineTrack && this._spectrogramController) {
+          for (const clip of engineTrack.clips) {
+            this._spectrogramController.unregisterClipAudio(clip.id);
+          }
+        }
+        this._disposeSpectrogramControllerIfEmpty();
+      }
+      if (descriptor.spectrogramConfig !== oldDescriptor?.spectrogramConfig) {
+        this._spectrogramController?.setTrackConfig(trackId, descriptor.spectrogramConfig ?? null);
+      }
     };
     this._onTrackControl = (e) => {
       const { trackId, prop, value } = e.detail ?? {};
@@ -3821,6 +3983,72 @@ var DawEditorElement = class extends LitElement10 {
     this._samplesPerPixel = clamped;
     this.requestUpdate("samplesPerPixel", old);
   }
+  get spectrogramConfig() {
+    return this._spectrogramConfig;
+  }
+  set spectrogramConfig(value) {
+    const old = this._spectrogramConfig;
+    this._spectrogramConfig = value;
+    this._spectrogramController?.setEditorConfig(value);
+    this.requestUpdate("spectrogramConfig", old);
+  }
+  get spectrogramColorMap() {
+    return this._spectrogramColorMap;
+  }
+  set spectrogramColorMap(value) {
+    const old = this._spectrogramColorMap;
+    this._spectrogramColorMap = value;
+    this._spectrogramController?.setEditorColorMap(value);
+    this.requestUpdate("spectrogramColorMap", old);
+  }
+  _ensureSpectrogramController() {
+    if (!this._spectrogramController) {
+      this._spectrogramController = new SpectrogramController(
+        this,
+        () => new Worker(new URL("@dawcore/spectrogram/worker/spectrogram.worker", import.meta.url), {
+          type: "module"
+        })
+      );
+      if (this._spectrogramConfig) {
+        this._spectrogramController.setEditorConfig(this._spectrogramConfig);
+      }
+      if (this._spectrogramColorMap) {
+        this._spectrogramController.setEditorColorMap(this._spectrogramColorMap);
+      }
+    }
+    return this._spectrogramController;
+  }
+  /** Called by <daw-spectrogram> after transferControlToOffscreen. */
+  _spectrogramRegisterCanvas(reg) {
+    this._ensureSpectrogramController().registerCanvas(reg);
+  }
+  /** Called by <daw-spectrogram> on chunk unmount / element disconnect. */
+  _spectrogramUnregisterCanvas(canvasId) {
+    this._spectrogramController?.unregisterCanvas(canvasId);
+  }
+  /**
+   * Push a clip's decoded audio into the spectrogram controller. No-op
+   * unless the track is in spectrogram render-mode and the controller
+   * already exists (it bootstraps from canvas registration).
+   */
+  _maybeRegisterSpectrogramClipAudio(trackId, clip) {
+    const descriptor = this._tracks.get(trackId);
+    if (descriptor?.renderMode !== "spectrogram") return;
+    const buffer = clip.audioBuffer ?? this._clipBuffers.get(clip.id);
+    if (!buffer) return;
+    const channelData = [];
+    for (let i = 0; i < buffer.numberOfChannels; i++) {
+      channelData.push(buffer.getChannelData(i));
+    }
+    this._ensureSpectrogramController().registerClipAudio({
+      clipId: clip.id,
+      trackId,
+      channelData,
+      sampleRate: buffer.sampleRate,
+      durationSamples: clip.durationSamples,
+      offsetSamples: clip.offsetSamples
+    });
+  }
   get ticksPerPixel() {
     return this._ticksPerPixel;
   }
@@ -4061,6 +4289,8 @@ var DawEditorElement = class extends LitElement10 {
     this._clipOffsets.clear();
     this._peakPipeline.terminate();
     this._minSamplesPerPixel = 0;
+    this._spectrogramController?.dispose();
+    this._spectrogramController = null;
     try {
       this._disposeEngine();
     } catch (err) {
@@ -4089,6 +4319,27 @@ var DawEditorElement = class extends LitElement10 {
       }
     }
   }
+  updated(_changed) {
+    if (this._spectrogramController) {
+      const vs = this._viewport.visibleStart;
+      const ve = this._viewport.visibleEnd;
+      const spp = this._renderSpp;
+      if (Number.isFinite(vs) && Number.isFinite(ve)) {
+        const prev = this._lastSpectrogramViewport;
+        if (prev && prev.vs === vs && prev.ve === ve && prev.spp === spp) return;
+        this._lastSpectrogramViewport = { vs, ve, spp };
+        const span = ve - vs;
+        const bufferPad = span * 0.25;
+        this._spectrogramController.setViewport({
+          visibleStartPx: vs,
+          visibleEndPx: ve,
+          bufferStartPx: Math.max(0, vs - bufferPad),
+          bufferEndPx: ve + bufferPad,
+          samplesPerPixel: spp
+        });
+      }
+    }
+  }
   _onTrackRemoved(trackId) {
     this._trackElements.delete(trackId);
     const removedTrack = this._engineTracks.get(trackId);
@@ -4098,6 +4349,7 @@ var DawEditorElement = class extends LitElement10 {
         this._clipBuffers.delete(clip.id);
         this._clipOffsets.delete(clip.id);
         nextPeaks.delete(clip.id);
+        this._spectrogramController?.unregisterClipAudio(clip.id);
       }
       this._peaksData = nextPeaks;
     }
@@ -4112,11 +4364,23 @@ var DawEditorElement = class extends LitElement10 {
       this._engine.removeTrack(trackId);
     }
     this._minSamplesPerPixel = this._peakPipeline.getMaxCachedScale(this._clipBuffers);
+    this._disposeSpectrogramControllerIfEmpty();
     if (nextEngine.size === 0) {
       this._currentTime = 0;
       this._stopPlayhead();
     }
   }
+  /** Drop the controller when no spectrogram tracks remain. */
+  _disposeSpectrogramControllerIfEmpty() {
+    if (!this._spectrogramController) return;
+    const stillNeeded = Array.from(this._tracks.values()).some(
+      (d) => d.renderMode === "spectrogram"
+    );
+    if (!stillNeeded) {
+      this._spectrogramController.dispose();
+      this._spectrogramController = null;
+    }
+  }
   _onClipRemovedFromDom(clipEl) {
     const clipId = clipEl.clipId;
     for (const [trackId, t] of this._engineTracks.entries()) {
@@ -4158,6 +4422,7 @@ var DawEditorElement = class extends LitElement10 {
         });
       }
       this._commitTrackChange(trackId, updatedTrack);
+      this._maybeRegisterSpectrogramClipAudio(trackId, clip);
       this.dispatchEvent(
         new CustomEvent("daw-clip-ready", {
           bubbles: true,
@@ -4332,6 +4597,7 @@ var DawEditorElement = class extends LitElement10 {
     nextPeaks.delete(clipId);
     this._peaksData = nextPeaks;
     this._clipOffsets.delete(clipId);
+    this._spectrogramController?.unregisterClipAudio(clipId);
   }
   /**
    * Recompute duration and forward an updated track to the engine. Single
@@ -4614,6 +4880,9 @@ var DawEditorElement = class extends LitElement10 {
       track.id = trackId;
       this._engineTracks = new Map(this._engineTracks).set(trackId, track);
       this._recomputeDuration();
+      for (const c of clips) {
+        this._maybeRegisterSpectrogramClipAudio(trackId, c);
+      }
       const engine = await this._ensureEngine();
       engine.setTracks([...this._engineTracks.values()]);
       this.dispatchEvent(
@@ -5425,19 +5694,34 @@ var DawEditorElement = class extends LitElement10 {
                           .visibleEnd=${this._viewport.visibleEnd}
                           .originX=${clipLeft}
                           ?selected=${t.trackId === this._selectedTrackId}
-                        ></daw-piano-roll>` : channels.map(
+                        ></daw-piano-roll>` : t.descriptor?.renderMode === "spectrogram" ? channels.map(
+          (_chPeaks, chIdx) => html9`<daw-spectrogram
+                                style="position:absolute;left:0;top:${hdrH + chIdx * chH}px;height:${chH}px;width:${peakData?.length ?? width}px;"
+                                .clipId=${clip.id}
+                                .trackId=${t.trackId}
+                                .channelIndex=${chIdx}
+                                .length=${peakData?.length ?? width}
+                                .waveHeight=${chH}
+                                .samplesPerPixel=${this._renderSpp}
+                                .sampleRate=${this.effectiveSampleRate}
+                                .clipOffsetSeconds=${(clip.offsetSamples ?? 0) / this.effectiveSampleRate}
+                                .visibleStart=${this._viewport.visibleStart}
+                                .visibleEnd=${this._viewport.visibleEnd}
+                                .originX=${clipLeft}
+                              ></daw-spectrogram>`
+        ) : channels.map(
           (chPeaks, chIdx) => html9` <daw-waveform
-                              style="position:absolute;left:0;top:${hdrH + chIdx * chH}px;"
-                              .peaks=${chPeaks}
-                              .length=${peakData?.length ?? width}
-                              .waveHeight=${chH}
-                              .barWidth=${this.barWidth}
-                              .barGap=${this.barGap}
-                              .visibleStart=${this._viewport.visibleStart}
-                              .visibleEnd=${this._viewport.visibleEnd}
-                              .originX=${clipLeft}
-                              .segments=${clipSegments}
-                            ></daw-waveform>`
+                                style="position:absolute;left:0;top:${hdrH + chIdx * chH}px;"
+                                .peaks=${chPeaks}
+                                .length=${peakData?.length ?? width}
+                                .waveHeight=${chH}
+                                .barWidth=${this.barWidth}
+                                .barGap=${this.barGap}
+                                .visibleStart=${this._viewport.visibleStart}
+                                .visibleEnd=${this._viewport.visibleEnd}
+                                .originX=${clipLeft}
+                                .segments=${clipSegments}
+                              ></daw-waveform>`
         )}
                     ${this.interactiveClips ? html9` <div
                             class="clip-boundary"
@@ -5545,6 +5829,12 @@ __decorateClass([
 __decorateClass([
   property8({ type: Boolean, attribute: "indefinite-playback" })
 ], DawEditorElement.prototype, "indefinitePlayback", 2);
+__decorateClass([
+  property8({ attribute: false, noAccessor: true })
+], DawEditorElement.prototype, "spectrogramConfig", 1);
+__decorateClass([
+  property8({ attribute: false, noAccessor: true })
+], DawEditorElement.prototype, "spectrogramColorMap", 1);
 __decorateClass([
   property8({ type: String, attribute: "scale-mode" })
 ], DawEditorElement.prototype, "scaleMode", 2);
@@ -6123,6 +6413,187 @@ __decorateClass([
 DawKeyboardShortcutsElement = __decorateClass([
   customElement16("daw-keyboard-shortcuts")
 ], DawKeyboardShortcutsElement);
+
+// src/elements/daw-spectrogram.ts
+import { LitElement as LitElement14, html as html13, css as css13 } from "lit";
+import { customElement as customElement17, property as property12 } from "lit/decorators.js";
+var MAX_CANVAS_WIDTH5 = 1e3;
+var DawSpectrogramElement = class extends LitElement14 {
+  constructor() {
+    super(...arguments);
+    this.clipId = "";
+    this.trackId = "";
+    this.channelIndex = 0;
+    this.length = 0;
+    this.waveHeight = 128;
+    this._samplesPerPixel = 1024;
+    this._sampleRate = 44100;
+    this.clipOffsetSeconds = 0;
+    this.visibleStart = -Infinity;
+    this.visibleEnd = Infinity;
+    this.originX = 0;
+    this._canvases = [];
+    this._registeredCanvasIds = [];
+  }
+  get samplesPerPixel() {
+    return this._samplesPerPixel;
+  }
+  set samplesPerPixel(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+      console.warn("[dawcore] daw-spectrogram samplesPerPixel " + value + " is invalid \u2014 ignored");
+      return;
+    }
+    const old = this._samplesPerPixel;
+    this._samplesPerPixel = value;
+    this.requestUpdate("samplesPerPixel", old);
+  }
+  get sampleRate() {
+    return this._sampleRate;
+  }
+  set sampleRate(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+      console.warn("[dawcore] daw-spectrogram sampleRate " + value + " is invalid \u2014 ignored");
+      return;
+    }
+    const old = this._sampleRate;
+    this._sampleRate = value;
+    this.requestUpdate("sampleRate", old);
+  }
+  /**
+   * Walk up to the editor host. `closest('daw-editor')` does NOT cross
+   * shadow boundaries — and this element lives inside the editor's shadow
+   * DOM — so use getRootNode().host to step out.
+   */
+  _findHostEditor() {
+    const root = this.getRootNode();
+    const host = root instanceof ShadowRoot ? root.host : null;
+    if (!host) return null;
+    if (host.tagName === "DAW-EDITOR") return host;
+    return host.closest("daw-editor");
+  }
+  willUpdate(changed) {
+    const layoutChanged = changed.has("length") || changed.has("waveHeight") || changed.has("samplesPerPixel") || changed.has("clipId") || changed.has("channelIndex");
+    if (layoutChanged) {
+      this._rebuildChunks();
+    }
+  }
+  _rebuildChunks() {
+    this._unregisterAllCanvases();
+    this._canvases = [];
+    if (this.length <= 0) return;
+    const chunkCount = Math.ceil(this.length / MAX_CANVAS_WIDTH5);
+    for (let i = 0; i < chunkCount; i++) {
+      const widthPx = Math.min(MAX_CANVAS_WIDTH5, this.length - i * MAX_CANVAS_WIDTH5);
+      const canvas = document.createElement("canvas");
+      canvas.style.left = i * MAX_CANVAS_WIDTH5 + "px";
+      canvas.style.width = widthPx + "px";
+      const dpr = window.devicePixelRatio || 1;
+      canvas.width = widthPx * dpr;
+      canvas.height = this.waveHeight * dpr;
+      this._canvases.push(canvas);
+    }
+  }
+  updated(_changed) {
+    if (this._registeredCanvasIds.length === 0 && this._canvases.length > 0) {
+      requestAnimationFrame(() => this._registerCanvases());
+    }
+  }
+  _registerCanvases() {
+    const editor = this._findHostEditor();
+    if (!editor || typeof editor._spectrogramRegisterCanvas !== "function") return;
+    for (let i = 0; i < this._canvases.length; i++) {
+      const canvas = this._canvases[i];
+      const canvasId = this.clipId + "-ch" + this.channelIndex + "-chunk" + i;
+      let offscreen;
+      try {
+        offscreen = canvas.transferControlToOffscreen();
+      } catch (err) {
+        console.warn(
+          "[dawcore] daw-spectrogram transferControlToOffscreen failed for " + canvasId + ": " + (err instanceof Error ? err.message : String(err))
+        );
+        continue;
+      }
+      editor._spectrogramRegisterCanvas({
+        canvasId,
+        canvas: offscreen,
+        clipId: this.clipId,
+        trackId: this.trackId,
+        channelIndex: this.channelIndex,
+        chunkIndex: i,
+        globalPixelOffset: this.originX + i * MAX_CANVAS_WIDTH5,
+        widthPx: parseFloat(canvas.style.width),
+        heightPx: this.waveHeight
+      });
+      this._registeredCanvasIds.push(canvasId);
+    }
+  }
+  _unregisterAllCanvases() {
+    const editor = this._findHostEditor();
+    if (editor && typeof editor._spectrogramUnregisterCanvas === "function") {
+      for (const id of this._registeredCanvasIds) {
+        editor._spectrogramUnregisterCanvas(id);
+      }
+    }
+    this._registeredCanvasIds = [];
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._unregisterAllCanvases();
+  }
+  render() {
+    return html13`${this._canvases.map((c) => c)}`;
+  }
+};
+DawSpectrogramElement.styles = css13`
+    :host {
+      display: block;
+      position: relative;
+      background: var(--daw-spectrogram-background, #000);
+    }
+    canvas {
+      position: absolute;
+      top: 0;
+      left: 0;
+      height: 100%;
+      pointer-events: none;
+    }
+  `;
+__decorateClass([
+  property12({ attribute: false })
+], DawSpectrogramElement.prototype, "clipId", 2);
+__decorateClass([
+  property12({ attribute: false })
+], DawSpectrogramElement.prototype, "trackId", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "channelIndex", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "length", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "waveHeight", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false, noAccessor: true })
+], DawSpectrogramElement.prototype, "samplesPerPixel", 1);
+__decorateClass([
+  property12({ type: Number, attribute: false, noAccessor: true })
+], DawSpectrogramElement.prototype, "sampleRate", 1);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "clipOffsetSeconds", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "visibleStart", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "visibleEnd", 2);
+__decorateClass([
+  property12({ type: Number, attribute: false })
+], DawSpectrogramElement.prototype, "originX", 2);
+DawSpectrogramElement = __decorateClass([
+  customElement17("daw-spectrogram")
+], DawSpectrogramElement);
 export {
   AudioResumeController,
   ClipPointerHandler,
@@ -6137,6 +6608,7 @@ export {
   DawRecordButtonElement,
   DawRulerElement,
   DawSelectionElement,
+  DawSpectrogramElement,
   DawStopButtonElement,
   DawTrackControlsElement,
   DawTrackElement,
@@ -6144,6 +6616,7 @@ export {
   DawTransportElement,
   DawWaveformElement,
   RecordingController,
+  SpectrogramController,
   isDomClip,
   splitAtPlayhead
 };