@incodetech/core 0.0.0-dev-20260911-aec162f0 → 0.0.0-dev-20260914-8aef7789

package/dist/{faceCaptureSetup-CAGBnLVx.esm.js → faceCaptureSetup-WeO8-TfR.esm.js}

@@ -1,15 +1,20 @@
+import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { r as getToken } from "./api-Bx3gKW_y.esm.js";
+import { l as trueSightLog, m as isTrueSightTesting } from "./trueSightService-TqmmYye3.esm.js";
+import "./sessionInitializer-CUpgbHzs.esm.js";
+import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
 import { t as isAndroid } from "./platform-DkcRc9JV.esm.js";
-import { i as assign, r as sendTo, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
+import { i as assign, n as enqueueActions, 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 invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-f7nBnW5P.esm.js";
-import { c as sendLabelInspectionEvent, d as stopRecording, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession, u as startRecordingSession } from "./onDeviceFaceResults-hle2Ci9l.esm.js";
-import { i as uploadDeepsightVideo } from "./recordingsRepository-CCWy13M-.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-7lzEiOsO.esm.js";
+import { a as sendLabelInspectionEvent, c as stopRecording, i as initializeDeepsightSession, l as stopStream, r as initializeCamera, s as startRecordingSession, t as FaceDetectionProvider } from "./FaceDetectionProvider-0bWjPgW5.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { n as releaseFaceAvatarWarmup, r as warmFaceAvatar, t as createFaceAvatar } from "./createFaceAvatar-DQKaRise.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-DxbvOoZJ.esm.js";
-import { n as flagFaceManualReview, t as imageFileToDataUrl } from "./imageFile-CLaua6xO.esm.js";
+import { a as flagFaceManualReview, i as imageFileToDataUrl, n as runProtectedAttempt, r as cameraCycleProvider, s as PROTECTED_CAPTURE_TARGET, t as createCameraCycleOwnership } from "./createCameraCycleOwnership-DQ5-F2oW.esm.js";
+import { n as releaseFaceAvatarWarmup, r as warmFaceAvatar, t as createFaceAvatar } from "./createFaceAvatar-BNHdeFj8.esm.js";
+import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-o1JLtewE.esm.js";
+import { i as uploadDeepsightVideo } from "./recordingsRepository-CCWy13M-.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
 import { n as getAdaptiveMediaRecorderOptions, t as MultipartRecordingService } from "./multipartRecordingService-B3C_zlev.esm.js";
 //#region src/internal/avatar/concealment.ts
 /**
@@ -269,6 +274,31 @@ const manualFaceUploadMachine = setup({
 	}
 });
 //#endregion
+//#region ../infra/src/providers/wasm/createProtectedFaceCaptureCapabilities.ts
+/**
+* Infrastructure composition boundary for one protected still-face attempt.
+* Core receives capability interfaces and never constructs or reaches for the
+* process-wide WASM providers directly.
+*/
+function createProtectedFaceCaptureCapabilities() {
+	return {
+		cycle: cameraCycleProvider,
+		faceDetection: new FaceDetectionProvider()
+	};
+}
+//#endregion
+//#region src/internal/faceCapture/faceCaptureDiagnostics.ts
+const FACE_CAMERA_DIAGNOSTIC_PREFIX = "[Incode face camera]";
+/**
+* Emits one bounded lifecycle line only for SDK testing sessions. The payload
+* deliberately excludes media, native results, tokens, request data, and
+* errors so a browser console recording cannot retain capture data.
+*/
+function logFaceCameraDiagnostic(event, fields) {
+	if (!isTrueSightTesting()) return;
+	console.debug(`${FACE_CAMERA_DIAGNOSTIC_PREFIX} ${event} ${JSON.stringify(fields)}`);
+}
+//#endregion
 //#region ../infra/src/media/VideoTrimmer.ts
 async function getDurationBySeek(videoBlob) {
 	const video = document.createElement("video");
@@ -555,6 +585,12 @@ var MultipartFaceRecordingService = class {
 		}
 		return { recordingId: null };
 	}
+	pauseForBackground() {
+		this.service.pause();
+	}
+	async resumeFromBackground() {
+		this.service.resume();
+	}
 	async stopAndGetVideo() {
 		try {
 			await this.service.stop();
@@ -619,14 +655,671 @@ var InjectedRecordingService = class {
 */
 function createRecordingService(params) {
 	if (params.config.onDeviceFaceResultsSubmissionEnabled === true) return;
+	if (params.localDelivery === true) return params.config.enableFaceRecording === true || params.config.deepsightLiveness === "VIDEOLIVENESS" ? new LocalRecordingService(params.wasmUtil, null) : void 0;
 	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
 	if (params.config.enableFaceRecording === true) return params.config.recording?.capability ? new InjectedRecordingService(params.config) : new MultipartFaceRecordingService();
 }
 //#endregion
+//#region src/internal/faceCapture/protectedFaceAttempt.ts
+const ON_DEVICE_MANUAL_CAPTURE_TIMEOUT_MS = 2147483647;
+var ProtectedFaceRecorderHooks = class {
+	constructor(config, dependencies, delivery) {
+		this.config = config;
+		this.dependencies = dependencies;
+		this.delivery = delivery;
+		this.mode = config.onDeviceFaceResultsSubmissionEnabled === true || config.enableFaceRecording !== true && config.deepsightLiveness !== "VIDEOLIVENESS" ? "none" : "finalizeBeforePoc";
+	}
+	async start(unprotectedStream) {
+		if (this.mode === "none") return;
+		const wasmUtil = await this.dependencies.getWasmUtil();
+		this.service = createRecordingService({
+			config: this.config,
+			wasmUtil,
+			sessionToken: getToken(),
+			localDelivery: this.delivery === "local"
+		});
+		await this.service?.start(unprotectedStream);
+	}
+	async prepareForPoc() {
+		if (!this.service) return {};
+		if (this.delivery === "local") {
+			try {
+				const result = await this.service.stopAndGetVideo();
+				this.captureOnlyVideoBase64 = result.videoBase64;
+			} catch {
+				this.captureOnlyVideoBase64 = void 0;
+			}
+			return {};
+		}
+		return this.service.stop();
+	}
+	async resumeAfterPoc() {}
+	pauseForBackground() {
+		this.service?.pauseForBackground?.();
+	}
+	async resumeFromBackground(unprotectedStream) {
+		await this.service?.resumeFromBackground?.(unprotectedStream);
+	}
+	dispose() {
+		try {
+			this.service?.cleanup();
+		} finally {
+			this.service = void 0;
+		}
+	}
+	takeCaptureOnlyVideo() {
+		const video = this.captureOnlyVideoBase64;
+		this.captureOnlyVideoBase64 = void 0;
+		return video;
+	}
+};
+let nextAttemptNumber = 1;
+/**
+* Private composition object for one still-face attempt. It owns provider
+* callbacks and raw-stream handoff outside XState; the machine sees only the
+* presentation stream/canvas and allowlisted semantic results.
+*/
+var ProtectedFaceAttemptRuntime = class ProtectedFaceAttemptRuntime {
+	constructor(options) {
+		this.options = options;
+		this.attemptId = `face-${nextAttemptNumber++}`;
+		this.acquiredUsingBackCamera = false;
+		this.rawHandedOff = false;
+		this.rawStreamReleased = false;
+		this.released = false;
+		this.recorderTransferred = false;
+		this.pendingSignals = [];
+		this.provider = options.faceDetection;
+		this.recorder = new ProtectedFaceRecorderHooks(options.config, options.dependencies, options.delivery);
+		this.cycleOwnership = createCameraCycleOwnership(options.cycle);
+	}
+	get delivery() {
+		return this.options.delivery;
+	}
+	get usingBackCamera() {
+		return this.acquiredUsingBackCamera;
+	}
+	setDeepsightService(service) {
+		if (this.released || this.deepsightService) return;
+		this.deepsightService = service;
+	}
+	async preAcquire() {
+		await this.acquireRawStream();
+	}
+	subscribeSignals(listener) {
+		if (this.released) return () => void 0;
+		this.signalListener = listener;
+		const queued = this.pendingSignals;
+		this.pendingSignals = [];
+		queued.forEach(listener);
+		return () => {
+			if (this.signalListener === listener) this.signalListener = void 0;
+		};
+	}
+	toActorInput(onStartupTiming) {
+		this.recorderTransferred = true;
+		return {
+			attemptId: this.attemptId,
+			target: this.options.target,
+			workflow: this.options.config.onDeviceFaceResultsSubmissionEnabled === true ? 5 : 4,
+			streamSource: {
+				kind: "acquire",
+				acquire: async () => {
+					const result = await this.acquireRawStream();
+					this.rawHandedOff = true;
+					return {
+						stream: result.stream,
+						constraints: result.constraints
+					};
+				}
+			},
+			cycle: this.options.cycle,
+			cycleOwnership: this.cycleOwnership,
+			recorder: this.recorder,
+			releaseUnadoptedStream: (stream) => stopStream(stream),
+			configureWorkflow: () => this.configureWorkflow(),
+			runPrc: () => this.runPrc(),
+			runPoc: () => this.runPoc(),
+			onStartupTiming,
+			faceResults: this.provider
+		};
+	}
+	createUploadCommand(recordingId) {
+		const token = getToken();
+		const config = {
+			headers: token ? { "X-Incode-Hardware-Id": token } : void 0,
+			timeout: 3e4
+		};
+		if (this.options.config.onDeviceFaceResultsSubmissionEnabled === true) return {
+			type: "UPLOAD_FACE_RESULTS",
+			config
+		};
+		const validRecordingId = recordingId && recordingId.trim().length > 0 ? recordingId : void 0;
+		if (this.options.target === PROTECTED_CAPTURE_TARGET.authentication) return {
+			type: "UPLOAD_PROTECTED",
+			request: {
+				target: PROTECTED_CAPTURE_TARGET.authentication,
+				extras: {
+					deviceClass: getDeviceClass(),
+					hint: this.options.authHint,
+					...validRecordingId ? { recordingId: validRecordingId } : {}
+				},
+				config
+			}
+		};
+		return {
+			type: "UPLOAD_PROTECTED",
+			request: {
+				target: PROTECTED_CAPTURE_TARGET.selfie,
+				extras: { deviceClass: getDeviceClass() },
+				config: {
+					...config,
+					params: {
+						imageType: "selfie",
+						...validRecordingId ? { recordingId: validRecordingId } : {}
+					}
+				}
+			}
+		};
+	}
+	mapProtectedResult(result) {
+		if (result.kind === "onDeviceFace") return {};
+		if (result.kind === "authentication") return {
+			overallStatus: result.overallStatus,
+			captureAttemptsLimit: {
+				max: this.options.config.captureAttempts ?? this.options.config.numberOfAttempts ?? 3,
+				remaining: result.attemptsRemaining ?? 0
+			},
+			candidate: "",
+			error: {
+				name: result.errorName ?? "",
+				message: result.errorName ?? ""
+			}
+		};
+		return result;
+	}
+	takeCaptureOnlyVideo() {
+		return this.recorder.takeCaptureOnlyVideo();
+	}
+	next() {
+		return new ProtectedFaceAttemptRuntime(this.options);
+	}
+	release() {
+		if (this.released) return;
+		this.released = true;
+		this.signalListener = void 0;
+		this.pendingSignals = [];
+		if (!this.recorderTransferred) try {
+			this.recorder.dispose();
+		} catch {}
+		try {
+			Promise.resolve(this.provider.dispose()).catch(() => void 0);
+		} catch {}
+		this.cycleOwnership.releaseByController();
+		if (!this.rawHandedOff) this.acquired?.then(({ stream }) => this.releaseRawStream(stream), () => void 0);
+	}
+	async acquireRawStream() {
+		if (!this.acquired) this.acquired = this.options.acquireCamera(this.provider);
+		const result = await this.acquired;
+		this.acquiredUsingBackCamera = result.usingBackCamera;
+		if (this.released) {
+			this.releaseRawStream(result.stream);
+			throw new Error("Protected face attempt was released");
+		}
+		return result;
+	}
+	async configureWorkflow() {
+		await this.provider.initialize({
+			autocaptureInterval: this.options.config.onDeviceFaceResultsSubmissionEnabled === true ? ON_DEVICE_MANUAL_CAPTURE_TIMEOUT_MS : this.options.config.autoCaptureTimeout * 1e3,
+			useOnDeviceWorkflow: this.options.config.onDeviceFaceResultsSubmissionEnabled === true
+		});
+		if (this.released) return;
+		this.provider.setChecksEnabled({
+			lenses: this.options.config.validateLenses ?? false,
+			mask: this.options.config.validateFaceMask ?? false,
+			closedEyes: this.options.config.validateClosedEyes ?? false,
+			headWear: this.options.config.validateHeadCover ?? false,
+			occlusion: false
+		});
+		this.provider.setCallbacks({
+			onFarAway: () => this.emitDetection("tooFar"),
+			onTooClose: () => this.emitDetection("tooClose"),
+			onTooManyFaces: () => this.emitDetection("tooManyFaces"),
+			onNoFace: () => this.emitDetection("idle"),
+			onCenterFace: () => this.emitDetection("centerFace"),
+			onGetReady: () => this.emitDetection("getReady"),
+			onGetReadyFinished: () => this.emitDetection("getReadyFinished"),
+			onDark: () => {
+				if (this.options.config.validateBrightness) this.emitDetection("dark");
+			},
+			onBlur: () => this.emitDetection("blur"),
+			onFaceAngle: () => this.emitDetection("faceAngle"),
+			onLenses: () => {
+				if (this.options.config.validateLenses) this.emitDetection("lenses");
+			},
+			onMask: () => {
+				if (this.options.config.validateFaceMask) this.emitDetection("faceMask");
+			},
+			onEyesClosed: () => {
+				if (this.options.config.validateClosedEyes) this.emitDetection("eyesClosed");
+			},
+			onHeadWear: () => {
+				if (this.options.config.validateHeadCover) this.emitDetection("headWear");
+			},
+			onFaceOccluded: () => this.emitDetection("faceOcclusion"),
+			onSwitchToManualCapture: () => {
+				if (this.options.config.onDeviceFaceResultsSubmissionEnabled !== true) this.emitDetection("manualCapture");
+			},
+			onCapture: (canvas) => {
+				this.emit({
+					type: "autoCapture",
+					preview: canvas.canvas
+				});
+			}
+		});
+		this.emitDetection("detecting");
+	}
+	async runPrc() {
+		if (this.options.delivery === "protected") await this.attachProtectedCameraMetadata();
+		if (this.released) return;
+		const wasmUtil = await this.options.dependencies.getWasmUtil();
+		if (this.released) return;
+		await wasmUtil.prc();
+	}
+	async runPoc() {
+		if (this.options.delivery === "local") return;
+		const deepsight = this.deepsightService;
+		if (!deepsight) throw new Error("Protected face Deepsight is not ready");
+		await deepsight.performVirtualCameraCheck(getToken(), "SELFIE");
+		if (this.released) return;
+		try {
+			await deepsight.finalizeProtectedCaptureMetadata();
+		} catch {
+			trueSightLog("warning", "deepsight", "faceScan", "protected capture metadata finalization failed");
+		}
+		if (this.released) return;
+		try {
+			addDeviceStats({
+				frontIdStatsAnalysisStatus: "",
+				backIdStatsAnalysisStatus: "",
+				selfieStatsAnalysisStatus: deepsight.getAnalysisStatus(),
+				motionStatus: deepsight.getMotionStatus()
+			});
+		} catch {}
+		const logs = deepsight.getPipelineState();
+		this.options.dependencies.trackCaptureAttemptFinished?.({ logs });
+	}
+	async attachProtectedCameraMetadata() {
+		const deepsight = this.deepsightService;
+		if (!deepsight) return;
+		try {
+			const { stream } = await this.acquireRawStream();
+			const [videoTrack] = stream.getVideoTracks();
+			if (videoTrack) await deepsight.checkVirtualCamera(videoTrack);
+		} catch {
+			trueSightLog("warning", "deepsight", "faceScan", "protected camera metadata attachment failed");
+		}
+	}
+	emitDetection(status) {
+		this.emit({
+			type: "detection",
+			status
+		});
+	}
+	emit(signal) {
+		if (this.released) return;
+		if (this.signalListener) this.signalListener(signal);
+		else this.pendingSignals.push(signal);
+	}
+	releaseRawStream(stream) {
+		if (this.rawHandedOff || this.rawStreamReleased) return;
+		this.rawStreamReleased = true;
+		try {
+			stopStream(stream);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/internal/faceCapture/protectedFaceController.ts
+/**
+* Binds one face-machine variant to a fixed native target and delivery mode.
+* The capability-bearing runtime and lifecycle input never leave this callback
+* actor's closure, so parent snapshots contain only presentation/output data.
+*/
+function createProtectedFaceControllerActor(options) {
+	return fromCallback(({ sendBack, receive }) => {
+		let controllerInput;
+		let runtime;
+		let deepsightService;
+		let deepsightState = "idle";
+		let signalCleanup;
+		let lifecycleCleanup;
+		let sendLifecycle;
+		let committedPreview;
+		let pendingAutoPreview;
+		let recording = {};
+		let generation = 0;
+		let active = true;
+		let diagnosticAttempt = 0;
+		let diagnosticStartedAt;
+		const logDiagnostic = (event, fields = {}) => {
+			if (diagnosticStartedAt === void 0) return;
+			logFaceCameraDiagnostic(event, {
+				attempt: diagnosticAttempt,
+				target: options.target === PROTECTED_CAPTURE_TARGET.authentication ? "authentication" : "selfie",
+				delivery: options.delivery,
+				elapsedMs: Math.round(getTimestamp() - diagnosticStartedAt),
+				...fields
+			});
+		};
+		const getControllerInput = () => {
+			if (!controllerInput) throw new Error("Protected face controller is not bound");
+			return controllerInput;
+		};
+		const ensureRuntime = () => {
+			if (!runtime) {
+				const input = getControllerInput();
+				const capabilities = options.createCapabilities();
+				runtime = new ProtectedFaceAttemptRuntime({
+					config: input.config,
+					dependencies: input.dependencies,
+					target: options.target,
+					delivery: options.delivery,
+					authHint: input.authHint,
+					faceDetection: capabilities.faceDetection,
+					cycle: capabilities.cycle,
+					acquireCamera: (provider) => initializeCamera({
+						config: input.config,
+						provider
+					})
+				});
+				if (deepsightService) runtime.setDeepsightService(deepsightService);
+			}
+			return runtime;
+		};
+		const releaseCurrent = (reason) => {
+			logDiagnostic("attempt-release", { releaseReason: reason });
+			diagnosticStartedAt = void 0;
+			generation += 1;
+			signalCleanup?.();
+			signalCleanup = void 0;
+			sendLifecycle?.({
+				type: "RELEASE",
+				reason
+			});
+			sendLifecycle = void 0;
+			lifecycleCleanup?.();
+			lifecycleCleanup = void 0;
+			runtime?.release();
+			runtime = void 0;
+			try {
+				deepsightService?.cleanup();
+			} catch {}
+			deepsightService = void 0;
+			deepsightState = "idle";
+			committedPreview = void 0;
+			pendingAutoPreview = void 0;
+			recording = {};
+		};
+		const initializeDeepsight = () => {
+			if (deepsightState === "ready") {
+				sendBack({ type: "PROTECTED_DEEPSIGHT_READY" });
+				return;
+			}
+			if (deepsightState === "initializing") return;
+			deepsightState = "initializing";
+			const input = getControllerInput();
+			const ownerGeneration = generation;
+			options.initializeDeepsight({
+				ds: input.config.ds,
+				storage: input.dependencies.storage
+			}).then((service) => {
+				if (!active || generation !== ownerGeneration) {
+					try {
+						service.cleanup();
+					} catch {}
+					return;
+				}
+				deepsightService = service;
+				deepsightState = "ready";
+				runtime?.setDeepsightService(service);
+				sendBack({ type: "PROTECTED_DEEPSIGHT_READY" });
+				const preview = pendingAutoPreview;
+				pendingAutoPreview = void 0;
+				if (preview) queueMicrotask(() => {
+					if (active && generation === ownerGeneration) sendBack({
+						type: "PROTECTED_NATIVE_AUTO_CAPTURE",
+						preview
+					});
+				});
+			}, () => {
+				if (!active || generation !== ownerGeneration) return;
+				deepsightState = "failed";
+				sendBack({ type: "PROTECTED_DEEPSIGHT_FAILED" });
+			}).finally(() => {
+				if (generation === ownerGeneration) {}
+			});
+		};
+		const finalizeLocalCapture = async (owner, ownerGeneration) => {
+			const preview = committedPreview;
+			if (!preview) throw new Error("selfieCaptureOnly: no captured image");
+			let metadata = "";
+			try {
+				metadata = deepsightService?.getMetadata() ?? "";
+			} catch {
+				metadata = "";
+			}
+			const canvas = new IncodeCanvas(preview);
+			const blobData = canvas.getBlobData();
+			if (!blobData) throw new Error("selfieCaptureOnly: failed to build image blob");
+			const result = {
+				imageBase64: canvas.getBase64Image() ?? "",
+				blob: blobData.blob,
+				url: blobData.url,
+				metadata,
+				videoBase64: owner.takeCaptureOnlyVideo()
+			};
+			if (active && runtime === owner && generation === ownerGeneration) {
+				sendBack({
+					type: "PROTECTED_LOCAL_DONE",
+					attemptId: owner.attemptId,
+					result
+				});
+				logDiagnostic("upload-complete");
+			}
+		};
+		const forwardLifecycleEvent = (event, owner, ownerGeneration) => {
+			if (!active || runtime !== owner || generation !== ownerGeneration) return;
+			switch (event.type) {
+				case "PROTECTED_ATTEMPT_READY":
+					logDiagnostic("camera-ready");
+					sendBack({
+						...event,
+						usingBackCamera: owner.usingBackCamera
+					});
+					return;
+				case "PROTECTED_AUTO_COMMITTED":
+				case "PROTECTED_MANUAL_COMMITTED":
+					logDiagnostic("capture-selected", { captureKind: event.type === "PROTECTED_AUTO_COMMITTED" ? "auto" : "manual" });
+					committedPreview = event.preview;
+					sendBack(event);
+					return;
+				case "PROTECTED_ATTEMPT_FINALIZED":
+					logDiagnostic("attempt-finalized");
+					recording = event.recording;
+					sendBack(event);
+					return;
+				case "PROTECTED_UPLOAD_DONE":
+					if (event.result.kind === "id") {
+						sendBack({
+							type: "PROTECTED_ATTEMPT_FAILED",
+							attemptId: event.attemptId,
+							failure: {
+								stage: "upload",
+								code: "protected-attempt-unexpected-result"
+							}
+						});
+						return;
+					}
+					sendBack({
+						type: "PROTECTED_UPLOAD_MAPPED",
+						attemptId: event.attemptId,
+						response: owner.mapProtectedResult(event.result)
+					});
+					logDiagnostic("upload-complete");
+					return;
+				case "PROTECTED_ATTEMPT_FAILED":
+					logDiagnostic("attempt-failed", {
+						failureStage: event.failure.stage,
+						failureCode: event.failure.code
+					});
+					sendBack(event);
+					return;
+				default: sendBack(event);
+			}
+		};
+		const start = (visible) => {
+			if (lifecycleCleanup) {
+				sendLifecycle?.({ type: visible ? "FOREGROUND" : "BACKGROUND" });
+				return;
+			}
+			const owner = ensureRuntime();
+			diagnosticAttempt += 1;
+			diagnosticStartedAt = getTimestamp();
+			logDiagnostic("attempt-start");
+			const ownerGeneration = generation;
+			signalCleanup = owner.subscribeSignals((signal) => {
+				if (!active || runtime !== owner || generation !== ownerGeneration) return;
+				if (signal.type === "detection") {
+					sendBack({
+						type: "DETECTION_UPDATE",
+						status: signal.status
+					});
+					return;
+				}
+				if (deepsightState === "ready") sendBack({
+					type: "PROTECTED_NATIVE_AUTO_CAPTURE",
+					preview: signal.preview
+				});
+				else pendingAutoPreview ??= signal.preview;
+			});
+			lifecycleCleanup = runProtectedAttempt({
+				input: owner.toActorInput((timing) => {
+					logDiagnostic("camera-startup", timing);
+				}),
+				sendBack: (event) => forwardLifecycleEvent(event, owner, ownerGeneration),
+				receive: (listener) => {
+					sendLifecycle = listener;
+				}
+			});
+			sendLifecycle?.({ type: visible ? "FOREGROUND" : "BACKGROUND" });
+		};
+		receive((command) => {
+			if (command.type === "BIND_PROTECTED_FACE_CONTROLLER") {
+				controllerInput ??= command.input;
+				return;
+			}
+			switch (command.type) {
+				case "INITIALIZE_DEEPSIGHT":
+					initializeDeepsight();
+					return;
+				case "PRE_ACQUIRE": {
+					const owner = ensureRuntime();
+					const ownerGeneration = generation;
+					owner.preAcquire().then(() => {
+						if (active && runtime === owner && generation === ownerGeneration) sendBack({
+							type: "PROTECTED_PRE_ACQUIRE_DONE",
+							usingBackCamera: owner.usingBackCamera
+						});
+					}, (error) => {
+						if (active && runtime === owner && generation === ownerGeneration) sendBack({
+							type: "PROTECTED_PRE_ACQUIRE_FAILED",
+							error
+						});
+					});
+					return;
+				}
+				case "START":
+					start(command.visible);
+					return;
+				case "AUTO_CAPTURED":
+				case "MANUAL_CAPTURE":
+				case "FINALIZE":
+					if (deepsightState !== "ready") return;
+					sendLifecycle?.(command);
+					return;
+				case "BACKGROUND":
+				case "FOREGROUND":
+					sendLifecycle?.(command);
+					return;
+				case "UPLOAD": {
+					const owner = runtime;
+					if (!owner) return;
+					logDiagnostic("upload-start");
+					if (options.delivery === "protected") {
+						sendLifecycle?.(owner.createUploadCommand(recording.recordingId));
+						return;
+					}
+					finalizeLocalCapture(owner, generation).catch(() => {
+						if (active && runtime === owner) sendBack({
+							type: "PROTECTED_ATTEMPT_FAILED",
+							attemptId: owner.attemptId,
+							failure: {
+								stage: "upload",
+								code: "protected-attempt-local-finalize-failed"
+							}
+						});
+					});
+					return;
+				}
+				case "RESET":
+					releaseCurrent("retry");
+					return;
+				case "RELEASE": releaseCurrent(command.reason);
+			}
+		});
+		return () => {
+			active = false;
+			releaseCurrent("externalStop");
+		};
+	});
+}
+//#endregion
+//#region src/internal/faceCapture/protectedFaceComposition.ts
+/**
+* Private composition root for protected still-face variants. Provider
+* construction remains in Infra; the controller receives only capability
+* interfaces/factories and owns them in its callback closure.
+*/
+function createDefaultProtectedFaceControllerActor(options) {
+	return createProtectedFaceControllerActor({
+		...options,
+		createCapabilities: createProtectedFaceCaptureCapabilities,
+		initializeDeepsight: initializeDeepsightSession
+	});
+}
+//#endregion
 //#region src/internal/faceCapture/faceCaptureSetup.ts
 const getAttemptsFromConfig = (config) => {
 	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
 };
+/**
+* The protected face controller is invoked at the machine root, so a started
+* machine has it for its whole lifetime and every guarded send below behaves
+* like a plain `sendTo`. Harnesses that start the machine from a resolved
+* snapshot carry no children (the Storybook state stories seed managers that
+* way), and XState throws on a send to a missing actor, so each send checks
+* for the controller first.
+*
+* Only sends that run after the machine has started may use this guard. A
+* root `entry` action runs inside the initial transition, before the actor
+* has a committed snapshot; XState delivers a plain `sendTo` from there
+* through its deferred-actor path, whereas this check cannot see the child
+* yet and would skip the send.
+*/
+function isProtectedFaceControllerRunning(self) {
+	return self.getSnapshot()?.children?.["protectedFaceController"] !== void 0;
+}
 const faceCaptureMachine = setup({
 	types: {
 		context: {},
@@ -640,46 +1333,9 @@ const faceCaptureMachine = setup({
 		requestPermission: fromPromise(async ({ input }) => {
 			return invokeRequestPermissionActor(input);
 		}),
-		initializeCamera: fromPromise(async ({ input }) => {
-			return initializeCamera({
-				config: input.config,
-				deepsightService: input.deepsightService
-			});
-		}),
-		runDetection: fromCallback(({ input, sendBack }) => {
-			if (!input.frameCapturer || !input.provider) {
-				sendBack({
-					type: "DETECTION_UPDATE",
-					status: "error"
-				});
-				return () => {};
-			}
-			if (input.manualCaptureTriggered) {
-				sendBack({
-					type: "DETECTION_UPDATE",
-					status: "manualCapture"
-				});
-				return () => {};
-			}
-			const { cleanup, reset } = startDetection({
-				config: input.config,
-				capturer: input.frameCapturer,
-				onUpdate: (status) => sendBack({
-					type: "DETECTION_UPDATE",
-					status
-				}),
-				onSuccess: (canvas, faceCoordinates) => sendBack({
-					type: "DETECTION_SUCCESS",
-					canvas,
-					faceCoordinates
-				}),
-				provider: input.provider
-			});
-			sendBack({
-				type: "DETECTION_RESET_READY",
-				reset
-			});
-			return cleanup;
+		protectedFaceController: createDefaultProtectedFaceControllerActor({
+			target: PROTECTED_CAPTURE_TARGET.selfie,
+			delivery: "protected"
 		}),
 		runAvatar: fromCallback(({ input, sendBack }) => {
 			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(input.config.selfieConcealmentOption);
@@ -713,115 +1369,61 @@ const faceCaptureMachine = setup({
 				handle?.stop();
 			};
 		}),
-		initializeDeepsightSession: fromPromise(async ({ input }) => {
-			return await initializeDeepsightSession({
-				ds: input.ds,
-				storage: input.storage
-			});
-		}),
-		startRecording: fromPromise(async ({ input }) => {
-			if (!input.stream) return input.recordingService;
-			const wasmUtil = await input.dependencies.getWasmUtil();
-			const sessionToken = getToken();
-			const service = input.recordingService ?? createRecordingService({
-				config: input.config,
-				wasmUtil,
-				sessionToken
-			});
-			if (service) await service.start(input.stream);
-			return service;
-		}),
-		checkVirtualCamera: fromPromise(async ({ input }) => {
-			if (!input.deepsightService || !input.stream) return false;
-			const videoTrack = input.stream.getVideoTracks()[0];
-			if (!videoTrack) return false;
-			return input.deepsightService.checkVirtualCamera(videoTrack);
-		}),
 		manualUploadMachine: manualFaceUploadMachine,
 		prepareFaceUpload: fromPromise(async () => {
 			throw new Error("prepareFaceUpload must be provided by variant");
 		}),
-		uploadFace: fromPromise(async () => {
-			throw new Error("uploadFace must be provided by variant");
-		}),
+		uploadFace: fromPromise(async () => new Promise(() => {})),
 		processFace: fromPromise(async () => {
 			throw new Error("processFace must be provided by variant");
 		})
 	},
 	actions: {
-		stopMediaStream: assign(({ context }) => {
-			context.frameCapturer?.dispose();
-			if (context.stream) stopStream(context.stream);
-			context.provider?.dispose();
+		bindProtectedFaceController: sendTo("protectedFaceController", ({ context }) => ({
+			type: "BIND_PROTECTED_FACE_CONTROLLER",
+			input: {
+				config: context.config,
+				dependencies: context.dependencies,
+				authHint: context.authHint
+			}
+		})),
+		stopMediaStream: assign(() => {
 			return {
 				stream: void 0,
-				provider: void 0,
-				frameCapturer: void 0,
 				avatarCanvas: void 0,
 				usingBackCamera: false
 			};
 		}),
-		setStreamAndCapturer: assign({
-			stream: ({ event }) => {
-				if ("output" in event) return event.output.stream;
-			},
-			provider: ({ event }) => {
-				if ("output" in event) return event.output.provider;
-			},
-			frameCapturer: ({ event }) => {
-				if ("output" in event) return new StreamCanvasCapture(event.output.stream);
-			},
-			usingBackCamera: ({ event }) => {
-				if ("output" in event) return event.output.usingBackCamera;
-				return false;
-			}
-		}),
+		setCameraPreAcquired: assign({ usingBackCamera: ({ event }) => event.usingBackCamera }),
 		trackTutorial: () => void 0,
 		trackContinue: () => {},
-		resetContext: assign(({ context }) => ({
-			stream: void 0,
-			provider: void 0,
-			frameCapturer: void 0,
-			usingBackCamera: false,
-			error: void 0,
-			detectionStatus: "idle",
-			capturedImage: void 0,
-			faceCoordinates: void 0,
-			uploadResponse: void 0,
-			processResponse: void 0,
-			recordingService: void 0,
-			attemptsRemaining: getAttemptsFromConfig(context.config),
-			uploadError: void 0,
-			permissionResult: void 0,
-			resetDetection: void 0,
-			deepsightService: void 0,
-			manualCaptureTriggered: false,
-			captureOnlyResult: void 0,
-			avatarCanvas: void 0
-		})),
-		resetDetection: ({ context }) => {
-			context.resetDetection?.();
-		},
-		captureImage: assign({ capturedImage: ({ context }) => {
-			if (context.capturedImage) return context.capturedImage;
-			return context.frameCapturer?.getLatestCanvas() ?? void 0;
-		} }),
-		captureLatestFrame: assign({ capturedImage: ({ context }) => {
-			return context.frameCapturer?.getLatestCanvas() ?? void 0;
-		} }),
+		resetContext: assign(({ context }) => {
+			return {
+				stream: void 0,
+				usingBackCamera: false,
+				error: void 0,
+				detectionStatus: "idle",
+				capturedImage: void 0,
+				faceCoordinates: void 0,
+				uploadResponse: void 0,
+				processResponse: void 0,
+				attemptsRemaining: getAttemptsFromConfig(context.config),
+				uploadError: void 0,
+				permissionResult: void 0,
+				deepsightReady: false,
+				manualCaptureTriggered: false,
+				captureOnlyResult: void 0,
+				avatarCanvas: void 0
+			};
+		}),
 		clearUploadFailure: assign({
 			uploadError: () => void 0,
 			detectionStatus: () => "idle",
 			capturedImage: () => void 0
 		}),
-		prepareStreamForRetry: assign(({ context }) => {
-			context.frameCapturer?.dispose();
-			if (context.stream) stopStream(context.stream);
-			context.provider?.dispose();
+		clearProtectedAttempt: assign(() => {
 			return {
 				stream: void 0,
-				provider: void 0,
-				frameCapturer: void 0,
 				avatarCanvas: void 0,
 				usingBackCamera: false
 			};
@@ -829,25 +1431,15 @@ const faceCaptureMachine = setup({
 		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
 		setUploadErrorFromUploadValidation: assign({ uploadError: () => FACE_ERROR_CODES.SERVER }),
 		setTerminalError: assign({ error: () => "Authentication failed" }),
-		clearRecordingService: assign({ recordingService: () => void 0 }),
-		stopRecordingService: ({ context }) => {
-			context.recordingService?.stop().catch(() => {
-				console.warn("[faceCapture] Recording finalization failed");
-			});
-		},
-		cleanup: ({ context }) => {
-			context.deepsightService?.cleanup();
-		},
+		cleanup: () => void 0,
 		setPermissionResultFromEvent: assign({ permissionResult: ({ event }) => event.output }),
 		setPermissionDenied: assign({ permissionResult: () => "denied" }),
 		setPermissionPrompt: assign({ permissionResult: () => "prompt" }),
 		setPermissionRefresh: assign({ permissionResult: () => "refresh" }),
-		setDeepsightServiceFromEvent: assign({ deepsightService: ({ event }) => event.output }),
+		setDeepsightReady: assign({ deepsightReady: () => true }),
+		setDeepsightNotReady: assign({ deepsightReady: () => false }),
 		setErrorFromEvent: assign({ error: ({ event }) => String(event.error) }),
 		setDetectionStatusDetecting: assign({ detectionStatus: ({ context }) => context.manualCaptureTriggered ? "manualCapture" : "detecting" }),
-		setRecordingServiceFromEvent: assign({ recordingService: ({ context, event }) => {
-			return event.output ?? context.recordingService;
-		} }),
 		setDetectionStatusFromEvent: assign({ detectionStatus: ({ event }) => event.status }),
 		setManualCaptureTriggered: assign({ manualCaptureTriggered: ({ context, event }) => {
 			const status = event.status;
@@ -855,11 +1447,27 @@ const faceCaptureMachine = setup({
 		} }),
 		setAvatarCanvas: assign({ avatarCanvas: ({ event }) => event.canvas }),
 		clearAvatarCanvas: assign({ avatarCanvas: () => void 0 }),
-		setResetDetectionFromEvent: assign({ resetDetection: ({ event }) => event.reset }),
 		setCapturedImageFromEvent: assign({
 			capturedImage: ({ event }) => event.canvas,
 			faceCoordinates: ({ event }) => event.faceCoordinates
 		}),
+		setProtectedAttemptReady: assign({
+			stream: ({ event }) => event.displayStream,
+			usingBackCamera: ({ event }) => event.usingBackCamera
+		}),
+		setProtectedCommittedPreview: assign({
+			capturedImage: ({ event }) => new IncodeCanvas(event.preview),
+			faceCoordinates: () => void 0,
+			detectionStatus: () => "success"
+		}),
+		setProtectedFinalization: assign({
+			uploadRecordingId: ({ event }) => event.recording.recordingId ?? null,
+			stream: ({ context, event }) => event.displayStream ?? context.stream
+		}),
+		setProtectedUploadResponse: assign({ uploadResponse: ({ event }) => event.response }),
+		setProtectedLocalResult: assign({ captureOnlyResult: ({ event }) => event.result }),
+		setProtectedFailure: assign({ error: ({ event }) => event.failure.code }),
+		setProtectedVisibility: assign({ protectedVisible: ({ event }) => event.visible }),
 		setUploadPreparationFromEvent: assign({
 			encryptedBase64Image: ({ event }) => event.output.encryptedBase64Image,
 			uploadRecordingId: ({ event }) => event.output.recordingId
@@ -889,7 +1497,56 @@ const faceCaptureMachine = setup({
 			releaseFaceAvatarWarmup();
 		},
 		noOp: () => void 0,
-		forwardToManualUpload: sendTo("manualUpload", ({ event }) => event)
+		forwardToManualUpload: sendTo("manualUpload", ({ event }) => event),
+		sendProtectedPreAcquire: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "PRE_ACQUIRE" });
+		}),
+		startProtectedAttempt: enqueueActions(({ enqueue, self, context }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", {
+				type: "START",
+				visible: context.protectedVisible
+			});
+		}),
+		initializeProtectedDeepsight: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "INITIALIZE_DEEPSIGHT" });
+		}),
+		resetProtectedController: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "RESET" });
+		}),
+		sendProtectedAutoCapture: enqueueActions(({ enqueue, self, event }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", {
+				type: "AUTO_CAPTURED",
+				preview: event.preview
+			});
+		}),
+		sendProtectedManualCapture: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "MANUAL_CAPTURE" });
+		}),
+		sendProtectedFinalize: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "FINALIZE" });
+		}),
+		sendProtectedUploadIfNeeded: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "UPLOAD" });
+		}),
+		sendProtectedVisibility: enqueueActions(({ enqueue, self, event }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: event.visible ? "FOREGROUND" : "BACKGROUND" });
+		}),
+		releaseProtectedAttempt: enqueueActions(({ enqueue, self, event }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", {
+				type: "RELEASE",
+				reason: event.reason ?? "externalStop"
+			});
+		})
 	},
 	guards: {
 		hasShowTutorial: ({ context }) => context.config.showTutorial,
@@ -914,9 +1571,12 @@ const faceCaptureMachine = setup({
 			return false;
 		},
 		hasStream: ({ context }) => context.stream !== void 0,
-		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightService !== void 0,
+		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightReady,
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
 		hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
+		canCommitProtectedManual: ({ context }) => context.manualCaptureTriggered && context.config.onDeviceFaceResultsSubmissionEnabled !== true,
+		isProtectedManualRefusal: ({ event }) => event.failure.stage === "manualCommit",
+		isProtectedUploadFailure: ({ event }) => event.failure.stage === "upload",
 		hasUploadValidationError: () => false,
 		isTerminalUploadError: () => false,
 		isNoAttemptsTerminal: () => false
@@ -924,13 +1584,12 @@ const faceCaptureMachine = setup({
 }).createMachine({
 	id: "faceCapture",
 	initial: "idle",
+	entry: "bindProtectedFaceController",
 	context: ({ input }) => ({
 		config: input.config,
 		dependencies: input.dependencies,
 		authHint: input.authHint,
 		stream: void 0,
-		provider: void 0,
-		frameCapturer: void 0,
 		usingBackCamera: false,
 		error: void 0,
 		detectionStatus: "idle",
@@ -938,20 +1597,28 @@ const faceCaptureMachine = setup({
 		faceCoordinates: void 0,
 		uploadResponse: void 0,
 		processResponse: void 0,
-		recordingService: void 0,
 		attemptsRemaining: getAttemptsFromConfig(input.config),
 		uploadError: void 0,
 		permissionResult: void 0,
-		resetDetection: void 0,
-		deepsightService: void 0,
+		deepsightReady: false,
 		encryptedBase64Image: void 0,
 		uploadRecordingId: void 0,
 		manualCaptureTriggered: false,
 		captureOnlyResult: void 0,
 		avatarCanvas: void 0,
-		faceFeed: void 0
+		faceFeed: void 0,
+		protectedVisible: true
 	}),
-	on: { QUIT: { target: "#faceCapture.closed" } },
+	invoke: {
+		id: "protectedFaceController",
+		src: "protectedFaceController"
+	},
+	on: {
+		QUIT: { target: "#faceCapture.closed" },
+		PROTECTED_VISIBILITY: { actions: "setProtectedVisibility" },
+		PROTECTED_DEEPSIGHT_READY: { actions: "setDeepsightReady" },
+		PROTECTED_DEEPSIGHT_FAILED: { actions: "setDeepsightNotReady" }
+	},
 	states: {
 		idle: { on: { LOAD: [
 			{
@@ -965,8 +1632,12 @@ const faceCaptureMachine = setup({
 			{ target: "loading" }
 		] } },
 		loading: {
-			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
-			invoke: [{
+			entry: [
+				"preloadRecordingProvider",
+				"warmAvatarProvider",
+				"initializeProtectedDeepsight"
+			],
+			invoke: {
 				id: "checkPermissionLoading",
 				src: "checkPermission",
 				onDone: [{
@@ -977,16 +1648,7 @@ const faceCaptureMachine = setup({
 					target: "permissions",
 					actions: "setPermissionResultFromEvent"
 				}]
-			}, {
-				id: "loadingInitDeepsight",
-				src: "initializeDeepsightSession",
-				input: ({ context }) => ({
-					ds: context.config.ds,
-					storage: context.dependencies.storage
-				}),
-				onDone: { actions: "setDeepsightServiceFromEvent" },
-				onError: { actions: "noOp" }
-			}]
+			}
 		},
 		tutorial: {
 			initial: "checkingPermission",
@@ -1018,40 +1680,36 @@ const faceCaptureMachine = setup({
 						cameraInit: {
 							initial: "initializingDeepsight",
 							states: {
-								initializingDeepsight: { invoke: {
-									id: "tutorialInitDeepsight",
-									src: "initializeDeepsightSession",
-									input: ({ context }) => ({
-										ds: context.config.ds,
-										storage: context.dependencies.storage
-									}),
-									onDone: {
-										target: "initializingStream",
-										actions: "setDeepsightServiceFromEvent"
-									},
-									onError: { target: "#faceCapture.tutorial.ready" }
-								} },
-								initializingStream: { invoke: {
-									id: "tutorialInitCamera",
-									src: "initializeCamera",
-									input: ({ context }) => ({
-										config: context.config,
-										dependencies: context.dependencies,
-										deepsightService: context.deepsightService
-									}),
-									onDone: {
-										target: "ready",
-										actions: "setStreamAndCapturer"
-									},
-									onError: [{
-										target: "#faceCapture.tutorial.ready",
-										guard: "isPermissionDeniedError",
-										actions: "setPermissionDenied"
-									}, {
-										target: "#faceCapture.tutorial.ready",
-										actions: "setErrorFromEvent"
-									}]
-								} },
+								initializingDeepsight: {
+									entry: "initializeProtectedDeepsight",
+									on: {
+										PROTECTED_DEEPSIGHT_READY: {
+											target: "initializingStream",
+											actions: "setDeepsightReady"
+										},
+										PROTECTED_DEEPSIGHT_FAILED: {
+											target: "#faceCapture.tutorial.ready",
+											actions: "setDeepsightNotReady"
+										}
+									}
+								},
+								initializingStream: {
+									entry: "sendProtectedPreAcquire",
+									on: {
+										PROTECTED_PRE_ACQUIRE_DONE: {
+											target: "ready",
+											actions: "setCameraPreAcquired"
+										},
+										PROTECTED_PRE_ACQUIRE_FAILED: [{
+											target: "#faceCapture.tutorial.ready",
+											guard: "isPermissionDeniedError",
+											actions: "setPermissionDenied"
+										}, {
+											target: "#faceCapture.tutorial.ready",
+											actions: "setErrorFromEvent"
+										}]
+									}
+								},
 								ready: { type: "final" }
 							}
 						},
@@ -1073,21 +1731,21 @@ const faceCaptureMachine = setup({
 					states: {
 						idle: { always: [{
 							target: "initializingDeepsight",
-							guard: ({ context }) => context.deepsightService === void 0
+							guard: ({ context }) => !context.deepsightReady
 						}, { target: "readyForNext" }] },
-						initializingDeepsight: { invoke: {
-							id: "initializeDeepsightTutorial",
-							src: "initializeDeepsightSession",
-							input: ({ context }) => ({
-								ds: context.config.ds,
-								storage: context.dependencies.storage
-							}),
-							onDone: {
-								target: "readyForNext",
-								actions: "setDeepsightServiceFromEvent"
-							},
-							onError: { target: "readyForNext" }
-						} },
+						initializingDeepsight: {
+							entry: "initializeProtectedDeepsight",
+							on: {
+								PROTECTED_DEEPSIGHT_READY: {
+									target: "readyForNext",
+									actions: "setDeepsightReady"
+								},
+								PROTECTED_DEEPSIGHT_FAILED: {
+									target: "readyForNext",
+									actions: "setDeepsightNotReady"
+								}
+							}
+						},
 						readyForNext: { on: { NEXT_STEP: {
 							target: "#faceCapture.tutorial.waitingForPermission",
 							actions: "trackContinue"
@@ -1117,26 +1775,30 @@ const faceCaptureMachine = setup({
 			}
 		},
 		permissions: {
-			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
+			entry: [
+				"preloadRecordingProvider",
+				"warmAvatarProvider",
+				"initializeProtectedDeepsight"
+			],
 			initial: "checkingDeepsight",
 			states: {
 				checkingDeepsight: { always: [{
 					target: "initializingDeepsight",
-					guard: ({ context }) => context.deepsightService === void 0
+					guard: ({ context }) => !context.deepsightReady
 				}, { target: "idle" }] },
-				initializingDeepsight: { invoke: {
-					id: "initializeDeepsightPerms",
-					src: "initializeDeepsightSession",
-					input: ({ context }) => ({
-						ds: context.config.ds,
-						storage: context.dependencies.storage
-					}),
-					onDone: {
-						target: "idle",
-						actions: "setDeepsightServiceFromEvent"
-					},
-					onError: { target: "idle" }
-				} },
+				initializingDeepsight: {
+					entry: "initializeProtectedDeepsight",
+					on: {
+						PROTECTED_DEEPSIGHT_READY: {
+							target: "idle",
+							actions: "setDeepsightReady"
+						},
+						PROTECTED_DEEPSIGHT_FAILED: {
+							target: "idle",
+							actions: "setDeepsightNotReady"
+						}
+					}
+				},
 				idle: {
 					invoke: {
 						id: "checkPermissionIdle",
@@ -1210,172 +1872,117 @@ const faceCaptureMachine = setup({
 			}
 		},
 		capture: {
-			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
+			entry: [
+				"preloadRecordingProvider",
+				"warmAvatarProvider",
+				"initializeProtectedDeepsight",
+				"startProtectedAttempt"
+			],
 			initial: "checkingDeepsight",
 			exit: [
+				"releaseProtectedAttempt",
 				"stopMediaStream",
-				"stopRecordingService",
-				"clearRecordingService",
 				"cleanup"
 			],
-			states: {
-				checkingDeepsight: { always: [{
-					target: "initializingDeepsight",
-					guard: ({ context }) => context.deepsightService === void 0
-				}, { target: "checkingStream" }] },
-				initializingDeepsight: { invoke: {
-					id: "initializeDeepsightCapture",
-					src: "initializeDeepsightSession",
-					input: ({ context }) => ({
-						ds: context.config.ds,
-						storage: context.dependencies.storage
-					}),
-					onDone: {
-						target: "checkingStream",
-						actions: ["setDeepsightServiceFromEvent"]
-					},
-					onError: { target: "#faceCapture.permissions" }
-				} },
-				checkingStream: { always: [
+			on: {
+				PROTECTED_ATTEMPT_READY: { actions: "setProtectedAttemptReady" },
+				PROTECTED_VISIBILITY: { actions: ["setProtectedVisibility", "sendProtectedVisibility"] },
+				PROTECTED_APPLY_VISIBILITY: { actions: "sendProtectedVisibility" },
+				PROTECTED_ATTEMPT_FAILED: [
 					{
-						target: "initializingDeepsight",
-						guard: ({ context }) => context.deepsightService === void 0
+						target: ".detecting",
+						guard: "isProtectedManualRefusal"
 					},
 					{
-						target: "detecting",
-						guard: "hasStream"
-					},
-					{ target: "initializing" }
-				] },
-				initializing: { invoke: {
-					id: "initializeCamera",
-					src: "initializeCamera",
-					input: ({ context }) => ({
-						config: context.config,
-						dependencies: context.dependencies,
-						deepsightService: context.deepsightService
-					}),
-					onDone: {
-						target: "detecting",
-						actions: ["setStreamAndCapturer"]
+						target: ".uploadError",
+						guard: "isProtectedUploadFailure",
+						actions: "setServerErrorAndDecrement"
 					},
-					onError: [{
-						target: "#faceCapture.permissions",
-						guard: "isPermissionDeniedError",
-						actions: "setPermissionDenied"
-					}, {
+					{
 						target: "#faceCapture.error",
-						actions: "setErrorFromEvent"
-					}]
+						actions: "setProtectedFailure"
+					}
+				],
+				PROTECTED_ATTEMPT_RELEASED: { actions: "noOp" }
+			},
+			states: {
+				checkingDeepsight: { always: [{
+					target: "initializingDeepsight",
+					guard: ({ context }) => !context.deepsightReady
+				}, { target: "initializing" }] },
+				initializingDeepsight: {
+					entry: "initializeProtectedDeepsight",
+					on: {
+						PROTECTED_DEEPSIGHT_READY: {
+							target: "initializing",
+							actions: "setDeepsightReady"
+						},
+						PROTECTED_DEEPSIGHT_FAILED: {
+							target: "#faceCapture.permissions",
+							actions: "setDeepsightNotReady"
+						}
+					}
+				},
+				checkingStream: { always: "initializing" },
+				initializing: { always: {
+					target: "detecting",
+					guard: "isCameraAndDeepsightReady"
 				} },
 				detecting: {
 					entry: ["setDetectionStatusDetecting"],
-					invoke: [
-						{
-							id: "checkVirtualCamera",
-							src: "checkVirtualCamera",
-							input: ({ context }) => ({
-								stream: context.stream,
-								deepsightService: context.deepsightService
-							}),
-							onDone: [{
-								target: "#faceCapture.processing",
-								guard: ({ event }) => event.output === true,
-								actions: "sendLabelInspection"
-							}],
-							onError: { actions: "noOp" }
-						},
-						{
-							id: "startRecording",
-							src: "startRecording",
-							input: ({ context }) => ({
-								config: context.config,
-								dependencies: context.dependencies,
-								recordingService: context.recordingService,
-								stream: context.stream
-							}),
-							onDone: { actions: "setRecordingServiceFromEvent" },
-							onError: { actions: "noOp" }
-						},
-						{
-							id: "runDetection",
-							src: "runDetection",
-							input: ({ context }) => ({
-								frameCapturer: context.frameCapturer,
-								provider: context.provider,
-								config: context.config,
-								manualCaptureTriggered: context.manualCaptureTriggered,
-								faceFeed: context.faceFeed
-							})
-						},
-						{
-							id: "runAvatar",
-							src: "runAvatar",
-							input: ({ context }) => ({
-								stream: context.stream,
-								config: context.config,
-								faceFeed: context.faceFeed
-							})
-						}
-					],
+					invoke: {
+						id: "runAvatar",
+						src: "runAvatar",
+						input: ({ context }) => ({
+							stream: context.stream,
+							config: context.config,
+							faceFeed: context.faceFeed
+						})
+					},
 					exit: ["clearAvatarCanvas"],
 					on: {
 						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
 						AVATAR_READY: { actions: "setAvatarCanvas" },
-						DETECTION_RESET_READY: { actions: "setResetDetectionFromEvent" },
-						DETECTION_SUCCESS: {
+						PROTECTED_NATIVE_AUTO_CAPTURE: { actions: "sendProtectedAutoCapture" },
+						PROTECTED_AUTO_COMMITTED: {
 							target: "capturing",
-							actions: "setCapturedImageFromEvent"
+							actions: "setProtectedCommittedPreview"
 						},
-						MANUAL_CAPTURE: { target: "capturingManual" }
+						MANUAL_CAPTURE: {
+							target: "capturingManual",
+							guard: "canCommitProtectedManual",
+							actions: "sendProtectedManualCapture"
+						}
 					}
 				},
 				capturing: {
-					entry: ["captureImage"],
-					always: [{
+					entry: ["sendProtectedFinalize"],
+					on: { PROTECTED_ATTEMPT_FINALIZED: {
 						target: "preparingUpload",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: "setServerErrorAndDecrement"
-					}]
+						actions: "setProtectedFinalization"
+					} }
 				},
-				capturingManual: {
-					entry: ["captureLatestFrame"],
-					always: [{
+				capturingManual: { on: {
+					PROTECTED_MANUAL_COMMITTED: { actions: ["setProtectedCommittedPreview", "sendProtectedFinalize"] },
+					PROTECTED_ATTEMPT_FINALIZED: {
 						target: "preparingUpload",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: "setServerErrorAndDecrement"
-					}]
-				},
-				preparingUpload: { invoke: {
-					id: "prepareFaceUpload",
-					src: "prepareFaceUpload",
-					input: ({ context }) => context,
-					onDone: {
-						target: "uploading",
-						actions: "setUploadPreparationFromEvent"
-					},
-					onError: {
-						target: "uploadError",
-						actions: "setServerErrorAndDecrement"
+						actions: "setProtectedFinalization"
 					}
 				} },
-				uploading: { invoke: {
-					id: "uploadFace",
-					src: "uploadFace",
-					input: ({ context }) => context,
-					onDone: {
-						target: "validatingUpload",
-						actions: "setUploadResponseFromEvent"
-					},
-					onError: {
-						target: "uploadError",
-						actions: "setServerErrorAndDecrement"
+				preparingUpload: { always: "uploading" },
+				uploading: {
+					entry: "sendProtectedUploadIfNeeded",
+					on: {
+						PROTECTED_UPLOAD_MAPPED: {
+							target: "validatingUpload",
+							actions: "setProtectedUploadResponse"
+						},
+						PROTECTED_LOCAL_DONE: {
+							target: "validatingUpload",
+							actions: "setProtectedLocalResult"
+						}
 					}
-				} },
+				},
 				validatingUpload: { always: [
 					{
 						target: "#faceCapture.error",
@@ -1391,12 +1998,14 @@ const faceCaptureMachine = setup({
 				] },
 				uploadError: { on: { RETRY_CAPTURE: [
 					{
-						target: "checkingStream",
+						target: "#faceCapture.capture",
+						reenter: true,
 						guard: "hasAttemptsRemaining",
 						actions: [
-							"resetDetection",
 							"clearUploadFailure",
-							"prepareStreamForRetry"
+							"setDeepsightNotReady",
+							"resetProtectedController",
+							"clearProtectedAttempt"
 						]
 					},
 					{
@@ -1410,17 +2019,17 @@ const faceCaptureMachine = setup({
 					}
 				] } },
 				success: {
-					entry: [
-						"stopRecordingService",
-						"clearRecordingService",
-						"cleanup"
-					],
+					entry: "cleanup",
 					after: { 3e3: { target: "#faceCapture.processing" } }
 				}
 			}
 		},
 		manualUpload: {
-			entry: ["stopMediaStream", "releaseAvatarWarmup"],
+			entry: [
+				"releaseProtectedAttempt",
+				"stopMediaStream",
+				"releaseAvatarWarmup"
+			],
 			invoke: {
 				id: "manualUpload",
 				src: "manualUploadMachine",
@@ -1469,21 +2078,29 @@ const faceCaptureMachine = setup({
 			}
 		},
 		finished: {
-			entry: ["stopMediaStream", "releaseAvatarWarmup"],
+			entry: [
+				"releaseProtectedAttempt",
+				"stopMediaStream",
+				"releaseAvatarWarmup"
+			],
 			type: "final"
 		},
 		closed: {
-			entry: ["stopMediaStream", "releaseAvatarWarmup"],
+			entry: [
+				"releaseProtectedAttempt",
+				"stopMediaStream",
+				"releaseAvatarWarmup"
+			],
 			type: "final"
 		},
 		error: {
 			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			on: { RESET: {
 				target: "idle",
-				actions: "resetContext"
+				actions: ["resetProtectedController", "resetContext"]
 			} }
 		}
 	}
 });
 //#endregion
-export { manualFaceUploadMachine as n, concealmentToAvatar as r, faceCaptureMachine as t };
+export { concealmentToAvatar as i, createDefaultProtectedFaceControllerActor as n, manualFaceUploadMachine as r, faceCaptureMachine as t };