@incodetech/core 0.0.0-dev-20260914-656e6757 → 0.0.0-dev-20260915-1e83a656

package/dist/{idCaptureDefaults-Cj1elqAi.esm.js → idCaptureDefaults-BqPUqWvx.esm.js}

@@ -1,20 +1,161 @@
 import { b as resolveWasmSource, p as WASM_MODEL_FILES } from "./wasmWebClient-B7baE-Wf.esm.js";
-import { p as getBarcodeEnhanceModelUrl } from "./setup-ItT0ngv1.esm.js";
+import { p as getBarcodeEnhanceModelUrl } from "./setup-CokQ-yUA.esm.js";
 import { s as wasmRuntime, t as getResolvedModelSource } from "./warmup-CUUnwYxe.esm.js";
 import { i as BaseWasmProvider } from "./safeStorage-B-trhxg6.esm.js";
 import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
+//#region ../infra/src/media/cameraCompositorWorker.ts
+/**
+* Whether the worker transport is available here. Every probe must hold;
+* anything missing routes `CameraCompositor` to its main-thread path.
+*/
+function canUseCameraCompositorWorker() {
+	const g = globalThis;
+	return typeof g.MediaStreamTrackProcessor === "function" && typeof g.MediaStreamTrackGenerator === "function" && typeof g.Worker === "function" && typeof g.OffscreenCanvas === "function" && typeof g.VideoFrame === "function";
+}
+function createTrackProcessor(track) {
+	const Ctor = globalThis.MediaStreamTrackProcessor;
+	if (!Ctor) throw new Error("MediaStreamTrackProcessor unavailable");
+	return new Ctor({ track });
+}
+function createTrackGenerator() {
+	const Ctor = globalThis.MediaStreamTrackGenerator;
+	if (!Ctor) throw new Error("MediaStreamTrackGenerator unavailable");
+	return new Ctor({ kind: "video" });
+}
+/**
+* The worker's entire logic. SELF-CONTAINED (serialized via toString into the
+* blob): no module references. Frame loop: read → scale within the bound →
+* write → close. The processor buffers at most one frame, so reads always
+* yield the freshest frame; while paused, frames are still read and closed so
+* the camera's frame pool stays healthy — an unclosed VideoFrame can stall the
+* capture pipeline, which the recording must never do.
+*/
+function cameraCompositorWorkerMain(scope) {
+	const g = globalThis;
+	let maxLongEdge = 1280;
+	let maxShortEdge = 720;
+	let canvas = null;
+	let ctx = null;
+	let writer = null;
+	let activeReader = null;
+	let generation = 0;
+	let paused = false;
+	let announceNextFrame = false;
+	const boundedSize = (width, height) => {
+		const scale = Math.min(1, maxLongEdge / Math.max(width, height), maxShortEdge / Math.min(width, height));
+		return {
+			width: Math.max(1, Math.round(width * scale)),
+			height: Math.max(1, Math.round(height * scale))
+		};
+	};
+	const scaled = (frame) => {
+		const size = boundedSize(frame.displayWidth, frame.displayHeight);
+		if (!canvas || !ctx || size.width === frame.displayWidth && size.height === frame.displayHeight) return frame;
+		if (canvas.width !== size.width || canvas.height !== size.height) {
+			canvas.width = size.width;
+			canvas.height = size.height;
+		}
+		ctx.drawImage(frame, 0, 0, size.width, size.height);
+		const out = new g.VideoFrame(canvas, { timestamp: frame.timestamp });
+		frame.close();
+		return out;
+	};
+	const pump = async (readable, gen) => {
+		const reader = readable.getReader();
+		activeReader = reader;
+		try {
+			for (;;) {
+				const { value: frame, done } = await reader.read();
+				if (done) {
+					if (gen === generation) scope.postMessage({ type: "ended" });
+					return;
+				}
+				if (gen !== generation) {
+					frame.close();
+					return;
+				}
+				if (paused || !writer) {
+					frame.close();
+					continue;
+				}
+				await writer.write(scaled(frame));
+				if (announceNextFrame) {
+					announceNextFrame = false;
+					scope.postMessage({ type: "frame" });
+				}
+			}
+		} catch (error) {
+			if (gen === generation) scope.postMessage({
+				type: "fatal",
+				message: String(error)
+			});
+		}
+	};
+	const switchSource = (readable) => {
+		generation += 1;
+		const previous = activeReader;
+		activeReader = null;
+		previous?.cancel().catch(() => {});
+		pump(readable, generation);
+	};
+	scope.onmessage = (event) => {
+		const message = event.data;
+		switch (message.type) {
+			case "start":
+				maxLongEdge = message.maxLongEdge;
+				maxShortEdge = message.maxShortEdge;
+				canvas = new g.OffscreenCanvas(1, 1);
+				ctx = canvas.getContext("2d");
+				writer = message.writable.getWriter();
+				announceNextFrame = true;
+				switchSource(message.readable);
+				break;
+			case "source":
+				switchSource(message.readable);
+				break;
+			case "pause":
+				paused = true;
+				break;
+			case "resume":
+				paused = false;
+				announceNextFrame = true;
+				break;
+			default: break;
+		}
+	};
+}
+/** Assembles the classic-worker script from the serialized worker main. */
+function buildCameraCompositorWorkerSource() {
+	return [`const workerMain = ${cameraCompositorWorkerMain.toString()};`, "workerMain(self);"].join("\n");
+}
+//#endregion
 //#region ../infra/src/media/CameraCompositor.ts
 const MAX_COMPOSITE_LONG_EDGE = 1280;
 const MAX_COMPOSITE_SHORT_EDGE = 720;
 const FRAME_INTERVAL_TOLERANCE_RATIO = .9;
 const DEFAULT_RESUME_TIMEOUT_MS = 2e3;
 /**
-* Composites the *active* camera into a canvas and exposes the canvas as a
-* single, stable `MediaStream` to record. Switching cameras (front ↔ back)
-* just repoints what the canvas draws — the output stream and its audio track
-* are never replaced — so a single `MediaRecorder` produces one continuous
-* video that follows the camera switches (V1 parity), instead of restarting
-* per camera.
+* 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
+* `MediaRecorder` produces one continuous video that follows the camera
+* switches (V1 parity), instead of restarting per camera.
+*
+* Two transports (ENG-55397):
+*  - **Worker (preferred, Chromium 94+):** camera track →
+*    `MediaStreamTrackProcessor` → worker scales on an `OffscreenCanvas` →
+*    `MediaStreamTrackGenerator`. The main thread is not in the frame path, so
+*    the recording stays at camera rate while the synchronous ID detection
+*    tick saturates the main thread (measured: 4–9 fps main-thread vs 30 fps
+*    worker on a Galaxy S21 under the same load).
+*  - **Main thread (fallback):** hidden `<video>` → rVFC/rAF → canvas →
+*    `captureStream`, for Safari, Firefox and strict-CSP hosts that block blob
+*    workers.
+*
+* 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
+* instead of talking to a dead worker.
 *
 * The audio track from the initial stream is carried through unchanged across
 * video switches, so there's no audio glitch when the camera flips.
@@ -24,8 +165,11 @@ var CameraCompositor = class {
 		this.canvas = null;
 		this.ctx = null;
 		this.video = null;
+		this.transport = null;
+		this.generator = null;
 		this.frameRequestId = null;
 		this.frameRequestKind = null;
+		this.sourceExceedsTargetFps = false;
 		this.lastDrawTimeMs = null;
 		this.lastVideoTimeSeconds = null;
 		this.audioTrack = null;
@@ -41,29 +185,33 @@ var CameraCompositor = class {
 	* `switchVideo` calls.
 	*/
 	start(stream) {
-		this.canvas = document.createElement("canvas");
-		this.ctx = this.canvas.getContext("2d");
-		this.video = document.createElement("video");
-		this.video.muted = true;
-		this.video.playsInline = true;
 		this.audioTrack = stream.getAudioTracks()[0] ?? null;
-		this.setVideoSource(stream);
-		const composite = this.canvas.captureStream(this.fps);
+		const composite = this.startWorkerTransport(stream) ?? this.startMainThread(stream);
 		if (this.audioTrack) composite.addTrack(this.audioTrack);
 		this.composite = composite;
-		this.startDrawLoop();
 		return composite;
 	}
 	/**
-	* Swap the camera feeding the canvas without interrupting the composite
+	* Swap the camera feeding the composite without interrupting the composite
 	* stream. Pass a video-only stream (audio is kept from `start`). The previous
 	* video track is stopped.
 	*/
 	switchVideo(stream) {
 		if (!this.composite) return;
 		const previousVideoTrack = this.videoTrack;
-		this.setVideoSource(stream);
-		this.startDrawLoop();
+		if (this.transport) {
+			this.videoTrack = stream.getVideoTracks()[0] ?? null;
+			if (this.videoTrack) try {
+				const processor = createTrackProcessor(this.videoTrack);
+				this.postToWorker({
+					type: "source",
+					readable: processor.readable
+				}, [processor.readable]);
+			} catch {}
+		} else if (this.video) {
+			this.setVideoSource(stream);
+			this.startDrawLoop();
+		} else this.videoTrack = stream.getVideoTracks()[0] ?? null;
 		if (previousVideoTrack) previousVideoTrack.stop();
 	}
 	/** The composite stream being recorded, if compositing is active. */
