@meframe/core 0.0.5 → 0.0.7

package/dist/workers/stages/decode/decode.worker.js

@@ -1,826 +0,0 @@
-import { W as WorkerChannel, a as WorkerMessageType, b as WorkerState } from "../../WorkerChannel.js";
-class BaseDecoder {
-  decoder;
-  config;
-  controller = null;
-  constructor(config) {
-    this.config = config;
-  }
-  async initialize() {
-    if (this.decoder?.state === "configured") {
-      return;
-    }
-    const isSupported = await this.isConfigSupported(this.config);
-    if (!isSupported.supported) {
-      throw new Error(
-        `Codec not supported: ${this.config.codecString || this.config.codec}`
-      );
-    }
-    this.decoder = this.createDecoder({
-      output: this.handleOutput.bind(this),
-      error: this.handleError.bind(this)
-    });
-    await this.configureDecoder(this.config);
-  }
-  async reconfigure(config) {
-    this.config = { ...this.config, ...config };
-    if (!this.decoder) {
-      await this.initialize();
-      return;
-    }
-    if (this.decoder.state === "configured") {
-      await this.decoder.flush();
-    }
-    const isSupported = await this.isConfigSupported(this.config);
-    if (!isSupported.supported) {
-      throw new Error(
-        `New configuration not supported: ${this.config.codecString || this.config.codec}`
-      );
-    }
-    await this.configureDecoder(this.config);
-  }
-  async flush() {
-    if (!this.decoder) return;
-    await this.decoder.flush();
-  }
-  async reset() {
-    if (!this.decoder) return;
-    this.decoder.reset();
-    this.onReset();
-  }
-  async close() {
-    if (!this.decoder) return;
-    if (this.decoder.state === "configured") {
-      await this.decoder.flush();
-    }
-    this.decoder.close();
-    this.decoder = void 0;
-  }
-  get isReady() {
-    return this.decoder?.state === "configured";
-  }
-  get queueSize() {
-    return this.decoder?.decodeQueueSize ?? 0;
-  }
-  handleOutput(data) {
-    if (!this.controller) {
-      this.closeIfPossible(data);
-      return;
-    }
-    try {
-      this.controller.enqueue(data);
-    } catch (error) {
-      if (error instanceof TypeError && /Cannot enqueue a chunk into a readable stream that is closed/.test(error.message)) {
-        this.closeIfPossible(data);
-        return;
-      }
-      throw error;
-    }
-  }
-  handleError(error) {
-    console.error(`${this.getDecoderType()} decoder error:`, error);
-    this.controller?.error(error);
-  }
-  closeIfPossible(data) {
-    data?.close?.();
-    data?.frame?.close?.();
-  }
-  onReset() {
-  }
-  createStream() {
-    return new TransformStream(
-      {
-        start: async (controller) => {
-          this.controller = controller;
-          if (!this.isReady) {
-            await this.initialize();
-          }
-        },
-        transform: async (input) => {
-          if (!this.decoder || this.decoder.state !== "configured") {
-            throw new Error("Decoder not configured");
-          }
-          if (this.decoder.decodeQueueSize >= this.decodeQueueThreshold) {
-            await new Promise((resolve) => {
-              const check = () => {
-                if (!this.decoder || this.decoder.decodeQueueSize < this.decodeQueueThreshold - 1) {
-                  resolve();
-                } else {
-                  setTimeout(check, 10);
-                }
-              };
-              check();
-            });
-          }
-          this.decode(input);
-        },
-        flush: async () => {
-          await this.flush();
-        }
-      },
-      {
-        highWaterMark: this.highWaterMark,
-        size: () => 1
-      }
-    );
-  }
-}
-class VideoChunkDecoder extends BaseDecoder {
-  static DEFAULT_HIGH_WATER_MARK = 4;
-  static DEFAULT_DECODE_QUEUE_THRESHOLD = 16;
-  trackId;
-  highWaterMark;
-  decodeQueueThreshold;
-  // GOP tracking (serial is derived from keyframe timestamp for idempotency)
-  currentGopSerial = -1;
-  isCurrentFrameKeyframe = false;
-  // Buffering support for delayed configuration
-  bufferedChunks = [];
-  isProcessingBuffer = false;
-  constructor(trackId, config) {
-    super(config || {});
-    this.trackId = trackId;
-    this.highWaterMark = config?.backpressure?.highWaterMark ?? VideoChunkDecoder.DEFAULT_HIGH_WATER_MARK;
-    this.decodeQueueThreshold = config?.backpressure?.decodeQueueThreshold ?? VideoChunkDecoder.DEFAULT_DECODE_QUEUE_THRESHOLD;
-  }
-  // Computed properties
-  get isConfigured() {
-    return this.isReady;
-  }
-  get state() {
-    return this.decoder?.state || "unconfigured";
-  }
-  /**
-   * Update configuration - can be called before or after initialization
-   */
-  async updateConfig(config) {
-    if (!this.isReady && config.codec) {
-      await this.configure(config);
-      await this.processBufferedChunks();
-    }
-  }
-  // Override createStream to handle GOP tracking and buffering
-  // Always create new stream for each clip (ReadableStreams can only be consumed once)
-  createStream() {
-    return new TransformStream(
-      {
-        start: async (controller) => {
-          this.controller = controller;
-          if (this.config?.codec && this.config?.description && !this.isReady) {
-            await this.initialize();
-          }
-        },
-        transform: async (chunk) => {
-          if (!this.isReady) {
-            this.bufferedChunks.push(chunk);
-            return;
-          }
-          if (this.isProcessingBuffer) {
-            this.bufferedChunks.push(chunk);
-            return;
-          }
-          await this.processChunk(chunk);
-        },
-        flush: async () => {
-          if (this.isReady) {
-            await this.flush();
-          }
-        }
-      },
-      {
-        highWaterMark: this.highWaterMark,
-        size: () => 1
-      }
-    );
-  }
-  /**
-   * Process a single chunk (extracted from transform for reuse)
-   */
-  async processChunk(chunk) {
-    if (!this.decoder) {
-      throw new Error("Decoder not initialized");
-    }
-    if (this.decoder.state !== "configured") {
-      console.error("[VideoChunkDecoder] Decoder in unexpected state:", this.decoder.state);
-      throw new Error(`Decoder not configured, state: ${this.decoder.state}`);
-    }
-    if (chunk.type === "key") {
-      this.handleKeyFrame(chunk.timestamp);
-    }
-    if (this.decoder.decodeQueueSize >= this.decodeQueueThreshold) {
-      await new Promise((resolve) => {
-        const check = () => {
-          if (!this.decoder || this.decoder.decodeQueueSize < this.decodeQueueThreshold - 1) {
-            resolve();
-          } else {
-            setTimeout(check, 20);
-          }
-        };
-        check();
-      });
-    }
-    try {
-      this.decode(chunk);
-    } catch (error) {
-      console.error(`[VideoChunkDecoder] decode error:`, error);
-      throw error;
-    }
-  }
-  // Override handleOutput to attach GOP metadata
-  handleOutput(frame) {
-    const wrappedFrame = {
-      frame,
-      gopSerial: this.currentGopSerial,
-      isKeyframe: this.isCurrentFrameKeyframe,
-      timestamp: frame.timestamp
-    };
-    this.isCurrentFrameKeyframe = false;
-    super.handleOutput(wrappedFrame);
-  }
-  // Implement abstract methods
-  async isConfigSupported(config) {
-    const result = await VideoDecoder.isConfigSupported({
-      codec: config.codec,
-      codedWidth: config.width,
-      codedHeight: config.height
-    });
-    return { supported: result.supported ?? false };
-  }
-  createDecoder(init) {
-    return new VideoDecoder(init);
-  }
-  getDecoderType() {
-    return "Video";
-  }
-  async configureDecoder(config) {
-    if (!this.decoder) return;
-    const decoderConfig = {
-      codec: config.codec,
-      codedWidth: config.width,
-      codedHeight: config.height,
-      hardwareAcceleration: config.hardwareAcceleration || "prefer-hardware",
-      optimizeForLatency: false,
-      ...config.description && { description: config.description },
-      ...config.displayAspectWidth && { displayAspectWidth: config.displayAspectWidth },
-      ...config.displayAspectHeight && { displayAspectHeight: config.displayAspectHeight }
-    };
-    this.decoder.configure(decoderConfig);
-  }
-  decode(chunk) {
-    this.decoder?.decode(chunk);
-  }
-  // Override reset to clear GOP data
-  onReset() {
-    this.currentGopSerial = -1;
-    this.isCurrentFrameKeyframe = false;
-  }
-  // GOP management methods
-  handleKeyFrame(timestamp) {
-    this.currentGopSerial = timestamp;
-    this.isCurrentFrameKeyframe = true;
-  }
-  /**
-   * Configure the decoder with codec info (can be called after creation)
-   */
-  async configure(config) {
-    if (this.isReady) {
-      await this.reconfigure(config);
-      return;
-    }
-    this.config = config;
-    await this.initialize();
-  }
-  /**
-   * Process any buffered chunks after configuration
-   */
-  async processBufferedChunks() {
-    if (!this.isReady || this.bufferedChunks.length === 0) {
-      return;
-    }
-    this.isProcessingBuffer = true;
-    const chunks = [...this.bufferedChunks];
-    this.bufferedChunks = [];
-    for (const chunk of chunks) {
-      try {
-        await this.processChunk(chunk);
-      } catch (error) {
-        console.error("[VideoChunkDecoder] Error processing buffered chunk:", error);
-      }
-    }
-    this.isProcessingBuffer = false;
-    if (this.bufferedChunks.length > 0) {
-      await this.processBufferedChunks();
-    }
-  }
-  // Override close to clean up GOP data
-  async close() {
-    this.bufferedChunks = [];
-    this.onReset();
-    await super.close();
-  }
-}
-class AudioChunkDecoder extends BaseDecoder {
-  // Default values
-  static DEFAULT_HIGH_WATER_MARK = 20;
-  static DEFAULT_DECODE_QUEUE_THRESHOLD = 16;
-  // Exposed properties
-  trackId;
-  // Backpressure configuration
-  highWaterMark;
-  decodeQueueThreshold;
-  constructor(trackId, config) {
-    super(config);
-    this.trackId = trackId;
-    this.highWaterMark = config?.backpressure?.highWaterMark ?? AudioChunkDecoder.DEFAULT_HIGH_WATER_MARK;
-    this.decodeQueueThreshold = AudioChunkDecoder.DEFAULT_DECODE_QUEUE_THRESHOLD;
-  }
-  // Computed properties
-  get isConfigured() {
-    return this.isReady;
-  }
-  get state() {
-    return this.decoder?.state || "unconfigured";
-  }
-  /**
-   * Update configuration - can be called before or after initialization
-   */
-  async updateConfig(config) {
-    if (!this.isReady && config.codec) {
-      await this.configure(config);
-      await this.processBufferedChunks();
-      return;
-    }
-  }
-  // Implement abstract methods
-  async isConfigSupported(config) {
-    const result = await AudioDecoder.isConfigSupported({
-      codec: config.codec,
-      sampleRate: config.sampleRate,
-      numberOfChannels: config.numberOfChannels
-    });
-    return { supported: result.supported ?? false };
-  }
-  createDecoder(init) {
-    return new AudioDecoder(init);
-  }
-  getDecoderType() {
-    return "Audio";
-  }
-  async configureDecoder(config) {
-    if (!this.decoder) return;
-    await this.decoder.configure({
-      codec: config.codec,
-      sampleRate: config.sampleRate,
-      numberOfChannels: config.numberOfChannels,
-      ...config.description && { description: config.description }
-    });
-  }
-  decode(chunk) {
-    this.decoder?.decode(chunk);
-  }
-  /**
-   * Configure the decoder with codec info (can be called after creation)
-   */
-  async configure(config) {
-    if (this.isReady) {
-      await this.reconfigure(config);
-      return;
-    }
-    this.config = config;
-    await this.initialize();
-  }
-  /**
-   * Process any buffered chunks after configuration
-   * Note: Audio doesn't buffer in current implementation, but keeping for interface consistency
-   */
-  async processBufferedChunks() {
-  }
-}
-const normalizeDescription = (desc) => {
-  if (!desc) return void 0;
-  if (desc instanceof ArrayBuffer) return desc;
-  const view = desc;
-  return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
-};
-class DecodeWorker {
-  channel;
-  // Map of clipId -> decoder instance
-  videoDecoders = /* @__PURE__ */ new Map();
-  audioDecoders = /* @__PURE__ */ new Map();
-  registeredAudioTracks = /* @__PURE__ */ new Set();
-  deliveredAudioTracks = /* @__PURE__ */ new Set();
-  audioTrackMetadata = /* @__PURE__ */ new Map();
-  /** Maximum number of active decoder pairs allowed at the same time */
-  static MAX_ACTIVE_DECODERS = 8;
-  // Cached default configs merged from orchestrator
-  defaultVideoConfig = {};
-  defaultAudioConfig = {};
-  // Connections to other workers
-  composePorts = /* @__PURE__ */ new Map();
-  audioDownstreamPort = null;
-  demuxPorts = /* @__PURE__ */ new Map();
-  // Connections from demux workers
-  constructor() {
-    this.channel = new WorkerChannel(self, {
-      name: "DecodeWorker",
-      timeout: 3e4
-    });
-    this.setupHandlers();
-  }
-  setupHandlers() {
-    this.channel.registerHandler("configure", this.handleConfigure.bind(this));
-    this.channel.registerHandler("connect", this.handleConnect.bind(this));
-    this.channel.registerHandler("flush", this.handleFlush.bind(this));
-    this.channel.registerHandler("reset", this.handleReset.bind(this));
-    this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
-    this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
-  }
-  /**
-   * Connect handler used by stream pipeline
-   */
-  async handleConnect(payload) {
-    const { port, direction, sessionId } = payload;
-    if (direction === "upstream") {
-      this.demuxPorts.set(sessionId || "default", port);
-      const channel = new WorkerChannel(port, {
-        name: "Demux-Decode",
-        timeout: 3e4
-      });
-      channel.receiveStream((stream, metadata) => {
-        this.handleReceiveStream(stream, {
-          ...metadata,
-          clipStartUs: payload.clipStartUs,
-          clipDurationUs: payload.clipDurationUs
-        });
-      });
-      channel.registerHandler("configure", this.handleConfigure.bind(this));
-    }
-    if (direction === "downstream") {
-      if (payload.streamType === "audio") {
-        this.audioDownstreamPort?.close();
-        this.audioDownstreamPort = port;
-      } else {
-        this.composePorts.set(sessionId || "default", port);
-      }
-    }
-    return { success: true };
-  }
-  /**
-   * Handle configuration message from orchestrator
-   * @param payload.initial - If true, initialize worker and recreate decoder instances; otherwise just update config
-   */
-  async handleConfigure(payload) {
-    const {
-      sessionId,
-      streamType,
-      codec,
-      width,
-      height,
-      sampleRate,
-      numberOfChannels,
-      description
-    } = payload;
-    if (sessionId && streamType) {
-      try {
-        if (streamType === "video") {
-          const decoder = this.videoDecoders.get(sessionId);
-          if (decoder) {
-            await decoder.updateConfig({
-              codec,
-              width,
-              height,
-              description: normalizeDescription(description)
-            });
-          }
-        } else if (streamType === "audio") {
-          const decoder = this.audioDecoders.get(sessionId);
-          if (decoder) {
-            await decoder.updateConfig({
-              codec,
-              sampleRate,
-              numberOfChannels,
-              description: normalizeDescription(description)
-            });
-          }
-        }
-      } catch (error) {
-        console.error("[DecodeWorker] Failed to configure decoder:", error);
-        throw {
-          code: "CODEC_CONFIG_ERROR",
-          message: error.message
-        };
-      }
-      return { success: true };
-    }
-    const { config } = payload;
-    if (!config) {
-      return { success: true };
-    }
-    this.channel.state = WorkerState.Ready;
-    if (config.video) {
-      Object.assign(this.defaultVideoConfig, config.video);
-    }
-    if (config.audio) {
-      Object.assign(this.defaultAudioConfig, config.audio);
-    }
-    if (config.video) {
-      for (const dec of this.videoDecoders.values()) {
-        await dec.updateConfig(config.video);
-      }
-    }
-    if (config.audio) {
-      for (const dec of this.audioDecoders.values()) {
-        await dec.updateConfig(config.audio);
-      }
-    }
-    return { success: true };
-  }
-  async handleReceiveStream(stream, metadata) {
-    const sessionId = metadata?.sessionId || "default";
-    const streamType = metadata?.streamType;
-    if (streamType === "video") {
-      const decoder = await this.getOrCreateDecoder("video", sessionId, metadata);
-      const transform = decoder.createStream();
-      const composePort = this.composePorts.get(sessionId);
-      if (composePort) {
-        const channel = new WorkerChannel(composePort, {
-          name: "Decode-Compose",
-          timeout: 3e4
-        });
-        channel.sendStream(transform.readable, {
-          streamType: "video",
-          sessionId
-        });
-        stream.pipeTo(transform.writable).catch(
-          (error) => console.error("[DecodeWorker] Video stream pipe error:", sessionId, error)
-        );
-      }
-    } else if (streamType === "audio") {
-      const decoder = await this.getOrCreateDecoder("audio", sessionId, metadata);
-      const transform = decoder.createStream();
-      stream.pipeTo(transform.writable).catch((error) => {
-        console.error("[DecodeWorker] Audio stream pipe error:", error);
-      });
-      const trackId = metadata?.trackId ?? sessionId;
-      await this.registerAudioTrack(trackId, sessionId, metadata);
-      this.channel.sendStream(transform.readable, {
-        streamType: "audio",
-        sessionId,
-        trackId,
-        clipStartUs: metadata?.clipStartUs ?? 0,
-        clipDurationUs: metadata?.clipDurationUs ?? 0
-      });
-      this.deliveredAudioTracks.add(trackId);
-    }
-  }
-  /**
-   * Flush decoders
-   */
-  async handleFlush(payload) {
-    try {
-      if (!payload?.type || payload.type === "video") {
-        for (const dec of this.videoDecoders.values()) {
-          await dec.flush();
-        }
-      }
-      if (!payload?.type || payload.type === "audio") {
-        for (const dec of this.audioDecoders.values()) {
-          await dec.flush();
-        }
-      }
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "FLUSH_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Reset decoders
-   */
-  async handleReset(payload) {
-    try {
-      if (!payload?.type || payload.type === "video") {
-        for (const dec of this.videoDecoders.values()) {
-          await dec.reset();
-        }
-      }
-      if (!payload?.type || payload.type === "audio") {
-        for (const dec of this.audioDecoders.values()) {
-          await dec.reset();
-        }
-      }
-      this.channel.notify("reset_complete", {
-        type: payload?.type || "all"
-      });
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "RESET_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Get decoder statistics
-   */
-  async handleGetStats() {
-    const stats = {};
-    if (this.videoDecoders.size) {
-      stats.video = Array.from(this.videoDecoders.entries()).map(([clipId, dec]) => ({
-        clipId,
-        configured: dec.isConfigured,
-        queueSize: dec.queueSize,
-        state: dec.state
-      }));
-    }
-    if (this.audioDecoders.size) {
-      stats.audio = Array.from(this.audioDecoders.entries()).map(([clipId, dec]) => ({
-        clipId,
-        configured: dec.isConfigured,
-        queueSize: dec.queueSize,
-        state: dec.state
-      }));
-    }
-    return stats;
-  }
-  /**
-   * Dispose worker and cleanup resources
-   */
-  async handleDispose() {
-    for (const dec of this.videoDecoders.values()) {
-      await dec.close();
-    }
-    for (const dec of this.audioDecoders.values()) {
-      await dec.close();
-    }
-    this.videoDecoders.clear();
-    this.audioDecoders.clear();
-    for (const port of this.composePorts.values()) {
-      port.close();
-    }
-    this.composePorts.clear();
-    if (this.audioDownstreamPort) {
-      this.audioDownstreamPort.close();
-      this.audioDownstreamPort = null;
-    }
-    this.registeredAudioTracks.clear();
-    this.deliveredAudioTracks.clear();
-    this.audioTrackMetadata.clear();
-    for (const port of this.demuxPorts.values()) {
-      port.close();
-    }
-    this.demuxPorts.clear();
-    this.channel.state = WorkerState.Disposed;
-    return { success: true };
-  }
-  /**
-   * Get existing decoder for clip or create a new one (with LRU eviction)
-   */
-  async getOrCreateDecoder(kind, clipId, metadata) {
-    if (kind === "video") {
-      let decoder = this.videoDecoders.get(clipId);
-      if (!decoder) {
-        decoder = new VideoChunkDecoder(
-          clipId,
-          metadata ? {
-            ...this.defaultVideoConfig,
-            codec: metadata.codec,
-            width: metadata.width,
-            height: metadata.height,
-            description: normalizeDescription(metadata.description)
-          } : void 0
-        );
-        this.evictIfNeeded("video");
-        this.videoDecoders.set(clipId, decoder);
-      }
-      this.videoDecoders.delete(clipId);
-      this.videoDecoders.set(clipId, decoder);
-      return decoder;
-    } else {
-      let decoder = this.audioDecoders.get(clipId);
-      if (!decoder) {
-        decoder = new AudioChunkDecoder(
-          clipId,
-          metadata ? {
-            ...this.defaultAudioConfig,
-            codec: metadata.codec,
-            sampleRate: metadata.sampleRate,
-            numberOfChannels: metadata.numberOfChannels,
-            description: normalizeDescription(metadata.description)
-          } : void 0
-        );
-        this.evictIfNeeded("audio");
-        this.audioDecoders.set(clipId, decoder);
-      }
-      this.audioDecoders.delete(clipId);
-      this.audioDecoders.set(clipId, decoder);
-      return decoder;
-    }
-  }
-  /**
-   * Evict least-recently-used decoder if we exceed MAX_ACTIVE_DECODERS.
-   */
-  evictIfNeeded(kind) {
-    const map = kind === "video" ? this.videoDecoders : this.audioDecoders;
-    if (map.size < DecodeWorker.MAX_ACTIVE_DECODERS) return;
-    const [lrucId, lruDecoder] = map.entries().next().value;
-    lruDecoder.close().catch(() => void 0);
-    map.delete(lrucId);
-  }
-  async registerAudioTrack(trackId, clipId, metadata) {
-    const record = {
-      clipId,
-      config: this.extractTrackConfig(metadata?.runtimeConfig),
-      sampleRate: metadata?.sampleRate,
-      numberOfChannels: metadata?.numberOfChannels,
-      type: metadata?.trackType ?? "other"
-    };
-    this.audioTrackMetadata.set(trackId, record);
-    if (this.registeredAudioTracks.has(trackId)) {
-      await this.sendAudioTrackUpdate(trackId, record);
-      return;
-    }
-    this.registeredAudioTracks.add(trackId);
-    await this.sendAudioTrackAdd(trackId, record);
-  }
-  // private unregisterAudioTrack(trackId: string): void {
-  //   if (!this.registeredAudioTracks.delete(trackId)) {
-  //     return;
-  //   }
-  //   const record = this.audioTrackMetadata.get(trackId);
-  //   this.audioTrackMetadata.delete(trackId);
-  //   if (!record) {
-  //     return;
-  //   }
-  //   const channel = this.ensureComposeChannel();
-  //   channel
-  //     ?.send(WorkerMessageType.AudioTrackRemove, {
-  //       clipId: record.clipId,
-  //       trackId,
-  //     })
-  //     .catch((error) => {
-  //       console.warn('[DecodeWorker] Failed to notify track removal', error);
-  //     });
-  // }
-  extractTrackConfig(config) {
-    return {
-      startTimeUs: config?.startTimeUs ?? 0,
-      durationUs: config?.durationUs,
-      volume: config?.volume ?? 1,
-      fadeIn: config?.fadeIn,
-      fadeOut: config?.fadeOut,
-      effects: config?.effects ?? [],
-      duckingTag: config?.duckingTag
-    };
-  }
-  async sendAudioTrackAdd(trackId, record) {
-    const channel = this.ensureComposeChannel();
-    if (!channel) {
-      return;
-    }
-    await channel.send(WorkerMessageType.AudioTrackAdd, {
-      clipId: record.clipId,
-      trackId,
-      config: record.config,
-      sampleRate: record.sampleRate,
-      numberOfChannels: record.numberOfChannels,
-      type: record.type
-    });
-  }
-  async sendAudioTrackUpdate(trackId, record) {
-    const channel = this.ensureComposeChannel();
-    if (!channel) {
-      return;
-    }
-    if (!channel) {
-      return;
-    }
-    await channel.send(WorkerMessageType.AudioTrackUpdate, {
-      clipId: record.clipId,
-      trackId,
-      config: record.config,
-      type: record.type
-    });
-  }
-  ensureComposeChannel() {
-    if (!this.audioDownstreamPort) {
-      return null;
-    }
-    return new WorkerChannel(this.audioDownstreamPort, {
-      name: "Decode-AudioCompose",
-      timeout: 3e4
-    });
-  }
-}
-const worker = new DecodeWorker();
-self.addEventListener("beforeunload", () => {
-  worker["handleDispose"]();
-});
-const decode_worker = null;
-export {
-  DecodeWorker,
-  decode_worker as default
-};
-//# sourceMappingURL=decode.worker.js.map