@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/mandatory-consent.d.ts

@@ -1,3 +1,3 @@
-import { r as MandatoryConsentConfig } from "./types-Ckir_BEs.js";
-import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-BQ43yndC.js";
+import { r as MandatoryConsentConfig } from "./types-Cd0J0F9D.js";
+import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-B88Sm5nd.js";
 export { type MandatoryConsentActor, type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/mandatory-consent.esm.js

@@ -1,3 +1,3 @@
-import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-pXWqAHo_.esm.js";
-import { n as createMandatoryConsentManagerFromActor, t as createMandatoryConsentManager } from "./mandatoryConsentManager-Cwqx1nK7.esm.js";
+import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-DWslYPA3.esm.js";
+import { n as createMandatoryConsentManagerFromActor, t as createMandatoryConsentManager } from "./mandatoryConsentManager-B4vCYslr.esm.js";
 export { createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/{mandatoryConsentManager-Cwqx1nK7.esm.js → mandatoryConsentManager-B4vCYslr.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Du2A4-Qr.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
-import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-pXWqAHo_.esm.js";
+import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-DWslYPA3.esm.js";
 //#region src/modules/mandatory-consent/mandatoryConsentActor.ts
 function createMandatoryConsentActor(options) {
 	return createActor(mandatoryConsentMachine, { input: { config: options.config } }).start();
@@ -32,7 +32,8 @@ function mapState(snapshot) {
 	if (typedSnapshot.matches("closed")) return { status: "closed" };
 	if (typedSnapshot.matches("error")) return {
 		status: "error",
-		error: context.error ?? "Unknown error"
+		error: context.error ?? "Unknown error",
+		moduleErrorCode: context.moduleErrorCode
 	};
 	return { status: "idle" };
 }

package/dist/{mandatoryConsentManager-BQ43yndC.d.ts → mandatoryConsentManager-B88Sm5nd.d.ts}

@@ -1,13 +1,14 @@
 import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
 import { t as Manager } from "./Manager-C9T5amUN.js";
 import "./Actor-DpTj5PFb.js";
-import { n as MandatoryConsent, r as MandatoryConsentConfig, t as FetchMandatoryConsentResponse } from "./types-Ckir_BEs.js";
+import { n as MandatoryConsent, r as MandatoryConsentConfig, t as FetchMandatoryConsentResponse } from "./types-Cd0J0F9D.js";
 //#region src/modules/mandatory-consent/mandatoryConsentStateMachine.d.ts
 type MandatoryConsentContext = {
   config: MandatoryConsentConfig;
   consent: MandatoryConsent | undefined;
   isSigned: boolean;
   error: string | undefined;
+  moduleErrorCode: string | undefined;
 };
 type MandatoryConsentInput = {
   config: MandatoryConsentConfig;
@@ -56,6 +57,10 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "setError";
     params: NonReducibleUnknown;
   };
+  setLoadError: {
+    type: "setLoadError";
+    params: NonReducibleUnknown;
+  };
   toggleSigned: {
     type: "toggleSigned";
     params: NonReducibleUnknown;
@@ -71,7 +76,7 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
 }>, {
   type: "canSubmit";
   params: unknown;
-}, never, "error" | "idle" | "closed" | "finished" | "submitting" | "loading" | "display", string, MandatoryConsentInput, NonReducibleUnknown, EventObject, MetaObject, {
+}, never, "error" | "idle" | "closed" | "finished" | "loading" | "submitting" | "display", string, MandatoryConsentInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "mandatoryConsent";
   readonly initial: "idle";
   readonly context: ({ input }: {
@@ -171,6 +176,7 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     consent: undefined;
     isSigned: false;
     error: undefined;
+    moduleErrorCode: undefined;
   };
   readonly states: {
     readonly idle: {
@@ -234,7 +240,7 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
         };
         readonly onError: {
           readonly target: "error";
-          readonly actions: "setError";
+          readonly actions: "setLoadError";
         };
       };
     };
@@ -375,6 +381,7 @@ type MandatoryConsentClosedState = {
 type MandatoryConsentErrorState = {
   status: 'error';
   error: string;
+  moduleErrorCode?: string;
 };
 type MandatoryConsentState = MandatoryConsentIdleState | MandatoryConsentLoadingState | MandatoryConsentDisplayState | MandatoryConsentSubmittingState | MandatoryConsentFinishedState | MandatoryConsentClosedState | MandatoryConsentErrorState;
 declare function createMandatoryConsentManager(options: CreateMandatoryConsentActorOptions): Manager<MandatoryConsentState> & {

package/dist/{mandatoryConsentStateMachine-pXWqAHo_.esm.js → mandatoryConsentStateMachine-DWslYPA3.esm.js}

@@ -1,4 +1,4 @@
-import { t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
 //#region src/modules/mandatory-consent/mandatoryConsentServices.ts
@@ -34,21 +34,33 @@ const mandatoryConsentMachine = setup({
 		}] }, signal))
 	},
 	actions: {
+		setLoadError: assign(({ event }) => ({
+			error: String(event.error),
+			moduleErrorCode: "REGULATORY_CONSENT_LOAD_FAILED"
+		})),
 		setConsent: assign(({ event }) => {
 			return {
 				consent: event.output.consents[0],
 				isSigned: false,
-				error: void 0
+				error: void 0,
+				moduleErrorCode: void 0
 			};
 		}),
 		toggleSigned: assign(({ context }) => ({ isSigned: !context.isSigned })),
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		clearError: assign({ error: () => void 0 }),
+		setError: assign(({ event }) => ({
+			error: String(event.error),
+			moduleErrorCode: void 0
+		})),
+		clearError: assign({
+			error: () => void 0,
+			moduleErrorCode: () => void 0
+		}),
 		resetContext: assign(({ context }) => ({
 			config: context.config,
 			consent: void 0,
 			isSigned: false,
-			error: void 0
+			error: void 0,
+			moduleErrorCode: void 0
 		}))
 	},
 	guards: { canSubmit: ({ context }) => Boolean(context.consent?.id) && context.isSigned }
@@ -59,7 +71,8 @@ const mandatoryConsentMachine = setup({
 		config: input.config,
 		consent: void 0,
 		isSigned: false,
-		error: void 0
+		error: void 0,
+		moduleErrorCode: void 0
 	}),
 	states: {
 		idle: { on: { LOAD: {
@@ -76,7 +89,7 @@ const mandatoryConsentMachine = setup({
 			},
 			onError: {
 				target: "error",
-				actions: "setError"
+				actions: "setLoadError"
 			}
 		} },
 		display: { on: {

package/dist/mediaRecorderOptions-B9-IEVtV.esm.js

@@ -0,0 +1,70 @@
+import { a as isIOS } from "./platform-aPh7gTWh.esm.js";
+//#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
+export { getMultipartRecorderMimeType as n, getWorkerRecordingProfile as r, getAdaptiveMediaRecorderOptions as t };

package/dist/multipartRecordingService-BTqkHGG9.esm.js

@@ -0,0 +1,407 @@
+import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as BrowserNetworkStatusProvider } from "./BrowserNetworkStatusProvider-BrDXBEDd.esm.js";
+import { t as MultipartRecordingProvider } from "./MultipartRecordingProvider-D9mauUdS.esm.js";
+//#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
+var multipartRecordingService_exports = /* @__PURE__ */ __exportAll({ MultipartRecordingService: () => MultipartRecordingService });
+/** 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 { multipartRecordingService_exports as n, MultipartRecordingService as t };