@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/{deepsightService-DLVQS_RH.d.ts → StreamCanvasCapture-_8gdW5Lk.d.ts}

@@ -1,43 +1,6 @@
+import { y as IncodeCanvas } from "./createFaceAvatar-BlcTYgJv.js";
+import "./IWasmUtilCapability-CNWRl7jr.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { o as IncodeCanvas } from "./IStorageCapability-ORkQfK3F.js";
-//#region ../infra/src/media/StreamCanvasCapture.d.ts
-type StreamCanvasCaptureOptions = {
-  fps?: number;
-  width?: number;
-  height?: number;
-};
-type StreamCanvasCaptureEventMap = {
-  frame: Event;
-};
-declare class StreamCanvasCapture {
-  private video;
-  private canvas;
-  private ctx;
-  private rafId;
-  private lastFrameTimeSeconds;
-  private lastTickTimeMs;
-  private hasFrame;
-  private disposed;
-  private eventTarget;
-  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
-  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
-  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
-  /**
-   * Returns the latest cached frame as an {@link IncodeCanvas}.
-   */
-  getLatestCanvas(): IncodeCanvas | null;
-  /**
-   * Returns the latest cached frame as raw {@link ImageData}.
-   */
-  getLatestFrame(): ImageData | null;
-  /**
-   * Disposes internal resources and stops the capture loop.
-   */
-  dispose(): void;
-  private rafLoop;
-  private tick;
-}
-//#endregion
 //#region ../infra/src/capabilities/IMotionSensorCapability.d.ts
 type MotionStatus = 'PASS' | 'FAIL' | 'UNCLEAR';
 type MotionPermissionState = 'granted' | 'denied' | 'not-required';
