@vidtreo/recorder 1.2.0 → 1.2.1

package/dist/index.js

@@ -300,7 +300,8 @@ function getDefaultConfigForFormat(format) {
   };
 }
 // src/core/processor/codec-detector.ts
-var VIDEO_CODEC_HEVC = "hevc";
+var VIDEO_CODEC_AV1 = "av1";
+var VIDEO_CODEC_VP9 = "vp9";
 var VIDEO_CODEC_AVC = "avc";
 var AUDIO_CODEC_AAC = "aac";
 var AUDIO_CODEC_OPUS = "opus";
@@ -347,6 +348,9 @@ function createVideoCodecSupportResult(supported) {
 function createVideoCodecSupportError(error) {
   return { kind: "error", error };
 }
+async function getVideoCodecSupport(canEncodeVideo, codec, checkOptions) {
+  return await canEncodeVideo(codec, checkOptions).then((supported) => createVideoCodecSupportResult(supported)).catch((error) => createVideoCodecSupportError(error));
+}
 function createAudioCodecLookupResult(codec) {
   return { kind: "result", codec };
 }
@@ -363,15 +367,41 @@ async function detectBestCodec(width, height, bitrate, dependencies) {
     return VIDEO_CODEC_AVC;
   }
   const checkOptions = buildVideoCodecCheckOptions(width, height, bitrate);
-  const videoCodecSupportResult = await canEncodeVideo(VIDEO_CODEC_HEVC, checkOptions).then((supported) => createVideoCodecSupportResult(supported)).catch((error) => createVideoCodecSupportError(error));
+  const videoCodecSupportResult = await getVideoCodecSupport(canEncodeVideo, VIDEO_CODEC_AV1, checkOptions);
   if (videoCodecSupportResult.kind === "error") {
     return VIDEO_CODEC_AVC;
   }
   if (videoCodecSupportResult.supported) {
-    return VIDEO_CODEC_HEVC;
+    return VIDEO_CODEC_AV1;
   }
   return VIDEO_CODEC_AVC;
 }
