@incodetech/core 0.0.0-dev-20260313-486e658 → 0.0.0-dev-20260313-bc2dab4

package/dist/Actor-BAf9LRYf.d.ts

@@ -0,0 +1,2 @@
+import { ActorRefFrom, createActor } from "xstate";
+export { createActor as n, ActorRefFrom as t };

package/dist/StateMachine-DJpZF_HP.d.ts

@@ -0,0 +1,2 @@
+import { AnyStateMachine, StateMachine, fromPromise } from "xstate";
+export { StateMachine as n, fromPromise as r, AnyStateMachine as t };

package/dist/authentication.d.ts

@@ -1,79 +1,11 @@
-import "./types-B4KNFqC4.js";
-import "./warmup-Da5qDIWZ.js";
-import { a as FaceCaptureDependencies, n as FaceCaptureManagerState, r as BaseFaceCaptureConfig, t as FaceCaptureManager } from "./faceCaptureManagerFactory-D1NUo68Z.js";
-import { t as Manager } from "./Manager-CG5CQ1kY.js";
-import "./camera-D7zu0Mls.js";
-import { t as ActorRefFrom } from "./Actor-B6Lr-x6S.js";
-import { t as AnyStateMachine } from "./StateMachine-WHeQE3lC.js";
-import "./types-DnrAr9fb.js";
-import { r as FlowModuleConfig } from "./types-Bn54lmeM.js";
-
-//#region src/modules/authentication/authenticationStateMachine.d.ts
-declare const _authenticationMachine: AnyStateMachine;
-type AuthenticationMachine = typeof _authenticationMachine;
-declare const authenticationMachine: AnyStateMachine;
-//#endregion
-//#region src/modules/authentication/types.d.ts
-type AuthenticationConfig = FlowModuleConfig['AUTHENTICATION'] & BaseFaceCaptureConfig;
-//#endregion
-//#region src/modules/authentication/authenticationActor.d.ts
-type CreateAuthenticationActorOptions = {
-  config: AuthenticationConfig;
-  dependencies?: FaceCaptureDependencies;
-  authHint?: string;
-};
-type AuthenticationActor = ActorRefFrom<AuthenticationMachine>;
-declare function createAuthenticationActor(options: CreateAuthenticationActorOptions): AuthenticationActor;
-//#endregion
-//#region src/modules/authentication/authenticationManager.d.ts
-type AuthenticationState = FaceCaptureManagerState;
-/**
- * Creates an authentication manager instance for handling face authentication flow.
- *
- * The authentication manager provides:
- * - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
- * - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
- * - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
- * - Camera stream access when in `capture` state
- * - Detection status feedback during face detection
- * - Attempt tracking with `attemptsRemaining`
- *
- * @param options - Configuration for the authentication actor
- * @param options.config - The authentication module configuration from the flow
- * @param options.authHint - Hint for identifying the user (e.g., phone number, email)
- * @returns A manager instance with state subscription, API methods, and lifecycle controls
- *
- * @example
- * ```ts
- * const authManager = createAuthenticationManager({
- *   config: authConfig,
- *   authHint: 'user@example.com'
- * });
- *
- * authManager.subscribe((state) => {
- *   if (state.status === 'capture') {
- *     console.log('Camera ready:', state.stream);
- *     console.log('Detection status:', state.detectionStatus);
- *   }
- *   if (state.status === 'finished') {
- *     console.log('Authentication successful!');
- *   }
- * });
- *
- * authManager.load();
- * ```
- */
-declare function createAuthenticationManager(options: CreateAuthenticationActorOptions): Manager<FaceCaptureManagerState> & {
-  load(): void;
-  nextStep(): void;
-  requestPermission(): void;
-  goToLearnMore(): void;
-  back(): void;
-  close(): void;
-  reset(): void;
-  retryCapture(): void;
-  capture(): void;
-};
-type AuthenticationManager = FaceCaptureManager;
-//#endregion
+import "./deepsightService-UhtHJCFb.js";
+import { g as AuthenticationConfig, h as createAuthenticationActor, m as CreateAuthenticationActorOptions, p as AuthenticationActor, y as authenticationMachine } from "./faceCaptureManagerFactory-CiQWYHp2.js";
+import "./warmup-Bp_1oXoL.js";
+import "./Manager-CXnC-tN_.js";
+import "./camera-DDn9ILon.js";
+import "./Actor-BAf9LRYf.js";
+import "./StateMachine-DJpZF_HP.js";
+import "./types-BugcSDaO.js";
+import "./types-C9Jo2XOb.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-DQL9XsaI.js";
 export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authentication.esm.js