@@ -86,7 +49,6 @@ type DeepsightService = {
   initialize(disableIpify?: boolean, disableFingerprint?: boolean): Promise<void>;
   requestMotionPermission(): Promise<'granted' | 'denied' | 'not-required'>;
   startMotionSensors(): Promise<void>;
-  primeWasmMotionSensor(): Promise<void>;
   stopMotionSensors(): void;
   checkVirtualCamera(videoTrack: MediaStreamTrack): Promise<boolean>;
   performVirtualCameraCheck(sessionToken: string | null, source: FrameSource): Promise<void>;
@@ -95,6 +57,12 @@ type DeepsightService = {
    */
   performPrcCheck(params: DeepsightPrcCheckParams): Promise<void>;
   analyzeFrame(imageData: ImageData): Promise<void>;
+  /**
+   * Finalizes non-frame DeepSight metadata after a protected WASM capture.
+   * The protected runtime owns frame analysis, so this intentionally does not
+   * call the host-supplied `analyzeFrame` fallback.
+   */
+  finalizeProtectedCaptureMetadata(): Promise<void>;
   getMetadata(): string;
   getMotionStatus(): string;
   getAnalysisStatus(): string;
@@ -105,4 +73,49 @@ type DeepsightPrcCheckParams = {
   constraints: MediaStreamConstraints;
 };
 //#endregion
-export { StreamCanvasCapture as n, DeepsightService as t };
+//#region ../infra/src/media/StreamCanvasCapture.d.ts
+type StreamCanvasCaptureOptions = {
+  fps?: number;
+  width?: number;
+  height?: number;
+  /**
+   * Keep a canvas cache updated from requestAnimationFrame. Defaults to true.
+   * Set false when a caller only needs an occasional presentation snapshot;
+   * `getLatestCanvas`/`getLatestFrame` will draw the current video frame on
+   * demand without running a duplicate per-frame loop.
+   */
+  continuous?: boolean;
+};
+type StreamCanvasCaptureEventMap = {
+  frame: Event;
+};
+declare class StreamCanvasCapture {
+  private video;
+  private canvas;
+  private ctx;
+  private rafId;
+  private lastFrameTimeSeconds;
+  private lastTickTimeMs;
+  private hasFrame;
+  private disposed;
+  private eventTarget;
+  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
+  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+  /**
+   * Returns the latest cached frame as an {@link IncodeCanvas}.
+   */
+  getLatestCanvas(): IncodeCanvas | null;
+  /**
+   * Returns the latest cached frame as raw {@link ImageData}.
+   */
+  getLatestFrame(): ImageData | null;
+  /**
+   * Disposes internal resources and stops the capture loop.
+   */
+  dispose(): void;
+  private rafLoop;
+  private tick;
+}
+//#endregion
+export { DeepsightService as n, StreamCanvasCapture as t };

package/dist/StreamCanvasProcessingSession-CBnbTnOr.esm.js

@@ -0,0 +1,42 @@
+//#region ../infra/src/media/StreamCanvasProcessingSession.ts
+var StreamCanvasProcessingSession = class {
+	/**
+	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
+	* and drives a provider's `processFrame()` method with backpressure.
+	*/
+	constructor(params) {
+		this.disposed = false;
+		this.isProcessing = false;
+		this.onFrameEvent = () => {
+			if (this.disposed || this.isProcessing) return;
+			const frame = this.capturer.getLatestFrame();
+			if (!frame) return;
+			this.onFrame?.(frame);
+			this.isProcessing = true;
+			this.provider.processFrame(frame).catch(() => {}).finally(() => {
+				this.isProcessing = false;
+			});
+		};
+		this.capturer = params.capturer;
+		this.provider = params.provider;
+		this.onFrame = params.onFrame;
+		this.capturer.addEventListener("frame", this.onFrameEvent);
+	}
+	/**
+	* Unsubscribes from frame events and resets the provider.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.capturer.removeEventListener("frame", this.onFrameEvent);
+		this.provider.reset();
+	}
+	/**
+	* Returns whether the session has been disposed.
+	*/
+	isDisposed() {
+		return this.disposed;
+	}
+};
+//#endregion
+export { StreamCanvasProcessingSession as t };

package/dist/{addressSearch-D1XpBdUS.esm.js → addressSearch-DyHGgeX8.esm.js}

@@ -1,6 +1,6 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 const usStateOptions = Object.values({
 	AL: {

package/dist/advanceableErrors-CpF2cBy6.esm.js

@@ -0,0 +1,21 @@
+import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
+//#region src/internal/orchestration/advanceableErrors.ts
+const VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE = "VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED";
+/**
+* Module terminal-error codes an orchestrator should treat as "advance to the
+* next step" rather than "fail the flow". Decided here, at the orchestration
+* layer, so every consumer behaves identically. "Advanceable" is independent of
+* "retryable" (the module's own concern): it only decides what the flow does
+* *after* a terminal error. Note `NO_MORE_ATTEMPTS` subsumes the former
+* `USER_IS_NOT_RECOGNIZED` entry — see the contract test for the full matrix.
+*/
+const ADVANCEABLE_ERROR_CODES = [
+	FACE_ERROR_CODES.NONEXISTENT_CUSTOMER,
+	FACE_ERROR_CODES.HINT_NOT_PROVIDED,
+	FACE_ERROR_CODES.NO_MORE_ATTEMPTS,
+	VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE
+];
+/** True when the given code is a module terminal error the flow should advance past rather than fail on. */
+const isAdvanceableError = (moduleErrorCode) => moduleErrorCode !== void 0 && ADVANCEABLE_ERROR_CODES.includes(moduleErrorCode);
+//#endregion
+export { isAdvanceableError as n, VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE as t };

package/dist/ae-signature.d.ts

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-CQQ99QOI.js";
-import { _ as getDefaultConsentChecks, a as ElectronicSignatureConfig, h as areAllConsented, i as ConsentKey, r as ConsentChecks, s as ElectronicSignatureDocument, t as AE_CONSENT_KEYS } from "./types-DVmXIdzW.js";
-import { n as ElectronicSignatureState, o as electronicSignatureMachine } from "./electronicSignatureManager-CcUXQZS7.js";
+import { S as getDefaultConsentChecks, a as ElectronicSignatureConfig, b as areAllConsented, i as ConsentKey, r as ConsentChecks, s as ElectronicSignatureDocument, t as AE_CONSENT_KEYS } from "./types-D0gekt4U.js";
+import { n as ElectronicSignatureState, o as electronicSignatureMachine } from "./electronicSignatureManager-Ds-KEVTq.js";
 import "./electronic-signature.js";
 //#region src/modules/ae-signature/index.d.ts
 type AeSignatureConfig = Omit<ElectronicSignatureConfig, 'variant'>;
@@ -14,6 +14,8 @@ declare function createAeSignatureManager(options: {
   confirmFile(): void;
   viewDocument(url: string): void;
   closeDocumentView(): void;
+  viewApplicationForm(): void;
+  closeApplicationForm(): void;
   sign(): void;
   finish(): void;
   retry(): void;

package/dist/ae-signature.esm.js

@@ -1,4 +1,4 @@
-import { c as getDefaultConsentChecks, i as AE_CONSENT_KEYS, o as areAllConsented, r as electronicSignatureMachine, t as createElectronicSignatureManager } from "./electronicSignatureManager-DGbAJ00W.esm.js";
+import { c as areAllConsented, i as AE_CONSENT_KEYS, r as electronicSignatureMachine, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-BJJH0Tvi.esm.js";
 //#region src/modules/ae-signature/index.ts
 function createAeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/antifraud.esm.js

@@ -1,3 +1,3 @@
-import { t as antifraudMachine } from "./antifraudStateMachine-Bf_JVNwn.esm.js";
-import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-CQFNgSPt.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-DBeq47D2.esm.js";
+import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-DNkw66oW.esm.js";
 export { antifraudMachine, createAntifraudManager, createAntifraudManagerFromActor };

package/dist/{antifraudManager-CQFNgSPt.esm.js → antifraudManager-DNkw66oW.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as antifraudMachine } from "./antifraudStateMachine-Bf_JVNwn.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-DBeq47D2.esm.js";
 //#region src/modules/antifraud/antifraudActor.ts
 function createAntifraudActor() {
 	return createActor(antifraudMachine).start();

package/dist/{antifraudStateMachine-Bf_JVNwn.esm.js → antifraudStateMachine-DBeq47D2.esm.js}

@@ -1,5 +1,5 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 //#region src/modules/antifraud/antifraudServices.ts

package/dist/{apiError-BA1d_au0.esm.js → apiError-Budb6m6w.esm.js}

@@ -1,4 +1,4 @@
-import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService---iW2KKJ.esm.js";
+import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-BN-Hzw82.esm.js";
 //#region src/internal/http/apiError.ts
 /**
 * Incode API error.
@@ -46,6 +46,18 @@ function isConnectivityError(err) {
 	return isHttpError(err) && err.status === 0;
 }
 /**
+* True when an error represents a failure that is the server's fault (or the
+* network's) rather than the caller's — HTTP `5xx`, or connectivity loss
+* (see {@link isConnectivityError}). Useful for callers that want to offer a
+* "Try again" retry only for these, while a `4xx` (the caller sent something
+* the backend rejected) is left for the caller to handle on its own terms —
+* retrying the identical payload would just fail again.
+*/
+function isServerError(err) {
+	if (isConnectivityError(err)) return true;
+	return err instanceof IncodeApiError && (err.httpStatus >= 500 || err.httpStatus === 0);
+}
+/**
 * Convert an unknown error caught from `api.{get,post,...}` into an
 * `IncodeApiError`, extracting the Incode-specific status and message from
 * the response body when present. The original error is preserved on
@@ -70,4 +82,4 @@ function logHttpFailureBreadcrumb(message, endpoint) {
 	} catch {}
 }
 //#endregion
-export { isConnectivityError as n, toIncodeApiError as r, IncodeApiError as t };
+export { toIncodeApiError as i, isConnectivityError as n, isServerError as r, IncodeApiError as t };

package/dist/authentication.d.ts

@@ -1,4 +1,4 @@
-import { b as createAuthenticationActor, v as AuthenticationActor, x as authenticationMachine, y as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-BxWPpxyd.js";
-import { t as AuthenticationConfig } from "./types-EELWyWpd.js";
-import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-BBMGTcwW.js";
+import { C as authenticationMachine, S as createAuthenticationActor, b as AuthenticationActor, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-BeUl8fl1.js";
+import { t as AuthenticationConfig } from "./types-ChAowIxT.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-CjXBjC-c.js";
 export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authentication.esm.js

@@ -1,3 +1,3 @@
-import { t as authenticationMachine } from "./authenticationStateMachine-xzi-vnvE.esm.js";
-import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-zh9TC62P.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-MOYz4HCf.esm.js";
+import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-cMXhG70r.esm.js";
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-BBMGTcwW.d.ts → authenticationManager-CjXBjC-c.d.ts}

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { n as FaceCaptureManagerState, t as FaceCaptureManager, v as AuthenticationActor, y as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-BxWPpxyd.js";
+import { b as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-BeUl8fl1.js";
 //#region src/modules/authentication/authenticationManager.d.ts
 type AuthenticationState = FaceCaptureManagerState;
 /**
@@ -22,6 +22,9 @@ declare function createAuthenticationManagerFromActor(actor: AuthenticationActor
   reset(): void;
   retryCapture(): void;
   capture(): void;
+  goToManualUpload(): void;
+  manualUploadSelectFile(file: File): void;
+  manualUploadContinue(): void;
 };
 /**
  * Creates an authentication manager instance for handling face authentication flow.
@@ -69,6 +72,9 @@ declare function createAuthenticationManager(options: CreateAuthenticationActorO
   reset(): void;
   retryCapture(): void;
   capture(): void;
+  goToManualUpload(): void;
+  manualUploadSelectFile(file: File): void;
+  manualUploadContinue(): void;
 };
 type AuthenticationManager = FaceCaptureManager;
 //#endregion

package/dist/{authenticationManager-zh9TC62P.esm.js → authenticationManager-cMXhG70r.esm.js}

@@ -1,9 +1,9 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
-import { n as eventModuleNames } from "./events-DYiyoSlx.esm.js";
+import { l as BrowserStorageProvider } from "./setup-BWG-hivt.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-CVnZ0fa5.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-xzi-vnvE.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-B7Ms6pSs.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-MOYz4HCf.esm.js";
 //#region src/modules/authentication/authenticationActor.ts
 function createAuthenticationActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{authenticationStateMachine-xzi-vnvE.esm.js → authenticationStateMachine-MOYz4HCf.esm.js}

@@ -1,12 +1,9 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
 import { i as assign } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-Cd-04W_X.esm.js";
-import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-9y-kbVDw.esm.js";
+import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-bkAlr5d8.esm.js";
+import { c as isOnDeviceMode } from "./FaceDetectionProvider-BfhWkK90.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
+import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-CX3hJGKc.esm.js";
 //#region src/modules/authentication/authenticationErrorUtils.ts
 const AUTH_ERROR_MAP = {
 	SPOOF_ATTEMPT_DETECTED: FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED,
@@ -42,46 +39,6 @@ const isTerminalAuthError = (response, attemptsRemaining) => {
 	return false;
 };
 //#endregion
-//#region src/modules/authentication/authenticationUploadService.ts
-async function uploadAuthFace(params) {
-	try {
-		const payload = {
-			base64Image: params.encryptedBase64Image,
-			faceCoordinates: params.faceCoordinates ?? void 0,
-			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() },
-			metadata: params.metadata ?? void 0,
-			...params.authHint !== void 0 && { hint: params.authHint }
-		};
-		const query = {};
-		if (params.recordingId) query.recordingId = params.recordingId;
-		const res = await api.post(endpoints.authenticate, payload, {
-			signal: params.signal,
-			query
-		});
-		if (!res.ok) throw new Error(`POST ${endpoints.authenticate} failed: ${res.status} ${res.statusText}`);
-		if (params.deepsightService) addDeviceStats({
-			frontIdStatsAnalysisStatus: "",
-			backIdStatsAnalysisStatus: "",
-			selfieStatsAnalysisStatus: params.deepsightService.getAnalysisStatus(),
-			motionStatus: params.deepsightService.getMotionStatus()
-		});
-		return res.data;
-	} catch (error) {
-		const errorCode = getAuthErrorCodeFromHttpError(error);
-		if (errorCode) throw new Error(errorCode);
-		throw new Error(FACE_ERROR_CODES.SERVER);
-	}
-}
-const getAuthErrorCodeFromHttpError = (error) => {
-	const err = error;
-	if (err.ok !== false || typeof err.status !== "number") return;
-	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
-	const errorName = err.data?.error?.name;
-	if (!errorName) return FACE_ERROR_CODES.BAD_REQUEST;
-	return AUTH_ERROR_MAP[errorName] ?? FACE_ERROR_CODES.BAD_REQUEST;
-};
-//#endregion
 //#region src/modules/authentication/authenticationStateMachine.ts
 /**
 * Narrow the base machine's opaque `uploadResponse` (Record<string, unknown>)
@@ -90,22 +47,9 @@ const getAuthErrorCodeFromHttpError = (error) => {
 const authUploadResponse = (context) => context.uploadResponse;
 const authenticationMachine = faceCaptureMachine.provide({
 	actors: {
-		prepareFaceUpload: fromPromise(async ({ input }) => {
-			const ctx = input;
-			return isOnDeviceMode(ctx.config) ? prepareOnDeviceFaceUpload(ctx) : defaultPrepareFaceUpload(ctx);
-		}),
-		uploadFace: fromPromise(async ({ input, signal }) => {
-			const ctx = input;
-			if (isOnDeviceMode(ctx.config)) return postOnDeviceFaceResults(ctx, signal);
-			return uploadAuthFace({
-				encryptedBase64Image: ctx.encryptedBase64Image,
-				faceCoordinates: ctx.faceCoordinates,
-				authHint: ctx.authHint,
-				metadata: ctx.deepsightService?.getMetadata(),
-				recordingId: ctx.uploadRecordingId,
-				deepsightService: ctx.deepsightService ?? void 0,
-				signal
-			});
+		protectedFaceController: createDefaultProtectedFaceControllerActor({
+			target: PROTECTED_CAPTURE_TARGET.authentication,
+			delivery: "protected"
 		}),
 		processFace: fromPromise(async () => ({}))
 	},

package/dist/avatar.d.ts

@@ -1,3 +1,2 @@
-import { n as AvatarFaceState } from "./IFaceAvatarCapability-BrL19G0s.js";
-import { i as createFaceAvatar, n as FaceAvatarHandle, r as FaceAvatarOptions, t as AvatarId } from "./createFaceAvatar-BEj18KXi.js";
+import { i as createFaceAvatar, n as FaceAvatarHandle, o as AvatarFaceState, r as FaceAvatarOptions, t as AvatarId } from "./createFaceAvatar-BlcTYgJv.js";
 export { type AvatarFaceState, type AvatarId, type FaceAvatarHandle, type FaceAvatarOptions, createFaceAvatar };

package/dist/avatar.esm.js

@@ -1,2 +1,2 @@
-import { t as createFaceAvatar } from "./createFaceAvatar-DQKaRise.esm.js";
+import { t as createFaceAvatar } from "./createFaceAvatar-BNHdeFj8.esm.js";
 export { createFaceAvatar };

package/dist/{backCameraStream-CUeYm5eu.esm.js → backCameraStream-BOtyQowf.esm.js}

@@ -1,7 +1,7 @@
-import { i as isIOS, o as isIPhone14OrHigher, r as isDesktop, s as isSafari, t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
-import { a as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-_2sXMXiF.esm.js";
+import { a as isIOS, c as isIPhone14OrHigher, d as isSafari, i as isDesktop, t as isAndroid } from "./platform-DkcRc9JV.esm.js";
+import { i as requestCameraAccess, n as enumerateVideoDevices, o as stopCameraStream, t as applyTrackConstraints } from "./camera-sIa9ceW2.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
-import { t as getBrowser } from "./getBrowser-DNrQeL4T.esm.js";
+import { t as getBrowser } from "./getBrowser-Cbe1C4Tn.esm.js";
 //#region src/internal/camera/backCameraStream.ts
 const BACK_CAMERA_KEYWORDS = [
 	"rear",
@@ -46,6 +46,10 @@ function isBackCameraLabel(label) {
 	const lowercaseLabel = label.toLowerCase();
 	return BACK_CAMERA_KEYWORDS.some((keyword) => lowercaseLabel.includes(keyword));
 }
+function isBackFacingTrack(track) {
+	const settings = track.getSettings();
+	return isBackCameraLabel(track.label) || settings.facingMode === "environment";
+}
 function classifyCamera(device, index, totalDevices) {
 	let cameraType;
 	if (device.label === "") cameraType = totalDevices === 1 || index + 1 <= totalDevices / 2 ? "front" : "back";
@@ -97,7 +101,7 @@ function selectMainCameraFromStream(track, cameras) {
 	const settings = track.getSettings();
 	const activeCamera = cameras.find((c) => c.deviceId === settings.deviceId || c.label !== "" && c.label === track.label);
 	if (!activeCamera) return void 0;
-	if ((settings.facingMode === "environment" || isBackCameraLabel(track.label)) && cameras.length > 1) {
+	if (isBackFacingTrack(track) && cameras.length > 1) {
 		cameras.forEach((camera) => {
 			if (camera.deviceId === activeCamera.deviceId) camera.cameraType = "back";
 			else if (!isBackCameraLabel(camera.label)) camera.cameraType = "front";
@@ -209,8 +213,11 @@ async function getAndroidBackCameraStream(fallbackLevel = 0) {
 		const mainCamera = selectMainCameraFromStream(track, await getCameras());
 		stopCameraStream(initialStream);
 		if (!mainCamera) throw new Error("Could not identify main camera");
+		const acquisitionConstraints = getAndroidFinalConstraints(mainCamera, fallbackLevel);
+		const finalStream = await requestCameraAccess({ video: acquisitionConstraints });
 		return {
-			stream: await requestCameraAccess({ video: getAndroidFinalConstraints(mainCamera, fallbackLevel) }),
+			stream: finalStream,
+			constraints: await applyAutofocusHint(finalStream, acquisitionConstraints),
 			fallbackLevel
 		};
 	} catch (error) {
@@ -228,16 +235,52 @@ async function getAndroidBackCameraStream(fallbackLevel = 0) {
 	}
 }
 async function getFirefoxAndroidBackCameraStream() {
+	const requestConstraints = getDesktopConstraints({ facingMode: "environment" });
+	const acquisitionConstraints = getVideoTrackConstraints(requestConstraints);
+	const stream = await requestCameraAccess(requestConstraints);
 	return {
-		stream: await requestCameraAccess(getDesktopConstraints({ facingMode: "environment" })),
+		stream,
+		constraints: await applyAutofocusHint(stream, acquisitionConstraints),
 		fallbackLevel: 0
 	};
 }
-async function applyFocusHint(stream) {
+/**
+* Preserve SDK 1's iOS focus-distance hint and request the browser's continuous
+* autofocus mode on any selected back-camera track that advertises it.
+*
+* This is deliberately capability-gated and best-effort. A fixed focus
+* distance on Android can blur a close document, while an unsupported advanced
+* constraint must never make camera acquisition fail.
+*/
+async function applyAutofocusHint(stream, acquisitionConstraints, includeIOSFocusDistance = false) {
 	const videoTrack = stream.getVideoTracks()[0];
+	if (!videoTrack) return acquisitionConstraints;
+	let focusMode;
 	try {
-		await applyTrackConstraints(videoTrack, { advanced: [{ focusDistance: 1 }] });
+		const advertisedModes = (videoTrack.getCapabilities?.())?.focusMode;
+		const supportedModes = Array.isArray(advertisedModes) ? advertisedModes : advertisedModes ? [advertisedModes] : [];
+		focusMode = supportedModes.includes("continuous") ? "continuous" : supportedModes.includes("auto") ? "auto" : void 0;
 	} catch {}
+	if (!focusMode && !includeIOSFocusDistance) return acquisitionConstraints;
+	const focusConstraints = {
+		...focusMode ? { focusMode } : {},
+		...includeIOSFocusDistance ? { focusDistance: 1 } : {}
+	};
+	const constraints = {
+		...acquisitionConstraints,
+		advanced: [...acquisitionConstraints.advanced ?? [], focusConstraints]
+	};
+	try {
+		await applyTrackConstraints(videoTrack, constraints);
+		return constraints;
+	} catch {
+		try {
+			await applyTrackConstraints(videoTrack, { advanced: [focusConstraints] });
+			return constraints;
+		} catch {
+			return acquisitionConstraints;
+		}
+	}
 }
 function getIOSConstraints() {
 	return {
@@ -250,9 +293,13 @@ function getIOSConstraints() {
 	};
 }
 async function getIOSCameraStream() {
-	const stream = await requestCameraAccess(getIOSConstraints());
-	await applyFocusHint(stream);
-	return stream;
+	const requestConstraints = getIOSConstraints();
+	const acquisitionConstraints = getVideoTrackConstraints(requestConstraints);
+	const stream = await requestCameraAccess(requestConstraints);
+	return {
+		stream,
+		constraints: await applyAutofocusHint(stream, acquisitionConstraints, true)
+	};
 }
 function getDesktopVideoConstraints(level) {
 	switch (level) {
@@ -331,17 +378,26 @@ function getDesktopConstraints(options, level = 0) {
 		}
 	};
 }
-async function getDesktopCameraStream(options, fallbackLevel = 0) {
+function getVideoTrackConstraints(constraints) {
+	return constraints.video && typeof constraints.video !== "boolean" ? constraints.video : {};
+}
+async function getDesktopCameraStreamResult(options, fallbackLevel = 0) {
 	if (fallbackLevel > 5) throw new Error("Failed to get desktop camera after all fallback attempts");
 	const constraints = getDesktopConstraints(options, fallbackLevel);
 	try {
-		return await requestCameraAccess(constraints);
+		return {
+			stream: await requestCameraAccess(constraints),
+			constraints: getVideoTrackConstraints(constraints)
+		};
 	} catch (error) {
 		const nextLevel = fallbackLevel + 1;
 		if (nextLevel > 5) throw error;
-		return getDesktopCameraStream(options, nextLevel);
+		return getDesktopCameraStreamResult(options, nextLevel);
 	}
 }
+async function getDesktopCameraStream(options, fallbackLevel = 0) {
+	return (await getDesktopCameraStreamResult(options, fallbackLevel)).stream;
+}
 /**
 * Pick the best back-facing device from a list already filtered by label.
 * Prefers the highest megapixel count when labels advertise it, else the first.
@@ -377,17 +433,17 @@ function selectBestBackDevice(devices) {
 * An explicit deviceId from the caller is always trusted as-is.
 */
 async function getDesktopBackCameraStream(deviceId) {
-	if (deviceId) return getDesktopCameraStream({ deviceId });
-	const original = await getDesktopCameraStream({ facingMode: "environment" });
-	const track = original.getVideoTracks()[0];
+	if (deviceId) return getDesktopCameraStreamResult({ deviceId });
+	const original = await getDesktopCameraStreamResult({ facingMode: "environment" });
+	const track = original.stream.getVideoTracks()[0];
 	if (track && isBackCameraLabel(track.label)) return original;
 	const backDevices = (await enumerateVideoDevices()).filter((d) => isBackCameraLabel(d.label));
 	if (backDevices.length === 0) return original;
 	const target = selectBestBackDevice(backDevices);
 	if (track && track.getSettings().deviceId === target.deviceId) return original;
 	try {
-		const corrected = await getDesktopCameraStream({ deviceId: target.deviceId });
-		stopCameraStream(original);
+		const corrected = await getDesktopCameraStreamResult({ deviceId: target.deviceId });
+		stopCameraStream(original.stream);
 		return corrected;
 	} catch {
 		return original;
@@ -431,12 +487,17 @@ async function ensureFrontCameraStream(open) {
 	}
 }
 async function getBackCameraStream(deviceId) {
-	if (isIOS()) return { stream: await getIOSCameraStream() };
+	if (isIOS()) return getIOSCameraStream();
 	if (isAndroid()) {
 		if (getBrowser() === "firefox") return getFirefoxAndroidBackCameraStream();
 		return getAndroidBackCameraStream(0);
 	}
-	return { stream: await getDesktopBackCameraStream(deviceId) };
+	const acquired = await getDesktopBackCameraStream(deviceId);
+	const constraints = await applyAutofocusHint(acquired.stream, acquired.constraints);
+	return {
+		stream: acquired.stream,
+		constraints
+	};
 }
 //#endregion
-export { hasBackCamera as i, getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };
+export { isBackFacingTrack as a, hasBackCamera as i, getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };