@incodetech/core 0.0.0-dev-20260911-aec162f0 → 0.0.0-dev-20260914-8aef7789

package/dist/FaceDetectionProvider-CyLxkzRP.d.ts

@@ -0,0 +1,36 @@
+import { c as FaceAttributesThresholds, d as FaceDetectionCallbacks, f as FaceDetectionConfig, h as IFaceDetectionCapability, l as FaceChecksConfig, m as FacePositionConstraints, p as FaceDetectionThresholds, v as WebApiHostRequestConfig } from "./createFaceAvatar-CTM9aj9Q.js";
+import { t as BaseWasmProvider } from "./BaseWasmProvider-CO0GfaHM.js";
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
+declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
+  private defaultThresholds;
+  private currentThresholds;
+  private currentFrame;
+  private onFaceDataCallback;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  /**
+   * Last-registered onCapture callback — captured into a private
+   * field so `forceCapture()` (called from outside the WASM-callback
+   * lifecycle) can re-fire the same wrapper. `setCallbacks` rebinds
+   * this on each invocation, so the field always reflects the
+   * current consumer.
+   */
+  private currentOnCaptureWrapper;
+  processPhoto(canvas: HTMLCanvasElement): void;
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+  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;
+  forceCapture(): void;
+  reset(): void;
+  private createDefaultFaceCoordinates;
+  private formatFaceCoordinates;
+}
+//#endregion
+export { FaceDetectionProvider as t };

package/dist/{IIdCaptureCapability-DDWlQzhi.d.ts → IIdCaptureCapability-nfpic2z2.d.ts}

@@ -1,5 +1,5 @@
-import "./warmup-CXHBgvFC.js";
-import { _ as MLProviderConfig, g as IMLProviderCapability, y as IncodeCanvas } from "./createFaceAvatar-pUEkdk4X.js";
+import "./warmup-Cis2p6O0.js";
+import { _ as MLProviderConfig, g as IMLProviderCapability, y as IncodeCanvas } from "./createFaceAvatar-CTM9aj9Q.js";
 //#region ../infra/src/wasm/mlWasmBridgeTypes.d.ts
 /**
  * Decoded PDF417 barcode surfaced from the WASM ID-capture pipeline during
@@ -72,7 +72,11 @@ interface IdCaptureCallbacks {
   onBlur?: () => void;
   onGlare?: () => void;
   onCapturing?: () => void;
-  onCapture?: () => void;
+  /**
+   * Receives the exact best-shot canvas detached by the Core ID workflow.
+   * The canvas is presentation-only; protected submission remains native-owned.
+   */
+  onCapture?: (canvas?: HTMLCanvasElement | null) => void;
   onBestFrame?: (blur: number, glare: number, orientation: string) => void;
   onIdNotDetected?: () => void;
   onSwitchToManualCapture?: () => void;

package/dist/{IWasmUtilCapability-SNPhmIwB.d.ts → IWasmUtilCapability-DaP6pfHq.d.ts}

