@incodetech/core 2.4.1-agentic → 2.4.1-agentic.2

package/dist/{multipartRecordingService-DMBxHKS2.esm.js → CameraCompositor-DN7NkJzV.esm.js}

@@ -1,116 +1,5 @@
-import { t as api, u as endpoints } from "./api-BO8JA7Pf.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { a as isIOS } from "./platform-aPh7gTWh.esm.js";
-import { o as BrowserNetworkStatusProvider } from "./connectivity-HSl0diCx.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.
-* WebM avoids Safari's fragmented-MP4 unknown-duration metadata on versions
-* that can record it; older Safari versions fall back to MP4. Returns '' when
-* none match.
-*/
-function getSupportedMediaRecorderMimeType() {
-	for (const type of [
-		"video/webm",
-		"video/webm;codecs=vp9",
-		"video/webm;codecs=vp8",
-		"video/mp4"
-	]) if (MediaRecorder.isTypeSupported(type)) return type;
-	return "";
-}
-/**
-* Multipart recordings use the same WebM-first order. Some Android devices
-* advertise H.264 support but fail after MediaRecorder starts (ENG-56439).
-*/
-function getMultipartRecorderMimeType() {
-	return getSupportedMediaRecorderMimeType();
-}
-/**
-* `MediaRecorder` options tuned per platform — a higher bitrate on iOS, lower
-* elsewhere — paired with the supported mime type.
-*/
-function getAdaptiveMediaRecorderOptions() {
-	const mimeType = getSupportedMediaRecorderMimeType();
-	if (isIOS()) return {
-		mimeType,
-		videoBitsPerSecond: 1e6,
-		bitsPerSecond: 1e6
-	};
-	return {
-		mimeType,
-		videoBitsPerSecond: 5e5,
-		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
+import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
+import { r as getWorkerRecordingProfile } from "./mediaRecorderOptions-B9-IEVtV.esm.js";
 //#region ../infra/src/media/cameraCompositorWorker.ts
 /**
 * Whether the worker transport is available here. Every probe must hold;
@@ -698,6 +587,10 @@ function buildCameraCompositorWorkerSource() {
 }
 //#endregion
 //#region ../infra/src/media/CameraCompositor.ts
+var CameraCompositor_exports = /* @__PURE__ */ __exportAll({
+	CameraCompositor: () => CameraCompositor,
+	createRecordingCompositor: () => createRecordingCompositor
+});
 const MAX_COMPOSITE_LONG_EDGE = 1280;
 const MAX_COMPOSITE_SHORT_EDGE = 720;
 const FRAME_INTERVAL_TOLERANCE_RATIO = .9;
@@ -1134,624 +1027,4 @@ var CameraCompositor = class {
 	}
 };
 //#endregion
-//#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
-/**
-* How often `MediaRecorder` hands us buffered data (incremental blobs).
-* 500 ms keeps each blob — and therefore each upload chunk — small: less
-* tail lost when a session is interrupted, and a smaller first blob (init
-* header + keyframe), which is the largest and most timeout-prone chunk.
-* Not lower: request rate doubles per halving, and browsers stop honoring
-* very small timeslices reliably.
-*/
-const TIMESLICE_MS = 500;
-/**
-* Encoder target for the full video-selfie session. Higher than the
-* short-clip liveness path (0.5–1 Mbps) so a multi-minute session keeps
-* usable quality. It's a ceiling — a still scene still encodes well below it.
-*/
-const VIDEO_BITS_PER_SECOND = 25e5;
-/**
-* Records a stream and emits every `MediaRecorder` timeslice blob as its own
-* part, in order. Each blob is a whole container fragment (WebM cluster /
-* fMP4 `moof`+`mdat`), which is the property the video-selfie-service's
-* gap-splicing depends on — parts must never cut a fragment at a byte
-* offset. The service stages sub-5 MiB chunks and combines them server-side,
-* so emitting the smallest whole-fragment unit (~0.5 s of video) maximizes
-* what an interrupted session can salvage.
-*
-* Page-lifecycle orchestration lives in Core: it pauses this recorder before a
-* backgrounded camera can stall, restores the camera/compositor, and only then
-* resumes this same media container.
-*/
-var MultipartRecordingProvider = class {
-	constructor() {
-		this.mediaRecorder = null;
-		this._isRecording = false;
-		this._hasError = false;
-		this._error = null;
-		this.mimeType = "";
-		this.partNumber = 0;
-		this.onPart = null;
-	}
-	get isRecording() {
-		return this._isRecording;
-	}
-	get hasError() {
-		return this._hasError;
-	}
-	get error() {
-		return this._error;
-	}
-	startRecording(stream, onPart) {
-		this.reset();
-		this.partNumber = 0;
-		this.onPart = onPart;
-		try {
-			this.mimeType = getMultipartRecorderMimeType();
-			const recorder = new MediaRecorder(stream.clone(), {
-				mimeType: this.mimeType,
-				videoBitsPerSecond: VIDEO_BITS_PER_SECOND
-			});
-			recorder.ondataavailable = (event) => {
-				if (event.data.size > 0 && this.onPart) {
-					this.partNumber += 1;
-					this.onPart({
-						chunk: event.data,
-						partNumber: this.partNumber
-					});
-				}
-			};
-			recorder.onerror = (event) => {
-				const detail = event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type;
-				this._error = `Recording error: ${detail}`;
-				this._isRecording = false;
-				this._hasError = true;
-			};
-			recorder.start(TIMESLICE_MS);
-			this.mediaRecorder = recorder;
-			this._isRecording = true;
-			this._error = null;
-			this._hasError = false;
-		} catch (err) {
-			const detail = err instanceof Error ? err.message : String(err);
-			this._error = `Failed to start recording: ${detail}`;
-			this._hasError = true;
-		}
-	}
-	pauseRecording() {
-		const recorder = this.mediaRecorder;
-		if (!recorder || !this._isRecording || this._hasError) return false;
-		if (recorder.state === "paused") return true;
-		if (recorder.state !== "recording") return false;
-		try {
-			recorder.pause();
-			return true;
-		} catch (err) {
-			const detail = err instanceof Error ? err.message : String(err);
-			this._error = `Failed to pause recording: ${detail}`;
-			this._hasError = true;
-			return false;
-		}
-	}
-	resumeRecording() {
-		const recorder = this.mediaRecorder;
-		if (!recorder || !this._isRecording || this._hasError) return false;
-		if (recorder.state === "recording") return true;
-		if (recorder.state !== "paused") return false;
-		try {
-			recorder.resume();
-			return true;
-		} catch (err) {
-			const detail = err instanceof Error ? err.message : String(err);
-			this._error = `Failed to resume recording: ${detail}`;
-			this._hasError = true;
-			return false;
-		}
-	}
-	stopRecording() {
-		const recorder = this.mediaRecorder;
-		return new Promise((resolve) => {
-			if (recorder && this._isRecording) {
-				recorder.onstop = () => {
-					resolve();
-				};
-				recorder.stop();
-				this._isRecording = false;
-			} else resolve();
-			recorder?.stream?.getTracks().forEach((track) => track.stop());
-		});
-	}
-	reset() {
-		const recorder = this.mediaRecorder;
-		if (recorder) {
-			recorder.ondataavailable = null;
-			recorder.onerror = null;
-			recorder.onstop = null;
-			if (recorder.state !== "inactive") recorder.stop();
-			recorder.stream.getTracks().forEach((track) => track.stop());
-			this.mediaRecorder = null;
-		}
-		this.onPart = null;
-		this._isRecording = false;
-		this._error = null;
-		this._hasError = false;
-	}
-};
-//#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 src/internal/recordings/videoSelfieUploadService.ts
-/**
-* Opens a scoped multipart video upload session. Idempotent server-side: if
-* an upload is already in progress for the `(session, scope)` pair, the same `uploadId`
-* comes back along with the parts already stored (`parts` non-empty) — but
-* always with a fresh `epoch` that locks out whoever held the previous one.
-*/
-async function initiateVideoSelfieUpload(scope = "videoselfie") {
-	const response = await api.post(endpoints.videoSelfieUploadInitiate, void 0, { query: { scope } });
-	return {
-		uploadId: response.data.uploadId,
-		epoch: response.data.epoch,
-		scope,
-		parts: response.data.parts ?? []
-	};
-}
-/**
-* Uploads a single chunk as a multipart part. The body is the raw video bytes
-* (no base64, no client-side encryption — encryption at rest is server-side
-* S3 SSE). Every part except the last must be >= 5 MiB (enforced
-* server-side). Returns the part number + `etag` needed to complete the
-* upload. Rejects with a `409` status when a newer initiate fenced this
-* session out.
-*/
-async function uploadVideoSelfiePart(session, partNumber, chunk) {
-	const response = await api.post(endpoints.videoSelfieUploadPart, chunk, {
-		query: {
-			uploadId: session.uploadId,
-			epoch: session.epoch,
-			partNumber,
-			scope: session.scope
-		},
-		headers: { "Content-Type": "application/octet-stream" }
-	});
-	return {
-		partNumber: response.data.partNumber,
-		etag: response.data.etag
-	};
-}
-/**
-* Finalizes the upload. The service assembles from the parts it stored; the
-* optional `parts` list is deliberately NOT sent — chunks staged below the
-* S3 minimum are combined and renumbered server-side, so a client-side list
-* could contradict the authoritative one. Safe to repeat if the response
-* was lost. Returns the server-reported status. Rejects with `400` naming a
-* missing part when the sequence has a hole.
-*/
-async function completeVideoSelfieUpload(session) {
-	return (await api.post(endpoints.videoSelfieUploadComplete, {
-		uploadId: session.uploadId,
-		epoch: session.epoch
-	}, { query: { scope: session.scope } })).data.status;
-}
-/**
-* Discards an in-progress upload and everything already sent for it, so the
-* backend fails the upload straight away instead of waiting for its expiry.
-* Call when a recording is abandoned or its upload can no longer complete.
-*/
-async function abortVideoSelfieUpload(session) {
-	return (await api.post(endpoints.videoSelfieUploadAbort, {
-		uploadId: session.uploadId,
-		epoch: session.epoch
-	}, { query: { scope: session.scope } })).data.status;
-}
-//#endregion
-//#region src/internal/recordings/videoSelfieChunkUploader.ts
-/**
-* How many part uploads run concurrently. The service allows 10 rps with a
-* burst of 30 per session; a real recorder emits ~2 chunks/s, so this cap
-* only matters when a backlog is draining after a network stall.
-*/
-const MAX_IN_FLIGHT = 3;
-/** Attempts per chunk in the live round (first try + retries). */
-const MAX_ATTEMPTS = 4;
-/** Extra attempts per parked chunk during the final drain() round. */
-const DRAIN_ATTEMPTS = 2;
-const BACKOFF_BASE_MS = 500;
-const BACKOFF_CAP_MS = 8e3;
-/** Upper bound honored for a server-sent `Retry-After` (seconds). */
-const RETRY_AFTER_CAP_MS = 3e4;
-/**
-* Ceiling on un-acknowledged chunk bytes held in memory. On a network slower
-* than the encoder the backlog grows without bound; past this the upload
-* cannot realistically catch up, so the uploader fails instead of eating
-* memory on a low-end device. ~48 MiB ≈ 2.5 minutes of video at our bitrate.
-*/
-const MAX_BUFFERED_BYTES = 48 * 1024 * 1024;
-function httpStatusOf$1(error) {
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
-	return null;
-}
-function retryAfterMsOf(error) {
-	if (typeof error === "object" && error !== null && "headers" in error && typeof error.headers === "object") {
-		const headers = error.headers;
-		const seconds = Number(headers?.["retry-after"]);
-		if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
-	}
-	return null;
-}
-/**
-* Uploads video-selfie chunks with the client-side half of the service's
-* resilience contract (`video-selfie-service` README, "What a client can
-* rely on"):
-*
-* - **Keep-until-ack** — every chunk is held in memory until its upload
-*   returns 200 (a hole in the sequence can only be filled by that exact
-*   data). Acked bytes are durable in S3 (stored as a part or staged), so
-*   the blob is released the moment the ack lands.
-* - **Retry with backoff** — transient failures (network error/timeout,
-*   408, 429, 5xx) retry the same bytes under the same partNumber with
-*   exponential backoff + full jitter; 429 honors the server's
-*   `Retry-After`. Chunks may land out of order — the service stages them.
-* - **Park, then drain** — a chunk that exhausts its live retries is parked
-*   (blob kept) without failing the recording; {@link drain} gives every
-*   parked chunk a final round once recording stops, so a mid-recording
-*   network outage only fails the upload if it persists to the end. A
-*   browser `online` event un-parks early: parked chunks get a fresh live
-*   round as soon as connectivity returns instead of waiting for stop.
-* - **409 is fatal** — a newer initiate fenced this session out ("latest
-*   initiate wins"); no retry can succeed, so the uploader stops.
-* - **Bounded memory** — when un-acked bytes exceed the ceiling the
-*   uploader fails rather than buffering a runaway backlog.
-*/
-var VideoSelfieChunkUploader = class {
-	constructor(session, dependencies = {}) {
-		this.queue = [];
-		this.parked = [];
-		this.inFlight = 0;
-		this.bufferedBytes = 0;
-		this.fatal = false;
-		this.disposed = false;
-		this.tasks = [];
-		this.session = session;
-		this.timer = dependencies.timer ?? BrowserTimerProvider.getInstance();
-		this.jitter = dependencies.jitter ?? Math.random;
-		const networkStatus = dependencies.networkStatus ?? new BrowserNetworkStatusProvider();
-		this.unsubscribeOnline = networkStatus.onOnline(() => this.unparkEarly());
-	}
-	/** True once the upload cannot complete (fenced out or over the memory cap). */
-	get failed() {
-		return this.fatal;
-	}
-	/**
-	* Accepts the next chunk for upload. Non-blocking: the upload (and any
-	* retries) run in the background; failures surface through {@link failed}
-	* and {@link drain}.
-	*/
-	enqueue(partNumber, chunk) {
-		if (this.fatal || this.disposed) return;
-		this.bufferedBytes += chunk.size;
-		if (this.bufferedBytes > MAX_BUFFERED_BYTES) {
-			this.fatal = true;
-			return;
-		}
-		this.queue.push({
-			partNumber,
-			chunk,
-			attempts: 0
-		});
-		this.pump();
-	}
-	/**
-	* Waits for every accepted chunk to be acknowledged, giving parked chunks
-	* one final retry round. Returns `true` when all chunks landed and the
-	* upload can be completed.
-	*/
-	async drain() {
-		this.unsubscribeOnline();
-		await this.settleLiveRound();
-		while (!this.fatal && this.parked.length > 0) {
-			const chunk = this.parked.shift();
-			chunk.attempts = MAX_ATTEMPTS - DRAIN_ATTEMPTS;
-			this.queue.push(chunk);
-			this.pump();
-			await this.settleLiveRound();
-			if (this.parked.some((p) => p.partNumber === chunk.partNumber)) return false;
-		}
-		return !this.disposed && !this.fatal && this.parked.length === 0;
-	}
-	/** Cancels all pending work; held blobs are released. */
-	dispose() {
-		this.disposed = true;
-		this.queue = [];
-		this.parked = [];
-		this.unsubscribeOnline();
-	}
-	/**
-	* Connectivity is back (browser `online` event) — give parked chunks a
-	* fresh live round right away instead of holding them until {@link drain}.
-	* The event is only a hint: chunks that still fail simply park again.
-	*/
-	unparkEarly() {
-		if (this.fatal || this.disposed || this.parked.length === 0) return;
-		for (const chunk of this.parked.splice(0)) {
-			chunk.attempts = 0;
-			this.queue.push(chunk);
-		}
-		this.pump();
-	}
-	async settleLiveRound() {
-		while (this.tasks.length > 0) {
-			const snapshot = [...this.tasks];
-			await Promise.all(snapshot);
-			this.tasks = this.tasks.filter((task) => !snapshot.includes(task));
-		}
-	}
-	pump() {
-		while (!this.fatal && !this.disposed && this.inFlight < MAX_IN_FLIGHT && this.queue.length > 0) {
-			const chunk = this.queue.shift();
-			this.inFlight += 1;
-			const task = this.uploadWithRetry(chunk).finally(() => {
-				this.inFlight -= 1;
-				this.pump();
-			});
-			this.tasks.push(task);
-		}
-	}
-	async uploadWithRetry(pending) {
-		while (!this.disposed) {
-			pending.attempts += 1;
-			try {
-				await uploadVideoSelfiePart(this.session, pending.partNumber, pending.chunk);
-				this.bufferedBytes -= pending.chunk.size;
-				return;
-			} catch (error) {
-				const status = httpStatusOf$1(error);
-				if (status === 409) {
-					this.fatal = true;
-					return;
-				}
-				if (status !== null && status >= 400 && status < 500 && status !== 408 && status !== 429 || pending.attempts >= MAX_ATTEMPTS) {
-					this.parked.push(pending);
-					return;
-				}
-				await this.delayBeforeRetry(pending.attempts, error);
-			}
-		}
-	}
-	delayBeforeRetry(attempt, error) {
-		const retryAfterMs = retryAfterMsOf(error);
-		const backoffCeiling = Math.min(BACKOFF_BASE_MS * 2 ** (attempt - 1), BACKOFF_CAP_MS);
-		const waitMs = retryAfterMs ?? backoffCeiling / 2 + this.jitter() * (backoffCeiling / 2);
-		return new Promise((resolve) => {
-			this.timer.setTimeout(resolve, waitMs);
-		});
-	}
-};
-//#endregion
-//#region src/internal/recordings/multipartRecordingService.ts
-/** Attempts for `complete` — documented safe to repeat if the response was lost. */
-const COMPLETE_ATTEMPTS = 3;
-const COMPLETE_BACKOFF_MS = 500;
-function httpStatusOf(error) {
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
-	return null;
-}
-/**
-* Records the camera on-device and streams it to the backend as it is
-* captured, using the video-selfie-service multipart upload protocol
-* (`/v1/video-upload/*`).
-*
-* This is the client-side recorder for Video Selfie and for scoped regular
-* Selfie and ID recordings. It replaces the former server-side recording path.
-*
-* Every ~0.5 s recorder blob uploads as its own chunk, concurrently with
-* recording, through {@link VideoSelfieChunkUploader} (keep-until-ack +
-* retry with backoff — see its doc for the full policy). The service stages
-* sub-5 MiB chunks and combines them server-side, so `stop()` only drains
-* the stragglers and finalizes; client memory holds un-acked chunks only.
-* No client-side encryption: video is encrypted at rest server-side
-* (S3 SSE-AES-256).
-*/
-var MultipartRecordingService = class {
-	constructor(scope = "videoselfie", recorder = new MultipartRecordingProvider()) {
-		this.scope = scope;
-		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;
-	}
-	async start(stream) {
-		if (this.recorder.isRecording) return;
-		let initiated = await initiateVideoSelfieUpload(this.scope);
-		if (initiated.parts.length > 0) {
-			await abortVideoSelfieUpload(initiated).catch(() => {});
-			initiated = await initiateVideoSelfieUpload(this.scope);
-		}
-		this.session = {
-			uploadId: initiated.uploadId,
-			epoch: initiated.epoch,
-			scope: this.scope
-		};
-		this.uploader = new VideoSelfieChunkUploader(this.session);
-		this.chunksEmitted = 0;
-		this.abandonRequested = false;
-		this.recorder.startRecording(stream, ({ chunk, partNumber }) => {
-			this.chunksEmitted += 1;
-			this.uploader?.enqueue(partNumber, chunk);
-		});
-	}
-	/** Pause the current media container without finalizing its upload. */
-	pause() {
-		return this.recorder.pauseRecording?.() ?? false;
-	}
-	/** Resume the same media container after its video source has recovered. */
-	resume() {
-		return this.recorder.resumeRecording?.() ?? false;
-	}
-	stop() {
-		if (this.stopPromise) return this.stopPromise;
-		const stopPromise = this.finalizeRecording();
-		this.stopPromise = stopPromise;
-		const clearStopPromise = () => {
-			if (this.stopPromise === stopPromise) {
-				this.stopPromise = null;
-				this.abandonRequested = false;
-			}
-		};
-		stopPromise.then(clearStopPromise, clearStopPromise);
-		return stopPromise;
-	}
-	async finalizeRecording() {
-		const session = this.session;
-		const uploader = this.uploader;
-		if (!this.recorder.isRecording || !session || !uploader) return { recordingId: null };
-		try {
-			await this.recorder.stopRecording();
-			if (this.abandonRequested) {
-				this.abandonUpload(session);
-				return { recordingId: null };
-			}
-			const delivered = await uploader.drain();
-			if (this.abandonRequested || !delivered || uploader.failed || this.chunksEmitted === 0) {
-				this.abandonUpload(session);
-				return { recordingId: null };
-			}
-		} catch (error) {
-			this.abandonUpload(session);
-			throw error;
-		}
-		try {
-			await this.completeWithRetry(session);
-			this.session = null;
-			this.uploader = null;
-			return { recordingId: session.uploadId };
-		} catch {
-			this.abandonUpload(session);
-			return { recordingId: null };
-		}
-	}
-	cleanup() {
-		if (this.session) if (this.stopPromise) {
-			this.abandonRequested = true;
-			this.uploader?.dispose();
-		} else this.abandonUpload(this.session);
-		this.recorder.reset();
-	}
-	/**
-	* `complete` is idempotent server-side ("safe to repeat if the response
-	* was lost"), so transient failures — network errors, 5xx, 429 — retry a
-	* couple of times before the recording is declared failed. A 4xx (e.g.
-	* `400` naming a missing part) is permanent: after a clean drain every
-	* chunk was acked, so a reported hole cannot be filled from here.
-	*/
-	async completeWithRetry(session) {
-		for (let attempt = 1;; attempt += 1) {
-			if (this.abandonRequested) throw new Error("Video upload abandoned");
-			try {
-				await completeVideoSelfieUpload(session);
-				return;
-			} catch (error) {
-				const status = httpStatusOf(error);
-				if (status !== null && status >= 400 && status < 500 && status !== 408 && status !== 429 || attempt >= COMPLETE_ATTEMPTS) throw error;
-				await new Promise((resolve) => {
-					this.timer.setTimeout(resolve, COMPLETE_BACKOFF_MS * attempt);
-				});
-			}
-		}
-	}
-	/**
-	* Fire-and-forget abort: the upload can no longer complete, so tell the
-	* backend to fail it immediately rather than at its expiry. Best-effort —
-	* an abort that doesn't land (including a 409 from a newer epoch having
-	* taken over) just means the server falls back to expiry or salvage.
-	*/
-	abandonUpload(session) {
-		if (this.session !== session) return;
-		this.session = null;
-		this.uploader?.dispose();
-		this.uploader = null;
-		abortVideoSelfieUpload(session).catch(() => {});
-	}
-};
-//#endregion
-export { getAdaptiveMediaRecorderOptions as a, createRecordingCompositor as i, WorkerEncoderRecordingProvider as n, StreamCanvasProcessingSession as o, CameraCompositor as r, MultipartRecordingService as t };
+export { CameraCompositor_exports as n, createRecordingCompositor as r, CameraCompositor as t };