@vidtreo/recorder 1.8.1 → 1.9.0

package/dist/index.js

@@ -139,6 +139,460 @@ class AudioLevelAnalyzer {
     return isMutedFromCallback || hasDisabledTracks;
   }
 }
+// src/core/audio-recording/audio-file-transcoder.ts
+import {
+  ALL_FORMATS,
+  AudioSampleSink,
+  BlobSource,
+  BufferTarget,
+  Conversion,
+  canEncodeAudio,
+  Input,
+  Mp4OutputFormat,
+  Output,
+  WebMOutputFormat
+} from "mediabunny";
+
+// src/core/recording/recording-filename.ts
+var MAX_TITLE_LENGTH = 120;
+var CONTROL_CHARACTERS = /\p{Cc}/gu;
+var FORBIDDEN_CHARACTERS = /[/\\*?"<>|]/g;
+var WHITESPACE = /\s+/g;
+var LEADING_DOTS = /^[.\s]+/;
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function truncateTitle(title) {
+  if (title.length <= MAX_TITLE_LENGTH) {
+    return title;
+  }
+  let truncated = title.slice(0, MAX_TITLE_LENGTH);
+  if (isHighSurrogate(truncated.charCodeAt(truncated.length - 1))) {
+    truncated = truncated.slice(0, -1);
+  }
+  return truncated.trimEnd();
+}
+function sanitizeRecordingTitle(title) {
+  const cleaned = title.replace(CONTROL_CHARACTERS, " ").replace(FORBIDDEN_CHARACTERS, "").replace(WHITESPACE, " ").replace(LEADING_DOTS, "").trim();
+  return truncateTitle(cleaned);
+}
+function createRecordingFilename(title, extension) {
+  const sanitized = title === null ? "" : sanitizeRecordingTitle(title);
+  if (sanitized === "") {
+    return `recording-${Date.now()}.${extension}`;
+  }
+  return `${sanitized}.${extension}`;
+}
+
+// src/core/utils/platform-detection.ts
+var PLATFORM_KEYWORD_LINUX = "linux";
+var PLATFORM_KEYWORD_ANDROID = "android";
+var RUNTIME_MARKER_BUN = "bun/";
+var RUNTIME_MARKER_HAPPY_DOM = "happydom";
+var RUNTIME_MARKER_NODE = "node.js";
+function normalizeValue(value) {
+  if (value === undefined) {
+    return "";
+  }
+  return value.toLowerCase();
+}
+function hasPlatformKeyword(value, keyword) {
+  return value.includes(keyword);
+}
+function isNonBrowserRuntime(userAgent) {
+  if (userAgent.includes(RUNTIME_MARKER_BUN)) {
+    return true;
+  }
+  if (userAgent.includes(RUNTIME_MARKER_HAPPY_DOM)) {
+    return true;
+  }
+  if (userAgent.includes(RUNTIME_MARKER_NODE)) {
+    return true;
+  }
+  return false;
+}
+function resolveNavigatorProvider(navigatorProvider) {
+  if (navigatorProvider) {
+    return navigatorProvider;
+  }
+  if (typeof navigator === "undefined") {
+    return null;
+  }
+  const globalNavigator = navigator;
+  return {
+    platform: globalNavigator.platform,
+    userAgent: globalNavigator.userAgent,
+    userAgentData: globalNavigator.userAgentData
+  };
+}
+function isLinuxPlatform(navigatorProvider) {
+  const resolvedNavigatorProvider = resolveNavigatorProvider(navigatorProvider);
+  if (resolvedNavigatorProvider === null) {
+    return false;
+  }
+  const userAgent = normalizeValue(resolvedNavigatorProvider.userAgent);
+  if (isNonBrowserRuntime(userAgent)) {
+    return false;
+  }
+  const platform = normalizeValue(resolvedNavigatorProvider.platform);
+  const userAgentDataPlatform = normalizeValue(resolvedNavigatorProvider.userAgentData?.platform);
+  const isAndroidPlatform = hasPlatformKeyword(platform, PLATFORM_KEYWORD_ANDROID) || hasPlatformKeyword(userAgentDataPlatform, PLATFORM_KEYWORD_ANDROID) || hasPlatformKeyword(userAgent, PLATFORM_KEYWORD_ANDROID);
+  if (isAndroidPlatform) {
+    return false;
+  }
+  if (platform.includes(PLATFORM_KEYWORD_LINUX)) {
+    return true;
+  }
+  if (userAgentDataPlatform.includes(PLATFORM_KEYWORD_LINUX)) {
+    return true;
+  }
+  if (userAgent.includes(PLATFORM_KEYWORD_LINUX)) {
+    return true;
+  }
+  return false;
+}
+
+// src/core/audio-recording/audio-recording-error.ts
+var ERROR_AUDIO_RECORDING_DISABLED = "recording.audio-disabled";
+var ERROR_AUDIO_SOURCE_SWITCH_UNSUPPORTED = "recording.audio-source-switch-unsupported";
+var ERROR_AUDIO_UNSUPPORTED_INPUT = "audio.unsupported-input";
+var ERROR_AUDIO_NO_AUDIO_TRACK = "audio.no-audio-track";
+var ERROR_AUDIO_CODEC_UNSUPPORTED = "audio.codec-unsupported";
+function createAudioRecordingError(code, message) {
+  const error = new Error(`${message} [${code}]`);
+  error.name = "AudioRecordingError";
+  error.code = code;
+  return error;
+}
+
+// src/core/audio-recording/audio-output-format.ts
+var AUDIO_OUTPUT_FORMATS = Object.freeze({
+  aac: {
+    format: "aac",
+    container: "mp4",
+    mimeType: "audio/mp4",
+    extension: "m4a"
+  },
+  opus: {
+    format: "opus",
+    container: "webm",
+    mimeType: "audio/webm",
+    extension: "webm"
+  }
+});
+function getAudioFormatCandidates(requestedFormat, isLinuxPlatform) {
+  if (isLinuxPlatform) {
+    return ["opus"];
+  }
+  if (requestedFormat === "opus") {
+    return ["opus", "aac"];
+  }
+  return ["aac", "opus"];
+}
+async function resolveAudioOutputFormat(requestedFormat, options) {
+  const candidates = getAudioFormatCandidates(requestedFormat, options.isLinuxPlatform);
+  for (const candidate of candidates) {
+    const isEncodable = await options.canEncode(candidate).catch(() => false);
+    if (isEncodable) {
+      return AUDIO_OUTPUT_FORMATS[candidate];
+    }
+  }
+  throw createAudioRecordingError(ERROR_AUDIO_CODEC_UNSUPPORTED, `This browser cannot encode audio as ${candidates.join(" or ")}`);
+}
+
+// src/core/audio-recording/audio-peaks.ts
+var PEAKS_VERSION = 1;
+var MAX_AUDIO_PEAK_POINTS = 1000;
+var PEAK_WINDOW_SECONDS = 0.01;
+var PEAK_PRECISION = 1000;
+function roundPeak(value) {
+  return Math.round(Math.min(1, value) * PEAK_PRECISION) / PEAK_PRECISION;
+}
+
+class AudioPeaksAccumulator {
+  windowPeaks = [];
+  windowFrames = 0;
+  currentWindowPeak = 0;
+  currentWindowFrameCount = 0;
+  addPlanarSamples(data, frames, numberOfChannels, sampleRate) {
+    if (frames <= 0 || numberOfChannels <= 0 || sampleRate <= 0) {
+      return;
+    }
+    if (this.windowFrames === 0) {
+      this.windowFrames = Math.max(1, Math.round(sampleRate * PEAK_WINDOW_SECONDS));
+    }
+    for (let frame = 0;frame < frames; frame += 1) {
+      let amplitude = 0;
+      for (let channel = 0;channel < numberOfChannels; channel += 1) {
+        const sample = Math.abs(data[channel * frames + frame]);
+        if (sample > amplitude) {
+          amplitude = sample;
+        }
+      }
+      if (amplitude > this.currentWindowPeak) {
+        this.currentWindowPeak = amplitude;
+      }
+      this.currentWindowFrameCount += 1;
+      if (this.currentWindowFrameCount >= this.windowFrames) {
+        this.flushWindow();
+      }
+    }
+  }
+  toPeaks() {
+    if (this.currentWindowFrameCount > 0) {
+      this.flushWindow();
+    }
+    const windowCount = this.windowPeaks.length;
+    const length = Math.min(MAX_AUDIO_PEAK_POINTS, windowCount);
+    const data = [];
+    for (let point = 0;point < length; point += 1) {
+      const start = Math.floor(point * windowCount / length);
+      const end = Math.max(start + 1, Math.floor((point + 1) * windowCount / length));
+      let peak = 0;
+      for (let index = start;index < end; index += 1) {
+        if (this.windowPeaks[index] > peak) {
+          peak = this.windowPeaks[index];
+        }
+      }
+      data.push(roundPeak(peak));
+    }
+    return { version: PEAKS_VERSION, length, data };
+  }
+  flushWindow() {
+    this.windowPeaks.push(this.currentWindowPeak);
+    this.currentWindowPeak = 0;
+    this.currentWindowFrameCount = 0;
+  }
+}
+
+// src/core/audio-recording/audio-file-transcoder.ts
+var FILE_EXTENSION_PATTERN = /\.[^.]+$/;
+function openInput(blob) {
+  return new Input({ formats: ALL_FORMATS, source: new BlobSource(blob) });
+}
+function requirePrimaryAudioTrack(input) {
+  return input.getPrimaryAudioTrack().catch(() => {
+    throw createAudioRecordingError(ERROR_AUDIO_UNSUPPORTED_INPUT, "The file format is not supported");
+  }).then((track) => {
+    if (!track) {
+      throw createAudioRecordingError(ERROR_AUDIO_NO_AUDIO_TRACK, "The file has no audio track");
+    }
+    return track;
+  });
+}
+function addSampleToPeaks(accumulator, sample) {
+  const frames = sample.numberOfFrames;
+  const channels = sample.numberOfChannels;
+  const planar = new Float32Array(frames * channels);
+  for (let channel = 0;channel < channels; channel += 1) {
+    sample.copyTo(planar.subarray(channel * frames, (channel + 1) * frames), {
+      planeIndex: channel,
+      format: "f32-planar"
+    });
+  }
+  accumulator.addPlanarSamples(planar, frames, channels, sample.sampleRate);
+}
+function createOutput(outputFormat) {
+  const format = outputFormat.container === "mp4" ? new Mp4OutputFormat({ fastStart: "in-memory" }) : new WebMOutputFormat;
+  return new Output({ format, target: new BufferTarget });
+}
+async function readAudioMetadata(blob) {
+  const input = openInput(blob);
+  const track = await requirePrimaryAudioTrack(input);
+  const metadata = {
+    duration: await input.computeDuration(),
+    channels: await track.getNumberOfChannels(),
+    sampleRate: await track.getSampleRate()
+  };
+  input.dispose();
+  return metadata;
+}
+async function computeAudioPeaksFromBlob(blob) {
+  const input = openInput(blob);
+  const track = await requirePrimaryAudioTrack(input);
+  if (!await track.canDecode()) {
+    input.dispose();
+    return null;
+  }
+  const accumulator = new AudioPeaksAccumulator;
+  for await (const sample of new AudioSampleSink(track).samples()) {
+    addSampleToPeaks(accumulator, sample);
+    sample.close();
+  }
+  input.dispose();
+  return accumulator.toPeaks();
+}
+async function convertAudio(file, config, options) {
+  const input = openInput(file);
+  const primaryTrack = await requirePrimaryAudioTrack(input);
+  if (!await primaryTrack.canDecode()) {
+    input.dispose();
+    throw createAudioRecordingError(ERROR_AUDIO_UNSUPPORTED_INPUT, `This browser cannot decode ${primaryTrack.codec ?? "this"} audio`);
+  }
+  const outputFormat = await resolveAudioOutputFormat(config.format, {
+    isLinuxPlatform: isLinuxPlatform(),
+    canEncode: (format) => canEncodeAudio(format, {
+      numberOfChannels: config.channels,
+      bitrate: config.bitrate
+    })
+  });
+  const output = createOutput(outputFormat);
+  const accumulator = new AudioPeaksAccumulator;
+  const audioOptions = {
+    codec: outputFormat.format,
+    bitrate: config.bitrate,
+    numberOfChannels: config.channels,
+    forceTranscode: options.shouldForceTranscode
+  };
+  if (options.shouldForceTranscode) {
+    audioOptions.process = (sample) => {
+      addSampleToPeaks(accumulator, sample);
+      return sample;
+    };
+  }
+  const conversion = await Conversion.init({
+    input,
+    output,
+    video: { discard: true },
+    audio: (track) => track === primaryTrack ? audioOptions : { discard: true },
+    showWarnings: false
+  });
+  if (!conversion.isValid) {
+    input.dispose();
+    throw createAudioRecordingError(ERROR_AUDIO_UNSUPPORTED_INPUT, "The audio track cannot be converted in this browser");
+  }
+  if (options.onProgress) {
+    const onProgress = options.onProgress;
+    conversion.onProgress = (progress) => onProgress(progress);
+  }
+  options.signal?.addEventListener("abort", () => {
+    conversion.cancel().catch(() => {
+      return;
+    });
+  }, { once: true });
+  await conversion.execute().finally(() => input.dispose());
+  const buffer = output.target.buffer;
+  if (!buffer) {
+    throw new Error("Audio conversion produced no output");
+  }
+  const blob = new Blob([buffer], { type: outputFormat.mimeType });
+  const peaks = options.shouldForceTranscode ? accumulator.toPeaks() : await computeAudioPeaksFromBlob(blob);
+  return { blob, outputFormat, bitrate: config.bitrate, peaks };
+}
+async function createAudioRecording(encoded) {
+  const metadata = await readAudioMetadata(encoded.blob);
+  return {
+    blob: encoded.blob,
+    mimeType: encoded.outputFormat.mimeType,
+    extension: encoded.outputFormat.extension,
+    duration: metadata.duration,
+    peaks: encoded.peaks,
+    format: encoded.outputFormat.format,
+    bitrate: encoded.bitrate,
+    channels: metadata.channels,
+    sampleRate: metadata.sampleRate
+  };
+}
+async function convertRecordedAudio(blob, config, options = {}) {
+  const encoded = await convertAudio(blob, config, {
+    ...options,
+    shouldForceTranscode: false
+  });
+  return await createAudioRecording(encoded);
+}
+function resolveSourceTitle(file) {
+  if (!(file instanceof File) || file.name.trim() === "") {
+    return null;
+  }
+  return file.name.replace(FILE_EXTENSION_PATTERN, "");
+}
+async function transcodeAudioFile(file, config, options = {}) {
+  const encoded = await convertAudio(file, config, {
+    ...options,
+    shouldForceTranscode: true
+  });
+  const recording = await createAudioRecording(encoded);
+  if (!recording.peaks) {
+    throw new Error("Audio peaks could not be computed");
+  }
+  return {
+    blob: recording.blob,
+    mimeType: recording.mimeType,
+    filename: createRecordingFilename(resolveSourceTitle(file), recording.extension),
+    duration: recording.duration,
+    peaks: recording.peaks,
+    format: recording.format,
+    bitrate: recording.bitrate,
+    channels: recording.channels,
+    sampleRate: recording.sampleRate
+  };
+}
+// src/core/audio-recording/audio-recording-config.ts
+var AUDIO_BITRATES = [
+  64000,
+  96000,
+  128000,
+  192000
+];
+var DISABLED_AUDIO_RECORDING_CONFIG = Object.freeze({
+  enabled: false,
+  format: "aac",
+  bitrate: 128000,
+  channels: 1,
+  echoCancellation: true,
+  noiseSuppression: true,
+  autoGain: true,
+  normalize: false
+});
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseFormat(value) {
+  if (value === "opus") {
+    return "opus";
+  }
+  return DISABLED_AUDIO_RECORDING_CONFIG.format;
+}
+function parseBitrate(value) {
+  const bitrate = AUDIO_BITRATES.find((candidate) => candidate === value);
+  if (bitrate === undefined) {
+    return DISABLED_AUDIO_RECORDING_CONFIG.bitrate;
+  }
+  return bitrate;
+}
+function parseChannels(value) {
+  if (value === 2) {
+    return 2;
+  }
+  return DISABLED_AUDIO_RECORDING_CONFIG.channels;
+}
+function parseBoolean(value, defaultValue) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return defaultValue;
+}
+function parseAudioRecordingConfig(value) {
+  if (!(isRecord(value) && value.enabled === true)) {
+    return { ...DISABLED_AUDIO_RECORDING_CONFIG };
+  }
+  return {
+    enabled: true,
+    format: parseFormat(value.format),
+    bitrate: parseBitrate(value.bitrate),
+    channels: parseChannels(value.channels),
+    echoCancellation: parseBoolean(value.echoCancellation, DISABLED_AUDIO_RECORDING_CONFIG.echoCancellation),
+    noiseSuppression: parseBoolean(value.noiseSuppression, DISABLED_AUDIO_RECORDING_CONFIG.noiseSuppression),
+    autoGain: parseBoolean(value.autoGain, DISABLED_AUDIO_RECORDING_CONFIG.autoGain),
+    normalize: parseBoolean(value.normalize, DISABLED_AUDIO_RECORDING_CONFIG.normalize)
+  };
+}
+function requireEnabledAudioRecordingConfig(config) {
+  if (!config?.enabled) {
+    throw createAudioRecordingError(ERROR_AUDIO_RECORDING_DISABLED, "Audio recording is not enabled for this environment");
+  }
+  return config;
+}
 // src/core/browser-guard/browser-guard.ts
 import { UAParser } from "ua-parser-js";
 var UNSUPPORTED_BROWSER_NAMES = new Set([
@@ -425,96 +879,28 @@ function isMobileDevice() {
   return false;
 }
 
-// src/core/utils/platform-detection.ts
-var PLATFORM_KEYWORD_LINUX = "linux";
-var PLATFORM_KEYWORD_ANDROID = "android";
-var RUNTIME_MARKER_BUN = "bun/";
-var RUNTIME_MARKER_HAPPY_DOM = "happydom";
-var RUNTIME_MARKER_NODE = "node.js";
-function normalizeValue(value) {
-  if (value === undefined) {
-    return "";
+// src/core/config/preset-mapper.ts
+function mapPresetToConfig(options) {
+  const { preset, outputFormat, watermark, isMobile } = options;
+  if (!(preset in RESOLUTION_MAP)) {
+    return Promise.reject(new Error(`Invalid preset: ${preset}`));
   }
-  return value.toLowerCase();
-}
-function hasPlatformKeyword(value, keyword) {
-  return value.includes(keyword);
-}
-function isNonBrowserRuntime(userAgent) {
-  if (userAgent.includes(RUNTIME_MARKER_BUN)) {
-    return true;
+  let isMobileDeviceDetected = isMobile;
+  if (isMobileDeviceDetected === undefined) {
+    isMobileDeviceDetected = isMobileDevice();
   }
-  if (userAgent.includes(RUNTIME_MARKER_HAPPY_DOM)) {
-    return true;
+  let resolutionMap = RESOLUTION_MAP;
+  if (isMobileDeviceDetected) {
+    resolutionMap = MOBILE_RESOLUTION_MAP;
   }
-  if (userAgent.includes(RUNTIME_MARKER_NODE)) {
-    return true;
+  const { width, height } = resolutionMap[preset];
+  let format = outputFormat;
+  if (format === undefined) {
+    format = "mp4";
   }
-  return false;
-}
-function resolveNavigatorProvider(navigatorProvider) {
-  if (navigatorProvider) {
-    return navigatorProvider;
-  }
-  if (typeof navigator === "undefined") {
-    return null;
-  }
-  const globalNavigator = navigator;
-  return {
-    platform: globalNavigator.platform,
-    userAgent: globalNavigator.userAgent,
-    userAgentData: globalNavigator.userAgentData
-  };
-}
-function isLinuxPlatform(navigatorProvider) {
-  const resolvedNavigatorProvider = resolveNavigatorProvider(navigatorProvider);
-  if (resolvedNavigatorProvider === null) {
-    return false;
-  }
-  const userAgent = normalizeValue(resolvedNavigatorProvider.userAgent);
-  if (isNonBrowserRuntime(userAgent)) {
-    return false;
-  }
-  const platform = normalizeValue(resolvedNavigatorProvider.platform);
-  const userAgentDataPlatform = normalizeValue(resolvedNavigatorProvider.userAgentData?.platform);
-  const isAndroidPlatform = hasPlatformKeyword(platform, PLATFORM_KEYWORD_ANDROID) || hasPlatformKeyword(userAgentDataPlatform, PLATFORM_KEYWORD_ANDROID) || hasPlatformKeyword(userAgent, PLATFORM_KEYWORD_ANDROID);
-  if (isAndroidPlatform) {
-    return false;
-  }
-  if (platform.includes(PLATFORM_KEYWORD_LINUX)) {
-    return true;
-  }
-  if (userAgentDataPlatform.includes(PLATFORM_KEYWORD_LINUX)) {
-    return true;
-  }
-  if (userAgent.includes(PLATFORM_KEYWORD_LINUX)) {
-    return true;
-  }
-  return false;
-}
-
-// src/core/config/preset-mapper.ts
-function mapPresetToConfig(options) {
-  const { preset, outputFormat, watermark, isMobile } = options;
-  if (!(preset in RESOLUTION_MAP)) {
-    return Promise.reject(new Error(`Invalid preset: ${preset}`));
-  }
-  let isMobileDeviceDetected = isMobile;
-  if (isMobileDeviceDetected === undefined) {
-    isMobileDeviceDetected = isMobileDevice();
-  }
-  let resolutionMap = RESOLUTION_MAP;
-  if (isMobileDeviceDetected) {
-    resolutionMap = MOBILE_RESOLUTION_MAP;
-  }
-  const { width, height } = resolutionMap[preset];
-  let format = outputFormat;
-  if (format === undefined) {
-    format = "mp4";
-  }
-  let isLinuxPlatformDetected = options.isLinuxPlatform;
-  if (isLinuxPlatformDetected === undefined) {
-    isLinuxPlatformDetected = isLinuxPlatform();
+  let isLinuxPlatformDetected = options.isLinuxPlatform;
+  if (isLinuxPlatformDetected === undefined) {
+    isLinuxPlatformDetected = isLinuxPlatform();
   }
   const policy = getFormatCompatibilityPolicy(format, {
     isLinuxPlatform: isLinuxPlatformDetected
@@ -645,6 +1031,9 @@ class ConfigService {
           preset: data.presetEncoding,
           outputFormat: data.outputFormat,
           watermark: data.watermark
+        }).then((config) => {
+          config.audioRecording = parseAudioRecordingConfig(data.audio);
+          return config;
         });
       });
     });
@@ -927,7 +1316,11 @@ function createPermissionRecoveryData(errorCode, browserInfo, language = "en") {
 }
 
 // src/core/device/permission-flow-orchestrator.ts
-var GRANTED_PERMISSION_COUNT = 2;
+var VIDEO_PERMISSION_NAMES = [
+  "camera",
+  "microphone"
+];
+var AUDIO_PERMISSION_NAMES = ["microphone"];
 var DEFAULT_PERMISSION_STATUS = {
   camera: "unknown",
   microphone: "unknown"
@@ -948,7 +1341,7 @@ function stopStreamTracks(stream) {
     track.stop();
   }
 }
-async function requestPermissionProbe() {
+async function requestPermissionProbe(mediaType = "video") {
   const mediaDevices = globalThis.navigator?.mediaDevices;
   if (!mediaDevices) {
     return;
@@ -957,6 +1350,14 @@ async function requestPermissionProbe() {
   if (!canGetUserMedia) {
     return;
   }
+  if (mediaType === "audio") {
+    const audioStream = await mediaDevices.getUserMedia({
+      audio: true,
+      video: false
+    });
+    stopStreamTracks(audioStream);
+    return;
+  }
   const stream = await mediaDevices.getUserMedia({ audio: true, video: true });
   stopStreamTracks(stream);
   await mediaDevices.getUserMedia({
@@ -967,45 +1368,14 @@ async function requestPermissionProbe() {
     return;
   }).catch(noOperation2);
 }
-function countGrantedPermissions(permissions) {
-  let grantedCount = 0;
-  if (permissions.camera === "granted") {
-    grantedCount += 1;
-  }
-  if (permissions.microphone === "granted") {
-    grantedCount += 1;
-  }
-  return grantedCount;
-}
-function hasUnknownPermissionState(permissions) {
-  if (permissions.camera === "unknown") {
-    return true;
-  }
-  if (permissions.microphone === "unknown") {
-    return true;
-  }
-  return false;
-}
-function hasPromptPermissionState(permissions) {
-  if (permissions.camera === "prompt") {
-    return true;
-  }
-  if (permissions.microphone === "prompt") {
-    return true;
-  }
-  return false;
+function hasPermissionState(permissions, permissionNames, state) {
+  return permissionNames.some((name) => permissions[name] === state);
 }
-function hasHardPermissionDenial(permissions) {
-  if (permissions.camera === "denied") {
-    return true;
-  }
-  if (permissions.microphone === "denied") {
-    return true;
-  }
-  return false;
+function areAllPermissionsGranted(permissions, permissionNames) {
+  return permissionNames.every((name) => permissions[name] === "granted");
 }
-function getPermissionDeniedIssueCode(permissions) {
-  const hasCameraDenied = permissions.camera === "denied";
+function getPermissionDeniedIssueCode(permissions, permissionNames) {
+  const hasCameraDenied = permissionNames.includes("camera") && permissions.camera === "denied";
   const hasMicrophoneDenied = permissions.microphone === "denied";
   if (hasCameraDenied && hasMicrophoneDenied) {
     return "permission-denied-both";
@@ -1036,6 +1406,8 @@ class PermissionFlowOrchestrator {
   dependencies;
   callbacks;
   language;
+  mediaType;
+  permissionNames;
   currentState;
   cleanupCameraListener = noOperation2;
   cleanupMicrophoneListener = noOperation2;
@@ -1053,6 +1425,12 @@ class PermissionFlowOrchestrator {
       language = "es";
     }
     this.language = language;
+    let mediaType = "video";
+    if (options.mediaType === "audio") {
+      mediaType = "audio";
+    }
+    this.mediaType = mediaType;
+    this.permissionNames = mediaType === "audio" ? AUDIO_PERMISSION_NAMES : VIDEO_PERMISSION_NAMES;
     this.currentState = {
       step: "idle",
       permissions: DEFAULT_PERMISSION_STATUS,
@@ -1107,9 +1485,9 @@ class PermissionFlowOrchestrator {
     return this.currentState;
   }
   requestPermissionAndRefresh() {
-    return this.dependencies.requestPermissionProbe().then(() => {
+    return this.dependencies.requestPermissionProbe(this.mediaType).then(() => {
       const grantedPermissions = {
-        camera: "granted",
+        camera: this.mediaType === "audio" ? this.currentState.permissions.camera : "granted",
         microphone: "granted"
       };
       this.currentState = this.createStateFromPermissions(grantedPermissions);
@@ -1169,8 +1547,7 @@ class PermissionFlowOrchestrator {
     if (!isSecureContext) {
       return this.createInsecureContextState();
     }
-    const grantedCount = countGrantedPermissions(permissions);
-    if (grantedCount === GRANTED_PERMISSION_COUNT) {
+    if (areAllPermissionsGranted(permissions, this.permissionNames)) {
       return {
         step: "ready",
         permissions,
@@ -1181,8 +1558,8 @@ class PermissionFlowOrchestrator {
         shouldProbeUnknown: false
       };
     }
-    if (hasHardPermissionDenial(permissions)) {
-      const issueCode = getPermissionDeniedIssueCode(permissions);
+    if (hasPermissionState(permissions, this.permissionNames, "denied")) {
+      const issueCode = getPermissionDeniedIssueCode(permissions, this.permissionNames);
       const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
       return {
         step: "blocked",
@@ -1196,8 +1573,8 @@ class PermissionFlowOrchestrator {
         shouldProbeUnknown: false
       };
     }
-    const shouldProbeUnknown = hasUnknownPermissionState(permissions);
-    const hasPromptState = hasPromptPermissionState(permissions);
+    const shouldProbeUnknown = hasPermissionState(permissions, this.permissionNames, "unknown");
+    const hasPromptState = hasPermissionState(permissions, this.permissionNames, "prompt");
     let canRetry = false;
     if (shouldProbeUnknown) {
       canRetry = true;
@@ -1216,7 +1593,7 @@ class PermissionFlowOrchestrator {
     };
   }
   transitionToBlockedFromFailedProbe() {
-    const issueCode = "permission-denied-both";
+    const issueCode = this.mediaType === "audio" ? "permission-denied-microphone" : "permission-denied-both";
     const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
     this.currentState = {
       step: "blocked",
@@ -1273,11 +1650,11 @@ class PermissionFlowOrchestrator {
   }
 }
 // src/core/utils/video-utils.ts
-import { BlobSource, Input, MP4 } from "mediabunny";
+import { BlobSource as BlobSource2, Input as Input2, MP4 } from "mediabunny";
 async function extractVideoDuration(file) {
   try {
-    const source = new BlobSource(file);
-    const input = new Input({
+    const source = new BlobSource2(file);
+    const input = new Input2({
       formats: [MP4],
       source
     });
@@ -1656,6 +2033,48 @@ function decideRecordingRoute(options) {
     }
   };
 }
+var UNSUPPORTED_AUDIO_GUIDANCE_MESSAGE = "Audio recording is not supported in this browser context. Use a secure connection and a current Chrome, Edge, Firefox or Safari browser.";
+function detectAudioRecordingCapabilities() {
+  const hasWindow = typeof window !== "undefined";
+  return {
+    isSecureContext: hasWindow && window.isSecureContext === true,
+    hasAudioEncoder: typeof AudioEncoder !== "undefined",
+    hasAudioWorklet: typeof AudioWorkletNode !== "undefined" && hasWindow && typeof window.AudioContext !== "undefined",
+    hasMediaRecorder: typeof MediaRecorder !== "undefined"
+  };
+}
+function decideAudioRecordingRoute(capabilities) {
+  if (!capabilities.isSecureContext) {
+    return {
+      route: "unsupported-with-guidance",
+      reasonCodes: ["insecure-context"],
+      guidance: {
+        canRetry: true,
+        message: UNSUPPORTED_AUDIO_GUIDANCE_MESSAGE
+      }
+    };
+  }
+  if (capabilities.hasAudioEncoder && capabilities.hasAudioWorklet) {
+    return {
+      route: "local-webcodecs",
+      reasonCodes: ["webcodecs-supported", "target-codec-supported"]
+    };
+  }
+  if (capabilities.hasMediaRecorder) {
+    return {
+      route: "safe-capture-post-recording-transcode",
+      reasonCodes: ["webcodecs-unavailable", "mediarecorder-supported"]
+    };
+  }
+  return {
+    route: "unsupported-with-guidance",
+    reasonCodes: ["webcodecs-unavailable", "mediarecorder-unavailable"],
+    guidance: {
+      canRetry: true,
+      message: UNSUPPORTED_AUDIO_GUIDANCE_MESSAGE
+    }
+  };
+}
 
 // src/core/storage/video-storage.ts
 var DB_NAME = "vidtreo-recorder";
@@ -1675,6 +2094,12 @@ var ERROR_BLOB_READ_FAILED = "Failed to prepare upload data for storage. The rec
 var PROBE_RECORD_ID = "__probe__";
 var PROBE_DATA = new ArrayBuffer(1);
 var ERROR_PROBE_WRITE_FAILED = "Storage write probe failed. Browser may be in private browsing mode or IndexedDB writes are restricted.";
+function resolveMediaType(mediaType) {
+  if (mediaType === "audio") {
+    return "audio";
+  }
+  return "video";
+}
 
 class VideoStorageService {
   db = null;
@@ -1821,6 +2246,7 @@ class VideoStorageService {
     const now = Date.now();
     const pendingUpload = {
       ...upload,
+      mediaType: resolveMediaType(upload.mediaType),
       id,
       status: "pending",
       retryCount: 0,
@@ -1935,14 +2361,16 @@ class VideoStorageService {
     return uploads.reduce((total, upload) => total + upload.blob.size, 0);
   }
   hydrateUpload(upload) {
+    const mediaType = resolveMediaType(upload.mediaType);
     if ("blobData" in upload && upload.blobData) {
       const { blobData, blobType, ...rest } = upload;
       return {
         ...rest,
+        mediaType,
         blob: new Blob([blobData], { type: blobType })
       };
     }
-    return upload;
+    return { ...upload, mediaType };
   }
   async createStoredUpdates(updates) {
     const storedUpdates = { ...updates };
@@ -2007,17 +2435,17 @@ class VideoStorageService {
 
 // src/core/transcode/video-transcoder.ts
 import {
-  ALL_FORMATS,
-  BlobSource as BlobSource2,
-  BufferTarget,
-  Conversion,
+  ALL_FORMATS as ALL_FORMATS2,
+  BlobSource as BlobSource3,
+  BufferTarget as BufferTarget2,
+  Conversion as Conversion2,
   FilePathSource,
-  Input as Input2,
+  Input as Input3,
   MkvOutputFormat,
   MovOutputFormat,
-  Mp4OutputFormat,
-  Output,
-  WebMOutputFormat
+  Mp4OutputFormat as Mp4OutputFormat2,
+  Output as Output2,
+  WebMOutputFormat as WebMOutputFormat2
 } from "mediabunny";
 
 // src/core/processor/codec-policy-resolver.ts
@@ -2263,16 +2691,16 @@ function createSource(input) {
     return new FilePathSource(input);
   }
   if (input instanceof Blob) {
-    return new BlobSource2(input);
+    return new BlobSource3(input);
   }
   throw new Error("Invalid input type. Expected Blob, File, or file path string.");
 }
 function createOutputFormat(format) {
   switch (format) {
     case "mp4":
-      return new Mp4OutputFormat;
+      return new Mp4OutputFormat2;
     case "webm":
-      return new WebMOutputFormat;
+      return new WebMOutputFormat2;
     case "mkv":
       return new MkvOutputFormat;
     case "mov":
@@ -2362,16 +2790,16 @@ async function transcodeVideo(input, config = {}, onProgress, maximumDurationSec
     height: finalConfig.height,
     bitrate: finalConfig.bitrate
   });
-  const mediabunnyInput = new Input2({
-    formats: ALL_FORMATS,
+  const mediabunnyInput = new Input3({
+    formats: ALL_FORMATS2,
     source
   });
   const outputFormat = createOutputFormat(finalConfig.format);
-  const output = new Output({
+  const output = new Output2({
     format: outputFormat,
-    target: new BufferTarget
+    target: new BufferTarget2
   });
-  const conversion = await Conversion.init({
+  const conversion = await Conversion2.init({
     input: mediabunnyInput,
     output,
     trim: await resolveTrim(mediabunnyInput, maximumDurationSeconds),
@@ -2437,17 +2865,17 @@ async function transcodeVideoForNativeCamera(file, config = {}, onProgress) {
     height: finalConfig.height,
     bitrate: finalConfig.bitrate
   });
-  const source = new BlobSource2(file);
-  const mediabunnyInput = new Input2({
-    formats: ALL_FORMATS,
+  const source = new BlobSource3(file);
+  const mediabunnyInput = new Input3({
+    formats: ALL_FORMATS2,
     source
   });
   const outputFormat = createOutputFormat(finalConfig.format);
-  const output = new Output({
+  const output = new Output2({
     format: outputFormat,
-    target: new BufferTarget
+    target: new BufferTarget2
   });
-  const conversion = await Conversion.init({
+  const conversion = await Conversion2.init({
     input: mediabunnyInput,
     output,
     video: {
@@ -2480,12 +2908,17 @@ async function transcodeVideoForNativeCamera(file, config = {}, onProgress) {
 }
 
 // src/core/upload/recording-upload-result.ts
-function createRecordingUploadResult(result) {
-  return {
+function createRecordingUploadResult(result, mediaType = "video") {
+  const recordingUploadResult = {
     ...result,
     recordingId: result.id,
     uploadUrl: result.uploadUrl ?? ""
   };
+  if (mediaType === "audio") {
+    recordingUploadResult.mediaType = "audio";
+    recordingUploadResult.audioId = result.id;
+  }
+  return recordingUploadResult;
 }
 
 // src/core/upload/upload-error.ts
@@ -2724,6 +3157,8 @@ class UploadQueueManager {
         duration: upload.duration,
         metadata: upload.metadata,
         userMetadata: upload.userMetadata,
+        mediaType: upload.mediaType,
+        audio: upload.audio,
         isResume: this.isResumedUpload(upload),
         onProgress: (progress) => {
           this.reportUploadProgress(upload.id, progress);
@@ -2740,7 +3175,7 @@ class UploadQueueManager {
       } else {
         throw new Error("Upload credentials are unavailable for recovery");
       }
-      const result = createRecordingUploadResult(await this.uploadService.uploadVideo(upload.blob, uploadOptions));
+      const result = createRecordingUploadResult(await this.uploadService.uploadVideo(upload.blob, uploadOptions), upload.mediaType);
       this.callbacks.onUploadAttemptSucceeded?.(upload.id, {
         attempt,
         maxAttempts: MAX_RETRIES2,
@@ -3596,6 +4031,7 @@ function revokeProbeWorkerUrl(workerUrl) {
 }
 
 // src/core/processor/worker/types.ts
+var WORKER_MESSAGE_TYPE_START_AUDIO = "startAudio";
 var WORKER_MESSAGE_TYPE_PROBE = "probe";
 var WORKER_MESSAGE_TYPE_WARMUP = "warmup";
 var WORKER_MESSAGE_TYPE_AUDIO_CHUNK = "audioChunk";
@@ -4035,6 +4471,56 @@ class StorageManager {
   }
 }
 
+// src/core/stream/constraints-builder.ts
+function buildVideoConstraints(cameraDeviceId, dependencies) {
+  let constraints = {};
+  if (dependencies.originalCameraConstraints) {
+    const { deviceId: _deviceId, ...originalConstraintsWithoutDeviceId } = dependencies.originalCameraConstraints;
+    constraints = {
+      ...constraints,
+      ...originalConstraintsWithoutDeviceId
+    };
+  }
+  if (cameraDeviceId) {
+    constraints = { ...constraints, deviceId: { exact: cameraDeviceId } };
+  }
+  const selectedDeviceId = dependencies.getSelectedCameraDeviceId();
+  let hasDeviceId = false;
+  if (cameraDeviceId) {
+    hasDeviceId = true;
+  }
+  if (constraints.deviceId) {
+    hasDeviceId = true;
+  }
+  if (!hasDeviceId && selectedDeviceId) {
+    constraints = { ...constraints, deviceId: { exact: selectedDeviceId } };
+  }
+  return constraints;
+}
+function buildAudioConstraints(micDeviceId) {
+  const constraints = {
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true
+  };
+  if (micDeviceId) {
+    return { ...constraints, deviceId: { exact: micDeviceId } };
+  }
+  return constraints;
+}
+function buildAudioRecordingConstraints(config, micDeviceId) {
+  const constraints = {
+    echoCancellation: config.echoCancellation,
+    noiseSuppression: config.noiseSuppression,
+    autoGainControl: config.autoGain,
+    channelCount: { ideal: config.channels }
+  };
+  if (micDeviceId) {
+    return { ...constraints, deviceId: { exact: micDeviceId } };
+  }
+  return constraints;
+}
+
 // src/core/utils/logger.ts
 function isDebugEnabled() {
   const globalAny = globalThis;
@@ -4196,44 +4682,6 @@ function requireMediaDevices() {
   return navigator.mediaDevices;
 }
 
-// src/core/stream/constraints-builder.ts
-function buildVideoConstraints(cameraDeviceId, dependencies) {
-  let constraints = {};
-  if (dependencies.originalCameraConstraints) {
-    const { deviceId: _deviceId, ...originalConstraintsWithoutDeviceId } = dependencies.originalCameraConstraints;
-    constraints = {
-      ...constraints,
-      ...originalConstraintsWithoutDeviceId
-    };
-  }
-  if (cameraDeviceId) {
-    constraints = { ...constraints, deviceId: { exact: cameraDeviceId } };
-  }
-  const selectedDeviceId = dependencies.getSelectedCameraDeviceId();
-  let hasDeviceId = false;
-  if (cameraDeviceId) {
-    hasDeviceId = true;
-  }
-  if (constraints.deviceId) {
-    hasDeviceId = true;
-  }
-  if (!hasDeviceId && selectedDeviceId) {
-    constraints = { ...constraints, deviceId: { exact: selectedDeviceId } };
-  }
-  return constraints;
-}
-function buildAudioConstraints(micDeviceId) {
-  const constraints = {
-    echoCancellation: true,
-    noiseSuppression: true,
-    autoGainControl: true
-  };
-  if (micDeviceId) {
-    return { ...constraints, deviceId: { exact: micDeviceId } };
-  }
-  return constraints;
-}
-
 // src/core/stream/stream-utils.ts
 var TRACK_READY_STATE_LIVE = "live";
 function stopLiveTracks(tracks) {
@@ -5735,6 +6183,9 @@ class SourceSwitchManager {
     if (sourceType === this.currentSourceType) {
       return;
     }
+    if (sourceType === "audio" || this.currentSourceType === "audio") {
+      throw createAudioRecordingError(ERROR_AUDIO_SOURCE_SWITCH_UNSUPPORTED, "Switching between audio and video sources is not supported");
+    }
     await this.resolveSwitch(sourceType).catch((error) => {
       this.handleToggleError(error);
     });
@@ -5751,6 +6202,15 @@ class SourceSwitchManager {
     }
     return this.switchToScreen();
   }
+  async startAudioOnly(audioConstraints) {
+    this.cleanup();
+    const stream = await this.streamManager.startAudioOnlyStream(audioConstraints);
+    this.currentSourceType = "audio";
+    if (this.callbacks.onSourceChange) {
+      await this.callbacks.onSourceChange(this.currentSourceType);
+    }
+    return stream;
+  }
   async startScreenOnly() {
     const displayStream = await this.requestDisplayStream();
     if (!displayStream) {
@@ -6526,6 +6986,29 @@ class StreamManager {
     this.emit("streamstart", { stream });
     return stream;
   }
+  async startAudioOnlyStream(audioConstraints) {
+    if (this.mediaStream) {
+      this.stopStream();
+    }
+    this.setState("starting");
+    this.setAudioStatus("pending");
+    this.pendingAudioError = null;
+    this.acquisitionGeneration++;
+    const audioTrack = await this.acquireAudioTrackWithRetry(requireMediaDevices(), audioConstraints).catch((error) => {
+      const audioError = error instanceof Error && "code" in error ? error : createAudioStreamError(error);
+      this.pendingAudioError = audioError;
+      this.setAudioStatus("failed");
+      this.setState("error");
+      this.emit("error", { error: audioError });
+      throw audioError;
+    });
+    const stream = new MediaStream([audioTrack]);
+    this.mediaStream = stream;
+    this.setAudioStatus("acquired");
+    this.setState("active");
+    this.emit("streamstart", { stream });
+    return stream;
+  }
   async acquireVideoAndAudioStream() {
     const mediaDevices = requireMediaDevices();
     const videoConstraints = this.buildVideoConstraints(this.selectedVideoDeviceId);
@@ -6807,8 +7290,8 @@ class StreamManager {
   switchVideoDevice(deviceId) {
     return this.switchDeviceTrack(deviceId, "video", this.streamConfig.video);
   }
-  switchAudioDevice(deviceId) {
-    return this.switchDeviceTrack(deviceId, "audio", this.streamConfig.audio);
+  switchAudioDevice(deviceId, audioConstraints = this.streamConfig.audio) {
+    return this.switchDeviceTrack(deviceId, "audio", audioConstraints);
   }
   setMediaStream(stream) {
     this.mediaStream = stream;
@@ -6967,21 +7450,113 @@ class SystemAudioMixer {
   }
 }
 
-// src/core/recording/recording-lifecycle-error.ts
-var ERROR_RECORDING_STOP_NOT_READY = "recording.stop-not-ready";
-var ERROR_RECORDING_FINALIZE_NOT_READY = "recording.finalize-not-ready";
-var ERROR_RECORDING_FINALIZE_TIMEOUT = "recording.finalize-timeout";
-var ERROR_RECORDING_UPLOAD_IN_PROGRESS = "recording.upload-in-progress";
-function createRecordingLifecycleError(code, message, details) {
-  const error = new Error(`${message} [${code}]`);
-  error.code = code;
-  error.isRecoverable = true;
-  if (details !== undefined) {
-    error.details = details;
+// src/core/audio-recording/audio-normalizer.ts
+var COMPRESSOR_THRESHOLD_DB = -24;
+var COMPRESSOR_KNEE_DB = 12;
+var COMPRESSOR_RATIO = 4;
+var COMPRESSOR_ATTACK_SECONDS = 0.003;
+var COMPRESSOR_RELEASE_SECONDS = 0.25;
+var MAKEUP_GAIN = 2;
+var LIMITER_THRESHOLD_DB = -1;
+var LIMITER_KNEE_DB = 0;
+var LIMITER_RATIO = 20;
+var LIMITER_ATTACK_SECONDS = 0.001;
+var LIMITER_RELEASE_SECONDS = 0.05;
+var DEFAULT_DEPENDENCIES2 = {
+  createAudioContext: () => {
+    const AudioContextClass = getAudioContextClass();
+    if (!AudioContextClass) {
+      return null;
+    }
+    return new AudioContextClass;
   }
-  return error;
-}
-function normalizeRecordingLifecycleError(error) {
+};
+
+class AudioNormalizer {
+  audioContext = null;
+  source = null;
+  destination = null;
+  dependencies;
+  constructor(dependencies = {}) {
+    this.dependencies = { ...DEFAULT_DEPENDENCIES2, ...dependencies };
+  }
+  start(track) {
+    const audioContext = this.dependencies.createAudioContext();
+    if (!audioContext) {
+      return null;
+    }
+    const compressor = audioContext.createDynamicsCompressor();
+    compressor.threshold.value = COMPRESSOR_THRESHOLD_DB;
+    compressor.knee.value = COMPRESSOR_KNEE_DB;
+    compressor.ratio.value = COMPRESSOR_RATIO;
+    compressor.attack.value = COMPRESSOR_ATTACK_SECONDS;
+    compressor.release.value = COMPRESSOR_RELEASE_SECONDS;
+    const makeupGain = audioContext.createGain();
+    makeupGain.gain.value = MAKEUP_GAIN;
+    const limiter = audioContext.createDynamicsCompressor();
+    limiter.threshold.value = LIMITER_THRESHOLD_DB;
+    limiter.knee.value = LIMITER_KNEE_DB;
+    limiter.ratio.value = LIMITER_RATIO;
+    limiter.attack.value = LIMITER_ATTACK_SECONDS;
+    limiter.release.value = LIMITER_RELEASE_SECONDS;
+    const source = audioContext.createMediaStreamSource(new MediaStream([track]));
+    const destination = audioContext.createMediaStreamDestination();
+    source.connect(compressor);
+    compressor.connect(makeupGain);
+    makeupGain.connect(limiter);
+    limiter.connect(destination);
+    this.audioContext = audioContext;
+    this.source = source;
+    this.destination = destination;
+    audioContext.resume().catch((error) => {
+      logger.warn("[AudioNormalizer] Failed to resume AudioContext", {
+        error: extractErrorMessage(error)
+      });
+    });
+    const outputTrack = destination.stream.getAudioTracks()[0];
+    if (!outputTrack) {
+      this.close();
+      return null;
+    }
+    return outputTrack;
+  }
+  close() {
+    this.source?.disconnect();
+    this.source = null;
+    if (this.destination) {
+      for (const track of this.destination.stream.getAudioTracks()) {
+        track.stop();
+      }
+      this.destination = null;
+    }
+    const audioContext = this.audioContext;
+    this.audioContext = null;
+    if (!audioContext) {
+      return;
+    }
+    audioContext.close().catch((error) => {
+      logger.warn("[AudioNormalizer] Failed to close AudioContext", {
+        error: extractErrorMessage(error)
+      });
+    });
+  }
+}
+
+// src/core/recording/recording-lifecycle-error.ts
+var ERROR_RECORDING_STOP_NOT_READY = "recording.stop-not-ready";
+var ERROR_RECORDING_FINALIZE_NOT_READY = "recording.finalize-not-ready";
+var ERROR_RECORDING_FINALIZE_TIMEOUT = "recording.finalize-timeout";
+var ERROR_RECORDING_UPLOAD_IN_PROGRESS = "recording.upload-in-progress";
+function createRecordingLifecycleError(code, message, details) {
+  const error = new Error(`${message} [${code}]`);
+  error.code = code;
+  error.isRecoverable = true;
+  if (details !== undefined) {
+    error.details = details;
+  }
+  return error;
+}
+function normalizeRecordingLifecycleError(error) {
   if (!(error instanceof Error)) {
     return error;
   }
@@ -7201,7 +7776,8 @@ function createUnsupportedRouteError(routeDecision) {
 var DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES = {
   checkRecorderSupport,
   getCurrentTimestamp: () => performance.now(),
-  createAudioMixer: () => new SystemAudioMixer
+  createAudioMixer: () => new SystemAudioMixer,
+  createAudioNormalizer: () => new AudioNormalizer
 };
 function isLiveTrack(track) {
   return !!track && track.readyState === "live";
@@ -7236,6 +7812,8 @@ class StreamRecordingState {
   isSystemAudioCaptureEnabled = false;
   systemAudioTrack = null;
   audioMixer = null;
+  audioNormalizer = null;
+  isAudioOnlyRecording = false;
   streamManager;
   dependencies;
   constructor(streamManager, dependencies) {
@@ -7257,7 +7835,8 @@ class StreamRecordingState {
     this.dependencies = {
       checkRecorderSupport: resolvedCheckRecorderSupportDependency,
       getCurrentTimestamp: resolvedGetCurrentTimestampDependency,
-      createAudioMixer: dependencies?.createAudioMixer ?? DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES.createAudioMixer
+      createAudioMixer: dependencies?.createAudioMixer ?? DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES.createAudioMixer,
+      createAudioNormalizer: dependencies?.createAudioNormalizer ?? DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES.createAudioNormalizer
     };
   }
   setPreResolvedSupportReport(report) {
@@ -7328,7 +7907,8 @@ class StreamRecordingState {
     if (this.activeRouteDecision.route === "unsupported-with-guidance") {
       throw createUnsupportedRouteError(this.activeRouteDecision);
     }
-    if (this.activeRouteDecision.route === "local-webcodecs") {
+    this.isAudioOnlyRecording = config.mediaType === "audio";
+    if (this.activeRouteDecision.route === "local-webcodecs" && !this.isAudioOnlyRecording) {
       const requiresWatermark = config.watermark !== undefined;
       let supportReport;
       if (this.preResolvedSupportReport?.isSupported) {
@@ -7380,13 +7960,14 @@ class StreamRecordingState {
       overlayConfig
     });
     if (this.activeRouteDecision.route === "safe-capture-post-recording-transcode") {
-      await this.startSafeCaptureRecording(mediaStream, config);
+      await this.startSafeCaptureRecording(this.buildNormalizedStream(mediaStream, config), config);
       logger.info("[StreamRecordingState] MediaRecorder capture started for post-recording transcode");
     } else {
       logger.debug("[StreamRecordingState] Starting processing");
-      const recordingStream = this.buildRecordingStream(mediaStream, processor);
+      const recordingStream = this.isAudioOnlyRecording ? this.buildNormalizedStream(mediaStream, config) : this.buildRecordingStream(mediaStream, processor);
       await processor.startProcessing(recordingStream, config, overlayConfig).catch((error) => {
         this.releaseAudioMixer();
+        this.releaseAudioNormalizer();
         throw error;
       });
       logger.info("[StreamRecordingState] Processing started and worker ready");
@@ -7444,9 +8025,13 @@ class StreamRecordingState {
         expectedDurationSeconds: safeCaptureResult.expectedDurationSeconds,
         mediaRecorderDiagnostics: safeCaptureResult.diagnostics
       };
+      this.releaseAudioNormalizer();
     } else {
       logger.debug("[StreamRecordingState] Finalizing stream processor");
-      result = await this.streamProcessor.finalize().finally(() => this.releaseAudioMixer());
+      result = await this.streamProcessor.finalize().finally(() => {
+        this.releaseAudioMixer();
+        this.releaseAudioNormalizer();
+      });
       logger.info("[StreamRecordingState] Stream processor finalized", {
         blobSize: result.blob.size,
         hasBlob: !!result.blob
@@ -7457,6 +8042,7 @@ class StreamRecordingState {
       blob: result.blob,
       mimeType: result.blob.type || "video/mp4"
     });
+    this.isAudioOnlyRecording = false;
     return {
       blob: result.blob,
       captureFrameRate: result.captureFrameRate,
@@ -7464,7 +8050,8 @@ class StreamRecordingState {
       tabVisibilityIntervals,
       recordingStats: result.recordingStats,
       encoderAcceleration: result.encoderAcceleration,
-      mediaRecorderDiagnostics: result.mediaRecorderDiagnostics
+      mediaRecorderDiagnostics: result.mediaRecorderDiagnostics,
+      audio: result.audio
     };
   }
   pauseRecording() {
@@ -7564,6 +8151,28 @@ class StreamRecordingState {
     });
     return new MediaStream([...mediaStream.getVideoTracks(), mixedTrack]);
   }
+  buildNormalizedStream(mediaStream, config) {
+    const microphone = mediaStream.getAudioTracks()[0];
+    const shouldNormalize = this.isAudioOnlyRecording && config.audioRecording?.normalize === true;
+    if (!(shouldNormalize && isLiveTrack(microphone))) {
+      return mediaStream;
+    }
+    const normalizer = this.dependencies.createAudioNormalizer();
+    const normalizedTrack = normalizer.start(microphone);
+    if (!normalizedTrack) {
+      logger.warn("[StreamRecordingState] Audio normalization unavailable, recording raw microphone");
+      return mediaStream;
+    }
+    this.audioNormalizer = normalizer;
+    return new MediaStream([normalizedTrack]);
+  }
+  releaseAudioNormalizer() {
+    if (!this.audioNormalizer) {
+      return;
+    }
+    this.audioNormalizer.close();
+    this.audioNormalizer = null;
+  }
   releaseAudioMixer() {
     if (!this.audioMixer) {
       return;
@@ -7831,6 +8440,15 @@ class StreamRecordingState {
       }
       return MediaRecorder.isTypeSupported(mimeType);
     };
+    if (this.isAudioOnlyRecording) {
+      return [
+        "audio/webm;codecs=opus",
+        "audio/mp4;codecs=mp4a.40.2",
+        "audio/mp4",
+        "audio/webm",
+        "audio/ogg;codecs=opus"
+      ].filter(canUseMimeType);
+    }
     const webmCandidateMimeTypes = [
       "video/webm;codecs=vp8,opus",
       "video/webm;codecs=vp9,opus",
@@ -8024,6 +8642,8 @@ class StreamRecordingState {
     this.clearMediaRecorderErrorTimeout();
     this.activeRouteDecision = DEFAULT_ROUTE_DECISION;
     this.releaseAudioMixer();
+    this.releaseAudioNormalizer();
+    this.isAudioOnlyRecording = false;
     if (this.streamProcessor) {
       this.streamProcessor.destroy();
       this.streamProcessor = null;
@@ -8091,14 +8711,17 @@ class CameraStreamManager {
   async startStreamWithVideoTrack(videoTrack) {
     return await this.streamManager.startStreamWithVideoTrack(videoTrack);
   }
+  async startAudioOnlyStream(audioConstraints) {
+    return await this.streamManager.startAudioOnlyStream(audioConstraints);
+  }
   stopStream() {
     this.streamManager.stopStream();
   }
   switchVideoDevice(deviceId) {
     return this.streamManager.switchVideoDevice(deviceId);
   }
-  async switchAudioDevice(deviceId) {
-    const stream = await this.streamManager.switchAudioDevice(deviceId);
+  async switchAudioDevice(deviceId, audioConstraints) {
+    const stream = await this.streamManager.switchAudioDevice(deviceId, audioConstraints);
     this.recordingState.updateMixedMicrophone(stream);
     return stream;
   }
@@ -8426,7 +9049,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.8.1",
+  version: "1.9.0",
   type: "module",
   description: "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   main: "./dist/index.js",
@@ -9995,6 +10618,8 @@ function easeToward(start, ceiling, elapsed, easingMs) {
 
 // src/core/upload/upload-service.ts
 var API_DIRECT_UPLOAD_PATH = "/api/v1/videos/uploads";
+var API_AUDIO_DIRECT_UPLOAD_PATH = "/api/v1/audios/uploads";
+var API_AUDIO_PATH = "/api/v1/audios";
 var TRAILING_SLASHES = /\/+$/;
 var MIME_TYPE_PARAMETER_SEPARATOR = ";";
 var MAX_TRANSFER_PROGRESS = 0.99;
@@ -10035,6 +10660,18 @@ var VIDEO_TRANSFER_STATUSES = new Set([
   "transferred",
   "failed"
 ]);
+var UPLOAD_RESOURCES = {
+  video: {
+    basePath: API_DIRECT_UPLOAD_PATH,
+    entityKey: "video",
+    idKey: "videoId"
+  },
+  audio: {
+    basePath: API_AUDIO_DIRECT_UPLOAD_PATH,
+    entityKey: "audio",
+    idKey: "audioId"
+  }
+};
 var UPLOAD_CANCELLED_CODE = "upload.cancelled";
 function createCancelledError() {
   return Object.assign(new Error("Upload was cancelled"), {
@@ -10075,6 +10712,9 @@ class VideoUploadService {
     if (options.duration !== undefined && (!Number.isFinite(options.duration) || options.duration <= 0)) {
       throw new Error("Duration must be a finite positive number");
     }
+    if (options.mediaType === "audio" && options.audio === undefined) {
+      throw new Error("Audio details are required for audio uploads");
+    }
     const filename = options.filename;
     const idempotencyKey = this.resolveIdempotencyKey(options.idempotencyKey);
     const mimeType = this.resolveUploadMimeType(blob, options.mimeType);
@@ -10092,7 +10732,7 @@ class VideoUploadService {
     return this.hashInitialParts(blob, hasher).then((checksums) => this.initiateUpload(blob, options, filename, idempotencyKey, mimeType, duration, checksums).then((initiation) => ({ initiation, checksums }))).then(({ initiation, checksums }) => {
       if (initiation.upload === null) {
         this.startFinalizing(reporter, blob.size);
-        return this.waitForTerminalUpload(options, initiation.video).then((result) => {
+        return this.waitForTerminalUpload(options, initiation.video).then((result) => this.uploadPeaksForResult(options, result)).then((result) => {
           this.reportCompletion(reporter, blob.size, blob.size);
           return result;
         });
@@ -10102,7 +10742,7 @@ class VideoUploadService {
       return this.transferToR2(blob, hasher, descriptor, options, reporter, checksums, initiation.authorizations).then((progress) => {
         assertNotCancelled(options.signal);
         this.startFinalizing(reporter, progress.totalBytes);
-        return this.confirmUpload(options, descriptor.videoId).then((result) => this.waitForTerminalUpload(options, result)).then((result) => {
+        return this.confirmUpload(options, descriptor.mediaId).then((result) => this.waitForTerminalUpload(options, result)).then((result) => this.uploadPeaksForResult(options, result)).then((result) => {
           this.reportCompletion(reporter, progress.loadedBytes, progress.totalBytes);
           return result;
         });
@@ -10122,13 +10762,19 @@ class VideoUploadService {
       mimeType,
       duration
     };
+    if (options.mediaType === "audio" && options.audio !== undefined) {
+      request.format = options.audio.format;
+      request.bitrate = options.audio.bitrate;
+      request.channels = options.audio.channels;
+      request.sampleRate = options.audio.sampleRate;
+    }
     if (options.userMetadata !== undefined) {
       request.userMetadata = options.userMetadata;
     }
     if (checksums.size > 0) {
       request.parts = this.buildPartManifests(checksums, [...checksums.keys()]);
     }
-    return this.requestAuthenticatedMetadata(options, this.buildBackendUrl(options.backendUrl, API_DIRECT_UPLOAD_PATH), {
+    return this.requestAuthenticatedMetadata(options, this.buildBackendUrl(options.backendUrl, this.resolveUploadResource(options).basePath), {
       method: "POST",
       credentials: "omit",
       headers: {
@@ -10136,7 +10782,7 @@ class VideoUploadService {
         "Idempotency-Key": idempotencyKey
       },
       body: JSON.stringify(request)
-    }, "Upload initiation").then((response) => this.parseInitiation(response, filename, blob.size, mimeType, checksums));
+    }, "Upload initiation").then((response) => this.parseInitiation(response, this.resolveUploadResource(options), filename, blob.size, mimeType, checksums));
   }
   transferToR2(blob, hasher, descriptor, options, reporter, checksums, authorizations) {
     if (descriptor.partSize !== calculateDirectUploadPartSize(blob.size)) {
@@ -10305,7 +10951,7 @@ class VideoUploadService {
     for (const partNumber of partNumbers) {
       session.signingParts.add(partNumber);
     }
-    const request = session.signing.then(() => this.hashParts(session.hasher, session.blob, session.descriptor.partSize, partNumbers, session.checksums)).then((checksums) => this.authorizeParts(session.options, session.descriptor.videoId, this.buildPartManifests(checksums, partNumbers))).then((authorizations) => {
+    const request = session.signing.then(() => this.hashParts(session.hasher, session.blob, session.descriptor.partSize, partNumbers, session.checksums)).then((checksums) => this.authorizeParts(session.options, session.descriptor.mediaId, this.buildPartManifests(checksums, partNumbers))).then((authorizations) => {
       for (const authorization of authorizations.values()) {
         session.authorizations.set(authorization.partNumber, authorization);
       }
@@ -10326,8 +10972,8 @@ class VideoUploadService {
   isAuthorizationFresh(authorization) {
     return Date.parse(authorization.expiresAt) - Date.now() > AUTHORIZATION_REFRESH_MARGIN_MS;
   }
-  authorizeParts(options, videoId, manifests) {
-    const path = `${API_DIRECT_UPLOAD_PATH}/${encodeURIComponent(videoId)}/parts`;
+  authorizeParts(options, mediaId, manifests) {
+    const path = `${this.resolveUploadResource(options).basePath}/${encodeURIComponent(mediaId)}/parts`;
     return this.requestAuthenticatedMetadata(options, this.buildBackendUrl(options.backendUrl, path), {
       method: "POST",
       credentials: "omit",
@@ -10474,15 +11120,15 @@ class VideoUploadService {
     const start = (partNumber - 1) * partSize;
     return blob.slice(start, Math.min(start + partSize, blob.size));
   }
-  confirmUpload(options, videoId) {
-    const path = `${API_DIRECT_UPLOAD_PATH}/${encodeURIComponent(videoId)}/confirm`;
+  confirmUpload(options, mediaId) {
+    const path = `${this.resolveUploadResource(options).basePath}/${encodeURIComponent(mediaId)}/confirm`;
     return this.requestAuthenticatedMetadata(options, this.buildBackendUrl(options.backendUrl, path), {
       method: "POST",
       credentials: "omit"
     }, "Upload confirmation").then((response) => this.parseVideoEnvelope(response));
   }
-  getUploadStatus(options, videoId) {
-    const path = `${API_DIRECT_UPLOAD_PATH}/${encodeURIComponent(videoId)}`;
+  getUploadStatus(options, mediaId) {
+    const path = `${this.resolveUploadResource(options).basePath}/${encodeURIComponent(mediaId)}`;
     return this.requestAuthenticatedMetadata(options, this.buildBackendUrl(options.backendUrl, path), {
       method: "GET",
       credentials: "omit"
@@ -10501,6 +11147,45 @@ class VideoUploadService {
     const nextDelay = Math.min(delay * STATUS_POLL_BACKOFF_FACTOR, STATUS_POLL_MAX_DELAY_MS);
     return this.waitForStatusPoll(delay).then(() => this.getUploadStatus(options, result.id)).then((nextResult) => this.waitForTerminalUpload(options, nextResult, deadline, nextDelay));
   }
+  resolveUploadResource(options) {
+    if (options.mediaType === "audio") {
+      return UPLOAD_RESOURCES.audio;
+    }
+    return UPLOAD_RESOURCES.video;
+  }
+  uploadPeaksForResult(options, result) {
+    const peaks = options.audio?.peaks;
+    if (options.mediaType !== "audio" || !peaks) {
+      return Promise.resolve(result);
+    }
+    return this.uploadAudioPeaks(options, result.id, peaks).then(() => result, (error) => {
+      logger.warn("[VideoUploadService] Audio peaks upload failed", {
+        audioId: result.id,
+        error: extractErrorMessage(error)
+      });
+      return result;
+    });
+  }
+  uploadAudioPeaks(options, audioId, peaks, hasRetriedAuthentication = false) {
+    const path = `${API_AUDIO_PATH}/${encodeURIComponent(audioId)}/peaks`;
+    return this.resolveAuthorization(options).then((authorization) => this.requestMetadataResponse(this.buildBackendUrl(options.backendUrl, path), {
+      method: "PUT",
+      credentials: "omit",
+      headers: {
+        Authorization: authorization,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(peaks)
+    }, "Audio peaks upload")).then((response) => {
+      if (response.ok) {
+        return;
+      }
+      if (response.status === 401 && options.getAccessToken !== undefined && !hasRetriedAuthentication) {
+        return this.uploadAudioPeaks(options, audioId, peaks, true);
+      }
+      throw new Error(`Audio peaks upload failed: ${response.status} ${response.statusText}`);
+    });
+  }
   waitForStatusPoll(delay) {
     return new Promise((resolve) => {
       window.setTimeout(resolve, delay);
@@ -10587,12 +11272,12 @@ class VideoUploadService {
       throw new Error(`${operation} response is invalid JSON`);
     });
   }
-  parseInitiation(response, expectedFilename, expectedFileSize, expectedMimeType, requestedChecksums) {
+  parseInitiation(response, resource, expectedFilename, expectedFileSize, expectedMimeType, requestedChecksums) {
     const data = response.data;
     if (!this.isRecord(data)) {
       throw new Error("Upload initiation response is missing data");
     }
-    const video = this.parseVideoResult(data.video, "Upload initiation");
+    const video = this.parseVideoResult(data[resource.entityKey], "Upload initiation");
     if (video.filename !== expectedFilename || video.fileSize !== expectedFileSize || video.mimeType !== expectedMimeType) {
       throw new Error("Upload initiation video does not match request");
     }
@@ -10602,8 +11287,8 @@ class VideoUploadService {
     if (!this.isRecord(data.upload)) {
       throw new Error("Upload initiation response has invalid authorization");
     }
-    const upload = this.parseDescriptor(data.upload, expectedFileSize);
-    if (upload.videoId !== video.id) {
+    const upload = this.parseDescriptor(data.upload, resource.idKey, expectedFileSize);
+    if (upload.mediaId !== video.id) {
       throw new Error("Upload authorization video does not match initiation");
     }
     if (data.upload.parts === undefined) {
@@ -10653,8 +11338,9 @@ class VideoUploadService {
   isOptionalTimestamp(value) {
     return value === undefined || value === null || typeof value === "string" && Number.isFinite(Date.parse(value));
   }
-  parseDescriptor(value, expectedFileSize) {
-    if (typeof value.videoId !== "string" || value.videoId.length === 0 || typeof value.partSize !== "number" || !Number.isSafeInteger(value.partSize) || value.partSize <= 0 || typeof value.partCount !== "number" || !Number.isSafeInteger(value.partCount) || value.partCount <= 0 || value.partCount > 1e4 || !Array.isArray(value.uploadedParts)) {
+  parseDescriptor(value, idKey, expectedFileSize) {
+    const mediaId = value[idKey];
+    if (typeof mediaId !== "string" || mediaId.length === 0 || typeof value.partSize !== "number" || !Number.isSafeInteger(value.partSize) || value.partSize <= 0 || typeof value.partCount !== "number" || !Number.isSafeInteger(value.partCount) || value.partCount <= 0 || value.partCount > 1e4 || !Array.isArray(value.uploadedParts)) {
       throw new Error("Upload initiation response has invalid authorization");
     }
     if (Math.ceil(expectedFileSize / value.partSize) !== value.partCount) {
@@ -10670,7 +11356,7 @@ class VideoUploadService {
       previousPart = partNumber;
     }
     return {
-      videoId: value.videoId,
+      mediaId,
       partSize: value.partSize,
       partCount: value.partCount,
       uploadedParts
@@ -10964,36 +11650,8 @@ function createSourceSwitchCallbacks(callbacks, dependencies) {
   };
 }
 
-// src/core/recording/recording-filename.ts
-var MAX_TITLE_LENGTH = 120;
-var CONTROL_CHARACTERS = /\p{Cc}/gu;
-var FORBIDDEN_CHARACTERS = /[/\\*?"<>|]/g;
-var WHITESPACE = /\s+/g;
-var LEADING_DOTS = /^[.\s]+/;
-function isHighSurrogate(code) {
-  return code >= 55296 && code <= 56319;
-}
-function truncateTitle(title) {
-  if (title.length <= MAX_TITLE_LENGTH) {
-    return title;
-  }
-  let truncated = title.slice(0, MAX_TITLE_LENGTH);
-  if (isHighSurrogate(truncated.charCodeAt(truncated.length - 1))) {
-    truncated = truncated.slice(0, -1);
-  }
-  return truncated.trimEnd();
-}
-function sanitizeRecordingTitle(title) {
-  const cleaned = title.replace(CONTROL_CHARACTERS, " ").replace(FORBIDDEN_CHARACTERS, "").replace(WHITESPACE, " ").replace(LEADING_DOTS, "").trim();
-  return truncateTitle(cleaned);
-}
-function createRecordingFilename(title, extension) {
-  const sanitized = title === null ? "" : sanitizeRecordingTitle(title);
-  if (sanitized === "") {
-    return `recording-${Date.now()}.${extension}`;
-  }
-  return `${sanitized}.${extension}`;
-}
+// src/core/processor/worker-processor.ts
+import { canEncodeAudio as canEncodeAudio2 } from "mediabunny";
 
 // src/core/audio/audio-health-monitor.ts
 var DEFAULT_SILENCE_THRESHOLD = 0.001;
@@ -11027,6 +11685,7 @@ class AudioHealthMonitor {
   mutedDurationMs = 0;
   currentMuted = false;
   hasHealthySignal = false;
+  pausedAtMs = null;
   constructor(options = {}) {
     this.silenceThreshold = this.resolveNumber(options.silenceThreshold, DEFAULT_SILENCE_THRESHOLD);
     this.lowSignalThreshold = this.resolveNumber(options.lowSignalThreshold, DEFAULT_LOW_SIGNAL_THRESHOLD);
@@ -11079,9 +11738,29 @@ class AudioHealthMonitor {
     return this.snapshot(input.timestampMs, input.isMuted);
   }
   inspect(timestampMs, isMuted) {
-    this.markStarted(timestampMs);
-    this.trackMuteState(timestampMs, isMuted);
-    return this.snapshot(timestampMs, isMuted);
+    const effectiveTimestampMs = this.pausedAtMs ?? timestampMs;
+    this.markStarted(effectiveTimestampMs);
+    this.trackMuteState(effectiveTimestampMs, isMuted);
+    return this.snapshot(effectiveTimestampMs, isMuted);
+  }
+  pause(timestampMs) {
+    if (this.pausedAtMs !== null) {
+      return;
+    }
+    this.pausedAtMs = timestampMs;
+  }
+  resume(timestampMs) {
+    if (this.pausedAtMs === null) {
+      return;
+    }
+    const pausedDurationMs = Math.max(0, timestampMs - this.pausedAtMs);
+    this.pausedAtMs = null;
+    this.startedAtMs = shiftTimestamp(this.startedAtMs, pausedDurationMs);
+    this.lastChunkTimestampMs = shiftTimestamp(this.lastChunkTimestampMs, pausedDurationMs);
+    this.silentStartedAtMs = shiftTimestamp(this.silentStartedAtMs, pausedDurationMs);
+    this.lowSignalStartedAtMs = shiftTimestamp(this.lowSignalStartedAtMs, pausedDurationMs);
+    this.mutedSpeechStartedAtMs = shiftTimestamp(this.mutedSpeechStartedAtMs, pausedDurationMs);
+    this.mutedStartedAtMs = shiftTimestamp(this.mutedStartedAtMs, pausedDurationMs);
   }
   reset() {
     this.totalChunks = 0;
@@ -11100,6 +11779,7 @@ class AudioHealthMonitor {
     this.mutedDurationMs = 0;
     this.currentMuted = false;
     this.hasHealthySignal = false;
+    this.pausedAtMs = null;
   }
   snapshot(timestampMs, isMuted) {
     const consecutiveSilentDurationMs = this.resolveSilentDuration(timestampMs);
@@ -11241,6 +11921,12 @@ class AudioHealthMonitor {
     return value;
   }
 }
+function shiftTimestamp(timestampMs, offsetMs) {
+  if (timestampMs === null) {
+    return null;
+  }
+  return timestampMs + offsetMs;
+}
 
 // src/core/processor/bitrate-utils.ts
 import {
@@ -11300,8 +11986,11 @@ const AUDIO_WORKLET_MESSAGE_TYPE_SET_PAUSED = "${AUDIO_WORKLET_MESSAGE_TYPE_SET_
 const AUDIO_WORKLET_MESSAGE_TYPE_SHUTDOWN = "${AUDIO_WORKLET_MESSAGE_TYPE_SHUTDOWN}";
 
 class VidtreoAudioWorkletProcessor extends AudioWorkletProcessor {
-  constructor() {
+  constructor(options) {
     super();
+    const processorOptions = options && options.processorOptions;
+    this.channelCount =
+      processorOptions && processorOptions.channelCount === 2 ? 2 : 1;
     this.isMuted = false;
     this.isPaused = false;
     this.processedFrames = 0;
@@ -11365,10 +12054,13 @@ class VidtreoAudioWorkletProcessor extends AudioWorkletProcessor {
     }
 
     const frames = firstChannel.length;
-    const data = new Float32Array(frames);
+    const data = new Float32Array(frames * this.channelCount);
 
-    data.set(firstChannel);
-    const inputStats = this.calculateStats(data);
+    for (let channel = 0; channel < this.channelCount; channel += 1) {
+      const channelData = inputGroup[channel] || firstChannel;
+      data.set(channelData, channel * frames);
+    }
+    const inputStats = this.calculateStats(firstChannel);
 
     if (this.isMuted) {
       data.fill(0);
@@ -11382,7 +12074,7 @@ class VidtreoAudioWorkletProcessor extends AudioWorkletProcessor {
         type: AUDIO_WORKLET_MESSAGE_TYPE_AUDIO_CHUNK,
         data,
         frames,
-        numberOfChannels: 1,
+        numberOfChannels: this.channelCount,
         sampleRate,
         timestamp,
         inputPeak: inputStats.peak,
@@ -11431,7 +12123,7 @@ class AudioWorkletController {
   isPaused = false;
   isProcessing = false;
   hasAudioWorkletUrlLease = false;
-  async initialize(audioStream, onAudioChunk) {
+  async initialize(audioStream, onAudioChunk, channelCount = RECORDING_AUDIO_CHANNELS) {
     if (!audioStream) {
       throw new Error("Audio stream is required");
     }
@@ -11459,7 +12151,8 @@ class AudioWorkletController {
       const audioWorkletNode = new AudioWorkletNode(audioContext, AUDIO_WORKLET_PROCESSOR_NAME, {
         numberOfInputs: AUDIO_WORKLET_INPUT_COUNT,
         numberOfOutputs: AUDIO_WORKLET_OUTPUT_COUNT,
-        outputChannelCount: [RECORDING_AUDIO_CHANNELS]
+        outputChannelCount: [RECORDING_AUDIO_CHANNELS],
+        processorOptions: { channelCount }
       });
       audioWorkletNode.port.onmessage = this.handleWorkletMessage.bind(this);
       this.audioWorkletNode = audioWorkletNode;
@@ -11468,7 +12161,7 @@ class AudioWorkletController {
       this.audioDestinationNode.gain.value = SILENT_GAIN_VALUE;
       const audioConfig = {
         sampleRate: audioContext.sampleRate,
-        numberOfChannels: RECORDING_AUDIO_CHANNELS,
+        numberOfChannels: channelCount,
         format: WORKER_AUDIO_SAMPLE_FORMAT_F32_PLANAR
       };
       this.audioConfig = audioConfig;
@@ -11633,7 +12326,7 @@ class AudioWorkletManager {
     }
     this.createController = createController;
   }
-  async prepareAudioConfig(audioTrack) {
+  async prepareAudioConfig(audioTrack, channelCount) {
     if (!audioTrack) {
       this.audioWorkletConfig = null;
       return null;
@@ -11642,7 +12335,7 @@ class AudioWorkletManager {
       this.audioWorkletController = this.createController();
     }
     const audioStream = new MediaStream([audioTrack]);
-    this.audioWorkletConfig = await this.audioWorkletController.initialize(audioStream, (chunk) => this.onChunk(chunk)).catch((error) => {
+    this.audioWorkletConfig = await this.audioWorkletController.initialize(audioStream, (chunk) => this.onChunk(chunk), channelCount).catch((error) => {
       this.stop();
       throw error;
     });
@@ -12178,6 +12871,16 @@ var workerCode = `(() => {
     const transformedHeight = Math.abs(b) * width + Math.abs(d) * height;
     return multiplyMatrices(multiplyMatrices(translationMatrix(-width / 2, -height / 2), linear), translationMatrix(transformedWidth / 2, transformedHeight / 2));
   };
+  var extractRotationFromMatrix = (matrix) => {
+    const [a, b] = matrix;
+    const radians = Math.atan2(b, matrixIsFlipped(matrix) ? -a : a);
+    return normalizeRotation(roundToMultiple(radians * RAD_TO_DEG, 90));
+  };
+  var matrixIsFlipped = (matrix) => {
+    const [a, b, , c, d] = matrix;
+    const det = a * d - b * c;
+    return det < 0;
+  };
   var rotationMatrix = (rotationInDegrees) => {
     const theta = rotationInDegrees * DEG_TO_RAD;
     const cosTheta = Math.round(Math.cos(theta));
@@ -12259,6 +12962,16 @@ var workerCode = `(() => {
     const codeNum = readExpGolomb(bitstream);
     return (codeNum & 1) === 0 ? -(codeNum >> 1) : codeNum + 1 >> 1;
   };
+  var writeBits = (bytes, start, end, value) => {
+    for (let i = start;i < end; i++) {
+      const byteIndex = Math.floor(i / 8);
+      let byte = bytes[byteIndex];
+      const bitIndex = 7 - (i & 7);
+      byte &= ~(1 << bitIndex);
+      byte |= (value & 1 << end - i - 1) >> end - i - 1 << bitIndex;
+      bytes[byteIndex] = byte;
+    }
+  };
   var toUint8Array = (source) => {
     if (source.constructor === Uint8Array) {
       return source;
@@ -12648,6 +13361,43 @@ var workerCode = `(() => {
       yield { key, value };
     }
   };
+  var imageMimeTypeToExtension = (mimeType) => {
+    switch (mimeType.toLowerCase()) {
+      case "image/jpeg":
+      case "image/jpg":
+        return ".jpg";
+      case "image/png":
+        return ".png";
+      case "image/gif":
+        return ".gif";
+      case "image/webp":
+        return ".webp";
+      case "image/bmp":
+        return ".bmp";
+      case "image/svg+xml":
+        return ".svg";
+      case "image/tiff":
+        return ".tiff";
+      case "image/avif":
+        return ".avif";
+      case "image/x-icon":
+      case "image/vnd.microsoft.icon":
+        return ".ico";
+      default:
+        return null;
+    }
+  };
+  var uint8ArraysAreEqual = (a, b) => {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0;i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  };
   var polyfillSymbolDispose = () => {
     Symbol.dispose ??= Symbol("Symbol.dispose");
   };
@@ -15415,6 +16165,27 @@ var workerCode = `(() => {
     }
     throw new TypeError(\`Unhandled codec '\${String(codec)}'.\`);
   };
+  var generateVp9CodecConfigurationFromCodecString = (codecString) => {
+    const parts = codecString.split(".");
+    const profile = Number(parts[1]);
+    const level = Number(parts[2]);
+    const bitDepth = Number(parts[3]);
+    const chromaSubsampling = parts[4] ? Number(parts[4]) : 1;
+    return [
+      1,
+      1,
+      profile,
+      2,
+      1,
+      level,
+      3,
+      1,
+      bitDepth,
+      4,
+      1,
+      chromaSubsampling
+    ];
+  };
   var generateAv1CodecConfigurationFromCodecString = (codecString) => {
     const parts = codecString.split(".");
     const marker = 1;
@@ -15604,6 +16375,7 @@ var workerCode = `(() => {
     }
     throw new TypeError(\`Unhandled codec '\${codec}'.\`);
   };
+  var OPUS_SAMPLE_RATE = 48000;
   var PCM_CODEC_REGEX = /^pcm-([usf])(\\d+)(be)?$/;
   var parsePcmCodec = (codec) => {
     assert(PCM_AUDIO_CODECS.includes(codec));
@@ -16081,6 +16853,443 @@ var workerCode = `(() => {
   var MIN_BOX_HEADER_SIZE = 8;
   var MAX_BOX_HEADER_SIZE = 16;
 
+  // ../../node_modules/.bun/mediabunny@1.61.3/node_modules/mediabunny/dist/modules/src/matroska/ebml.js
+  /*!
+   * Copyright (c) 2026-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/.
+   */
+
+  class EBMLFloat32 {
+    constructor(value) {
+      this.value = value;
+    }
+  }
+
+  class EBMLFloat64 {
+    constructor(value) {
+      this.value = value;
+    }
+  }
+
+  class EBMLSignedInt {
+    constructor(value) {
+      this.value = value;
+    }
+  }
+
+  class EBMLUnicodeString {
+    constructor(value) {
+      this.value = value;
+    }
+  }
+  var EBMLId;
+  (function(EBMLId) {
+    EBMLId[EBMLId["EBML"] = 440786851] = "EBML";
+    EBMLId[EBMLId["EBMLVersion"] = 17030] = "EBMLVersion";
+    EBMLId[EBMLId["EBMLReadVersion"] = 17143] = "EBMLReadVersion";
+    EBMLId[EBMLId["EBMLMaxIDLength"] = 17138] = "EBMLMaxIDLength";
+    EBMLId[EBMLId["EBMLMaxSizeLength"] = 17139] = "EBMLMaxSizeLength";
+    EBMLId[EBMLId["DocType"] = 17026] = "DocType";
+    EBMLId[EBMLId["DocTypeVersion"] = 17031] = "DocTypeVersion";
+    EBMLId[EBMLId["DocTypeReadVersion"] = 17029] = "DocTypeReadVersion";
+    EBMLId[EBMLId["Void"] = 236] = "Void";
+    EBMLId[EBMLId["Segment"] = 408125543] = "Segment";
+    EBMLId[EBMLId["SeekHead"] = 290298740] = "SeekHead";
+    EBMLId[EBMLId["Seek"] = 19899] = "Seek";
+    EBMLId[EBMLId["SeekID"] = 21419] = "SeekID";
+    EBMLId[EBMLId["SeekPosition"] = 21420] = "SeekPosition";
+    EBMLId[EBMLId["Duration"] = 17545] = "Duration";
+    EBMLId[EBMLId["Info"] = 357149030] = "Info";
+    EBMLId[EBMLId["TimestampScale"] = 2807729] = "TimestampScale";
+    EBMLId[EBMLId["MuxingApp"] = 19840] = "MuxingApp";
+    EBMLId[EBMLId["WritingApp"] = 22337] = "WritingApp";
+    EBMLId[EBMLId["Tracks"] = 374648427] = "Tracks";
+    EBMLId[EBMLId["TrackEntry"] = 174] = "TrackEntry";
+    EBMLId[EBMLId["TrackNumber"] = 215] = "TrackNumber";
+    EBMLId[EBMLId["TrackUID"] = 29637] = "TrackUID";
+    EBMLId[EBMLId["TrackType"] = 131] = "TrackType";
+    EBMLId[EBMLId["FlagEnabled"] = 185] = "FlagEnabled";
+    EBMLId[EBMLId["FlagDefault"] = 136] = "FlagDefault";
+    EBMLId[EBMLId["FlagForced"] = 21930] = "FlagForced";
+    EBMLId[EBMLId["FlagOriginal"] = 21934] = "FlagOriginal";
+    EBMLId[EBMLId["FlagHearingImpaired"] = 21931] = "FlagHearingImpaired";
+    EBMLId[EBMLId["FlagVisualImpaired"] = 21932] = "FlagVisualImpaired";
+    EBMLId[EBMLId["FlagCommentary"] = 21935] = "FlagCommentary";
+    EBMLId[EBMLId["FlagLacing"] = 156] = "FlagLacing";
+    EBMLId[EBMLId["Name"] = 21358] = "Name";
+    EBMLId[EBMLId["Language"] = 2274716] = "Language";
+    EBMLId[EBMLId["LanguageBCP47"] = 2274717] = "LanguageBCP47";
+    EBMLId[EBMLId["CodecID"] = 134] = "CodecID";
+    EBMLId[EBMLId["CodecPrivate"] = 25506] = "CodecPrivate";
+    EBMLId[EBMLId["CodecDelay"] = 22186] = "CodecDelay";
+    EBMLId[EBMLId["SeekPreRoll"] = 22203] = "SeekPreRoll";
+    EBMLId[EBMLId["DefaultDuration"] = 2352003] = "DefaultDuration";
+    EBMLId[EBMLId["Video"] = 224] = "Video";
+    EBMLId[EBMLId["PixelWidth"] = 176] = "PixelWidth";
+    EBMLId[EBMLId["PixelHeight"] = 186] = "PixelHeight";
+    EBMLId[EBMLId["DisplayWidth"] = 21680] = "DisplayWidth";
+    EBMLId[EBMLId["DisplayHeight"] = 21690] = "DisplayHeight";
+    EBMLId[EBMLId["DisplayUnit"] = 21682] = "DisplayUnit";
+    EBMLId[EBMLId["AlphaMode"] = 21440] = "AlphaMode";
+    EBMLId[EBMLId["Audio"] = 225] = "Audio";
+    EBMLId[EBMLId["SamplingFrequency"] = 181] = "SamplingFrequency";
+    EBMLId[EBMLId["Channels"] = 159] = "Channels";
+    EBMLId[EBMLId["BitDepth"] = 25188] = "BitDepth";
+    EBMLId[EBMLId["SimpleBlock"] = 163] = "SimpleBlock";
+    EBMLId[EBMLId["BlockGroup"] = 160] = "BlockGroup";
+    EBMLId[EBMLId["Block"] = 161] = "Block";
+    EBMLId[EBMLId["BlockAdditions"] = 30113] = "BlockAdditions";
+    EBMLId[EBMLId["BlockMore"] = 166] = "BlockMore";
+    EBMLId[EBMLId["BlockAdditional"] = 165] = "BlockAdditional";
+    EBMLId[EBMLId["BlockAddID"] = 238] = "BlockAddID";
+    EBMLId[EBMLId["BlockDuration"] = 155] = "BlockDuration";
+    EBMLId[EBMLId["ReferenceBlock"] = 251] = "ReferenceBlock";
+    EBMLId[EBMLId["Cluster"] = 524531317] = "Cluster";
+    EBMLId[EBMLId["Timestamp"] = 231] = "Timestamp";
+    EBMLId[EBMLId["Cues"] = 475249515] = "Cues";
+    EBMLId[EBMLId["CuePoint"] = 187] = "CuePoint";
+    EBMLId[EBMLId["CueTime"] = 179] = "CueTime";
+    EBMLId[EBMLId["CueTrackPositions"] = 183] = "CueTrackPositions";
+    EBMLId[EBMLId["CueTrack"] = 247] = "CueTrack";
+    EBMLId[EBMLId["CueClusterPosition"] = 241] = "CueClusterPosition";
+    EBMLId[EBMLId["Colour"] = 21936] = "Colour";
+    EBMLId[EBMLId["MatrixCoefficients"] = 21937] = "MatrixCoefficients";
+    EBMLId[EBMLId["TransferCharacteristics"] = 21946] = "TransferCharacteristics";
+    EBMLId[EBMLId["Primaries"] = 21947] = "Primaries";
+    EBMLId[EBMLId["Range"] = 21945] = "Range";
+    EBMLId[EBMLId["Projection"] = 30320] = "Projection";
+    EBMLId[EBMLId["ProjectionType"] = 30321] = "ProjectionType";
+    EBMLId[EBMLId["ProjectionPoseYaw"] = 30323] = "ProjectionPoseYaw";
+    EBMLId[EBMLId["ProjectionPosePitch"] = 30324] = "ProjectionPosePitch";
+    EBMLId[EBMLId["ProjectionPoseRoll"] = 30325] = "ProjectionPoseRoll";
+    EBMLId[EBMLId["Attachments"] = 423732329] = "Attachments";
+    EBMLId[EBMLId["AttachedFile"] = 24999] = "AttachedFile";
+    EBMLId[EBMLId["FileDescription"] = 18046] = "FileDescription";
+    EBMLId[EBMLId["FileName"] = 18030] = "FileName";
+    EBMLId[EBMLId["FileMediaType"] = 18016] = "FileMediaType";
+    EBMLId[EBMLId["FileData"] = 18012] = "FileData";
+    EBMLId[EBMLId["FileUID"] = 18094] = "FileUID";
+    EBMLId[EBMLId["Chapters"] = 272869232] = "Chapters";
+    EBMLId[EBMLId["Tags"] = 307544935] = "Tags";
+    EBMLId[EBMLId["Tag"] = 29555] = "Tag";
+    EBMLId[EBMLId["Targets"] = 25536] = "Targets";
+    EBMLId[EBMLId["TargetTypeValue"] = 26826] = "TargetTypeValue";
+    EBMLId[EBMLId["TargetType"] = 25546] = "TargetType";
+    EBMLId[EBMLId["TagTrackUID"] = 25541] = "TagTrackUID";
+    EBMLId[EBMLId["TagEditionUID"] = 25545] = "TagEditionUID";
+    EBMLId[EBMLId["TagChapterUID"] = 25540] = "TagChapterUID";
+    EBMLId[EBMLId["TagAttachmentUID"] = 25542] = "TagAttachmentUID";
+    EBMLId[EBMLId["SimpleTag"] = 26568] = "SimpleTag";
+    EBMLId[EBMLId["TagName"] = 17827] = "TagName";
+    EBMLId[EBMLId["TagLanguage"] = 17530] = "TagLanguage";
+    EBMLId[EBMLId["TagString"] = 17543] = "TagString";
+    EBMLId[EBMLId["TagBinary"] = 17541] = "TagBinary";
+    EBMLId[EBMLId["ContentEncodings"] = 28032] = "ContentEncodings";
+    EBMLId[EBMLId["ContentEncoding"] = 25152] = "ContentEncoding";
+    EBMLId[EBMLId["ContentEncodingOrder"] = 20529] = "ContentEncodingOrder";
+    EBMLId[EBMLId["ContentEncodingScope"] = 20530] = "ContentEncodingScope";
+    EBMLId[EBMLId["ContentCompression"] = 20532] = "ContentCompression";
+    EBMLId[EBMLId["ContentCompAlgo"] = 16980] = "ContentCompAlgo";
+    EBMLId[EBMLId["ContentCompSettings"] = 16981] = "ContentCompSettings";
+    EBMLId[EBMLId["ContentEncryption"] = 20533] = "ContentEncryption";
+  })(EBMLId || (EBMLId = {}));
+  var LEVEL_0_EBML_IDS = [
+    EBMLId.EBML,
+    EBMLId.Segment
+  ];
+  var LEVEL_1_EBML_IDS = [
+    EBMLId.SeekHead,
+    EBMLId.Info,
+    EBMLId.Cluster,
+    EBMLId.Tracks,
+    EBMLId.Cues,
+    EBMLId.Attachments,
+    EBMLId.Chapters,
+    EBMLId.Tags
+  ];
+  var LEVEL_0_AND_1_EBML_IDS = [
+    ...LEVEL_0_EBML_IDS,
+    ...LEVEL_1_EBML_IDS
+  ];
+  var measureUnsignedInt = (value) => {
+    if (value < 1 << 8) {
+      return 1;
+    } else if (value < 1 << 16) {
+      return 2;
+    } else if (value < 1 << 24) {
+      return 3;
+    } else if (value < 2 ** 32) {
+      return 4;
+    } else if (value < 2 ** 40) {
+      return 5;
+    } else {
+      return 6;
+    }
+  };
+  var measureUnsignedBigInt = (value) => {
+    if (value < 1n << 8n) {
+      return 1;
+    } else if (value < 1n << 16n) {
+      return 2;
+    } else if (value < 1n << 24n) {
+      return 3;
+    } else if (value < 1n << 32n) {
+      return 4;
+    } else if (value < 1n << 40n) {
+      return 5;
+    } else if (value < 1n << 48n) {
+      return 6;
+    } else if (value < 1n << 56n) {
+      return 7;
+    } else {
+      return 8;
+    }
+  };
+  var measureSignedInt = (value) => {
+    if (value >= -(1 << 6) && value < 1 << 6) {
+      return 1;
+    } else if (value >= -(1 << 13) && value < 1 << 13) {
+      return 2;
+    } else if (value >= -(1 << 20) && value < 1 << 20) {
+      return 3;
+    } else if (value >= -(1 << 27) && value < 1 << 27) {
+      return 4;
+    } else if (value >= -(2 ** 34) && value < 2 ** 34) {
+      return 5;
+    } else {
+      return 6;
+    }
+  };
+  var measureVarInt = (value) => {
+    if (value < (1 << 7) - 1) {
+      return 1;
+    } else if (value < (1 << 14) - 1) {
+      return 2;
+    } else if (value < (1 << 21) - 1) {
+      return 3;
+    } else if (value < (1 << 28) - 1) {
+      return 4;
+    } else if (value < 2 ** 35 - 1) {
+      return 5;
+    } else if (value < 2 ** 42 - 1) {
+      return 6;
+    } else {
+      throw new Error("EBML varint size not supported " + value);
+    }
+  };
+
+  class EBMLWriter {
+    constructor(writer) {
+      this.writer = writer;
+      this.helper = new Uint8Array(8);
+      this.helperView = new DataView(this.helper.buffer);
+      this.offsets = new WeakMap;
+      this.dataOffsets = new WeakMap;
+    }
+    writeByte(value) {
+      this.helperView.setUint8(0, value);
+      this.writer.write(this.helper.subarray(0, 1));
+    }
+    writeFloat32(value) {
+      this.helperView.setFloat32(0, value, false);
+      this.writer.write(this.helper.subarray(0, 4));
+    }
+    writeFloat64(value) {
+      this.helperView.setFloat64(0, value, false);
+      this.writer.write(this.helper);
+    }
+    writeUnsignedInt(value, width = measureUnsignedInt(value)) {
+      let pos = 0;
+      switch (width) {
+        case 6:
+          this.helperView.setUint8(pos++, value / 2 ** 40 | 0);
+        case 5:
+          this.helperView.setUint8(pos++, value / 2 ** 32 | 0);
+        case 4:
+          this.helperView.setUint8(pos++, value >> 24);
+        case 3:
+          this.helperView.setUint8(pos++, value >> 16);
+        case 2:
+          this.helperView.setUint8(pos++, value >> 8);
+        case 1:
+          this.helperView.setUint8(pos++, value);
+          break;
+        default:
+          throw new Error("Bad unsigned int size " + width);
+      }
+      this.writer.write(this.helper.subarray(0, pos));
+    }
+    writeUnsignedBigInt(value, width = measureUnsignedBigInt(value)) {
+      let pos = 0;
+      for (let i = width - 1;i >= 0; i--) {
+        this.helperView.setUint8(pos++, Number(value >> BigInt(i * 8) & 0xffn));
+      }
+      this.writer.write(this.helper.subarray(0, pos));
+    }
+    writeSignedInt(value, width = measureSignedInt(value)) {
+      if (value < 0) {
+        value += 2 ** (width * 8);
+      }
+      this.writeUnsignedInt(value, width);
+    }
+    writeVarInt(value, width = measureVarInt(value)) {
+      let pos = 0;
+      switch (width) {
+        case 1:
+          this.helperView.setUint8(pos++, 1 << 7 | value);
+          break;
+        case 2:
+          this.helperView.setUint8(pos++, 1 << 6 | value >> 8);
+          this.helperView.setUint8(pos++, value);
+          break;
+        case 3:
+          this.helperView.setUint8(pos++, 1 << 5 | value >> 16);
+          this.helperView.setUint8(pos++, value >> 8);
+          this.helperView.setUint8(pos++, value);
+          break;
+        case 4:
+          this.helperView.setUint8(pos++, 1 << 4 | value >> 24);
+          this.helperView.setUint8(pos++, value >> 16);
+          this.helperView.setUint8(pos++, value >> 8);
+          this.helperView.setUint8(pos++, value);
+          break;
+        case 5:
+          this.helperView.setUint8(pos++, 1 << 3 | value / 2 ** 32 & 7);
+          this.helperView.setUint8(pos++, value >> 24);
+          this.helperView.setUint8(pos++, value >> 16);
+          this.helperView.setUint8(pos++, value >> 8);
+          this.helperView.setUint8(pos++, value);
+          break;
+        case 6:
+          this.helperView.setUint8(pos++, 1 << 2 | value / 2 ** 40 & 3);
+          this.helperView.setUint8(pos++, value / 2 ** 32 | 0);
+          this.helperView.setUint8(pos++, value >> 24);
+          this.helperView.setUint8(pos++, value >> 16);
+          this.helperView.setUint8(pos++, value >> 8);
+          this.helperView.setUint8(pos++, value);
+          break;
+        default:
+          throw new Error("Bad EBML varint size " + width);
+      }
+      this.writer.write(this.helper.subarray(0, pos));
+    }
+    writeAsciiString(str) {
+      this.writer.write(new Uint8Array(str.split("").map((x) => x.charCodeAt(0))));
+    }
+    writeEBML(data) {
+      if (data === null)
+        return;
+      if (data instanceof Uint8Array) {
+        this.writer.write(data);
+      } else if (Array.isArray(data)) {
+        for (const elem of data) {
+          this.writeEBML(elem);
+        }
+      } else {
+        this.offsets.set(data, this.writer.getPos());
+        this.writeUnsignedInt(data.id);
+        if (Array.isArray(data.data)) {
+          const sizePos = this.writer.getPos();
+          const sizeSize = data.size === -1 ? 1 : data.size ?? 4;
+          if (data.size === -1) {
+            this.writeByte(255);
+          } else {
+            this.writer.seek(this.writer.getPos() + sizeSize);
+          }
+          const startPos = this.writer.getPos();
+          this.dataOffsets.set(data, startPos);
+          this.writeEBML(data.data);
+          if (data.size !== -1) {
+            const size = this.writer.getPos() - startPos;
+            const endPos = this.writer.getPos();
+            this.writer.seek(sizePos);
+            this.writeVarInt(size, sizeSize);
+            this.writer.seek(endPos);
+          }
+        } else if (typeof data.data === "number") {
+          const size = data.size ?? measureUnsignedInt(data.data);
+          this.writeVarInt(size);
+          this.writeUnsignedInt(data.data, size);
+        } else if (typeof data.data === "bigint") {
+          const size = data.size ?? measureUnsignedBigInt(data.data);
+          this.writeVarInt(size);
+          this.writeUnsignedBigInt(data.data, size);
+        } else if (typeof data.data === "string") {
+          this.writeVarInt(data.data.length);
+          this.writeAsciiString(data.data);
+        } else if (data.data instanceof Uint8Array) {
+          this.writeVarInt(data.data.byteLength, data.size);
+          this.writer.write(data.data);
+        } else if (data.data instanceof EBMLFloat32) {
+          this.writeVarInt(4);
+          this.writeFloat32(data.data.value);
+        } else if (data.data instanceof EBMLFloat64) {
+          this.writeVarInt(8);
+          this.writeFloat64(data.data.value);
+        } else if (data.data instanceof EBMLSignedInt) {
+          const size = data.size ?? measureSignedInt(data.data.value);
+          this.writeVarInt(size);
+          this.writeSignedInt(data.data.value, size);
+        } else if (data.data instanceof EBMLUnicodeString) {
+          const bytes = textEncoder.encode(data.data.value);
+          this.writeVarInt(bytes.length);
+          this.writer.write(bytes);
+        } else {
+          assertNever(data.data);
+        }
+      }
+    }
+  }
+  var MAX_VAR_INT_SIZE = 8;
+  var MAX_HEADER_SIZE = 2 * MAX_VAR_INT_SIZE;
+  var CODEC_STRING_MAP = {
+    avc: "V_MPEG4/ISO/AVC",
+    hevc: "V_MPEGH/ISO/HEVC",
+    vp8: "V_VP8",
+    vp9: "V_VP9",
+    av1: "V_AV1",
+    prores: "V_PRORES",
+    aac: "A_AAC",
+    mp3: "A_MPEG/L3",
+    opus: "A_OPUS",
+    vorbis: "A_VORBIS",
+    flac: "A_FLAC",
+    ac3: "A_AC3",
+    eac3: "A_EAC3",
+    dts: "A_DTS",
+    "pcm-u8": "A_PCM/INT/LIT",
+    "pcm-s16": "A_PCM/INT/LIT",
+    "pcm-s16be": "A_PCM/INT/BIG",
+    "pcm-s24": "A_PCM/INT/LIT",
+    "pcm-s24be": "A_PCM/INT/BIG",
+    "pcm-s32": "A_PCM/INT/LIT",
+    "pcm-s32be": "A_PCM/INT/BIG",
+    "pcm-f32": "A_PCM/FLOAT/IEEE",
+    "pcm-f64": "A_PCM/FLOAT/IEEE",
+    webvtt: "S_TEXT/WEBVTT"
+  };
+
+  // ../../node_modules/.bun/mediabunny@1.61.3/node_modules/mediabunny/dist/modules/src/matroska/matroska-misc.js
+  /*!
+   * Copyright (c) 2026-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 buildMatroskaMimeType = (info) => {
+    const base = info.hasVideo ? "video/" : info.hasAudio ? "audio/" : "application/";
+    let string = base + (info.isWebM ? "webm" : "x-matroska");
+    if (info.codecStrings.length > 0) {
+      const uniqueCodecMimeTypes = [...new Set(info.codecStrings.filter(Boolean))];
+      string += \`; codecs="\${uniqueCodecMimeTypes.join(", ")}"\`;
+    }
+    return string;
+  };
+
   // ../../node_modules/.bun/mediabunny@1.61.3/node_modules/mediabunny/dist/modules/src/adts/adts-reader.js
   /*!
    * Copyright (c) 2026-present, Vanilagy and contributors
@@ -18917,6 +20126,13 @@ var workerCode = `(() => {
    * file, You can obtain one at https://mozilla.org/MPL/2.0/.
    */
   var inlineTimestampRegex = /<(?:(\\d{2}):)?(\\d{2}):(\\d{2}).(\\d{3})>/g;
+  var timestampRegex = /(?:(\\d{2}):)?(\\d{2}):(\\d{2}).(\\d{3})/;
+  var parseSubtitleTimestamp = (string) => {
+    const match = timestampRegex.exec(string);
+    if (!match)
+      throw new Error("Expected match.");
+    return 60 * 60 * 1000 * Number(match[1] || "0") + 60 * 1000 * Number(match[2]) + 1000 * Number(match[3]) + Number(match[4]);
+  };
   var formatSubtitleTimestamp = (timestamp) => {
     const hours = Math.floor(timestamp / (60 * 60 * 1000));
     const minutes = Math.floor(timestamp % (60 * 60 * 1000) / (60 * 1000));
@@ -21967,6 +23183,994 @@ var workerCode = `(() => {
     }
   }
 
+  // ../../node_modules/.bun/mediabunny@1.61.3/node_modules/mediabunny/dist/modules/src/matroska/matroska-muxer.js
+  /*!
+   * Copyright (c) 2026-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 MIN_CLUSTER_TIMESTAMP_MS = -(2 ** 15);
+  var MAX_CLUSTER_TIMESTAMP_MS = 2 ** 15 - 1;
+  var SEGMENT_SIZE_BYTES = 6;
+  var CLUSTER_SIZE_BYTES = 5;
+  var TRACK_TYPE_MAP = {
+    video: 1,
+    audio: 2,
+    subtitle: 17
+  };
+
+  class MatroskaMuxer extends Muxer {
+    constructor(output, format) {
+      super(output);
+      this.trackDatas = [];
+      this.allTracksKnown = promiseWithResolvers();
+      this.segment = null;
+      this.segmentInfo = null;
+      this.seekHead = null;
+      this.tracksElement = null;
+      this.tagsElement = null;
+      this.attachmentsElement = null;
+      this.segmentDuration = null;
+      this.cues = null;
+      this.currentCluster = null;
+      this.currentClusterStartMsTimestamp = null;
+      this.currentClusterMaxMsTimestamp = null;
+      this.trackDatasInCurrentCluster = new Map;
+      this.startTimestamp = Infinity;
+      this.endTimestamp = -Infinity;
+      this.warnedAboutTooNegativeTimestamp = false;
+      this.format = format;
+    }
+    async start() {
+      const release = await this.mutex.acquire();
+      this.writer = await this.output._getRootWriter(!!this.format._options.appendOnly);
+      this.ebmlWriter = new EBMLWriter(this.writer);
+      this.writeEBMLHeader();
+      this.createSegmentInfo();
+      this.createCues();
+      await this.writer.flush();
+      for (const track of this.output.tracks) {
+        if (track.isVideoTrack() && track.metadata.decoderConfig) {
+          this.getVideoTrackData(track, track.metadata.primingPacket ?? null, { decoderConfig: track.metadata.decoderConfig });
+        } else if (track.isAudioTrack() && track.metadata.decoderConfig) {
+          this.getAudioTrackData(track, track.metadata.primingPacket ?? null, { decoderConfig: track.metadata.decoderConfig });
+        }
+      }
+      release();
+    }
+    writeEBMLHeader() {
+      if (this.format._options.onEbmlHeader) {
+        this.writer.startTrackingWrites();
+      }
+      const ebmlHeader = { id: EBMLId.EBML, data: [
+        { id: EBMLId.EBMLVersion, data: 1 },
+        { id: EBMLId.EBMLReadVersion, data: 1 },
+        { id: EBMLId.EBMLMaxIDLength, data: 4 },
+        { id: EBMLId.EBMLMaxSizeLength, data: 8 },
+        { id: EBMLId.DocType, data: this.format instanceof WebMOutputFormat ? "webm" : "matroska" },
+        { id: EBMLId.DocTypeVersion, data: 4 },
+        { id: EBMLId.DocTypeReadVersion, data: 2 }
+      ] };
+      this.ebmlWriter.writeEBML(ebmlHeader);
+      if (this.format._options.onEbmlHeader) {
+        const { data, start } = this.writer.stopTrackingWrites();
+        this.format._options.onEbmlHeader(data, start);
+      }
+    }
+    maybeCreateSeekHead(writeOffsets) {
+      if (this.format._options.appendOnly) {
+        return;
+      }
+      const kaxCues = new Uint8Array([28, 83, 187, 107]);
+      const kaxInfo = new Uint8Array([21, 73, 169, 102]);
+      const kaxTracks = new Uint8Array([22, 84, 174, 107]);
+      const kaxAttachments = new Uint8Array([25, 65, 164, 105]);
+      const kaxTags = new Uint8Array([18, 84, 195, 103]);
+      const seekHead = { id: EBMLId.SeekHead, data: [
+        { id: EBMLId.Seek, data: [
+          { id: EBMLId.SeekID, data: kaxInfo },
+          {
+            id: EBMLId.SeekPosition,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.segmentInfo) - this.segmentDataOffset : 0
+          }
+        ] },
+        { id: EBMLId.Seek, data: [
+          { id: EBMLId.SeekID, data: kaxTracks },
+          {
+            id: EBMLId.SeekPosition,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.tracksElement) - this.segmentDataOffset : 0
+          }
+        ] },
+        this.attachmentsElement ? { id: EBMLId.Seek, data: [
+          { id: EBMLId.SeekID, data: kaxAttachments },
+          {
+            id: EBMLId.SeekPosition,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.attachmentsElement) - this.segmentDataOffset : 0
+          }
+        ] } : null,
+        this.tagsElement ? { id: EBMLId.Seek, data: [
+          { id: EBMLId.SeekID, data: kaxTags },
+          {
+            id: EBMLId.SeekPosition,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.tagsElement) - this.segmentDataOffset : 0
+          }
+        ] } : null,
+        { id: EBMLId.Seek, data: [
+          { id: EBMLId.SeekID, data: kaxCues },
+          {
+            id: EBMLId.SeekPosition,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.cues) - this.segmentDataOffset : 0
+          }
+        ] }
+      ] };
+      this.seekHead = seekHead;
+    }
+    createSegmentInfo() {
+      const segmentDuration = { id: EBMLId.Duration, data: new EBMLFloat64(0) };
+      this.segmentDuration = segmentDuration;
+      const segmentInfo = { id: EBMLId.Info, data: [
+        { id: EBMLId.TimestampScale, data: 1e6 },
+        { id: EBMLId.MuxingApp, data: VERSIONED_NAME },
+        { id: EBMLId.WritingApp, data: VERSIONED_NAME },
+        !this.format._options.appendOnly ? segmentDuration : null
+      ] };
+      this.segmentInfo = segmentInfo;
+    }
+    createTracks() {
+      const tracksElement = { id: EBMLId.Tracks, data: [] };
+      this.tracksElement = tracksElement;
+      for (const trackData of this.trackDatas) {
+        let codecId = CODEC_STRING_MAP[trackData.track.source._codec];
+        assert(codecId);
+        if (trackData.type === "audio" && trackData.track.source._codec === "dts") {
+          if (trackData.info.decoderConfig.codec === "dtse") {
+            codecId = "A_DTS/EXPRESS";
+          } else if (trackData.info.decoderConfig.codec === "dtsl") {
+            codecId = "A_DTS/LOSSLESS";
+          }
+        }
+        let seekPreRollNs = 0;
+        if (trackData.type === "audio" && trackData.track.source._codec === "opus") {
+          seekPreRollNs = 1e6 * 80;
+          const description = trackData.info.decoderConfig.description;
+          if (description) {
+            const bytes = toUint8Array(description);
+            const header = parseOpusIdentificationHeader(bytes);
+            seekPreRollNs = Math.round(1e9 * (header.preSkip / OPUS_SAMPLE_RATE));
+          }
+        }
+        tracksElement.data.push({ id: EBMLId.TrackEntry, data: [
+          { id: EBMLId.TrackNumber, data: trackData.track.id },
+          { id: EBMLId.TrackUID, data: trackData.track.id },
+          { id: EBMLId.TrackType, data: TRACK_TYPE_MAP[trackData.type] },
+          trackData.track.metadata.disposition?.default === false ? { id: EBMLId.FlagDefault, data: 0 } : null,
+          trackData.track.metadata.disposition?.forced ? { id: EBMLId.FlagForced, data: 1 } : null,
+          trackData.track.metadata.disposition?.hearingImpaired ? { id: EBMLId.FlagHearingImpaired, data: 1 } : null,
+          trackData.track.metadata.disposition?.visuallyImpaired ? { id: EBMLId.FlagVisualImpaired, data: 1 } : null,
+          trackData.track.metadata.disposition?.original ? { id: EBMLId.FlagOriginal, data: 1 } : null,
+          trackData.track.metadata.disposition?.commentary ? { id: EBMLId.FlagCommentary, data: 1 } : null,
+          { id: EBMLId.FlagLacing, data: 0 },
+          { id: EBMLId.Language, data: trackData.track.metadata.languageCode ?? UNDETERMINED_LANGUAGE },
+          { id: EBMLId.CodecID, data: codecId },
+          trackData.codecPrivate ? { id: EBMLId.CodecPrivate, data: toUint8Array(trackData.codecPrivate) } : null,
+          seekPreRollNs > 0 ? { id: EBMLId.SeekPreRoll, data: seekPreRollNs } : null,
+          trackData.track.metadata.name !== undefined ? { id: EBMLId.Name, data: new EBMLUnicodeString(trackData.track.metadata.name) } : null,
+          trackData.type === "video" ? this.videoSpecificTrackInfo(trackData) : null,
+          trackData.type === "audio" ? this.audioSpecificTrackInfo(trackData) : null,
+          trackData.type === "subtitle" ? this.subtitleSpecificTrackInfo(trackData) : null
+        ] });
+      }
+    }
+    videoSpecificTrackInfo(trackData) {
+      const { frameRate, transformationMatrix } = trackData.track.metadata;
+      const elements = [
+        frameRate ? {
+          id: EBMLId.DefaultDuration,
+          data: 1e9 / frameRate
+        } : null
+      ];
+      let rotation;
+      let horizontalScale;
+      let verticalScale;
+      if (transformationMatrix) {
+        rotation = extractRotationFromMatrix(transformationMatrix);
+        const unrotated = multiplyMatrices(rotationMatrix(-rotation), transformationMatrix);
+        horizontalScale = Math.sign(unrotated[0]);
+        verticalScale = Math.sign(unrotated[4]);
+        if (verticalScale === -1) {
+          verticalScale = 1;
+          horizontalScale = -horizontalScale;
+          rotation = normalizeRotation(rotation + 180);
+        }
+      } else {
+        rotation = trackData.track.metadata.rotation ?? 0;
+        horizontalScale = trackData.track.metadata.flip ? -1 : 1;
+        verticalScale = 1;
+      }
+      const roll = rotation ? normalizeRotation(horizontalScale === -1 ? rotation : -rotation) : 0;
+      const yaw = Math.round(Math.acos(horizontalScale) * RAD_TO_DEG);
+      const pitch = Math.round(Math.acos(verticalScale) * RAD_TO_DEG);
+      const hasNonSquarePixelAspectRatio = !!trackData.info.aspectRatio && trackData.info.aspectRatio.num * trackData.info.height !== trackData.info.aspectRatio.den * trackData.info.width;
+      const colorSpace = trackData.info.decoderConfig.colorSpace;
+      const videoElement = { id: EBMLId.Video, data: [
+        { id: EBMLId.PixelWidth, data: trackData.info.width },
+        { id: EBMLId.PixelHeight, data: trackData.info.height },
+        hasNonSquarePixelAspectRatio ? { id: EBMLId.DisplayWidth, data: trackData.info.aspectRatio.num } : null,
+        hasNonSquarePixelAspectRatio ? { id: EBMLId.DisplayHeight, data: trackData.info.aspectRatio.den } : null,
+        hasNonSquarePixelAspectRatio ? { id: EBMLId.DisplayUnit, data: 3 } : null,
+        trackData.info.alphaMode ? { id: EBMLId.AlphaMode, data: 1 } : null,
+        colorSpaceIsEmpty(colorSpace) ? null : {
+          id: EBMLId.Colour,
+          data: [
+            {
+              id: EBMLId.MatrixCoefficients,
+              data: colorSpace?.matrix != null ? MATRIX_COEFFICIENTS_MAP[colorSpace.matrix] : 2
+            },
+            {
+              id: EBMLId.TransferCharacteristics,
+              data: colorSpace?.transfer != null ? TRANSFER_CHARACTERISTICS_MAP[colorSpace.transfer] : 2
+            },
+            {
+              id: EBMLId.Primaries,
+              data: colorSpace?.primaries != null ? COLOR_PRIMARIES_MAP[colorSpace.primaries] : 2
+            },
+            {
+              id: EBMLId.Range,
+              data: colorSpace?.fullRange != null ? colorSpace.fullRange ? 2 : 1 : 0
+            }
+          ]
+        },
+        roll || yaw || pitch ? {
+          id: EBMLId.Projection,
+          data: [
+            {
+              id: EBMLId.ProjectionType,
+              data: 0
+            },
+            yaw ? {
+              id: EBMLId.ProjectionPoseYaw,
+              data: new EBMLFloat32(yaw)
+            } : null,
+            pitch ? {
+              id: EBMLId.ProjectionPosePitch,
+              data: new EBMLFloat32(pitch)
+            } : null,
+            roll ? {
+              id: EBMLId.ProjectionPoseRoll,
+              data: new EBMLFloat32((roll + 180) % 360 - 180)
+            } : null
+          ]
+        } : null
+      ] };
+      elements.push(videoElement);
+      return elements;
+    }
+    audioSpecificTrackInfo(trackData) {
+      const pcmInfo = PCM_AUDIO_CODECS.includes(trackData.track.source._codec) ? parsePcmCodec(trackData.track.source._codec) : null;
+      return [
+        { id: EBMLId.Audio, data: [
+          { id: EBMLId.SamplingFrequency, data: new EBMLFloat32(trackData.info.sampleRate) },
+          { id: EBMLId.Channels, data: trackData.info.numberOfChannels },
+          pcmInfo ? { id: EBMLId.BitDepth, data: 8 * pcmInfo.sampleSize } : null
+        ] }
+      ];
+    }
+    subtitleSpecificTrackInfo(trackData) {
+      return [];
+    }
+    maybeCreateTags() {
+      const simpleTags = [];
+      const addSimpleTag = (key, value) => {
+        simpleTags.push({ id: EBMLId.SimpleTag, data: [
+          { id: EBMLId.TagName, data: new EBMLUnicodeString(key) },
+          typeof value === "string" ? { id: EBMLId.TagString, data: new EBMLUnicodeString(value) } : { id: EBMLId.TagBinary, data: value }
+        ] });
+      };
+      const metadataTags = this.output._metadataTags;
+      const writtenTags = new Set;
+      for (const { key, value } of keyValueIterator(metadataTags)) {
+        switch (key) {
+          case "title":
+            {
+              addSimpleTag("TITLE", value);
+              writtenTags.add("TITLE");
+            }
+            ;
+            break;
+          case "description":
+            {
+              addSimpleTag("DESCRIPTION", value);
+              writtenTags.add("DESCRIPTION");
+            }
+            ;
+            break;
+          case "artist":
+            {
+              addSimpleTag("ARTIST", value);
+              writtenTags.add("ARTIST");
+            }
+            ;
+            break;
+          case "album":
+            {
+              addSimpleTag("ALBUM", value);
+              writtenTags.add("ALBUM");
+            }
+            ;
+            break;
+          case "albumArtist":
+            {
+              addSimpleTag("ALBUM_ARTIST", value);
+              writtenTags.add("ALBUM_ARTIST");
+            }
+            ;
+            break;
+          case "genre":
+            {
+              addSimpleTag("GENRE", value);
+              writtenTags.add("GENRE");
+            }
+            ;
+            break;
+          case "beatsPerMinute":
+            {
+              addSimpleTag("BPM", value.toString());
+              writtenTags.add("BPM");
+            }
+            ;
+            break;
+          case "comment":
+            {
+              addSimpleTag("COMMENT", value);
+              writtenTags.add("COMMENT");
+            }
+            ;
+            break;
+          case "lyrics":
+            {
+              addSimpleTag("LYRICS", value);
+              writtenTags.add("LYRICS");
+            }
+            ;
+            break;
+          case "date":
+            {
+              addSimpleTag("DATE", value.toISOString().slice(0, 10));
+              writtenTags.add("DATE");
+            }
+            ;
+            break;
+          case "trackNumber":
+            {
+              const string = metadataTags.tracksTotal !== undefined ? \`\${value}/\${metadataTags.tracksTotal}\` : value.toString();
+              addSimpleTag("PART_NUMBER", string);
+              writtenTags.add("PART_NUMBER");
+            }
+            ;
+            break;
+          case "discNumber":
+            {
+              const string = metadataTags.discsTotal !== undefined ? \`\${value}/\${metadataTags.discsTotal}\` : value.toString();
+              addSimpleTag("DISC", string);
+              writtenTags.add("DISC");
+            }
+            ;
+            break;
+          case "tracksTotal":
+          case "discsTotal":
+            {}
+            ;
+            break;
+          case "images":
+          case "raw":
+            {}
+            ;
+            break;
+          default:
+            assertNever(key);
+        }
+      }
+      if (metadataTags.raw) {
+        for (const key in metadataTags.raw) {
+          const value = metadataTags.raw[key];
+          if (value == null || writtenTags.has(key)) {
+            continue;
+          }
+          if (typeof value === "string" || value instanceof Uint8Array) {
+            addSimpleTag(key, value);
+          }
+        }
+      }
+      if (simpleTags.length === 0) {
+        return;
+      }
+      this.tagsElement = {
+        id: EBMLId.Tags,
+        data: [{ id: EBMLId.Tag, data: [
+          { id: EBMLId.Targets, data: [
+            { id: EBMLId.TargetTypeValue, data: 50 },
+            { id: EBMLId.TargetType, data: "MOVIE" }
+          ] },
+          ...simpleTags
+        ] }]
+      };
+    }
+    maybeCreateAttachments() {
+      const metadataTags = this.output._metadataTags;
+      const elements = [];
+      const existingFileUids = new Set;
+      const images = metadataTags.images ?? [];
+      for (const image of images) {
+        let imageName = image.name;
+        if (imageName === undefined) {
+          const baseName = image.kind === "coverFront" ? "cover" : image.kind === "coverBack" ? "back" : "image";
+          imageName = baseName + (imageMimeTypeToExtension(image.mimeType) ?? "");
+        }
+        let fileUid;
+        while (true) {
+          fileUid = 0n;
+          for (let i = 0;i < 8; i++) {
+            fileUid <<= 8n;
+            fileUid |= BigInt(Math.floor(Math.random() * 256));
+          }
+          if (fileUid !== 0n && !existingFileUids.has(fileUid)) {
+            break;
+          }
+        }
+        existingFileUids.add(fileUid);
+        elements.push({
+          id: EBMLId.AttachedFile,
+          data: [
+            image.description !== undefined ? { id: EBMLId.FileDescription, data: new EBMLUnicodeString(image.description) } : null,
+            { id: EBMLId.FileName, data: new EBMLUnicodeString(imageName) },
+            { id: EBMLId.FileMediaType, data: image.mimeType },
+            { id: EBMLId.FileData, data: image.data },
+            { id: EBMLId.FileUID, data: fileUid }
+          ]
+        });
+      }
+      for (const [key, value] of Object.entries(metadataTags.raw ?? {})) {
+        if (!(value instanceof AttachedFile)) {
+          continue;
+        }
+        const keyIsNumeric = /^\\d+$/.test(key);
+        if (!keyIsNumeric) {
+          continue;
+        }
+        if (images.find((x) => x.mimeType === value.mimeType && uint8ArraysAreEqual(x.data, value.data))) {
+          continue;
+        }
+        elements.push({
+          id: EBMLId.AttachedFile,
+          data: [
+            value.description !== undefined ? { id: EBMLId.FileDescription, data: new EBMLUnicodeString(value.description) } : null,
+            { id: EBMLId.FileName, data: new EBMLUnicodeString(value.name ?? "") },
+            { id: EBMLId.FileMediaType, data: value.mimeType ?? "" },
+            { id: EBMLId.FileData, data: value.data },
+            { id: EBMLId.FileUID, data: BigInt(key) }
+          ]
+        });
+      }
+      if (elements.length === 0) {
+        return;
+      }
+      this.attachmentsElement = { id: EBMLId.Attachments, data: elements };
+    }
+    createSegment() {
+      this.createTracks();
+      this.maybeCreateTags();
+      this.maybeCreateAttachments();
+      this.maybeCreateSeekHead(false);
+      const segment = {
+        id: EBMLId.Segment,
+        size: this.format._options.appendOnly ? -1 : SEGMENT_SIZE_BYTES,
+        data: [
+          this.seekHead,
+          this.segmentInfo,
+          this.tracksElement,
+          this.attachmentsElement,
+          this.tagsElement
+        ]
+      };
+      this.segment = segment;
+      if (this.format._options.onSegmentHeader) {
+        this.writer.startTrackingWrites();
+      }
+      this.ebmlWriter.writeEBML(segment);
+      if (this.format._options.onSegmentHeader) {
+        const { data, start } = this.writer.stopTrackingWrites();
+        this.format._options.onSegmentHeader(data, start);
+      }
+    }
+    createCues() {
+      this.cues = { id: EBMLId.Cues, data: [] };
+    }
+    get segmentDataOffset() {
+      assert(this.segment);
+      return this.ebmlWriter.dataOffsets.get(this.segment);
+    }
+    allTracksAreKnown() {
+      for (const track of this.output.tracks) {
+        if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    async getMimeType() {
+      await this.allTracksKnown.promise;
+      const codecStrings = this.trackDatas.map((trackData) => {
+        if (trackData.type === "video") {
+          return trackData.info.decoderConfig.codec;
+        } else if (trackData.type === "audio") {
+          return trackData.info.decoderConfig.codec;
+        } else {
+          const map = {
+            webvtt: "wvtt"
+          };
+          return map[trackData.track.source._codec];
+        }
+      });
+      return buildMatroskaMimeType({
+        isWebM: this.format instanceof WebMOutputFormat,
+        hasVideo: this.trackDatas.some((x) => x.type === "video"),
+        hasAudio: this.trackDatas.some((x) => x.type === "audio"),
+        codecStrings
+      });
+    }
+    getVideoTrackData(track, packet, meta) {
+      const existingTrackData = this.trackDatas.find((x) => x.track === track);
+      if (existingTrackData) {
+        return existingTrackData;
+      }
+      validateVideoChunkMetadata(meta, track.source._codec);
+      assert(meta);
+      assert(meta.decoderConfig);
+      assert(meta.decoderConfig.codedWidth !== undefined);
+      assert(meta.decoderConfig.codedHeight !== undefined);
+      const displayAspectWidth = meta.decoderConfig.displayAspectWidth;
+      const displayAspectHeight = meta.decoderConfig.displayAspectHeight;
+      const aspectRatio = displayAspectWidth === undefined || displayAspectHeight === undefined ? null : simplifyRational({
+        num: displayAspectWidth,
+        den: displayAspectHeight
+      });
+      const newTrackData = {
+        track,
+        type: "video",
+        info: {
+          width: meta.decoderConfig.codedWidth,
+          height: meta.decoderConfig.codedHeight,
+          aspectRatio,
+          decoderConfig: meta.decoderConfig,
+          alphaMode: track.metadata.canBeTransparent || (packet ? !!packet.sideData.alpha : null)
+        },
+        chunkQueue: [],
+        lastWrittenMsTimestamp: null,
+        codecPrivate: meta.decoderConfig.description ?? null,
+        closed: false
+      };
+      if (track.source._codec === "vp9") {
+        newTrackData.codecPrivate = new Uint8Array(generateVp9CodecConfigurationFromCodecString(newTrackData.info.decoderConfig.codec));
+      } else if (track.source._codec === "av1") {
+        newTrackData.codecPrivate = new Uint8Array(generateAv1CodecConfigurationFromCodecString(newTrackData.info.decoderConfig.codec));
+      } else if (track.source._codec === "prores") {
+        newTrackData.codecPrivate = textEncoder.encode(meta.decoderConfig.codec);
+      }
+      this.trackDatas.push(newTrackData);
+      this.trackDatas.sort((a, b) => a.track.id - b.track.id);
+      if (this.allTracksAreKnown()) {
+        this.allTracksKnown.resolve();
+      }
+      return newTrackData;
+    }
+    getAudioTrackData(track, packet, meta) {
+      const existingTrackData = this.trackDatas.find((x) => x.track === track);
+      if (existingTrackData) {
+        return existingTrackData;
+      }
+      validateAudioChunkMetadata(meta, track.source._codec);
+      assert(meta);
+      assert(meta.decoderConfig);
+      const decoderConfig = { ...meta.decoderConfig };
+      let requiresAdtsStripping = false;
+      if (track.source._codec === "aac" && !decoderConfig.description) {
+        if (!packet) {
+          throw new Error("No AAC description provided; you must therefore provide a priming packet.");
+        }
+        const adtsFrame = readAdtsFrameHeader(FileSlice.tempFromBytes(packet.data));
+        if (!adtsFrame) {
+          throw new Error("Couldn't parse ADTS header from the AAC packet. Make sure the packets are in ADTS format" + " (as specified in ISO 13818-7) when not providing a description, or provide a description" + " (must be an AudioSpecificConfig as specified in ISO 14496-3) and ensure the packets" + " are raw AAC data.");
+        }
+        const sampleRate = aacFrequencyTable[adtsFrame.samplingFrequencyIndex];
+        const numberOfChannels = aacChannelMap[adtsFrame.channelConfiguration];
+        if (sampleRate === undefined || numberOfChannels === undefined) {
+          throw new Error("Invalid ADTS frame header.");
+        }
+        decoderConfig.description = buildAacAudioSpecificConfig({
+          objectType: adtsFrame.objectType,
+          outputSampleRate: sampleRate,
+          outputNumberOfChannels: numberOfChannels
+        });
+        requiresAdtsStripping = true;
+      }
+      const newTrackData = {
+        track,
+        type: "audio",
+        info: {
+          numberOfChannels: meta.decoderConfig.numberOfChannels,
+          sampleRate: meta.decoderConfig.sampleRate,
+          decoderConfig,
+          requiresAdtsStripping
+        },
+        chunkQueue: [],
+        lastWrittenMsTimestamp: null,
+        codecPrivate: decoderConfig.description ?? null,
+        closed: false
+      };
+      this.trackDatas.push(newTrackData);
+      this.trackDatas.sort((a, b) => a.track.id - b.track.id);
+      if (this.allTracksAreKnown()) {
+        this.allTracksKnown.resolve();
+      }
+      return newTrackData;
+    }
+    getSubtitleTrackData(track, meta) {
+      const existingTrackData = this.trackDatas.find((x) => x.track === track);
+      if (existingTrackData) {
+        return existingTrackData;
+      }
+      validateSubtitleMetadata(meta);
+      assert(meta);
+      assert(meta.config);
+      const newTrackData = {
+        track,
+        type: "subtitle",
+        info: {
+          config: meta.config
+        },
+        chunkQueue: [],
+        lastWrittenMsTimestamp: null,
+        codecPrivate: textEncoder.encode(meta.config.description),
+        closed: false
+      };
+      this.trackDatas.push(newTrackData);
+      this.trackDatas.sort((a, b) => a.track.id - b.track.id);
+      if (this.allTracksAreKnown()) {
+        this.allTracksKnown.resolve();
+      }
+      return newTrackData;
+    }
+    async addEncodedVideoPacket(track, packet, meta) {
+      const release = await this.mutex.acquire();
+      try {
+        const trackData = this.getVideoTrackData(track, packet, meta);
+        trackData.info.alphaMode ??= !!packet.sideData.alpha;
+        let packetData = packet.data;
+        if (track.source._codec === "prores") {
+          if (packetData.byteLength < 8) {
+            throw new Error("ProRes packet too small, expected at least 8 bytes.");
+          }
+          packetData = packetData.subarray(8);
+        }
+        const isKeyFrame = packet.type === "key";
+        this.validateTimestamp(trackData.track, packet.timestamp, isKeyFrame);
+        let timestamp = packet.timestamp;
+        let duration = packet.duration;
+        if (track.metadata.frameRate !== undefined) {
+          timestamp = roundToDivisor(timestamp, track.metadata.frameRate);
+          duration = roundToDivisor(duration, track.metadata.frameRate);
+        }
+        const additions = trackData.info.alphaMode ? packet.sideData.alpha ?? null : null;
+        const videoChunk = this.createInternalChunk(packetData, timestamp, duration, packet.type, additions);
+        if (track.source._codec === "vp9")
+          this.fixVP9ColorSpace(trackData, videoChunk);
+        trackData.chunkQueue.push(videoChunk);
+        await this.interleaveChunks();
+      } finally {
+        release();
+      }
+    }
+    async addEncodedAudioPacket(track, packet, meta) {
+      const release = await this.mutex.acquire();
+      try {
+        const trackData = this.getAudioTrackData(track, packet, meta);
+        let packetData = packet.data;
+        if (trackData.info.requiresAdtsStripping) {
+          const adtsFrame = readAdtsFrameHeader(FileSlice.tempFromBytes(packetData));
+          if (!adtsFrame) {
+            throw new Error("Expected ADTS frame, didn't get one.");
+          }
+          const headerLength = adtsFrame.crcCheck === null ? MIN_ADTS_FRAME_HEADER_SIZE : MAX_ADTS_FRAME_HEADER_SIZE;
+          packetData = packetData.subarray(headerLength);
+        }
+        const isKeyFrame = packet.type === "key";
+        this.validateTimestamp(trackData.track, packet.timestamp, isKeyFrame);
+        const audioChunk = this.createInternalChunk(packetData, packet.timestamp, packet.duration, packet.type);
+        trackData.chunkQueue.push(audioChunk);
+        await this.interleaveChunks();
+      } finally {
+        release();
+      }
+    }
+    async addSubtitleCue(track, cue, meta) {
+      const release = await this.mutex.acquire();
+      try {
+        const trackData = this.getSubtitleTrackData(track, meta);
+        this.validateTimestamp(trackData.track, cue.timestamp, true);
+        let bodyText = cue.text;
+        const timestampMs = Math.round(cue.timestamp * 1000);
+        inlineTimestampRegex.lastIndex = 0;
+        bodyText = bodyText.replace(inlineTimestampRegex, (match) => {
+          const time = parseSubtitleTimestamp(match.slice(1, -1));
+          const offsetTime = time - timestampMs;
+          return \`<\${formatSubtitleTimestamp(offsetTime)}>\`;
+        });
+        const body = textEncoder.encode(bodyText);
+        const additions = \`\${cue.settings ?? ""}
+\${cue.identifier ?? ""}
+\${cue.notes ?? ""}\`;
+        const subtitleChunk = this.createInternalChunk(body, cue.timestamp, cue.duration, "key", additions.trim() ? textEncoder.encode(additions) : null);
+        trackData.chunkQueue.push(subtitleChunk);
+        await this.interleaveChunks();
+      } finally {
+        release();
+      }
+    }
+    async interleaveChunks(isFinalCall = false) {
+      if (!isFinalCall && !this.allTracksAreKnown()) {
+        return;
+      }
+      outer:
+        while (true) {
+          let trackWithMinTimestamp = null;
+          let minTimestamp = Infinity;
+          for (const trackData of this.trackDatas) {
+            if (!isFinalCall && trackData.chunkQueue.length === 0 && !trackData.closed) {
+              break outer;
+            }
+            if (trackData.chunkQueue.length > 0 && trackData.chunkQueue[0].timestamp < minTimestamp) {
+              trackWithMinTimestamp = trackData;
+              minTimestamp = trackData.chunkQueue[0].timestamp;
+            }
+          }
+          if (!trackWithMinTimestamp) {
+            break;
+          }
+          const chunk = trackWithMinTimestamp.chunkQueue.shift();
+          this.writeBlock(trackWithMinTimestamp, chunk);
+        }
+      if (!isFinalCall) {
+        await this.writer.flush();
+      }
+    }
+    fixVP9ColorSpace(trackData, chunk) {
+      if (chunk.type !== "key")
+        return;
+      if (!trackData.info.decoderConfig.colorSpace || !trackData.info.decoderConfig.colorSpace.matrix)
+        return;
+      const bitstream = new Bitstream(chunk.data);
+      bitstream.skipBits(2);
+      const profileLowBit = bitstream.readBits(1);
+      const profileHighBit = bitstream.readBits(1);
+      const profile = (profileHighBit << 1) + profileLowBit;
+      if (profile === 3)
+        bitstream.skipBits(1);
+      const showExistingFrame = bitstream.readBits(1);
+      if (showExistingFrame)
+        return;
+      const frameType = bitstream.readBits(1);
+      if (frameType !== 0)
+        return;
+      bitstream.skipBits(2);
+      const syncCode = bitstream.readBits(24);
+      if (syncCode !== 4817730)
+        return;
+      if (profile >= 2)
+        bitstream.skipBits(1);
+      const colorSpaceID = {
+        rgb: 7,
+        bt709: 2,
+        bt470bg: 1,
+        smpte170m: 3
+      }[trackData.info.decoderConfig.colorSpace.matrix];
+      writeBits(chunk.data, bitstream.pos, bitstream.pos + 3, colorSpaceID);
+    }
+    createInternalChunk(data, timestamp, duration, type, additions = null) {
+      const internalChunk = {
+        data,
+        type,
+        timestamp,
+        duration,
+        additions
+      };
+      return internalChunk;
+    }
+    writeBlock(trackData, chunk) {
+      if (!this.segment) {
+        this.createSegment();
+      }
+      const msTimestamp = Math.round(1000 * chunk.timestamp);
+      const keyFrameQueuedEverywhere = this.trackDatas.every((otherTrackData) => {
+        if (trackData === otherTrackData) {
+          return chunk.type === "key";
+        }
+        const firstQueuedSample = otherTrackData.chunkQueue[0];
+        if (firstQueuedSample) {
+          return firstQueuedSample.type === "key";
+        }
+        return otherTrackData.closed;
+      });
+      let shouldCreateNewCluster = false;
+      if (!this.currentCluster) {
+        shouldCreateNewCluster = true;
+      } else {
+        assert(this.currentClusterStartMsTimestamp !== null);
+        assert(this.currentClusterMaxMsTimestamp !== null);
+        const relativeTimestamp = msTimestamp - this.currentClusterStartMsTimestamp;
+        shouldCreateNewCluster = keyFrameQueuedEverywhere && msTimestamp > this.currentClusterMaxMsTimestamp && relativeTimestamp >= 1000 * (this.format._options.minimumClusterDuration ?? 1) || relativeTimestamp > MAX_CLUSTER_TIMESTAMP_MS;
+      }
+      if (shouldCreateNewCluster) {
+        this.createNewCluster(msTimestamp);
+      }
+      const relativeTimestamp = msTimestamp - this.currentClusterStartMsTimestamp;
+      if (relativeTimestamp < MIN_CLUSTER_TIMESTAMP_MS) {
+        if (!this.warnedAboutTooNegativeTimestamp) {
+          const formatName = this.format instanceof WebMOutputFormat ? "WebM" : "Matroska";
+          Logging._warn(\`Packets had to be discarded because their timestamp is too negative to represent in\` + \` \${formatName}.\`);
+          this.warnedAboutTooNegativeTimestamp = true;
+        }
+        return;
+      }
+      const prelude = new Uint8Array(4);
+      const view = new DataView(prelude.buffer);
+      view.setUint8(0, 128 | trackData.track.id);
+      view.setInt16(1, relativeTimestamp, false);
+      const msDuration = Math.round(1000 * chunk.duration);
+      const needsBlockGroup = !!chunk.additions || trackData.type === "subtitle";
+      if (!needsBlockGroup) {
+        view.setUint8(3, Number(chunk.type === "key") << 7);
+        const simpleBlock = { id: EBMLId.SimpleBlock, data: [
+          prelude,
+          chunk.data
+        ] };
+        this.ebmlWriter.writeEBML(simpleBlock);
+      } else {
+        const blockGroup = { id: EBMLId.BlockGroup, data: [
+          { id: EBMLId.Block, data: [
+            prelude,
+            chunk.data
+          ] },
+          chunk.type === "delta" ? {
+            id: EBMLId.ReferenceBlock,
+            data: new EBMLSignedInt(trackData.lastWrittenMsTimestamp - msTimestamp)
+          } : null,
+          chunk.additions ? { id: EBMLId.BlockAdditions, data: [
+            { id: EBMLId.BlockMore, data: [
+              { id: EBMLId.BlockAddID, data: 1 },
+              { id: EBMLId.BlockAdditional, data: chunk.additions }
+            ] }
+          ] } : null,
+          msDuration > 0 ? { id: EBMLId.BlockDuration, data: msDuration } : null
+        ] };
+        this.ebmlWriter.writeEBML(blockGroup);
+      }
+      this.startTimestamp = Math.min(this.startTimestamp, msTimestamp);
+      this.endTimestamp = Math.max(this.endTimestamp, msTimestamp + msDuration);
+      trackData.lastWrittenMsTimestamp = msTimestamp;
+      if (!this.trackDatasInCurrentCluster.has(trackData)) {
+        this.trackDatasInCurrentCluster.set(trackData, {
+          firstMsTimestamp: msTimestamp
+        });
+      }
+      this.currentClusterMaxMsTimestamp = Math.max(this.currentClusterMaxMsTimestamp, msTimestamp);
+    }
+    createNewCluster(msTimestamp) {
+      msTimestamp = Math.max(0, msTimestamp);
+      if (this.currentCluster) {
+        this.finalizeCurrentCluster();
+      }
+      if (this.format._options.onCluster) {
+        this.writer.startTrackingWrites();
+      }
+      this.currentCluster = {
+        id: EBMLId.Cluster,
+        size: this.format._options.appendOnly ? -1 : CLUSTER_SIZE_BYTES,
+        data: [
+          { id: EBMLId.Timestamp, data: msTimestamp }
+        ]
+      };
+      this.ebmlWriter.writeEBML(this.currentCluster);
+      this.currentClusterStartMsTimestamp = msTimestamp;
+      this.currentClusterMaxMsTimestamp = msTimestamp;
+      this.trackDatasInCurrentCluster.clear();
+    }
+    finalizeCurrentCluster() {
+      assert(this.currentCluster);
+      if (!this.format._options.appendOnly) {
+        const clusterSize = this.writer.getPos() - this.ebmlWriter.dataOffsets.get(this.currentCluster);
+        const endPos = this.writer.getPos();
+        this.writer.seek(this.ebmlWriter.offsets.get(this.currentCluster) + 4);
+        this.ebmlWriter.writeVarInt(clusterSize, CLUSTER_SIZE_BYTES);
+        this.writer.seek(endPos);
+      }
+      if (this.format._options.onCluster) {
+        assert(this.currentClusterStartMsTimestamp !== null);
+        const { data, start } = this.writer.stopTrackingWrites();
+        this.format._options.onCluster(data, start, this.currentClusterStartMsTimestamp / 1000);
+      }
+      const clusterOffsetFromSegment = this.ebmlWriter.offsets.get(this.currentCluster) - this.segmentDataOffset;
+      const groupedByTimestamp = new Map;
+      for (const [trackData, { firstMsTimestamp }] of this.trackDatasInCurrentCluster) {
+        if (!groupedByTimestamp.has(firstMsTimestamp)) {
+          groupedByTimestamp.set(firstMsTimestamp, []);
+        }
+        groupedByTimestamp.get(firstMsTimestamp).push(trackData);
+      }
+      const groupedAndSortedByTimestamp = [...groupedByTimestamp.entries()].sort((a, b) => a[0] - b[0]);
+      for (const [msTimestamp, trackDatas] of groupedAndSortedByTimestamp) {
+        assert(this.cues);
+        this.cues.data.push({ id: EBMLId.CuePoint, data: [
+          { id: EBMLId.CueTime, data: Math.max(0, msTimestamp) },
+          ...trackDatas.map((trackData) => {
+            return { id: EBMLId.CueTrackPositions, data: [
+              { id: EBMLId.CueTrack, data: trackData.track.id },
+              { id: EBMLId.CueClusterPosition, data: clusterOffsetFromSegment }
+            ] };
+          })
+        ] });
+      }
+    }
+    async onTrackClose(track) {
+      const release = await this.mutex.acquire();
+      const trackData = this.trackDatas.find((x) => x.track === track);
+      if (trackData) {
+        trackData.closed = true;
+      }
+      if (this.allTracksAreKnown()) {
+        this.allTracksKnown.resolve();
+      }
+      await this.interleaveChunks();
+      release();
+    }
+    async finalize() {
+      const release = await this.mutex.acquire();
+      this.allTracksKnown.resolve();
+      for (const trackData of this.trackDatas) {
+        trackData.closed = true;
+      }
+      if (!this.segment) {
+        this.createSegment();
+      }
+      await this.interleaveChunks(true);
+      if (this.currentCluster) {
+        this.finalizeCurrentCluster();
+      }
+      assert(this.cues);
+      this.ebmlWriter.writeEBML(this.cues);
+      if (!this.format._options.appendOnly) {
+        const segmentSize = this.writer.getPos() - this.segmentDataOffset;
+        this.writer.seek(this.ebmlWriter.offsets.get(this.segment) + 4);
+        this.ebmlWriter.writeVarInt(segmentSize, SEGMENT_SIZE_BYTES);
+        const duration = this.startTimestamp === Infinity ? 0 : this.endTimestamp;
+        this.segmentDuration.data = new EBMLFloat64(duration);
+        this.writer.seek(this.ebmlWriter.offsets.get(this.segmentDuration));
+        this.ebmlWriter.writeEBML(this.segmentDuration);
+        assert(this.seekHead);
+        this.writer.seek(this.ebmlWriter.offsets.get(this.seekHead));
+        this.maybeCreateSeekHead(true);
+        this.ebmlWriter.writeEBML(this.seekHead);
+      }
+      release();
+    }
+  }
+
   // ../../node_modules/.bun/mediabunny@1.61.3/node_modules/mediabunny/dist/modules/src/resample.js
   /*!
    * Copyright (c) 2026-present, Vanilagy and contributors
@@ -23737,6 +25941,97 @@ var workerCode = `(() => {
     }
   }
 
+  class MkvOutputFormat extends OutputFormat {
+    constructor(options = {}) {
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.appendOnly !== undefined && typeof options.appendOnly !== "boolean") {
+        throw new TypeError("options.appendOnly, when provided, must be a boolean.");
+      }
+      if (options.minimumClusterDuration !== undefined && (!isNumber(options.minimumClusterDuration) || options.minimumClusterDuration < 0)) {
+        throw new TypeError("options.minimumClusterDuration, when provided, must be a non-negative number.");
+      }
+      if (options.onEbmlHeader !== undefined && typeof options.onEbmlHeader !== "function") {
+        throw new TypeError("options.onEbmlHeader, when provided, must be a function.");
+      }
+      if (options.onSegmentHeader !== undefined && typeof options.onSegmentHeader !== "function") {
+        throw new TypeError("options.onHeader, when provided, must be a function.");
+      }
+      if (options.onCluster !== undefined && typeof options.onCluster !== "function") {
+        throw new TypeError("options.onCluster, when provided, must be a function.");
+      }
+      super();
+      this._options = options;
+    }
+    _createMuxer(output) {
+      return new MatroskaMuxer(output, this);
+    }
+    get _name() {
+      return "Matroska";
+    }
+    getSupportedTrackCounts() {
+      const max = 127;
+      return {
+        video: { min: 0, max },
+        audio: { min: 0, max },
+        subtitle: { min: 0, max },
+        total: { min: 0, max }
+      };
+    }
+    get fileExtension() {
+      return ".mkv";
+    }
+    get mimeType() {
+      return "video/x-matroska";
+    }
+    getSupportedCodecs() {
+      return [
+        ...VIDEO_CODECS,
+        ...NON_PCM_AUDIO_CODECS,
+        ...PCM_AUDIO_CODECS.filter((codec) => !["pcm-s8", "pcm-f32be", "pcm-f64be", "ulaw", "alaw"].includes(codec)),
+        ...SUBTITLE_CODECS
+      ];
+    }
+    get supportsVideoTransformationMetadata() {
+      return false;
+    }
+    get supportsTimestampedMediaData() {
+      return true;
+    }
+    get negativeTimestampSupport() {
+      return "prefer-non-negative";
+    }
+  }
+
+  class WebMOutputFormat extends MkvOutputFormat {
+    constructor(options) {
+      super(options);
+    }
+    getSupportedCodecs() {
+      return [
+        ...VIDEO_CODECS.filter((codec) => ["vp8", "vp9", "av1"].includes(codec)),
+        ...AUDIO_CODECS.filter((codec) => ["opus", "vorbis"].includes(codec)),
+        ...SUBTITLE_CODECS
+      ];
+    }
+    get _name() {
+      return "WebM";
+    }
+    get fileExtension() {
+      return ".webm";
+    }
+    get mimeType() {
+      return "video/webm";
+    }
+    _codecUnsupportedHint(codec) {
+      if (new MkvOutputFormat().getSupportedCodecs().includes(codec)) {
+        return " Switching to MKV will grant support for this codec.";
+      }
+      return "";
+    }
+  }
+
   // ../../node_modules/.bun/mediabunny@1.61.3/node_modules/mediabunny/dist/modules/src/output.js
   /*!
    * Copyright (c) 2026-present, Vanilagy and contributors
@@ -24358,6 +26653,34 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
     return value;
   }
 
+  // src/core/processor/worker/audio-only-config.ts
+  var AUDIO_CODEC_CONTAINERS = {
+    aac: "mp4",
+    opus: "webm"
+  };
+  function validateAudioOnlyWorkerConfig(config, audioConfig) {
+    if (!audioConfig) {
+      throw new Error("Audio-only recording requires an audio input");
+    }
+    if (audioConfig.sampleRate <= 0) {
+      throw new Error("Audio sample rate must be greater than zero");
+    }
+    if (audioConfig.numberOfChannels <= 0) {
+      throw new Error("Audio channels must be greater than zero");
+    }
+    if (!Number.isFinite(config.audioBitrate) || config.audioBitrate <= 0) {
+      throw new Error("Audio bitrate must be greater than zero");
+    }
+    const expectedFormat = AUDIO_CODEC_CONTAINERS[config.audioCodec];
+    if (expectedFormat === undefined) {
+      throw new Error(\`Audio codec \${config.audioCodec} is not supported\`);
+    }
+    if (config.format !== expectedFormat) {
+      throw new Error(\`Audio codec \${config.audioCodec} requires the \${expectedFormat} container\`);
+    }
+    return audioConfig;
+  }
+
   // src/core/processor/worker/audio-state.ts
   var MILLISECONDS_PER_SECOND = 1000;
 
@@ -25539,6 +27862,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
   }
 
   // src/core/processor/worker/types.ts
+  var WORKER_MESSAGE_TYPE_START_AUDIO = "startAudio";
   var WORKER_MESSAGE_TYPE_PROBE = "probe";
   var WORKER_MESSAGE_TYPE_WARMUP = "warmup";
   var WORKER_MESSAGE_TYPE_AUDIO_CHUNK = "audioChunk";
@@ -25758,6 +28082,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
     videoProcessingRunId = 0;
     totalFrameErrors = 0;
     totalFramesProcessed = 0;
+    isAudioOnly = false;
     constructor() {
       this.bufferTracker = new BufferTracker({
         getBufferSize: () => this.totalSize,
@@ -25878,6 +28203,9 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         case "start":
           this.handleStartMessage(message);
           return;
+        case WORKER_MESSAGE_TYPE_START_AUDIO:
+          this.handleStartAudioMessage(message);
+          return;
         case "pause":
           this.handlePause();
           return;
@@ -25927,6 +28255,40 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       }
       this.handleAsyncOperation(this.handleStart(message, videoTrack, videoStream), "handleStart");
     }
+    handleStartAudioMessage(message) {
+      if (this.shouldIgnoreMessage()) {
+        logger.debug("[RecorderWorker] startAudio ignored (stopping/finalized)");
+        return;
+      }
+      this.handleAsyncOperation(this.handleAudioOnlyStart(message), "handleAudioOnlyStart");
+    }
+    async handleAudioOnlyStart(message) {
+      const audioConfig = validateAudioOnlyWorkerConfig(message.config, message.audioConfig);
+      this.isStopping = false;
+      this.isFinalized = false;
+      if (this.output) {
+        await this.cleanup();
+      }
+      this.isAudioOnly = true;
+      this.config = null;
+      this.audioState.reset();
+      this.pendingWriteCount = 0;
+      this.expectedAudioChannels = audioConfig.numberOfChannels;
+      this.expectedAudioSampleRate = audioConfig.sampleRate;
+      this.createOutput(message.config.format);
+      this.audioSource = new AudioSampleSource({
+        codec: message.config.audioCodec,
+        bitrate: message.config.audioBitrate,
+        bitrateMode: "variable"
+      });
+      const output = requireNonNull(this.output, "Output must be initialized before adding audio track");
+      output.addAudioTrack(this.audioSource);
+      this.audioState.setProcessingActive(true);
+      await output.start();
+      this.bufferTracker.start();
+      this.sendReady();
+      this.sendStateChange("recording");
+    }
     handleStopMessage() {
       if (this.shouldIgnoreMessage()) {
         logger.debug("[RecorderWorker] stop ignored (stopping/finalized)");
@@ -26003,12 +28365,12 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       };
       logger.debug("[RecorderWorker] Overlay config initialized", logData);
     }
-    createOutput() {
+    createOutput(container = "mp4") {
       const writable = new WritableStream({
         write: (chunk) => this.handleOutputChunkWrite(chunk)
       });
       this.output = new Output({
-        format: new Mp4OutputFormat({
+        format: container === "webm" ? new WebMOutputFormat : new Mp4OutputFormat({
           fastStart: MP4_FAST_START_DISABLED
         }),
         target: new StreamTarget(writable, {
@@ -26164,6 +28526,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         logger.debug("[RecorderWorker] Cleaning up existing output");
         await this.cleanup();
       }
+      this.isAudioOnly = false;
       this.initializeRecordingState(config);
       const resolvedVideoSettings = message.videoSettings;
       if (resolvedVideoSettings) {
@@ -26619,6 +28982,9 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         timeoutMilliseconds: STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS2
       });
       this.sendRecordingStats();
+      if (this.isAudioOnly) {
+        return;
+      }
       this.logEarlyFrameWarning();
       const integrity = validateRecordingIntegrity({
         frameCount: this.timestampManager.getFrameCount(),
@@ -26793,6 +29159,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       this.totalFrameErrors = 0;
       this.totalFramesProcessed = 0;
       this.visibilityTracker.reset(this.recordingStartTime, this.isScreenCapture);
+      this.isAudioOnly = false;
     }
     setExpectedAudioFormat(sampleRate, numberOfChannels) {
       if (this.expectedAudioSampleRate === null) {
@@ -27038,6 +29405,7 @@ class WorkerProcessor {
   videoFramePreflightDeps;
   noFrameWatchdogId = null;
   watchdogDelayMs;
+  audioOnlyRecording = null;
   constructor(dependencies = {}) {
     let createWorkerFn = (workerUrl) => new Worker(workerUrl, { type: "classic" });
     if (dependencies.createWorker) {
@@ -27216,9 +29584,14 @@ class WorkerProcessor {
     return this.workerProbeManager.getProbeResult(worker);
   }
   async startProcessing(stream, config, overlayConfig) {
+    if (config.mediaType === "audio") {
+      await this.startAudioOnlyProcessing(stream, config.audioRecording);
+      return;
+    }
     this.getWorkerOrThrow();
     this.ensureProcessingInactive();
     this.resetProcessingState(overlayConfig);
+    this.audioOnlyRecording = null;
     this.stopAudioWorklet();
     this.audioWorkletManager = new AudioWorkletManager({
       onChunk: this.handleAudioWorkletChunk.bind(this)
@@ -27310,6 +29683,57 @@ class WorkerProcessor {
       throw error;
     }
   }
+  async startAudioOnlyProcessing(stream, audioRecording) {
+    if (!audioRecording) {
+      throw new Error("Audio recording config is required");
+    }
+    this.getWorkerOrThrow();
+    this.ensureProcessingInactive();
+    this.resetProcessingState();
+    this.stopAudioWorklet();
+    this.audioWorkletManager = new AudioWorkletManager({
+      onChunk: this.handleAudioWorkletChunk.bind(this)
+    });
+    await this.prepareAudioOnlyStart(stream, audioRecording).catch((error) => {
+      this.audioOnlyRecording = null;
+      this.resetStartProcessingStateAfterFailure();
+      throw error;
+    });
+    this.startAudioHealthMonitoring();
+  }
+  async prepareAudioOnlyStart(stream, audioRecording) {
+    const audioTrack = prepareAudioTrack(stream.getAudioTracks(), this.getVideoInputSelectorDependencies());
+    if (!audioTrack) {
+      throw createAudioNoTrackAtStartError();
+    }
+    const audioConfig = await this.audioWorkletManager.prepareAudioConfig(audioTrack, audioRecording.channels);
+    if (!audioConfig) {
+      throw this.createBrowserUnsupportedError();
+    }
+    const outputFormat = await resolveAudioOutputFormat(audioRecording.format, {
+      isLinuxPlatform: this.isLinuxPlatformFn(),
+      canEncode: (format) => canEncodeAudio2(format, {
+        numberOfChannels: audioConfig.numberOfChannels,
+        sampleRate: audioConfig.sampleRate,
+        bitrate: audioRecording.bitrate
+      })
+    });
+    this.audioOnlyRecording = {
+      outputFormat,
+      bitrate: audioRecording.bitrate,
+      peaks: new AudioPeaksAccumulator
+    };
+    const message = {
+      type: WORKER_MESSAGE_TYPE_START_AUDIO,
+      audioConfig,
+      config: {
+        format: outputFormat.container,
+        audioCodec: outputFormat.format,
+        audioBitrate: audioRecording.bitrate
+      }
+    };
+    await this.postStartMessage(message, [], true);
+  }
   getWorkerOrThrow() {
     if (!this.worker) {
       throw new Error("Worker not initialized");
@@ -27326,6 +29750,7 @@ class WorkerProcessor {
       return;
     }
     this.recordAudioHealthChunk(chunk);
+    this.audioOnlyRecording?.peaks.addPlanarSamples(chunk.data, chunk.frames, chunk.numberOfChannels, chunk.sampleRate);
     const message = {
       type: WORKER_MESSAGE_TYPE_AUDIO_CHUNK,
       data: chunk.data,
@@ -27428,7 +29853,7 @@ class WorkerProcessor {
     this.noFrameWatchdogId = null;
   }
   handleNoFrameWatchdogStats(stats) {
-    if (!this.isActive || stats.videoFrameCount > 0) {
+    if (!this.isActive || this.audioOnlyRecording !== null || stats.videoFrameCount > 0) {
       return;
     }
     logger.error("[WorkerProcessor] No video frames received after watchdog delay", {
@@ -27701,6 +30126,7 @@ class WorkerProcessor {
     const message = { type: "pause" };
     this.worker.postMessage(message);
     this.setAudioWorkletPaused(true);
+    this.audioHealthMonitor.pause(performance.now());
   }
   resume() {
     if (!(this.isWorkerActive() && this.worker)) {
@@ -27709,6 +30135,7 @@ class WorkerProcessor {
     const message = { type: "resume" };
     this.worker.postMessage(message);
     this.setAudioWorkletPaused(false);
+    this.audioHealthMonitor.resume(performance.now());
   }
   isWorkerActive() {
     return !!(this.worker && this.isActive);
@@ -27945,6 +30372,9 @@ class WorkerProcessor {
     for (const chunk of sortedChunks) {
       view.set(chunk.data, chunk.position);
     }
+    if (this.audioOnlyRecording) {
+      return this.createAudioOnlyResult(buffer, this.audioOnlyRecording);
+    }
     assertMp4ContainerIsNonFragmented(buffer);
     assertMp4HasVideoTrack(buffer);
     if (this.audioWasExpected) {
@@ -27968,6 +30398,29 @@ class WorkerProcessor {
     }
     return streamProcessorResult;
   }
+  createAudioOnlyResult(buffer, recording) {
+    this.audioOnlyRecording = null;
+    if (recording.outputFormat.container === "mp4") {
+      assertMp4ContainerIsNonFragmented(buffer);
+    }
+    this.assertRuntimeAudioHealth();
+    if (recording.outputFormat.container === "mp4") {
+      assertMp4HasAudioTrack(buffer);
+    }
+    const blob = new Blob([buffer], {
+      type: recording.outputFormat.mimeType
+    });
+    return {
+      blob,
+      totalSize: this.totalSize,
+      audio: {
+        blob,
+        outputFormat: recording.outputFormat,
+        bitrate: recording.bitrate,
+        peaks: recording.peaks.toPeaks()
+      }
+    };
+  }
   rejectFinalizeBlobCreationError(reject, error, finalizeStartedAtMilliseconds) {
     logger.error("[WorkerProcessor] Finalize failed while creating blob", {
       elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3,
@@ -27992,6 +30445,7 @@ class WorkerProcessor {
     this.isPaused = false;
     this.chunks = [];
     this.totalSize = 0;
+    this.audioOnlyRecording = null;
     this.audioWasExpected = false;
     this.emittedAudioWarnings = new Set;
     this.audioTrackEndedDuringSession = false;
@@ -28407,19 +30861,19 @@ class StreamProcessor {
 }
 
 // src/core/transcode/deferred-video-transcoder.ts
-import { ALL_FORMATS as ALL_FORMATS3, BlobSource as BlobSource4, EncodedPacketSink as EncodedPacketSink2, Input as Input4 } from "mediabunny";
+import { ALL_FORMATS as ALL_FORMATS4, BlobSource as BlobSource5, EncodedPacketSink as EncodedPacketSink2, Input as Input5 } from "mediabunny";
 
 // src/core/transcode/deferred-video-timing-repair.ts
 import {
-  ALL_FORMATS as ALL_FORMATS2,
-  BlobSource as BlobSource3,
-  BufferTarget as BufferTarget2,
+  ALL_FORMATS as ALL_FORMATS3,
+  BlobSource as BlobSource4,
+  BufferTarget as BufferTarget3,
   EncodedAudioPacketSource,
   EncodedPacketSink,
   EncodedVideoPacketSource,
-  Input as Input3,
-  Mp4OutputFormat as Mp4OutputFormat2,
-  Output as Output2
+  Input as Input4,
+  Mp4OutputFormat as Mp4OutputFormat3,
+  Output as Output3
 } from "mediabunny";
 var MINIMUM_IMPLAUSIBLE_DURATION_SECONDS = 60;
 var EXPECTED_DURATION_MULTIPLIER = 2;
@@ -28609,9 +31063,9 @@ async function remuxRepairedVideo(input, videoTrack, plan) {
       throw new Error("Timing repair requires a supported audio codec");
     }
   }
-  const target = new BufferTarget2;
-  const output = new Output2({
-    format: new Mp4OutputFormat2({ fastStart: "in-memory" }),
+  const target = new BufferTarget3;
+  const output = new Output3({
+    format: new Mp4OutputFormat3({ fastStart: "in-memory" }),
     target
   });
   const videoSource = new EncodedVideoPacketSource(videoCodec);
@@ -28636,9 +31090,9 @@ async function remuxRepairedVideo(input, videoTrack, plan) {
   return new Blob([target.buffer], { type: "video/mp4" });
 }
 async function repairDeferredVideoTiming(blob, expectedDurationSeconds) {
-  const input = new Input3({
-    formats: ALL_FORMATS2,
-    source: new BlobSource3(blob)
+  const input = new Input4({
+    formats: ALL_FORMATS3,
+    source: new BlobSource4(blob)
   });
   try {
     const videoTrack = await input.getPrimaryVideoTrack();
@@ -28813,9 +31267,9 @@ function validateDeferredVideoStatsWithDiagnostics(validation, additionalDiagnos
   }
 }
 async function inspectVideoPackets(blob) {
-  const input = new Input4({
-    formats: ALL_FORMATS3,
-    source: new BlobSource4(blob)
+  const input = new Input5({
+    formats: ALL_FORMATS4,
+    source: new BlobSource5(blob)
   });
   const videoTrack = await input.getPrimaryVideoTrack();
   if (videoTrack === null) {
@@ -28950,7 +31404,8 @@ var DEFAULT_ROUTE_DECISION2 = {
   reasonCodes: ["webcodecs-supported", "target-codec-supported"]
 };
 var DEFAULT_RECORDING_MANAGER_DEPENDENCIES = {
-  transcodeVideo: transcodeDeferredVideo
+  transcodeVideo: transcodeDeferredVideo,
+  convertRecordedAudio
 };
 
 class RecordingManager {
@@ -28962,6 +31417,8 @@ class RecordingManager {
   countdownStartTime = null;
   isPaused = false;
   maxRecordingTime = null;
+  activeMaxRecordingTime = null;
+  lastAudioRecording = null;
   maxTimeTimer = null;
   recordingStartTime = null;
   maxTimeRemaining = null;
@@ -29004,6 +31461,12 @@ class RecordingManager {
   isPausedState() {
     return this.isPaused;
   }
+  getAudioRecording(blob) {
+    if (this.lastAudioRecording?.blob !== blob) {
+      return null;
+    }
+    return this.lastAudioRecording;
+  }
   getRecordingSeconds() {
     return this.recordingSeconds;
   }
@@ -29151,8 +31614,9 @@ class RecordingManager {
     this.callbacks.onStateChange(this.recordingState);
     this.startRecordingTimer();
     this.recordingStartTime = Date.now();
-    if (this.maxRecordingTime && this.maxRecordingTime > 0) {
-      this.maxTimeRemaining = this.maxRecordingTime;
+    this.activeMaxRecordingTime = this.maxRecordingTime;
+    if (this.activeMaxRecordingTime && this.activeMaxRecordingTime > 0) {
+      this.maxTimeRemaining = this.activeMaxRecordingTime;
       this.startMaxTimeTimer();
     }
   }
@@ -29186,7 +31650,9 @@ class RecordingManager {
       this.callbacks.onStopAudioTracking();
       logger.debug("[RecordingManager] Stopping recording in stream manager");
       const stopResult = await this.streamManager.stopRecording();
-      const finalResult = await this.resolveFinalRecordingBlob(stopResult.blob, stopResult.captureFrameRate, stopResult.expectedDurationSeconds);
+      const audioRecording = await this.resolveAudioRecording(stopResult.blob, stopResult.audio);
+      this.lastAudioRecording = audioRecording;
+      const finalResult = audioRecording === null ? await this.resolveFinalRecordingBlob(stopResult.blob, stopResult.captureFrameRate, stopResult.expectedDurationSeconds) : { blob: audioRecording.blob };
       const finalBlob = finalResult.blob;
       logger.info("[RecordingManager] Recording stopped, blob size:", finalBlob.size);
       this.recordingState = RECORDING_STATE_IDLE;
@@ -29212,6 +31678,15 @@ class RecordingManager {
       if (finalResult.diagnostics !== undefined) {
         Object.assign(telemetryProperties, finalResult.diagnostics);
       }
+      if (audioRecording !== null) {
+        telemetryProperties.mediaType = "audio";
+        telemetryProperties.audioFormat = audioRecording.format;
+        return {
+          blob: finalBlob,
+          telemetryProperties,
+          audio: audioRecording
+        };
+      }
       return {
         blob: finalBlob,
         telemetryProperties
@@ -29241,9 +31716,9 @@ class RecordingManager {
     this.clearTimer(this.recordingIntervalId, clearInterval);
     this.recordingIntervalId = null;
     this.pauseStartTime = Date.now();
-    if (this.maxTimeTimer !== null && this.recordingStartTime !== null && this.maxRecordingTime !== null) {
+    if (this.maxTimeTimer !== null && this.recordingStartTime !== null && this.activeMaxRecordingTime !== null) {
       const elapsed = Date.now() - this.recordingStartTime - this.totalPausedTime;
-      this.maxTimeRemaining = Math.max(0, this.maxRecordingTime - elapsed);
+      this.maxTimeRemaining = Math.max(0, this.activeMaxRecordingTime - elapsed);
       this.clearTimer(this.maxTimeTimer, clearTimeout);
       this.maxTimeTimer = null;
     }
@@ -29292,6 +31767,23 @@ class RecordingManager {
     this.recordingStartTime = null;
     this.maxTimeRemaining = null;
   }
+  async resolveAudioRecording(blob, encodedAudio) {
+    if (this.activeRecordingConfig?.mediaType !== "audio") {
+      return null;
+    }
+    if (encodedAudio) {
+      return await createAudioRecording(encodedAudio);
+    }
+    const audioConfig = requireEnabledAudioRecordingConfig(this.activeRecordingConfig.audioRecording);
+    this.callbacks.onTranscodingProgress?.(0);
+    const recording = await this.dependencies.convertRecordedAudio(blob, audioConfig, {
+      onProgress: (progress) => {
+        this.callbacks.onTranscodingProgress?.(progress);
+      }
+    });
+    this.callbacks.onTranscodingProgress?.(1);
+    return recording;
+  }
   async resolveFinalRecordingBlob(blob, captureFrameRate, expectedDurationSeconds) {
     if (this.activeRouteDecision.route !== "safe-capture-post-recording-transcode") {
       return { blob };
@@ -29573,7 +32065,7 @@ class RecorderController {
     this.uploadMetadataManager = new UploadMetadataManager;
     const recordingCallbacks = createRecordingCallbacks(callbacks, {
       stopAudioTracking: () => this.audioLevelAnalyzer.stopTracking(),
-      getConfig: () => Promise.resolve(this.configManager.getConfigForRecording()),
+      getConfig: () => Promise.resolve().then(() => this.resolveRecordingConfig()),
       getRouteDecision: async () => await this.resolveRecordingRouteDecision("live-recorder"),
       onAudioWarning: callbacks.recording?.onAudioWarning ? (warning) => {
         this.sendAudioWarningTelemetry(warning);
@@ -29680,6 +32172,13 @@ class RecorderController {
     });
   }
   async startStream(requestedSourceType = "camera") {
+    if (requestedSourceType === "audio") {
+      await this.startAudioStream();
+      return;
+    }
+    if (this.getCurrentSourceType() === "audio") {
+      this.streamManager.stopStream();
+    }
     const shouldStartScreenOnly = requestedSourceType === "screen" && this.sourceSwitchManager.shouldStartScreenWithoutCamera() && !this.streamManager.isActive();
     let sourceType = this.getCurrentSourceType();
     if (shouldStartScreenOnly) {
@@ -29708,6 +32207,72 @@ class RecorderController {
       }
     });
   }
+  async startAudioStream() {
+    await this.telemetryManager.executeAction({
+      succeededEvent: "preview.start.succeeded",
+      failedEvent: "preview.start.failed",
+      action: async () => {
+        await this.ensureConfigReady();
+        const config = await this.configManager.getConfig();
+        const audioConfig = requireEnabledAudioRecordingConfig(config.audioRecording);
+        const isAudioStreamActive = this.getCurrentSourceType() === "audio" && this.streamManager.isActive();
+        if (isAudioStreamActive) {
+          return;
+        }
+        if (this.streamManager.isActive()) {
+          this.streamManager.stopStream();
+        }
+        await this.sourceSwitchManager.startAudioOnly(buildAudioRecordingConstraints(audioConfig, this.deviceManager.getSelectedMicDeviceId()));
+      },
+      properties: {
+        sourceType: "audio"
+      }
+    });
+  }
+  resolveRecordingConfig() {
+    const config = this.configManager.getConfigForRecording();
+    if (this.getCurrentSourceType() !== "audio") {
+      return config;
+    }
+    return {
+      ...config,
+      mediaType: "audio",
+      audioRecording: requireEnabledAudioRecordingConfig(config.audioRecording)
+    };
+  }
+  getRecordingMediaType(blob) {
+    if (this.recordingManager.getAudioRecording(blob)) {
+      return "audio";
+    }
+    return "video";
+  }
+  async resolveRecordingUploadDetails(blob, title) {
+    const audioRecording = this.recordingManager.getAudioRecording(blob);
+    if (audioRecording) {
+      return {
+        filename: createRecordingFilename(title, audioRecording.extension),
+        mimeType: audioRecording.mimeType,
+        duration: audioRecording.duration,
+        mediaType: "audio",
+        sourceType: "audio",
+        audio: {
+          format: audioRecording.format,
+          bitrate: audioRecording.bitrate,
+          channels: audioRecording.channels,
+          sampleRate: audioRecording.sampleRate,
+          peaks: audioRecording.peaks
+        }
+      };
+    }
+    const outputFormat = this.configManager.getConfigForRecording().format;
+    return {
+      filename: createRecordingFilename(title, getFileExtensionForOutputFormat(outputFormat)),
+      mimeType: getMimeTypeForOutputFormat(outputFormat),
+      duration: await extractVideoDuration(blob),
+      mediaType: "video",
+      sourceType: this.getCurrentSourceType()
+    };
+  }
   async stopStream() {
     await this.streamManager.stopStream();
   }
@@ -29719,7 +32284,11 @@ class RecorderController {
     return this.streamManager.switchVideoDevice(deviceId);
   }
   switchAudioDevice(deviceId) {
-    return this.streamManager.switchAudioDevice(deviceId);
+    if (this.getCurrentSourceType() !== "audio") {
+      return this.streamManager.switchAudioDevice(deviceId);
+    }
+    const audioConfig = requireEnabledAudioRecordingConfig(this.configManager.getConfigForRecording().audioRecording);
+    return this.streamManager.switchAudioDevice(deviceId, buildAudioRecordingConstraints(audioConfig, null));
   }
   async startRecording(options = {}) {
     const sourceType = this.getCurrentSourceType();
@@ -29882,18 +32451,21 @@ class RecorderController {
   }
   async prepareLocalRecording(blob) {
     const title = this.recordingTitle;
-    const outputFormat = this.configManager.getConfigForRecording().format;
-    const sourceType = this.getCurrentSourceType();
-    const duration = await extractVideoDuration(blob);
+    const details = await this.resolveRecordingUploadDetails(blob, title);
     this.clearRecordingTitle(title);
-    return {
+    const localRecording = {
       blob,
       title,
-      filename: createRecordingFilename(title, getFileExtensionForOutputFormat(outputFormat)),
-      mimeType: getMimeTypeForOutputFormat(outputFormat),
-      duration,
-      sourceType
+      filename: details.filename,
+      mimeType: details.mimeType,
+      duration: details.duration,
+      sourceType: details.sourceType,
+      mediaType: details.mediaType
     };
+    if (details.audio) {
+      localRecording.audio = details.audio;
+    }
+    return localRecording;
   }
   uploadVideo(blob, apiKey, backendUrl, metadata, getAccessToken) {
     this.uploadCallbacks.onClearStatus();
@@ -29909,11 +32481,8 @@ class RecorderController {
   }
   async uploadVideoAfterStatusClear(blob, apiKey, backendUrl, metadata, getAccessToken) {
     const title = this.recordingTitle;
-    const duration = await extractVideoDuration(blob);
-    const outputFormat = this.configManager.getConfigForRecording().format;
-    const filename = createRecordingFilename(title, getFileExtensionForOutputFormat(outputFormat));
-    const mimeType = getMimeTypeForOutputFormat(outputFormat);
-    const sourceType = this.getCurrentSourceType();
+    const details = await this.resolveRecordingUploadDetails(blob, title);
+    const { filename, mimeType, duration, sourceType } = details;
     let userMetadata;
     if (Object.keys(metadata).length > 0) {
       userMetadata = metadata;
@@ -29933,7 +32502,9 @@ class RecorderController {
         mimeType,
         duration,
         sourceType,
-        userMetadata
+        userMetadata,
+        mediaType: details.mediaType,
+        audio: details.audio
       });
       this.clearRecordingTitle(title);
       return;
@@ -29946,7 +32517,9 @@ class RecorderController {
       mimeType,
       duration,
       metadata: undefined,
-      userMetadata
+      userMetadata,
+      mediaType: details.mediaType,
+      audio: details.audio
     });
     this.clearRecordingTitle(title);
     this.uploadMetadataManager.setMetadata(uploadId, {
@@ -29980,6 +32553,8 @@ class RecorderController {
         duration: options.duration,
         metadata: undefined,
         userMetadata: options.userMetadata,
+        mediaType: options.mediaType,
+        audio: options.audio,
         onProgress: this.uploadCallbacks.onProgress,
         onProgressDetails: (details) => {
           progressDetails = details;
@@ -29990,7 +32565,7 @@ class RecorderController {
         ...uploadOptions,
         ...options.apiKey !== null ? { apiKey: options.apiKey } : { getAccessToken: options.getAccessToken }
       });
-      this.uploadCallbacks.onSuccess(createRecordingUploadResult(result));
+      this.uploadCallbacks.onSuccess(createRecordingUploadResult(result, options.mediaType));
       this.telemetryManager.sendEvent("upload.succeeded", {
         filename: options.filename,
         duration: options.duration,
@@ -30141,6 +32716,20 @@ class RecorderController {
     }
   }
   async resolveRecordingRouteDecision(routeSourceType) {
+    if (this.getCurrentSourceType() === "audio") {
+      const capabilities = detectAudioRecordingCapabilities();
+      const audioDecision = decideAudioRecordingRoute(capabilities);
+      this.telemetryManager.sendEvent("recording.route.selected", {
+        routeDecision: {
+          selectedRoute: audioDecision.route,
+          reasonCodes: audioDecision.reasonCodes,
+          sourceType: routeSourceType,
+          mediaType: "audio",
+          capabilitySummary: capabilities
+        }
+      });
+      return audioDecision;
+    }
     const config = this.configManager.getConfigForRecording();
     const codecCandidates = this.buildCodecProbeCandidates(config);
     const codecProbeResults = await this.resolveCodecProbeResults(codecCandidates);
@@ -30500,7 +33089,7 @@ class QuotaManager {
   }
 }
 // src/core/transcode/upload-transcoder.ts
-import { ALL_FORMATS as ALL_FORMATS4, BlobSource as BlobSource5, Input as Input5 } from "mediabunny";
+import { ALL_FORMATS as ALL_FORMATS5, BlobSource as BlobSource6, Input as Input6 } from "mediabunny";
 var BITRATE_TOLERANCE = 1.25;
 var FRAME_RATE_TOLERANCE = 1.05;
 var DEFAULT_VIDEO_CODEC = "avc";
@@ -30547,9 +33136,9 @@ function canUploadWithoutTranscoding(fileType, source, config) {
   return source.bitrate <= config.bitrate * BITRATE_TOLERANCE;
 }
 async function readSourceVideo(file) {
-  const input = new Input5({
-    formats: ALL_FORMATS4,
-    source: new BlobSource5(file)
+  const input = new Input6({
+    formats: ALL_FORMATS5,
+    source: new BlobSource6(file)
   });
   const videoTrack = await input.getPrimaryVideoTrack();
   if (!videoTrack) {
@@ -30873,7 +33462,8 @@ class VidtreoRecorder {
   }
   async startRecording(options = {}, sourceType = "camera") {
     await this.ensureInitialized();
-    if (!this.controller.isActive()) {
+    const isAudioTransition = sourceType === "audio" || this.controller.getCurrentSourceType() === "audio";
+    if (!this.controller.isActive() || isAudioTransition) {
       await this.startPreview(sourceType);
     }
     if (this.controller.getCurrentSourceType() !== sourceType) {
@@ -30925,37 +33515,71 @@ class VidtreoRecorder {
   async stopRecording() {
     await this.ensureInitialized();
     const blob = await this.controller.stopRecording();
+    const title = this.controller.getRecordingTitle();
     if (this.config.autoUpload === false) {
-      this.controller.clearRecordingTitle(this.controller.getRecordingTitle());
-      return { recordingId: "", uploadUrl: "", blob };
+      this.controller.clearRecordingTitle(title);
+      return {
+        recordingId: "",
+        uploadUrl: "",
+        blob,
+        mediaType: this.controller.getRecordingMediaType(blob)
+      };
     }
-    const outputFormat = (await this.controller.getConfig()).format;
-    const title = this.controller.getRecordingTitle();
-    const filename = createRecordingFilename(title, getFileExtensionForOutputFormat(outputFormat));
-    const mimeType = getMimeTypeForOutputFormat(outputFormat);
-    const duration = await extractVideoDuration(blob);
+    const details = await this.controller.resolveRecordingUploadDetails(blob, title);
+    const result = await this.uploadMedia(blob, details);
+    this.controller.clearRecordingTitle(title);
+    return result;
+  }
+  async getAudioRecordingConfig() {
+    await this.ensureInitialized();
+    const config = await this.controller.getConfig();
+    if (!config.audioRecording) {
+      return { ...DISABLED_AUDIO_RECORDING_CONFIG };
+    }
+    return config.audioRecording;
+  }
+  async uploadAudio(audio) {
+    requireEnabledAudioRecordingConfig(await this.getAudioRecordingConfig());
+    return await this.uploadMedia(audio.blob, {
+      filename: audio.filename,
+      mimeType: audio.mimeType,
+      duration: audio.duration,
+      mediaType: "audio",
+      audio: {
+        format: audio.format,
+        bitrate: audio.bitrate,
+        channels: audio.channels,
+        sampleRate: audio.sampleRate,
+        peaks: audio.peaks
+      }
+    });
+  }
+  async uploadMedia(blob, details) {
     const uploadService = this.controller.getUploadService();
     if (!uploadService) {
       throw new Error("Upload service not available");
     }
-    const uploadOptions = {
+    const uploadResult = await uploadService.uploadVideo(blob, {
       backendUrl: this.config.apiUrl,
-      filename,
-      mimeType,
-      duration,
+      filename: details.filename,
+      mimeType: details.mimeType,
+      duration: details.duration,
       userMetadata: this.config.userMetadata,
-      onProgress: this.config.onUploadProgress
-    };
-    const uploadResult = await uploadService.uploadVideo(blob, {
-      ...uploadOptions,
+      onProgress: this.config.onUploadProgress,
+      mediaType: details.mediaType,
+      audio: details.audio,
       ...this.config.apiKey !== undefined ? { apiKey: this.config.apiKey } : { getAccessToken: this.config.getAccessToken }
     });
-    this.controller.clearRecordingTitle(title);
-    return {
+    const result = {
       recordingId: uploadResult.id,
       uploadUrl: uploadResult.uploadUrl || "",
-      blob
+      blob,
+      mediaType: details.mediaType
     };
+    if (details.mediaType === "audio") {
+      result.audioId = uploadResult.id;
+    }
+    return result;
   }
   async getAvailableDevices() {
     if (this.config.enableDeviceChange === false) {
@@ -31022,6 +33646,7 @@ class VidtreoRecorder {
   }
 }
 export {
+  AUDIO_OUTPUT_FORMATS,
   AudioLevelAnalyzer,
   CONFIG_ERROR_CREDENTIAL_CONFLICT,
   CREDENTIAL_CONFLICT_MESSAGE,
@@ -31033,8 +33658,14 @@ export {
   DEFAULT_RECORDING_OPTIONS,
   DEFAULT_STREAM_CONFIG,
   DEFAULT_TRANSCODE_CONFIG,
+  DISABLED_AUDIO_RECORDING_CONFIG,
   DeviceManager,
+  ERROR_AUDIO_CODEC_UNSUPPORTED,
+  ERROR_AUDIO_NO_AUDIO_TRACK,
   ERROR_AUDIO_NO_TRACK_AT_START,
+  ERROR_AUDIO_RECORDING_DISABLED,
+  ERROR_AUDIO_SOURCE_SWITCH_UNSUPPORTED,
+  ERROR_AUDIO_UNSUPPORTED_INPUT,
   ERROR_PICTURE_IN_PICTURE_UNSUPPORTED,
   ERROR_RECORDING_AUDIO_INVALID_SAMPLE_RATE,
   ERROR_RECORDING_AUDIO_NO_CHUNKS,
@@ -31098,6 +33729,7 @@ export {
   isPictureInPictureSupported,
   logger,
   mapPresetToConfig,
+  parseAudioRecordingConfig,
   parseBrowserErrorLinkContent,
   recoverPendingUpload,
   requireActive,
@@ -31110,6 +33742,7 @@ export {
   resolveDeviceError,
   resolvePictureInPictureConfig,
   sanitizeRecordingTitle,
+  transcodeAudioFile,
   transcodeVideo,
   transcodeVideoForNativeCamera,
   transcodeVideoForUpload,