+async function detectBestWebmCodec(width, height, bitrate, dependencies) {
+  const mediabunnyModuleResult = await resolveMediabunnyModule(dependencies).then((module) => createMediabunnyModuleResult(module)).catch((error) => createMediabunnyModuleError(error));
+  if (mediabunnyModuleResult.kind === "error") {
+    return VIDEO_CODEC_VP9;
+  }
+  const { canEncodeVideo } = mediabunnyModuleResult.module;
+  if (typeof canEncodeVideo !== "function") {
+    return VIDEO_CODEC_VP9;
+  }
+  const checkOptions = buildVideoCodecCheckOptions(width, height, bitrate);
+  const av1SupportResult = await getVideoCodecSupport(canEncodeVideo, VIDEO_CODEC_AV1, checkOptions);
+  if (av1SupportResult.kind === "error") {
+    return VIDEO_CODEC_VP9;
+  }
+  if (av1SupportResult.supported) {
+    return VIDEO_CODEC_AV1;
+  }
+  const vp9SupportResult = await getVideoCodecSupport(canEncodeVideo, VIDEO_CODEC_VP9, checkOptions);
+  if (vp9SupportResult.kind === "error") {
+    return VIDEO_CODEC_VP9;
+  }
+  if (vp9SupportResult.supported) {
+    return VIDEO_CODEC_VP9;
+  }
+  return VIDEO_CODEC_VP9;
+}
 async function detectBestAudioCodec(bitrate, dependencies) {
   const mediabunnyModuleResult = await resolveMediabunnyModule(dependencies).then((module) => createMediabunnyModuleResult(module)).catch((error) => createMediabunnyModuleError(error));
   if (mediabunnyModuleResult.kind === "error") {
@@ -735,6 +765,7 @@ import {
   WebMOutputFormat
 } from "mediabunny";
 var ALLOW_ROTATION_METADATA = false;
+var OUTPUT_FORMAT_WEBM = "webm";
 function createSource(input) {
   if (typeof input === "string") {
     return new FilePathSource(input);
@@ -772,6 +803,12 @@ function getMimeTypeForFormat(format) {
       throw new Error(`Unsupported output format: ${format}`);
   }
 }
+async function resolvePreferredVideoCodec(config) {
+  if (config.format === OUTPUT_FORMAT_WEBM) {
+    return await detectBestWebmCodec(config.width, config.height, config.bitrate);
+  }
+  return await detectBestCodec(config.width, config.height, config.bitrate);
+}
 function createConversionOptions(config, optimizeForSpeed = false) {
   const audioCodec = getAudioCodecForFormat(config.format, config.audioCodec);
   const video = {
@@ -822,6 +859,7 @@ async function transcodeVideo(input, config = {}, onProgress) {
   if (!finalConfig.audioCodec) {
     finalConfig.audioCodec = await detectBestAudioCodec(finalConfig.audioBitrate);
   }
+  finalConfig.codec = await resolvePreferredVideoCodec(finalConfig);
   const source = createSource(input);
   const mediabunnyInput = new Input2({
     formats: ALL_FORMATS,
@@ -861,6 +899,7 @@ async function transcodeVideoForNativeCamera(file, config = {}, onProgress) {
   if (!finalConfig.audioCodec) {
     finalConfig.audioCodec = await detectBestAudioCodec(finalConfig.audioBitrate);
   }
+  finalConfig.codec = await resolvePreferredVideoCodec(finalConfig);
   const source = new BlobSource2(file);
   const mediabunnyInput = new Input2({
     formats: ALL_FORMATS,
@@ -1341,7 +1380,7 @@ function getEmptyProbeResult() {
 }
 // src/core/storage/video-storage.ts
 var DB_NAME = "vidtreo-recorder";
-var DB_VERSION = 1;
+var DB_VERSION = 2;
 var STORE_NAME = "pending-uploads";
 var STATUS_INDEX = "status";
 var CREATED_AT_INDEX = "createdAt";
@@ -1350,28 +1389,55 @@ var MAX_RETRIES = 10;
 var MILLISECONDS_PER_HOUR = 60 * 60 * 1000;
 var ID_PREFIX = "upload-";
 var ID_RANDOM_LENGTH = 9;
+var VERSION_ERROR_NAME = "VersionError";
+var ERROR_SCHEMA_MISSING_STORE = "Database schema is missing required object store: pending-uploads";
+var ERROR_SCHEMA_MISSING_STATUS_INDEX = "Database schema is missing required index: status";
+var ERROR_SCHEMA_MISSING_CREATED_AT_INDEX = "Database schema is missing required index: createdAt";
 
 class VideoStorageService {
   db = null;
+  databaseFactory;
+  constructor(databaseFactory) {
+    if (databaseFactory) {
+      this.databaseFactory = databaseFactory;
+      return;
+    }
+    this.databaseFactory = indexedDB;
+  }
   init() {
     if (this.db) {
       return Promise.resolve();
     }
+    return this.openDatabase(DB_VERSION, true);
+  }
+  openDatabase(databaseVersion, canRetryWithoutVersion) {
     return new Promise((resolve, reject) => {
-      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      const request = this.createOpenRequest(databaseVersion);
       request.onerror = () => {
-        if (request.error) {
-          reject(request.error);
-        } else {
-          reject(new Error("Failed to open database"));
+        const requestError = request.error;
+        if (canRetryWithoutVersion && requestError && requestError.name === VERSION_ERROR_NAME) {
+          this.openDatabase(undefined, false).then(resolve).catch(reject);
+          return;
         }
+        if (requestError) {
+          reject(requestError);
+          return;
+        }
+        reject(new Error("Failed to open database"));
       };
       request.onsuccess = () => {
         if (!request.result) {
           reject(new Error("Database result is null"));
           return;
         }
-        this.db = request.result;
+        const database = request.result;
+        const schemaValidationError = this.validateRequiredSchema(database);
+        if (schemaValidationError) {
+          database.close();
+          reject(schemaValidationError);
+          return;
+        }
+        this.db = database;
         resolve();
       };
       request.onupgradeneeded = (event) => {
@@ -1380,16 +1446,42 @@ class VideoStorageService {
           reject(new Error("Database upgrade result is null"));
           return;
         }
-        if (!db.objectStoreNames.contains(STORE_NAME)) {
-          const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
-          store.createIndex(STATUS_INDEX, STATUS_INDEX, { unique: false });
-          store.createIndex(CREATED_AT_INDEX, CREATED_AT_INDEX, {
-            unique: false
-          });
-        }
+        this.initializeStoreSchema(db);
       };
     });
   }
+  createOpenRequest(databaseVersion) {
+    if (databaseVersion === undefined) {
+      return this.databaseFactory.open(DB_NAME);
+    }
+    return this.databaseFactory.open(DB_NAME, databaseVersion);
+  }
+  initializeStoreSchema(database) {
+    if (database.objectStoreNames.contains(STORE_NAME)) {
+      return;
+    }
+    const objectStore = database.createObjectStore(STORE_NAME, {
+      keyPath: "id"
+    });
+    objectStore.createIndex(STATUS_INDEX, STATUS_INDEX, { unique: false });
+    objectStore.createIndex(CREATED_AT_INDEX, CREATED_AT_INDEX, {
+      unique: false
+    });
+  }
+  validateRequiredSchema(database) {
+    if (!database.objectStoreNames.contains(STORE_NAME)) {
+      return new Error(ERROR_SCHEMA_MISSING_STORE);
+    }
+    const transaction = database.transaction([STORE_NAME], "readonly");
+    const store = transaction.objectStore(STORE_NAME);
+    if (!store.indexNames.contains(STATUS_INDEX)) {
+      return new Error(ERROR_SCHEMA_MISSING_STATUS_INDEX);
+    }
+    if (!store.indexNames.contains(CREATED_AT_INDEX)) {
+      return new Error(ERROR_SCHEMA_MISSING_CREATED_AT_INDEX);
+    }
+    return null;
+  }
   isInitialized() {
     return this.db !== null;
   }
@@ -3105,9 +3197,11 @@ class StreamRecordingState {
     this.startRecordingTimer();
   }
   async stopRecording() {
+    const recordingElapsedSeconds = (performance.now() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND;
     logger.debug("[StreamRecordingState] stopRecording called", {
       hasStreamProcessor: !!this.streamProcessor,
-      isRecording: this.isRecording()
+      isRecording: this.isRecording(),
+      recordingElapsedSeconds
     });
     if (!(this.streamProcessor && this.isRecording())) {
       throw new Error("Not currently recording");
@@ -3429,7 +3523,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.2.0",
+  version: "1.2.1",
   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",
@@ -4348,6 +4442,118 @@ function serializeBitrate(bitrate) {
   return "high";
 }
 
+// src/core/processor/mp4-container-guard.ts
+var MP4_BOX_HEADER_BYTES = 8;
+var MP4_BOX_TYPE_OFFSET_BYTES = 4;
+var MP4_EXTENDED_SIZE_MARKER = 1;
+var MP4_ZERO_SIZE_MARKER = 0;
+var MP4_EXTENDED_SIZE_BYTES = 8;
+var MP4_EXTENDED_BOX_HEADER_BYTES = MP4_BOX_HEADER_BYTES + MP4_EXTENDED_SIZE_BYTES;
+var TWO_POWER_32 = 4294967296;
+var MP4_FRAGMENT_BOX_TYPE_MOOF = "moof";
+var MP4_FRAGMENT_BOX_TYPE_MFRA = "mfra";
+var ERROR_RECORDING_INVALID_CONTAINER_LAYOUT = "recording.invalid-container-layout";
+function createInvalidMp4ContainerLayoutError(detectedBoxTypes) {
+  const error = new Error(ERROR_RECORDING_INVALID_CONTAINER_LAYOUT);
+  error.code = ERROR_RECORDING_INVALID_CONTAINER_LAYOUT;
+  error.detectedBoxTypes = detectedBoxTypes;
+  return error;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  return new Uint8Array(input);
+}
+function readBoxType(view, offset) {
+  const firstCharCode = view.getUint8(offset);
+  const secondCharCode = view.getUint8(offset + 1);
+  const thirdCharCode = view.getUint8(offset + 2);
+  const fourthCharCode = view.getUint8(offset + 3);
+  return String.fromCharCode(firstCharCode, secondCharCode, thirdCharCode, fourthCharCode);
+}
+function readLargeSize(view, offset) {
+  const highBits = view.getUint32(offset, false);
+  const lowBits = view.getUint32(offset + MP4_BOX_TYPE_OFFSET_BYTES, false);
+  return highBits * TWO_POWER_32 + lowBits;
+}
+function getUniqueValues(values) {
+  const uniqueValues = new Set;
+  for (const value of values) {
+    uniqueValues.add(value);
+  }
+  return [...uniqueValues];
+}
+function parseMp4TopLevelBoxes(input) {
+  const bytes = toUint8Array(input);
+  const totalBytes = bytes.byteLength;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const boxes = [];
+  let currentOffset = 0;
+  while (currentOffset < totalBytes) {
+    const hasMinimumHeader = currentOffset + MP4_BOX_HEADER_BYTES <= totalBytes;
+    if (!hasMinimumHeader) {
+      const detectedBoxTypes = boxes.map((box) => box.type);
+      throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+    }
+    const declaredSize = view.getUint32(currentOffset, false);
+    const typeOffset = currentOffset + MP4_BOX_TYPE_OFFSET_BYTES;
+    const boxType = readBoxType(view, typeOffset);
+    let boxSize = declaredSize;
+    let headerSize = MP4_BOX_HEADER_BYTES;
+    if (declaredSize === MP4_EXTENDED_SIZE_MARKER) {
+      const largeSizeOffset = currentOffset + MP4_BOX_HEADER_BYTES;
+      const hasExtendedHeader = largeSizeOffset + MP4_EXTENDED_SIZE_BYTES <= totalBytes;
+      if (!hasExtendedHeader) {
+        const detectedBoxTypes = boxes.map((box) => box.type);
+        throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+      }
+      boxSize = readLargeSize(view, largeSizeOffset);
+      headerSize = MP4_EXTENDED_BOX_HEADER_BYTES;
+    }
+    if (declaredSize === MP4_ZERO_SIZE_MARKER) {
+      boxSize = totalBytes - currentOffset;
+    }
+    const hasValidHeaderSize = boxSize >= headerSize;
+    if (!hasValidHeaderSize) {
+      const detectedBoxTypes = boxes.map((box) => box.type);
+      throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+    }
+    const nextOffset = currentOffset + boxSize;
+    const hasValidBoxRange = nextOffset <= totalBytes;
+    if (!hasValidBoxRange) {
+      const detectedBoxTypes = boxes.map((box) => box.type);
+      throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+    }
+    boxes.push({
+      type: boxType,
+      size: boxSize,
+      startOffset: currentOffset,
+      endOffset: nextOffset
+    });
+    currentOffset = nextOffset;
+  }
+  return boxes;
+}
+function assertMp4ContainerIsNonFragmented(input) {
+  const topLevelBoxes = parseMp4TopLevelBoxes(input);
+  const detectedFragmentBoxes = topLevelBoxes.filter((box) => {
+    if (box.type === MP4_FRAGMENT_BOX_TYPE_MOOF) {
+      return true;
+    }
+    if (box.type === MP4_FRAGMENT_BOX_TYPE_MFRA) {
+      return true;
+    }
+    return false;
+  }).map((box) => box.type);
+  const hasFragmentBoxes = detectedFragmentBoxes.length > 0;
+  if (!hasFragmentBoxes) {
+    return;
+  }
+  const uniqueDetectedBoxTypes = getUniqueValues(detectedFragmentBoxes);
+  throw createInvalidMp4ContainerLayoutError(uniqueDetectedBoxTypes);
+}
+
 // src/core/utils/shared-object-url-store.ts
 function createSharedObjectUrlStore(dependencies) {
   let activeUrl = null;
@@ -13374,6 +13580,54 @@ class FrameCompositor {
   }
 }
 
+// src/core/processor/worker/stop-finalization.ts
+var STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS = 500;
+var STOP_PENDING_WRITES_POLL_INTERVAL_MILLISECONDS = 10;
+var ERROR_STOP_PENDING_WRITES_TIMEOUT = "stop.pending-writes-timeout";
+function createDefaultNowMilliseconds() {
+  return () => performance.now();
+}
+function createDefaultWaitMilliseconds() {
+  return (milliseconds) => new Promise((resolve) => {
+    globalThis.setTimeout(resolve, milliseconds);
+  });
+}
+async function waitForPendingWritesToDrain(dependencies) {
+  let getNowMilliseconds = dependencies.getNowMilliseconds;
+  if (!getNowMilliseconds) {
+    getNowMilliseconds = createDefaultNowMilliseconds();
+  }
+  let waitMilliseconds = dependencies.waitMilliseconds;
+  if (!waitMilliseconds) {
+    waitMilliseconds = createDefaultWaitMilliseconds();
+  }
+  let timeoutMilliseconds = dependencies.timeoutMilliseconds;
+  if (timeoutMilliseconds === undefined) {
+    timeoutMilliseconds = STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS;
+  }
+  const startedAtMilliseconds = getNowMilliseconds();
+  let pendingWriteCount = dependencies.getPendingWriteCount();
+  while (pendingWriteCount > 0) {
+    const elapsedMilliseconds = getNowMilliseconds() - startedAtMilliseconds;
+    if (elapsedMilliseconds >= timeoutMilliseconds) {
+      throw new Error(ERROR_STOP_PENDING_WRITES_TIMEOUT);
+    }
+    await waitMilliseconds(STOP_PENDING_WRITES_POLL_INTERVAL_MILLISECONDS);
+    pendingWriteCount = dependencies.getPendingWriteCount();
+  }
+}
+
+// src/core/processor/worker/stop-transition.ts
+async function runStopTransition(dependencies) {
+  await dependencies.finalizeStopSequence().then(() => dependencies.completeStop()).catch((error) => {
+    return dependencies.recoverStopFailure().then(() => {
+      throw error;
+    });
+  }).finally(() => {
+    dependencies.clearStoppingFlag();
+  });
+}
+
 // src/core/processor/worker/timestamp-manager.ts
 var DEFAULT_FRAME_RATE = 30;
 var DEFAULT_KEY_FRAME_INTERVAL_SECONDS = 5;
@@ -13584,7 +13838,6 @@ function clampValue(value, min, max) {
 var WORKER_MESSAGE_TYPE_PROBE = "probe";
 var WORKER_MESSAGE_TYPE_AUDIO_CHUNK = "audioChunk";
 var WORKER_RESPONSE_TYPE_PROBE_RESULT = "probeResult";
-var WORKER_RESPONSE_TYPE_DEBUG_LOG = "debugLog";
 var WORKER_AUDIO_SAMPLE_FORMAT_F32_PLANAR = "f32-planar";
 
 // src/core/processor/worker/visibility-tracker.ts
@@ -13707,6 +13960,8 @@ var ERROR_AUDIO_CHANNELS_INVALID = "Audio channels must be greater than zero";
 var ERROR_AUDIO_FRAMES_INVALID = "Audio frames must be greater than zero";
 var STEREO_CHANNEL_COUNT = 2;
 var AUDIO_SAMPLE_AVERAGE_SCALE = 0.5;
+var STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS2 = 500;
+var MP4_FAST_START_DISABLED = false;
 
 class RecorderWorker {
   output = null;
@@ -13729,6 +13984,7 @@ class RecorderWorker {
   totalSize = 0;
   expectedAudioChannels = null;
   expectedAudioSampleRate = null;
+  pendingWriteCount = 0;
   constructor() {
     this.bufferTracker = new BufferTracker({
       getBufferSize: () => this.totalSize,
@@ -13759,14 +14015,6 @@ class RecorderWorker {
       },
       getNowMilliseconds: () => performance.now()
     });
-    const sendDebugLog = (message, payload) => {
-      const response = {
-        type: WORKER_RESPONSE_TYPE_DEBUG_LOG,
-        message,
-        payload
-      };
-      self.postMessage(response);
-    };
     this.frameCompositor = new FrameCompositor({
       logger: {
         debug: (message, data) => logger.debug(message, data),
@@ -13775,7 +14023,9 @@ class RecorderWorker {
       },
       fetchResource: (input, init) => fetch(input, init),
       createImageBitmap: (image) => createImageBitmap(image),
-      sendDebugLog
+      sendDebugLog: (_message, _payload) => {
+        return;
+      }
     });
     self.addEventListener("message", this.handleMessage);
   }
@@ -13909,6 +14159,7 @@ class RecorderWorker {
     this.audioState.reset();
     this.expectedAudioChannels = null;
     this.expectedAudioSampleRate = null;
+    this.pendingWriteCount = 0;
     this.videoProcessingActive = false;
     this.frameCompositor.reset();
     this.recordingStartTime = 0;
@@ -13939,13 +14190,11 @@ class RecorderWorker {
   }
   createOutput() {
     const writable = new WritableStream({
-      write: (chunk) => {
-        this.sendChunk(chunk.data, chunk.position);
-      }
+      write: (chunk) => this.handleOutputChunkWrite(chunk)
     });
     this.output = new Output({
       format: new Mp4OutputFormat({
-        fastStart: "fragmented"
+        fastStart: MP4_FAST_START_DISABLED
       }),
       target: new StreamTarget(writable, {
         chunked: true,
@@ -13953,6 +14202,24 @@ class RecorderWorker {
       })
     });
   }
+  decrementPendingWriteCount() {
+    this.pendingWriteCount -= 1;
+    if (this.pendingWriteCount < 0) {
+      this.pendingWriteCount = 0;
+    }
+  }
+  handleOutputChunkWrite(chunk) {
+    this.pendingWriteCount += 1;
+    const writeOperation = Promise.resolve().then(() => {
+      this.sendChunk(chunk.data, chunk.position);
+    });
+    return writeOperation.then(() => {
+      this.decrementPendingWriteCount();
+    }, (error) => {
+      this.decrementPendingWriteCount();
+      throw error;
+    });
+  }
   createVideoSource(config) {
     const fps = this.timestampManager.getFrameRate();
     const keyFrameIntervalSeconds = config.keyFrameInterval;
@@ -14442,19 +14709,42 @@ class RecorderWorker {
     }
     this.sendStateChange("recording");
   }
-  async handleStop() {
+  handleStop() {
     if (this.isStopping) {
       logger.debug("[RecorderWorker] handleStop ignored (stopping/finalized)");
-      return;
+      return Promise.resolve();
     }
     if (this.isFinalized) {
       logger.debug("[RecorderWorker] handleStop ignored (stopping/finalized)");
-      return;
+      return Promise.resolve();
     }
     this.isStopping = true;
     this.isFinalized = true;
     this.videoProcessingActive = false;
     this.audioState.setProcessingActive(false);
+    return runStopTransition({
+      finalizeStopSequence: () => this.finalizeStopSequence(),
+      completeStop: () => this.completeStop(),
+      recoverStopFailure: () => {
+        if (this.isFinalized) {
+          this.resetStopStateAfterFailure();
+        }
+        return this.cleanup().catch((cleanupError) => {
+          logger.error("[RecorderWorker] Stop failure cleanup failed", {
+            error: extractErrorMessage(cleanupError)
+          });
+        });
+      },
+      clearStoppingFlag: () => {
+        this.isStopping = false;
+      }
+    });
+  }
+  async completeStop() {
+    await this.cleanup();
+    this.sendStateChange("stopped");
+  }
+  async finalizeStopSequence() {
     if (this.videoProcessor) {
       await this.videoProcessor.cancel();
       this.videoProcessor = null;
@@ -14464,13 +14754,17 @@ class RecorderWorker {
       this.audioProcessor = null;
     }
     if (this.output) {
-      await this.output.finalize().catch((error) => {
-        logger.warn("[RecorderWorker] finalize failed (ignored, already finalized?)", error);
-      });
+      await this.output.finalize();
     }
-    await this.cleanup();
-    this.sendStateChange("stopped");
-    this.isStopping = false;
+    await waitForPendingWritesToDrain({
+      getPendingWriteCount: () => this.pendingWriteCount,
+      timeoutMilliseconds: STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS2
+    });
+  }
+  resetStopStateAfterFailure() {
+    this.isFinalized = false;
+    this.videoProcessingActive = false;
+    this.audioState.setProcessingActive(false);
   }
   handleToggleMute() {
     this.audioState.toggleMuted();
@@ -14586,6 +14880,7 @@ class RecorderWorker {
     this.isScreenCapture = false;
     this.expectedAudioChannels = null;
     this.expectedAudioSampleRate = null;
+    this.pendingWriteCount = 0;
     this.visibilityTracker.reset(this.recordingStartTime, this.isScreenCapture);
   }
   setExpectedAudioFormat(sampleRate, numberOfChannels) {
@@ -14708,6 +15003,7 @@ var WORKER_PROBE_TIMEOUT_MILLISECONDS = 2000;
 var FINALIZE_TIMEOUT_MILLISECONDS = 30000;
 var MILLISECONDS_PER_SECOND2 = 1000;
 var DEFAULT_RECORDING_FORMAT = "mp4";
+var OUTPUT_FORMAT_WEBM2 = "webm";
 
 class WorkerProcessor {
   worker = null;
@@ -14876,7 +15172,7 @@ class WorkerProcessor {
     this.stopAudioWorklet();
     const format = this.resolveRecordingFormat(config);
     const audioCodec = await this.resolveAudioCodec(config);
-    const codec = await this.resolveVideoCodec(config);
+    const codec = await this.resolveVideoCodec(config, format);
     const isScreenCapture = isScreenCaptureStream(stream);
     logger.debug("[WorkerProcessor] Starting processing", {
       isScreenCapture,
@@ -14967,12 +15263,11 @@ class WorkerProcessor {
     }
     return audioCodec;
   }
-  async resolveVideoCodec(config) {
-    let codec = config.codec;
-    if (!codec) {
-      codec = await detectBestCodec(config.width, config.height, config.bitrate);
+  async resolveVideoCodec(config, format) {
+    if (format === OUTPUT_FORMAT_WEBM2) {
+      return await detectBestWebmCodec(config.width, config.height, config.bitrate);
     }
-    return codec;
+    return await detectBestCodec(config.width, config.height, config.bitrate);
   }
   buildWorkerTranscodeConfig(config, audioCodec, codec, format) {
     return {
@@ -14990,6 +15285,7 @@ class WorkerProcessor {
   }
   async prepareAudioPipeline(audioTrack, workerProbeResult) {
     if (!audioTrack) {
+      logger.debug("[WorkerProcessor] Audio pipeline disabled (no track)");
       return {
         audioConfig: null,
         audioStream: null,
@@ -15000,6 +15296,10 @@ class WorkerProcessor {
     if (canUseMainThreadAudioPipeline) {
       const audioStream = this.createAudioStreamFromTrack(audioTrack);
       if (audioStream) {
+        logger.debug("[WorkerProcessor] Audio pipeline selected", {
+          path: "main-thread-audio-stream",
+          hasAudioDataInWorker: workerProbeResult.hasAudioData
+        });
         return {
           audioConfig: null,
           audioStream,
@@ -15009,6 +15309,11 @@ class WorkerProcessor {
     }
     const audioConfig = await this.prepareAudioConfig(audioTrack);
     if (audioConfig) {
+      logger.debug("[WorkerProcessor] Audio pipeline selected", {
+        path: "audio-worklet-chunks",
+        sampleRate: audioConfig.sampleRate,
+        numberOfChannels: audioConfig.numberOfChannels
+      });
       return {
         audioConfig,
         audioStream: null,
@@ -15143,42 +15448,88 @@ class WorkerProcessor {
     if (!this.isWorkerActive()) {
       throw new Error("Processing not active");
     }
+    const finalizeStartedAtMilliseconds = performance.now();
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("Finalize timeout"));
-      }, FINALIZE_TIMEOUT_MILLISECONDS);
-      const removeWorkerListener = () => {
-        if (!this.worker) {
+      const worker = this.worker;
+      if (!worker) {
+        reject(new Error("Worker not initialized"));
+        return;
+      }
+      let timeoutId = null;
+      const clearFinalizeTimeout = () => {
+        if (timeoutId === null) {
           return;
         }
-        this.worker.removeEventListener("message", messageHandler);
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      };
+      const removeWorkerListener = () => {
+        worker.removeEventListener("message", messageHandler);
+      };
+      let hasSettled = false;
+      const settleOnce = () => {
+        if (hasSettled) {
+          return false;
+        }
+        hasSettled = true;
+        clearFinalizeTimeout();
+        removeWorkerListener();
+        return true;
       };
       const messageHandler = (event) => {
+        if (hasSettled) {
+          return;
+        }
         const response = event.data;
         const isStopped = response.type === "stateChange" && response.state === "stopped";
         if (isStopped) {
-          removeWorkerListener();
-          clearTimeout(timeout);
-          this.isActive = false;
-          this.stopAudioWorklet();
-          resolve(this.createBlobFromChunks());
+          const canSettle2 = settleOnce();
+          if (!canSettle2) {
+            return;
+          }
+          this.resetFinalizeRuntimeState();
+          Promise.resolve().then(() => this.createBlobFromChunks()).then((streamProcessorResult) => {
+            resolve(streamProcessorResult);
+          }, (error) => {
+            this.rejectFinalizeBlobCreationError(reject, error, finalizeStartedAtMilliseconds);
+          });
           return;
         }
         const isError = response.type === "error";
-        if (isError) {
-          removeWorkerListener();
-          clearTimeout(timeout);
-          this.stopAudioWorklet();
-          reject(new Error(response.error));
+        if (!isError) {
+          return;
         }
+        const canSettle = settleOnce();
+        if (!canSettle) {
+          return;
+        }
+        this.resetFinalizeRuntimeState();
+        logger.error("[WorkerProcessor] Finalize failed", {
+          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND2,
+          error: response.error
+        });
+        reject(new Error(response.error));
       };
-      if (this.worker) {
-        this.worker.addEventListener("message", messageHandler);
-        const message = { type: "stop" };
-        this.worker.postMessage(message);
-      }
+      timeoutId = setTimeout(() => {
+        const canSettle = settleOnce();
+        if (!canSettle) {
+          return;
+        }
+        logger.error("[WorkerProcessor] Finalize timeout reached", {
+          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND2
+        });
+        this.resetFinalizeRuntimeState();
+        reject(new Error("Finalize timeout"));
+      }, FINALIZE_TIMEOUT_MILLISECONDS);
+      worker.addEventListener("message", messageHandler);
+      const message = { type: "stop" };
+      worker.postMessage(message);
     });
   }
+  resetFinalizeRuntimeState() {
+    this.isActive = false;
+    this.stopAudioWorklet();
+  }
   createBlobFromChunks() {
     const sortedChunks = [...this.chunks].sort((a, b) => a.position - b.position);
     const buffer = new ArrayBuffer(this.totalSize);
@@ -15186,12 +15537,24 @@ class WorkerProcessor {
     for (const chunk of sortedChunks) {
       view.set(chunk.data, chunk.position);
     }
+    assertMp4ContainerIsNonFragmented(buffer);
     const blob = new Blob([buffer], { type: "video/mp4" });
     return {
       blob,
       totalSize: this.totalSize
     };
   }
+  rejectFinalizeBlobCreationError(reject, error, finalizeStartedAtMilliseconds) {
+    logger.error("[WorkerProcessor] Finalize failed while creating blob", {
+      elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND2,
+      error: extractErrorMessage(error)
+    });
+    if (error instanceof Error) {
+      reject(error);
+      return;
+    }
+    reject(new Error(extractErrorMessage(error)));
+  }
   cancel() {
     if (this.worker && this.isActive) {
       const message = { type: "stop" };