@incodetech/core 0.0.0-dev-20260206-4cf3405 → 0.0.0-dev-20260209-c0e857b

package/dist/Actor-uC1hxvGo.d.ts

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

package/dist/{OpenViduLogger-DrE4_cHh.esm.js → OpenViduLogger-Cut9zn-U.esm.js}

@@ -1,4 +1,4 @@
-import { t as __commonJS } from "./chunk-CiY78uGR.esm.js";
+import { t as __commonJS } from "./chunk-CbPq_V01.esm.js";
 
 //#region ../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js
 var require_jsnlog = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js": ((exports) => {

package/dist/OpenViduLogger-D_YCgaLD.esm.js

@@ -0,0 +1,3 @@
+import { t as require_OpenViduLogger } from "./OpenViduLogger-Cut9zn-U.esm.js";
+
+export default require_OpenViduLogger();

package/dist/authentication.d.ts

@@ -0,0 +1,75 @@
+import "./types-u31qr1MR.js";
+import { a as AnyStateMachine, r as FlowModuleConfig } from "./types-Dc1nBvy2.js";
+import { a as FaceCaptureDependencies, n as FaceCaptureManagerState, r as BaseFaceCaptureConfig, t as FaceCaptureManager } from "./faceCaptureManagerFactory-CZgmP4pc.js";
+import { t as Manager } from "./Manager-BiAYYF50.js";
+import { t as ActorRefFrom } from "./Actor-uC1hxvGo.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
+export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authentication.esm.js

@@ -0,0 +1,194 @@
+import { d as addEvent, n as eventModuleNames } from "./events-CieIKgPk.esm.js";
+import { m as BrowserStorageProvider, r as WasmUtilProvider } from "./src-BFHUdMI6.esm.js";
+import { a as fromPromise, o as createActor, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
+import { c as getDeviceClass } from "./streamingEvents-DM6KFfsz.esm.js";
+import "./deepsightService-DLabZ49g.esm.js";
+import { t as api } from "./api-Cqrn4bGi.esm.js";
+import "./stats-DuS7aVaJ.esm.js";
+import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManager, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-DRbBF7AJ.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,
+			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);
+		}
+	}
+});
+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/{deepsightLoader-CHzDt5p2.esm.js → deepsightLoader-DHzfMqHS.esm.js}

