@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/{faceCaptureManagerFactory-DiJ64oem.d.ts → faceCaptureManagerFactory-BxWPpxyd.d.ts}

@@ -1,24 +1,59 @@
-import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import { t as ActorRefFrom } from "./Actor-BwgmOPkb.js";
-import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-BZ1rE7ly.js";
-import { t as CameraStream } from "./camera-CKU96nwJ.js";
-import { t as IncodeCanvas } from "./canvas-90BqS0NF.js";
-import { s as FaceFeed, t as AvatarId, u as FaceCoordinates } from "./createFaceAvatar-CpdYp9Iy.js";
-import { i as FlowModuleConfig } from "./types-BUgeB2X6.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-BcF-fii5.js";
-import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode, r as FaceCaptureDependencies, t as BaseFaceCaptureConfig } from "./types-fO6KIdol.js";
-import { t as FaceDetectionProvider } from "./FaceDetectionProvider-CPWg-PAH.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-DHaWferF.js";
-import { t as DeepsightService } from "./deepsightService-BuTOFTr8.js";
-
+import { A as StateMachine, i as ActorRefFrom, l as AnyStateMachine } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
+import "./index-B8weJxmL.js";
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { o as IncodeCanvas } from "./IStorageCapability-ORkQfK3F.js";
+import { i as FaceData, r as FaceCoordinates, t as FaceDetectionProvider } from "./FaceDetectionProvider-Mh6q3EbA.js";
+import { t as AvatarId } from "./createFaceAvatar-BEj18KXi.js";
+import { i as FlowModuleConfig } from "./types-KPvmag_B.js";
+import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode, r as FaceCaptureDependencies, t as BaseFaceCaptureConfig } from "./types-Hmd7U0JA.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
+import { t as AuthenticationConfig } from "./types-EELWyWpd.js";
+import { n as StreamCanvasCapture, t as DeepsightService } from "./deepsightService-DLVQS_RH.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;
+//#region ../infra/src/avatar/faceFeed.d.ts
+/**
+ * A tiny per-frame pub/sub channel for the Incode WASM pipeline's `FaceData`.
+ *
+ * The parked `incode-2d` avatar drives the cosmetic avatar from the **existing** Incode face-detection
+ * pipeline (no second MediaPipe model). The detection pipeline lives in core's
+ * detection actor, while the avatar lives in the avatar actor — so the avatar is
+ * *fed* `FaceData` through this channel rather than running its own model.
+ *
+ * Deliberately NOT routed through XState events/context: the pipeline emits
+ * ~10×/s, and assigning that into context would re-run `mapState` and notify all
+ * manager subscribers 10×/s — needless churn that could itself regress UI perf.
+ * The feed is a plain emitter passed as input to both actors (detection
+ * publishes, the avatar source subscribes); nothing else observes it.
+ *
+ * Strictly read-only w.r.t. the authoritative pipeline — the feed only forwards
+ * data the pipeline already computed; it never influences detection/autocapture.
+ */
+interface FaceFeedReader {
+  /** Subscribe to per-frame faces. Returns an unsubscribe function. */
+  subscribe(listener: (face: FaceData) => void): () => void;
+  /** The most recently published face, or null if none yet. */
+  getLatest(): FaceData | null;
+  /**
+   * Subscribe to the coarse "eyes closed" pulse — the only real eye signal the
+   * Incode pipeline exposes (a threshold event, both eyes, fired only when the
+   * closed-eyes check is enabled via `validateClosedEyes`). The avatar uses it
+   * to drive a real blink. Returns an unsubscribe function.
+   */
+  onEyesClosed(listener: () => void): () => void;
+}
+interface FaceFeed extends FaceFeedReader {
+  publish(face: FaceData): void;
+  /** Fire the eyes-closed pulse (from the detection pipeline's threshold event). */
+  signalEyesClosed(): void;
+}
 //#endregion
 //#region src/modules/authentication/authenticationActor.d.ts
 type CreateAuthenticationActorOptions = {
@@ -120,9 +155,9 @@ type FaceCaptureContext = {
   stream: CameraStream | undefined;
   provider: FaceDetectionProvider | undefined;
   frameCapturer: StreamCanvasCapture | undefined;
+  usingBackCamera: boolean;
   error: string | FaceErrorObject | undefined;
   detectionStatus: DetectionStatus;
-  debugFrame: ImageData | undefined;
   capturedImage: IncodeCanvas | undefined;
   faceCoordinates: FaceCoordinates | undefined;
   uploadResponse: Record<string, unknown> | undefined;
@@ -182,9 +217,6 @@ type FaceCaptureEvent = {
 } | {
   type: 'DETECTION_UPDATE';
   status: DetectionStatus;
-} | {
-  type: 'DETECTION_FRAME';
-  frame: ImageData;
 } | {
   type: 'DETECTION_SUCCESS';
   canvas: IncodeCanvas;
@@ -275,14 +307,21 @@ type FaceCaptureCaptureState = {
   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) */
+  /**
+   * The requested config flag only — it does NOT say which camera is in use,
+   * since devices without a rear camera fall back to the front one. Use
+   * {@link usingBackCamera} for camera-dependent concerns like mirroring.
+   */
   assistedOnboarding: boolean;
+  /**
+   * Whether the active `stream` really came from a rear camera. Mirror the
+   * preview when this is `false` (selfie view), leave it as-is when `true`.
+   */
+  usingBackCamera: boolean;
   ageAssurance?: boolean;
   /**
    * Whether on-device face-results submission is enabled
@@ -397,4 +436,4 @@ declare function createFaceCaptureManagerFromActor(actor: FaceCaptureActor, modu
 };
 type FaceCaptureManager = ReturnType<typeof createFaceCaptureManagerFromActor>;
 //#endregion
-export { authenticationMachine as S, SendFaceImageResponse as _, SelfieCaptureOnlyMachine as a, createAuthenticationActor as b, SelfieActor as c, FaceCaptureContext as d, FaceCaptureEvent as f, SelfieConfig as g, SelfieCaptureOnlyConfig as h, SelfieCaptureOnlyActor as i, SelfieMachine as l, faceCaptureMachine as m, FaceCaptureManagerState as n, selfieCaptureOnlyMachine as o, FaceCaptureInput as p, CreateSelfieCaptureOnlyActorOptions as r, CreateSelfieActorOptions as s, FaceCaptureManager as t, selfieMachine as u, AuthenticationActor as v, AuthenticationConfig as x, CreateAuthenticationActorOptions as y };
+export { SendFaceImageResponse as _, SelfieCaptureOnlyMachine as a, createAuthenticationActor as b, SelfieActor as c, FaceCaptureContext as d, FaceCaptureEvent as f, SelfieConfig as g, SelfieCaptureOnlyConfig as h, SelfieCaptureOnlyActor as i, SelfieMachine as l, faceCaptureMachine as m, FaceCaptureManagerState as n, selfieCaptureOnlyMachine as o, FaceCaptureInput as p, CreateSelfieCaptureOnlyActorOptions as r, CreateSelfieActorOptions as s, FaceCaptureManager as t, selfieMachine as u, AuthenticationActor as v, authenticationMachine as x, CreateAuthenticationActorOptions as y };

package/dist/{faceCaptureSetup-BqhqfFHL.esm.js → faceCaptureSetup-C7Qv79fA.esm.js}

@@ -1,13 +1,14 @@
-import { r as getToken } from "./api-DsbUi7TO.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import { c as sendLabelInspectionEvent, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession } from "./onDeviceFaceResults-DILtthks.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BKLb3C42.esm.js";
-import { t as createFaceAvatar } from "./createFaceAvatar-BZSg2MNo.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-CAqUdVkM.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BNOe4Tnu.esm.js";
-import { n as preloadOpenViduProvider, r as flagFaceManualReview, t as createRecordingService } from "./recordingService-CxaYkITO.esm.js";
-
+import { r as getToken } from "./api-Bx3gKW_y.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { c as sendLabelInspectionEvent, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession } from "./onDeviceFaceResults-f81FVdQs.esm.js";
+import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
+import { n as releaseFaceAvatarWarmup, r as warmFaceAvatar, t as createFaceAvatar } from "./createFaceAvatar-DQKaRise.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-KINpmKtI.esm.js";
+import { t as flagFaceManualReview } from "./manualReviewService-D4IkipnN.esm.js";
+import { n as preloadOpenViduProvider, t as createRecordingService } from "./recordingService-CFpfdXSS.esm.js";
 //#region src/internal/avatar/concealment.ts
 /**
 * Maps a backend concealment option to the internal avatar flags. `OPTION_NONE`
@@ -37,13 +38,12 @@ function concealmentToAvatar(option) {
 		};
 	}
 }
-
 //#endregion
 //#region src/internal/faceCapture/faceCaptureSetup.ts
 const getAttemptsFromConfig = (config) => {
 	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
 };
-const _faceCaptureMachine = setup({
+const faceCaptureMachine = setup({
 	types: {
 		context: {},
 		events: {},
@@ -84,10 +84,6 @@ const _faceCaptureMachine = setup({
 					type: "DETECTION_UPDATE",
 					status
 				}),
-				onFrame: (frame) => sendBack({
-					type: "DETECTION_FRAME",
-					frame
-				}),
 				onSuccess: (canvas, faceCoordinates) => sendBack({
 					type: "DETECTION_SUCCESS",
 					canvas,
@@ -176,7 +172,8 @@ const _faceCaptureMachine = setup({
 				stream: void 0,
 				provider: void 0,
 				frameCapturer: void 0,
-				avatarCanvas: void 0
+				avatarCanvas: void 0,
+				usingBackCamera: false
 			};
 		}),
 		setStreamAndCapturer: assign({
@@ -188,6 +185,10 @@ const _faceCaptureMachine = setup({
 			},
 			frameCapturer: ({ event }) => {
 				if ("output" in event) return new StreamCanvasCapture(event.output.stream);
+			},
+			usingBackCamera: ({ event }) => {
+				if ("output" in event) return event.output.usingBackCamera;
+				return false;
 			}
 		}),
 		trackTutorial: () => void 0,
@@ -196,9 +197,9 @@ const _faceCaptureMachine = setup({
 			stream: void 0,
 			provider: void 0,
 			frameCapturer: void 0,
+			usingBackCamera: false,
 			error: void 0,
 			detectionStatus: "idle",
-			debugFrame: void 0,
 			capturedImage: void 0,
 			faceCoordinates: void 0,
 			uploadResponse: void 0,
@@ -236,7 +237,8 @@ const _faceCaptureMachine = setup({
 				stream: void 0,
 				provider: void 0,
 				frameCapturer: void 0,
-				avatarCanvas: void 0
+				avatarCanvas: void 0,
+				usingBackCamera: false
 			};
 		}),
 		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
@@ -261,7 +263,6 @@ const _faceCaptureMachine = setup({
 			const status = event.status;
 			return context.manualCaptureTriggered || status === "manualCapture";
 		} }),
-		setDebugFrameFromEvent: assign({ debugFrame: ({ event }) => event.frame }),
 		setAvatarCanvas: assign({ avatarCanvas: ({ event }) => event.canvas }),
 		clearAvatarCanvas: assign({ avatarCanvas: () => void 0 }),
 		setResetDetectionFromEvent: assign({ resetDetection: ({ event }) => event.reset }),
@@ -288,10 +289,22 @@ const _faceCaptureMachine = setup({
 		preloadRecordingProvider: ({ context }) => {
 			if (context.config.enableFaceRecording === true && context.config.deepsightLiveness !== "VIDEOLIVENESS") preloadOpenViduProvider();
 		},
+		warmAvatarProvider: ({ context }) => {
+			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(context.config.selfieConcealmentOption);
+			if (!obfuscateWithAvatar || !avatarVariant) return;
+			warmFaceAvatar({
+				variant: avatarVariant,
+				assets: context.config.avatarAssets
+			});
+		},
+		releaseAvatarWarmup: () => {
+			releaseFaceAvatarWarmup();
+		},
 		noOp: () => void 0
 	},
 	guards: {
 		hasShowTutorial: ({ context }) => context.config.showTutorial,
+		hasAgeAssurance: ({ context }) => context.config.ageAssurance === true,
 		isPermissionGranted: ({ event }) => {
 			if ("output" in event) return event.output === "granted";
 			return false;
@@ -327,9 +340,9 @@ const _faceCaptureMachine = setup({
 		stream: void 0,
 		provider: void 0,
 		frameCapturer: void 0,
+		usingBackCamera: false,
 		error: void 0,
 		detectionStatus: "idle",
-		debugFrame: void 0,
 		capturedImage: void 0,
 		faceCoordinates: void 0,
 		uploadResponse: void 0,
@@ -349,12 +362,19 @@ const _faceCaptureMachine = setup({
 	}),
 	on: { QUIT: { target: "#faceCapture.closed" } },
 	states: {
-		idle: { on: { LOAD: [{
-			target: "tutorial",
-			guard: "hasShowTutorial"
-		}, { target: "loading" }] } },
+		idle: { on: { LOAD: [
+			{
+				target: "tutorial",
+				guard: "hasShowTutorial"
+			},
+			{
+				target: "tutorial",
+				guard: "hasAgeAssurance"
+			},
+			{ target: "loading" }
+		] } },
 		loading: {
-			entry: "preloadRecordingProvider",
+			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
 			invoke: [{
 				id: "checkPermissionLoading",
 				src: "checkPermission",
@@ -379,7 +399,11 @@ const _faceCaptureMachine = setup({
 		},
 		tutorial: {
 			initial: "checkingPermission",
-			entry: ["trackTutorial", "preloadRecordingProvider"],
+			entry: [
+				"trackTutorial",
+				"preloadRecordingProvider",
+				"warmAvatarProvider"
+			],
 			states: {
 				checkingPermission: { invoke: {
 					id: "checkPermissionTutorial",
@@ -498,7 +522,7 @@ const _faceCaptureMachine = setup({
 			}
 		},
 		permissions: {
-			entry: "preloadRecordingProvider",
+			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
 			initial: "checkingDeepsight",
 			states: {
 				checkingDeepsight: { always: [{
@@ -591,7 +615,7 @@ const _faceCaptureMachine = setup({
 			}
 		},
 		capture: {
-			entry: "preloadRecordingProvider",
+			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
 			initial: "checkingDeepsight",
 			exit: [
 				"stopMediaStream",
@@ -701,7 +725,6 @@ const _faceCaptureMachine = setup({
 					exit: ["clearAvatarCanvas"],
 					on: {
 						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
-						DETECTION_FRAME: { actions: "setDebugFrameFromEvent" },
 						AVATAR_READY: { actions: "setAvatarCanvas" },
 						DETECTION_RESET_READY: { actions: "setResetDetectionFromEvent" },
 						DETECTION_SUCCESS: {
@@ -820,15 +843,15 @@ const _faceCaptureMachine = setup({
 			}
 		},
 		finished: {
-			entry: "stopMediaStream",
+			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			type: "final"
 		},
 		closed: {
-			entry: "stopMediaStream",
+			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			type: "final"
 		},
 		error: {
-			entry: "stopMediaStream",
+			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			on: { RESET: {
 				target: "idle",
 				actions: "resetContext"
@@ -836,7 +859,5 @@ const _faceCaptureMachine = setup({
 		}
 	}
 });
-const faceCaptureMachine = _faceCaptureMachine;
-
 //#endregion
-export { concealmentToAvatar as n, faceCaptureMachine as t };
+export { concealmentToAvatar as n, faceCaptureMachine as t };

package/dist/faceMatchManager-BXp2WUT-.esm.js

@@ -0,0 +1,201 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as faceMatchMachine } from "./faceMatchStateMachine-CJiO2yLO.esm.js";
+//#region src/modules/face-match/faceMatchActor.ts
+function createFaceMatchActor(options) {
+	return createActor(faceMatchMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/face-match/faceMatchManager.ts
+/**
+* @module @incodetech/core/face-match
+*
+* Face match module for the Incode Web SDK.
+* Supports both headless (programmatic) and UI-driven usage patterns.
+*
+* ## Headless Usage
+*
+* The face match manager can be used entirely without UI for backend integrations,
+* custom UI implementations, or automated workflows.
+*
+* @example Basic headless face match with auto-skip
+* ```typescript
+* import { createFaceMatchManager } from '@incodetech/core/face-match';
+* import { setup } from '@incodetech/core';
+*
+* // 1. Configure the SDK (required before using any module)
+* setup({ apiURL: 'https://api.example.com', token: 'your-token' });
+*
+* // 2. Create the face match manager
+* const faceMatchManager = createFaceMatchManager({
+*   config: {
+*     matchingType: 'selfieVsId',
+*     disableFaceMatchAnimation: true,
+*   },
+* });
+*
+* // 3. Subscribe to state changes (optional but recommended)
+* faceMatchManager.subscribe((state) => {
+*   console.log('Face match state:', state.status);
+*   if (state.status === 'finished') {
+*     console.log('Face match complete!', state.matched);
+*   }
+*   if (state.status === 'error') {
+*     console.error('Error:', state.error);
+*   }
+* });
+*
+* // 4. Start the flow
+* faceMatchManager.load();
+*
+* // 5. Auto-completes when disableFaceMatchAnimation is true
+* // Or call faceMatchManager.continue() after animation in custom UI
+*
+* // 6. Clean up when done
+* faceMatchManager.stop();
+* ```
+*
+* @example Headless face match with custom UI
+* ```typescript
+* const faceMatchManager = createFaceMatchManager({
+*   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: false },
+* });
+*
+* faceMatchManager.subscribe((state) => {
+*   if (state.status === 'animating') {
+*     // Render your custom animation
+*     renderAnimation(state.images, state.result);
+*   }
+*   if (state.status === 'result') {
+*     // Show result and wait for user to click continue
+*     showResult(state.matched);
+*   }
+* });
+*
+* faceMatchManager.load();
+* // When animation completes in your UI:
+* faceMatchManager.animationComplete();
+* // When user clicks continue:
+* faceMatchManager.continue();
+* ```
+*/
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("animating")) return {
+		status: "animating",
+		images: context.images,
+		result: context.result
+	};
+	if (typedSnapshot.matches("result")) return {
+		status: "result",
+		images: context.images,
+		result: context.result,
+		matched: context.result.matched
+	};
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		matched: context.result?.matched ?? null
+	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		/**
+		* Initializes the face match flow.
+		* Transitions from 'idle' to 'loading'.
+		* Must be called before any other method.
+		*/
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		/**
+		* Signals that the animation has completed.
+		* Should be called when state is 'animating' and your UI animation finishes.
+		* Transitions to 'result' state.
+		*/
+		animationComplete() {
+			actor.send({ type: "ANIMATION_COMPLETE" });
+		},
+		/**
+		* User clicked continue button.
+		* Should be called when state is 'result'.
+		* Transitions to 'finished' state.
+		*/
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		/**
+		* Resets the manager to initial state.
+		* Can be called from 'error' state to start over.
+		* Clears all stored data including images and result.
+		*/
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates a face match manager for headless or UI-driven usage.
+*
+* The manager provides a state machine-based API for face comparison
+* with optional animation display.
+*
+* @param options - Configuration options
+* @param options.config - Face match configuration
+* @param options.config.matchingType - Which images to compare (default: 'selfieVsId')
+* @param options.config.disableFaceMatchAnimation - Skip animation and auto-complete (default: false)
+*
+* @returns Face match manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createFaceMatchManager({
+*   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: true },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* // Auto-completes when disableFaceMatchAnimation is true
+* manager.stop();
+* ```
+*
+* @example With React/Preact UI hook
+* ```tsx
+* const [state, manager] = useManager(() => createFaceMatchManager({ config }));
+*
+* if (state.status === 'animating') {
+*   return <Animation images={state.images} />;
+* }
+* ```
+*/
+function createFaceMatchManager(options) {
+	return createManager({
+		actor: createFaceMatchActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.faceMatch)
+	});
+}
+/**
+* Creates a face-match manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createFaceMatchManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.faceMatch)
+	});
+}
+//#endregion
+export { createFaceMatchManagerFromActor as n, createFaceMatchManager as t };