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

package/dist/selfie.d.ts

@@ -1,409 +1,11 @@
-import { i as IncodeCanvas, n as StreamCanvasCapture, t as DeepsightService } from "./deepsightService-CYCDsan2.js";
-import { n as PermissionStatus, o as IMLProviderCapability, s as MLProviderConfig, t as PermissionResult } from "./types-B4KNFqC4.js";
-import { n as WasmPipeline } from "./warmup-Da5qDIWZ.js";
-import { a as FaceCaptureDependencies, i as DetectionStatus, n as FaceCaptureManagerState, o as FaceErrorCode, r as BaseFaceCaptureConfig, t as FaceCaptureManager } from "./faceCaptureManagerFactory-D1NUo68Z.js";
-import { t as Manager } from "./Manager-CG5CQ1kY.js";
-import { t as CameraStream } from "./camera-D7zu0Mls.js";
-import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-WHeQE3lC.js";
-import "./types-DnrAr9fb.js";
-import { r as FlowModuleConfig } from "./types-Bn54lmeM.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/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/selfie/types.d.ts
-type SelfieConfig = FlowModuleConfig['SELFIE'] & BaseFaceCaptureConfig;
-type SelfieDependencies = FaceCaptureDependencies;
-//#endregion
-//#region src/modules/selfie/selfieUploadService.d.ts
-type ProcessFaceImageType = 'selfie' | 'videoSelfie';
-type ProcessFaceResponse = {
-  faceMatch: boolean;
-  confidence: number;
-  existingUser: boolean;
-};
-declare function processFace(imageType?: ProcessFaceImageType, signal?: AbortSignal): Promise<ProcessFaceResponse>;
-//#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';
-};
-//#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;
-};
-//#endregion
-//#region src/modules/selfie/selfieManager.d.ts
-type SelfieState = FaceCaptureManagerState;
-/**
- * Creates a selfie manager instance for handling selfie capture flow.
- *
- * The selfie 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 selfie actor
- * @param options.config - The selfie module configuration from the flow
- * @returns A manager instance with state subscription, API methods, and lifecycle controls
- *
- * @example
- * ```ts
- * const selfieManager = createSelfieManager({ config: selfieConfig });
- *
- * selfieManager.subscribe((state) => {
- *   if (state.status === 'capture') {
- *     console.log('Camera ready:', state.stream);
- *     console.log('Detection status:', state.detectionStatus);
- *   }
- * });
- *
- * selfieManager.load();
- * ```
- */
-declare function createSelfieManager(options: CreateSelfieActorOptions): Manager<FaceCaptureManagerState> & {
-  load(): void;
-  nextStep(): void;
-  requestPermission(): void;
-  goToLearnMore(): void;
-  back(): void;
-  close(): void;
-  reset(): void;
-  retryCapture(): void;
-  capture(): void;
-};
-type SelfieManager = FaceCaptureManager;
-//#endregion
+import { n as PermissionResult, r as PermissionStatus, t as DeepsightService } from "./deepsightService-UhtHJCFb.js";
+import { _ as DetectionStatus, a as SelfieMachine, d as SelfieConfig, o as selfieMachine, v as FaceErrorCode } from "./faceCaptureManagerFactory-CiQWYHp2.js";
+import "./warmup-Bp_1oXoL.js";
+import "./Manager-CXnC-tN_.js";
+import { t as CameraStream } from "./camera-DDn9ILon.js";
+import "./Actor-BAf9LRYf.js";
+import "./StateMachine-DJpZF_HP.js";
+import "./types-BugcSDaO.js";
+import "./types-C9Jo2XOb.js";
+import { a as ProcessFaceResponse, n as SelfieState, o as processFace, r as createSelfieManager, t as SelfieManager } from "./selfieManager-Czysy-lv.js";
 export { type CameraStream, type DeepsightService, type DetectionStatus, type FaceErrorCode, type PermissionResult, type PermissionStatus, type ProcessFaceResponse, type SelfieConfig, type SelfieMachine, type SelfieManager, type SelfieState, createSelfieManager, processFace, selfieMachine };

package/dist/selfie.esm.js