@@ -1,7 +1,7 @@
-import { g as BrowserEnvironmentProvider, l as MotionSensorProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-B0UBQ8zw.esm.js";
-import { t as createDeepsightService } from "./deepsightService-C_AyxXhJ.esm.js";
-import "./api-BkkE6cfa.esm.js";
-import "./stats-CpcCA-Ml.esm.js";
+import { g as BrowserEnvironmentProvider, l as MotionSensorProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-BFHUdMI6.esm.js";
+import { t as createDeepsightService } from "./deepsightService-DLabZ49g.esm.js";
+import "./api-Cqrn4bGi.esm.js";
+import "./stats-DuS7aVaJ.esm.js";
 
 //#region src/internal/deepsight/deepsightLoader.ts
 const SDK_VERSION = "2.0.0";

package/dist/{deepsightService-D8qaikEi.d.ts → deepsightService-D9Isk8fg.d.ts}

@@ -1,4 +1,5 @@
-import { s as WasmPipeline } from "./types-BHcijCvX.js";
+import { r as CameraStream } from "./types-u31qr1MR.js";
+import { s as WasmPipeline } from "./types-Dc1nBvy2.js";
 
 //#region ../infra/src/media/canvas.d.ts
 /**
@@ -111,61 +112,8 @@ declare class IncodeCanvas {
   getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
 }
 //#endregion
-//#region ../infra/src/capabilities/IMLProviderCapability.d.ts
-/**
- * Base configuration shared by all ML provider capabilities.
- */
-interface MLProviderConfig {
-  /** Path to the WASM binary */
-  wasmPath?: string;
-  /** Path to the SIMD-optimized WASM binary (optional) */
-  wasmSimdPath?: string;
-  /** Path to the WASM glue code */
-  glueCodePath?: string;
-  /** Whether to use SIMD optimizations (default: true) */
-  useSimd?: boolean;
-  /**
-   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
-   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
-   */
-  modelsBasePath?: string;
-}
-/**
- * Base interface for ML provider capabilities.
- * Provides common lifecycle and frame processing methods shared by
- * FaceDetectionCapability and IdCaptureCapability.
- */
-interface IMLProviderCapability<TConfig extends MLProviderConfig> {
-  /**
-   * Whether the provider has been initialized and is ready to process frames.
-   */
-  readonly initialized: boolean;
-  /**
-   * Initializes the provider with the given configuration.
-   * If WASM was already warmed up via `setup()` or `warmupWasm()`, this returns almost instantly.
-   * @param config - Provider configuration including WASM paths
-   */
-  initialize(config: TConfig): Promise<void>;
-  /**
-   * Processes a frame through the ML pipeline.
-   * Callbacks set via `setCallbacks()` will be invoked based on the analysis results.
-   * @param image - Image data to process
-   * @throws Error if provider is not initialized
-   */
-  processFrame(image: ImageData): Promise<void>;
-  /**
-   * Resets the pipeline to its initial state.
-   * Safe to call even if not initialized (no-op in that case).
-   */
-  reset(): void;
-  /**
-   * Disposes of resources and resets initialization state.
-   * Safe to call even if not initialized.
-   */
-  dispose(): Promise<void>;
-}
-//#endregion
 //#region ../infra/src/capabilities/IMotionSensorCapability.d.ts
+
 type MotionStatus = 'PASS' | 'FAIL' | 'UNCLEAR';
 type MotionPermissionState = 'granted' | 'denied' | 'not-required';
 type IMotionSensorCapability = {
@@ -177,80 +125,6 @@ type IMotionSensorCapability = {
   readonly hasPermission: boolean;
 };
 //#endregion
-//#region ../infra/src/capabilities/IRecordingCapability.d.ts
-type RecordingPublisher = {
-  getStreamId: () => string | undefined;
-  replaceVideoTrack: (track: MediaStreamTrack) => Promise<void>;
-  destroy: () => void;
-};
-type RecordingConnection = {
-  sessionId: string | undefined;
-  publisher: RecordingPublisher;
-  disconnect: () => Promise<void>;
-};
-type RecordingConnectionEvents = {
-  onSessionConnected?: (sessionId: string | undefined) => void;
-  onSessionDisconnected?: (sessionId: string | undefined) => void;
-  onSessionException?: (params: {
-    name?: string;
-    message?: string;
-    sessionId?: string;
-  }) => void;
-  onPublisherCreated?: (params: {
-    streamId?: string;
-    sessionId?: string;
-  }) => void;
-  onPublisherError?: (params: {
-    message?: string;
-    sessionId?: string;
-    streamId?: string;
-  }) => void;
-};
-type ConnectRecordingParams = {
-  sessionToken: string;
-  stream: MediaStream;
-  events?: RecordingConnectionEvents;
-};
-type IRecordingCapability = {
-  /**
-   * Connects to a recording session and publishes the provided media stream.
-   * Returns a connection handle that can be disconnected and used to manage the publisher.
-   */
-  connect: (params: ConnectRecordingParams) => Promise<RecordingConnection>;
-};
-//#endregion
-//#region ../infra/src/capabilities/IStorageCapability.d.ts
-/**
- * Storage capability interface for abstracting storage operations.
- * Enables swapping between browser localStorage and future WASM-based storage.
- */
-interface IStorageCapability {
-  /**
-   * Retrieves a value from storage.
-   * @param key - The storage key
-   * @returns The stored value or null if not found
-   */
-  get<T>(key: string): Promise<T | null>;
-  /**
-   * Stores a value in storage.
-   * @param key - The storage key
-   * @param value - The value to store (will be serialized)
-   */
-  set<T>(key: string, value: T): Promise<void>;
-  /**
-   * Removes a value from storage.
-   * @param key - The storage key to remove
-   */
-  remove(key: string): Promise<void>;
-  /**
-   * Clears all values from storage.
-   */
-  clear(): Promise<void>;
-}
-//#endregion
-//#region ../infra/src/media/camera.d.ts
-type CameraStream = MediaStream;
-//#endregion
 //#region ../infra/src/media/StreamCanvasCapture.d.ts
 type StreamCanvasCaptureOptions = {
   fps?: number;
@@ -366,10 +240,6 @@ declare abstract class BaseWasmProvider {
   dispose(): Promise<void>;
 }
 //#endregion
-//#region src/internal/permissions/types.d.ts
-type PermissionResult = 'granted' | 'denied' | 'prompt';
-type PermissionStatus = 'idle' | 'requesting' | 'denied' | 'learnMore';
-//#endregion
 //#region src/internal/deepsight/metadataService.d.ts
 type MetadataService = {
   initialize(sdkVersion: string, disableIpify?: boolean): Promise<void>;
@@ -430,4 +300,4 @@ type DeepsightPrcCheckParams = {
   constraints: MediaStreamConstraints;
 };
 //#endregion
-export { StreamCanvasCapture as a, IRecordingCapability as c, IMLProviderCapability as d, MLProviderConfig as f, BaseWasmProvider as i, RecordingConnection as l, PermissionResult as n, CameraStream as o, IncodeCanvas as p, PermissionStatus as r, IStorageCapability as s, DeepsightService as t, IMotionSensorCapability as u };
+export { IncodeCanvas as a, IMotionSensorCapability as i, BaseWasmProvider as n, StreamCanvasCapture as r, DeepsightService as t };

package/dist/{deepsightService-C_AyxXhJ.esm.js → deepsightService-DLabZ49g.esm.js}

@@ -1,6 +1,6 @@
-import { A as getUserAgent, O as getDeviceInfo, T as stopCameraStream, b as createHiddenVideoElement, w as requestCameraAccess, x as IncodeCanvas } from "./src-B0UBQ8zw.esm.js";
-import { t as api } from "./api-BkkE6cfa.esm.js";
-import { t as addDeviceStats } from "./stats-CpcCA-Ml.esm.js";
+import { A as getUserAgent, O as getDeviceInfo, T as stopCameraStream, b as createHiddenVideoElement, w as requestCameraAccess, x as IncodeCanvas } from "./src-BFHUdMI6.esm.js";
+import { t as api } from "./api-Cqrn4bGi.esm.js";
+import { t as addDeviceStats } from "./stats-DuS7aVaJ.esm.js";
 
 //#region src/internal/device/browserSimulation.ts
 const AUTOMATION_MARKERS = {

package/dist/email.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-CWwvSZqZ.js";
+import { t as Manager } from "./Manager-BiAYYF50.js";
 
 //#region src/modules/email/types.d.ts
 

package/dist/email.esm.js

@@ -1,7 +1,7 @@
-import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-BN5bIhsN.esm.js";
-import { E as createManager, p as BrowserTimerProvider } from "./src-B0UBQ8zw.esm.js";
-import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-Q2cBwc8v.esm.js";
-import { t as api } from "./api-BkkE6cfa.esm.js";
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-CieIKgPk.esm.js";
+import { E as createManager, p as BrowserTimerProvider } from "./src-BFHUdMI6.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
+import { t as api } from "./api-Cqrn4bGi.esm.js";
 
 //#region src/modules/email/emailServices.ts
 async function fetchEmail(signal) {

package/dist/{endpoints-Q2cBwc8v.esm.js → endpoints-CJtl25ka.esm.js}

@@ -3264,6 +3264,7 @@ const endpoints = {
 	flow: "/omni/onboarding/flow",
 	events: "/omni/interview-events",
 	selfie: "/omni/add/face",
+	authenticate: "/omni/onboarding-authentications/authenticate",
 	recordingCreateSessionV2: "/omni/recordings/create-session/v2",
 	recordingStartV2: "/omni/recordings/record-start/v2",
 	recordingStopV2: "/omni/recordings/record-stop/v2",

package/dist/{events-BN5bIhsN.esm.js → events-CieIKgPk.esm.js}

@@ -1,5 +1,5 @@
-import { t as endpoints } from "./endpoints-Q2cBwc8v.esm.js";
-import { i as isApiConfigured, r as getToken, t as api } from "./api-BkkE6cfa.esm.js";
+import { t as endpoints } from "./endpoints-CJtl25ka.esm.js";
+import { i as isApiConfigured, r as getToken, t as api } from "./api-Cqrn4bGi.esm.js";
 
 //#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
 function getTimestamp() {
@@ -123,6 +123,7 @@ function screenClosed(module, screen, payload) {
 //#region src/internal/events/types.ts
 const eventModuleNames = {
 	selfie: "SELFIE",
+	authentication: "AUTHENTICATION",
 	authFace: "AUTH_FACE",
 	mlConsent: "ML_CONSENT",
 	combinedConsent: "COMBINED_CONSENT",

package/dist/face-match.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-CWwvSZqZ.js";
+import { t as Manager } from "./Manager-BiAYYF50.js";
 
 //#region src/modules/face-match/types.d.ts
 

package/dist/face-match.esm.js

@@ -1,7 +1,7 @@
-import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-BN5bIhsN.esm.js";
-import { E as createManager } from "./src-B0UBQ8zw.esm.js";
-import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-Q2cBwc8v.esm.js";
-import { t as api } from "./api-BkkE6cfa.esm.js";
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-CieIKgPk.esm.js";
+import { E as createManager } from "./src-BFHUdMI6.esm.js";
+import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
+import { t as api } from "./api-Cqrn4bGi.esm.js";
 
 //#region src/modules/face-match/faceMatchServices.ts
 /**