@meframe/core 0.0.2 → 0.0.3

package/dist/model/types.js

@@ -1,5 +0,0 @@
-const MICROSECONDS_PER_SECOND = 1e6;
-export {
-  MICROSECONDS_PER_SECOND
-};
-//# sourceMappingURL=types.js.map

package/dist/model/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sources":["../../src/model/types.ts"],"sourcesContent":["// All time values in microseconds (µs)\nexport type TimeUs = number; // 1 second = 1_000_000 µs\n\n// Helper constants\nexport const MICROSECONDS_PER_SECOND = 1_000_000;\nexport const MICROSECONDS_PER_MILLISECOND = 1_000;\n\n// ────── Root Object ──────\nexport interface CompositionModelData {\n  version: '1.0';\n  fps: 24 | 25 | 30 | 60;\n  durationUs: TimeUs;\n\n  tracks: Track[];\n  resources: Record<string, Resource>;\n\n  renderConfig?: RenderConfig;\n\n  ext?: Record<string, unknown>;\n}\n\nexport interface RenderConfig {\n  width: number;\n  height: number;\n  backgroundColor?: string;\n}\n\n// ────── Track ──────\nexport interface Track {\n  id: string;\n  kind: 'video' | 'audio' | 'caption' | 'fx';\n  clips: Clip[];\n\n  effects?: Effect[];\n  duckingRules?: DuckingRule[];\n}\n\n// ────── Clip ──────\nexport interface Clip {\n  id: string;\n  resourceId: string;\n  startUs: TimeUs;\n  durationUs: TimeUs;\n  trackId?: string;\n  trackKind?: 'video' | 'audio' | 'caption' | 'fx';\n\n  trimStartUs?: TimeUs;\n  trimEndUs?: TimeUs;\n\n  effects?: Effect[];\n  attachments?: Attachment[];\n\n  transitionIn?: Transition;\n  transitionOut?: Transition;\n}\n\n// ────── Resource ──────\nexport interface Resource {\n  id: string;\n  type: 'video' | 'image' | 'audio' | 'json' | string;\n  uri: string;\n  metadata?: Record<string, unknown>;\n  clipIds?: string[];\n  // Runtime state maintained by engine\n  state?: 'pending' | 'loading' | 'ready' | 'error';\n}\n\n// ────── Common Structures ──────\nexport interface Effect {\n  id: string;\n  effectType: 'filter' | 'lut' | 'animation' | string;\n  params?: Record<string, unknown>;\n}\n\nexport interface Transition {\n  id: string;\n  transitionType: 'fade' | 'wipe' | 'slide' | string;\n  durationUs: TimeUs;\n  curve?: 'linear' | 'ease-in' | 'ease-out' | string;\n  params?: Record<string, unknown>;\n}\n\nexport interface Attachment {\n  id: string;\n  kind: 'caption' | 'sticker' | 'mask' | string;\n  startUs: TimeUs;\n  durationUs: TimeUs;\n  data: Record<string, unknown>;\n}\n\nexport interface DuckingRule {\n  targetTrackKind: 'voice' | 'audio' | string;\n  ratio: number;\n  attackMs: number;\n  releaseMs: number;\n}\n\n// ────── Patch System ──────\nexport interface CompositionPatch {\n  operations: PatchOperation[];\n  metadata?: {\n    timestamp: number;\n    source?: string;\n    version?: string;\n  };\n}\n\nexport type PatchOperation =\n  | TrackOperation\n  | ClipOperation\n  | ResourceOperation\n  | AttachmentOperation\n  | TransitionOperation\n  | EffectOperation\n  | RenderConfigOperation;\n\n// Track operations\nexport interface TrackOperation {\n  type: 'addTrack' | 'updateTrack' | 'removeTrack';\n  trackId?: string;\n  track?: Partial<Track>;\n}\n\n// Clip operations\nexport interface ClipOperation {\n  type: 'addClip' | 'updateClip' | 'removeClip' | 'moveClip';\n  trackId: string;\n  clipId?: string;\n  clip?: Partial<Clip>;\n  targetTrackId?: string;\n  targetStartUs?: TimeUs;\n}\n\n// Resource operations\nexport interface ResourceOperation {\n  type: 'addResource' | 'updateResource' | 'removeResource';\n  resourceId: string;\n  resource?: Partial<Resource>;\n}\n\n// Attachment operations\nexport interface AttachmentOperation {\n  type: 'addAttachment' | 'updateAttachment' | 'removeAttachment';\n  trackId: string;\n  clipId: string;\n  attachmentId?: string;\n  attachment?: Partial<Attachment>;\n}\n\n// Transition operations\nexport interface TransitionOperation {\n  type: 'addTransition' | 'updateTransition' | 'removeTransition';\n  trackId: string;\n  clipId: string;\n  position: 'in' | 'out';\n  transition?: Partial<Transition>;\n}\n\n// Render config operations\nexport interface RenderConfigOperation {\n  type: 'updateRenderConfig';\n  renderConfig?: Partial<RenderConfig>;\n}\n\n// Effect operations\nexport interface EffectOperation {\n  type: 'addEffect' | 'updateEffect' | 'removeEffect';\n  targetType: 'track' | 'clip';\n  targetId: string;\n  effectId?: string;\n  effect?: Partial<Effect>;\n}\n\n// ────── Dirty Range ──────\nexport interface DirtyRange {\n  trackId: string;\n  startUs: TimeUs;\n  endUs: TimeUs;\n  reason: string;\n}\n\n// ────── Validation ──────\nexport interface ValidationError {\n  path: string;\n  message: string;\n  value: any;\n}\n"],"names":[],"mappings":"AAIO,MAAM,0BAA0B;"}