@@ -1,120 +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 "./streamingEvents-CQq5fJCL.esm.js";
-import "./deepsightService-CTK55DG8.esm.js";
-import "./api-3fZO5bmj.esm.js";
-import "./endpoints-5sPFFmaB.esm.js";
-import "./stats-D76Thmqp.esm.js";
-import { a as FACE_ERROR_CODES, i as uploadSelfie, n as faceCaptureMachine, o as createFaceCaptureManager, r as processFace, 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 { r as processFace } from "./faceCaptureSetup-CF9TJlsc.esm.js";
+import { r as selfieMachine, t as createSelfieManager } from "./selfieManager-ByV0akn-.esm.js";
 
-//#region src/modules/selfie/selfieErrorUtils.ts
-const FACE_ERROR_CODE_VALUES = Object.values(FACE_ERROR_CODES);
-const validateUploadResponse = ({ config, response }) => {
-	if (!response) return FACE_ERROR_CODES.SERVER;
-	if (response.confidence !== 0) return FACE_ERROR_CODES.LIVENESS;
-	if (config.validateBrightness && !response.isBright) return FACE_ERROR_CODES.BRIGHTNESS;
-	if (config.validateLenses && response.hasLenses) return FACE_ERROR_CODES.LENSES;
-	if (config.validateFaceMask && response.hasFaceMask) return FACE_ERROR_CODES.MASK;
-	if (config.validateClosedEyes && response.hasClosedEyes) return FACE_ERROR_CODES.CLOSED_EYES;
-	if (config.validateHeadCover && response.hasHeadCover) return FACE_ERROR_CODES.HEAD_COVER;
-};
-
-//#endregion
-//#region src/modules/selfie/selfieStateMachine.ts
-const _selfieMachine = faceCaptureMachine.provide({
-	actors: {
-		uploadFace: fromPromise(async ({ input, signal }) => {
-			const ctx = input;
-			return uploadSelfie({
-				encryptedBase64Image: ctx.encryptedBase64Image,
-				faceCoordinates: ctx.faceCoordinates,
-				metadata: ctx.deepsightService?.getMetadata(),
-				recordingId: ctx.uploadRecordingId,
-				signal
-			});
-		}),
-		processFace: fromPromise(async ({ signal }) => {
-			return processFace("selfie", signal);
-		})
-	},
-	actions: {
-		trackContinue: () => {
-			addEvent({
-				code: FACE_CAPTURE_EVENT_CODES.CONTINUE,
-				module: eventModuleNames.selfie
-			});
-		},
-		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => validateUploadResponse({
-			config: context.config,
-			response: context.uploadResponse
-		}) ?? FACE_ERROR_CODES.SERVER })
-	},
-	guards: {
-		hasUploadValidationError: ({ context }) => validateUploadResponse({
-			config: context.config,
-			response: context.uploadResponse
-		}) !== void 0,
-		isTerminalUploadError: () => false
-	}
-});
-/**
-* The selfie capture state machine.
-*
-* Note: Uses AnyStateMachine type for declaration file portability.
-* Type safety is ensured via the machine configuration.
-*/
-const selfieMachine = _selfieMachine;
-
-//#endregion
-//#region src/modules/selfie/selfieActor.ts
-function createSelfieActor(options) {
-	const dependencies = options.dependencies ?? {
-		storage: new BrowserStorageProvider(),
-		getWasmUtil: () => WasmUtilProvider.getInstance()
-	};
-	return createActor(selfieMachine, { input: {
-		config: options.config,
-		dependencies,
-		authHint: options.authHint
-	} }).start();
-}
-
-//#endregion
-//#region src/modules/selfie/selfieManager.ts
-/**
-* Creates a selfie manager instance for handling selfie capture flow.
-*
-* The selfie 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 selfie actor
-* @param options.config - The selfie module configuration from the flow
-* @returns A manager instance with state subscription, API methods, and lifecycle controls
-*
-* @example
-* ```ts
-* const selfieManager = createSelfieManager({ config: selfieConfig });
-*
-* selfieManager.subscribe((state) => {
-*   if (state.status === 'capture') {
-*     console.log('Camera ready:', state.stream);
-*     console.log('Detection status:', state.detectionStatus);
-*   }
-* });
-*
-* selfieManager.load();
-* ```
-*/
-function createSelfieManager(options) {
-	return createFaceCaptureManager(createSelfieActor(options));
-}
-
-//#endregion
 export { createSelfieManager, processFace, selfieMachine };