@@ -1,5 +1,5 @@
-import { c as WasmPipeline } from "./warmup-CXHBgvFC.js";
-import { _ as MLProviderConfig } from "./createFaceAvatar-pUEkdk4X.js";
+import { c as WasmPipeline } from "./warmup-Cis2p6O0.js";
+import { _ as MLProviderConfig } from "./createFaceAvatar-CTM9aj9Q.js";
 //#region ../infra/src/capabilities/IRecordingCapability.d.ts
 type RecordingPublisher = {
   getStreamId: () => string | undefined;
@@ -105,8 +105,10 @@ type IWasmUtilCapability = {
   setMotionStatus(status: string): void;
   setBackgroundMode(backgroundMode: boolean): void;
   /**
-   * Enables on-device mode: the native WASM module skips full fingerprint
-   * collection and keeps only the device-detection DTO. Additive; default off.
+   * @deprecated Compatibility-only no-op for ml-wasm-kit v2.14.49-post1.
+   * Both values are accepted before or after initialization and never invoke
+   * native code. The public `fingerprint` option controls client-side
+   * submission; native fingerprint lifecycle remains owned by WASM.
    */
   setOnDeviceMode(enabled: boolean): void;
   setZc(zc: string): void;
@@ -130,6 +132,10 @@ type IWasmUtilCapability = {
    */
   getPipelineState(): string;
   estimatePerformance(): string;
+  /**
+   * @deprecated Returns `false` for compatibility. Protected PRC/POC is the
+   * authoritative virtual-camera decision path.
+   */
   isVirtualCamera(label: string | null): boolean;
   prc(): Promise<void>;
   poc(output: VirtualCameraCheckOutput): Promise<void>;

package/dist/{MotionSensorProvider-Vlyhbcty.esm.js → MotionSensorProvider-BnZ8_1Sk.esm.js}

@@ -1,4 +1,4 @@
-import { n as resolveSessionStorage } from "./safeStorage-Dp9m6aOh.esm.js";
+import { n as resolveSessionStorage } from "./safeStorage-1O9k0ulP.esm.js";
 //#region ../infra/src/providers/browser/MotionSensorProvider.ts
 const MOTION_PERMISSION_GRANTED_KEY = "motionSensorsPermissionsGranted";
 const MOTION_PERMISSION_DENIED_KEY = "motionSensorsPermissionsDenied";

package/dist/{StreamCanvasCapture-D2XcXCZ4.esm.js → StreamCanvasCapture-C9jtgBdT.esm.js}

@@ -1,4 +1,4 @@
-import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
+import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
 //#region ../infra/src/media/StreamCanvasCapture.ts
 var StreamCanvasCapture = class {
 	constructor(stream, options) {
@@ -28,7 +28,7 @@ var StreamCanvasCapture = class {
 		try {
 			this.video.play();
 		} catch {}
-		this.rafLoop(intervalMs);
+		if (options?.continuous !== false) this.rafLoop(intervalMs);
 	}
 	addEventListener(type, listener, options) {
 		this.eventTarget.addEventListener(type, listener, options);

package/dist/{deepsightService-MZOpj7Vp.d.ts → StreamCanvasCapture-D9Dz8kqB.d.ts}

@@ -1,44 +1,6 @@
-import { y as IncodeCanvas } from "./createFaceAvatar-pUEkdk4X.js";
-import "./IWasmUtilCapability-SNPhmIwB.js";
+import { y as IncodeCanvas } from "./createFaceAvatar-CTM9aj9Q.js";
+import "./IWasmUtilCapability-DaP6pfHq.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.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';
@@ -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/ae-signature.esm.js

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

package/dist/{apiError-XdhqSAmg.esm.js → apiError-CixFeCyt.esm.js}

@@ -1,4 +1,4 @@
-import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-DLzYznkh.esm.js";
+import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-TqmmYye3.esm.js";
 //#region src/internal/http/apiError.ts
 /**
 * Incode API error.

package/dist/authentication.d.ts

@@ -1,4 +1,4 @@
-import { C as authenticationMachine, S as createAuthenticationActor, b as AuthenticationActor, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-CzUr_ZPq.js";
-import { t as AuthenticationConfig } from "./types-m4t_cT5J.js";
-import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-BCkV6CSG.js";
+import { C as authenticationMachine, S as createAuthenticationActor, b as AuthenticationActor, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-DqrYpjA5.js";
+import { t as AuthenticationConfig } from "./types-BhHF-CuL.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-D7UUqgnN.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-Cto_G5bN.esm.js";
-import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-DqBOkMzk.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-CUXpIxAD.esm.js";
+import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-CN26fkJa.esm.js";
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-DqBOkMzk.esm.js → authenticationManager-CN26fkJa.esm.js}

@@ -1,9 +1,9 @@
-import { l as BrowserStorageProvider } from "./setup-BHJ3-fhX.esm.js";
-import { r as WasmUtilProvider } from "./safeStorage-Dp9m6aOh.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CfNAVG-d.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-1O9k0ulP.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-kDmbL0I7.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-Cto_G5bN.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-D_EjQnnE.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-CUXpIxAD.esm.js";
 //#region src/modules/authentication/authenticationActor.ts
 function createAuthenticationActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{authenticationManager-BCkV6CSG.d.ts → authenticationManager-D7UUqgnN.d.ts}

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { b as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-CzUr_ZPq.js";
+import { b as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-DqrYpjA5.js";
 //#region src/modules/authentication/authenticationManager.d.ts
 type AuthenticationState = FaceCaptureManagerState;
 /**

package/dist/{authenticationStateMachine-Cto_G5bN.esm.js → authenticationStateMachine-CUXpIxAD.esm.js}

@@ -1,12 +1,9 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
-import { t as addDeviceStats } from "./stats-DkK-f8JT.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-CAGBnLVx.esm.js";
-import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-hle2Ci9l.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
+import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-WeO8-TfR.esm.js";
+import { u as isOnDeviceMode } from "./FaceDetectionProvider-0bWjPgW5.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
+import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-DQ5-F2oW.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,2 +1,2 @@
-import { i as createFaceAvatar, n as FaceAvatarHandle, o as AvatarFaceState, r as FaceAvatarOptions, t as AvatarId } from "./createFaceAvatar-pUEkdk4X.js";
+import { i as createFaceAvatar, n as FaceAvatarHandle, o as AvatarFaceState, r as FaceAvatarOptions, t as AvatarId } from "./createFaceAvatar-CTM9aj9Q.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-DE_5qY04.esm.js → backCameraStream-BOtyQowf.esm.js}

@@ -1,5 +1,5 @@
 import { a as isIOS, c as isIPhone14OrHigher, d as isSafari, i as isDesktop, t as isAndroid } from "./platform-DkcRc9JV.esm.js";
-import { a as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-_2sXMXiF.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-Cbe1C4Tn.esm.js";
 //#region src/internal/camera/backCameraStream.ts
@@ -213,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) {
@@ -232,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 {
@@ -254,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) {
@@ -335,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.
@@ -381,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;
@@ -435,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 { isBackFacingTrack as a, hasBackCamera as i, getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };

package/dist/{camera-_2sXMXiF.esm.js → camera-sIa9ceW2.esm.js}

@@ -126,6 +126,24 @@ async function requestCameraWithFallback(baseConstraints, fallbacks = DEFAULT_RE
 	}
 	throw new Error("All camera resolution fallbacks failed");
 }
+/**
+* Preserve the constraints used for an acquired camera while pinning future
+* acquisitions to the device the browser actually selected.
+*
+* Protected WASM PRC/POC may reacquire the stream. Advisory constraints such
+* as `facingMode` are not enough on devices with multiple matching cameras,
+* so the selected device must be replayed as an exact constraint.
+*/
+function getCameraReacquisitionConstraints(track, acquisitionConstraints) {
+	if (!track) return acquisitionConstraints;
+	const constraints = acquisitionConstraints ?? track.getConstraints();
+	const selectedDeviceId = track.getSettings().deviceId;
+	if (!selectedDeviceId) return constraints;
+	return {
+		...constraints,
+		deviceId: { exact: selectedDeviceId }
+	};
+}
 function stopCameraStream(stream) {
 	for (const track of stream.getTracks()) track.stop();
 }
@@ -137,4 +155,4 @@ async function applyTrackConstraints(track, constraints) {
 	await track.applyConstraints(constraints);
 }
 //#endregion
-export { stopCameraStream as a, requestCameraWithFallback as i, enumerateVideoDevices as n, clearCameraGrantedInDocument as o, requestCameraAccess as r, isCameraGrantedInDocument as s, applyTrackConstraints as t };
+export { requestCameraWithFallback as a, isCameraGrantedInDocument as c, requestCameraAccess as i, enumerateVideoDevices as n, stopCameraStream as o, getCameraReacquisitionConstraints as r, clearCameraGrantedInDocument as s, applyTrackConstraints as t };

package/dist/camera.esm.js

@@ -1,2 +1,2 @@
-import { i as requestPermission, t as checkPermission } from "./permissionServices-f7nBnW5P.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-7lzEiOsO.esm.js";
 export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/{canvas-E1zGkel4.esm.js → canvas-BxFzWTt-.esm.js}

@@ -170,6 +170,25 @@ var IncodeCanvas = class IncodeCanvas {
 		if (base64) this.blobData = IncodeCanvas.base64ToBlob(base64);
 	}
 	/**
+	* Creates a JPEG Blob without synchronously encoding the canvas as base64.
+	* Returns `null` when the canvas is invalid, encoding is unavailable, or the
+	* browser cannot produce a Blob.
+	*/
+	async updateBlobAsync(jpegQuality = 1) {
+		if (!this.checkCanvas() || typeof this.canvas.toBlob !== "function") return null;
+		const blob = await new Promise((resolve) => {
+			this.canvas.toBlob(resolve, "image/jpeg", jpegQuality);
+		});
+		if (!blob) return null;
+		if (this.blobData?.url) URL.revokeObjectURL(this.blobData.url);
+		const blobData = {
+			blob,
+			url: URL.createObjectURL(blob)
+		};
+		this.blobData = blobData;
+		return blobData;
+	}
+	/**
 	* Converts a base64 string to a Blob and creates a URL for it.
 	*/
 	static base64ToBlob(base64) {