@remotion/web-renderer 4.0.383 → 4.0.385

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/misc.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/misc.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -186,6 +186,29 @@ var promiseWithResolvers = () => {
 var assertNever = (x) => {
   throw new Error(`Unexpected value: ${x}`);
 };
+var setUint24 = (view, byteOffset, value, littleEndian) => {
+  value = value >>> 0;
+  value = value & 16777215;
+  if (littleEndian) {
+    view.setUint8(byteOffset, value & 255);
+    view.setUint8(byteOffset + 1, value >>> 8 & 255);
+    view.setUint8(byteOffset + 2, value >>> 16 & 255);
+  } else {
+    view.setUint8(byteOffset, value >>> 16 & 255);
+    view.setUint8(byteOffset + 1, value >>> 8 & 255);
+    view.setUint8(byteOffset + 2, value & 255);
+  }
+};
+var setInt24 = (view, byteOffset, value, littleEndian) => {
+  value = clamp(value, -8388608, 8388607);
+  if (value < 0) {
+    value = value + 16777216 & 16777215;
+  }
+  setUint24(view, byteOffset, value, littleEndian);
+};
+var clamp = (value, min, max) => {
+  return Math.max(min, Math.min(max, value));
+};
 var UNDETERMINED_LANGUAGE = "und";
 var roundToMultiple = (value, multiple) => {
   return Math.round(value / multiple) * multiple;
@@ -291,7 +314,7 @@ var polyfillSymbolDispose = () => {
   Symbol.dispose ??= Symbol("Symbol.dispose");
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/metadata.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/metadata.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -430,7 +453,7 @@ var validateTrackDisposition = (disposition) => {
   }
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/codec.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/codec.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -640,6 +663,109 @@ var generateAv1CodecConfigurationFromCodecString = (codecString) => {
   const fourthByte = initialPresentationDelayPresent;
   return [firstByte, secondByte, thirdByte, fourthByte];
 };
+var buildAudioCodecString = (codec, numberOfChannels, sampleRate) => {
+  if (codec === "aac") {
+    if (numberOfChannels >= 2 && sampleRate <= 24000) {
+      return "mp4a.40.29";
+    }
+    if (sampleRate <= 24000) {
+      return "mp4a.40.5";
+    }
+    return "mp4a.40.2";
+  } else if (codec === "mp3") {
+    return "mp3";
+  } else if (codec === "opus") {
+    return "opus";
+  } else if (codec === "vorbis") {
+    return "vorbis";
+  } else if (codec === "flac") {
+    return "flac";
+  } else if (PCM_AUDIO_CODECS.includes(codec)) {
+    return codec;
+  }
+  throw new TypeError(`Unhandled codec '${codec}'.`);
+};
+var aacFrequencyTable = [
+  96000,
+  88200,
+  64000,
+  48000,
+  44100,
+  32000,
+  24000,
+  22050,
+  16000,
+  12000,
+  11025,
+  8000,
+  7350
+];
+var aacChannelMap = [-1, 1, 2, 3, 4, 5, 6, 8];
+var parseAacAudioSpecificConfig = (bytes) => {
+  if (!bytes || bytes.byteLength < 2) {
+    throw new TypeError("AAC description must be at least 2 bytes long.");
+  }
+  const bitstream = new Bitstream(bytes);
+  let objectType = bitstream.readBits(5);
+  if (objectType === 31) {
+    objectType = 32 + bitstream.readBits(6);
+  }
+  const frequencyIndex = bitstream.readBits(4);
+  let sampleRate = null;
+  if (frequencyIndex === 15) {
+    sampleRate = bitstream.readBits(24);
+  } else {
+    if (frequencyIndex < aacFrequencyTable.length) {
+      sampleRate = aacFrequencyTable[frequencyIndex];
+    }
+  }
+  const channelConfiguration = bitstream.readBits(4);
+  let numberOfChannels = null;
+  if (channelConfiguration >= 1 && channelConfiguration <= 7) {
+    numberOfChannels = aacChannelMap[channelConfiguration];
+  }
+  return {
+    objectType,
+    frequencyIndex,
+    sampleRate,
+    channelConfiguration,
+    numberOfChannels
+  };
+};
+var buildAacAudioSpecificConfig = (config) => {
+  let frequencyIndex = aacFrequencyTable.indexOf(config.sampleRate);
+  let customSampleRate = null;
+  if (frequencyIndex === -1) {
+    frequencyIndex = 15;
+    customSampleRate = config.sampleRate;
+  }
+  const channelConfiguration = aacChannelMap.indexOf(config.numberOfChannels);
+  if (channelConfiguration === -1) {
+    throw new TypeError(`Unsupported number of channels: ${config.numberOfChannels}`);
+  }
+  let bitCount = 5 + 4 + 4;
+  if (config.objectType >= 32) {
+    bitCount += 6;
+  }
+  if (frequencyIndex === 15) {
+    bitCount += 24;
+  }
+  const byteCount = Math.ceil(bitCount / 8);
+  const bytes = new Uint8Array(byteCount);
+  const bitstream = new Bitstream(bytes);
+  if (config.objectType < 32) {
+    bitstream.writeBits(5, config.objectType);
+  } else {
+    bitstream.writeBits(5, 31);
+    bitstream.writeBits(6, config.objectType - 32);
+  }
+  bitstream.writeBits(4, frequencyIndex);
+  if (frequencyIndex === 15) {
+    bitstream.writeBits(24, customSampleRate);
+  }
+  bitstream.writeBits(4, channelConfiguration);
+  return bytes;
+};
 var OPUS_SAMPLE_RATE = 48000;
 var PCM_CODEC_REGEX = /^pcm-([usf])(\d+)+(be)?$/;
 var parsePcmCodec = (codec) => {
@@ -714,6 +840,22 @@ var getVideoEncoderConfigExtension = (codec) => {
   }
   return {};
 };
+var getAudioEncoderConfigExtension = (codec) => {
+  if (codec === "aac") {
+    return {
+      aac: {
+        format: "aac"
+      }
+    };
+  } else if (codec === "opus") {
+    return {
+      opus: {
+        format: "opus"
+      }
+    };
+  }
+  return {};
+};
 var VALID_VIDEO_CODEC_STRING_PREFIXES = ["avc1", "avc3", "hev1", "hvc1", "vp8", "vp09", "av01"];
 var AVC_CODEC_STRING_REGEX = /^(avc1|avc3)\.[0-9a-fA-F]{6}$/;
 var HEVC_CODEC_STRING_REGEX = /^(hev1|hvc1)\.(?:[ABC]?\d+)\.[0-9a-fA-F]{1,8}\.[LH]\d+(?:\.[0-9a-fA-F]{1,2}){0,6}$/;
@@ -881,7 +1023,7 @@ var validateSubtitleMetadata = (metadata) => {
   }
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/muxer.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/muxer.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -925,7 +1067,7 @@ class Muxer {
   }
 }
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/codec-data.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/codec-data.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -936,6 +1078,7 @@ class Muxer {
 var AvcNalUnitType;
 (function(AvcNalUnitType2) {
   AvcNalUnitType2[AvcNalUnitType2["IDR"] = 5] = "IDR";
+  AvcNalUnitType2[AvcNalUnitType2["SEI"] = 6] = "SEI";
   AvcNalUnitType2[AvcNalUnitType2["SPS"] = 7] = "SPS";
   AvcNalUnitType2[AvcNalUnitType2["PPS"] = 8] = "PPS";
   AvcNalUnitType2[AvcNalUnitType2["SPS_EXT"] = 13] = "SPS_EXT";
@@ -1630,7 +1773,7 @@ var FlacBlockType;
   FlacBlockType2[FlacBlockType2["PICTURE"] = 6] = "PICTURE";
 })(FlacBlockType || (FlacBlockType = {}));
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/custom-coder.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/custom-coder.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -1639,8 +1782,9 @@ var FlacBlockType;
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 var customVideoEncoders = [];
+var customAudioEncoders = [];
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/packet.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/packet.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -1772,7 +1916,60 @@ class EncodedPacket {
   }
 }
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/sample.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/pcm.js
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var toUlaw = (s16) => {
+  const MULAW_MAX = 8191;
+  const MULAW_BIAS = 33;
+  let number = s16;
+  let mask = 4096;
+  let sign = 0;
+  let position = 12;
+  let lsb = 0;
+  if (number < 0) {
+    number = -number;
+    sign = 128;
+  }
+  number += MULAW_BIAS;
+  if (number > MULAW_MAX) {
+    number = MULAW_MAX;
+  }
+  while ((number & mask) !== mask && position >= 5) {
+    mask >>= 1;
+    position--;
+  }
+  lsb = number >> position - 4 & 15;
+  return ~(sign | position - 5 << 4 | lsb) & 255;
+};
+var toAlaw = (s16) => {
+  const ALAW_MAX = 4095;
+  let mask = 2048;
+  let sign = 0;
+  let position = 11;
+  let lsb = 0;
+  let number = s16;
+  if (number < 0) {
+    number = -number;
+    sign = 128;
+  }
+  if (number > ALAW_MAX) {
+    number = ALAW_MAX;
+  }
+  while ((number & mask) !== mask && position >= 5) {
+    mask >>= 1;
+    position--;
+  }
+  lsb = number >> (position === 4 ? 1 : position - 4) & 15;
+  return (sign | position - 4 << 4 | lsb) ^ 85;
+};
+
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/sample.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -1781,6 +1978,31 @@ class EncodedPacket {
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 polyfillSymbolDispose();
+var lastVideoGcErrorLog = -Infinity;
+var lastAudioGcErrorLog = -Infinity;
+var finalizationRegistry = null;
+if (typeof FinalizationRegistry !== "undefined") {
+  finalizationRegistry = new FinalizationRegistry((value) => {
+    const now = Date.now();
+    if (value.type === "video") {
+      if (now - lastVideoGcErrorLog >= 1000) {
+        console.error(`A VideoSample was garbage collected without first being closed. For proper resource management,` + ` make sure to call close() on all your VideoSamples as soon as you're done using them.`);
+        lastVideoGcErrorLog = now;
+      }
+      if (typeof VideoFrame !== "undefined" && value.data instanceof VideoFrame) {
+        value.data.close();
+      }
+    } else {
+      if (now - lastAudioGcErrorLog >= 1000) {
+        console.error(`An AudioSample was garbage collected without first being closed. For proper resource management,` + ` make sure to call close() on all your AudioSamples as soon as you're done using them.`);
+        lastAudioGcErrorLog = now;
+      }
+      if (typeof AudioData !== "undefined" && value.data instanceof AudioData) {
+        value.data.close();
+      }
+    }
+  });
+}
 
 class VideoSample {
   get displayWidth() {
@@ -1800,7 +2022,7 @@ class VideoSample {
   }
   constructor(data, init) {
     this._closed = false;
-    if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+    if (data instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && data instanceof SharedArrayBuffer || ArrayBuffer.isView(data)) {
       if (!init || typeof init !== "object") {
         throw new TypeError("init must be an object.");
       }
@@ -1905,6 +2127,7 @@ class VideoSample {
     } else {
       throw new TypeError("Invalid data type: Must be a BufferSource or CanvasImageSource.");
     }
+    finalizationRegistry?.register(this, { type: "video", data: this._data }, this);
   }
   clone() {
     if (this._closed) {
@@ -1943,6 +2166,7 @@ class VideoSample {
     if (this._closed) {
       return;
     }
+    finalizationRegistry?.unregister(this);
     if (isVideoFrame(this._data)) {
       this._data.close();
     } else {
@@ -2222,7 +2446,465 @@ var validateCropRectangle = (crop, prefix) => {
 };
 var AUDIO_SAMPLE_FORMATS = new Set(["f32", "f32-planar", "s16", "s16-planar", "s32", "s32-planar", "u8", "u8-planar"]);
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-misc.js
+class AudioSample {
+  get microsecondTimestamp() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.timestamp);
+  }
+  get microsecondDuration() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.duration);
+  }
+  constructor(init) {
+    this._closed = false;
+    if (isAudioData(init)) {
+      if (init.format === null) {
+        throw new TypeError("AudioData with null format is not supported.");
+      }
+      this._data = init;
+      this.format = init.format;
+      this.sampleRate = init.sampleRate;
+      this.numberOfFrames = init.numberOfFrames;
+      this.numberOfChannels = init.numberOfChannels;
+      this.timestamp = init.timestamp / 1e6;
+      this.duration = init.numberOfFrames / init.sampleRate;
+    } else {
+      if (!init || typeof init !== "object") {
+        throw new TypeError("Invalid AudioDataInit: must be an object.");
+      }
+      if (!AUDIO_SAMPLE_FORMATS.has(init.format)) {
+        throw new TypeError("Invalid AudioDataInit: invalid format.");
+      }
+      if (!Number.isFinite(init.sampleRate) || init.sampleRate <= 0) {
+        throw new TypeError("Invalid AudioDataInit: sampleRate must be > 0.");
+      }
+      if (!Number.isInteger(init.numberOfChannels) || init.numberOfChannels === 0) {
+        throw new TypeError("Invalid AudioDataInit: numberOfChannels must be an integer > 0.");
+      }
+      if (!Number.isFinite(init?.timestamp)) {
+        throw new TypeError("init.timestamp must be a number.");
+      }
+      const numberOfFrames = init.data.byteLength / (getBytesPerSample(init.format) * init.numberOfChannels);
+      if (!Number.isInteger(numberOfFrames)) {
+        throw new TypeError("Invalid AudioDataInit: data size is not a multiple of frame size.");
+      }
+      this.format = init.format;
+      this.sampleRate = init.sampleRate;
+      this.numberOfFrames = numberOfFrames;
+      this.numberOfChannels = init.numberOfChannels;
+      this.timestamp = init.timestamp;
+      this.duration = numberOfFrames / init.sampleRate;
+      let dataBuffer;
+      if (init.data instanceof ArrayBuffer) {
+        dataBuffer = new Uint8Array(init.data);
+      } else if (ArrayBuffer.isView(init.data)) {
+        dataBuffer = new Uint8Array(init.data.buffer, init.data.byteOffset, init.data.byteLength);
+      } else {
+        throw new TypeError("Invalid AudioDataInit: data is not a BufferSource.");
+      }
+      const expectedSize = this.numberOfFrames * this.numberOfChannels * getBytesPerSample(this.format);
+      if (dataBuffer.byteLength < expectedSize) {
+        throw new TypeError("Invalid AudioDataInit: insufficient data size.");
+      }
+      this._data = dataBuffer;
+    }
+    finalizationRegistry?.register(this, { type: "audio", data: this._data }, this);
+  }
+  allocationSize(options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("options must be an object.");
+    }
+    if (!Number.isInteger(options.planeIndex) || options.planeIndex < 0) {
+      throw new TypeError("planeIndex must be a non-negative integer.");
+    }
+    if (options.format !== undefined && !AUDIO_SAMPLE_FORMATS.has(options.format)) {
+      throw new TypeError("Invalid format.");
+    }
+    if (options.frameOffset !== undefined && (!Number.isInteger(options.frameOffset) || options.frameOffset < 0)) {
+      throw new TypeError("frameOffset must be a non-negative integer.");
+    }
+    if (options.frameCount !== undefined && (!Number.isInteger(options.frameCount) || options.frameCount < 0)) {
+      throw new TypeError("frameCount must be a non-negative integer.");
+    }
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    const destFormat = options.format ?? this.format;
+    const frameOffset = options.frameOffset ?? 0;
+    if (frameOffset >= this.numberOfFrames) {
+      throw new RangeError("frameOffset out of range");
+    }
+    const copyFrameCount = options.frameCount !== undefined ? options.frameCount : this.numberOfFrames - frameOffset;
+    if (copyFrameCount > this.numberOfFrames - frameOffset) {
+      throw new RangeError("frameCount out of range");
+    }
+    const bytesPerSample = getBytesPerSample(destFormat);
+    const isPlanar = formatIsPlanar(destFormat);
+    if (isPlanar && options.planeIndex >= this.numberOfChannels) {
+      throw new RangeError("planeIndex out of range");
+    }
+    if (!isPlanar && options.planeIndex !== 0) {
+      throw new RangeError("planeIndex out of range");
+    }
+    const elementCount = isPlanar ? copyFrameCount : copyFrameCount * this.numberOfChannels;
+    return elementCount * bytesPerSample;
+  }
+  copyTo(destination, options) {
+    if (!isAllowSharedBufferSource(destination)) {
+      throw new TypeError("destination must be an ArrayBuffer or an ArrayBuffer view.");
+    }
+    if (!options || typeof options !== "object") {
+      throw new TypeError("options must be an object.");
+    }
+    if (!Number.isInteger(options.planeIndex) || options.planeIndex < 0) {
+      throw new TypeError("planeIndex must be a non-negative integer.");
+    }
+    if (options.format !== undefined && !AUDIO_SAMPLE_FORMATS.has(options.format)) {
+      throw new TypeError("Invalid format.");
+    }
+    if (options.frameOffset !== undefined && (!Number.isInteger(options.frameOffset) || options.frameOffset < 0)) {
+      throw new TypeError("frameOffset must be a non-negative integer.");
+    }
+    if (options.frameCount !== undefined && (!Number.isInteger(options.frameCount) || options.frameCount < 0)) {
+      throw new TypeError("frameCount must be a non-negative integer.");
+    }
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    const { planeIndex, format, frameCount: optFrameCount, frameOffset: optFrameOffset } = options;
+    const destFormat = format ?? this.format;
+    if (!destFormat)
+      throw new Error("Destination format not determined");
+    const numFrames = this.numberOfFrames;
+    const numChannels = this.numberOfChannels;
+    const frameOffset = optFrameOffset ?? 0;
+    if (frameOffset >= numFrames) {
+      throw new RangeError("frameOffset out of range");
+    }
+    const copyFrameCount = optFrameCount !== undefined ? optFrameCount : numFrames - frameOffset;
+    if (copyFrameCount > numFrames - frameOffset) {
+      throw new RangeError("frameCount out of range");
+    }
+    const destBytesPerSample = getBytesPerSample(destFormat);
+    const destIsPlanar = formatIsPlanar(destFormat);
+    if (destIsPlanar && planeIndex >= numChannels) {
+      throw new RangeError("planeIndex out of range");
+    }
+    if (!destIsPlanar && planeIndex !== 0) {
+      throw new RangeError("planeIndex out of range");
+    }
+    const destElementCount = destIsPlanar ? copyFrameCount : copyFrameCount * numChannels;
+    const requiredSize = destElementCount * destBytesPerSample;
+    if (destination.byteLength < requiredSize) {
+      throw new RangeError("Destination buffer is too small");
+    }
+    const destView = toDataView(destination);
+    const writeFn = getWriteFunction(destFormat);
+    if (isAudioData(this._data)) {
+      if (destIsPlanar) {
+        if (destFormat === "f32-planar") {
+          this._data.copyTo(destination, {
+            planeIndex,
+            frameOffset,
+            frameCount: copyFrameCount,
+            format: "f32-planar"
+          });
+        } else {
+          const tempBuffer = new ArrayBuffer(copyFrameCount * 4);
+          const tempArray = new Float32Array(tempBuffer);
+          this._data.copyTo(tempArray, {
+            planeIndex,
+            frameOffset,
+            frameCount: copyFrameCount,
+            format: "f32-planar"
+          });
+          const tempView = new DataView(tempBuffer);
+          for (let i = 0;i < copyFrameCount; i++) {
+            const destOffset = i * destBytesPerSample;
+            const sample = tempView.getFloat32(i * 4, true);
+            writeFn(destView, destOffset, sample);
+          }
+        }
+      } else {
+        const numCh = numChannels;
+        const temp = new Float32Array(copyFrameCount);
+        for (let ch = 0;ch < numCh; ch++) {
+          this._data.copyTo(temp, {
+            planeIndex: ch,
+            frameOffset,
+            frameCount: copyFrameCount,
+            format: "f32-planar"
+          });
+          for (let i = 0;i < copyFrameCount; i++) {
+            const destIndex = i * numCh + ch;
+            const destOffset = destIndex * destBytesPerSample;
+            writeFn(destView, destOffset, temp[i]);
+          }
+        }
+      }
+    } else {
+      const uint8Data = this._data;
+      const srcView = toDataView(uint8Data);
+      const srcFormat = this.format;
+      const readFn = getReadFunction(srcFormat);
+      const srcBytesPerSample = getBytesPerSample(srcFormat);
+      const srcIsPlanar = formatIsPlanar(srcFormat);
+      for (let i = 0;i < copyFrameCount; i++) {
+        if (destIsPlanar) {
+          const destOffset = i * destBytesPerSample;
+          let srcOffset;
+          if (srcIsPlanar) {
+            srcOffset = (planeIndex * numFrames + (i + frameOffset)) * srcBytesPerSample;
+          } else {
+            srcOffset = ((i + frameOffset) * numChannels + planeIndex) * srcBytesPerSample;
+          }
+          const normalized = readFn(srcView, srcOffset);
+          writeFn(destView, destOffset, normalized);
+        } else {
+          for (let ch = 0;ch < numChannels; ch++) {
+            const destIndex = i * numChannels + ch;
+            const destOffset = destIndex * destBytesPerSample;
+            let srcOffset;
+            if (srcIsPlanar) {
+              srcOffset = (ch * numFrames + (i + frameOffset)) * srcBytesPerSample;
+            } else {
+              srcOffset = ((i + frameOffset) * numChannels + ch) * srcBytesPerSample;
+            }
+            const normalized = readFn(srcView, srcOffset);
+            writeFn(destView, destOffset, normalized);
+          }
+        }
+      }
+    }
+  }
+  clone() {
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    if (isAudioData(this._data)) {
+      const sample = new AudioSample(this._data.clone());
+      sample.setTimestamp(this.timestamp);
+      return sample;
+    } else {
+      return new AudioSample({
+        format: this.format,
+        sampleRate: this.sampleRate,
+        numberOfFrames: this.numberOfFrames,
+        numberOfChannels: this.numberOfChannels,
+        timestamp: this.timestamp,
+        data: this._data
+      });
+    }
+  }
+  close() {
+    if (this._closed) {
+      return;
+    }
+    finalizationRegistry?.unregister(this);
+    if (isAudioData(this._data)) {
+      this._data.close();
+    } else {
+      this._data = new Uint8Array(0);
+    }
+    this._closed = true;
+  }
+  toAudioData() {
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    if (isAudioData(this._data)) {
+      if (this._data.timestamp === this.microsecondTimestamp) {
+        return this._data.clone();
+      } else {
+        if (formatIsPlanar(this.format)) {
+          const size = this.allocationSize({ planeIndex: 0, format: this.format });
+          const data = new ArrayBuffer(size * this.numberOfChannels);
+          for (let i = 0;i < this.numberOfChannels; i++) {
+            this.copyTo(new Uint8Array(data, i * size, size), { planeIndex: i, format: this.format });
+          }
+          return new AudioData({
+            format: this.format,
+            sampleRate: this.sampleRate,
+            numberOfFrames: this.numberOfFrames,
+            numberOfChannels: this.numberOfChannels,
+            timestamp: this.microsecondTimestamp,
+            data
+          });
+        } else {
+          const data = new ArrayBuffer(this.allocationSize({ planeIndex: 0, format: this.format }));
+          this.copyTo(data, { planeIndex: 0, format: this.format });
+          return new AudioData({
+            format: this.format,
+            sampleRate: this.sampleRate,
+            numberOfFrames: this.numberOfFrames,
+            numberOfChannels: this.numberOfChannels,
+            timestamp: this.microsecondTimestamp,
+            data
+          });
+        }
+      }
+    } else {
+      return new AudioData({
+        format: this.format,
+        sampleRate: this.sampleRate,
+        numberOfFrames: this.numberOfFrames,
+        numberOfChannels: this.numberOfChannels,
+        timestamp: this.microsecondTimestamp,
+        data: this._data.buffer instanceof ArrayBuffer ? this._data.buffer : this._data.slice()
+      });
+    }
+  }
+  toAudioBuffer() {
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    const audioBuffer = new AudioBuffer({
+      numberOfChannels: this.numberOfChannels,
+      length: this.numberOfFrames,
+      sampleRate: this.sampleRate
+    });
+    const dataBytes = new Float32Array(this.allocationSize({ planeIndex: 0, format: "f32-planar" }) / 4);
+    for (let i = 0;i < this.numberOfChannels; i++) {
+      this.copyTo(dataBytes, { planeIndex: i, format: "f32-planar" });
+      audioBuffer.copyToChannel(dataBytes, i);
+    }
+    return audioBuffer;
+  }
+  setTimestamp(newTimestamp) {
+    if (!Number.isFinite(newTimestamp)) {
+      throw new TypeError("newTimestamp must be a number.");
+    }
+    this.timestamp = newTimestamp;
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  static *_fromAudioBuffer(audioBuffer, timestamp) {
+    if (!(audioBuffer instanceof AudioBuffer)) {
+      throw new TypeError("audioBuffer must be an AudioBuffer.");
+    }
+    const MAX_FLOAT_COUNT = 48000 * 5;
+    const numberOfChannels = audioBuffer.numberOfChannels;
+    const sampleRate = audioBuffer.sampleRate;
+    const totalFrames = audioBuffer.length;
+    const maxFramesPerChunk = Math.floor(MAX_FLOAT_COUNT / numberOfChannels);
+    let currentRelativeFrame = 0;
+    let remainingFrames = totalFrames;
+    while (remainingFrames > 0) {
+      const framesToCopy = Math.min(maxFramesPerChunk, remainingFrames);
+      const chunkData = new Float32Array(numberOfChannels * framesToCopy);
+      for (let channel = 0;channel < numberOfChannels; channel++) {
+        audioBuffer.copyFromChannel(chunkData.subarray(channel * framesToCopy, (channel + 1) * framesToCopy), channel, currentRelativeFrame);
+      }
+      yield new AudioSample({
+        format: "f32-planar",
+        sampleRate,
+        numberOfFrames: framesToCopy,
+        numberOfChannels,
+        timestamp: timestamp + currentRelativeFrame / sampleRate,
+        data: chunkData
+      });
+      currentRelativeFrame += framesToCopy;
+      remainingFrames -= framesToCopy;
+    }
+  }
+  static fromAudioBuffer(audioBuffer, timestamp) {
+    if (!(audioBuffer instanceof AudioBuffer)) {
+      throw new TypeError("audioBuffer must be an AudioBuffer.");
+    }
+    const MAX_FLOAT_COUNT = 48000 * 5;
+    const numberOfChannels = audioBuffer.numberOfChannels;
+    const sampleRate = audioBuffer.sampleRate;
+    const totalFrames = audioBuffer.length;
+    const maxFramesPerChunk = Math.floor(MAX_FLOAT_COUNT / numberOfChannels);
+    let currentRelativeFrame = 0;
+    let remainingFrames = totalFrames;
+    const result = [];
+    while (remainingFrames > 0) {
+      const framesToCopy = Math.min(maxFramesPerChunk, remainingFrames);
+      const chunkData = new Float32Array(numberOfChannels * framesToCopy);
+      for (let channel = 0;channel < numberOfChannels; channel++) {
+        audioBuffer.copyFromChannel(chunkData.subarray(channel * framesToCopy, (channel + 1) * framesToCopy), channel, currentRelativeFrame);
+      }
+      const audioSample = new AudioSample({
+        format: "f32-planar",
+        sampleRate,
+        numberOfFrames: framesToCopy,
+        numberOfChannels,
+        timestamp: timestamp + currentRelativeFrame / sampleRate,
+        data: chunkData
+      });
+      result.push(audioSample);
+      currentRelativeFrame += framesToCopy;
+      remainingFrames -= framesToCopy;
+    }
+    return result;
+  }
+}
+var getBytesPerSample = (format) => {
+  switch (format) {
+    case "u8":
+    case "u8-planar":
+      return 1;
+    case "s16":
+    case "s16-planar":
+      return 2;
+    case "s32":
+    case "s32-planar":
+      return 4;
+    case "f32":
+    case "f32-planar":
+      return 4;
+    default:
+      throw new Error("Unknown AudioSampleFormat");
+  }
+};
+var formatIsPlanar = (format) => {
+  switch (format) {
+    case "u8-planar":
+    case "s16-planar":
+    case "s32-planar":
+    case "f32-planar":
+      return true;
+    default:
+      return false;
+  }
+};
+var getReadFunction = (format) => {
+  switch (format) {
+    case "u8":
+    case "u8-planar":
+      return (view, offset) => (view.getUint8(offset) - 128) / 128;
+    case "s16":
+    case "s16-planar":
+      return (view, offset) => view.getInt16(offset, true) / 32768;
+    case "s32":
+    case "s32-planar":
+      return (view, offset) => view.getInt32(offset, true) / 2147483648;
+    case "f32":
+    case "f32-planar":
+      return (view, offset) => view.getFloat32(offset, true);
+  }
+};
+var getWriteFunction = (format) => {
+  switch (format) {
+    case "u8":
+    case "u8-planar":
+      return (view, offset, value) => view.setUint8(offset, clamp((value + 1) * 127.5, 0, 255));
+    case "s16":
+    case "s16-planar":
+      return (view, offset, value) => view.setInt16(offset, clamp(Math.round(value * 32767), -32768, 32767), true);
+    case "s32":
+    case "s32-planar":
+      return (view, offset, value) => view.setInt32(offset, clamp(Math.round(value * 2147483647), -2147483648, 2147483647), true);
+    case "f32":
+    case "f32-planar":
+      return (view, offset, value) => view.setFloat32(offset, value, true);
+  }
+};
+var isAudioData = (x) => {
+  return typeof AudioData !== "undefined" && x instanceof AudioData;
+};
+
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-misc.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -2240,7 +2922,7 @@ var buildIsobmffMimeType = (info) => {
   return string;
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-reader.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-reader.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -2251,7 +2933,7 @@ var buildIsobmffMimeType = (info) => {
 var MIN_BOX_HEADER_SIZE = 8;
 var MAX_BOX_HEADER_SIZE = 16;
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/matroska/ebml.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/matroska/ebml.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -2661,7 +3343,7 @@ var CODEC_STRING_MAP = {
   webvtt: "S_TEXT/WEBVTT"
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/matroska/matroska-misc.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/matroska/matroska-misc.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -2679,7 +3361,7 @@ var buildMatroskaMimeType = (info) => {
   return string;
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/subtitles.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/subtitles.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -2703,7 +3385,7 @@ var formatSubtitleTimestamp = (timestamp) => {
   return hours.toString().padStart(2, "0") + ":" + minutes.toString().padStart(2, "0") + ":" + seconds.toString().padStart(2, "0") + "." + milliseconds.toString().padStart(3, "0");
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-boxes.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-boxes.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -4037,7 +4719,7 @@ var getLanguageCodeInt = (code) => {
   return language;
 };
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/writer.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/writer.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -4165,7 +4847,7 @@ class BufferTargetWriter extends Writer {
 }
 var DEFAULT_CHUNK_SIZE = 2 ** 24;
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/target.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/target.js
 var nodeAlias = (() => ({}));
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
@@ -4191,7 +4873,7 @@ class BufferTarget extends Target {
   }
 }
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-muxer.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/isobmff/isobmff-muxer.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -5018,7 +5700,7 @@ class IsobmffMuxer extends Muxer {
   }
 }
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/matroska/matroska-muxer.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/matroska/matroska-muxer.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -5901,7 +6583,7 @@ ${cue.notes ?? ""}`;
   }
 }
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/output-format.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/output-format.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -6119,7 +6801,7 @@ class WebMOutputFormat extends MkvOutputFormat {
   }
 }
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/encode.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/encode.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -6197,6 +6879,53 @@ var buildVideoEncoderConfig = (options) => {
     ...getVideoEncoderConfigExtension(options.codec)
   };
 };
+var validateAudioEncodingConfig = (config) => {
+  if (!config || typeof config !== "object") {
+    throw new TypeError("Encoding config must be an object.");
+  }
+  if (!AUDIO_CODECS.includes(config.codec)) {
+    throw new TypeError(`Invalid audio codec '${config.codec}'. Must be one of: ${AUDIO_CODECS.join(", ")}.`);
+  }
+  if (config.bitrate === undefined && (!PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
+    throw new TypeError("config.bitrate must be provided for compressed audio codecs.");
+  }
+  if (config.bitrate !== undefined && !(config.bitrate instanceof Quality) && (!Number.isInteger(config.bitrate) || config.bitrate <= 0)) {
+    throw new TypeError("config.bitrate, when provided, must be a positive integer or a quality.");
+  }
+  if (config.onEncodedPacket !== undefined && typeof config.onEncodedPacket !== "function") {
+    throw new TypeError("config.onEncodedChunk, when provided, must be a function.");
+  }
+  if (config.onEncoderConfig !== undefined && typeof config.onEncoderConfig !== "function") {
+    throw new TypeError("config.onEncoderConfig, when provided, must be a function.");
+  }
+  validateAudioEncodingAdditionalOptions(config.codec, config);
+};
+var validateAudioEncodingAdditionalOptions = (codec, options) => {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("Encoding options must be an object.");
+  }
+  if (options.bitrateMode !== undefined && !["constant", "variable"].includes(options.bitrateMode)) {
+    throw new TypeError("bitrateMode, when provided, must be 'constant' or 'variable'.");
+  }
+  if (options.fullCodecString !== undefined && typeof options.fullCodecString !== "string") {
+    throw new TypeError("fullCodecString, when provided, must be a string.");
+  }
+  if (options.fullCodecString !== undefined && inferCodecFromCodecString(options.fullCodecString) !== codec) {
+    throw new TypeError(`fullCodecString, when provided, must be a string that matches the specified codec (${codec}).`);
+  }
+};
+var buildAudioEncoderConfig = (options) => {
+  const resolvedBitrate = options.bitrate instanceof Quality ? options.bitrate._toAudioBitrate(options.codec) : options.bitrate;
+  return {
+    codec: options.fullCodecString ?? buildAudioCodecString(options.codec, options.numberOfChannels, options.sampleRate),
+    numberOfChannels: options.numberOfChannels,
+    sampleRate: options.sampleRate,
+    bitrate: resolvedBitrate,
+    bitrateMode: options.bitrateMode,
+    ...getAudioEncoderConfigExtension(options.codec)
+  };
+};
+
 class Quality {
   constructor(factor) {
     this._factor = factor;
@@ -6267,8 +6996,52 @@ var QUALITY_LOW = /* @__PURE__ */ new Quality(0.6);
 var QUALITY_MEDIUM = /* @__PURE__ */ new Quality(1);
 var QUALITY_HIGH = /* @__PURE__ */ new Quality(2);
 var QUALITY_VERY_HIGH = /* @__PURE__ */ new Quality(4);
+var canEncodeAudio = async (codec, options = {}) => {
+  const { numberOfChannels = 2, sampleRate = 48000, bitrate = 128000, ...restOptions } = options;
+  if (!AUDIO_CODECS.includes(codec)) {
+    return false;
+  }
+  if (!Number.isInteger(numberOfChannels) || numberOfChannels <= 0) {
+    throw new TypeError("numberOfChannels must be a positive integer.");
+  }
+  if (!Number.isInteger(sampleRate) || sampleRate <= 0) {
+    throw new TypeError("sampleRate must be a positive integer.");
+  }
+  if (!(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    throw new TypeError("bitrate must be a positive integer.");
+  }
+  validateAudioEncodingAdditionalOptions(codec, restOptions);
+  let encoderConfig = null;
+  if (customAudioEncoders.length > 0) {
+    encoderConfig ??= buildAudioEncoderConfig({
+      codec,
+      numberOfChannels,
+      sampleRate,
+      bitrate,
+      ...restOptions
+    });
+    if (customAudioEncoders.some((x) => x.supports(codec, encoderConfig))) {
+      return true;
+    }
+  }
+  if (PCM_AUDIO_CODECS.includes(codec)) {
+    return true;
+  }
+  if (typeof AudioEncoder === "undefined") {
+    return false;
+  }
+  encoderConfig ??= buildAudioEncoderConfig({
+    codec,
+    numberOfChannels,
+    sampleRate,
+    bitrate,
+    ...restOptions
+  });
+  const support = await AudioEncoder.isConfigSupported(encoderConfig);
+  return support.supported === true;
+};
 
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/media-source.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/media-source.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -6898,18 +7671,371 @@ class AudioSource extends MediaSource {
     this._codec = codec;
   }
 }
-class SubtitleSource extends MediaSource {
-  constructor(codec) {
-    super();
-    this._connectedTrack = null;
-    if (!SUBTITLE_CODECS.includes(codec)) {
-      throw new TypeError(`Invalid subtitle codec '${codec}'. Must be one of: ${SUBTITLE_CODECS.join(", ")}.`);
-    }
-    this._codec = codec;
+class AudioEncoderWrapper {
+  constructor(source, encodingConfig) {
+    this.source = source;
+    this.encodingConfig = encodingConfig;
+    this.ensureEncoderPromise = null;
+    this.encoderInitialized = false;
+    this.encoder = null;
+    this.muxer = null;
+    this.lastNumberOfChannels = null;
+    this.lastSampleRate = null;
+    this.isPcmEncoder = false;
+    this.outputSampleSize = null;
+    this.writeOutputValue = null;
+    this.customEncoder = null;
+    this.customEncoderCallSerializer = new CallSerializer;
+    this.customEncoderQueueSize = 0;
+    this.lastEndSampleIndex = null;
+    this.error = null;
+    this.errorNeedsNewStack = true;
   }
-}
-
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/output.js
+  async add(audioSample, shouldClose) {
+    try {
+      this.checkForEncoderError();
+      this.source._ensureValidAdd();
+      if (this.lastNumberOfChannels !== null && this.lastSampleRate !== null) {
+        if (audioSample.numberOfChannels !== this.lastNumberOfChannels || audioSample.sampleRate !== this.lastSampleRate) {
+          throw new Error(`Audio parameters must remain constant. Expected ${this.lastNumberOfChannels} channels at` + ` ${this.lastSampleRate} Hz, got ${audioSample.numberOfChannels} channels at` + ` ${audioSample.sampleRate} Hz.`);
+        }
+      } else {
+        this.lastNumberOfChannels = audioSample.numberOfChannels;
+        this.lastSampleRate = audioSample.sampleRate;
+      }
+      if (!this.encoderInitialized) {
+        if (!this.ensureEncoderPromise) {
+          this.ensureEncoder(audioSample);
+        }
+        if (!this.encoderInitialized) {
+          await this.ensureEncoderPromise;
+        }
+      }
+      assert(this.encoderInitialized);
+      {
+        const startSampleIndex = Math.round(audioSample.timestamp * audioSample.sampleRate);
+        const endSampleIndex = Math.round((audioSample.timestamp + audioSample.duration) * audioSample.sampleRate);
+        if (this.lastEndSampleIndex === null) {
+          this.lastEndSampleIndex = endSampleIndex;
+        } else {
+          const sampleDiff = startSampleIndex - this.lastEndSampleIndex;
+          if (sampleDiff >= 64) {
+            const fillSample = new AudioSample({
+              data: new Float32Array(sampleDiff * audioSample.numberOfChannels),
+              format: "f32-planar",
+              sampleRate: audioSample.sampleRate,
+              numberOfChannels: audioSample.numberOfChannels,
+              numberOfFrames: sampleDiff,
+              timestamp: this.lastEndSampleIndex / audioSample.sampleRate
+            });
+            await this.add(fillSample, true);
+          }
+          this.lastEndSampleIndex += audioSample.numberOfFrames;
+        }
+      }
+      if (this.customEncoder) {
+        this.customEncoderQueueSize++;
+        const clonedSample = audioSample.clone();
+        const promise = this.customEncoderCallSerializer.call(() => this.customEncoder.encode(clonedSample)).then(() => this.customEncoderQueueSize--).catch((error) => this.error ??= error).finally(() => {
+          clonedSample.close();
+        });
+        if (this.customEncoderQueueSize >= 4) {
+          await promise;
+        }
+        await this.muxer.mutex.currentPromise;
+      } else if (this.isPcmEncoder) {
+        await this.doPcmEncoding(audioSample, shouldClose);
+      } else {
+        assert(this.encoder);
+        const audioData = audioSample.toAudioData();
+        this.encoder.encode(audioData);
+        audioData.close();
+        if (shouldClose) {
+          audioSample.close();
+        }
+        if (this.encoder.encodeQueueSize >= 4) {
+          await new Promise((resolve) => this.encoder.addEventListener("dequeue", resolve, { once: true }));
+        }
+        await this.muxer.mutex.currentPromise;
+      }
+    } finally {
+      if (shouldClose) {
+        audioSample.close();
+      }
+    }
+  }
+  async doPcmEncoding(audioSample, shouldClose) {
+    assert(this.outputSampleSize);
+    assert(this.writeOutputValue);
+    const { numberOfChannels, numberOfFrames, sampleRate, timestamp } = audioSample;
+    const CHUNK_SIZE = 2048;
+    const outputs = [];
+    for (let frame = 0;frame < numberOfFrames; frame += CHUNK_SIZE) {
+      const frameCount = Math.min(CHUNK_SIZE, audioSample.numberOfFrames - frame);
+      const outputSize = frameCount * numberOfChannels * this.outputSampleSize;
+      const outputBuffer = new ArrayBuffer(outputSize);
+      const outputView = new DataView(outputBuffer);
+      outputs.push({ frameCount, view: outputView });
+    }
+    const allocationSize = audioSample.allocationSize({ planeIndex: 0, format: "f32-planar" });
+    const floats = new Float32Array(allocationSize / Float32Array.BYTES_PER_ELEMENT);
+    for (let i = 0;i < numberOfChannels; i++) {
+      audioSample.copyTo(floats, { planeIndex: i, format: "f32-planar" });
+      for (let j = 0;j < outputs.length; j++) {
+        const { frameCount, view: view2 } = outputs[j];
+        for (let k = 0;k < frameCount; k++) {
+          this.writeOutputValue(view2, (k * numberOfChannels + i) * this.outputSampleSize, floats[j * CHUNK_SIZE + k]);
+        }
+      }
+    }
+    if (shouldClose) {
+      audioSample.close();
+    }
+    const meta = {
+      decoderConfig: {
+        codec: this.encodingConfig.codec,
+        numberOfChannels,
+        sampleRate
+      }
+    };
+    for (let i = 0;i < outputs.length; i++) {
+      const { frameCount, view: view2 } = outputs[i];
+      const outputBuffer = view2.buffer;
+      const startFrame = i * CHUNK_SIZE;
+      const packet = new EncodedPacket(new Uint8Array(outputBuffer), "key", timestamp + startFrame / sampleRate, frameCount / sampleRate);
+      this.encodingConfig.onEncodedPacket?.(packet, meta);
+      await this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta);
+    }
+  }
+  ensureEncoder(audioSample) {
+    const encoderError = new Error;
+    this.ensureEncoderPromise = (async () => {
+      const { numberOfChannels, sampleRate } = audioSample;
+      const encoderConfig = buildAudioEncoderConfig({
+        numberOfChannels,
+        sampleRate,
+        ...this.encodingConfig
+      });
+      this.encodingConfig.onEncoderConfig?.(encoderConfig);
+      const MatchingCustomEncoder = customAudioEncoders.find((x) => x.supports(this.encodingConfig.codec, encoderConfig));
+      if (MatchingCustomEncoder) {
+        this.customEncoder = new MatchingCustomEncoder;
+        this.customEncoder.codec = this.encodingConfig.codec;
+        this.customEncoder.config = encoderConfig;
+        this.customEncoder.onPacket = (packet, meta) => {
+          if (!(packet instanceof EncodedPacket)) {
+            throw new TypeError("The first argument passed to onPacket must be an EncodedPacket.");
+          }
+          if (meta !== undefined && (!meta || typeof meta !== "object")) {
+            throw new TypeError("The second argument passed to onPacket must be an object or undefined.");
+          }
+          this.encodingConfig.onEncodedPacket?.(packet, meta);
+          this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta).catch((error) => {
+            this.error ??= error;
+            this.errorNeedsNewStack = false;
+          });
+        };
+        await this.customEncoder.init();
+      } else if (PCM_AUDIO_CODECS.includes(this.encodingConfig.codec)) {
+        this.initPcmEncoder();
+      } else {
+        if (typeof AudioEncoder === "undefined") {
+          throw new Error("AudioEncoder is not supported by this browser.");
+        }
+        const support = await AudioEncoder.isConfigSupported(encoderConfig);
+        if (!support.supported) {
+          throw new Error(`This specific encoder configuration (${encoderConfig.codec}, ${encoderConfig.bitrate} bps,` + ` ${encoderConfig.numberOfChannels} channels, ${encoderConfig.sampleRate} Hz) is not` + ` supported by this browser. Consider using another codec or changing your audio parameters.`);
+        }
+        this.encoder = new AudioEncoder({
+          output: (chunk, meta) => {
+            if (this.encodingConfig.codec === "aac" && meta?.decoderConfig) {
+              let needsDescriptionOverwrite = false;
+              if (!meta.decoderConfig.description || meta.decoderConfig.description.byteLength < 2) {
+                needsDescriptionOverwrite = true;
+              } else {
+                const audioSpecificConfig = parseAacAudioSpecificConfig(toUint8Array(meta.decoderConfig.description));
+                needsDescriptionOverwrite = audioSpecificConfig.objectType === 0;
+              }
+              if (needsDescriptionOverwrite) {
+                const objectType = Number(last(encoderConfig.codec.split(".")));
+                meta.decoderConfig.description = buildAacAudioSpecificConfig({
+                  objectType,
+                  numberOfChannels: meta.decoderConfig.numberOfChannels,
+                  sampleRate: meta.decoderConfig.sampleRate
+                });
+              }
+            }
+            const packet = EncodedPacket.fromEncodedChunk(chunk);
+            this.encodingConfig.onEncodedPacket?.(packet, meta);
+            this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta).catch((error) => {
+              this.error ??= error;
+              this.errorNeedsNewStack = false;
+            });
+          },
+          error: (error) => {
+            error.stack = encoderError.stack;
+            this.error ??= error;
+          }
+        });
+        this.encoder.configure(encoderConfig);
+      }
+      assert(this.source._connectedTrack);
+      this.muxer = this.source._connectedTrack.output._muxer;
+      this.encoderInitialized = true;
+    })();
+  }
+  initPcmEncoder() {
+    this.isPcmEncoder = true;
+    const codec = this.encodingConfig.codec;
+    const { dataType, sampleSize, littleEndian } = parsePcmCodec(codec);
+    this.outputSampleSize = sampleSize;
+    switch (sampleSize) {
+      case 1:
+        {
+          if (dataType === "unsigned") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setUint8(byteOffset, clamp((value + 1) * 127.5, 0, 255));
+          } else if (dataType === "signed") {
+            this.writeOutputValue = (view2, byteOffset, value) => {
+              view2.setInt8(byteOffset, clamp(Math.round(value * 128), -128, 127));
+            };
+          } else if (dataType === "ulaw") {
+            this.writeOutputValue = (view2, byteOffset, value) => {
+              const int16 = clamp(Math.floor(value * 32767), -32768, 32767);
+              view2.setUint8(byteOffset, toUlaw(int16));
+            };
+          } else if (dataType === "alaw") {
+            this.writeOutputValue = (view2, byteOffset, value) => {
+              const int16 = clamp(Math.floor(value * 32767), -32768, 32767);
+              view2.setUint8(byteOffset, toAlaw(int16));
+            };
+          } else {
+            assert(false);
+          }
+        }
+        ;
+        break;
+      case 2:
+        {
+          if (dataType === "unsigned") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setUint16(byteOffset, clamp((value + 1) * 32767.5, 0, 65535), littleEndian);
+          } else if (dataType === "signed") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setInt16(byteOffset, clamp(Math.round(value * 32767), -32768, 32767), littleEndian);
+          } else {
+            assert(false);
+          }
+        }
+        ;
+        break;
+      case 3:
+        {
+          if (dataType === "unsigned") {
+            this.writeOutputValue = (view2, byteOffset, value) => setUint24(view2, byteOffset, clamp((value + 1) * 8388607.5, 0, 16777215), littleEndian);
+          } else if (dataType === "signed") {
+            this.writeOutputValue = (view2, byteOffset, value) => setInt24(view2, byteOffset, clamp(Math.round(value * 8388607), -8388608, 8388607), littleEndian);
+          } else {
+            assert(false);
+          }
+        }
+        ;
+        break;
+      case 4:
+        {
+          if (dataType === "unsigned") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setUint32(byteOffset, clamp((value + 1) * 2147483647.5, 0, 4294967295), littleEndian);
+          } else if (dataType === "signed") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setInt32(byteOffset, clamp(Math.round(value * 2147483647), -2147483648, 2147483647), littleEndian);
+          } else if (dataType === "float") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setFloat32(byteOffset, value, littleEndian);
+          } else {
+            assert(false);
+          }
+        }
+        ;
+        break;
+      case 8:
+        {
+          if (dataType === "float") {
+            this.writeOutputValue = (view2, byteOffset, value) => view2.setFloat64(byteOffset, value, littleEndian);
+          } else {
+            assert(false);
+          }
+        }
+        ;
+        break;
+      default:
+        {
+          assertNever(sampleSize);
+          assert(false);
+        }
+        ;
+    }
+  }
+  async flushAndClose(forceClose) {
+    if (!forceClose)
+      this.checkForEncoderError();
+    if (this.customEncoder) {
+      if (!forceClose) {
+        this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+      }
+      await this.customEncoderCallSerializer.call(() => this.customEncoder.close());
+    } else if (this.encoder) {
+      if (!forceClose) {
+        await this.encoder.flush();
+      }
+      if (this.encoder.state !== "closed") {
+        this.encoder.close();
+      }
+    }
+    if (!forceClose)
+      this.checkForEncoderError();
+  }
+  getQueueSize() {
+    if (this.customEncoder) {
+      return this.customEncoderQueueSize;
+    } else if (this.isPcmEncoder) {
+      return 0;
+    } else {
+      return this.encoder?.encodeQueueSize ?? 0;
+    }
+  }
+  checkForEncoderError() {
+    if (this.error) {
+      if (this.errorNeedsNewStack) {
+        this.error.stack = new Error().stack;
+      }
+      throw this.error;
+    }
+  }
+}
+
+class AudioSampleSource extends AudioSource {
+  constructor(encodingConfig) {
+    validateAudioEncodingConfig(encodingConfig);
+    super(encodingConfig.codec);
+    this._encoder = new AudioEncoderWrapper(this, encodingConfig);
+  }
+  add(audioSample) {
+    if (!(audioSample instanceof AudioSample)) {
+      throw new TypeError("audioSample must be an AudioSample.");
+    }
+    return this._encoder.add(audioSample, false);
+  }
+  _flushAndClose(forceClose) {
+    return this._encoder.flushAndClose(forceClose);
+  }
+}
+class SubtitleSource extends MediaSource {
+  constructor(codec) {
+    super();
+    this._connectedTrack = null;
+    if (!SUBTITLE_CODECS.includes(codec)) {
+      throw new TypeError(`Invalid subtitle codec '${codec}'. Must be one of: ${SUBTITLE_CODECS.join(", ")}.`);
+    }
+    this._codec = codec;
+  }
+}
+
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/output.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -7123,7 +8249,7 @@ class Output {
     })();
   }
 }
-// ../../node_modules/.bun/mediabunny@1.25.3/node_modules/mediabunny/dist/modules/src/index.js
+// ../../node_modules/.bun/mediabunny@1.25.8/node_modules/mediabunny/dist/modules/src/index.js
 /*!
  * Copyright (c) 2025-present, Vanilagy and contributors
  *
@@ -7135,6 +8261,25 @@ class Output {
 // src/render-media-on-web.tsx
 import { Internals as Internals3 } from "remotion";
 
+// src/add-sample.ts
+var addVideoSampleAndCloseFrame = async (frameToEncode, videoSampleSource) => {
+  const sample = new VideoSample(frameToEncode);
+  try {
+    await videoSampleSource.add(sample);
+  } finally {
+    sample.close();
+    frameToEncode.close();
+  }
+};
+var addAudioSample = async (audio, audioSampleSource) => {
+  const sample = new AudioSample(audio);
+  try {
+    await audioSampleSource.add(sample);
+  } finally {
+    sample.close();
+  }
+};
+
 // src/artifact.ts
 import { NoReactInternals } from "remotion/no-react";
 var onlyArtifact = async ({
@@ -7172,34 +8317,72 @@ var onlyArtifact = async ({
   }
   return result.filter(NoReactInternals.truthy);
 };
-var handleArtifacts = ({
-  ref,
-  onArtifact
-}) => {
+var handleArtifacts = () => {
   const previousArtifacts = [];
   const handle = async ({
     imageData,
-    frame
+    frame,
+    assets: artifactAssets,
+    onArtifact
   }) => {
-    const artifactAssets = ref.current.collectAssets();
-    if (onArtifact) {
-      const artifacts = await onlyArtifact({
-        assets: artifactAssets,
-        frameBuffer: imageData
-      });
-      for (const artifact of artifacts) {
-        const previousArtifact = previousArtifacts.find((a) => a.filename === artifact.filename);
-        if (previousArtifact) {
-          throw new Error(`An artifact with output "${artifact.filename}" was already registered at frame ${previousArtifact.frame}, but now registered again at frame ${frame}. Artifacts must have unique names. https://remotion.dev/docs/artifacts`);
-        }
-        onArtifact(artifact);
-        previousArtifacts.push({ frame, filename: artifact.filename });
+    const artifacts = await onlyArtifact({
+      assets: artifactAssets,
+      frameBuffer: imageData
+    });
+    for (const artifact of artifacts) {
+      const previousArtifact = previousArtifacts.find((a) => a.filename === artifact.filename);
+      if (previousArtifact) {
+        throw new Error(`An artifact with output "${artifact.filename}" was already registered at frame ${previousArtifact.frame}, but now registered again at frame ${frame}. Artifacts must have unique names. https://remotion.dev/docs/artifacts`);
       }
+      onArtifact(artifact);
+      previousArtifacts.push({ frame, filename: artifact.filename });
     }
   };
   return { handle };
 };
 
+// src/audio.ts
+var TARGET_NUMBER_OF_CHANNELS = 2;
+var TARGET_SAMPLE_RATE = 48000;
+function mixAudio(waves, length) {
+  if (waves.length === 1) {
+    return waves[0];
+  }
+  const mixed = new Int16Array(length);
+  for (let i = 0;i < length; i++) {
+    const sum = waves.reduce((acc, wave2) => {
+      return acc + (wave2[i] ?? 0);
+    }, 0);
+    mixed[i] = Math.max(-32768, Math.min(32767, sum));
+  }
+  return mixed;
+}
+var onlyInlineAudio = ({
+  assets,
+  fps,
+  frame
+}) => {
+  const inlineAudio = assets.filter((asset) => asset.type === "inline-audio");
+  if (inlineAudio.length === 0) {
+    return null;
+  }
+  const expectedLength = Math.round(TARGET_NUMBER_OF_CHANNELS * TARGET_SAMPLE_RATE / fps);
+  for (const asset of inlineAudio) {
+    if (asset.toneFrequency !== 1) {
+      throw new Error("Setting the toneFrequency is not supported yet in web rendering.");
+    }
+  }
+  const mixedAudio = mixAudio(inlineAudio.map((asset) => asset.audio), expectedLength);
+  return new AudioData({
+    data: mixedAudio,
+    format: "s16",
+    numberOfChannels: TARGET_NUMBER_OF_CHANNELS,
+    numberOfFrames: expectedLength / TARGET_NUMBER_OF_CHANNELS,
+    sampleRate: TARGET_SAMPLE_RATE,
+    timestamp: frame / fps * 1e6
+  });
+};
+
 // src/create-scaffold.tsx
 import { createRef } from "react";
 import { flushSync as flushSync2 } from "react-dom";
@@ -7399,6 +8582,25 @@ var getRealFrameRange = (durationInFrames, frameRange) => {
   return frameRange;
 };
 
+// src/get-audio-encoding-config.ts
+var getDefaultAudioEncodingConfig = async () => {
+  const preferredDefaultAudioEncodingConfig = {
+    codec: "aac",
+    bitrate: QUALITY_MEDIUM
+  };
+  if (await canEncodeAudio(preferredDefaultAudioEncodingConfig.codec, preferredDefaultAudioEncodingConfig)) {
+    return preferredDefaultAudioEncodingConfig;
+  }
+  const backupDefaultAudioEncodingConfig = {
+    codec: "opus",
+    bitrate: QUALITY_MEDIUM
+  };
+  if (await canEncodeAudio(backupDefaultAudioEncodingConfig.codec, backupDefaultAudioEncodingConfig)) {
+    return backupDefaultAudioEncodingConfig;
+  }
+  return null;
+};
+
 // src/mediabunny-mappings.ts
 var codecToMediabunnyCodec = (codec) => {
   switch (codec) {
@@ -7453,7 +8655,143 @@ var getQualityForWebRendererQuality = (quality) => {
   }
 };
 
-// src/parse-transform-origin.ts
+// src/drawing/border-radius.ts
+function parseValue({
+  value,
+  reference
+}) {
+  value = value.trim();
+  if (value.endsWith("%")) {
+    const percentage = parseFloat(value);
+    return percentage / 100 * reference;
+  }
+  if (value.endsWith("px")) {
+    return parseFloat(value);
+  }
+  return parseFloat(value);
+}
+function expandShorthand(values) {
+  if (values.length === 1) {
+    return [values[0], values[0], values[0], values[0]];
+  }
+  if (values.length === 2) {
+    return [values[0], values[1], values[0], values[1]];
+  }
+  if (values.length === 3) {
+    return [values[0], values[1], values[2], values[1]];
+  }
+  return [values[0], values[1], values[2], values[3]];
+}
+function clampBorderRadius({
+  borderRadius,
+  width,
+  height
+}) {
+  const clamped = {
+    topLeft: { ...borderRadius.topLeft },
+    topRight: { ...borderRadius.topRight },
+    bottomRight: { ...borderRadius.bottomRight },
+    bottomLeft: { ...borderRadius.bottomLeft }
+  };
+  const topSum = clamped.topLeft.horizontal + clamped.topRight.horizontal;
+  if (topSum > width) {
+    const factor = width / topSum;
+    clamped.topLeft.horizontal *= factor;
+    clamped.topRight.horizontal *= factor;
+  }
+  const rightSum = clamped.topRight.vertical + clamped.bottomRight.vertical;
+  if (rightSum > height) {
+    const factor = height / rightSum;
+    clamped.topRight.vertical *= factor;
+    clamped.bottomRight.vertical *= factor;
+  }
+  const bottomSum = clamped.bottomRight.horizontal + clamped.bottomLeft.horizontal;
+  if (bottomSum > width) {
+    const factor = width / bottomSum;
+    clamped.bottomRight.horizontal *= factor;
+    clamped.bottomLeft.horizontal *= factor;
+  }
+  const leftSum = clamped.bottomLeft.vertical + clamped.topLeft.vertical;
+  if (leftSum > height) {
+    const factor = height / leftSum;
+    clamped.bottomLeft.vertical *= factor;
+    clamped.topLeft.vertical *= factor;
+  }
+  return clamped;
+}
+function parseBorderRadius({
+  borderRadius,
+  width,
+  height
+}) {
+  const parts = borderRadius.split("/").map((part) => part.trim());
+  const horizontalPart = parts[0];
+  const verticalPart = parts[1];
+  const horizontalValues = horizontalPart.split(/\s+/).filter((v) => v);
+  const verticalValues = verticalPart ? verticalPart.split(/\s+/).filter((v) => v) : horizontalValues;
+  const [hTopLeft, hTopRight, hBottomRight, hBottomLeft] = expandShorthand(horizontalValues);
+  const [vTopLeft, vTopRight, vBottomRight, vBottomLeft] = expandShorthand(verticalValues);
+  return clampBorderRadius({
+    borderRadius: {
+      topLeft: {
+        horizontal: parseValue({ value: hTopLeft, reference: width }),
+        vertical: parseValue({ value: vTopLeft, reference: height })
+      },
+      topRight: {
+        horizontal: parseValue({ value: hTopRight, reference: width }),
+        vertical: parseValue({ value: vTopRight, reference: height })
+      },
+      bottomRight: {
+        horizontal: parseValue({ value: hBottomRight, reference: width }),
+        vertical: parseValue({ value: vBottomRight, reference: height })
+      },
+      bottomLeft: {
+        horizontal: parseValue({ value: hBottomLeft, reference: width }),
+        vertical: parseValue({ value: vBottomLeft, reference: height })
+      }
+    },
+    width,
+    height
+  });
+}
+function setBorderRadius({
+  ctx,
+  x,
+  y,
+  width,
+  height,
+  borderRadius
+}) {
+  if (borderRadius.topLeft.horizontal === 0 && borderRadius.topLeft.vertical === 0 && borderRadius.topRight.horizontal === 0 && borderRadius.topRight.vertical === 0 && borderRadius.bottomRight.horizontal === 0 && borderRadius.bottomRight.vertical === 0 && borderRadius.bottomLeft.horizontal === 0 && borderRadius.bottomLeft.vertical === 0) {
+    return () => {};
+  }
+  ctx.save();
+  ctx.beginPath();
+  ctx.moveTo(x + borderRadius.topLeft.horizontal, y);
+  ctx.lineTo(x + width - borderRadius.topRight.horizontal, y);
+  if (borderRadius.topRight.horizontal > 0 || borderRadius.topRight.vertical > 0) {
+    ctx.ellipse(x + width - borderRadius.topRight.horizontal, y + borderRadius.topRight.vertical, borderRadius.topRight.horizontal, borderRadius.topRight.vertical, 0, -Math.PI / 2, 0);
+  }
+  ctx.lineTo(x + width, y + height - borderRadius.bottomRight.vertical);
+  if (borderRadius.bottomRight.horizontal > 0 || borderRadius.bottomRight.vertical > 0) {
+    ctx.ellipse(x + width - borderRadius.bottomRight.horizontal, y + height - borderRadius.bottomRight.vertical, borderRadius.bottomRight.horizontal, borderRadius.bottomRight.vertical, 0, 0, Math.PI / 2);
+  }
+  ctx.lineTo(x + borderRadius.bottomLeft.horizontal, y + height);
+  if (borderRadius.bottomLeft.horizontal > 0 || borderRadius.bottomLeft.vertical > 0) {
+    ctx.ellipse(x + borderRadius.bottomLeft.horizontal, y + height - borderRadius.bottomLeft.vertical, borderRadius.bottomLeft.horizontal, borderRadius.bottomLeft.vertical, 0, Math.PI / 2, Math.PI);
+  }
+  ctx.lineTo(x, y + borderRadius.topLeft.vertical);
+  if (borderRadius.topLeft.horizontal > 0 || borderRadius.topLeft.vertical > 0) {
+    ctx.ellipse(x + borderRadius.topLeft.horizontal, y + borderRadius.topLeft.vertical, borderRadius.topLeft.horizontal, borderRadius.topLeft.vertical, 0, Math.PI, Math.PI * 3 / 2);
+  }
+  ctx.closePath();
+  ctx.clip();
+  return () => {
+    ctx.restore();
+  };
+}
+
+// src/drawing/parse-transform-origin.ts
 var parseTransformOrigin = (transformOrigin) => {
   if (transformOrigin.trim() === "") {
     return null;
@@ -7462,7 +8800,7 @@ var parseTransformOrigin = (transformOrigin) => {
   return { x: parseFloat(x), y: parseFloat(y) };
 };
 
-// src/calculate-transforms.ts
+// src/drawing/calculate-transforms.ts
 var getInternalTransformOrigin = (transform) => {
   const centerX = transform.boundingClientRect.width / 2;
   const centerY = transform.boundingClientRect.height / 2;
@@ -7483,8 +8821,13 @@ var calculateTransforms = (element) => {
   let parent = element;
   const transforms = [];
   const toReset = [];
+  let opacity = 1;
   while (parent) {
     const computedStyle = getComputedStyle(parent);
+    const parentOpacity = computedStyle.opacity;
+    if (parentOpacity && parentOpacity !== "") {
+      opacity *= parseFloat(parentOpacity);
+    }
     if (computedStyle.transform && computedStyle.transform !== "none" || parent === element) {
       const toParse = computedStyle.transform === "none" || computedStyle.transform === "" ? undefined : computedStyle.transform;
       const matrix = new DOMMatrix(toParse);
@@ -7525,11 +8868,122 @@ var calculateTransforms = (element) => {
         reset();
       }
     },
-    nativeTransformOrigin
+    nativeTransformOrigin,
+    opacity
+  };
+};
+
+// src/drawing/draw-border.ts
+var drawBorder = ({
+  ctx,
+  x,
+  y,
+  width,
+  height,
+  borderRadius,
+  computedStyle
+}) => {
+  const {
+    borderStyle,
+    borderColor,
+    borderWidth: computedBorderWidth
+  } = computedStyle;
+  const borderWidths = computedBorderWidth.split(/\s+/).map((w) => parseFloat(w));
+  const borderTop = borderWidths[0] || 0;
+  const borderRight = borderWidths[1] || borderTop;
+  const borderBottom = borderWidths[2] || borderTop;
+  const borderLeft = borderWidths[3] || borderRight;
+  const hasBorder = borderStyle && borderStyle !== "none" && borderStyle !== "hidden" && (borderTop > 0 || borderRight > 0 || borderBottom > 0 || borderLeft > 0);
+  if (!hasBorder) {
+    return;
+  }
+  const originalStrokeStyle = ctx.strokeStyle;
+  const originalLineWidth = ctx.lineWidth;
+  const originalLineDash = ctx.getLineDash();
+  ctx.strokeStyle = borderColor;
+  if (borderStyle === "dashed") {
+    const max = Math.max(borderTop, borderRight, borderBottom, borderLeft);
+    ctx.setLineDash([max * 2, max]);
+  } else if (borderStyle === "dotted") {
+    ctx.setLineDash([
+      Math.max(borderTop, borderRight, borderBottom, borderLeft)
+    ]);
+  } else {
+    ctx.setLineDash([]);
+  }
+  const maxBorderWidth = Math.max(borderTop, borderRight, borderBottom, borderLeft);
+  ctx.beginPath();
+  const borderX = x + maxBorderWidth / 2;
+  const borderY = y + maxBorderWidth / 2;
+  const borderWidth = width - maxBorderWidth;
+  const borderHeight = height - maxBorderWidth;
+  const adjustedBorderRadius = {
+    topLeft: {
+      horizontal: Math.max(0, borderRadius.topLeft.horizontal - maxBorderWidth / 2),
+      vertical: Math.max(0, borderRadius.topLeft.vertical - maxBorderWidth / 2)
+    },
+    topRight: {
+      horizontal: Math.max(0, borderRadius.topRight.horizontal - maxBorderWidth / 2),
+      vertical: Math.max(0, borderRadius.topRight.vertical - maxBorderWidth / 2)
+    },
+    bottomRight: {
+      horizontal: Math.max(0, borderRadius.bottomRight.horizontal - maxBorderWidth / 2),
+      vertical: Math.max(0, borderRadius.bottomRight.vertical - maxBorderWidth / 2)
+    },
+    bottomLeft: {
+      horizontal: Math.max(0, borderRadius.bottomLeft.horizontal - maxBorderWidth / 2),
+      vertical: Math.max(0, borderRadius.bottomLeft.vertical - maxBorderWidth / 2)
+    }
+  };
+  ctx.moveTo(borderX + adjustedBorderRadius.topLeft.horizontal, borderY);
+  ctx.lineTo(borderX + borderWidth - adjustedBorderRadius.topRight.horizontal, borderY);
+  if (adjustedBorderRadius.topRight.horizontal > 0 || adjustedBorderRadius.topRight.vertical > 0) {
+    ctx.ellipse(borderX + borderWidth - adjustedBorderRadius.topRight.horizontal, borderY + adjustedBorderRadius.topRight.vertical, adjustedBorderRadius.topRight.horizontal, adjustedBorderRadius.topRight.vertical, 0, -Math.PI / 2, 0);
+  }
+  ctx.lineTo(borderX + borderWidth, borderY + borderHeight - adjustedBorderRadius.bottomRight.vertical);
+  if (adjustedBorderRadius.bottomRight.horizontal > 0 || adjustedBorderRadius.bottomRight.vertical > 0) {
+    ctx.ellipse(borderX + borderWidth - adjustedBorderRadius.bottomRight.horizontal, borderY + borderHeight - adjustedBorderRadius.bottomRight.vertical, adjustedBorderRadius.bottomRight.horizontal, adjustedBorderRadius.bottomRight.vertical, 0, 0, Math.PI / 2);
+  }
+  ctx.lineTo(borderX + adjustedBorderRadius.bottomLeft.horizontal, borderY + borderHeight);
+  if (adjustedBorderRadius.bottomLeft.horizontal > 0 || adjustedBorderRadius.bottomLeft.vertical > 0) {
+    ctx.ellipse(borderX + adjustedBorderRadius.bottomLeft.horizontal, borderY + borderHeight - adjustedBorderRadius.bottomLeft.vertical, adjustedBorderRadius.bottomLeft.horizontal, adjustedBorderRadius.bottomLeft.vertical, 0, Math.PI / 2, Math.PI);
+  }
+  ctx.lineTo(borderX, borderY + adjustedBorderRadius.topLeft.vertical);
+  if (adjustedBorderRadius.topLeft.horizontal > 0 || adjustedBorderRadius.topLeft.vertical > 0) {
+    ctx.ellipse(borderX + adjustedBorderRadius.topLeft.horizontal, borderY + adjustedBorderRadius.topLeft.vertical, adjustedBorderRadius.topLeft.horizontal, adjustedBorderRadius.topLeft.vertical, 0, Math.PI, Math.PI * 3 / 2);
+  }
+  ctx.closePath();
+  ctx.lineWidth = maxBorderWidth;
+  ctx.stroke();
+  ctx.strokeStyle = originalStrokeStyle;
+  ctx.lineWidth = originalLineWidth;
+  ctx.setLineDash(originalLineDash);
+};
+
+// src/drawing/opacity.ts
+var setOpacity = ({
+  ctx,
+  opacity
+}) => {
+  const previousAlpha = ctx.globalAlpha;
+  ctx.globalAlpha = previousAlpha * opacity;
+  return () => {
+    ctx.globalAlpha = previousAlpha;
+  };
+};
+
+// src/drawing/transform.ts
+var setTransform = ({
+  ctx,
+  transform
+}) => {
+  ctx.setTransform(transform);
+  return () => {
+    ctx.setTransform(new DOMMatrix);
   };
 };
 
-// src/compose-svg.ts
+// src/drawing/turn-svg-into-drawable.ts
 var turnSvgIntoDrawable = (svg) => {
   const originalTransform = svg.style.transform;
   const originalTransformOrigin = svg.style.transformOrigin;
@@ -7563,59 +9017,83 @@ var turnSvgIntoDrawable = (svg) => {
   });
 };
 
-// src/compose-canvas.ts
-var composeCanvas = async (canvas, context) => {
-  const { totalMatrix, reset, dimensions } = calculateTransforms(canvas);
-  context.setTransform(totalMatrix);
-  const drawable = canvas instanceof SVGSVGElement ? await turnSvgIntoDrawable(canvas) : canvas;
-  context.drawImage(drawable, dimensions.left, dimensions.top, dimensions.width, dimensions.height);
-  context.setTransform(new DOMMatrix);
+// src/drawing/draw-element-to-canvas.ts
+var drawElementToCanvas = async ({
+  element,
+  context
+}) => {
+  const { totalMatrix, reset, dimensions, opacity } = calculateTransforms(element);
+  if (opacity === 0) {
+    reset();
+    return;
+  }
+  if (dimensions.width <= 0 || dimensions.height <= 0) {
+    reset();
+    return;
+  }
+  const computedStyle = getComputedStyle(element);
+  const background = computedStyle.backgroundColor;
+  const borderRadius = parseBorderRadius({
+    borderRadius: computedStyle.borderRadius,
+    width: dimensions.width,
+    height: dimensions.height
+  });
+  const finishTransform = setTransform({
+    ctx: context,
+    transform: totalMatrix
+  });
+  const finishBorderRadius = setBorderRadius({
+    ctx: context,
+    x: dimensions.left,
+    y: dimensions.top,
+    width: dimensions.width,
+    height: dimensions.height,
+    borderRadius
+  });
+  const finishOpacity = setOpacity({
+    ctx: context,
+    opacity
+  });
+  const drawable = element instanceof SVGSVGElement ? await turnSvgIntoDrawable(element) : element instanceof HTMLImageElement ? element : element instanceof HTMLCanvasElement ? element : null;
+  if (background && background !== "transparent" && !(background.startsWith("rgba") && (background.endsWith(", 0)") || background.endsWith(",0")))) {
+    const originalFillStyle = context.fillStyle;
+    context.fillStyle = background;
+    context.fillRect(dimensions.left, dimensions.top, dimensions.width, dimensions.height);
+    context.fillStyle = originalFillStyle;
+  }
+  if (drawable) {
+    context.drawImage(drawable, dimensions.left, dimensions.top, dimensions.width, dimensions.height);
+  }
+  drawBorder({
+    ctx: context,
+    x: dimensions.left,
+    y: dimensions.top,
+    width: dimensions.width,
+    height: dimensions.height,
+    borderRadius,
+    computedStyle
+  });
+  finishOpacity();
+  finishBorderRadius();
+  finishTransform();
   reset();
 };
 
 // src/compose.ts
-var compose = async ({
-  composables,
-  width,
-  height
-}) => {
-  const canvas = new OffscreenCanvas(width, height);
-  const context = canvas.getContext("2d");
-  if (!context) {
-    throw new Error("Could not get context");
-  }
-  for (const composable of composables) {
-    await composeCanvas(composable.element, context);
-  }
-  return canvas;
-};
-
-// src/find-capturable-elements.ts
-var findCapturableElements = (element) => {
-  const canvasAndSvgElements = element.querySelectorAll("svg,canvas,img");
-  const composables = [];
-  Array.from(canvasAndSvgElements).forEach((capturableElement) => {
-    if (capturableElement.tagName.toLocaleLowerCase() === "canvas") {
-      const canvas = capturableElement;
-      composables.push({
-        type: "canvas",
-        element: canvas
-      });
-    } else if (capturableElement.tagName.toLocaleLowerCase() === "svg") {
-      const svg = capturableElement;
-      composables.push({
-        type: "svg",
-        element: svg
-      });
-    } else if (capturableElement.tagName.toLocaleLowerCase() === "img") {
-      const img = capturableElement;
-      composables.push({
-        type: "img",
-        element: img
-      });
+var compose = async (element, context) => {
+  const treeWalker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, (node) => {
+    if (node instanceof Element) {
+      const computedStyle = getComputedStyle(node);
+      return computedStyle.display === "none" ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT;
     }
+    return NodeFilter.FILTER_ACCEPT;
   });
-  return composables;
+  while (treeWalker.nextNode()) {
+    const node = treeWalker.currentNode;
+    if (node instanceof HTMLElement || node instanceof SVGElement) {
+      await drawElementToCanvas({ element: node, context });
+    }
+  }
 };
 
 // src/take-screenshot.ts
@@ -7624,13 +9102,13 @@ var createFrame = async ({
   width,
   height
 }) => {
-  const composables = findCapturableElements(div);
-  const composed = await compose({
-    composables,
-    width,
-    height
-  });
-  return composed;
+  const canvas = new OffscreenCanvas(width, height);
+  const context = canvas.getContext("2d");
+  if (!context) {
+    throw new Error("Could not get context");
+  }
+  await compose(div, context);
+  return canvas;
 };
 var takeScreenshot = async ({
   div,
@@ -7807,10 +9285,7 @@ var internalRenderMediaOnWeb = async ({
     defaultCodec: resolved.defaultCodec,
     defaultOutName: resolved.defaultOutName
   });
-  const artifactsHandler = handleArtifacts({
-    ref: collectAssets,
-    onArtifact
-  });
+  const artifactsHandler = handleArtifacts();
   cleanupFns.push(() => {
     cleanupScaffold();
   });
@@ -7850,6 +9325,15 @@ var internalRenderMediaOnWeb = async ({
       videoSampleSource.close();
     });
     output.addVideoTrack(videoSampleSource);
+    const defaultAudioEncodingConfig = await getDefaultAudioEncodingConfig();
+    if (!defaultAudioEncodingConfig) {
+      return Promise.reject(new Error("No default audio encoding config found"));
+    }
+    const audioSampleSource = new AudioSampleSource(defaultAudioEncodingConfig);
+    cleanupFns.push(() => {
+      audioSampleSource.close();
+    });
+    output.addAudioTrack(audioSampleSource);
     await output.start();
     if (signal?.aborted) {
       throw new Error("renderMediaOnWeb() was cancelled");
@@ -7859,8 +9343,11 @@ var internalRenderMediaOnWeb = async ({
       encodedFrames: 0
     };
     const throttledOnProgress = createThrottledProgressCallback(onProgress);
-    for (let i = realFrameRange[0];i <= realFrameRange[1]; i++) {
-      timeUpdater.current?.update(i);
+    for (let frame = realFrameRange[0];frame <= realFrameRange[1]; frame++) {
+      if (signal?.aborted) {
+        throw new Error("renderMediaOnWeb() was cancelled");
+      }
+      timeUpdater.current?.update(frame);
       await waitForReady({
         timeoutInMilliseconds: delayRenderTimeoutInMilliseconds,
         scope: delayRenderScope,
@@ -7875,11 +9362,23 @@ var internalRenderMediaOnWeb = async ({
         width: resolved.width,
         height: resolved.height
       });
-      await artifactsHandler.handle({ imageData, frame: i });
       if (signal?.aborted) {
         throw new Error("renderMediaOnWeb() was cancelled");
       }
-      const timestamp = Math.round((i - realFrameRange[0]) / resolved.fps * 1e6);
+      const assets = collectAssets.current.collectAssets();
+      if (onArtifact) {
+        await artifactsHandler.handle({
+          imageData,
+          frame,
+          assets,
+          onArtifact
+        });
+      }
+      if (signal?.aborted) {
+        throw new Error("renderMediaOnWeb() was cancelled");
+      }
+      const audio = onlyInlineAudio({ assets, fps: resolved.fps, frame });
+      const timestamp = Math.round((frame - realFrameRange[0]) / resolved.fps * 1e6);
       const videoFrame = new VideoFrame(imageData, {
         timestamp
       });
@@ -7888,6 +9387,9 @@ var internalRenderMediaOnWeb = async ({
       let frameToEncode = videoFrame;
       if (onFrame) {
         const returnedFrame = await onFrame(videoFrame);
+        if (signal?.aborted) {
+          throw new Error("renderMediaOnWeb() was cancelled");
+        }
         frameToEncode = validateVideoFrame({
           originalFrame: videoFrame,
           returnedFrame,
@@ -7896,16 +9398,19 @@ var internalRenderMediaOnWeb = async ({
           expectedTimestamp: timestamp
         });
       }
-      await videoSampleSource.add(new VideoSample(frameToEncode));
+      await Promise.all([
+        addVideoSampleAndCloseFrame(frameToEncode, videoSampleSource),
+        audio ? addAudioSample(audio, audioSampleSource) : Promise.resolve()
+      ]);
       progress.encodedFrames++;
       throttledOnProgress?.({ ...progress });
-      frameToEncode.close();
       if (signal?.aborted) {
         throw new Error("renderMediaOnWeb() was cancelled");
       }
     }
     onProgress?.({ ...progress });
     videoSampleSource.close();
+    audioSampleSource.close();
     await output.finalize();
     return output.target.buffer;
   } finally {
@@ -7982,10 +9487,7 @@ async function internalRenderStillOnWeb({
     defaultCodec: resolved.defaultCodec,
     defaultOutName: resolved.defaultOutName
   });
-  const artifactsHandler = handleArtifacts({
-    ref: collectAssets,
-    onArtifact
-  });
+  const artifactsHandler = handleArtifacts();
   try {
     if (signal?.aborted) {
       throw new Error("renderStillOnWeb() was cancelled");
@@ -8005,7 +9507,10 @@ async function internalRenderStillOnWeb({
       height: resolved.height,
       imageFormat
     });
-    await artifactsHandler.handle({ imageData, frame });
+    const assets = collectAssets.current.collectAssets();
+    if (onArtifact) {
+      await artifactsHandler.handle({ imageData, frame, assets, onArtifact });
+    }
     return imageData;
   } finally {
     cleanupScaffold();