@@ -1,197 +1,13 @@
-import { d as addEvent, n as eventModuleNames } from "./events-b4_xvENs.esm.js";
-import "./backCameraStream-B57NWDGu.esm.js";
-import { _ as BrowserStorageProvider, a as WasmUtilProvider } from "./src-D3v6I2la.esm.js";
-import { a as createActor, i as fromPromise, n as assign } from "./xstate.esm-07M59Cte.esm.js";
-import { l as getDeviceClass } from "./streamingEvents-CQq5fJCL.esm.js";
-import "./deepsightService-CTK55DG8.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-5sPFFmaB.esm.js";
-import "./stats-D76Thmqp.esm.js";
-import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManager, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-10lCb_yE.esm.js";
+import "./events-3HzCcoEy.esm.js";
+import "./backCameraStream-4aLwsDOv.esm.js";
+import "./src-BmVrWkLJ.esm.js";
+import "./xstate.esm-CcoTezCZ.esm.js";
+import "./streamingEvents-Cw6kqXEh.esm.js";
+import "./deepsightService-BgqD33AH.esm.js";
+import "./api-C2uzxrpN.esm.js";
+import "./endpoints-IAlXA1zN.esm.js";
+import "./stats-kLtQIgsA.esm.js";
+import "./faceCaptureSetup-CF9TJlsc.esm.js";
+import { i as authenticationMachine, r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-4j4j8ac9.esm.js";
 
-//#region src/modules/authentication/authenticationErrorUtils.ts
-const AUTH_ERROR_MAP = {
-	SPOOF_ATTEMPT_DETECTED: FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED,
-	SELFIE_FACE_OCCLUDED: FACE_ERROR_CODES.FACE_OCCLUDED,
-	FACE_OCCLUDED: FACE_ERROR_CODES.FACE_OCCLUDED,
-	FACE_TOO_DARK: FACE_ERROR_CODES.FACE_TOO_DARK,
-	LENSES_DETECTED: FACE_ERROR_CODES.LENSES_DETECTED,
-	FACE_MASK_DETECTED: FACE_ERROR_CODES.FACE_MASK_DETECTED,
-	CLOSED_EYES_DETECTED: FACE_ERROR_CODES.CLOSED_EYES_DETECTED,
-	HEAD_COVER_DETECTED: FACE_ERROR_CODES.HEAD_COVER_DETECTED,
-	FACE_NOT_FOUND: FACE_ERROR_CODES.FACE_NOT_FOUND,
-	FACE_CROPPING_FAILED: FACE_ERROR_CODES.FACE_CROPPING_FAILED,
-	FACE_TOO_SMALL: FACE_ERROR_CODES.FACE_TOO_SMALL,
-	FACE_TOO_BLURRY: FACE_ERROR_CODES.FACE_TOO_BLURRY,
-	BAD_PHOTO_QUALITY: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
-	PROCESSING_ERROR: FACE_ERROR_CODES.PROCESSING_ERROR,
-	BAD_REQUEST: FACE_ERROR_CODES.BAD_REQUEST,
-	SERVER: FACE_ERROR_CODES.SERVER,
-	USER_IS_NOT_RECOGNIZED: FACE_ERROR_CODES.USER_IS_NOT_RECOGNIZED,
-	NONEXISTENT_CUSTOMER: FACE_ERROR_CODES.NONEXISTENT_CUSTOMER,
-	HINT_NOT_PROVIDED: FACE_ERROR_CODES.HINT_NOT_PROVIDED
-};
-const TERMINAL_AUTH_ERROR_CODES = [FACE_ERROR_CODES.NONEXISTENT_CUSTOMER, FACE_ERROR_CODES.HINT_NOT_PROVIDED];
-const validateAuthUploadResponse = (response) => {
-	if (!response) return FACE_ERROR_CODES.SERVER;
-	if (response.overallStatus !== "PASS") return AUTH_ERROR_MAP[response.error?.name] ?? FACE_ERROR_CODES.SERVER;
-};
-const isTerminalAuthError = (response, attemptsRemaining) => {
-	if (!response) return false;
-	const mappedError = AUTH_ERROR_MAP[response.error?.name];
-	if (mappedError && TERMINAL_AUTH_ERROR_CODES.includes(mappedError)) return true;
-	if (attemptsRemaining <= 0) return true;
-	return false;
-};
-
-//#endregion
-//#region src/modules/authentication/authenticationUploadService.ts
-async function uploadAuthFace(params) {
-	try {
-		const payload = {
-			base64Image: params.encryptedBase64Image,
-			faceCoordinates: params.faceCoordinates ?? void 0,
-			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() },
-			metadata: params.metadata ?? void 0,
-			...params.authHint !== void 0 && { hint: params.authHint }
-		};
-		const query = {};
-		if (params.recordingId) query.recordingId = params.recordingId;
-		const res = await api.post(endpoints.authenticate, payload, {
-			signal: params.signal,
-			query
-		});
-		if (!res.ok) throw new Error(`POST ${endpoints.authenticate} failed: ${res.status} ${res.statusText}`);
-		return res.data;
-	} catch (error) {
-		const errorCode = getAuthErrorCodeFromHttpError(error);
-		if (errorCode) throw new Error(errorCode);
-		throw new Error(FACE_ERROR_CODES.SERVER);
-	}
-}
-const getAuthErrorCodeFromHttpError = (error) => {
-	const err = error;
-	if (err.ok !== false || typeof err.status !== "number") return;
-	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
-	const errorName = err.data?.error?.name;
-	if (!errorName) return FACE_ERROR_CODES.BAD_REQUEST;
-	return AUTH_ERROR_MAP[errorName] ?? FACE_ERROR_CODES.BAD_REQUEST;
-};
-
-//#endregion
-//#region src/modules/authentication/authenticationStateMachine.ts
-const _authenticationMachine = faceCaptureMachine.provide({
-	actors: {
-		uploadFace: fromPromise(async ({ input, signal }) => {
-			const ctx = input;
-			return uploadAuthFace({
-				encryptedBase64Image: ctx.encryptedBase64Image,
-				faceCoordinates: ctx.faceCoordinates,
-				authHint: ctx.authHint,
-				metadata: ctx.deepsightService?.getMetadata(),
-				recordingId: ctx.uploadRecordingId,
-				signal
-			});
-		}),
-		processFace: fromPromise(async () => ({}))
-	},
-	actions: {
-		trackContinue: () => {
-			addEvent({
-				code: FACE_CAPTURE_EVENT_CODES.CONTINUE,
-				module: eventModuleNames.authentication
-			});
-		},
-		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => {
-			const resp = context.uploadResponse;
-			return validateAuthUploadResponse(resp) ?? FACE_ERROR_CODES.SERVER;
-		} }),
-		setTerminalError: assign({ error: ({ context }) => {
-			const resp = context.uploadResponse;
-			if (context.attemptsRemaining <= 0) return {
-				type: "FACE_AUTH_ERROR",
-				message: "No more attempts remaining"
-			};
-			if (!resp) return {
-				type: "FACE_AUTH_ERROR",
-				message: "Authentication failed"
-			};
-			return {
-				type: "FACE_AUTH_ERROR",
-				message: resp.error?.message ?? resp.error?.name ?? "Face authentication error"
-			};
-		} })
-	},
-	guards: {
-		hasUploadValidationError: ({ context }) => {
-			const resp = context.uploadResponse;
-			return validateAuthUploadResponse(resp) !== void 0;
-		},
-		isTerminalUploadError: ({ context }) => {
-			const resp = context.uploadResponse;
-			return isTerminalAuthError(resp, context.attemptsRemaining);
-		},
-		isNoAttemptsTerminal: () => true
-	}
-});
-const authenticationMachine = _authenticationMachine;
-
-//#endregion
-//#region src/modules/authentication/authenticationActor.ts
-function createAuthenticationActor(options) {
-	const dependencies = options.dependencies ?? {
-		storage: new BrowserStorageProvider(),
-		getWasmUtil: () => WasmUtilProvider.getInstance()
-	};
-	return createActor(authenticationMachine, { input: {
-		config: options.config,
-		dependencies,
-		authHint: options.authHint
-	} }).start();
-}
-
-//#endregion
-//#region src/modules/authentication/authenticationManager.ts
-/**
-* Creates an authentication manager instance for handling face authentication flow.
-*
-* The authentication manager provides:
-* - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
-* - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
-* - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
-* - Camera stream access when in `capture` state
-* - Detection status feedback during face detection
-* - Attempt tracking with `attemptsRemaining`
-*
-* @param options - Configuration for the authentication actor
-* @param options.config - The authentication module configuration from the flow
-* @param options.authHint - Hint for identifying the user (e.g., phone number, email)
-* @returns A manager instance with state subscription, API methods, and lifecycle controls
-*
-* @example
-* ```ts
-* const authManager = createAuthenticationManager({
-*   config: authConfig,
-*   authHint: 'user@example.com'
-* });
-*
-* authManager.subscribe((state) => {
-*   if (state.status === 'capture') {
-*     console.log('Camera ready:', state.stream);
-*     console.log('Detection status:', state.detectionStatus);
-*   }
-*   if (state.status === 'finished') {
-*     console.log('Authentication successful!');
-*   }
-* });
-*
-* authManager.load();
-* ```
-*/
-function createAuthenticationManager(options) {
-	return createFaceCaptureManager(createAuthenticationActor(options));
-}
-
-//#endregion
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authenticationManager-4j4j8ac9.esm.js

