@incodetech/core 2.3.0-rc.2 → 2.3.0-rc.3

package/dist/{multipartRecordingService-OEgIRvqC.esm.js → multipartRecordingService-CuXLH4tK.esm.js}

@@ -47,6 +47,451 @@ function getAdaptiveMediaRecorderOptions() {
 	};
 }
 //#endregion
+//#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 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.
+*/
+var CameraCompositor = class {
+	constructor(options = {}) {
+		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;
+		this.videoTrack = null;
+		this.composite = null;
+		this.fps = options.fps ?? 30;
+		this.frameIntervalMs = this.fps > 0 ? 1e3 / this.fps : 0;
+		this.resumeTimeoutMs = options.resumeTimeoutMs ?? DEFAULT_RESUME_TIMEOUT_MS;
+	}
+	/**
+	* Begin compositing `stream` and return the composite stream to record. The
+	* stream's audio track (if any) is carried through unchanged across later
+	* `switchVideo` calls.
+	*/
+	start(stream) {
+		this.audioTrack = stream.getAudioTracks()[0] ?? null;
+		const composite = this.startWorkerTransport(stream) ?? this.startMainThread(stream);
+		if (this.audioTrack) composite.addTrack(this.audioTrack);
+		this.composite = composite;
+		return 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;
+		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. */
+	get stream() {
+		return this.composite ?? void 0;
+	}
+	/** 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 reach
+	* the stable composite stream. The caller must not resume encoding until
+	* this resolves with `resumed`.
+	*/
+	async resume(signal) {
+		const video = this.video;
+		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";
+		if (video && !this.transport) {
+			try {
+				await video.play();
+			} catch {
+				return "timed-out";
+			}
+			if (signal?.aborted) return "timed-out";
+		}
+		this.finishResume("timed-out");
+		return new Promise((resolve) => {
+			const timeout = setTimeout(() => {
+				this.finishResume("timed-out");
+			}, this.resumeTimeoutMs);
+			if (signal) {
+				const onAbort = () => this.finishResume("timed-out");
+				this.resumeWaiter = {
+					resolve,
+					timeout,
+					signal,
+					onAbort
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				if (signal.aborted) {
+					this.finishResume("timed-out");
+					return;
+				}
+			} else this.resumeWaiter = {
+				resolve,
+				timeout
+			};
+			if (this.transport) {
+				this.postToWorker({ type: "resume" });
+				return;
+			}
+			this.startDrawLoop(false);
+		});
+	}
+	/** 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());
+		if (this.video) this.video.srcObject = null;
+		this.canvas = null;
+		this.ctx = null;
+		this.video = null;
+		this.videoTrack = null;
+		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());
+		video.play().catch(() => {});
+	}
+	startDrawLoop(resetSourceTime = true) {
+		this.cancelDrawLoop();
+		this.lastDrawTimeMs = null;
+		if (resetSourceTime) this.lastVideoTimeSeconds = null;
+		const draw = (timeMs) => {
+			const elapsed = this.lastDrawTimeMs === null ? Infinity : timeMs - this.lastDrawTimeMs;
+			if ((!(this.frameIntervalMs > 0 && (this.frameRequestKind !== "video" || this.sourceExceedsTargetFps)) || elapsed >= this.frameIntervalMs * FRAME_INTERVAL_TOLERANCE_RATIO) && this.drawCurrentFrame()) {
+				this.lastDrawTimeMs = timeMs;
+				this.finishResume("resumed");
+			}
+			this.scheduleNextFrame(draw);
+		};
+		this.scheduleNextFrame(draw);
+	}
+	finishResume(result) {
+		const waiter = this.resumeWaiter;
+		if (!waiter) return;
+		this.resumeWaiter = void 0;
+		clearTimeout(waiter.timeout);
+		if ("signal" in waiter) waiter.signal.removeEventListener("abort", waiter.onAbort);
+		waiter.resolve(result);
+	}
+	scheduleNextFrame(callback) {
+		const video = this.video;
+		if (video && typeof video.requestVideoFrameCallback === "function") {
+			this.frameRequestKind = "video";
+			this.frameRequestId = video.requestVideoFrameCallback(callback);
+			return;
+		}
+		this.frameRequestKind = "animation";
+		this.frameRequestId = requestAnimationFrame(callback);
+	}
+	cancelDrawLoop() {
+		if (this.frameRequestId === null) return;
+		if (this.frameRequestKind === "video" && this.video && typeof this.video.cancelVideoFrameCallback === "function") this.video.cancelVideoFrameCallback(this.frameRequestId);
+		else cancelAnimationFrame(this.frameRequestId);
+		this.frameRequestId = null;
+		this.frameRequestKind = null;
+	}
+	drawCurrentFrame() {
+		const video = this.video;
+		const canvas = this.canvas;
+		const ctx = this.ctx;
+		if (!video || !canvas || !ctx || video.videoWidth <= 0) return false;
+		if (this.lastVideoTimeSeconds === video.currentTime) return false;
+		const dimensions = this.getBoundedDimensions(video.videoWidth, video.videoHeight);
+		if (canvas.width !== dimensions.width || canvas.height !== dimensions.height) {
+			canvas.width = dimensions.width;
+			canvas.height = dimensions.height;
+		}
+		ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+		this.lastVideoTimeSeconds = video.currentTime;
+		return true;
+	}
+	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);
+		return {
+			width: Math.max(1, Math.round(width * scale)),
+			height: Math.max(1, Math.round(height * scale))
+		};
+	}
+};
+//#endregion
 //#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
 /**
 * How often `MediaRecorder` hands us buffered data (incremental blobs).
@@ -602,4 +1047,4 @@ var MultipartRecordingService = class {
 	}
 };
 //#endregion
-export { getAdaptiveMediaRecorderOptions as n, MultipartRecordingService as t };
+export { CameraCompositor as n, getAdaptiveMediaRecorderOptions as r, MultipartRecordingService as t };

package/dist/personhood.esm.js

@@ -1,16 +1,16 @@
-import { l as BrowserStorageProvider } from "./setup-6e71xCI7.esm.js";
+import { l as BrowserStorageProvider } from "./setup-B-qr0dC6.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-DJ1kSDlH.esm.js";
+import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-De306VXK.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-C1A6s33W.esm.js";
+import { b as BrowserEnvironmentProvider, h as isBrowserSimulation, n as getFingerprintEnabled, v as getThumbmarkId, y as getDeviceFingerprintInfo } from "./sessionInitializer-DKCQfxZ2.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.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, o as startDetection, s as stopStream, t as FaceDetectionProvider } from "./FaceDetectionProvider-i55W_Jkj.esm.js";
+import { i as initializeDeepsightSession, o as startDetection, s as stopStream, t as FaceDetectionProvider } from "./FaceDetectionProvider-DAVK6BAe.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-8VGN2aKU.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-Bc8MLmTL.esm.js";
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/{runChildModule-CT0aKjFV.esm.js → runChildModule-CTeh8a1T.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-DJ1kSDlH.esm.js";
+import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-De306VXK.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-DTrl2Jm7.esm.js → sdkVersion-DYlnESxD.esm.js}

@@ -1,4 +1,4 @@
 //#region src/internal/version/sdkVersion.ts
-const SDK_VERSION = "2.3.0-rc.2+aecc086";
+const SDK_VERSION = "2.3.0-rc.3+bd43d20";
 //#endregion
 export { SDK_VERSION as t };

package/dist/selfie.d.ts

@@ -1,10 +1,10 @@
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { _ as SelfieCaptureOnlyConfig, a as SelfieCaptureOnlyMachine, c as SelfieActor, g as processFace, h as ProcessFaceResponse, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine, v as SelfieConfig } from "./faceCaptureManagerFactory-BeUl8fl1.js";
+import { _ as SelfieCaptureOnlyConfig, a as SelfieCaptureOnlyMachine, c as SelfieActor, g as processFace, h as ProcessFaceResponse, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine, v as SelfieConfig } from "./faceCaptureManagerFactory-Cx-8SqRy.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
 import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode } from "./types-Bnl58jUQ.js";
 import { n as DeepsightService } from "./StreamCanvasCapture-_8gdW5Lk.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { i as createSelfieManagerFromActor, n as SelfieState, r as createSelfieManager, t as SelfieManager } from "./selfieManager-4RRLi21P.js";
+import { i as createSelfieManagerFromActor, n as SelfieState, r as createSelfieManager, t as SelfieManager } from "./selfieManager-jXqwqosi.js";
 //#region src/modules/selfie/selfieCaptureOnlyManager.d.ts
 type SelfieCaptureOnlyState = FaceCaptureManagerState;
 type SelfieCaptureOnlyManager = FaceCaptureManager;

package/dist/selfie.esm.js

@@ -1,14 +1,14 @@
-import { l as BrowserStorageProvider } from "./setup-6e71xCI7.esm.js";
+import { l as BrowserStorageProvider } from "./setup-B-qr0dC6.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-CDGmqC8J.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Bl6EffXD.esm.js";
+import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-DpM1YYl9.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-qPW__uXd.esm.js";
 import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-CX3hJGKc.esm.js";
 import { r as processFace } from "./selfieErrorUtils-UiQ46EBa.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-rfneTd9x.esm.js";
-import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-0gvnAH1m.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-BJVwANex.esm.js";
+import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-CFGf-DmP.esm.js";
 import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-BjzPjJ_p.esm.js";
 /**
 * Selfie state machine variant for the captureOnly flow. Shares the full base

package/dist/{selfieManager-0gvnAH1m.esm.js → selfieManager-CFGf-DmP.esm.js}

@@ -1,9 +1,9 @@
-import { l as BrowserStorageProvider } from "./setup-6e71xCI7.esm.js";
+import { l as BrowserStorageProvider } from "./setup-B-qr0dC6.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 { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Bl6EffXD.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-rfneTd9x.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-qPW__uXd.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-BJVwANex.esm.js";
 //#region src/modules/selfie/selfieActor.ts
 function createSelfieActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{selfieManager-4RRLi21P.d.ts → selfieManager-jXqwqosi.d.ts}

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { c as SelfieActor, n as FaceCaptureManagerState, s as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-BeUl8fl1.js";
+import { c as SelfieActor, n as FaceCaptureManagerState, s as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-Cx-8SqRy.js";
 //#region src/modules/selfie/selfieManager.d.ts
 type SelfieState = FaceCaptureManagerState;
 /**

package/dist/{selfieStateMachine-rfneTd9x.esm.js → selfieStateMachine-BJVwANex.esm.js}

@@ -1,7 +1,7 @@
 import { i as assign } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as createDefaultProtectedFaceControllerActor, r as manualFaceUploadMachine, t as faceCaptureMachine } from "./faceCaptureSetup-CDGmqC8J.esm.js";
-import { c as isOnDeviceMode } from "./FaceDetectionProvider-i55W_Jkj.esm.js";
+import { n as createDefaultProtectedFaceControllerActor, r as manualFaceUploadMachine, t as faceCaptureMachine } from "./faceCaptureSetup-DpM1YYl9.esm.js";
+import { c as isOnDeviceMode } from "./FaceDetectionProvider-DAVK6BAe.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-CX3hJGKc.esm.js";
 import { i as uploadManualSelfie, n as validateUploadResponse, r as processFace } from "./selfieErrorUtils-UiQ46EBa.esm.js";

package/dist/{session-ZAdron5D.esm.js → session-Cs6z9Stj.esm.js}

@@ -1,8 +1,8 @@
 import { n as getApi } from "./api-Bx3gKW_y.esm.js";
-import { g as noteSessionCreated, l as trueSightLog } from "./trueSightService-DJ1kSDlH.esm.js";
-import "./sessionInitializer-C1A6s33W.esm.js";
+import { g as noteSessionCreated, l as trueSightLog } from "./trueSightService-De306VXK.esm.js";
+import "./sessionInitializer-DKCQfxZ2.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { i as toIncodeApiError } from "./apiError-DcnaKSwk.esm.js";
+import { i as toIncodeApiError } from "./apiError-BArJSmSN.esm.js";
 //#region src/internal/session/sessionService.ts
 /**
 * HTTP status codes the QR validation endpoint emits, keyed by their semantic

package/dist/session.esm.js

@@ -1,5 +1,5 @@
-import { i as initializeSession, l as whenSessionFingerprintSettled } from "./sessionInitializer-C1A6s33W.esm.js";
-import { t as IncodeApiError } from "./apiError-DcnaKSwk.esm.js";
-import { a as refreshQrUrlUuid, i as createSession, n as QrValidationError, o as validateQrUuid, r as bootstrapSession, t as QR_VALIDATION_ERROR_CODES } from "./session-ZAdron5D.esm.js";
-import { n as getFinishStatus } from "./flowCompletionService-CayNS1FR.esm.js";
+import { i as initializeSession, l as whenSessionFingerprintSettled } from "./sessionInitializer-DKCQfxZ2.esm.js";
+import { t as IncodeApiError } from "./apiError-BArJSmSN.esm.js";
+import { a as refreshQrUrlUuid, i as createSession, n as QrValidationError, o as validateQrUuid, r as bootstrapSession, t as QR_VALIDATION_ERROR_CODES } from "./session-Cs6z9Stj.esm.js";
+import { n as getFinishStatus } from "./flowCompletionService-D0qKFy5Y.esm.js";
 export { IncodeApiError, QR_VALIDATION_ERROR_CODES, QrValidationError, bootstrapSession, createSession, getFinishStatus, initializeSession, refreshQrUrlUuid, validateQrUuid, whenSessionFingerprintSettled };

package/dist/{sessionInitializer-C1A6s33W.esm.js → sessionInitializer-DKCQfxZ2.esm.js}

@@ -1,8 +1,8 @@
-import { E as updateFeatureManagementUser } from "./feature-management-J3rr-HDW.esm.js";
+import { E as updateFeatureManagementUser } from "./feature-management-Bzr9uaS4.esm.js";
 import { c as setToken, r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { d as fetchFeatureConfig, f as isFeatureEnabled, h as noteEnvironment, l as trueSightLog, p as resetFeatureConfigCache, s as startTrueSightCollection, v as noteTokenActivated } from "./trueSightService-DJ1kSDlH.esm.js";
+import { d as fetchFeatureConfig, f as isFeatureEnabled, h as noteEnvironment, l as trueSightLog, p as resetFeatureConfigCache, s as startTrueSightCollection, v as noteTokenActivated } from "./trueSightService-De306VXK.esm.js";
 import { v as addEvent, y as getAnalyticsBatcher } from "./events-ijlbX_Wx.esm.js";
-import { t as SDK_VERSION } from "./sdkVersion-DTrl2Jm7.esm.js";
+import { t as SDK_VERSION } from "./sdkVersion-DYlnESxD.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue } from "./stats-CZcy2J53.esm.js";
 import { t as getParsedUserAgent } from "./getParsedUserAgent-B2iFDql1.esm.js";

package/dist/{setup-6e71xCI7.esm.js → setup-B-qr0dC6.esm.js}

@@ -2,16 +2,16 @@ import { f as deriveSiblingJsPath, p as WASM_MODEL_FILES, v as buildModelVariant
 import { i as setWasmOnDeviceMode, o as warmupWasm } from "./warmup-CUUnwYxe.esm.js";
 import { r as WasmUtilProvider, t as resolveLocalStorage } from "./safeStorage-B-trhxg6.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { C as resetFeatureManagement, D as applyEnvironment, O as getEnvironment, S as optOutFeatureManagement, b as initializeFeatureManagement, c as resetResolvedExperiments, k as resetEnvironment, v as getIsFeatureManagementLocked, w as resetFeatureManagementProviderInstance } from "./feature-management-J3rr-HDW.esm.js";
+import { C as resetFeatureManagement, D as applyEnvironment, O as getEnvironment, S as optOutFeatureManagement, b as initializeFeatureManagement, c as resetResolvedExperiments, k as resetEnvironment, v as getIsFeatureManagementLocked, w as resetFeatureManagementProviderInstance } from "./feature-management-Bzr9uaS4.esm.js";
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { a as resetApi, i as isApiConfigured, n as getApi, r as getToken, s as setHttpRequestObserver, t as api } from "./api-Bx3gKW_y.esm.js";
-import { C as upgradeToWasmHttpClient$1, S as resetHttpClientState, _ as noteTestingSignals, b as getStoredHttpConfig, l as trueSightLog, n as initializeTrueSightDiagnostics, o as resetTrueSight, t as finalizeTrueSight, u as categoryForEndpoint, x as installFreshHttpClient } from "./trueSightService-DJ1kSDlH.esm.js";
+import { C as upgradeToWasmHttpClient$1, S as resetHttpClientState, _ as noteTestingSignals, b as getStoredHttpConfig, l as trueSightLog, n as initializeTrueSightDiagnostics, o as resetTrueSight, t as finalizeTrueSight, u as categoryForEndpoint, x as installFreshHttpClient } from "./trueSightService-De306VXK.esm.js";
 import { b as resetAnalyticsBatcher, c as resetExperimentAssignments, x as setAnalyticsBatcher, y as getAnalyticsBatcher } from "./events-ijlbX_Wx.esm.js";
-import { a as resetSessionInit, b as BrowserEnvironmentProvider, c as setClientIpLookupEnabled, d as registerFlowPreloader, f as resetStandaloneFlowPolicy, i as initializeSession, m as setStandaloneFlowPolicy, o as setClientFingerprintEnabled, p as resolveStandaloneFlowPolicy, s as setClientHostingApp } from "./sessionInitializer-C1A6s33W.esm.js";
+import { a as resetSessionInit, b as BrowserEnvironmentProvider, c as setClientIpLookupEnabled, d as registerFlowPreloader, f as resetStandaloneFlowPolicy, i as initializeSession, m as setStandaloneFlowPolicy, o as setClientFingerprintEnabled, p as resolveStandaloneFlowPolicy, s as setClientHostingApp } from "./sessionInitializer-DKCQfxZ2.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-CZcy2J53.esm.js";
 import { a as resetTRI, n as initializeTRI, o as resetTRIProviderInstance } from "./tri-4RsGrIt6.esm.js";
-import { i as resetDashboardFlowCache, r as preloadDashboardFlow } from "./flowServices-DX5ygAyn.esm.js";
+import { i as resetDashboardFlowCache, r as preloadDashboardFlow } from "./flowServices-CnyFU9Bz.esm.js";
 //#region ../infra/src/wasm/wasmDefaults.ts
 const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
 /** The WASM version bundled and tested with this SDK release. */

package/dist/{trueSightService-DJ1kSDlH.esm.js → trueSightService-De306VXK.esm.js}

@@ -2,7 +2,7 @@ import { a as setWebApiHttpTransport, i as initializeWasmWebClient, o as setupWa
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { i as isApiConfigured, n as getApi, o as setClient, r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
 import { S as subscribeEvent, n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
-import { t as SDK_VERSION } from "./sdkVersion-DTrl2Jm7.esm.js";
+import { t as SDK_VERSION } from "./sdkVersion-DYlnESxD.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 //#region ../infra/src/http/createApi.ts
 var FetchHttpError = class extends Error {
@@ -336,7 +336,7 @@ const createWasmApi = async (config) => {
 			const upperMethod = normalizeMethod(method);
 			const requestParams = params ?? query;
 			const fullUrl = buildUrl(defaults.baseURL, url, requestParams);
-			const needsSchemeHeader = ie || useSha256 && isEncryptionEnabled();
+			const needsSchemeHeader = useSha256 && isEncryptionEnabled();
 			const mergedHeaders = {
 				...defaults.headers,
 				...needsSchemeHeader ? { "X-RSA-Encryption-Scheme": RSA_OAEP_SHA256_SCHEME } : {},
@@ -1320,7 +1320,7 @@ let cryptoProviderPromise = null;
 * the service's prewarm).
 */
 function loadDiagnosticsCryptoProvider() {
-	cryptoProviderPromise ??= import("./BrowserDiagnosticsCryptoProvider-Crg8fwBl.esm.js").then((module) => new module.BrowserDiagnosticsCryptoProvider());
+	cryptoProviderPromise ??= import("./BrowserDiagnosticsCryptoProvider-C2E4mGEX.esm.js").then((module) => new module.BrowserDiagnosticsCryptoProvider());
 	return cryptoProviderPromise;
 }
 /**