@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/faceCaptureManagerFactory-CGKbf7zt.d.ts

@@ -0,0 +1,400 @@
+import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
+import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-BbWjgpiF.js";
+import { t as CameraStream } from "./camera-CNVUo-bC.js";
+import { t as IncodeCanvas } from "./canvas-CJUmoXSD.js";
+import { s as FaceFeed, t as AvatarId, u as FaceCoordinates } from "./createFaceAvatar-B8pFpy6o.js";
+import { i as FlowModuleConfig } from "./types-BsYXnC5s.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-Duy2rDxF.js";
+import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode, r as FaceCaptureDependencies, t as BaseFaceCaptureConfig } from "./types-CxW2e0Ar.js";
+import { t as FaceDetectionProvider } from "./FaceDetectionProvider-B78455D4.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-DS1TOoiH.js";
+import { t as DeepsightService } from "./deepsightService-CMB9XjES.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/selfie/types.d.ts
+/**
+ * Public selfie configuration.
+ *
+ * For the captureOnly flow (delivering the captured image locally instead of
+ * uploading to Incode), use `createSelfieCaptureOnlyManager` with
+ * `SelfieCaptureOnlyConfig`.
+ */
+type SelfieConfig = FlowModuleConfig['SELFIE'] & BaseFaceCaptureConfig;
+/**
+ * Public selfie configuration for the captureOnly flow.
+ *
+ * captureOnly bypasses the Incode upload/processing pipeline, so this config
+ * intentionally exposes ONLY the options that affect the on-device capture
+ * experience: the tutorial/preview UX, attempts, timeout, and the on-device
+ * face validations. Backend-coupled flags of {@link SelfieConfig} (face
+ * recording, assisted onboarding, on-device results submission, …) don't apply
+ * here and are omitted.
+ *
+ * `onCapture` is the one required field — it receives the captured image
+ * locally (compile-time enforced so you can't ship a captureOnly flow with no
+ * destination for the payload). Everything else is optional and defaulted by
+ * the factory (see `DEFAULT_SELFIE_CAPTURE_ONLY_CONFIG`); set only what you care
+ * about, e.g. `{ onCapture, captureAttempts: 5, validateBrightness: true }`.
+ */
+type SelfieCaptureOnlyConfig = Partial<Pick<SelfieConfig, 'showTutorial' | 'showPreview' | 'captureAttempts' | 'autoCaptureTimeout' | 'validateLenses' | 'validateFaceMask' | 'validateHeadCover' | 'validateClosedEyes' | 'validateBrightness'>> & {
+  onCapture: (response: FaceCaptureOnlyResponse) => void | Promise<void>;
+};
+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;
+  }>;
+  /**
+   * Stops the recorder and returns the raw (un-encrypted, not uploaded)
+   * video as base64. Used by the captureOnly flow, which hands video bytes
+   * to the integrator via `onCapture` instead of uploading to Incode.
+   *
+   * Returns `{ videoBase64: undefined }` when video is not available for
+   * any reason, including:
+   * - the recorder was never started or is already stopped,
+   * - the provider is server-side (e.g. OpenVidu) and the client never
+   *   holds the bytes,
+   * - video assembly fails.
+   */
+  stopAndGetVideo(): Promise<{
+    videoBase64: string | undefined;
+  }>;
+  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;
+  /**
+   * Stable machine-readable error code (a `FaceErrorCode`, e.g.
+   * `NONEXISTENT_CUSTOMER`) when known, in addition to the human-readable
+   * `message`. Lets hosts react to a specific terminal error without parsing
+   * the (server-/locale-dependent) message string.
+   */
+  moduleErrorCode?: 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;
+  /**
+   * Canvas the cosmetic AR avatar renders into, created by `Avatar3DProvider`
+   * and forwarded to the UI for mounting. Only populated while `capture` is
+   * active and `obfuscateWithAvatar` is on; otherwise `undefined`. Display-only
+   * — never read by the capture/upload pipeline.
+   */
+  avatarCanvas: HTMLCanvasElement | undefined;
+  /**
+   * Per-frame `FaceData` channel shared between the detection actor (publisher)
+   * and the avatar actor (subscriber) for the **parked** Incode-data avatar
+   * (`incode-2d`). Currently always `undefined` (no shipped avatar consumes it);
+   * a plain emitter, deliberately NOT routed through XState events to avoid
+   * per-frame subscriber churn. Display-only — never read by the capture/upload
+   * pipeline. Kept as revival plumbing for `incode-2d`.
+   */
+  faceFeed: FaceFeed | undefined;
+  /**
+   * Rich capture payload used only by the captureOnly variant. Populated by
+   * the variant's `.provide()` override of `setUploadResponseFromEvent`,
+   * which writes the `uploadFace` actor's output here instead of the loose
+   * `uploadResponse` channel. Consumed by the captureOnly manager on
+   * transition into `finished`. Remains `undefined` in the regular upload
+   * flow (the base action writes to `uploadResponse` and never touches this
+   * field).
+   */
+  captureOnlyResult: FaceCapturedImageData | undefined;
+};
+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: 'AVATAR_READY';
+  canvas: HTMLCanvasElement;
+} | {
+  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/modules/selfie/selfieCaptureOnlyStateMachine.d.ts
+type SelfieCaptureOnlyContext = FaceCaptureContext;
+type SelfieCaptureOnlyEvent = FaceCaptureEvent;
+type SelfieCaptureOnlyInput = FaceCaptureInput;
+/**
+ * Selfie state machine variant for the captureOnly flow. Shares the full base
+ * face-capture state tree; only the upload/process step is local instead of
+ * remote.
+ */
+declare const selfieCaptureOnlyMachine: AnyStateMachine;
+type SelfieCaptureOnlyMachine = StateMachine<SelfieCaptureOnlyContext, SelfieCaptureOnlyEvent, any, any, any, any, any, any, any, SelfieCaptureOnlyInput, any, any, any, any>;
+//#endregion
+//#region src/modules/selfie/selfieCaptureOnlyActor.d.ts
+type CreateSelfieCaptureOnlyActorOptions = {
+  config: SelfieCaptureOnlyConfig;
+  dependencies?: SelfieDependencies;
+};
+type SelfieCaptureOnlyActor = ActorRefFrom<SelfieCaptureOnlyMachine>;
+//#endregion
+//#region src/internal/faceCapture/faceCaptureManagerFactory.d.ts
+type FaceCaptureActor = SelfieActor | AuthenticationActor | SelfieCaptureOnlyActor;
+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';
+  ageAssurance?: boolean;
+};
+/** 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;
+  ageAssurance?: boolean;
+  /**
+   * Whether on-device face-results submission is enabled
+   * (`onDeviceFaceResultsSubmissionEnabled`). When true, WASM autocapture
+   * never falls back to manual capture and the UI must not show the manual
+   * capture button.
+   */
+  onDeviceMode: boolean;
+  /** Whether the cosmetic AR-avatar overlay is enabled (`obfuscateWithAvatar`). */
+  obfuscateWithAvatar: boolean;
+  /**
+   * Canvas the avatar renders into, for the UI to mount in place of the live
+   * video. `undefined` until the avatar provider has started (or when
+   * `obfuscateWithAvatar` is off). Display-only.
+   */
+  avatarCanvas?: HTMLCanvasElement;
+  /**
+   * Which avatar variant is active, derived from `selfieConcealmentOption`
+   * (`undefined` when no concealing avatar is selected). Display-only — the UI
+   * keeps the face outline for `privacy-lens` (a lens over the real video) but
+   * hides it for the full 2D/3D avatars.
+   */
+  avatarVariant?: AvatarId;
+};
+/** 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;
+  /**
+   * Stable machine-readable error code (a `FaceErrorCode`, e.g.
+   * `NONEXISTENT_CUSTOMER`) when known. Use this — not the `error` message —
+   * to branch on a specific terminal error.
+   */
+  moduleErrorCode?: string;
+};
+/** Union of all possible face capture states */
+type FaceCaptureManagerState = FaceCaptureIdleState | FaceCaptureLoadingState | FaceCaptureTutorialState | FaceCapturePermissionsState | FaceCaptureCaptureState | FaceCaptureProcessingState | FaceCaptureFinishedState | FaceCaptureClosedState | FaceCaptureErrorState;
+/**
+ * Builds a face capture manager (selfie / authentication / captureOnly) from an
+ * already-created actor.
+ *
+ * `visibilityObserver` defaults to the browser `document.visibilitychange`
+ * provider so first-party and BYO-actor callers get foreground/background
+ * events without extra wiring. Construction lives here — a documented, narrow
+ * deviation from "never `new` a provider inside Core" (see
+ * `docs/patterns/CAPABILITY.md`). Pass a fake/no-op to override (tests do).
+ */
+declare function createFaceCaptureManagerFromActor(actor: FaceCaptureActor, moduleName: string, visibilityObserver?: IVisibilityObserverCapability): 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(): Promise<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 { 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 };