package/dist/plugins/BackpressureMonitor.js

@@ -1,62 +0,0 @@
-class BackpressureMonitor {
-  metrics = /* @__PURE__ */ new Map();
-  /**
-   * Update metrics for a stage
-   */
-  updateMetrics(stage, desiredSize, queueSize = 0) {
-    const isPaused = desiredSize <= 0;
-    this.metrics.set(stage, {
-      desiredSize,
-      queueSize,
-      isPaused,
-      lastUpdate: Date.now()
-    });
-  }
-  /**
-   * Get current metrics snapshot
-   */
-  getSnapshot() {
-    const now = Date.now();
-    const snapshot = {};
-    for (const [stage, metrics] of this.metrics) {
-      snapshot[stage] = {
-        ...metrics,
-        age: now - metrics.lastUpdate
-      };
-    }
-    return snapshot;
-  }
-  /**
-   * Check if any stage is experiencing backpressure
-   */
-  hasBackpressure() {
-    for (const metrics of this.metrics.values()) {
-      if (metrics.isPaused) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Get stages currently experiencing backpressure
-   */
-  getBottlenecks() {
-    const bottlenecks = [];
-    for (const [stage, metrics] of this.metrics) {
-      if (metrics.isPaused) {
-        bottlenecks.push(stage);
-      }
-    }
-    return bottlenecks;
-  }
-  /**
-   * Clear all metrics
-   */
-  clear() {
-    this.metrics.clear();
-  }
-}
-export {
-  BackpressureMonitor
-};
-//# sourceMappingURL=BackpressureMonitor.js.map

package/dist/plugins/BackpressureMonitor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BackpressureMonitor.js","sources":["../../src/plugins/BackpressureMonitor.ts"],"sourcesContent":["/**\n * Monitor and report backpressure status across pipeline stages\n * This is a runtime monitoring tool used by plugins\n */\nexport class BackpressureMonitor {\n  private metrics = new Map<\n    string,\n    {\n      desiredSize: number;\n      queueSize: number;\n      isPaused: boolean;\n      lastUpdate: number;\n    }\n  >();\n\n  /**\n   * Update metrics for a stage\n   */\n  updateMetrics(stage: string, desiredSize: number, queueSize: number = 0): void {\n    const isPaused = desiredSize <= 0;\n    this.metrics.set(stage, {\n      desiredSize,\n      queueSize,\n      isPaused,\n      lastUpdate: Date.now(),\n    });\n  }\n\n  /**\n   * Get current metrics snapshot\n   */\n  getSnapshot(): Record<\n    string,\n    {\n      desiredSize: number;\n      queueSize: number;\n      isPaused: boolean;\n      age: number;\n    }\n  > {\n    const now = Date.now();\n    const snapshot: Record<string, any> = {};\n\n    for (const [stage, metrics] of this.metrics) {\n      snapshot[stage] = {\n        ...metrics,\n        age: now - metrics.lastUpdate,\n      };\n    }\n\n    return snapshot;\n  }\n\n  /**\n   * Check if any stage is experiencing backpressure\n   */\n  hasBackpressure(): boolean {\n    for (const metrics of this.metrics.values()) {\n      if (metrics.isPaused) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Get stages currently experiencing backpressure\n   */\n  getBottlenecks(): string[] {\n    const bottlenecks: string[] = [];\n    for (const [stage, metrics] of this.metrics) {\n      if (metrics.isPaused) {\n        bottlenecks.push(stage);\n      }\n    }\n    return bottlenecks;\n  }\n\n  /**\n   * Clear all metrics\n   */\n  clear(): void {\n    this.metrics.clear();\n  }\n}\n"],"names":[],"mappings":"AAIO,MAAM,oBAAoB;AAAA,EACvB,8BAAc,IAAA;AAAA;AAAA;AAAA;AAAA,EAatB,cAAc,OAAe,aAAqB,YAAoB,GAAS;AAC7E,UAAM,WAAW,eAAe;AAChC,SAAK,QAAQ,IAAI,OAAO;AAAA,MACtB;AAAA,MACA;AAAA,MACA;AAAA,MACA,YAAY,KAAK,IAAA;AAAA,IAAI,CACtB;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,cAQE;AACA,UAAM,MAAM,KAAK,IAAA;AACjB,UAAM,WAAgC,CAAA;AAEtC,eAAW,CAAC,OAAO,OAAO,KAAK,KAAK,SAAS;AAC3C,eAAS,KAAK,IAAI;AAAA,QAChB,GAAG;AAAA,QACH,KAAK,MAAM,QAAQ;AAAA,MAAA;AAAA,IAEvB;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,kBAA2B;AACzB,eAAW,WAAW,KAAK,QAAQ,OAAA,GAAU;AAC3C,UAAI,QAAQ,UAAU;AACpB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,iBAA2B;AACzB,UAAM,cAAwB,CAAA;AAC9B,eAAW,CAAC,OAAO,OAAO,KAAK,KAAK,SAAS;AAC3C,UAAI,QAAQ,UAAU;AACpB,oBAAY,KAAK,KAAK;AAAA,MACxB;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,QAAQ,MAAA;AAAA,EACf;AACF;"}

package/dist/stages/compose/AudioDucker.js

@@ -1,161 +0,0 @@
-class AudioDucker {
-  config = null;
-  sampleRate;
-  constructor(sampleRate) {
-    this.sampleRate = sampleRate;
-  }
-  configure(config) {
-    this.config = config;
-  }
-  /**
-   * Analyze trigger tracks (voice) and generate ducking envelope
-   * Returns gain values (0-1) to apply to target tracks (BGM)
-   */
-  async generateDuckingEnvelope(tracks, frameCount) {
-    if (!this.config?.enabled) {
-      return new Float32Array(frameCount).fill(1);
-    }
-    const envelope = new Float32Array(frameCount);
-    envelope.fill(1);
-    const triggerTracks = tracks.filter((t) => this.config.triggerTracks.includes(t.trackId));
-    if (triggerTracks.length === 0) {
-      return envelope;
-    }
-    for (const track of triggerTracks) {
-      const voiceActivity = await this.detectVoiceActivity(track.audioData);
-      this.applyDuckingToEnvelope(envelope, voiceActivity);
-    }
-    return envelope;
-  }
-  /**
-   * Voice Activity Detection (VAD)
-   * Simple energy-based detection with smoothing
-   * More sophisticated implementations could use:
-   * - Zero-crossing rate (ZCR) for speech/music discrimination
-   * - Spectral centroid for voice frequency detection
-   * - Machine learning models for robust VAD
-   */
-  async detectVoiceActivity(audioData) {
-    const frameCount = audioData.numberOfFrames;
-    const activity = new Float32Array(frameCount);
-    const monoData = new Float32Array(frameCount);
-    const channelData = new Float32Array(frameCount);
-    for (let ch = 0; ch < audioData.numberOfChannels; ch++) {
-      audioData.copyTo(channelData, {
-        planeIndex: ch,
-        format: "f32-planar"
-      });
-      for (let i = 0; i < frameCount; i++) {
-        if (monoData && channelData) {
-          monoData[i] = (monoData[i] || 0) + (channelData[i] || 0) / audioData.numberOfChannels;
-        }
-      }
-    }
-    const windowSize = Math.floor(this.sampleRate * 0.02);
-    const hopSize = Math.floor(windowSize / 2);
-    for (let i = 0; i < frameCount; i += hopSize) {
-      const end = Math.min(i + windowSize, frameCount);
-      let energy = 0;
-      for (let j = i; j < end; j++) {
-        if (monoData && monoData[j] !== void 0) {
-          const sample = monoData[j];
-          if (sample !== void 0) {
-            energy += sample * sample;
-          }
-        }
-      }
-      energy = Math.sqrt(energy / (end - i));
-      const threshold = 0.01;
-      const isVoice = energy > threshold;
-      for (let j = i; j < end; j++) {
-        activity[j] = isVoice ? 1 : 0;
-      }
-    }
-    return this.smoothActivityDetection(activity);
-  }
-  /**
-   * Smooth voice activity detection to avoid choppy ducking
-   * Uses a simple moving average filter
-   */
-  smoothActivityDetection(activity) {
-    const smoothed = new Float32Array(activity.length);
-    const smoothWindow = Math.floor(this.sampleRate * 0.05);
-    for (let i = 0; i < activity.length; i++) {
-      let sum = 0;
-      let count = 0;
-      for (let j = Math.max(0, i - smoothWindow); j <= Math.min(activity.length - 1, i + smoothWindow); j++) {
-        if (activity && activity[j] !== void 0) {
-          const val = activity[j];
-          if (val !== void 0) {
-            sum += val;
-          }
-        }
-        count++;
-      }
-      smoothed[i] = sum / count;
-    }
-    return smoothed;
-  }
-  /**
-   * Apply ducking based on voice activity
-   * Implements attack/release envelope shaping
-   */
-  applyDuckingToEnvelope(envelope, voiceActivity) {
-    if (!this.config) return;
-    const duckingLevel = 1 - this.config.duckingLevel;
-    const attackSamples = Math.floor(this.config.attackTimeMs / 1e3 * this.sampleRate);
-    const releaseSamples = Math.floor(this.config.releaseTimeMs / 1e3 * this.sampleRate);
-    const lookAheadSamples = this.config.lookAheadMs ? Math.floor(this.config.lookAheadMs / 1e3 * this.sampleRate) : 0;
-    let currentGain = 1;
-    let releaseCounter = 0;
-    for (let i = 0; i < envelope.length; i++) {
-      const lookAheadIndex = Math.min(i + lookAheadSamples, voiceActivity.length - 1);
-      const activity = voiceActivity[lookAheadIndex];
-      if (activity !== void 0 && activity > 0.5) {
-        if (currentGain > duckingLevel) {
-          currentGain = Math.max(duckingLevel, currentGain - (1 - duckingLevel) / attackSamples);
-        } else {
-          currentGain = duckingLevel;
-        }
-        releaseCounter = 0;
-      } else if (currentGain < 1) {
-        releaseCounter++;
-        if (releaseCounter > releaseSamples * 0.1) {
-          currentGain = Math.min(1, currentGain + (1 - duckingLevel) / releaseSamples);
-        }
-      }
-      envelope[i] = Math.min(envelope[i] || 1, currentGain);
-    }
-  }
-  /**
-   * Apply ducking envelope to audio buffer
-   * This modulates the volume over time according to the envelope
-   */
-  applyEnvelopeToVolume(baseVolume, envelope) {
-    const result = new Float32Array(envelope.length);
-    for (let i = 0; i < envelope.length; i++) {
-      result[i] = baseVolume * (envelope[i] || 1);
-    }
-    return result;
-  }
-  /**
-   * Calculate dynamic range to avoid over-compression
-   * Returns the difference between peak and RMS levels in dB
-   */
-  calculateDynamicRange(envelope) {
-    let peak = 0;
-    let sumSquares = 0;
-    for (const value of envelope) {
-      peak = Math.max(peak, value);
-      sumSquares += value * value;
-    }
-    const rms = Math.sqrt(sumSquares / envelope.length);
-    const peakDb = 20 * Math.log10(peak);
-    const rmsDb = 20 * Math.log10(rms);
-    return peakDb - rmsDb;
-  }
-}
-export {
-  AudioDucker
-};
-//# sourceMappingURL=AudioDucker.js.map

package/dist/stages/compose/AudioDucker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AudioDucker.js","sources":["../../../src/stages/compose/AudioDucker.ts"],"sourcesContent":["import type { DuckingConfig, MixRequest } from './types';\n\n/**\n * AudioDucker - Automatic volume ducking for background music\n *\n * Ducking: Audio engineering technique where the volume of one audio source\n * is automatically reduced when another audio source is present.\n *\n * Common use case: Reduce background music volume when voice/narration plays\n * to improve speech intelligibility without completely muting the music.\n *\n * Key parameters:\n * - Threshold: Level at which ducking triggers\n * - Ratio: How much to reduce volume (e.g., 3:1 means reduce by 1/3)\n * - Attack: How quickly volume reduces (typically 10-50ms)\n * - Release: How quickly volume returns to normal (typically 100-500ms)\n * - Hold: Time to maintain ducking after trigger ends\n */\nexport class AudioDucker {\n  private config: DuckingConfig | null = null;\n  private sampleRate: number;\n\n  constructor(sampleRate: number) {\n    this.sampleRate = sampleRate;\n  }\n\n  configure(config: DuckingConfig): void {\n    this.config = config;\n  }\n\n  /**\n   * Analyze trigger tracks (voice) and generate ducking envelope\n   * Returns gain values (0-1) to apply to target tracks (BGM)\n   */\n  async generateDuckingEnvelope(\n    tracks: MixRequest['tracks'],\n    frameCount: number\n  ): Promise<Float32Array> {\n    if (!this.config?.enabled) {\n      return new Float32Array(frameCount).fill(1.0);\n    }\n\n    // Initialize envelope with no ducking (gain = 1.0)\n    const envelope = new Float32Array(frameCount);\n    envelope.fill(1.0);\n\n    // Find trigger tracks (typically voice/narration)\n    const triggerTracks = tracks.filter((t) => this.config!.triggerTracks.includes(t.trackId));\n\n    if (triggerTracks.length === 0) {\n      return envelope;\n    }\n\n    // Analyze each trigger track for voice activity\n    for (const track of triggerTracks) {\n      const voiceActivity = await this.detectVoiceActivity(track.audioData);\n      this.applyDuckingToEnvelope(envelope, voiceActivity);\n    }\n\n    return envelope;\n  }\n\n  /**\n   * Voice Activity Detection (VAD)\n   * Simple energy-based detection with smoothing\n   * More sophisticated implementations could use:\n   * - Zero-crossing rate (ZCR) for speech/music discrimination\n   * - Spectral centroid for voice frequency detection\n   * - Machine learning models for robust VAD\n   */\n  private async detectVoiceActivity(audioData: AudioData): Promise<Float32Array> {\n    const frameCount = audioData.numberOfFrames;\n    const activity = new Float32Array(frameCount);\n\n    // Convert to mono for analysis\n    const monoData = new Float32Array(frameCount);\n    const channelData = new Float32Array(frameCount);\n\n    for (let ch = 0; ch < audioData.numberOfChannels; ch++) {\n      audioData.copyTo(channelData, {\n        planeIndex: ch,\n        format: 'f32-planar' as const,\n      });\n\n      for (let i = 0; i < frameCount; i++) {\n        if (monoData && channelData) {\n          monoData[i] = (monoData[i] || 0) + (channelData[i] || 0) / audioData.numberOfChannels;\n        }\n      }\n    }\n\n    // Energy calculation with windowing\n    // Window size: 20ms is typical for speech analysis\n    const windowSize = Math.floor(this.sampleRate * 0.02);\n    const hopSize = Math.floor(windowSize / 2); // 50% overlap\n\n    for (let i = 0; i < frameCount; i += hopSize) {\n      const end = Math.min(i + windowSize, frameCount);\n\n      // Calculate RMS energy in window\n      let energy = 0;\n      for (let j = i; j < end; j++) {\n        if (monoData && monoData[j] !== undefined) {\n          const sample = monoData[j];\n          if (sample !== undefined) {\n            energy += sample * sample;\n          }\n        }\n      }\n      energy = Math.sqrt(energy / (end - i));\n\n      // Simple threshold-based VAD\n      // Typical speech energy threshold: -40dB to -30dB\n      const threshold = 0.01; // Approximately -40dB\n      const isVoice = energy > threshold;\n\n      // Fill activity array for this window\n      for (let j = i; j < end; j++) {\n        activity[j] = isVoice ? 1.0 : 0.0;\n      }\n    }\n\n    // Smooth activity detection to avoid rapid changes\n    return this.smoothActivityDetection(activity);\n  }\n\n  /**\n   * Smooth voice activity detection to avoid choppy ducking\n   * Uses a simple moving average filter\n   */\n  private smoothActivityDetection(activity: Float32Array): Float32Array {\n    const smoothed = new Float32Array(activity.length);\n    const smoothWindow = Math.floor(this.sampleRate * 0.05); // 50ms smoothing\n\n    for (let i = 0; i < activity.length; i++) {\n      let sum = 0;\n      let count = 0;\n\n      for (\n        let j = Math.max(0, i - smoothWindow);\n        j <= Math.min(activity.length - 1, i + smoothWindow);\n        j++\n      ) {\n        if (activity && activity[j] !== undefined) {\n          const val = activity[j];\n          if (val !== undefined) {\n            sum += val;\n          }\n        }\n        count++;\n      }\n\n      smoothed[i] = sum / count;\n    }\n\n    return smoothed;\n  }\n\n  /**\n   * Apply ducking based on voice activity\n   * Implements attack/release envelope shaping\n   */\n  private applyDuckingToEnvelope(envelope: Float32Array, voiceActivity: Float32Array): void {\n    if (!this.config) return;\n\n    const duckingLevel = 1.0 - this.config.duckingLevel;\n    const attackSamples = Math.floor((this.config.attackTimeMs / 1000) * this.sampleRate);\n    const releaseSamples = Math.floor((this.config.releaseTimeMs / 1000) * this.sampleRate);\n    const lookAheadSamples = this.config.lookAheadMs\n      ? Math.floor((this.config.lookAheadMs / 1000) * this.sampleRate)\n      : 0;\n\n    let currentGain = 1.0;\n    let releaseCounter = 0;\n\n    for (let i = 0; i < envelope.length; i++) {\n      // Look ahead for upcoming voice activity\n      const lookAheadIndex = Math.min(i + lookAheadSamples, voiceActivity.length - 1);\n      const activity = voiceActivity[lookAheadIndex];\n\n      if (activity !== undefined && activity > 0.5) {\n        // Voice detected - apply ducking with attack curve\n        if (currentGain > duckingLevel) {\n          // Attack phase - reduce gain\n          currentGain = Math.max(duckingLevel, currentGain - (1.0 - duckingLevel) / attackSamples);\n        } else {\n          currentGain = duckingLevel;\n        }\n        releaseCounter = 0;\n      } else if (currentGain < 1.0) {\n        // No voice - apply release curve\n        releaseCounter++;\n        if (releaseCounter > releaseSamples * 0.1) {\n          // Small hold time\n          currentGain = Math.min(1.0, currentGain + (1.0 - duckingLevel) / releaseSamples);\n        }\n      }\n\n      // Apply the calculated gain\n      envelope[i] = Math.min(envelope[i] || 1, currentGain);\n    }\n  }\n\n  /**\n   * Apply ducking envelope to audio buffer\n   * This modulates the volume over time according to the envelope\n   */\n  applyEnvelopeToVolume(baseVolume: number, envelope: Float32Array): Float32Array {\n    const result = new Float32Array(envelope.length);\n    for (let i = 0; i < envelope.length; i++) {\n      result[i] = baseVolume * (envelope[i] || 1);\n    }\n    return result;\n  }\n\n  /**\n   * Calculate dynamic range to avoid over-compression\n   * Returns the difference between peak and RMS levels in dB\n   */\n  calculateDynamicRange(envelope: Float32Array): number {\n    let peak = 0;\n    let sumSquares = 0;\n\n    for (const value of envelope) {\n      peak = Math.max(peak, value);\n      sumSquares += value * value;\n    }\n\n    const rms = Math.sqrt(sumSquares / envelope.length);\n\n    // Convert to dB (20 * log10(ratio))\n    const peakDb = 20 * Math.log10(peak);\n    const rmsDb = 20 * Math.log10(rms);\n\n    return peakDb - rmsDb;\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/stages/compose/AudioMixer.js

@@ -1,373 +0,0 @@
-class AudioMixer {
-  config;
-  tracksMap = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-  }
-  getConfig() {
-    return { ...this.config };
-  }
-  updateConfig(update) {
-    this.config = { ...this.config, ...update };
-  }
-  get tracks() {
-    return Array.from(this.tracksMap.values());
-  }
-  createMixStream(ducker) {
-    return new TransformStream(
-      {
-        transform: async (request, controller) => {
-          try {
-            const frameCount = this.getFrameCount(request.durationUs);
-            if (ducker && request.duckingConfig?.enabled && frameCount > 0) {
-              const envelope = await ducker.generateDuckingEnvelope(request.tracks, frameCount);
-              for (const track of request.tracks) {
-                if (request.duckingConfig.targetTracks.includes(track.trackId)) {
-                  track.duckingEnvelope = ducker.applyEnvelopeToVolume(1, envelope);
-                }
-              }
-            }
-            const result = await this.mixTracks(request, frameCount);
-            controller.enqueue(result);
-          } catch (error) {
-            controller.error(error);
-          }
-        }
-      },
-      {
-        highWaterMark: 2,
-        size: () => 1
-      }
-    );
-  }
-  async mixTracks(request, precomputedFrameCount) {
-    const tracks = request.tracks ?? [];
-    const frameCount = precomputedFrameCount ?? this.getFrameCount(request.durationUs);
-    const requestedChannelCount = this.config.numberOfChannels ?? 0;
-    const inferredChannelCount = tracks.reduce((max, track) => {
-      const trackChannels = track?.numberOfChannels ?? track?.audioData?.numberOfChannels ?? this.config.numberOfChannels ?? 0;
-      return trackChannels > max ? trackChannels : max;
-    }, 0);
-    const channelCount = requestedChannelCount > 0 ? requestedChannelCount : Math.max(inferredChannelCount, 1);
-    const outputChannels = Array.from({ length: channelCount }, () => {
-      return new Float32Array(frameCount);
-    });
-    for (const track of tracks) {
-      if (!track) {
-        continue;
-      }
-      const resolvedAudioData = track.audioData;
-      if (!resolvedAudioData) {
-        continue;
-      }
-      this.mixTrackIntoOutput(
-        outputChannels,
-        {
-          ...track,
-          audioData: resolvedAudioData,
-          numberOfChannels: track.numberOfChannels ?? resolvedAudioData.numberOfChannels ?? this.config.numberOfChannels,
-          sampleRate: track.sampleRate ?? resolvedAudioData.sampleRate ?? this.config.sampleRate
-        },
-        request.timeUs,
-        frameCount
-      );
-    }
-    const { peakLevel, rmsLevel } = this.limitAndMeasure(outputChannels);
-    const audioData = this.createAudioData(outputChannels, request.timeUs);
-    return {
-      audioData,
-      timeUs: request.timeUs,
-      durationUs: request.durationUs,
-      peakLevel,
-      rmsLevel
-    };
-  }
-  addTrack(track) {
-    this.tracksMap.set(track.id, track);
-  }
-  removeTrack(trackId) {
-    this.tracksMap.delete(trackId);
-  }
-  updateTrack(trackId, patch) {
-    const track = this.tracksMap.get(trackId);
-    if (!track) {
-      return;
-    }
-    const { config, ...rest } = patch;
-    if (config) {
-      Object.assign(track.config, config);
-    }
-    Object.assign(track, rest);
-  }
-  mixTrackIntoOutput(outputChannels, track, mixStartUs, totalFrameCount) {
-    if (totalFrameCount === 0) {
-      track.audioData.close();
-      return;
-    }
-    if (track.sampleRate !== this.config.sampleRate) {
-      track.audioData.close();
-      throw new Error("AudioMixer: sample rate mismatch");
-    }
-    const trackChannelCount = track.audioData.numberOfChannels ?? track.numberOfChannels ?? 0;
-    if (trackChannelCount === 0) {
-      track.audioData.close();
-      return;
-    }
-    const trackChannels = this.extractChannels(track.audioData);
-    if (trackChannels.length === 0) {
-      track.audioData.close();
-      return;
-    }
-    const trackFrameCount = track.audioData.numberOfFrames;
-    if (trackFrameCount === 0) {
-      track.audioData.close();
-      return;
-    }
-    const timestampUs = track.audioData.timestamp ?? mixStartUs;
-    const deltaUs = timestampUs - mixStartUs;
-    let outputOffsetFrames = Math.round(deltaUs / 1e6 * this.config.sampleRate);
-    let sourceOffsetFrames = 0;
-    if (outputOffsetFrames < 0) {
-      sourceOffsetFrames = Math.min(trackFrameCount, -outputOffsetFrames);
-      outputOffsetFrames = 0;
-    }
-    if (outputOffsetFrames >= totalFrameCount) {
-      track.audioData.close();
-      return;
-    }
-    const availableFrames = Math.min(
-      trackFrameCount - sourceOffsetFrames,
-      totalFrameCount - outputOffsetFrames
-    );
-    if (availableFrames <= 0) {
-      track.audioData.close();
-      return;
-    }
-    const gains = this.buildGainEnvelope(
-      track,
-      availableFrames,
-      outputOffsetFrames,
-      sourceOffsetFrames,
-      trackFrameCount
-    );
-    const destinationChannelCount = outputChannels.length;
-    const sourceChannelCount = trackChannels.length;
-    for (let channelIndex = 0; channelIndex < destinationChannelCount; channelIndex++) {
-      const destination = outputChannels[channelIndex];
-      const source = trackChannels[channelIndex] ?? trackChannels[sourceChannelCount - 1];
-      if (!destination || !source) continue;
-      for (let frameIndex = 0; frameIndex < availableFrames; frameIndex++) {
-        const sample = source[sourceOffsetFrames + frameIndex] ?? 0;
-        const gain = gains[frameIndex] ?? 0;
-        destination[outputOffsetFrames + frameIndex] = (destination[outputOffsetFrames + frameIndex] ?? 0) + sample * gain;
-      }
-    }
-    track.audioData.close();
-  }
-  buildGainEnvelope(track, length, outputOffsetFrames, sourceOffsetFrames, trackFrameCount) {
-    const gains = new Float32Array(length);
-    const baseVolume = typeof track.config.volume === "number" ? track.config.volume : 1;
-    gains.fill(baseVolume);
-    const fadeInSamples = this.getFadeSampleCount(track.config.fadeIn);
-    const fadeOutSamples = this.getFadeSampleCount(track.config.fadeOut);
-    const clipDurationSamples = this.getClipSampleCount(track.config.durationUs) || trackFrameCount;
-    const trackStartFrame = this.computeTrackStartFrame(track);
-    for (let i = 0; i < length; i++) {
-      const envelopeIndex = outputOffsetFrames + i;
-      const absoluteFrame = trackStartFrame + sourceOffsetFrames + i;
-      let gain = baseVolume;
-      if (fadeInSamples > 0 && absoluteFrame < fadeInSamples) {
-        const progress = Math.min(1, absoluteFrame / fadeInSamples);
-        gain *= this.getCurveValue(progress, track.config.fadeIn?.curve);
-      }
-      if (fadeOutSamples > 0 && clipDurationSamples > 0) {
-        const fadeStart = Math.max(0, clipDurationSamples - fadeOutSamples);
-        if (absoluteFrame >= fadeStart) {
-          const progress = Math.min(1, (absoluteFrame - fadeStart) / fadeOutSamples);
-          const remaining = Math.max(0, 1 - progress);
-          gain *= this.getCurveValue(remaining, track.config.fadeOut?.curve);
-        }
-      }
-      if (track.duckingEnvelope && envelopeIndex < track.duckingEnvelope.length && envelopeIndex >= 0) {
-        gain *= track.duckingEnvelope[envelopeIndex] ?? 1;
-      }
-      gains[i] = gain;
-    }
-    return gains;
-  }
-  extractChannels(audioData) {
-    const configuredChannels = this.config.numberOfChannels ?? 0;
-    const channelCount = audioData.numberOfChannels ?? configuredChannels;
-    const frameCount = audioData.numberOfFrames;
-    const format = audioData.format ?? "f32";
-    if (!channelCount || !frameCount) {
-      return [];
-    }
-    const toFloat = (value) => value / 32768;
-    const zeroChannels = () => Array.from(
-      { length: configuredChannels || channelCount },
-      () => new Float32Array(frameCount)
-    );
-    if (format === "f32") {
-      const interleaved = new Float32Array(frameCount * channelCount);
-      audioData.copyTo(interleaved, { format: "f32", planeIndex: 0 });
-      const channels2 = zeroChannels();
-      for (let frame = 0; frame < frameCount; frame++) {
-        const offset = frame * channelCount;
-        for (let channel = 0; channel < channels2.length; channel++) {
-          const channelArray = channels2[channel];
-          if (!channelArray) continue;
-          const sourceChannel = channel < channelCount ? channel : channelCount - 1;
-          channelArray[frame] = interleaved[offset + sourceChannel] ?? 0;
-        }
-      }
-      return channels2;
-    }
-    if (format === "s16") {
-      const interleaved = new Int16Array(frameCount * channelCount);
-      audioData.copyTo(interleaved, { format: "s16", planeIndex: 0 });
-      const channels2 = zeroChannels();
-      for (let frame = 0; frame < frameCount; frame++) {
-        const offset = frame * channelCount;
-        for (let channel = 0; channel < channels2.length; channel++) {
-          const channelArray = channels2[channel];
-          if (!channelArray) continue;
-          const sourceChannel = channel < channelCount ? channel : channelCount - 1;
-          channelArray[frame] = toFloat(interleaved[offset + sourceChannel] ?? 0);
-        }
-      }
-      return channels2;
-    }
-    if (format === "f32-planar") {
-      const channels2 = zeroChannels();
-      for (let channel = 0; channel < channels2.length; channel++) {
-        const channelArray = channels2[channel];
-        if (!channelArray) continue;
-        const sourceChannel = channel < channelCount ? channel : channelCount - 1;
-        audioData.copyTo(channelArray, { planeIndex: sourceChannel, format: "f32-planar" });
-      }
-      return channels2;
-    }
-    if (format === "s16-planar") {
-      const tmp = new Int16Array(frameCount);
-      const channels2 = zeroChannels();
-      for (let channel = 0; channel < channels2.length; channel++) {
-        const channelArray = channels2[channel];
-        if (!channelArray) continue;
-        const sourceChannel = channel < channelCount ? channel : channelCount - 1;
-        audioData.copyTo(tmp, { planeIndex: sourceChannel, format: "s16-planar" });
-        for (let i = 0; i < frameCount; i++) {
-          channelArray[i] = toFloat(tmp[i] ?? 0);
-        }
-      }
-      return channels2;
-    }
-    const channels = zeroChannels();
-    for (let channel = 0; channel < channels.length; channel++) {
-      const channelArray = channels[channel];
-      if (!channelArray) continue;
-      const sourceChannel = channel < channelCount ? channel : channelCount - 1;
-      audioData.copyTo(channelArray, { planeIndex: sourceChannel });
-    }
-    return channels;
-  }
-  limitAndMeasure(channels) {
-    let peak = 0;
-    let sumSquares = 0;
-    let samples = 0;
-    for (const channel of channels) {
-      for (let i = 0; i < channel.length; i++) {
-        let sample = channel[i] ?? 0;
-        if (sample > 1) {
-          sample = 1;
-        } else if (sample < -1) {
-          sample = -1;
-        }
-        channel[i] = sample;
-        const absSample = Math.abs(sample);
-        if (absSample > peak) {
-          peak = absSample;
-        }
-        sumSquares += sample * sample;
-        samples++;
-      }
-    }
-    const rmsLevel = samples > 0 ? Math.sqrt(sumSquares / samples) : 0;
-    return {
-      peakLevel: peak,
-      rmsLevel
-    };
-  }
-  createAudioData(channels, timestampUs) {
-    const configuredChannels = this.config.numberOfChannels ?? 0;
-    const inferredChannels = channels.length;
-    const numberOfChannels = (inferredChannels > 0 ? inferredChannels : configuredChannels) || 1;
-    const numberOfFrames = channels[0]?.length ?? 0;
-    if (numberOfFrames === 0) {
-      return new AudioData({
-        format: "f32",
-        sampleRate: this.config.sampleRate,
-        numberOfFrames: 0,
-        numberOfChannels,
-        timestamp: timestampUs,
-        data: new Float32Array(0)
-      });
-    }
-    const interleaved = new Float32Array(numberOfFrames * numberOfChannels);
-    for (let frame = 0; frame < numberOfFrames; frame++) {
-      for (let channel = 0; channel < numberOfChannels; channel++) {
-        const sourceChannel = channels[channel] ?? channels[channels.length - 1];
-        interleaved[frame * numberOfChannels + channel] = sourceChannel?.[frame] ?? 0;
-      }
-    }
-    return new AudioData({
-      format: "f32",
-      sampleRate: this.config.sampleRate,
-      numberOfFrames,
-      numberOfChannels,
-      timestamp: timestampUs,
-      data: interleaved
-    });
-  }
-  getFrameCount(durationUs) {
-    if (durationUs <= 0) {
-      return 0;
-    }
-    return Math.ceil(durationUs / 1e6 * this.config.sampleRate);
-  }
-  getFadeSampleCount(fade) {
-    if (!fade || fade.durationUs <= 0) {
-      return 0;
-    }
-    return Math.round(fade.durationUs / 1e6 * this.config.sampleRate);
-  }
-  getClipSampleCount(durationUs) {
-    if (!durationUs || durationUs <= 0) {
-      return 0;
-    }
-    return Math.round(durationUs / 1e6 * this.config.sampleRate);
-  }
-  computeTrackStartFrame(track) {
-    const audioTimestamp = track.audioData.timestamp ?? track.config.startTimeUs;
-    const relativeUs = audioTimestamp - track.config.startTimeUs;
-    const relativeFrames = Math.round(relativeUs / 1e6 * this.config.sampleRate);
-    return relativeFrames > 0 ? relativeFrames : 0;
-  }
-  getCurveValue(progress, curve = "linear") {
-    const clamped = Math.min(Math.max(progress, 0), 1);
-    switch (curve) {
-      case "exponential":
-        return clamped * clamped;
-      case "logarithmic":
-        return Math.log10(clamped * 9 + 1);
-      case "cosine":
-        return (1 - Math.cos(clamped * Math.PI)) / 2;
-      default:
-        return clamped;
-    }
-  }
-}
-export {
-  AudioMixer
-};
-//# sourceMappingURL=AudioMixer.js.map