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

package/dist/faceCaptureManagerFactory-CiQWYHp2.d.ts

@@ -0,0 +1,610 @@
+import { a as IStorageCapability, d as IncodeCanvas, i as StreamCanvasCapture, l as IMLProviderCapability, n as PermissionResult, o as IRecordingCapability, r as PermissionStatus, t as DeepsightService, u as MLProviderConfig } from "./deepsightService-UhtHJCFb.js";
+import { n as WasmPipeline } from "./warmup-Bp_1oXoL.js";
+import { t as Manager } from "./Manager-CXnC-tN_.js";
+import { t as CameraStream } from "./camera-DDn9ILon.js";
+import { t as ActorRefFrom } from "./Actor-BAf9LRYf.js";
+import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-DJpZF_HP.js";
+import { r as FlowModuleConfig, t as Flow } from "./types-C9Jo2XOb.js";
+
+//#region ../infra/src/capabilities/IFaceDetectionCapability.d.ts
+/**
+ * Configuration for face detection provider.
+ * Extends base ML provider config with face-detection specific options.
+ */
+interface FaceDetectionConfig extends MLProviderConfig {
+  autocaptureInterval?: number;
+}
+interface FacePositionConstraints {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+interface FaceDetectionThresholds {
+  brightnessThreshold: number;
+  blurrinessThreshold: number;
+  tiltRotationAngleThreshold: number;
+  minMagicCropSize: number;
+  autocaptureInterval: number;
+  minFaceQualityScore: number;
+  faceOcclusionThreshold: number;
+}
+interface FaceAttributesThresholds {
+  headwearThreshold: number;
+  lensesThreshold: number;
+  closedEyesThreshold: number;
+  maskThreshold: number;
+}
+interface FaceChecksConfig {
+  lenses: boolean;
+  mask: boolean;
+  closedEyes: boolean;
+  headWear: boolean;
+  occlusion: boolean;
+}
+interface FaceData {
+  rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  rightEye: {
+    x: number;
+    y: number;
+  };
+  leftEye: {
+    x: number;
+    y: number;
+  };
+  noseTip: {
+    x: number;
+    y: number;
+  };
+  rightMouthCorner: {
+    x: number;
+    y: number;
+  };
+  leftMouthCorner: {
+    x: number;
+    y: number;
+  };
+  pitch: number;
+  yaw: number;
+  roll: number;
+}
+type FaceCoordinates = {
+  rightEyeX: number;
+  rightEyeY: number;
+  leftEyeX: number;
+  leftEyeY: number;
+  noseTipX: number;
+  noseTipY: number;
+  rightMouthX: number;
+  rightMouthY: number;
+  mouthX: number;
+  mouthY: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+interface FaceDetectionCallbacks {
+  onFarAway?: () => void;
+  onTooClose?: () => void;
+  onTooManyFaces?: () => void;
+  onNoFace?: () => void;
+  onCapture?: (canvas: IncodeCanvas, faceCoordinates: FaceCoordinates) => void;
+  onGetReady?: () => void;
+  onGetReadyFinished?: () => void;
+  onCenterFace?: () => void;
+  onDark?: () => void;
+  onBlur?: () => void;
+  onFaceAngle?: () => void;
+  onBestShot?: (face: FaceData) => void;
+  onLenses?: () => void;
+  onMask?: () => void;
+  onEyesClosed?: () => void;
+  onHeadWear?: () => void;
+  onSwitchToManualCapture?: () => void;
+  onFaceOccluded?: () => void;
+}
+/**
+ * Capability interface for face detection and selfie capture.
+ * Extends the base ML provider capability with face-detection specific methods.
+ */
+interface IFaceDetectionCapability extends IMLProviderCapability<FaceDetectionConfig> {
+  /**
+   * Sets callbacks for face detection events.
+   * @param callbacks - Object containing callback functions for various detection events
+   */
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  /**
+   * Sets position constraints for face detection.
+   * @param constraints - Bounding box constraints for valid face position
+   */
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  /**
+   * Sets detection thresholds for quality checks.
+   * @param thresholds - Threshold values for various quality metrics
+   */
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  /**
+   * Sets thresholds for face attribute detection.
+   * @param thresholds - Threshold values for attribute detection (headwear, lenses, etc.)
+   */
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  /**
+   * Enables or disables specific face checks.
+   * @param config - Configuration for which checks to enable
+   */
+  setChecksEnabled(config: FaceChecksConfig): void;
+  /**
+   * Sets video selfie mode.
+   * @param enabled - Whether to enable video selfie mode
+   */
+  setVideoSelfieMode(enabled: boolean): void;
+}
+//#endregion
+//#region ../infra/src/capabilities/IWasmUtilCapability.d.ts
+type WasmUtilConfig = MLProviderConfig & {
+  pipelines?: WasmPipeline[];
+};
+type VirtualCameraCheckOutput = {
+  canvas: HTMLCanvasElement | null;
+  itr: boolean | null;
+  skipped: boolean | null;
+};
+type IWasmUtilCapability = {
+  /**
+   * Whether the provider has been initialized and is ready to be used.
+   */
+  readonly initialized: boolean;
+  /**
+   * Initializes the provider with the given configuration.
+   * If WASM was already warmed up via `warmupWasm()`, this returns almost instantly.
+   * @param config - Provider configuration including WASM paths
+   */
+  initialize(config: WasmUtilConfig): Promise<void>;
+  /**
+   * Encrypts a base64 image using the WASM utility API.
+   * @param image - Base64 image string (no data URL prefix)
+   * @returns Encrypted string
+   */
+  encryptImage(image: string): string;
+  setSdkVersion(version: string): void;
+  setSdkPlatform(platform: string): void;
+  setDeviceInfo(deviceInfo: object, overrideExisting?: boolean): void;
+  setBrowserInfo(browserInfo: object, overrideExisting?: boolean): void;
+  setCameraInfo(cameraInfo: object, overrideExisting?: boolean): void;
+  setMotionStatus(status: string): void;
+  setBackgroundMode(backgroundMode: boolean): void;
+  setZc(zc: string): void;
+  setInspectorOpened(opened: boolean): void;
+  getMetadata(): string;
+  analyzeFrame(image: ImageData): Promise<void>;
+  getCheck(): string;
+  /**
+   * Gets the current pipeline state. Must be called before setMotionStatus(),
+   * getCheck(), setBackgroundMode(), and getMetadata() for proper metadata generation.
+   */
+  getPipelineState(): string;
+  estimatePerformance(): string;
+  isVirtualCamera(label: string | null): boolean;
+  prc(): Promise<void>;
+  poc(output: VirtualCameraCheckOutput): Promise<void>;
+  ckvcks(data: ArrayBuffer): void;
+  getVersions(): Promise<unknown>;
+  /**
+   * Disposes of resources and resets initialization state.
+   */
+  dispose(): Promise<void>;
+};
+//#endregion
+//#region ../infra/src/wasm/WasmPipelineType.d.ts
+declare enum WasmPipelineType {
+  IdBlurGlarePipeline = 0,
+  IdBarcodeAndTextQualityPipeline = 1,
+  IdVideoSelfiePipeline = 2,
+  SelfieWithAggregationMetrics = 3,
+  SelfieWithQualityMetrics = 4,
+  IdFaceDetectionPipeline = 5,
+}
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.d.ts
+/**
+ * Base configuration for WASM providers
+ */
+interface BaseWasmConfig {
+  /** 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 provider class that abstracts common WASM functionality.
+ * This serves as a foundation for specific ML capability providers
+ * like FaceDetectionProvider and IdCaptureProvider.
+ */
+declare abstract class BaseWasmProvider {
+  private _isInitialized;
+  protected pipelineType: WasmPipelineType | undefined;
+  /**
+   * Creates a new BaseWasmProvider
+   * @param pipelineType - The WASM pipeline type this provider uses
+   */
+  constructor(pipelineType?: WasmPipelineType);
+  /**
+   * Returns whether this provider has been initialized.
+   */
+  get initialized(): boolean;
+  protected getPipelineType(): WasmPipelineType;
+  /**
+   * Initializes the provider by ensuring WASM is loaded
+   * @param config - Provider configuration
+   * @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+   */
+  protected initializeBase(config: BaseWasmConfig, pipeline: WasmPipeline): Promise<void>;
+  /**
+   * Ensures the provider is initialized before performing operations.
+   * @throws Error if not initialized
+   */
+  protected ensureInitialized(): void;
+  /**
+   * Processes a frame through the WASM pipeline
+   * @param image - Image data to process
+   * @returns The pipeline result (type depends on pipeline - WASM returns any)
+   */
+  protected processFrameWasm(image: ImageData): Promise<any>;
+  abstract 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/providers/wasm/FaceDetectionProvider.d.ts
+declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
+  private defaultThresholds;
+  private currentThresholds;
+  private currentFrame;
+  private bestCanvas;
+  private bestFace;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  applyDefaults(autocaptureInterval?: number): void;
+  setAutocaptureInterval(interval: number): void;
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  setChecksEnabled(config: FaceChecksConfig): void;
+  setVideoSelfieMode(enabled: boolean): void;
+  reset(): void;
+  private createDefaultFaceCoordinates;
+  private formatFaceCoordinates;
+}
+//#endregion
+//#region src/modules/authentication/authenticationStateMachine.d.ts
+declare const _authenticationMachine: AnyStateMachine;
+type AuthenticationMachine = typeof _authenticationMachine;
+declare const authenticationMachine: AnyStateMachine;
+//#endregion
+//#region src/internal/faceCapture/types.d.ts
+type BaseFaceCaptureConfig = {
+  showTutorial: boolean;
+  showPreview?: boolean;
+  assistedOnboarding?: boolean;
+  enableFaceRecording?: boolean;
+  autoCaptureTimeout: number;
+  captureAttempts?: number;
+  numberOfAttempts?: number;
+  validateLenses?: boolean;
+  validateFaceMask?: boolean;
+  validateHeadCover?: boolean;
+  validateClosedEyes?: boolean;
+  validateBrightness?: boolean;
+  deepsightLiveness?: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+  recording?: {
+    capability?: IRecordingCapability;
+  };
+  ds?: Flow['ds'];
+};
+type FaceCaptureDependencies = {
+  storage: IStorageCapability;
+  getWasmUtil: () => Promise<IWasmUtilCapability>;
+};
+type DetectionStatus = 'idle' | 'detecting' | 'noFace' | 'tooManyFaces' | 'tooClose' | 'tooFar' | 'blur' | 'dark' | 'faceAngle' | 'headWear' | 'lenses' | 'eyesClosed' | 'faceMask' | 'centerFace' | 'manualCapture' | 'success' | 'error' | 'capturing' | 'getReady' | 'getReadyFinished' | 'offline';
+declare const FACE_ERROR_CODES: {
+  readonly FACE_OCCLUDED: "FACE_OCCLUDED";
+  readonly LIVENESS: "LIVENESS_ERROR";
+  readonly BRIGHTNESS: "BRIGHTNESS_ERROR";
+  readonly LENSES: "LENSES_ERROR";
+  readonly MASK: "MASK_ERROR";
+  readonly CLOSED_EYES: "CLOSED_EYES_ERROR";
+  readonly HEAD_COVER: "HEAD_COVER_ERROR";
+  readonly SERVER: "SERVER_ERROR";
+  readonly FACE_NOT_FOUND: "FACE_NOT_FOUND";
+  readonly MULTIPLE_FACES: "MULTIPLE_FACES";
+  readonly TOO_BLURRY: "TOO_BLURRY_ERROR";
+  readonly TOO_DARK: "TOO_DARK_ERROR";
+  readonly USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED";
+  readonly SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED";
+  readonly FACE_TOO_DARK: "FACE_TOO_DARK";
+  readonly LENSES_DETECTED: "LENSES_DETECTED";
+  readonly FACE_MASK_DETECTED: "FACE_MASK_DETECTED";
+  readonly CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED";
+  readonly HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED";
+  readonly FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED";
+  readonly FACE_TOO_SMALL: "FACE_TOO_SMALL";
+  readonly FACE_TOO_BLURRY: "FACE_TOO_BLURRY";
+  readonly BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY";
+  readonly PROCESSING_ERROR: "PROCESSING_ERROR";
+  readonly BAD_REQUEST: "BAD_REQUEST";
+  readonly NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER";
+  readonly HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED";
+  readonly SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY";
+};
+type FaceErrorCode = (typeof FACE_ERROR_CODES)[keyof typeof FACE_ERROR_CODES];
+//#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/selfie/types.d.ts
+type SelfieConfig = FlowModuleConfig['SELFIE'] & BaseFaceCaptureConfig;
+type SelfieDependencies = FaceCaptureDependencies;
+type SendFaceImageResponse = {
+  age: number;
+  confidence: number;
+  hasClosedEyes: boolean;
+  hasFaceMask: boolean;
+  hasHeadCover: boolean;
+  hasLenses: boolean;
+  isBright: boolean;
+  liveness: boolean;
+  imageBase64: string;
+  sessionStatus: string;
+};
+//#endregion
+//#region src/internal/faceCapture/recordingService.d.ts
+type RecordingService = {
+  start(stream: MediaStream): Promise<void>;
+  stop(): Promise<{
+    recordingId: string | null;
+  }>;
+  cleanup(): void;
+};
+//#endregion
+//#region src/internal/faceCapture/faceCaptureSetup.d.ts
+type FaceCaptureConfig = BaseFaceCaptureConfig;
+type FaceCaptureInput = {
+  config: FaceCaptureConfig;
+  dependencies: FaceCaptureDependencies;
+  authHint?: string;
+};
+type FaceErrorObject = {
+  type: string;
+  message: string;
+};
+type FaceCaptureContext = {
+  config: FaceCaptureConfig;
+  dependencies: FaceCaptureDependencies;
+  authHint: string | undefined;
+  stream: CameraStream | undefined;
+  provider: FaceDetectionProvider | undefined;
+  frameCapturer: StreamCanvasCapture | undefined;
+  error: string | FaceErrorObject | undefined;
+  detectionStatus: DetectionStatus;
+  debugFrame: ImageData | undefined;
+  capturedImage: IncodeCanvas | undefined;
+  faceCoordinates: FaceCoordinates | undefined;
+  uploadResponse: Record<string, unknown> | undefined;
+  processResponse: Record<string, unknown> | undefined;
+  recordingService: RecordingService | undefined;
+  attemptsRemaining: number;
+  uploadError: FaceErrorCode | undefined;
+  permissionResult: PermissionResult | 'refresh' | undefined;
+  resetDetection: (() => void) | undefined;
+  deepsightService: DeepsightService | undefined;
+  encryptedBase64Image: string | undefined;
+  uploadRecordingId: string | null | undefined;
+  manualCaptureTriggered: boolean;
+};
+type FaceCaptureEvent = {
+  type: 'LOAD';
+} | {
+  type: 'NEXT_STEP';
+} | {
+  type: 'REQUEST_PERMISSION';
+} | {
+  type: 'GO_TO_LEARN_MORE';
+} | {
+  type: 'BACK';
+} | {
+  type: 'QUIT';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MANUAL_CAPTURE';
+} | {
+  type: 'DETECTION_UPDATE';
+  status: DetectionStatus;
+} | {
+  type: 'DETECTION_FRAME';
+  frame: ImageData;
+} | {
+  type: 'DETECTION_SUCCESS';
+  canvas: IncodeCanvas;
+  faceCoordinates?: FaceCoordinates;
+} | {
+  type: 'DETECTION_RESET_READY';
+  reset: () => void;
+} | {
+  type: 'RETRY_CAPTURE';
+};
+declare const faceCaptureMachine: AnyStateMachine;
+//#endregion
+//#region src/modules/selfie/selfieStateMachine.d.ts
+type SelfieContext = FaceCaptureContext;
+type SelfieEvent = FaceCaptureEvent;
+type SelfieInput = FaceCaptureInput;
+/**
+ * The selfie capture state machine.
+ *
+ * Note: Uses AnyStateMachine type for declaration file portability.
+ * Type safety is ensured via the machine configuration.
+ */
+declare const selfieMachine: AnyStateMachine;
+/**
+ * Type representing the selfie machine.
+ * For advanced use cases requiring specific machine types.
+ */
+type SelfieMachine = StateMachine<SelfieContext, SelfieEvent, any, any, any, any, any, any, any, SelfieInput, any, any, any, any>;
+//#endregion
+//#region src/modules/selfie/selfieActor.d.ts
+type CreateSelfieActorOptions = {
+  config: SelfieConfig;
+  dependencies?: SelfieDependencies;
+  authHint?: string;
+};
+type SelfieActor = ActorRefFrom<SelfieMachine>;
+//#endregion
+//#region src/internal/faceCapture/faceCaptureManagerFactory.d.ts
+type FaceCaptureActor = SelfieActor | AuthenticationActor;
+type CaptureStatus = 'initializing' | 'detecting' | 'capturing' | 'uploading' | 'uploadError' | 'success';
+/** Face capture manager is waiting to be started */
+type FaceCaptureIdleState = {
+  status: 'idle';
+};
+/** Checking camera permissions (when no tutorial) */
+type FaceCaptureLoadingState = {
+  status: 'loading';
+};
+/** Showing face capture tutorial */
+type FaceCaptureTutorialState = {
+  status: 'tutorial';
+};
+/** Handling camera permissions */
+type FaceCapturePermissionsState = {
+  status: 'permissions';
+  /** Current permission sub-state: initial, requesting, denied, or learnMore */
+  permissionStatus: PermissionStatus;
+};
+/** Camera is ready for face capture */
+type FaceCaptureCaptureState = {
+  status: 'capture';
+  /** Current capture sub-state */
+  captureStatus: CaptureStatus;
+  /** The active camera stream */
+  stream: CameraStream | undefined;
+  /** Current face detection status */
+  detectionStatus: DetectionStatus;
+  /** Latest frame processed in the detection loop (for UI debug rendering) */
+  debugFrame: ImageData | undefined;
+  /** Number of capture attempts remaining */
+  attemptsRemaining: number;
+  /** Error message from failed upload */
+  uploadError: string | undefined;
+  /** Whether assisted onboarding mode is active (back camera, no mirror) */
+  assistedOnboarding: boolean;
+};
+/** Processing the captured face */
+type FaceCaptureProcessingState = {
+  status: 'processing';
+};
+/** Face capture completed successfully */
+type FaceCaptureFinishedState = {
+  status: 'finished';
+  /** Face processing result (face match, confidence, existing user) */
+  processResponse: Record<string, unknown> | undefined;
+};
+/** User closed the face capture flow */
+type FaceCaptureClosedState = {
+  status: 'closed';
+};
+/** An error occurred during the flow */
+type FaceCaptureErrorState = {
+  status: 'error';
+  /** The error message */
+  error: string;
+};
+/** Union of all possible face capture states */
+type FaceCaptureManagerState = FaceCaptureIdleState | FaceCaptureLoadingState | FaceCaptureTutorialState | FaceCapturePermissionsState | FaceCaptureCaptureState | FaceCaptureProcessingState | FaceCaptureFinishedState | FaceCaptureClosedState | FaceCaptureErrorState;
+declare function createFaceCaptureManagerFromActor(actor: FaceCaptureActor): Manager<FaceCaptureManagerState> & {
+  /**
+   * Starts the face capture flow.
+   * Goes to `tutorial` if showTutorial is true, otherwise to `loading`.
+   * Requires setup() to have been called with a token first.
+   */
+  load(): void;
+  /**
+   * Advances to the next step.
+   * From `tutorial` → permissions or capture (based on permission status).
+   * From `capture` → finished.
+   */
+  nextStep(): void;
+  /**
+   * Requests camera permission via getUserMedia.
+   * Only effective when in `permissions.idle` or `permissions.learnMore` state.
+   */
+  requestPermission(): void;
+  /**
+   * Navigates to the "learn more" permission screen.
+   * Only effective when in `permissions.idle` state.
+   */
+  goToLearnMore(): void;
+  /**
+   * Goes back from "learn more" to the initial permission screen.
+   * Only effective when in `permissions.learnMore` state.
+   */
+  back(): void;
+  /**
+   * Closes the face capture flow and transitions to `closed` state.
+   * Can be called from any state.
+   */
+  close(): void;
+  /**
+   * Resets the face capture manager to its initial `idle` state.
+   * Can be called from `error` state. Not available from `finished` (final state).
+   */
+  reset(): void;
+  /**
+   * Retries the capture after an upload error.
+   * Only effective when in `capture.uploadError` state and `attemptsRemaining > 0`.
+   * If no attempts remaining, the transition is blocked.
+   */
+  retryCapture(): void;
+  /**
+   * Captures a face in manual capture mode.
+   * Only effective when in `capture.detecting` state and `detectionStatus === 'manualCapture'`.
+   */
+  capture(): void;
+};
+type FaceCaptureManager = ReturnType<typeof createFaceCaptureManagerFromActor>;
+//#endregion
+export { WasmUtilConfig as C, VirtualCameraCheckOutput as S, DetectionStatus as _, SelfieMachine as a, BaseWasmProvider as b, FaceCaptureEvent as c, SelfieConfig as d, SendFaceImageResponse as f, AuthenticationConfig as g, createAuthenticationActor as h, SelfieActor as i, FaceCaptureInput as l, CreateAuthenticationActorOptions as m, FaceCaptureManagerState as n, selfieMachine as o, AuthenticationActor as p, CreateSelfieActorOptions as r, FaceCaptureContext as s, FaceCaptureManager as t, faceCaptureMachine as u, FaceErrorCode as v, IWasmUtilCapability as x, authenticationMachine as y };

package/dist/{faceCaptureSetup-10lCb_yE.esm.js → faceCaptureSetup-CF9TJlsc.esm.js}

@@ -1,11 +1,11 @@
-import { d as addEvent, n as eventModuleNames } from "./events-b4_xvENs.esm.js";
-import { t as getBackCameraStream } from "./backCameraStream-B57NWDGu.esm.js";
-import { A as createManager, O as requestCameraAccess, S as StreamCanvasCapture, d as OpenViduRecordingProvider, k as stopCameraStream, p as LocalRecordingProvider, s as FaceDetectionProvider, x as StreamCanvasProcessingSession } from "./src-D3v6I2la.esm.js";
-import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-07M59Cte.esm.js";
-import { a as uploadDeepsightVideo, i as stopRecording$1, l as getDeviceClass, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-CQq5fJCL.esm.js";
-import { r as getToken, t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-5sPFFmaB.esm.js";
-import { t as addDeviceStats } from "./stats-D76Thmqp.esm.js";
+import { d as addEvent, n as eventModuleNames } from "./events-3HzCcoEy.esm.js";
+import { t as getBackCameraStream } from "./backCameraStream-4aLwsDOv.esm.js";
+import { A as createManager, O as requestCameraAccess, S as StreamCanvasCapture, d as OpenViduRecordingProvider, k as stopCameraStream, p as LocalRecordingProvider, s as FaceDetectionProvider, x as StreamCanvasProcessingSession } from "./src-BmVrWkLJ.esm.js";
+import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-CcoTezCZ.esm.js";
+import { a as uploadDeepsightVideo, i as stopRecording$1, l as getDeviceClass, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-Cw6kqXEh.esm.js";
+import { r as getToken, t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
+import { t as addDeviceStats } from "./stats-kLtQIgsA.esm.js";
 
 //#region src/internal/faceCapture/faceCaptureManagerFactory.ts
 function getPermissionStatus(snapshot) {
@@ -96,7 +96,7 @@ function createApi({ actor }) {
 		}
 	};
 }
-function createFaceCaptureManager(actor) {
+function createFaceCaptureManagerFromActor(actor) {
 	return createManager({
 		actor,
 		mapState,
@@ -445,7 +445,7 @@ async function stopRecording(session) {
 	}
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-BXTRzhYx.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-C-Xil8cg.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage
@@ -1216,4 +1216,4 @@ const _faceCaptureMachine = setup({
 const faceCaptureMachine = _faceCaptureMachine;
 
 //#endregion
-export { FACE_ERROR_CODES as a, uploadSelfie as i, faceCaptureMachine as n, createFaceCaptureManager as o, processFace as r, FACE_CAPTURE_EVENT_CODES as t };
+export { FACE_ERROR_CODES as a, uploadSelfie as i, faceCaptureMachine as n, createFaceCaptureManagerFromActor as o, processFace as r, FACE_CAPTURE_EVENT_CODES as t };

package/dist/flow.d.ts

@@ -1,10 +1,10 @@
-import { n as WasmPipeline } from "./warmup-Da5qDIWZ.js";
-import { t as Manager } from "./Manager-CG5CQ1kY.js";
-import "./camera-D7zu0Mls.js";
-import { t as AnyStateMachine } from "./StateMachine-WHeQE3lC.js";
-import "./types-DnrAr9fb.js";
-import { n as FlowModule, r as FlowModuleConfig, t as Flow } from "./types-Bn54lmeM.js";
-import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-DeWKduBI.js";
+import { n as WasmPipeline } from "./warmup-Bp_1oXoL.js";
+import { t as Manager } from "./Manager-CXnC-tN_.js";
+import "./camera-DDn9ILon.js";
+import { t as AnyStateMachine } from "./StateMachine-DJpZF_HP.js";
+import "./types-BugcSDaO.js";
+import { n as FlowModule, r as FlowModuleConfig, t as Flow } from "./types-C9Jo2XOb.js";
+import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-D4YDcHQR.js";
 
 //#region src/modules/flow/flowUtils.d.ts
 

package/dist/flow.esm.js

@@ -1,8 +1,8 @@
-import { A as createManager } from "./src-D3v6I2la.esm.js";
-import { a as createActor, i as fromPromise, n as assign, r as fromCallback, 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 { t as getFinishStatus } from "./flowCompletionService-DHXqHOAk.esm.js";
+import { A as createManager } from "./src-BmVrWkLJ.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, 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";
+import { t as getFinishStatus } from "./flowCompletionService-CV8Ywiut.esm.js";
 
 //#region src/modules/flow/flowUtils.ts
 const WASM_MODULE_PIPELINES = {