@incodetech/core 2.0.1-rc.0 → 2.1.0-rc.0

package/dist/{authenticationStateMachine-BMZqatiF.esm.js → authenticationStateMachine-DksVbF_H.esm.js}

@@ -1,9 +1,11 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, r as assign } from "./xstate.esm-B70JrNqo.esm.js";
-import { a as prepareOnDeviceFaceUpload, i as postOnDeviceFaceResults, n as defaultPrepareFaceUpload, r as isOnDeviceMode, t as faceCaptureMachine } from "./faceCaptureSetup-B3faSpYA.esm.js";
-import { m as FACE_ERROR_CODES } from "./recordingService-Ig2UgbLv.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
+import { a as fromPromise, r as assign } from "./xstate.esm-C9wncMQa.esm.js";
+import { a as defaultPrepareFaceUpload, c as prepareOnDeviceFaceUpload, o as isOnDeviceMode, s as postOnDeviceFaceResults } from "./recordingService-Bn9EdCmz.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-C8Do2qYu.esm.js";
+import { t as FACE_ERROR_CODES } from "./types-DsnEVMhr.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-CtvHWd3x.esm.js";
 
 //#region src/modules/authentication/authenticationErrorUtils.ts
 const AUTH_ERROR_MAP = {
@@ -27,7 +29,7 @@ const AUTH_ERROR_MAP = {
 	NONEXISTENT_CUSTOMER: FACE_ERROR_CODES.NONEXISTENT_CUSTOMER,
 	HINT_NOT_PROVIDED: FACE_ERROR_CODES.HINT_NOT_PROVIDED
 };
-const TERMINAL_AUTH_ERROR_CODES = [FACE_ERROR_CODES.NONEXISTENT_CUSTOMER, FACE_ERROR_CODES.HINT_NOT_PROVIDED];
+const NON_RETRYABLE_AUTH_ERROR_CODES = [FACE_ERROR_CODES.NONEXISTENT_CUSTOMER, FACE_ERROR_CODES.HINT_NOT_PROVIDED];
 const validateAuthUploadResponse = (response) => {
 	if (!response) return FACE_ERROR_CODES.SERVER;
 	if (response.overallStatus !== "PASS") return AUTH_ERROR_MAP[response.error?.name] ?? FACE_ERROR_CODES.SERVER;
@@ -35,7 +37,7 @@ const validateAuthUploadResponse = (response) => {
 const isTerminalAuthError = (response, attemptsRemaining) => {
 	if (!response) return false;
 	const mappedError = AUTH_ERROR_MAP[response.error?.name];
-	if (mappedError && TERMINAL_AUTH_ERROR_CODES.includes(mappedError)) return true;
+	if (mappedError && NON_RETRYABLE_AUTH_ERROR_CODES.includes(mappedError)) return true;
 	if (attemptsRemaining <= 0) return true;
 	return false;
 };
@@ -59,6 +61,12 @@ async function uploadAuthFace(params) {
 			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);
@@ -92,6 +100,7 @@ const _authenticationMachine = faceCaptureMachine.provide({
 				authHint: ctx.authHint,
 				metadata: ctx.deepsightService?.getMetadata(),
 				recordingId: ctx.uploadRecordingId,
+				deepsightService: ctx.deepsightService ?? void 0,
 				signal
 			});
 		}),
@@ -105,9 +114,11 @@ const _authenticationMachine = faceCaptureMachine.provide({
 		} }),
 		setTerminalError: assign({ error: ({ context }) => {
 			const resp = context.uploadResponse;
+			const moduleErrorCode = resp ? AUTH_ERROR_MAP[resp.error?.name] : void 0;
 			if (context.attemptsRemaining <= 0) return {
 				type: "FACE_AUTH_ERROR",
-				message: "No more attempts remaining"
+				message: "No more attempts remaining",
+				moduleErrorCode
 			};
 			if (!resp) return {
 				type: "FACE_AUTH_ERROR",
@@ -115,7 +126,8 @@ const _authenticationMachine = faceCaptureMachine.provide({
 			};
 			return {
 				type: "FACE_AUTH_ERROR",
-				message: resp.error?.message ?? resp.error?.name ?? "Face authentication error"
+				message: resp.error?.message ?? resp.error?.name ?? "Face authentication error",
+				moduleErrorCode
 			};
 		} })
 	},

package/dist/{backCameraStream-DMdMeGk2.esm.js → backCameraStream-D7Wo4Nbx.esm.js}

@@ -1,6 +1,6 @@
-import { t as sleep } from "./ITimerCapability-C67ZRskg.esm.js";
-import { i as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-PA2Ljri3.esm.js";
-import { a as isIPhone14OrHigher, o as isSafari, r as isIOS, t as isAndroid } from "./platform-CfrjKhmi.esm.js";
+import { a as isIPhone14OrHigher, o as isSafari, r as isIOS, t as isAndroid } from "./platform-SKvEfCBh.esm.js";
+import { i as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-DJWm3V4g.esm.js";
+import { t as sleep } from "./ITimerCapability-CB0I1Uf2.esm.js";
 
 //#region src/internal/camera/backCameraStream.ts
 const BACK_CAMERA_KEYWORDS = [
@@ -314,12 +314,12 @@ function getDesktopVideoConstraints(level) {
 	}
 }
 function getDesktopConstraints(options, level = 0) {
-	const { deviceId } = options;
+	const { deviceId, facingMode = "user" } = options;
 	const resolution = getDesktopVideoConstraints(level);
 	return {
 		audio: isSafari(),
 		video: {
-			facingMode: "user",
+			facingMode,
 			deviceId: deviceId ? { exact: deviceId } : void 0,
 			...resolution
 		}
@@ -336,11 +336,99 @@ async function getDesktopCameraStream(options, fallbackLevel = 0) {
 		return getDesktopCameraStream(options, nextLevel);
 	}
 }
+/**
+* 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.
+*/
+function selectBestBackDevice(devices) {
+	if (devices.length === 1) return devices[0];
+	const withMp = devices.map((d) => {
+		const match = d.label.match(/\b([0-9]+)\s*MP?\b/i);
+		return {
+			device: d,
+			mp: match ? parseInt(match[1], 10) : 0
+		};
+	});
+	const maxMp = Math.max(...withMp.map((w) => w.mp));
+	const best = withMp.find((w) => w.mp === maxMp);
+	return best ? best.device : devices[0];
+}
+/**
+* Desktop / non-mobile back-camera acquisition with verify-and-correct.
+*
+* Why this exists: devices like the Microsoft Surface fall into the desktop
+* branch (Windows is neither iOS nor Android) and have a documented bug where
+* requesting `facingMode: 'environment'` hands back the FRONT camera — and the
+* reported `facingMode` can falsely say 'environment'. So we never trust
+* facingMode; we verify what we actually got by LABEL only.
+*
+* Flow:
+*  1. Open best-effort with an 'environment' hint.
+*  2. If the opened track's label looks like a back camera → done.
+*  3. Otherwise enumerate and look for a back-LABELLED device, reopen it.
+*  4. If no device has a back label → keep the original stream (never regress).
+*
+* 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 (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);
+		return corrected;
+	} catch {
+		return original;
+	}
+}
+/**
+* Desktop front-camera (selfie) acquisition with verify-and-correct.
+*
+* Counterpart to {@link getDesktopBackCameraStream}. Requesting a front camera
+* uses an *advisory* `facingMode: 'user'` hint, which the browser may ignore —
+* notably on a Surface after the back camera was explicitly opened by deviceId
+* for ID capture, the browser remembers the rear camera as its preferred device
+* and hands it back for the selfie too.
+*
+* The caller supplies an `open(deviceId?)` callback so this stays agnostic to
+* the selfie resolution strategy. We then verify by LABEL only (never
+* facingMode):
+*  1. Open via the callback.
+*  2. If the opened track is NOT a back camera → trust it, return as-is.
+*  3. If it IS a back camera, enumerate and reopen the first non-back device.
+*  4. If there is no non-back device, or the reopen fails → keep the original.
+*
+* Note: "first non-back device" is intentionally simple — on machines that also
+* expose a Windows Hello IR sensor this could pick the IR camera. Accepted
+* tradeoff; revisit with a front-label allowlist if it proves a problem.
+*/
+async function ensureFrontCameraStream(open) {
+	const original = await open();
+	const track = original.getVideoTracks()[0];
+	if (!track || !isBackCameraLabel(track.label)) return original;
+	const frontDevices = (await enumerateVideoDevices()).filter((d) => !isBackCameraLabel(d.label));
+	if (frontDevices.length === 0) return original;
+	const target = frontDevices[0];
+	if (track.getSettings().deviceId === target.deviceId) return original;
+	try {
+		const corrected = await open(target.deviceId);
+		stopCameraStream(original);
+		return corrected;
+	} catch {
+		return original;
+	}
+}
 async function getBackCameraStream(deviceId) {
 	if (isIOS()) return { stream: await getIOSCameraStream() };
 	if (isAndroid()) return getAndroidBackCameraStream(0);
-	return { stream: await getDesktopCameraStream({ deviceId }) };
+	return { stream: await getDesktopBackCameraStream(deviceId) };
 }
 
 //#endregion
-export { getDesktopCameraStream as n, getBackCameraStream as t };
+export { getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };