@incodetech/core 2.3.0-rc.9 → 2.3.0

package/dist/{multipartRecordingService-DDAOXQKm.esm.js → multipartRecordingService-mwKFTlhR.esm.js}

@@ -2,6 +2,47 @@ import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.j
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { a as isIOS } from "./platform-DkcRc9JV.esm.js";
+//#region ../infra/src/media/StreamCanvasProcessingSession.ts
+var StreamCanvasProcessingSession = class {
+	/**
+	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
+	* and drives a provider's `processFrame()` method with backpressure.
+	*/
+	constructor(params) {
+		this.disposed = false;
+		this.isProcessing = false;
+		this.onFrameEvent = () => {
+			if (this.disposed || this.isProcessing) return;
+			const frame = this.capturer.getLatestFrame();
+			if (!frame) return;
+			this.onFrame?.(frame);
+			this.isProcessing = true;
+			this.provider.processFrame(frame).catch(() => {}).finally(() => {
+				this.isProcessing = false;
+			});
+		};
+		this.capturer = params.capturer;
+		this.provider = params.provider;
+		this.onFrame = params.onFrame;
+		this.capturer.addEventListener("frame", this.onFrameEvent);
+	}
+	/**
+	* Unsubscribes from frame events and resets the provider.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.capturer.removeEventListener("frame", this.onFrameEvent);
+		this.provider.reset();
+	}
+	/**
+	* Returns whether the session has been disposed.
+	*/
+	isDisposed() {
+		return this.disposed;
+	}
+};
+//#endregion
 //#region ../infra/src/media/mediaRecorderOptions.ts
 /**
 * Picks a `MediaRecorder` mime type the current browser actually supports.
@@ -42,6 +83,33 @@ function getAdaptiveMediaRecorderOptions() {
 		bitsPerSecond: 5e5
 	};
 }
+/**
+* Worker-encoded multipart recording profile (ENG-55397). 2 GB-class devices
+* (`navigator.deviceMemory` ≤ 2) record 360p at 15 fps: on a Galaxy A01 Core,
+* 720p30 plus WASM detection exhausted memory (renderer swapped, GPU process
+* killed), and even the in-worker encoder starved the camera preview to
+* 6 fps. They also upload 2 s parts: every part is one request through the
+* WASM HTTP client on the main thread, and at 0.5 s parts the uploads fell
+* behind during face detection, stretching the final "processing" wait.
+* Other devices, and browsers without `deviceMemory`, keep 720p30 at the
+* MediaRecorder bitrate and 0.5 s parts.
+*/
+function getWorkerRecordingProfile(deviceMemoryGb = typeof navigator !== "undefined" ? navigator.deviceMemory : void 0) {
+	if (deviceMemoryGb !== void 0 && deviceMemoryGb <= 2) return {
+		maxLongEdge: 640,
+		maxShortEdge: 360,
+		fps: 15,
+		bitrate: 6e5,
+		timesliceMs: 2e3
+	};
+	return {
+		maxLongEdge: 1280,
+		maxShortEdge: 720,
+		fps: 30,
+		bitrate: 25e5,
+		timesliceMs: 500
+	};
+}
 //#endregion
 //#region ../infra/src/media/cameraCompositorWorker.ts
 /**
@@ -81,6 +149,9 @@ function cameraCompositorWorkerMain(scope) {
 	let generation = 0;
 	let paused = false;
 	let announceNextFrame = false;
+	let minFrameIntervalUs = 0;
+	let lastWrittenUs = -Infinity;
+	let encodeConfig = null;
 	const boundedSize = (width, height) => {
 		const scale = Math.min(1, maxLongEdge / Math.max(width, height), maxShortEdge / Math.min(width, height));
 		return {
@@ -100,6 +171,423 @@ function cameraCompositorWorkerMain(scope) {
 		frame.close();
 		return out;
 	};
+	const video = {
+		number: 1,
+		offsetUs: null,
+		lastUs: -1
+	};
+	const audio = {
+		number: 2,
+		offsetUs: null,
+		lastUs: -1
+	};
+	let videoEncoder = null;
+	let audioEncoder = null;
+	let hasAudioSource = false;
+	let audioWanted = false;
+	let audioFormat = null;
+	let audioInHeader = false;
+	/**
+	* The Opus encoder numbers its output by sample count from its first input,
+	* so track where that count has reached on our timeline (µs).
+	*/
+	let audioClockStartUs = null;
+	let audioFedUs = 0;
+	let recording = "off";
+	let encodedSize = {
+		width: 0,
+		height: 0
+	};
+	let originMs = 0;
+	let pausedMs = 0;
+	let pauseStartedMs = 0;
+	/** Pacer: source time the next frame is due (schedule, not last frame). */
+	let nextDueUs = -Infinity;
+	let lastKeyUs = -Infinity;
+	let forceKey = true;
+	let headerSent = false;
+	let lastFlushMs = 0;
+	/** Oldest pending block timestamp (µs); pending is small but hot. */
+	let oldestPendingUs = Infinity;
+	let pending = [];
+	const concat = (parts) => {
+		let length = 0;
+		for (const part of parts) length += part.length;
+		const out = new Uint8Array(length);
+		let offset = 0;
+		for (const part of parts) {
+			out.set(part, offset);
+			offset += part.length;
+		}
+		return out;
+	};
+	const uint = (value) => {
+		const out = [];
+		let rest = value;
+		do {
+			out.unshift(rest % 256);
+			rest = Math.floor(rest / 256);
+		} while (rest > 0);
+		return out;
+	};
+	/** EBML variable-length size, shortest form. */
+	const vsize = (size) => {
+		for (let length = 1; length <= 8; length += 1) if (size < 2 ** (7 * length) - 1) {
+			const out = uint(size);
+			while (out.length < length) out.unshift(0);
+			out[0] |= 128 >> length - 1;
+			return out;
+		}
+		throw new Error("EBML element too large");
+	};
+	const element = (id, ...body) => {
+		const data = concat(body);
+		return concat([
+			id,
+			vsize(data.length),
+			data
+		]);
+	};
+	const text = (value) => Array.from(value, (char) => char.charCodeAt(0));
+	const float64 = (value) => {
+		const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+		view.setFloat64(0, value);
+		return Array.from(new Uint8Array(view.buffer));
+	};
+	/** RFC 7845 identification header: version 1, pre-skip 312, family 0. */
+	const opusHead = (channels, sampleRate) => [
+		...text("OpusHead"),
+		1,
+		channels,
+		56,
+		1,
+		sampleRate & 255,
+		sampleRate >> 8 & 255,
+		sampleRate >> 16 & 255,
+		sampleRate >> 24 & 255,
+		0,
+		0,
+		0
+	];
+	const webmHeader = () => {
+		const videoEntry = element([174], element([215], [1]), element([115, 197], [1]), element([131], [1]), element([134], text("V_VP8")), element([224], element([176], uint(encodedSize.width)), element([186], uint(encodedSize.height))));
+		const audioEntry = audioInHeader && audioFormat ? element([174], element([215], [2]), element([115, 197], [2]), element([131], [2]), element([134], text("A_OPUS")), element([99, 162], opusHead(audioFormat.channels, audioFormat.sampleRate)), element([225], element([181], float64(48e3)), element([159], [audioFormat.channels]))) : /* @__PURE__ */ new Uint8Array(0);
+		return concat([
+			element([
+				26,
+				69,
+				223,
+				163
+			], element([66, 134], [1]), element([66, 247], [1]), element([66, 242], [4]), element([66, 243], [8]), element([66, 130], text("webm")), element([66, 135], [4]), element([66, 133], [2])),
+			[
+				24,
+				83,
+				128,
+				103,
+				1,
+				255,
+				255,
+				255,
+				255,
+				255,
+				255,
+				255
+			],
+			element([
+				21,
+				73,
+				169,
+				102
+			], element([
+				42,
+				215,
+				177
+			], uint(1e6)), element([77, 128], text("incode")), element([87, 65], text("incode"))),
+			element([
+				22,
+				84,
+				174,
+				107
+			], videoEntry, audioEntry)
+		]);
+	};
+	/**
+	* Writes every pending block older than `limitUs` as one cluster (one
+	* upload part). The first part carries the header, so it waits (up to
+	* 3 s) for the microphone's format when a microphone is attached.
+	*/
+	const flushBefore = (limitUs, force = false) => {
+		if (pending.length === 0) return;
+		const oldestUs = oldestPendingUs;
+		const timesliceMs = encodeConfig?.timesliceMs ?? 500;
+		if (!force && performance.now() - lastFlushMs < timesliceMs * .8) return;
+		if (!force && !headerSent && audioWanted && !audioFormat && limitUs - oldestUs < 3e6) return;
+		const ready = pending.filter((block) => block.us < limitUs).sort((a, b) => a.us - b.us || a.track - b.track);
+		if (ready.length === 0) return;
+		pending = pending.filter((block) => block.us >= limitUs);
+		oldestPendingUs = pending.reduce((min, block) => Math.min(min, block.us), Infinity);
+		if (!headerSent) audioInHeader = audioFormat !== null;
+		const blocks = ready.filter((block) => block.track === 1 || audioInHeader);
+		if (blocks.length === 0) return;
+		const clusters = [];
+		let run = [];
+		const closeRun = () => {
+			if (run.length === 0) return;
+			const clusterMs = Math.floor(run[0].us / 1e3);
+			clusters.push(element([
+				31,
+				67,
+				182,
+				117
+			], element([231], uint(clusterMs)), ...run.map((block) => {
+				const relative = Math.round(block.us / 1e3) - clusterMs;
+				return element([163], [
+					128 | block.track,
+					relative >> 8 & 255,
+					relative & 255,
+					block.key ? 128 : 0
+				], block.data);
+			})));
+			run = [];
+		};
+		for (const block of blocks) {
+			if (run.length > 0 && block.us - run[0].us > 3e7) closeRun();
+			run.push(block);
+		}
+		closeRun();
+		const cluster = concat(clusters);
+		const part = headerSent ? cluster : concat([webmHeader(), cluster]);
+		headerSent = true;
+		lastFlushMs = performance.now();
+		scope.postMessage({
+			type: "part",
+			data: part.buffer
+		}, [part.buffer]);
+	};
+	const onEncoded = (track) => (chunk) => {
+		const data = new Uint8Array(chunk.byteLength);
+		chunk.copyTo(data);
+		pending.push({
+			us: chunk.timestamp,
+			data,
+			key: chunk.type === "key",
+			track: track.number
+		});
+		oldestPendingUs = Math.min(oldestPendingUs, chunk.timestamp);
+		const timesliceUs = (encodeConfig?.timesliceMs ?? 500) * 1e3;
+		const spanUs = chunk.timestamp - oldestPendingUs;
+		if (track === video && chunk.type === "key" && spanUs >= timesliceUs / 2) flushBefore(chunk.timestamp);
+		else if (spanUs > timesliceUs * 3) flushBefore(chunk.timestamp - 2e5);
+	};
+	const timelineNowUs = () => (performance.now() - originMs - pausedMs) * 1e3;
+	const anchor = (track, sourceUs) => {
+		const nowUs = timelineNowUs();
+		if (track === audio && track.offsetUs !== null && nowUs - (sourceUs + track.offsetUs) > 25e4) track.offsetUs = null;
+		if (track.offsetUs === null) track.offsetUs = nowUs - sourceUs;
+		const us = Math.max(Math.round(sourceUs + track.offsetUs), track.lastUs + 1);
+		track.lastUs = us;
+		return us;
+	};
+	const reanchor = () => {
+		video.offsetUs = null;
+		audio.offsetUs = null;
+		nextDueUs = -Infinity;
+		forceKey = true;
+	};
+	const resetRecording = () => {
+		videoEncoder = null;
+		audioEncoder = null;
+		audioWanted = hasAudioSource;
+		audioFormat = null;
+		audioInHeader = false;
+		audioClockStartUs = null;
+		audioFedUs = 0;
+		originMs = performance.now();
+		pausedMs = 0;
+		video.lastUs = -1;
+		audio.lastUs = -1;
+		reanchor();
+		lastKeyUs = -Infinity;
+		headerSent = false;
+		lastFlushMs = 0;
+		oldestPendingUs = Infinity;
+		pending = [];
+	};
+	const encodeVideo = (frame) => {
+		const config = encodeConfig;
+		if (!config) {
+			frame.close();
+			return;
+		}
+		if (minFrameIntervalUs > 0) {
+			const intervalUs = 1e6 / config.fps;
+			if (frame.timestamp < nextDueUs - intervalUs * .2) {
+				frame.close();
+				return;
+			}
+			nextDueUs = nextDueUs === -Infinity || frame.timestamp - nextDueUs > intervalUs ? frame.timestamp + intervalUs : nextDueUs + intervalUs;
+		}
+		if (!videoEncoder) {
+			const size = boundedSize(frame.displayWidth, frame.displayHeight);
+			encodedSize = {
+				width: Math.max(2, size.width - size.width % 2),
+				height: Math.max(2, size.height - size.height % 2)
+			};
+			videoEncoder = new g.VideoEncoder({
+				output: onEncoded(video),
+				error: (error) => scope.postMessage({
+					type: "record-error",
+					message: String(error)
+				})
+			});
+			videoEncoder.configure({
+				codec: config.codec,
+				width: encodedSize.width,
+				height: encodedSize.height,
+				bitrate: config.bitrate,
+				framerate: config.fps,
+				latencyMode: "realtime"
+			});
+		}
+		if (videoEncoder.state !== "configured" || videoEncoder.encodeQueueSize > 4) {
+			frame.close();
+			return;
+		}
+		const us = anchor(video, frame.timestamp);
+		const keyFrame = forceKey || us - lastKeyUs >= config.timesliceMs * 1e3;
+		if (keyFrame) {
+			lastKeyUs = us;
+			forceKey = false;
+		}
+		const rebased = new g.VideoFrame(frame, { timestamp: us });
+		frame.close();
+		videoEncoder.encode(rebased, { keyFrame });
+		rebased.close();
+	};
+	/** AudioData cannot be re-timestamped in place; copying 10 ms is cheap. */
+	const retimed = (data, us) => {
+		const planes = data.format.endsWith("-planar") ? data.numberOfChannels : 1;
+		const sizes = [];
+		for (let plane = 0; plane < planes; plane += 1) sizes.push(data.allocationSize({ planeIndex: plane }));
+		const buffer = new Uint8Array(sizes.reduce((sum, size) => sum + size, 0));
+		let offset = 0;
+		for (let plane = 0; plane < planes; plane += 1) {
+			data.copyTo(buffer.subarray(offset, offset + sizes[plane]), { planeIndex: plane });
+			offset += sizes[plane];
+		}
+		return new g.AudioData({
+			format: data.format,
+			sampleRate: data.sampleRate,
+			numberOfFrames: data.numberOfFrames,
+			numberOfChannels: data.numberOfChannels,
+			timestamp: us,
+			data: buffer
+		});
+	};
+	const bytesPerSample = (format) => format.startsWith("u8") ? 1 : format.startsWith("s16") ? 2 : 4;
+	/** Zero-filled AudioData (silence for every signed / float format). */
+	const silence = (like, us, durationUs) => {
+		const frames = Math.max(1, Math.round(durationUs * like.sampleRate / 1e6));
+		return new g.AudioData({
+			format: like.format,
+			sampleRate: like.sampleRate,
+			numberOfFrames: frames,
+			numberOfChannels: like.numberOfChannels,
+			timestamp: us,
+			data: new Uint8Array(frames * like.numberOfChannels * bytesPerSample(like.format))
+		});
+	};
+	const encodeAudio = (data) => {
+		const config = encodeConfig;
+		if (!config || !audioWanted) {
+			data.close();
+			return;
+		}
+		if (!audioEncoder) try {
+			const encoderInstance = new g.AudioEncoder({
+				output: onEncoded(audio),
+				error: (error) => {
+					audioWanted = false;
+					audioEncoder = null;
+					scope.postMessage({
+						type: "record-error",
+						message: `audio encoder: ${String(error)}`
+					});
+				}
+			});
+			encoderInstance.configure({
+				codec: "opus",
+				sampleRate: data.sampleRate,
+				numberOfChannels: data.numberOfChannels,
+				bitrate: config.audioBitrate ?? 64e3
+			});
+			audioEncoder = encoderInstance;
+			audioFormat = {
+				sampleRate: data.sampleRate,
+				channels: data.numberOfChannels
+			};
+		} catch (error) {
+			audioWanted = false;
+			scope.postMessage({
+				type: "record-error",
+				message: `audio configure: ${String(error)}`
+			});
+			data.close();
+			return;
+		}
+		if (audioEncoder.state !== "configured" || audioEncoder.encodeQueueSize > 50) {
+			data.close();
+			return;
+		}
+		const us = anchor(audio, data.timestamp);
+		audioClockStartUs ??= us;
+		const driftUs = us - (audioClockStartUs + audioFedUs);
+		if (driftUs < -2e5) {
+			data.close();
+			return;
+		}
+		if (driftUs > 1e5) {
+			const fillUs = Math.min(driftUs, 5e6);
+			const filler = silence(data, audioClockStartUs + audioFedUs, fillUs);
+			audioEncoder.encode(filler);
+			filler.close();
+			audioFedUs += filler.numberOfFrames * 1e6 / filler.sampleRate;
+		}
+		audioFedUs += data.numberOfFrames * 1e6 / data.sampleRate;
+		const copy = retimed(data, us);
+		data.close();
+		audioEncoder.encode(copy);
+		copy.close();
+	};
+	const pumpAudio = async (readable) => {
+		const reader = readable.getReader();
+		try {
+			for (;;) {
+				const { value, done } = await reader.read();
+				if (done) return;
+				if (paused || recording !== "on") value.close();
+				else encodeAudio(value);
+			}
+		} catch (error) {
+			audioWanted = false;
+			scope.postMessage({
+				type: "record-error",
+				message: `audio source: ${String(error)}`
+			});
+		}
+	};
+	const stopRecording = async () => {
+		recording = "off";
+		for (const current of [videoEncoder, audioEncoder]) try {
+			if (current && current.state === "configured") await current.flush();
+		} catch {}
+		flushBefore(Infinity, true);
+		for (const current of [videoEncoder, audioEncoder]) try {
+			current?.close();
+		} catch {}
+		resetRecording();
+		scope.postMessage({ type: "record-stopped" });
+	};
 	const pump = async (readable, gen) => {
 		const reader = readable.getReader();
 		activeReader = reader;
@@ -114,10 +602,21 @@ function cameraCompositorWorkerMain(scope) {
 					frame.close();
 					return;
 				}
-				if (paused || !writer) {
+				if (encodeConfig) {
+					if (paused || recording !== "on") frame.close();
+					else encodeVideo(frame);
+					if (announceNextFrame && !paused) {
+						announceNextFrame = false;
+						scope.postMessage({ type: "frame" });
+					}
+					continue;
+				}
+				const sinceLastUs = frame.timestamp - lastWrittenUs;
+				if (paused || !writer || sinceLastUs >= 0 && sinceLastUs < minFrameIntervalUs) {
 					frame.close();
 					continue;
 				}
+				lastWrittenUs = frame.timestamp;
 				await writer.write(scaled(frame));
 				if (announceNextFrame) {
 					announceNextFrame = false;
@@ -133,6 +632,8 @@ function cameraCompositorWorkerMain(scope) {
 	};
 	const switchSource = (readable) => {
 		generation += 1;
+		lastWrittenUs = -Infinity;
+		reanchor();
 		const previous = activeReader;
 		activeReader = null;
 		previous?.cancel().catch(() => {});
@@ -144,6 +645,12 @@ function cameraCompositorWorkerMain(scope) {
 			case "start":
 				maxLongEdge = message.maxLongEdge;
 				maxShortEdge = message.maxShortEdge;
+				minFrameIntervalUs = message.minFrameIntervalUs ?? 0;
+				encodeConfig = message.encode ?? null;
+				if (encodeConfig && message.audio) {
+					hasAudioSource = true;
+					pumpAudio(message.audio);
+				}
 				canvas = new g.OffscreenCanvas(1, 1);
 				ctx = canvas.getContext("2d");
 				writer = message.writable.getWriter();
@@ -159,6 +666,27 @@ function cameraCompositorWorkerMain(scope) {
 			case "resume":
 				paused = false;
 				announceNextFrame = true;
+				reanchor();
+				break;
+			case "record-start":
+				resetRecording();
+				recording = "on";
+				break;
+			case "record-pause":
+				if (recording === "on") {
+					recording = "paused";
+					pauseStartedMs = performance.now();
+				}
+				break;
+			case "record-resume":
+				if (recording === "paused") {
+					pausedMs += performance.now() - pauseStartedMs;
+					recording = "on";
+					reanchor();
+				}
+				break;
+			case "record-stop":
+				stopRecording();
 				break;
 			default: break;
 		}
@@ -175,6 +703,26 @@ const MAX_COMPOSITE_SHORT_EDGE = 720;
 const FRAME_INTERVAL_TOLERANCE_RATIO = .9;
 const DEFAULT_RESUME_TIMEOUT_MS = 2e3;
 /**
+* Compositor for a multipart recording (ID, Selfie, Video Selfie): encodes
+* inside its worker at the device's {@link getWorkerRecordingProfile} tier.
+* Pair it with
+* `WorkerEncoderRecordingProvider`, which falls back to `MediaRecorder` when
+* in-worker encoding is unavailable.
+*/
+function createRecordingCompositor() {
+	const profile = getWorkerRecordingProfile();
+	return new CameraCompositor({
+		fps: profile.fps,
+		maxLongEdge: profile.maxLongEdge,
+		maxShortEdge: profile.maxShortEdge,
+		paceWorkerFrames: profile.fps < 30,
+		encodeInWorker: {
+			bitrate: profile.bitrate,
+			timesliceMs: profile.timesliceMs
+		}
+	});
+}
+/**
 * Composites the *active* camera into a single, stable `MediaStream` to
 * record. Switching cameras (front ↔ back) just repoints the source — the
 * output stream and its audio track are never replaced — so a single
@@ -192,6 +740,10 @@ const DEFAULT_RESUME_TIMEOUT_MS = 2e3;
 *    `captureStream`, for Safari, Firefox and strict-CSP hosts that block blob
 *    workers.
 *
+* With `encodeInWorker`, the worker transport also records: it encodes and
+* muxes the WebM itself (see `startWorkerRecording`), so no `MediaRecorder`
+* — which needs the main thread for every frame — is involved.
+*
 * A worker that dies mid-recording (GPU-process crash, OOM) is released at
 * once; the composite track stays valid but receives no further frames, and
 * the next `resume()` reports `timed-out` so the caller reacquires the camera
@@ -202,6 +754,10 @@ const DEFAULT_RESUME_TIMEOUT_MS = 2e3;
 */
 var CameraCompositor = class {
 	constructor(options = {}) {
+		this.workerEncoding = false;
+		this.onWorkerPart = null;
+		this.workerRecordingError = null;
+		this.workerRecordingStopped = null;
 		this.canvas = null;
 		this.ctx = null;
 		this.video = null;
@@ -216,6 +772,10 @@ var CameraCompositor = class {
 		this.videoTrack = null;
 		this.composite = null;
 		this.fps = options.fps ?? 30;
+		this.maxLongEdge = options.maxLongEdge ?? MAX_COMPOSITE_LONG_EDGE;
+		this.maxShortEdge = options.maxShortEdge ?? MAX_COMPOSITE_SHORT_EDGE;
+		this.paceWorkerFrames = options.paceWorkerFrames ?? false;
+		this.encodeInWorker = options.encodeInWorker;
 		this.frameIntervalMs = this.fps > 0 ? 1e3 / this.fps : 0;
 		this.resumeTimeoutMs = options.resumeTimeoutMs ?? DEFAULT_RESUME_TIMEOUT_MS;
 	}
@@ -254,6 +814,66 @@ var CameraCompositor = class {
 		} else this.videoTrack = stream.getVideoTracks()[0] ?? null;
 		if (previousVideoTrack) previousVideoTrack.stop();
 	}
+	/**
+	* True when this compositor records by itself: the worker transport started
+	* with `encodeInWorker` and the browser has `VideoEncoder`. Use the
+	* `*WorkerRecording` methods instead of a `MediaRecorder` then; the
+	* composite stream receives no frames.
+	*/
+	get encodesInWorker() {
+		return this.workerEncoding && this.transport !== null;
+	}
+	/** Last in-worker encoder error, if any. */
+	get workerRecordingErrorMessage() {
+		return this.workerRecordingError;
+	}
+	/**
+	* Start a new WebM recording inside the worker. `onPart` receives whole
+	* WebM clusters (~`timesliceMs` each, keyframe first; the first part also
+	* carries the header), in order. Returns false when not encoding in-worker.
+	*/
+	startWorkerRecording(onPart) {
+		if (!this.encodesInWorker) return false;
+		this.onWorkerPart = onPart;
+		this.workerRecordingError = null;
+		this.postToWorker({ type: "record-start" });
+		return true;
+	}
+	pauseWorkerRecording() {
+		if (!this.encodesInWorker || !this.onWorkerPart) return false;
+		this.postToWorker({ type: "record-pause" });
+		return true;
+	}
+	resumeWorkerRecording() {
+		if (!this.encodesInWorker || !this.onWorkerPart) return false;
+		this.postToWorker({ type: "record-resume" });
+		return true;
+	}
+	/**
+	* Flush the encoder and resolve once every part has reached `onPart`.
+	* Resolves at once if the worker is gone (its buffered frames are lost).
+	*/
+	stopWorkerRecording() {
+		if (!this.onWorkerPart) return Promise.resolve();
+		if (!this.transport) {
+			this.onWorkerPart = null;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => {
+			this.workerRecordingStopped = () => {
+				this.workerRecordingStopped = null;
+				this.onWorkerPart = null;
+				resolve();
+			};
+			this.postToWorker({ type: "record-stop" });
+		});
+	}
+	/** Stop in-worker recording and drop whatever it still emits. */
+	cancelWorkerRecording() {
+		if (this.onWorkerPart && this.transport) this.postToWorker({ type: "record-stop" });
+		this.onWorkerPart = null;
+		this.workerRecordingStopped?.();
+	}
 	/** The composite stream being recorded, if compositing is active. */
 	get stream() {
 		return this.composite ?? void 0;
@@ -345,6 +965,13 @@ var CameraCompositor = class {
 		let worker = null;
 		let generator = null;
 		let blobUrl = null;
+		const codecs = globalThis;
+		const encode = this.encodeInWorker && typeof codecs.VideoEncoder === "function" && (!this.audioTrack || typeof codecs.AudioEncoder === "function") ? {
+			codec: "vp8",
+			bitrate: this.encodeInWorker.bitrate,
+			fps: this.fps,
+			timesliceMs: this.encodeInWorker.timesliceMs
+		} : null;
 		try {
 			const processor = createTrackProcessor(track);
 			generator = createTrackGenerator();
@@ -355,14 +982,22 @@ var CameraCompositor = class {
 				type: "fatal",
 				message: event?.message || "worker error"
 			});
+			const audioReadable = encode && this.audioTrack ? createTrackProcessor(this.audioTrack).readable : void 0;
 			const message = {
 				type: "start",
+				audio: audioReadable,
 				readable: processor.readable,
 				writable: generator.writable,
-				maxLongEdge: MAX_COMPOSITE_LONG_EDGE,
-				maxShortEdge: MAX_COMPOSITE_SHORT_EDGE
+				maxLongEdge: this.maxLongEdge,
+				maxShortEdge: this.maxShortEdge,
+				minFrameIntervalUs: this.paceWorkerFrames && this.frameIntervalMs > 0 ? this.frameIntervalMs * 1e3 * FRAME_INTERVAL_TOLERANCE_RATIO : 0,
+				encode: encode ?? void 0
 			};
-			worker.postMessage(message, [processor.readable, generator.writable]);
+			worker.postMessage(message, [
+				processor.readable,
+				generator.writable,
+				...audioReadable ? [audioReadable] : []
+			]);
 		} catch {
 			worker?.terminate();
 			generator?.stop();
@@ -375,6 +1010,7 @@ var CameraCompositor = class {
 			blobUrl
 		};
 		this.generator = generator;
+		this.workerEncoding = encode !== null;
 		return new MediaStream([generator]);
 	}
 	/** Terminates the worker and frees its blob; idempotent. */
@@ -383,6 +1019,7 @@ var CameraCompositor = class {
 		this.transport.worker.terminate();
 		URL.revokeObjectURL(this.transport.blobUrl);
 		this.transport = null;
+		this.workerRecordingStopped?.();
 	}
 	startMainThread(stream) {
 		this.canvas = document.createElement("canvas");
@@ -407,6 +1044,15 @@ var CameraCompositor = class {
 			case "ended":
 				this.finishResume("video-ended");
 				break;
+			case "part":
+				this.onWorkerPart?.(new Blob([message.data], { type: "video/webm" }));
+				break;
+			case "record-stopped":
+				this.workerRecordingStopped?.();
+				break;
+			case "record-error":
+				this.workerRecordingError = message.message;
+				break;
 			case "fatal":
 				this.releaseWorker();
 				this.finishResume("timed-out");
@@ -480,7 +1126,7 @@ var CameraCompositor = class {
 	getBoundedDimensions(width, height) {
 		const longEdge = Math.max(width, height);
 		const shortEdge = Math.min(width, height);
-		const scale = Math.min(1, MAX_COMPOSITE_LONG_EDGE / longEdge, MAX_COMPOSITE_SHORT_EDGE / shortEdge);
+		const scale = Math.min(1, this.maxLongEdge / longEdge, this.maxShortEdge / shortEdge);
 		return {
 			width: Math.max(1, Math.round(width * scale)),
 			height: Math.max(1, Math.round(height * scale))
@@ -632,6 +1278,82 @@ var MultipartRecordingProvider = class {
 	}
 };
 //#endregion
+//#region ../infra/src/providers/browser/WorkerEncoderRecordingProvider.ts
+/**
+* Multipart recorder for a `CameraCompositor` that encodes inside its worker
+* (ENG-55397): emits the worker's WebM clusters as parts, in order. When the
+* compositor could not start in-worker encoding (no insertable streams or
+* WebCodecs, strict CSP), it records the composite stream with
+* `MediaRecorder` instead, so callers wire it unconditionally.
+*
+* Why not always `MediaRecorder`: Chrome hands every recorded frame through
+* the page main thread and drops frames while it is blocked. On a Galaxy A01
+* Core the ID flow blocks it for 3–5 s (WASM + 1080p readbacks); a
+* `MediaRecorder` fed by the worker kept 74 of 149 frames under 1.5 s
+* freezes, the in-worker encoder 150 of 151.
+*/
+var WorkerEncoderRecordingProvider = class {
+	constructor(compositor) {
+		this.compositor = compositor;
+		this._isRecording = false;
+		this._error = null;
+		this.partNumber = 0;
+		this.fallback = null;
+	}
+	get isRecording() {
+		return this.fallback ? this.fallback.isRecording : this._isRecording;
+	}
+	get hasError() {
+		return this.error !== null;
+	}
+	get error() {
+		if (this.fallback) return this.fallback.error;
+		return this._error ?? this.compositor.workerRecordingErrorMessage;
+	}
+	startRecording(stream, onPart) {
+		this.reset();
+		if (!this.compositor.encodesInWorker) {
+			this.fallback = new MultipartRecordingProvider();
+			this.fallback.startRecording(stream, onPart);
+			return;
+		}
+		this.partNumber = 0;
+		const started = this.compositor.startWorkerRecording((chunk) => {
+			this.partNumber += 1;
+			onPart({
+				chunk,
+				partNumber: this.partNumber
+			});
+		});
+		this._isRecording = started;
+		this._error = started ? null : "Failed to start recording: no encoder";
+	}
+	pauseRecording() {
+		if (this.fallback) return this.fallback.pauseRecording();
+		return this._isRecording && this.compositor.pauseWorkerRecording();
+	}
+	resumeRecording() {
+		if (this.fallback) return this.fallback.resumeRecording();
+		return this._isRecording && this.compositor.resumeWorkerRecording();
+	}
+	async stopRecording() {
+		if (this.fallback) {
+			await this.fallback.stopRecording();
+			return;
+		}
+		if (!this._isRecording) return;
+		this._isRecording = false;
+		await this.compositor.stopWorkerRecording();
+	}
+	reset() {
+		this.fallback?.reset();
+		this.fallback = null;
+		this.compositor.cancelWorkerRecording();
+		this._isRecording = false;
+		this._error = null;
+	}
+};
+//#endregion
 //#region ../infra/src/providers/browser/BrowserNetworkStatusProvider.ts
 var BrowserNetworkStatusProvider = class {
 	onOnline(listener) {
@@ -916,15 +1638,15 @@ function httpStatusOf(error) {
 * (S3 SSE-AES-256).
 */
 var MultipartRecordingService = class {
-	constructor(scope = "videoselfie") {
+	constructor(scope = "videoselfie", recorder = new MultipartRecordingProvider()) {
 		this.scope = scope;
-		this.recorder = new MultipartRecordingProvider();
 		this.timer = BrowserTimerProvider.getInstance();
 		this.session = null;
 		this.uploader = null;
 		this.chunksEmitted = 0;
 		this.stopPromise = null;
 		this.abandonRequested = false;
+		this.recorder = recorder;
 	}
 	get isRecording() {
 		return this.recorder.isRecording;
@@ -1043,4 +1765,4 @@ var MultipartRecordingService = class {
 	}
 };
 //#endregion
-export { CameraCompositor as n, getAdaptiveMediaRecorderOptions as r, MultipartRecordingService as t };
+export { getAdaptiveMediaRecorderOptions as a, createRecordingCompositor as i, WorkerEncoderRecordingProvider as n, StreamCanvasProcessingSession as o, CameraCompositor as r, MultipartRecordingService as t };