package/dist/{faceCaptureSetup-B9t6bYze.esm.js → faceCaptureSetup-CDUVU1nl.esm.js}

@@ -1,11 +1,44 @@
-import { r as getToken } from "./api-CESGtpbH.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-Doec4X5L.esm.js";
-import { d as sendLabelInspectionEvent, f as startDetection, l as initializeCamera, n as preloadOpenViduProvider, p as stopStream, r as flagFaceManualReview, t as createRecordingService, u as initializeDeepsightSession } from "./recordingService-yRw7hfzU.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-DsnEVMhr.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-ImiDQdVA.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-D0wGddy7.esm.js";
+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-Bomq1a0z.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-BJhGL13R.esm.js";
+import { c as sendLabelInspectionEvent, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession } from "./onDeviceFaceResults-DVBggeq8.esm.js";
+import { t as FACE_ERROR_CODES } from "./types-CMcxlSmH.esm.js";
+import { t as createFaceAvatar } from "./createFaceAvatar-BOHDKQRq.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-Bz17q4FP.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BR2oN573.esm.js";
+import { n as preloadOpenViduProvider, r as flagFaceManualReview, t as createRecordingService } from "./recordingService-m_1xCthr.esm.js";
 
+//#region src/internal/avatar/concealment.ts
+/**
+* Maps a backend concealment option to the internal avatar flags. `OPTION_NONE`
+* — and any absent or unknown value, for forward-compat safety — yields the live
+* video (no avatar). The other three map 1:1 onto the shipped avatar catalog:
+*  - `OPTION_3D`         → `avatar-3d` (3D VRM)
+*  - `OPTION_2D`         → `avatar-2d` (stylized 2D face)
+*  - `OPTION_SILHOUETTE` → `privacy-lens` (WebGL frosted-glass conceal)
+*/
+function concealmentToAvatar(option) {
+	switch (option) {
+		case "OPTION_3D": return {
+			obfuscateWithAvatar: true,
+			avatarVariant: "avatar-3d"
+		};
+		case "OPTION_2D": return {
+			obfuscateWithAvatar: true,
+			avatarVariant: "avatar-2d"
+		};
+		case "OPTION_SILHOUETTE": return {
+			obfuscateWithAvatar: true,
+			avatarVariant: "privacy-lens"
+		};
+		default: return {
+			obfuscateWithAvatar: false,
+			avatarVariant: void 0
+		};
+	}
+}
+
+//#endregion
 //#region src/internal/faceCapture/faceCaptureSetup.ts
 const getAttemptsFromConfig = (config) => {
 	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
@@ -68,6 +101,38 @@ const _faceCaptureMachine = setup({
 			});
 			return cleanup;
 		}),
