@incodetech/core 2.0.0-alpha.12 → 2.0.0-alpha.14

package/dist/selfie.esm.js

@@ -1,9 +1,11 @@
-import { E as createManager, T as stopCameraStream, f as FaceDetectionProvider, h as OpenViduRecordingProvider, i as getToken, n as api, t as endpoints, u as WasmUtilProvider, v as StreamCanvasProcessingSession, w as requestCameraAccess, y as StreamCanvasCapture } from "./endpoints-D9TGnxRK.esm.js";
-import { n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-D5MURoVB.esm.js";
-import { i as getDeviceClass, n as checkPermission, r as requestPermission, t as streamingEvents } from "./streamingEvents-B3hNanPl.esm.js";
-import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-2hDiAXvZ.esm.js";
-import { t as addEvent } from "./addEvent-BGKc_lHF.esm.js";
-import "./deepsightService-BWxcc4OC.esm.js";
+import { d as addEvent, n as eventModuleNames } from "./events-B8ZkhAZo.esm.js";
+import { C as createManager, S as stopCameraStream, a as FaceDetectionProvider, c as OpenViduRecordingProvider, f as BrowserStorageProvider, h as StreamCanvasCapture, m as StreamCanvasProcessingSession, r as WasmUtilProvider, u as LocalRecordingProvider, x as requestCameraAccess } from "./src-DYtpbFY5.esm.js";
+import "./getDeviceClass-DkfbtsIJ.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
+import { a as uploadDeepsightVideo, c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-CfEJv3xH.esm.js";
+import { r as getToken, t as api } from "./api-DfRLAneb.esm.js";
+import "./deepsightService-j5zMt6wf.esm.js";
+import { t as addDeviceStats } from "./stats-DnU4uUFv.esm.js";
 
 //#region src/modules/selfie/types.ts
 const FACE_ERROR_CODES = {
@@ -110,6 +112,9 @@ async function processFace(imageType = "selfie", signal) {
 
 //#endregion
 //#region src/modules/selfie/selfieServices.ts
+function sendLabelInspectionEvent() {
+	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
+}
 const CAMERA_CONSTRAINTS = {
 	video: {
 		facingMode: "user",
@@ -121,7 +126,8 @@ const CAMERA_CONSTRAINTS = {
 function stopStream(stream) {
 	stopCameraStream(stream);
 }
-async function initializeCamera(config) {
+async function initializeCamera(params) {
+	const { config, dependencies } = params;
 	const provider = new FaceDetectionProvider();
 	await provider.initialize({ autocaptureInterval: config.autoCaptureTimeout * 1e3 });
 	provider.setChecksEnabled({
@@ -131,6 +137,16 @@ async function initializeCamera(config) {
 		headWear: config.validateHeadCover,
 		occlusion: false
 	});
+	console.log("performPrcCheck init");
+	const timerName = `performPrcCheck ${Math.random()}`;
+	console.time(timerName);
+	await params.deepsightService.performPrcCheck({
+		constraints: { video: CAMERA_CONSTRAINTS.video },
+		ds: config.ds,
+		storage: dependencies.storage
+	});
+	console.timeEnd(timerName);
+	console.log("performPrcCheck end");
 	return {
 		stream: await requestCameraAccess({
 			video: CAMERA_CONSTRAINTS.video,
@@ -142,10 +158,10 @@ async function initializeCamera(config) {
 /**
 * Encrypts the provided selfie image using WASM.
 */
-async function encryptSelfieImage({ canvas }) {
+async function encryptSelfieImage({ canvas, dependencies }) {
 	const base64Image = canvas.getBase64Image();
 	if (!base64Image) throw new Error("Canvas image is empty or null");
-	return (await WasmUtilProvider.getInstance()).encryptImage(base64Image);
+	return (await dependencies.getWasmUtil()).encryptImage(base64Image);
 }
 function startDetection(params) {
 	let lastStatus;
@@ -244,6 +260,7 @@ async function startRecordingSession(params) {
 			onSessionConnected: (sessionId) => {
 				addEvent({
 					code: streamingEvents.strSessionDidConnect,
+					module: eventModuleNames.selfie,
 					payload: {
 						message: "Recording session connected",
 						sessionId
@@ -253,6 +270,7 @@ async function startRecordingSession(params) {
 			onSessionDisconnected: (sessionId) => {
 				addEvent({
 					code: streamingEvents.strSessionDidDisconnect,
+					module: eventModuleNames.selfie,
 					payload: {
 						message: "Recording session disconnected",
 						sessionId
@@ -262,6 +280,7 @@ async function startRecordingSession(params) {
 			onSessionException: (event) => {
 				addEvent({
 					code: streamingEvents.strSessionDidFailWithError,
+					module: eventModuleNames.selfie,
 					payload: {
 						message: "Recording session failed due to an error",
 						eventName: event.name,
@@ -274,6 +293,7 @@ async function startRecordingSession(params) {
 			onPublisherCreated: (p) => {
 				addEvent({
 					code: streamingEvents.strStreamPublisherCreated,
+					module: eventModuleNames.selfie,
 					payload: {
 						message: "Recording publisher created",
 						sessionId: p.sessionId,
@@ -284,6 +304,7 @@ async function startRecordingSession(params) {
 			onPublisherError: (p) => {
 				addEvent({
 					code: streamingEvents.strStreamPublisherDidFailWithError,
+					module: eventModuleNames.selfie,
 					payload: {
 						message: "Recording publisher failed due to an error",
 						sessionId: p.sessionId,
@@ -302,6 +323,7 @@ async function startRecordingSession(params) {
 	});
 	addEvent({
 		code: streamingEvents.strStreamVideoCaptureStart,
+		module: eventModuleNames.selfie,
 		payload: {
 			message: "Recording capture started",
 			resolution,
@@ -324,6 +346,7 @@ function stopRecording(session) {
 		try {
 			addEvent({
 				code: streamingEvents.strStreamVideoCaptureStop,
+				module: eventModuleNames.selfie,
 				payload: {
 					message: "Recording capture stopped",
 					videoRecordingId: session.videoRecordingId,
@@ -334,6 +357,7 @@ function stopRecording(session) {
 			await stopRecording$1(session.videoRecordingId);
 			addEvent({
 				code: streamingEvents.strStreamPublisherDestroyed,
+				module: eventModuleNames.selfie,
 				payload: {
 					message: "Recording publisher destroyed",
 					sessionId: session.sessionId,
@@ -344,6 +368,7 @@ function stopRecording(session) {
 			await session.connection.disconnect();
 			addEvent({
 				code: streamingEvents.strSessionDidDisconnect,
+				module: eventModuleNames.selfie,
 				payload: {
 					message: "Recording session disconnected",
 					sessionId: session.sessionId
@@ -352,12 +377,72 @@ function stopRecording(session) {
 		}
 	})();
 }
-async function initializeDeepsightSession(config) {
-	if (config.deepsightLiveness !== "VIDEOLIVENESS") return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-B36_XZ7r.esm.js");
+async function initializeDeepsightSession() {
+	const { loadDeepsightSession } = await import("./deepsightLoader-BMT0FSg6.esm.js");
 	return loadDeepsightSession();
 }
 
+//#endregion
+//#region src/modules/selfie/recordingService.ts
+/**
+* Records on-device and uploads encrypted video for liveness.
+*/
+var LocalRecordingService = class {
+	constructor(wasmUtil, sessionToken) {
+		this.recorder = new LocalRecordingProvider();
+		this.sessionToken = sessionToken;
+		this.wasmUtil = wasmUtil;
+	}
+	async start(stream) {
+		this.recorder.startRecording(stream);
+	}
+	async stop() {
+		if (!this.recorder.isRecording) return { recordingId: null };
+		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
+		if (!this.sessionToken) return { recordingId: null };
+		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
+	}
+	cleanup() {
+		this.recorder.reset();
+	}
+};
+/**
+* Records through OpenVidu and manages the session lifecycle.
+*/
+var OpenViduRecordingService = class {
+	constructor(config) {
+		this.provider = new OpenViduRecordingProvider();
+		this.config = config;
+	}
+	async start(stream) {
+		this.session = await startRecordingSession({
+			config: {
+				...this.config,
+				recording: { capability: this.provider }
+			},
+			clonedStream: stream.clone(),
+			existing: this.session
+		});
+	}
+	async stop() {
+		if (this.session) {
+			stopRecording(this.session);
+			this.session = void 0;
+		}
+		return { recordingId: null };
+	}
+	cleanup() {
+		if (this.session) stopRecording(this.session);
+	}
+};
+/**
+* Creates the recording service for the current configuration.
+*/
+function createRecordingService(params) {
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
+	if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
+}
+
 //#endregion
 //#region src/modules/selfie/selfieStateMachine.ts
 const _selfieMachine = setup({
@@ -374,7 +459,11 @@ const _selfieMachine = setup({
 			return requestPermission();
 		}),
 		initializeCamera: fromPromise(async ({ input }) => {
-			return initializeCamera(input);
+			return initializeCamera({
+				config: input.config,
+				dependencies: input.dependencies,
+				deepsightService: input.deepsightService
+			});
 		}),
 		runDetection: fromCallback(({ input, sendBack }) => {
 			if (!input.frameCapturer || !input.provider) {
@@ -408,37 +497,51 @@ const _selfieMachine = setup({
 			});
 			return cleanup;
 		}),
-		initializeDeepsightSession: fromPromise(async ({ input }) => {
-			return await initializeDeepsightSession(input.config);
+		initializeDeepsightSession: fromPromise(async () => {
+			return await initializeDeepsightSession();
+		}),
+		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);
 		}),
 		uploadSelfie: fromPromise(async ({ input, signal }) => {
-			let metadata;
 			let recordingId = null;
-			if (input.deepsightService) {
-				const imageData = input.canvas.getImageData();
-				const sessionToken = getToken();
-				if (imageData && sessionToken) {
-					const result = await input.deepsightService.performCapture(sessionToken, imageData);
-					metadata = result.metadata;
-					recordingId = result.recordingId;
+			const sessionToken = getToken();
+			try {
+				if (input.deepsightService) {
+					const [_, recordingServiceStopResult] = await Promise.all([
+						input.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"),
+						input.recordingService?.stop(),
+						input.deepsightService.analyzeFrame(input.canvas.getImageData())
+					]);
+					recordingId = recordingServiceStopResult?.recordingId ?? null;
 				}
-			}
+			} catch (error) {}
 			return uploadSelfie({
-				encryptedBase64Image: await encryptSelfieImage({ canvas: input.canvas }),
+				encryptedBase64Image: await encryptSelfieImage({
+					canvas: input.canvas,
+					dependencies: input.dependencies
+				}),
 				faceCoordinates: input.faceCoordinates,
-				metadata,
+				metadata: input.deepsightService?.getMetadata(),
 				recordingId,
 				signal
 			});
 		}),
-		startRecording: fromPromise(async ({ input }) => {
-			if (!input.clonedStream) return;
-			return startRecordingSession({
-				config: input.config,
-				clonedStream: input.clonedStream,
-				existing: input.existing
-			});
-		}),
 		processFace: fromPromise(async ({ signal }) => {
 			return processFace("selfie", signal);
 		})
@@ -468,11 +571,15 @@ const _selfieMachine = setup({
 		trackTutorialSelfie: () => {
 			addEvent({
 				code: "tutorialSelfie",
+				module: eventModuleNames.selfie,
 				payload: { tutorialSelfie: true }
 			});
 		},
 		trackContinue: () => {
-			addEvent({ code: "continue" });
+			addEvent({
+				code: "continue",
+				module: eventModuleNames.selfie
+			});
 		},
 		resetContext: assign(({ context }) => ({
 			stream: void 0,
@@ -485,8 +592,7 @@ const _selfieMachine = setup({
 			faceCoordinates: void 0,
 			uploadResponse: void 0,
 			processResponse: void 0,
-			recordingSession: void 0,
-			recordingStream: void 0,
+			recordingService: void 0,
 			attemptsRemaining: context.config.captureAttempts,
 			uploadError: void 0,
 			permissionResult: void 0,
@@ -508,39 +614,20 @@ const _selfieMachine = setup({
 			detectionStatus: () => "idle",
 			capturedImage: () => void 0
 		}),
+		clearStreamForRetry: assign({
+			stream: () => void 0,
+			provider: () => void 0,
+			frameCapturer: () => void 0
+		}),
 		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
 		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => validateUploadResponse({
 			config: context.config,
 			response: context.uploadResponse
 		}) ?? FACE_ERROR_CODES.SERVER }),
-		stopMediaRecording: ({ context }) => {
-			if (context.recordingSession) stopRecording(context.recordingSession);
-		},
-		clearRecordingSession: assign({
-			recordingSession: () => void 0,
-			recordingStream: () => void 0
-		}),
-		createRecordingStream: assign({ recordingStream: ({ context }) => {
-			if (!context.config.enableFaceRecording) return;
-			if (context.recordingStream) return context.recordingStream;
-			return context.stream?.clone();
-		} }),
-		stopRecordingStream: ({ context }) => {
-			if (context.recordingStream) stopStream(context.recordingStream);
-		},
-		startDeepsightRecording: ({ context }) => {
-			if (context.deepsightService && context.stream) context.deepsightService.startRecording(context.stream);
-		},
-		checkVirtualCamera: ({ context }) => {
-			(async () => {
-				if (context.deepsightService && context.stream) {
-					const videoTrack = context.stream.getVideoTracks()[0];
-					if (videoTrack) await context.deepsightService.checkVirtualCamera(videoTrack);
-				}
-			})();
-		},
-		cleanupDeepsight: ({ context }) => {
+		clearRecordingService: assign({ recordingService: () => void 0 }),
+		cleanup: ({ context }) => {
 			context.deepsightService?.cleanup();
+			context.recordingService?.cleanup();
 		}
 	},
 	guards: {
@@ -557,7 +644,7 @@ const _selfieMachine = setup({
 			return false;
 		},
 		hasStream: ({ context }) => context.stream !== void 0,
-		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && (context.config.deepsightLiveness !== "VIDEOLIVENESS" || context.deepsightService !== void 0),
+		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightService !== void 0,
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
 		hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
 		hasUploadValidationError: ({ context }) => validateUploadResponse({
@@ -570,6 +657,7 @@ const _selfieMachine = setup({
 	initial: "idle",
 	context: ({ input }) => ({
 		config: input.config,
+		dependencies: input.dependencies,
 		stream: void 0,
 		provider: void 0,
 		frameCapturer: void 0,
@@ -580,8 +668,7 @@ const _selfieMachine = setup({
 		faceCoordinates: void 0,
 		uploadResponse: void 0,
 		processResponse: void 0,
-		recordingSession: void 0,
-		recordingStream: void 0,
+		recordingService: void 0,
 		attemptsRemaining: input.config.captureAttempts,
 		uploadError: void 0,
 		permissionResult: void 0,
@@ -608,7 +695,6 @@ const _selfieMachine = setup({
 		}, {
 			id: "loadingInitDeepsight",
 			src: "initializeDeepsightSession",
-			input: ({ context }) => ({ config: context.config }),
 			onDone: { actions: assign({ deepsightService: ({ event }) => event.output }) },
 			onError: { actions: () => void 0 }
 		}] },
@@ -629,62 +715,67 @@ const _selfieMachine = setup({
 					}]
 				} },
 				initializingCamera: {
-					initial: "booting",
-					invoke: [{
-						id: "tutorialInitCamera",
-						src: "initializeCamera",
-						input: ({ context }) => context.config,
-						onDone: { actions: "setStreamAndCapturer" },
-						onError: [{
-							target: "ready",
-							guard: "isPermissionDeniedError",
-							actions: assign({ permissionResult: () => "denied" })
-						}, {
-							target: "ready",
-							actions: assign({ error: ({ event }) => String(event.error) })
-						}]
-					}, {
-						id: "tutorialInitDeepsight",
-						src: "initializeDeepsightSession",
-						input: ({ context }) => ({ config: context.config }),
-						onDone: { actions: assign({ deepsightService: ({ event }) => event.output }) },
-						onError: { actions: () => void 0 }
-					}],
+					type: "parallel",
 					states: {
-						booting: {
-							always: [{
-								target: "#tutorialCameraReady",
-								guard: "isCameraAndDeepsightReady"
-							}],
-							on: { NEXT_STEP: {
-								target: "waitingForStream",
-								actions: "trackContinue"
-							} }
+						cameraInit: {
+							initial: "initializingDeepsight",
+							states: {
+								initializingDeepsight: { invoke: {
+									id: "tutorialInitDeepsight",
+									src: "initializeDeepsightSession",
+									onDone: {
+										target: "initializingStream",
+										actions: assign({ deepsightService: ({ event }) => event.output })
+									},
+									onError: { target: "#selfie.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: "#selfie.tutorial.ready",
+										guard: "isPermissionDeniedError",
+										actions: assign({ permissionResult: () => "denied" })
+									}, {
+										target: "#selfie.tutorial.ready",
+										actions: assign({ error: ({ event }) => String(event.error) })
+									}]
+								} },
+								ready: { type: "final" }
+							}
 						},
-						waitingForStream: { always: [{
-							target: "#selfie.capture",
-							guard: "isCameraAndDeepsightReady"
-						}] }
-					}
-				},
-				cameraReady: {
-					id: "tutorialCameraReady",
-					on: { NEXT_STEP: {
-						target: "#selfie.capture",
-						actions: "trackContinue"
-					} }
+						userIntent: {
+							initial: "waiting",
+							states: {
+								waiting: { on: { NEXT_STEP: {
+									target: "clicked",
+									actions: "trackContinue"
+								} } },
+								clicked: { type: "final" }
+							}
+						}
+					},
+					onDone: { target: "#selfie.capture" }
 				},
 				ready: {
 					initial: "idle",
 					states: {
 						idle: { always: [{
 							target: "initializingDeepsight",
-							guard: ({ context }) => context.config.deepsightLiveness === "VIDEOLIVENESS"
+							guard: ({ context }) => context.deepsightService === void 0
 						}, { target: "readyForNext" }] },
 						initializingDeepsight: { invoke: {
 							id: "initializeDeepsightTutorial",
 							src: "initializeDeepsightSession",
-							input: ({ context }) => ({ config: context.config }),
 							onDone: {
 								target: "readyForNext",
 								actions: assign({ deepsightService: ({ event }) => event.output })
@@ -716,12 +807,11 @@ const _selfieMachine = setup({
 			states: {
 				checkingDeepsight: { always: [{
 					target: "initializingDeepsight",
-					guard: ({ context }) => context.config.deepsightLiveness === "VIDEOLIVENESS" && context.deepsightService === void 0
+					guard: ({ context }) => context.deepsightService === void 0
 				}, { target: "idle" }] },
 				initializingDeepsight: { invoke: {
 					id: "initializeDeepsightPerms",
 					src: "initializeDeepsightSession",
-					input: ({ context }) => ({ config: context.config }),
 					onDone: {
 						target: "idle",
 						actions: assign({ deepsightService: ({ event }) => event.output })
@@ -778,35 +868,43 @@ const _selfieMachine = setup({
 		capture: {
 			initial: "checkingDeepsight",
 			exit: [
-				"stopMediaRecording",
-				"stopRecordingStream",
-				"clearRecordingSession",
 				"stopMediaStream",
-				"cleanupDeepsight"
+				"cleanup",
+				"clearRecordingService"
 			],
 			states: {
 				checkingDeepsight: { always: [{
 					target: "initializingDeepsight",
-					guard: ({ context }) => context.config.deepsightLiveness === "VIDEOLIVENESS" && context.deepsightService === void 0
+					guard: ({ context }) => context.deepsightService === void 0
 				}, { target: "checkingStream" }] },
 				initializingDeepsight: { invoke: {
 					id: "initializeDeepsightCapture",
 					src: "initializeDeepsightSession",
-					input: ({ context }) => ({ config: context.config }),
 					onDone: {
 						target: "checkingStream",
 						actions: [assign({ deepsightService: ({ event }) => event.output })]
 					},
-					onError: { target: "checkingStream" }
+					onError: { target: "#selfie.permissions" }
 				} },
-				checkingStream: { always: [{
-					target: "detecting",
-					guard: "hasStream"
-				}, { target: "initializing" }] },
+				checkingStream: { always: [
+					{
+						target: "initializingDeepsight",
+						guard: ({ context }) => context.deepsightService === void 0
+					},
+					{
+						target: "detecting",
+						guard: "hasStream"
+					},
+					{ target: "initializing" }
+				] },
 				initializing: { invoke: {
 					id: "initializeCamera",
 					src: "initializeCamera",
-					input: ({ context }) => context.config,
+					input: ({ context }) => ({
+						config: context.config,
+						dependencies: context.dependencies,
+						deepsightService: context.deepsightService
+					}),
 					onDone: {
 						target: "detecting",
 						actions: ["setStreamAndCapturer"]
@@ -821,33 +919,48 @@ const _selfieMachine = setup({
 					}]
 				} },
 				detecting: {
-					entry: [
-						assign({ detectionStatus: () => "detecting" }),
-						"createRecordingStream",
-						"checkVirtualCamera",
-						"startDeepsightRecording"
+					entry: [assign({ detectionStatus: () => "detecting" })],
+					invoke: [
+						{
+							id: "checkVirtualCamera",
+							src: "checkVirtualCamera",
+							input: ({ context }) => ({
+								stream: context.stream,
+								deepsightService: context.deepsightService
+							}),
+							onDone: [{
+								target: "#selfie.processing",
+								guard: ({ event }) => event.output === true,
+								actions: () => {
+									sendLabelInspectionEvent();
+								}
+							}],
+							onError: { actions: () => void 0 }
+						},
+						{
+							id: "startRecording",
+							src: "startRecording",
+							input: ({ context }) => ({
+								config: context.config,
+								dependencies: context.dependencies,
+								recordingService: context.recordingService,
+								stream: context.stream
+							}),
+							onDone: { actions: assign({ recordingService: ({ context, event }) => {
+								return event.output ?? context.recordingService;
+							} }) },
+							onError: { actions: () => void 0 }
+						},
+						{
+							id: "runDetection",
+							src: "runDetection",
+							input: ({ context }) => ({
+								frameCapturer: context.frameCapturer,
+								provider: context.provider,
+								config: context.config
+							})
+						}
 					],
-					invoke: [{
-						id: "startRecording",
-						src: "startRecording",
-						input: ({ context }) => ({
-							config: context.config,
-							clonedStream: context.recordingStream,
-							existing: context.recordingSession
-						}),
-						onDone: { actions: assign({ recordingSession: ({ context, event }) => {
-							return event.output ?? context.recordingSession;
-						} }) },
-						onError: { actions: () => void 0 }
-					}, {
-						id: "runDetection",
-						src: "runDetection",
-						input: ({ context }) => ({
-							frameCapturer: context.frameCapturer,
-							provider: context.provider,
-							config: context.config
-						})
-					}],
 					on: {
 						DETECTION_UPDATE: { actions: assign({ detectionStatus: ({ event }) => event.status }) },
 						DETECTION_FRAME: { actions: assign({ debugFrame: ({ event }) => event.frame }) },
@@ -897,7 +1010,9 @@ const _selfieMachine = setup({
 						return {
 							canvas,
 							faceCoordinates: context.faceCoordinates,
-							deepsightService: context.deepsightService
+							deepsightService: context.deepsightService,
+							dependencies: context.dependencies,
+							recordingService: context.recordingService
 						};
 					},
 					onDone: {
@@ -918,12 +1033,16 @@ const _selfieMachine = setup({
 					actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
 				}, { target: "success" }] },
 				uploadError: { on: { RETRY_CAPTURE: {
-					target: "detecting",
+					target: "checkingStream",
 					guard: "hasAttemptsRemaining",
-					actions: ["resetDetection", "clearUploadFailure"]
+					actions: [
+						"resetDetection",
+						"clearUploadFailure",
+						"clearStreamForRetry"
+					]
 				} } },
 				success: {
-					entry: "stopMediaRecording",
+					entry: "cleanup",
 					after: { 3e3: { target: "#selfie.processing" } }
 				}
 			}
@@ -939,10 +1058,7 @@ const _selfieMachine = setup({
 		} },
 		finished: {
 			entry: "stopMediaStream",
-			on: { RESET: {
-				target: "idle",
-				actions: "resetContext"
-			} }
+			type: "final"
 		},
 		closed: {
 			entry: "stopMediaStream",
@@ -968,7 +1084,14 @@ const selfieMachine = _selfieMachine;
 //#endregion
 //#region src/modules/selfie/selfieActor.ts
 function createSelfieActor(options) {
-	return createActor(selfieMachine, { input: { config: options.config } }).start();
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieMachine, { input: {
+		config: options.config,
+		dependencies
+	} }).start();
 }
 
 //#endregion