@@ -0,0 +1,197 @@
+import { d as addEvent, n as eventModuleNames } from "./events-3HzCcoEy.esm.js";
+import { _ as BrowserStorageProvider, a as WasmUtilProvider } from "./src-BmVrWkLJ.esm.js";
+import { a as createActor, i as fromPromise, n as assign } from "./xstate.esm-CcoTezCZ.esm.js";
+import { l as getDeviceClass } from "./streamingEvents-Cw6kqXEh.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
+import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManagerFromActor, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-CF9TJlsc.esm.js";
+
+//#region src/modules/authentication/authenticationErrorUtils.ts
+const AUTH_ERROR_MAP = {
+	SPOOF_ATTEMPT_DETECTED: FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED,
+	SELFIE_FACE_OCCLUDED: FACE_ERROR_CODES.FACE_OCCLUDED,
+	FACE_OCCLUDED: FACE_ERROR_CODES.FACE_OCCLUDED,
+	FACE_TOO_DARK: FACE_ERROR_CODES.FACE_TOO_DARK,
+	LENSES_DETECTED: FACE_ERROR_CODES.LENSES_DETECTED,
+	FACE_MASK_DETECTED: FACE_ERROR_CODES.FACE_MASK_DETECTED,
+	CLOSED_EYES_DETECTED: FACE_ERROR_CODES.CLOSED_EYES_DETECTED,
+	HEAD_COVER_DETECTED: FACE_ERROR_CODES.HEAD_COVER_DETECTED,
+	FACE_NOT_FOUND: FACE_ERROR_CODES.FACE_NOT_FOUND,
+	FACE_CROPPING_FAILED: FACE_ERROR_CODES.FACE_CROPPING_FAILED,
+	FACE_TOO_SMALL: FACE_ERROR_CODES.FACE_TOO_SMALL,
+	FACE_TOO_BLURRY: FACE_ERROR_CODES.FACE_TOO_BLURRY,
+	BAD_PHOTO_QUALITY: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
+	PROCESSING_ERROR: FACE_ERROR_CODES.PROCESSING_ERROR,
+	BAD_REQUEST: FACE_ERROR_CODES.BAD_REQUEST,
+	SERVER: FACE_ERROR_CODES.SERVER,
+	USER_IS_NOT_RECOGNIZED: FACE_ERROR_CODES.USER_IS_NOT_RECOGNIZED,
+	NONEXISTENT_CUSTOMER: FACE_ERROR_CODES.NONEXISTENT_CUSTOMER,
+	HINT_NOT_PROVIDED: FACE_ERROR_CODES.HINT_NOT_PROVIDED
+};
+const TERMINAL_AUTH_ERROR_CODES = [FACE_ERROR_CODES.NONEXISTENT_CUSTOMER, FACE_ERROR_CODES.HINT_NOT_PROVIDED];
+const validateAuthUploadResponse = (response) => {
+	if (!response) return FACE_ERROR_CODES.SERVER;
+	if (response.overallStatus !== "PASS") return AUTH_ERROR_MAP[response.error?.name] ?? FACE_ERROR_CODES.SERVER;
+};
+const isTerminalAuthError = (response, attemptsRemaining) => {
+	if (!response) return false;
+	const mappedError = AUTH_ERROR_MAP[response.error?.name];
+	if (mappedError && TERMINAL_AUTH_ERROR_CODES.includes(mappedError)) return true;
+	if (attemptsRemaining <= 0) return true;
+	return false;
+};
+
+//#endregion
+//#region src/modules/authentication/authenticationUploadService.ts
+async function uploadAuthFace(params) {
+	try {
+		const payload = {
+			base64Image: params.encryptedBase64Image,
+			faceCoordinates: params.faceCoordinates ?? void 0,
+			encrypted: true,
+			clientInfo: { deviceClass: getDeviceClass() },
+			metadata: params.metadata ?? void 0,
+			...params.authHint !== void 0 && { hint: params.authHint }
+		};
+		const query = {};
+		if (params.recordingId) query.recordingId = params.recordingId;
+		const res = await api.post(endpoints.authenticate, payload, {
+			signal: params.signal,
+			query
+		});
+		if (!res.ok) throw new Error(`POST ${endpoints.authenticate} failed: ${res.status} ${res.statusText}`);
+		return res.data;
+	} catch (error) {
+		const errorCode = getAuthErrorCodeFromHttpError(error);
+		if (errorCode) throw new Error(errorCode);
+		throw new Error(FACE_ERROR_CODES.SERVER);
+	}
+}
+const getAuthErrorCodeFromHttpError = (error) => {
+	const err = error;
+	if (err.ok !== false || typeof err.status !== "number") return;
+	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
+	const errorName = err.data?.error?.name;
+	if (!errorName) return FACE_ERROR_CODES.BAD_REQUEST;
+	return AUTH_ERROR_MAP[errorName] ?? FACE_ERROR_CODES.BAD_REQUEST;
+};
+
+//#endregion
+//#region src/modules/authentication/authenticationStateMachine.ts
+const _authenticationMachine = faceCaptureMachine.provide({
+	actors: {
+		uploadFace: fromPromise(async ({ input, signal }) => {
+			const ctx = input;
+			return uploadAuthFace({
+				encryptedBase64Image: ctx.encryptedBase64Image,
+				faceCoordinates: ctx.faceCoordinates,
+				authHint: ctx.authHint,
+				metadata: ctx.deepsightService?.getMetadata(),
+				recordingId: ctx.uploadRecordingId,
+				signal
+			});
+		}),
+		processFace: fromPromise(async () => ({}))
+	},
+	actions: {
+		trackContinue: () => {
+			addEvent({
+				code: FACE_CAPTURE_EVENT_CODES.CONTINUE,
+				module: eventModuleNames.authentication
+			});
+		},
+		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => {
+			const resp = context.uploadResponse;
+			return validateAuthUploadResponse(resp) ?? FACE_ERROR_CODES.SERVER;
+		} }),
+		setTerminalError: assign({ error: ({ context }) => {
+			const resp = context.uploadResponse;
+			if (context.attemptsRemaining <= 0) return {
+				type: "FACE_AUTH_ERROR",
+				message: "No more attempts remaining"
+			};
+			if (!resp) return {
+				type: "FACE_AUTH_ERROR",
+				message: "Authentication failed"
+			};
+			return {
+				type: "FACE_AUTH_ERROR",
+				message: resp.error?.message ?? resp.error?.name ?? "Face authentication error"
+			};
+		} })
+	},
+	guards: {
+		hasUploadValidationError: ({ context }) => {
+			const resp = context.uploadResponse;
+			return validateAuthUploadResponse(resp) !== void 0;
+		},
+		isTerminalUploadError: ({ context }) => {
+			const resp = context.uploadResponse;
+			return isTerminalAuthError(resp, context.attemptsRemaining);
+		},
+		isNoAttemptsTerminal: () => true
+	}
+});
+const authenticationMachine = _authenticationMachine;
+
+//#endregion
+//#region src/modules/authentication/authenticationActor.ts
+function createAuthenticationActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(authenticationMachine, { input: {
+		config: options.config,
+		dependencies,
+		authHint: options.authHint
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/authentication/authenticationManager.ts
+function createAuthenticationManagerFromActor(actor) {
+	return createFaceCaptureManagerFromActor(actor);
+}
+/**
+* Creates an authentication manager instance for handling face authentication flow.
+*
+* The authentication manager provides:
+* - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+* - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+* - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+* - Camera stream access when in `capture` state
+* - Detection status feedback during face detection
+* - Attempt tracking with `attemptsRemaining`
+*
+* @param options - Configuration for the authentication actor
+* @param options.config - The authentication module configuration from the flow
+* @param options.authHint - Hint for identifying the user (e.g., phone number, email)
+* @returns A manager instance with state subscription, API methods, and lifecycle controls
+*
+* @example
+* ```ts
+* const authManager = createAuthenticationManager({
+*   config: authConfig,
+*   authHint: 'user@example.com'
+* });
+*
+* authManager.subscribe((state) => {
+*   if (state.status === 'capture') {
+*     console.log('Camera ready:', state.stream);
+*     console.log('Detection status:', state.detectionStatus);
+*   }
+*   if (state.status === 'finished') {
+*     console.log('Authentication successful!');
+*   }
+* });
+*
+* authManager.load();
+* ```
+*/
+function createAuthenticationManager(options) {
+	return createFaceCaptureManagerFromActor(createAuthenticationActor(options));
+}
+
+//#endregion
+export { authenticationMachine as i, createAuthenticationManagerFromActor as n, createAuthenticationActor as r, createAuthenticationManager as t };

package/dist/authenticationManager-DQL9XsaI.d.ts

@@ -0,0 +1,66 @@
+import { m as CreateAuthenticationActorOptions, n as FaceCaptureManagerState, p as AuthenticationActor, t as FaceCaptureManager } from "./faceCaptureManagerFactory-CiQWYHp2.js";
+import { t as Manager } from "./Manager-CXnC-tN_.js";
+
+//#region src/modules/authentication/authenticationManager.d.ts
+type AuthenticationState = FaceCaptureManagerState;
+declare function createAuthenticationManagerFromActor(actor: AuthenticationActor): Manager<FaceCaptureManagerState> & {
+  load(): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  capture(): void;
+};
+/**
+ * Creates an authentication manager instance for handling face authentication flow.
+ *
+ * The authentication manager provides:
+ * - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+ * - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+ * - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+ * - Camera stream access when in `capture` state
+ * - Detection status feedback during face detection
+ * - Attempt tracking with `attemptsRemaining`
+ *
+ * @param options - Configuration for the authentication actor
+ * @param options.config - The authentication module configuration from the flow
+ * @param options.authHint - Hint for identifying the user (e.g., phone number, email)
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const authManager = createAuthenticationManager({
+ *   config: authConfig,
+ *   authHint: 'user@example.com'
+ * });
+ *
+ * authManager.subscribe((state) => {
+ *   if (state.status === 'capture') {
+ *     console.log('Camera ready:', state.stream);
+ *     console.log('Detection status:', state.detectionStatus);
+ *   }
+ *   if (state.status === 'finished') {
+ *     console.log('Authentication successful!');
+ *   }
+ * });
+ *
+ * authManager.load();
+ * ```
+ */
+declare function createAuthenticationManager(options: CreateAuthenticationActorOptions): Manager<FaceCaptureManagerState> & {
+  load(): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  capture(): void;
+};
+type AuthenticationManager = FaceCaptureManager;
+//#endregion
+export { createAuthenticationManagerFromActor as i, AuthenticationState as n, createAuthenticationManager as r, AuthenticationManager as t };

package/dist/{backCameraStream-B57NWDGu.esm.js → backCameraStream-4aLwsDOv.esm.js}

@@ -1,4 +1,4 @@
-import { B as isSafari, D as enumerateVideoDevices, E as applyTrackConstraints, F as isAndroid, L as isIOS, O as requestCameraAccess, k as stopCameraStream, z as isIPhone14OrHigher } from "./src-D3v6I2la.esm.js";
+import { B as isSafari, D as enumerateVideoDevices, E as applyTrackConstraints, F as isAndroid, L as isIOS, O as requestCameraAccess, k as stopCameraStream, z as isIPhone14OrHigher } from "./src-BmVrWkLJ.esm.js";
 
 //#region ../infra/src/capabilities/ITimerCapability.ts
 function sleep(ms) {

package/dist/curp-validation.d.ts

@@ -1,7 +1,7 @@
-import { t as Manager } from "./Manager-CG5CQ1kY.js";
-import "./camera-D7zu0Mls.js";
-import "./types-DnrAr9fb.js";
-import { r as FlowModuleConfig } from "./types-Bn54lmeM.js";
+import { t as Manager } from "./Manager-CXnC-tN_.js";
+import "./camera-DDn9ILon.js";
+import "./types-BugcSDaO.js";
+import { r as FlowModuleConfig } from "./types-C9Jo2XOb.js";
 
 //#region src/modules/curp-validation/types.d.ts
 type CurpValidationConfig = FlowModuleConfig['CURP_VALIDATION'] & {

package/dist/curp-validation.esm.js

@@ -1,8 +1,8 @@
-import { n as eventModuleNames, r as eventScreenNames, u as screenOpened } from "./events-b4_xvENs.esm.js";
-import { A as createManager } from "./src-D3v6I2la.esm.js";
-import { a as createActor, i as fromPromise, n as assign, t as setup } from "./xstate.esm-07M59Cte.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-5sPFFmaB.esm.js";
+import { n as eventModuleNames, r as eventScreenNames, u as screenOpened } from "./events-3HzCcoEy.esm.js";
+import { A as createManager } from "./src-BmVrWkLJ.esm.js";
+import { a as createActor, i as fromPromise, n as assign, t as setup } from "./xstate.esm-CcoTezCZ.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
 
 //#region src/modules/curp-validation/curpValidationUtils.ts
 const CURP_PATTERN = /^([A-Z][AEIOUX][A-Z]{2}\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])[HMX](?:AS|B[CS]|C[CLMSH]|D[FG]|G[TR]|HG|JC|M[CNS]|N[ETL]|OC|PL|Q[TR]|S[PLR]|T[CSL]|VZ|YN|ZS)[B-DF-HJ-NP-TV-Z]{3}[A-Z\d])(\d)$/;

package/dist/{deepsightLoader-BXTRzhYx.esm.js → deepsightLoader-C-Xil8cg.esm.js}

@@ -1,7 +1,7 @@
-import { a as WasmUtilProvider, f as MotionSensorProvider, l as VisibilityProvider, y as BrowserEnvironmentProvider } from "./src-D3v6I2la.esm.js";
-import { t as createDeepsightService } from "./deepsightService-CTK55DG8.esm.js";
-import "./api-3fZO5bmj.esm.js";
-import "./stats-D76Thmqp.esm.js";
+import { a as WasmUtilProvider, f as MotionSensorProvider, l as VisibilityProvider, y as BrowserEnvironmentProvider } from "./src-BmVrWkLJ.esm.js";
+import { t as createDeepsightService } from "./deepsightService-BgqD33AH.esm.js";
+import "./api-C2uzxrpN.esm.js";
+import "./stats-kLtQIgsA.esm.js";
 
 //#region src/internal/deepsight/deepsightLoader.ts
 const SDK_VERSION = "2.0.0";

package/dist/{deepsightService-CTK55DG8.esm.js → deepsightService-BgqD33AH.esm.js}

@@ -1,6 +1,6 @@
-import { M as getDeviceInfo, O as requestCameraAccess, P as getUserAgent, T as IncodeCanvas, k as stopCameraStream, w as createHiddenVideoElement } from "./src-D3v6I2la.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as addDeviceStats } from "./stats-D76Thmqp.esm.js";
+import { M as getDeviceInfo, O as requestCameraAccess, P as getUserAgent, T as IncodeCanvas, k as stopCameraStream, w as createHiddenVideoElement } from "./src-BmVrWkLJ.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as addDeviceStats } from "./stats-kLtQIgsA.esm.js";
 
 //#region src/internal/device/browserSimulation.ts
 const AUTOMATION_MARKERS = {