+		runAvatar: fromCallback(({ input, sendBack }) => {
+			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(input.config.selfieConcealmentOption);
+			if (!obfuscateWithAvatar || !input.stream) return () => {};
+			const stream = input.stream;
+			const variant = avatarVariant ?? "avatar-3d";
+			let handle = null;
+			let cancelled = false;
+			(async () => {
+				try {
+					const created = await createFaceAvatar({
+						variant,
+						stream,
+						assets: input.config.avatarAssets
+					});
+					if (cancelled) {
+						created.stop();
+						return;
+					}
+					handle = created;
+					sendBack({
+						type: "AVATAR_READY",
+						canvas: created.canvas
+					});
+				} catch (err) {
+					console.warn("[face-avatar] failed to start avatar overlay", err);
+				}
+			})();
+			return () => {
+				cancelled = true;
+				handle?.stop();
+			};
+		}),
 		initializeDeepsightSession: fromPromise(async ({ input }) => {
 			return await initializeDeepsightSession({
 				ds: input.ds,
@@ -110,7 +175,8 @@ const _faceCaptureMachine = setup({
 			return {
 				stream: void 0,
 				provider: void 0,
-				frameCapturer: void 0
+				frameCapturer: void 0,
+				avatarCanvas: void 0
 			};
 		}),
 		setStreamAndCapturer: assign({
@@ -144,7 +210,8 @@ const _faceCaptureMachine = setup({
 			resetDetection: void 0,
 			deepsightService: void 0,
 			manualCaptureTriggered: false,
-			captureOnlyResult: void 0
+			captureOnlyResult: void 0,
+			avatarCanvas: void 0
 		})),
 		resetDetection: ({ context }) => {
 			context.resetDetection?.();
@@ -168,7 +235,8 @@ const _faceCaptureMachine = setup({
 			return {
 				stream: void 0,
 				provider: void 0,
-				frameCapturer: void 0
+				frameCapturer: void 0,
+				avatarCanvas: void 0
 			};
 		}),
 		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
@@ -194,6 +262,8 @@ const _faceCaptureMachine = setup({
 			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 }),
 		setCapturedImageFromEvent: assign({
 			capturedImage: ({ event }) => event.canvas,
@@ -273,7 +343,9 @@ const _faceCaptureMachine = setup({
 		encryptedBase64Image: void 0,
 		uploadRecordingId: void 0,
 		manualCaptureTriggered: false,
-		captureOnlyResult: void 0
+		captureOnlyResult: void 0,
+		avatarCanvas: void 0,
+		faceFeed: void 0
 	}),
 	on: { QUIT: { target: "#faceCapture.closed" } },
 	states: {
@@ -612,13 +684,25 @@ const _faceCaptureMachine = setup({
 								frameCapturer: context.frameCapturer,
 								provider: context.provider,
 								config: context.config,
-								manualCaptureTriggered: context.manualCaptureTriggered
+								manualCaptureTriggered: context.manualCaptureTriggered,
+								faceFeed: context.faceFeed
+							})
+						},
+						{
+							id: "runAvatar",
+							src: "runAvatar",
+							input: ({ context }) => ({
+								stream: context.stream,
+								config: context.config,
+								faceFeed: context.faceFeed
 							})
 						}
 					],
+					exit: ["clearAvatarCanvas"],
 					on: {
 						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
 						DETECTION_FRAME: { actions: "setDebugFrameFromEvent" },
+						AVATAR_READY: { actions: "setAvatarCanvas" },
 						DETECTION_RESET_READY: { actions: "setResetDetectionFromEvent" },
 						DETECTION_SUCCESS: {
 							target: "capturing",
@@ -755,4 +839,4 @@ const _faceCaptureMachine = setup({
 const faceCaptureMachine = _faceCaptureMachine;
 
 //#endregion
-export { faceCaptureMachine as t };
+export { concealmentToAvatar as n, faceCaptureMachine as t };

package/dist/{faceMatchStateMachine-DeXXzSuz.esm.js → faceMatchStateMachine-DUeUjEPx.esm.js}

@@ -1,6 +1,6 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
 
 //#region src/modules/face-match/constants.ts
 /**

package/dist/field-comparison.d.ts

@@ -1,4 +1,5 @@
-import "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { a as FieldComparisonActor, c as FieldComparisonFields, i as createFieldComparisonManagerFromActor, n as FieldComparisonState, o as fieldComparisonMachine, r as createFieldComparisonManager, s as FieldComparisonConfig, t as FieldComparisonManager } from "./fieldComparisonManager-Bu5TaSr3.js";
+import "./StateMachine-C_AY4cs7.js";
+import "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { a as FieldComparisonActor, c as FieldComparisonFields, i as createFieldComparisonManagerFromActor, n as FieldComparisonState, o as fieldComparisonMachine, r as createFieldComparisonManager, s as FieldComparisonConfig, t as FieldComparisonManager } from "./fieldComparisonManager-DdLqDeB2.js";
 export { type FieldComparisonActor, type FieldComparisonConfig, type FieldComparisonFields, type FieldComparisonManager, type FieldComparisonState, createFieldComparisonManager, createFieldComparisonManagerFromActor, fieldComparisonMachine };

package/dist/field-comparison.esm.js

@@ -1,7 +1,8 @@
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import { n as createFieldComparisonManagerFromActor, r as fieldComparisonMachine, t as createFieldComparisonManager } from "./fieldComparisonManager-COGI2ARD.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import { n as createFieldComparisonManagerFromActor, r as fieldComparisonMachine, t as createFieldComparisonManager } from "./fieldComparisonManager-B9W0a9A5.esm.js";
 
 export { createFieldComparisonManager, createFieldComparisonManagerFromActor, fieldComparisonMachine };

package/dist/{fieldComparisonManager-COGI2ARD.esm.js → fieldComparisonManager-B9W0a9A5.esm.js}

@@ -1,7 +1,8 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, l as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
 
 //#region src/modules/field-comparison/fieldComparisonServices.ts
 /** Submit first and last name for backend field comparison. Throws on failure. */

package/dist/{fieldComparisonManager-Bu5TaSr3.d.ts → fieldComparisonManager-DdLqDeB2.d.ts}

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
 
 //#region src/modules/field-comparison/types.d.ts
 

package/dist/fiscal-qr.d.ts

@@ -1,6 +1,8 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./camera-SRBpPq2X.js";
-import "./StreamCanvasCapture-yyl20qd9.js";
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./camera-CNVUo-bC.js";
+import "./canvas-CJUmoXSD.js";
+import "./StreamCanvasCapture-DS1TOoiH.js";
 
 //#region src/modules/fiscal-qr/types.d.ts
 /**

package/dist/fiscal-qr.esm.js

@@ -1,15 +1,16 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { h as addEvent, n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import "./platform-SKvEfCBh.esm.js";
-import { a as fromPromise, c as createManager, i as fromCallback, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { i as stopCameraStream } from "./camera-DJWm3V4g.esm.js";
-import "./ITimerCapability-CB0I1Uf2.esm.js";
-import "./canvas-SKcRBxsk.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-D7Wo4Nbx.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-ImiDQdVA.esm.js";
-import "./http-Cai3IoLS.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { d as addEvent, n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import "./platform-uIVQUnJP.esm.js";
+import { a as fromPromise, i as fromCallback, l as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { a as stopCameraStream } from "./camera-DUkgmYMo.esm.js";
+import "./ITimerCapability-pltuG1E8.esm.js";
+import "./canvas-_I95hkPg.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-ZyqrFyjO.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-Bz17q4FP.esm.js";
+import "./http-BkiUT7EB.esm.js";
 import { BrowserQRCodeReader } from "@zxing/browser";
 
 //#region src/modules/fiscal-qr/fiscalQrConstants.ts