package/dist/selfieManager-ByV0akn-.esm.js

@@ -0,0 +1,117 @@
+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 { a as FACE_ERROR_CODES, i as uploadSelfie, n as faceCaptureMachine, o as createFaceCaptureManagerFromActor, r as processFace, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-CF9TJlsc.esm.js";
+
+//#region src/modules/selfie/selfieErrorUtils.ts
+const FACE_ERROR_CODE_VALUES = Object.values(FACE_ERROR_CODES);
+const validateUploadResponse = ({ config, response }) => {
+	if (!response) return FACE_ERROR_CODES.SERVER;
+	if (response.confidence !== 0) return FACE_ERROR_CODES.LIVENESS;
+	if (config.validateBrightness && !response.isBright) return FACE_ERROR_CODES.BRIGHTNESS;
+	if (config.validateLenses && response.hasLenses) return FACE_ERROR_CODES.LENSES;
+	if (config.validateFaceMask && response.hasFaceMask) return FACE_ERROR_CODES.MASK;
+	if (config.validateClosedEyes && response.hasClosedEyes) return FACE_ERROR_CODES.CLOSED_EYES;
+	if (config.validateHeadCover && response.hasHeadCover) return FACE_ERROR_CODES.HEAD_COVER;
+};
+
+//#endregion
+//#region src/modules/selfie/selfieStateMachine.ts
+const _selfieMachine = faceCaptureMachine.provide({
+	actors: {
+		uploadFace: fromPromise(async ({ input, signal }) => {
+			const ctx = input;
+			return uploadSelfie({
+				encryptedBase64Image: ctx.encryptedBase64Image,
+				faceCoordinates: ctx.faceCoordinates,
+				metadata: ctx.deepsightService?.getMetadata(),
+				recordingId: ctx.uploadRecordingId,
+				signal
+			});
+		}),
+		processFace: fromPromise(async ({ signal }) => {
+			return processFace("selfie", signal);
+		})
+	},
+	actions: {
+		trackContinue: () => {
+			addEvent({
+				code: FACE_CAPTURE_EVENT_CODES.CONTINUE,
+				module: eventModuleNames.selfie
+			});
+		},
+		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => validateUploadResponse({
+			config: context.config,
+			response: context.uploadResponse
+		}) ?? FACE_ERROR_CODES.SERVER })
+	},
+	guards: {
+		hasUploadValidationError: ({ context }) => validateUploadResponse({
+			config: context.config,
+			response: context.uploadResponse
+		}) !== void 0,
+		isTerminalUploadError: () => false
+	}
+});
+/**
+* The selfie capture state machine.
+*
+* Note: Uses AnyStateMachine type for declaration file portability.
+* Type safety is ensured via the machine configuration.
+*/
+const selfieMachine = _selfieMachine;
+
+//#endregion
+//#region src/modules/selfie/selfieActor.ts
+function createSelfieActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieMachine, { input: {
+		config: options.config,
+		dependencies,
+		authHint: options.authHint
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/selfie/selfieManager.ts
+function createSelfieManagerFromActor(actor) {
+	return createFaceCaptureManagerFromActor(actor);
+}
+/**
+* Creates a selfie manager instance for handling selfie capture flow.
+*
+* The selfie 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 selfie actor
+* @param options.config - The selfie module configuration from the flow
+* @returns A manager instance with state subscription, API methods, and lifecycle controls
+*
+* @example
+* ```ts
+* const selfieManager = createSelfieManager({ config: selfieConfig });
+*
+* selfieManager.subscribe((state) => {
+*   if (state.status === 'capture') {
+*     console.log('Camera ready:', state.stream);
+*     console.log('Detection status:', state.detectionStatus);
+*   }
+* });
+*
+* selfieManager.load();
+* ```
+*/
+function createSelfieManager(options) {
+	return createFaceCaptureManagerFromActor(createSelfieActor(options));
+}
+
+//#endregion
+export { createSelfieManagerFromActor as n, selfieMachine as r, createSelfieManager as t };