@@ -73,26 +221,32 @@ var CameraCompositor = class {
 	/** Pause source playback and drawing while the page is backgrounded. */
 	pause() {
 		this.finishResume("timed-out");
+		if (this.transport) {
+			this.postToWorker({ type: "pause" });
+			return;
+		}
 		this.cancelDrawLoop();
 		this.video?.pause();
 	}
 	/**
-	* Restart source playback and wait for a genuinely new camera frame to be
-	* drawn into the stable canvas stream. The caller must not resume encoding
-	* until this resolves with `resumed`.
+	* Restart source playback and wait for a genuinely new camera frame to reach
+	* the stable composite stream. The caller must not resume encoding until
+	* this resolves with `resumed`.
 	*/
 	async resume(signal) {
 		const video = this.video;
-		if (!video || !this.composite) return "timed-out";
+		if (!this.composite || !video && !this.transport) return "timed-out";
 		if (this.audioTrack?.readyState === "ended") return "audio-ended";
 		if (!this.videoTrack || this.videoTrack.readyState === "ended") return "video-ended";
 		if (signal?.aborted) return "timed-out";
-		try {
-			await video.play();
-		} catch {
-			return "timed-out";
+		if (video && !this.transport) {
+			try {
+				await video.play();
+			} catch {
+				return "timed-out";
+			}
+			if (signal?.aborted) return "timed-out";
 		}
-		if (signal?.aborted) return "timed-out";
 		this.finishResume("timed-out");
 		return new Promise((resolve) => {
 			const timeout = setTimeout(() => {
@@ -115,13 +269,20 @@ var CameraCompositor = class {
 				resolve,
 				timeout
 			};
+			if (this.transport) {
+				this.postToWorker({ type: "resume" });
+				return;
+			}
 			this.startDrawLoop(false);
 		});
 	}
-	/** Stop compositing and release the canvas, audio, and video tracks. */
+	/** Stop compositing and release the worker, canvas, audio and video tracks. */
 	stop() {
 		this.finishResume("timed-out");
 		this.cancelDrawLoop();
+		this.releaseWorker();
+		this.generator?.stop();
+		this.generator = null;
 		this.videoTrack?.stop();
 		this.audioTrack?.stop();
 		this.composite?.getTracks().forEach((track) => track.stop());
@@ -133,8 +294,90 @@ var CameraCompositor = class {
 		this.audioTrack = null;
 		this.composite = null;
 	}
+	/**
+	* Worker transport. Returns `null` — and leaves nothing behind — when the
+	* browser lacks insertable streams or a strict `worker-src` CSP blocks blob
+	* workers, so `start` falls through to the main-thread path. Never throws.
+	*/
+	startWorkerTransport(stream) {
+		const track = stream.getVideoTracks()[0];
+		if (!track || !canUseCameraCompositorWorker()) return null;
+		let worker = null;
+		let generator = null;
+		let blobUrl = null;
+		try {
+			const processor = createTrackProcessor(track);
+			generator = createTrackGenerator();
+			blobUrl = URL.createObjectURL(new Blob([buildCameraCompositorWorkerSource()], { type: "text/javascript" }));
+			worker = new Worker(blobUrl);
+			worker.onmessage = (event) => this.onWorkerMessage(event.data);
+			worker.onerror = (event) => this.onWorkerMessage({
+				type: "fatal",
+				message: event?.message || "worker error"
+			});
+			const message = {
+				type: "start",
+				readable: processor.readable,
+				writable: generator.writable,
+				maxLongEdge: MAX_COMPOSITE_LONG_EDGE,
+				maxShortEdge: MAX_COMPOSITE_SHORT_EDGE
+			};
+			worker.postMessage(message, [processor.readable, generator.writable]);
+		} catch {
+			worker?.terminate();
+			generator?.stop();
+			if (blobUrl) URL.revokeObjectURL(blobUrl);
+			return null;
+		}
+		this.videoTrack = track;
+		this.transport = {
+			worker,
+			blobUrl
+		};
+		this.generator = generator;
+		return new MediaStream([generator]);
+	}
+	/** Terminates the worker and frees its blob; idempotent. */
+	releaseWorker() {
+		if (!this.transport) return;
+		this.transport.worker.terminate();
+		URL.revokeObjectURL(this.transport.blobUrl);
+		this.transport = null;
+	}
+	startMainThread(stream) {
+		this.canvas = document.createElement("canvas");
+		this.ctx = this.canvas.getContext("2d");
+		this.video = document.createElement("video");
+		this.video.muted = true;
+		this.video.playsInline = true;
+		this.setVideoSource(stream);
+		const composite = this.canvas.captureStream(this.fps);
+		this.startDrawLoop();
+		return composite;
+	}
+	postToWorker(message, transfer = []) {
+		this.transport?.worker.postMessage(message, transfer);
+	}
+	onWorkerMessage(message) {
+		if (!this.transport) return;
+		switch (message.type) {
+			case "frame":
+				this.finishResume("resumed");
+				break;
+			case "ended":
+				this.finishResume("video-ended");
+				break;
+			case "fatal":
+				this.releaseWorker();
+				this.finishResume("timed-out");
+				break;
+			default: break;
+		}
+	}
 	setVideoSource(stream) {
 		this.videoTrack = stream.getVideoTracks()[0] ?? null;
+		const sourceFps = this.videoTrack && typeof this.videoTrack.getSettings === "function" ? this.videoTrack.getSettings().frameRate : void 0;
+		this.sourceExceedsTargetFps = typeof sourceFps === "number" && sourceFps > this.fps;
 		const video = this.video;
 		if (!video) return;
 		video.srcObject = new MediaStream(stream.getVideoTracks());
@@ -146,7 +389,7 @@ var CameraCompositor = class {
 		if (resetSourceTime) this.lastVideoTimeSeconds = null;
 		const draw = (timeMs) => {
 			const elapsed = this.lastDrawTimeMs === null ? Infinity : timeMs - this.lastDrawTimeMs;
-			if ((this.frameIntervalMs === 0 || elapsed >= this.frameIntervalMs * FRAME_INTERVAL_TOLERANCE_RATIO) && this.drawCurrentFrame()) {
+			if ((!(this.frameIntervalMs > 0 && (this.frameRequestKind !== "video" || this.sourceExceedsTargetFps)) || elapsed >= this.frameIntervalMs * FRAME_INTERVAL_TOLERANCE_RATIO) && this.drawCurrentFrame()) {
 				this.lastDrawTimeMs = timeMs;
 				this.finishResume("resumed");
 			}

package/dist/{idCaptureManager-ssRJRsGQ.esm.js → idCaptureManager-JfqtqR7F.esm.js}

@@ -1,12 +1,12 @@
-import { l as BrowserStorageProvider } from "./setup-ItT0ngv1.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CokQ-yUA.esm.js";
 import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-B2e8p268.esm.js";
 import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BrJN1B8A.esm.js";
 import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-Bj_fyWtv.esm.js";
-import { a as createIdProtectedCaptureController, n as provideIdProtectedCaptureController, o as findIdProtectedCaptureController, s as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-DS6fNfwz.esm.js";
-import { v as resolveCaptureOptimizingTreatment, y as resolveIdCaptureThresholds } from "./idCaptureServices-BRq1TB4U.esm.js";
+import { a as createIdProtectedCaptureController, n as provideIdProtectedCaptureController, o as findIdProtectedCaptureController, s as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-Dt-gpoLr.esm.js";
+import { v as resolveCaptureOptimizingTreatment, y as resolveIdCaptureThresholds } from "./idCaptureServices-DLL6vNtO.esm.js";
 //#region src/modules/id/digitalUpload/instrumentation.ts
 const TERMINAL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isHoldingState(value) {

package/dist/{idCaptureServices-BRq1TB4U.esm.js → idCaptureServices-DLL6vNtO.esm.js}

@@ -1,5 +1,5 @@
-import { t as ensureWasmPipelines } from "./setup-ItT0ngv1.esm.js";
-import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-DFmsuX0f.esm.js";
+import { t as ensureWasmPipelines } from "./setup-CokQ-yUA.esm.js";
+import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-BEx5c9G9.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { i as isDesktop } from "./platform-DkcRc9JV.esm.js";
@@ -9,8 +9,8 @@ import { s as queryCameraPermission } from "./permissionServices-Bj_fyWtv.esm.js
 import { n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-CCWy13M-.esm.js";
 import { a as isBackFacingTrack, n as getBackCameraStream } from "./backCameraStream-BOtyQowf.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
-import { t as MultipartRecordingService } from "./multipartRecordingService-B3C_zlev.esm.js";
-import { i as CameraCompositor, n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-Cj1elqAi.esm.js";
+import { t as MultipartRecordingService } from "./multipartRecordingService-CWxZ5mTi.esm.js";
+import { i as CameraCompositor, n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-BqPUqWvx.esm.js";
 //#region src/internal/camera/cameraServices.ts
 function createCameraServices(camera) {
 	return {

package/dist/{idCaptureStateMachine-DS6fNfwz.esm.js → idCaptureStateMachine-Dt-gpoLr.esm.js}

@@ -1,16 +1,16 @@
-import { l as BrowserStorageProvider } from "./setup-ItT0ngv1.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CokQ-yUA.esm.js";
 import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { s as exposeExperimentOnce } from "./feature-management-DFmsuX0f.esm.js";
+import { s as exposeExperimentOnce } from "./feature-management-BEx5c9G9.esm.js";
 import { n as revokeObjectURL, t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, m as isTrueSightTesting, r as noteTrueSightCaptureActivity } from "./trueSightService-Cmein6eU.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, m as isTrueSightTesting, r as noteTrueSightCaptureActivity } from "./trueSightService-D03Z4v0r.esm.js";
 import { n as eventModuleNames, s as recordExperimentAssignmentOnce } from "./events-ijlbX_Wx.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-HuJ4OYs0.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-CX84J4ZG.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
 import { a as isIOS, s as isIPad, t as isAndroid, u as isMacOsSafari } from "./platform-DkcRc9JV.esm.js";
-import "./session-c5Zk9ScZ.esm.js";
+import "./session-2LBHdwZv.esm.js";
 import { c as not, i as assign, l as raise, n as enqueueActions, o as and, r as sendTo, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { n as getUrlSearchParam, t as buildUrlWithSearchParams } from "./urlUtils-D6phjq1-.esm.js";
@@ -24,8 +24,8 @@ import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as getBrowser } from "./getBrowser-Cbe1C4Tn.esm.js";
 import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
 import { n as runVirtualCameraCheck, t as frameSources } from "./virtualCameraCheck-WOloJ-do.esm.js";
-import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-Cj1elqAi.esm.js";
-import { S as getIdCameraStream, _ as ID_ERROR_CODES, a as getRealQualityValue, b as CAPTURE_OPTIMIZING, d as startRecordingSession, f as stopRecording, g as validateUploadResponse, h as uploadManualIdFile, i as finalizeRecordingSession, l as prepareRecordingForCameraRetry, m as uploadIdImage, o as initializeIdCapture, p as stopStream, r as disposeRecordingSession, t as addBarcode, u as processId, x as OPTIMIZING_WATCHDOG_MARGIN_MS, y as resolveIdCaptureThresholds } from "./idCaptureServices-BRq1TB4U.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-BqPUqWvx.esm.js";
+import { S as getIdCameraStream, _ as ID_ERROR_CODES, a as getRealQualityValue, b as CAPTURE_OPTIMIZING, d as startRecordingSession, f as stopRecording, g as validateUploadResponse, h as uploadManualIdFile, i as finalizeRecordingSession, l as prepareRecordingForCameraRetry, m as uploadIdImage, o as initializeIdCapture, p as stopStream, r as disposeRecordingSession, t as addBarcode, u as processId, x as OPTIMIZING_WATCHDOG_MARGIN_MS, y as resolveIdCaptureThresholds } from "./idCaptureServices-DLL6vNtO.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.esm.js";
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
 const TERMINAL_FAIL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
@@ -1781,7 +1781,7 @@ fromPromise(async ({ input }) => {
 });
 fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-CLFrwfgX.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-DrRcGBbp.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,
@@ -2224,7 +2224,7 @@ function cleanup(service) {
 		service.cleanup();
 	} catch {}
 }
-function createIdMetadataPreparationCoordinator(load = async (input) => (await import("./deepsightLoader-CLFrwfgX.esm.js")).loadDeepsightSession(input)) {
+function createIdMetadataPreparationCoordinator(load = async (input) => (await import("./deepsightLoader-DrRcGBbp.esm.js")).loadDeepsightSession(input)) {
 	let disposed = false;
 	let preparation;
 	let service;

package/dist/{idOcrManager-CFlDwUvN.d.ts → idOcrManager-BF_cXZq8.d.ts}

@@ -110,7 +110,7 @@ declare const idOcrStateMachine: StateMachine<IdOcrContext, {
     type: "shouldProceedWithoutSubmitToSecondId";
     params: unknown;
   };
-}>, never, "error" | "idle" | "success" | "finished" | "loading" | "submitting" | "inputting" | "readonly" | "validatingContinue", string, IdOcrInput, NonReducibleUnknown, EventObject, MetaObject, {
+}>, never, "error" | "idle" | "success" | "finished" | "submitting" | "loading" | "inputting" | "readonly" | "validatingContinue", string, IdOcrInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "idOcr";
   readonly initial: "idle";
   readonly context: ({ input }: {

package/dist/identity-reuse.d.ts

@@ -1,2 +1,2 @@
-import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-D6pD4hcZ.js";
+import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-v2TH5g7e.js";
 export { type FetchDocumentsResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type ReusableDocument, SCAN_NEW_DOCUMENT, type SelectedDocumentId, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/{identityReuseManager-D6pD4hcZ.d.ts → identityReuseManager-v2TH5g7e.d.ts}

@@ -125,7 +125,7 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
     type: "hasSelection";
     params: unknown;
   };
-}>, never, "error" | "idle" | "finished" | "loading" | "submitting" | "documentsFound", string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
+}>, never, "error" | "idle" | "finished" | "submitting" | "loading" | "documentsFound", string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "identityReuse";
   readonly initial: "idle";
   readonly context: ({ input }: {

package/dist/index.esm.js

@@ -1,2 +1,2 @@
-import { i as reset, r as isConfigured, s as setup } from "./setup-ItT0ngv1.esm.js";
+import { i as reset, r as isConfigured, s as setup } from "./setup-CokQ-yUA.esm.js";
 export { isConfigured, reset, setup };

package/dist/mandatory-consent.d.ts

@@ -1,3 +1,3 @@
 import { r as MandatoryConsentConfig } from "./types-9_esGTPj.js";
-import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-CkK0Qzue.js";
+import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-2O5wztkg.js";
 export { type MandatoryConsentActor, type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/{mandatoryConsentManager-CkK0Qzue.d.ts → mandatoryConsentManager-2O5wztkg.d.ts}

@@ -53,6 +53,10 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "setConsent";
     params: NonReducibleUnknown;
   };
+  toggleSigned: {
+    type: "toggleSigned";
+    params: NonReducibleUnknown;
+  };
   setError: {
     type: "setError";
     params: NonReducibleUnknown;
@@ -65,14 +69,10 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "resetContext";
     params: NonReducibleUnknown;
   };
-  toggleSigned: {
-    type: "toggleSigned";
-    params: NonReducibleUnknown;
-  };
 }>, {
   type: "canSubmit";
   params: unknown;
-}, never, "error" | "idle" | "closed" | "finished" | "loading" | "submitting" | "display", string, MandatoryConsentInput, NonReducibleUnknown, EventObject, MetaObject, {
+}, never, "error" | "idle" | "closed" | "finished" | "submitting" | "loading" | "display", string, MandatoryConsentInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "mandatoryConsent";
   readonly initial: "idle";
   readonly context: ({ input }: {

package/dist/{multipartRecordingService-B3C_zlev.esm.js → multipartRecordingService-CWxZ5mTi.esm.js}

@@ -1,7 +1,7 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
-import { a as isIOS } from "./platform-DkcRc9JV.esm.js";
+import { a as isIOS, t as isAndroid } from "./platform-DkcRc9JV.esm.js";
 //#region ../infra/src/media/mediaRecorderOptions.ts
 /**
 * Picks a `MediaRecorder` mime type the current browser actually supports.
@@ -19,6 +19,17 @@ function getSupportedMediaRecorderMimeType() {
 	return "";
 }
 /**
+* Mime type for the multipart (video-selfie-service) recorder. Android
+* Chromium gets hardware H.264 in fragmented MP4 first — the fragment shape
+* the service already ingests from Safari. Measured on a Galaxy S21 under ID
+* detection load (ENG-55397): 720p VP8 dropped 16% of frames, H.264 dropped
+* none. Everything else keeps the WebM-first order.
+*/
+function getMultipartRecorderMimeType() {
+	if (isAndroid() && MediaRecorder.isTypeSupported("video/mp4;codecs=avc1")) return "video/mp4;codecs=avc1";
+	return getSupportedMediaRecorderMimeType();
+}
+/**
 * `MediaRecorder` options tuned per platform — a higher bitrate on iOS, lower
 * elsewhere — paired with the supported mime type.
 */
@@ -89,7 +100,7 @@ var MultipartRecordingProvider = class {
 		this.partNumber = 0;
 		this.onPart = onPart;
 		try {
-			this.mimeType = getSupportedMediaRecorderMimeType();
+			this.mimeType = getMultipartRecorderMimeType();
 			const recorder = new MediaRecorder(stream.clone(), {
 				mimeType: this.mimeType,
 				videoBitsPerSecond: VIDEO_BITS_PER_SECOND

package/dist/personhood.esm.js

@@ -1,16 +1,16 @@
-import { l as BrowserStorageProvider } from "./setup-ItT0ngv1.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CokQ-yUA.esm.js";
 import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-Cmein6eU.esm.js";
+import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-D03Z4v0r.esm.js";
 import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
-import { b as BrowserEnvironmentProvider, h as isBrowserSimulation, n as getFingerprintEnabled, v as getThumbmarkId, y as getDeviceFingerprintInfo } from "./sessionInitializer-HuJ4OYs0.esm.js";
+import { b as BrowserEnvironmentProvider, h as isBrowserSimulation, n as getFingerprintEnabled, v as getThumbmarkId, y as getDeviceFingerprintInfo } from "./sessionInitializer-CX84J4ZG.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { i as requestCameraAccess, o as stopCameraStream } from "./camera-sIa9ceW2.esm.js";
 import { i as requestPermission, t as checkPermission } from "./permissionServices-Bj_fyWtv.esm.js";
-import { i as initializeDeepsightSession, l as stopStream, o as startDetection, t as FaceDetectionProvider } from "./FaceDetectionProvider-Dz_zxzth.esm.js";
+import { i as initializeDeepsightSession, l as stopStream, o as startDetection, t as FaceDetectionProvider } from "./FaceDetectionProvider-CWujhVWD.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.esm.js";
 //#region src/modules/personhood/personhoodServices.ts

package/dist/qe-signature.esm.js

@@ -1,4 +1,4 @@
-import { a as NAMIRIAL_QES_CONSENT_KEYS, c as areAllConsented, o as NAMIRIAL_QES_PROVIDER_CODE, r as electronicSignatureMachine, s as QE_CONSENT_KEYS, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-B85WICzC.esm.js";
+import { a as NAMIRIAL_QES_CONSENT_KEYS, c as areAllConsented, o as NAMIRIAL_QES_PROVIDER_CODE, r as electronicSignatureMachine, s as QE_CONSENT_KEYS, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-BGtmVYnW.esm.js";
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/{runChildModule-0wMdwznt.esm.js → runChildModule-BOJWRUG7.esm.js}

@@ -1,5 +1,5 @@
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-Cmein6eU.esm.js";
+import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-D03Z4v0r.esm.js";
 import { C as createEventBus } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";

package/dist/{sdkVersion-CIExIk-y.esm.js → sdkVersion-BpWCQ-V3.esm.js}

@@ -1,4 +1,4 @@
 //#region src/internal/version/sdkVersion.ts
-const SDK_VERSION = "0.0.0-dev-20260914-656e6757";
+const SDK_VERSION = "0.0.0-dev-20260915-1e83a656";
 //#endregion
 export { SDK_VERSION as t };

package/dist/selfie.esm.js

@@ -1,14 +1,14 @@
-import { l as BrowserStorageProvider } from "./setup-ItT0ngv1.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CokQ-yUA.esm.js";
 import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
 import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-BlUhLA18.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-CbIMYS4-.esm.js";
+import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-BuI9bUDW.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-jOdgsEsg.esm.js";
 import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-DQ5-F2oW.esm.js";
 import { r as processFace } from "./selfieErrorUtils-C77GXJH6.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-CnrxNcRk.esm.js";
-import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-BVK8Yo__.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-B1Ni3iDU.esm.js";
+import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-gOb5R-nd.esm.js";
 import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-BjzPjJ_p.esm.js";
 /**
 * Selfie state machine variant for the captureOnly flow. Shares the full base