@ultrst-armada/kloks 0.0.0-stage → 1.0.0

package/packages/audio-midi/dist/chunk-N55BWOC6.js

@@ -0,0 +1,439 @@
+import {
+  synthEngine
+} from "./chunk-3GRGELA4.js";
+
+// src/engine/audio/clipWaveforms.ts
+function generatePresetAudioBuffer(ctx, sampleType) {
+  const duration = 2;
+  const rate = ctx.sampleRate;
+  const length = Math.floor(rate * duration);
+  const buffer = ctx.createBuffer(2, length, rate);
+  const left = buffer.getChannelData(0);
+  const right = buffer.getChannelData(1);
+  for (let i = 0; i < length; i++) {
+    const t = i / rate;
+    const progress = i / length;
+    let sL = 0;
+    let sR = 0;
+    if (sampleType === "ambient_drone") {
+      const f1 = 110 + Math.sin(t * 1.5) * 5;
+      const f2 = 165 + Math.cos(t * 2.2) * 8;
+      sL = Math.sin(2 * Math.PI * f1 * t) * 0.4 + Math.sin(2 * Math.PI * f2 * t) * 0.3;
+      sR = Math.sin(2 * Math.PI * (f1 * 1.005) * t) * 0.4 + Math.sin(2 * Math.PI * (f2 * 0.995) * t) * 0.3;
+      sL *= Math.sin(progress * Math.PI);
+      sR *= Math.sin(progress * Math.PI);
+    } else if (sampleType === "pulsar_synth") {
+      const sweepFreq = 220 + Math.sin(t * 8) * 80 + progress * 200;
+      sL = (Math.sin(2 * Math.PI * sweepFreq * t) > 0 ? 0.3 : -0.3) * (1 - progress * 0.6);
+      sR = Math.sin(2 * Math.PI * sweepFreq * 1.01 * t) * 0.4 * (1 - progress * 0.6);
+    } else if (sampleType === "cosmic_warp") {
+      const warpFreq = 600 * Math.exp(-progress * 2.5) + Math.sin(t * 30) * 100;
+      sL = Math.sin(2 * Math.PI * warpFreq * t) * Math.exp(-progress * 1.8);
+      sR = Math.cos(2 * Math.PI * warpFreq * 1.02 * t) * Math.exp(-progress * 1.8);
+    } else if (sampleType === "starlight_vox") {
+      const chord = [261.63, 329.63, 392, 523.25];
+      chord.forEach((freq, idx) => {
+        const lfo = Math.sin(t * (3 + idx)) * 0.05;
+        sL += Math.sin(2 * Math.PI * freq * (1 + lfo) * t) * 0.18;
+        sR += Math.sin(2 * Math.PI * freq * 1.003 * (1 - lfo) * t) * 0.18;
+      });
+      sL *= Math.sin(progress * Math.PI);
+      sR *= Math.sin(progress * Math.PI);
+    } else if (sampleType === "cyber_808") {
+      const pitch = 55 * Math.exp(-progress * 6) + 35;
+      const sub = Math.sin(2 * Math.PI * pitch * t);
+      const dist = Math.tanh(sub * 2.5) * 0.5;
+      sL = dist * Math.exp(-progress * 2);
+      sR = dist * Math.exp(-progress * 2);
+    } else if (sampleType === "space_percussion") {
+      const noise = Math.random() * 2 - 1;
+      const tonal = Math.sin(2 * Math.PI * (180 * Math.exp(-progress * 12)) * t);
+      sL = (noise * 0.3 + tonal * 0.7) * Math.exp(-progress * 5);
+      sR = (noise * 0.3 + tonal * 0.7) * Math.exp(-progress * 5);
+    } else {
+      sL = Math.sin(2 * Math.PI * 440 * t) * (1 - progress);
+      sR = sL;
+    }
+    left[i] = Math.max(-1, Math.min(1, sL));
+    right[i] = Math.max(-1, Math.min(1, sR));
+  }
+  return buffer;
+}
+
+// src/engine/audio/audioClipEngine/audioClipEngine.ts
+var AudioClipEngine = class {
+  bufferCache = /* @__PURE__ */ new Map();
+  maxCacheSize = 32;
+  loadingPromises = /* @__PURE__ */ new Map();
+  activeSources = /* @__PURE__ */ new Map();
+  activePlaybacks = /* @__PURE__ */ new Map();
+  activeAudition = null;
+  getContext() {
+    return synthEngine.getContext();
+  }
+  setBufferCacheEntry(key, buffer) {
+    if (this.bufferCache.has(key)) {
+      this.bufferCache.delete(key);
+    } else if (this.bufferCache.size >= this.maxCacheSize) {
+      const oldestKey = this.bufferCache.keys().next().value;
+      if (oldestKey) {
+        this.bufferCache.delete(oldestKey);
+      }
+    }
+    this.bufferCache.set(key, buffer);
+  }
+  getOrCreatePresetBuffer(sampleType) {
+    if (this.bufferCache.has(sampleType)) {
+      const buffer2 = this.bufferCache.get(sampleType);
+      this.bufferCache.delete(sampleType);
+      this.bufferCache.set(sampleType, buffer2);
+      return buffer2;
+    }
+    const buffer = generatePresetAudioBuffer(this.getContext(), sampleType);
+    this.setBufferCacheEntry(sampleType, buffer);
+    return buffer;
+  }
+  extractWaveformData(buffer, numPoints = 100) {
+    const channelData = buffer.getChannelData(0);
+    const blockSize = Math.floor(channelData.length / numPoints);
+    const peaks = [];
+    for (let i = 0; i < numPoints; i++) {
+      const start = i * blockSize;
+      let max = 0;
+      for (let j = 0; j < blockSize && start + j < channelData.length; j++) {
+        const val = Math.abs(channelData[start + j] || 0);
+        if (val > max) max = val;
+      }
+      peaks.push(Math.min(1, Math.round(max * 100) / 100));
+    }
+    return peaks;
+  }
+  async loadSampleFromUrl(url) {
+    if (this.bufferCache.has(url)) {
+      const buffer = this.bufferCache.get(url);
+      return { buffer, peaks: this.extractWaveformData(buffer) };
+    }
+    if (this.loadingPromises.has(url)) {
+      return this.loadingPromises.get(url);
+    }
+    const promise = (async () => {
+      try {
+        const ctx = this.getContext();
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`HTTP ${res.status} fetching sample: ${url}`);
+        const arrayBuf = await res.arrayBuffer();
+        const audioBuf = await ctx.decodeAudioData(arrayBuf);
+        this.setBufferCacheEntry(url, audioBuf);
+        return { buffer: audioBuf, peaks: this.extractWaveformData(audioBuf) };
+      } finally {
+        this.loadingPromises.delete(url);
+      }
+    })();
+    this.loadingPromises.set(url, promise);
+    return promise;
+  }
+  async getOrLoadBuffer(sampleType, customUrl) {
+    if (customUrl) {
+      try {
+        const { buffer } = await this.loadSampleFromUrl(customUrl);
+        return buffer;
+      } catch (err) {
+        console.warn("Failed to load custom sample URL, falling back to preset:", customUrl, err);
+      }
+    }
+    return this.getOrCreatePresetBuffer(sampleType);
+  }
+  async auditionSampleUrl(url, onEnded) {
+    this.stopAudition();
+    const ctx = this.getContext();
+    if (ctx.state === "suspended") await ctx.resume().catch(() => {
+    });
+    try {
+      const { buffer } = await this.loadSampleFromUrl(url);
+      if (ctx.state === "suspended") await ctx.resume().catch(() => {
+      });
+      const src = ctx.createBufferSource();
+      src.buffer = buffer;
+      const gain = ctx.createGain();
+      gain.gain.value = 0.85;
+      src.connect(gain);
+      gain.connect(synthEngine.getMasterNode() || ctx.destination);
+      this.activeAudition = {
+        url,
+        startTime: ctx.currentTime,
+        duration: buffer.duration,
+        source: src
+      };
+      src.onended = () => {
+        if (this.activeAudition?.source === src) this.activeAudition = null;
+        if (onEnded) onEnded();
+      };
+      src.start();
+    } catch (err) {
+      console.error("Failed to audition sample:", err);
+      if (onEnded) onEnded();
+    }
+  }
+  stopAudition() {
+    if (this.activeAudition) {
+      try {
+        this.activeAudition.source.stop();
+        this.activeAudition.source.disconnect();
+      } catch {
+      }
+      this.activeAudition = null;
+    }
+  }
+  getAuditionProgress() {
+    if (!this.activeAudition) return { isPlaying: false, progress: 0 };
+    const ctx = this.getContext();
+    const elapsed = ctx.currentTime - this.activeAudition.startTime;
+    const progress = Math.max(0, Math.min(1, elapsed / this.activeAudition.duration));
+    return { isPlaying: elapsed <= this.activeAudition.duration, progress };
+  }
+  async playAudioTrack(track, bpm, destination, containerId, offsetBeats, volumeScale = 1, panOffset = 0) {
+    const ctx = this.getContext();
+    if (ctx.state === "suspended") await ctx.resume().catch(() => {
+    });
+    if (!containerId || !synthEngine.isNodeConnectedToOutput(containerId)) return;
+    this.stopAudioTrack(track.id);
+    const buffer = await this.getOrLoadBuffer(track.sampleType, track.customAudioUrl);
+    if (ctx.state === "suspended") await ctx.resume().catch(() => {
+    });
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.playbackRate.setValueAtTime(Math.pow(2, (track.pitchShift || 0) / 12), ctx.currentTime);
+    const filter = ctx.createBiquadFilter();
+    filter.type = "lowpass";
+    filter.frequency.setValueAtTime(track.filterCutoff || 8e3, ctx.currentTime);
+    const gainNode = ctx.createGain();
+    const effectiveGain = Math.max(0, (track.gain ?? 1) * volumeScale * 0.75);
+    gainNode.gain.setValueAtTime(effectiveGain, ctx.currentTime);
+    const outTarget = destination || synthEngine.getMasterNode() || ctx.destination;
+    const panner = ctx.createStereoPanner ? ctx.createStereoPanner() : null;
+    if (panner) {
+      const effectivePan = Math.max(-1, Math.min(1, (track.pan || 0) + panOffset));
+      panner.pan.setValueAtTime(effectivePan, ctx.currentTime);
+      source.connect(filter);
+      filter.connect(gainNode);
+      gainNode.connect(panner);
+      panner.connect(outTarget);
+    } else {
+      source.connect(filter);
+      filter.connect(gainNode);
+      gainNode.connect(outTarget);
+    }
+    const secPerBeat = 60 / (bpm || 120);
+    const startSec = ((track.trimStartBeats || 0) + (offsetBeats || 0)) * secPerBeat;
+    const endSec = Math.min(buffer.duration, (track.trimEndBeats || track.durationBeats || 4) * secPerBeat);
+    const playDuration = Math.max(0.05, endSec - startSec);
+    this.activeSources.set(track.id, source);
+    if (containerId) {
+      synthEngine.markNodeActive(containerId, playDuration);
+    }
+    this.activePlaybacks.set(track.id, {
+      trackId: track.id,
+      startTime: ctx.currentTime,
+      startSec,
+      playDuration,
+      bufferDuration: buffer.duration,
+      secPerBeat,
+      source
+    });
+    source.start(ctx.currentTime, startSec, playDuration);
+    source.onended = () => {
+      if (this.activeSources.get(track.id) === source) {
+        this.activeSources.delete(track.id);
+        this.activePlaybacks.delete(track.id);
+      }
+    };
+  }
+  getTrackPlaybackProgress(trackId) {
+    const playback = this.activePlaybacks.get(trackId);
+    if (!playback) return { isPlaying: false, progress: 0, currentBeat: 0, elapsedSec: 0 };
+    const ctx = this.getContext();
+    const elapsed = ctx.currentTime - playback.startTime;
+    if (elapsed > playback.playDuration) {
+      return { isPlaying: false, progress: 1, currentBeat: playback.playDuration / playback.secPerBeat, elapsedSec: playback.playDuration };
+    }
+    const progress = Math.max(0, Math.min(1, elapsed / playback.playDuration));
+    return { isPlaying: true, progress, currentBeat: elapsed / playback.secPerBeat, elapsedSec: elapsed };
+  }
+  stopAudioTrack(trackId) {
+    const active = this.activeSources.get(trackId);
+    if (active) {
+      try {
+        active.stop();
+        active.disconnect();
+      } catch {
+      }
+      this.activeSources.delete(trackId);
+      this.activePlaybacks.delete(trackId);
+    }
+  }
+  async loadAudioFile(file) {
+    const ctx = this.getContext();
+    const arrayBuf = await file.arrayBuffer();
+    const audioBuf = await ctx.decodeAudioData(arrayBuf);
+    const peaks = this.extractWaveformData(audioBuf, 100);
+    const url = URL.createObjectURL(file);
+    this.setBufferCacheEntry(url, audioBuf);
+    return { buffer: audioBuf, peaks, url };
+  }
+  startRecording(node, currentBeat, onUpdateNode) {
+    const updated = {
+      ...node,
+      isRecording: true,
+      isArmed: false,
+      quantizeStatus: "recording",
+      recordingStartBeat: currentBeat,
+      pendingTriggerBeat: null,
+      pendingAction: null
+    };
+    if (onUpdateNode) onUpdateNode(updated);
+  }
+  stopRecordingToContainer(node, targetContainer, onUpdateNode) {
+    const isAudio = node.recorderType === "audio" || node.recorderType === "audio_stereo" || node.recorderType === "audio_mono";
+    const isCurve = node.recorderType === "curve";
+    const isMidi = node.recorderType === "midi";
+    const durationBeats = node.recordingLengthBeats || 4;
+    const packetName = node.targetPacketName || `Take ${(node.recordedPacketsCount || 0) + 1}`;
+    const newPacket = {
+      id: `pkt-${Date.now()}`,
+      index: Array.isArray(targetContainer) && targetContainer[0]?.packets ? targetContainer[0].packets.length : targetContainer?.packets ? targetContainer.packets.length : 0,
+      name: packetName,
+      type: isAudio ? "audio" : isCurve ? "curve" : "midi",
+      signalFormat: "packet",
+      signalType: isAudio ? "audio_packet" : isCurve ? "curve_packet" : "midi_packet",
+      durationBeats,
+      createdAt: Date.now()
+    };
+    if (isAudio) {
+      newPacket.sampleType = "cosmic_warp";
+      newPacket.gain = 1;
+      newPacket.pan = 0;
+      newPacket.pitchShift = 0;
+      newPacket.filterCutoff = 8e3;
+      newPacket.fadeInBeats = 0.05;
+      newPacket.fadeOutBeats = 0.1;
+      newPacket.trimStartBeats = 0;
+      newPacket.trimEndBeats = durationBeats;
+      newPacket.audioFormat = node.recorderType === "audio_mono" ? "mono" : "stereo";
+    } else if (isCurve) {
+      newPacket.curveData = {
+        id: `crv-${Date.now()}`,
+        name: packetName,
+        lengthInBeats: durationBeats,
+        targetParam: "cutoff",
+        minValue: 400,
+        maxValue: 8e3,
+        points: [
+          { id: "p0", x: 0, y: 0.2, tension: 0 },
+          { id: "p1", x: durationBeats * 0.25, y: 0.8, tension: 0 },
+          { id: "p2", x: durationBeats * 0.5, y: 0.4, tension: 0 },
+          { id: "p3", x: durationBeats * 0.75, y: 0.9, tension: 0 },
+          { id: "p4", x: durationBeats, y: 0.2, tension: 0 }
+        ]
+      };
+    } else {
+      newPacket.pattern = {
+        id: `pat-${Date.now()}`,
+        name: packetName,
+        lengthInBeats: durationBeats,
+        tempo: 120,
+        notes: [
+          { note: 60, name: "C4", velocity: 0.8, time: 0, duration: 1 },
+          { note: 64, name: "E4", velocity: 0.8, time: 1, duration: 1 },
+          { note: 67, name: "G4", velocity: 0.8, time: 2, duration: 1 },
+          { note: 71, name: "B4", velocity: 0.8, time: 3, duration: 1 }
+        ]
+      };
+    }
+    const defaultWaveform = [
+      0.12,
+      0.35,
+      0.65,
+      0.8,
+      0.55,
+      0.72,
+      0.88,
+      0.6,
+      0.25,
+      0.48,
+      0.75,
+      0.9,
+      0.68,
+      0.38,
+      0.58,
+      0.82,
+      0.88,
+      0.58,
+      0.32,
+      0.52,
+      0.78,
+      0.89,
+      0.68,
+      0.48,
+      0.62,
+      0.82,
+      0.72,
+      0.48,
+      0.28,
+      0.42,
+      0.55,
+      0.32,
+      0.18,
+      0.12,
+      0.08,
+      0.06
+    ];
+    if (isAudio) {
+      newPacket.waveformData = defaultWaveform;
+    }
+    const containers = Array.isArray(targetContainer) ? targetContainer : targetContainer ? [targetContainer] : [];
+    containers.forEach((cont) => {
+      if (!cont || node.autoStoreOnStop === false) return;
+      if (isAudio) {
+        cont.audioTrack = {
+          id: `aud-${Date.now()}-${cont.id}`,
+          name: packetName,
+          sampleType: newPacket.sampleType || "cosmic_warp",
+          durationBeats,
+          gain: 1,
+          pan: 0,
+          pitchShift: 0,
+          filterCutoff: 8e3,
+          fadeInBeats: 0.05,
+          fadeOutBeats: 0.1,
+          trimStartBeats: 0,
+          trimEndBeats: durationBeats,
+          isReversed: false,
+          waveformData: defaultWaveform
+        };
+      } else if (isCurve) {
+        cont.curveData = newPacket.curveData;
+      } else {
+        cont.pattern = newPacket.pattern;
+      }
+    });
+    const updatedNode = {
+      ...node,
+      isRecording: false,
+      isArmed: false,
+      quantizeStatus: "idle",
+      pendingTriggerBeat: null,
+      pendingAction: null,
+      recordedPacketsCount: (node.recordedPacketsCount || 0) + 1,
+      targetPacketName: `Take ${(node.recordedPacketsCount || 0) + 2}`,
+      lastTransferredAt: Date.now()
+    };
+    if (onUpdateNode) onUpdateNode(updatedNode);
+  }
+};
+var audioClipEngine = new AudioClipEngine();
+
+export {
+  generatePresetAudioBuffer,
+  AudioClipEngine,
+  audioClipEngine
+};