@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/{idCaptureServices-44kwQItl.esm.js → idCaptureServices-i1KxugN7.esm.js}

@@ -1,12 +1,192 @@
-import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-CPQ4qv3F.esm.js";
+import { t as ensureWasmPipelines } from "./setup-BWG-hivt.esm.js";
+import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-E0mq0pMs.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { r as isDesktop } from "./platform-BJrm5nzZ.esm.js";
-import { h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-9y-kbVDw.esm.js";
-import { n as preloadOpenViduProvider } from "./recordingService-3NSENVwp.esm.js";
-import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-WeHbQM7W.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
+import { i as isDesktop } from "./platform-DkcRc9JV.esm.js";
+import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
+import { s as queryCameraPermission } from "./permissionServices-Bj_fyWtv.esm.js";
+import { a as isBackFacingTrack, n as getBackCameraStream } from "./backCameraStream-BOtyQowf.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
+import { t as MultipartRecordingService } from "./multipartRecordingService-OEgIRvqC.esm.js";
+import { i as CameraCompositor, n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-CbPA-Auz.esm.js";
+//#region src/internal/camera/cameraServices.ts
+function createCameraServices(camera) {
+	return {
+		async checkPermission() {
+			return queryCameraPermission();
+		},
+		async requestStream(config) {
+			return camera.requestStream({
+				facingMode: config.facingMode,
+				deviceId: config.deviceId
+			});
+		},
+		stopStream(stream) {
+			camera.stopStream(stream);
+		},
+		captureFrame(video) {
+			return camera.captureFrame(video);
+		}
+	};
+}
+setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		checkPermission: fromPromise(async ({ input }) => {
+			return createCameraServices(input.camera).checkPermission();
+		}),
+		requestStream: fromPromise(async ({ input }) => {
+			return createCameraServices(input.camera).requestStream(input.config);
+		})
+	},
+	actions: {
+		setPermissionResult: assign({ permissionResult: ({ event }) => {
+			if ("output" in event) return event.output;
+			if (event.type === "PERMISSION_RESULT") return event.result;
+		} }),
+		setStream: assign({ stream: ({ event }) => {
+			if ("output" in event) return event.output;
+			if (event.type === "STREAM_READY") return event.stream;
+		} }),
+		setError: assign({
+			error: ({ event }) => {
+				if ("error" in event && event.type?.startsWith?.("xstate.error")) {
+					const err = event.error;
+					return err.message || String(err);
+				}
+				if (event.type === "STREAM_ERROR") return event.error;
+			},
+			errorType: ({ event }) => {
+				if ("error" in event && event.type?.startsWith?.("xstate.error")) {
+					const err = event.error;
+					if (err.name === "NotAllowedError") return "permission_denied";
+					if (err.name === "NotFoundError") return "not_found";
+					if (err.name === "NotReadableError") return "not_readable";
+					if (err.name === "OverconstrainedError") return "overconstrained";
+					if (err.name === "SecurityError") return "security";
+					if (err.name === "AbortError") return "abort";
+					return "unknown";
+				}
+				if (event.type === "STREAM_ERROR") return event.errorType;
+			}
+		}),
+		stopStream: ({ context }) => {
+			if (context.stream) createCameraServices(context.camera).stopStream(context.stream);
+		},
+		resetContext: assign(({ context }) => ({
+			camera: context.camera,
+			config: context.config,
+			stream: void 0,
+			permissionResult: void 0,
+			error: void 0,
+			errorType: void 0
+		}))
+	},
+	guards: {
+		permissionGranted: ({ context }) => context.permissionResult === "granted",
+		permissionDenied: ({ context }) => context.permissionResult === "denied",
+		hasStream: ({ context }) => context.stream !== void 0
+	}
+}).createMachine({
+	id: "camera",
+	initial: "idle",
+	context: ({ input }) => ({
+		camera: input.camera,
+		config: input.config ?? {},
+		stream: void 0,
+		permissionResult: void 0,
+		error: void 0,
+		errorType: void 0
+	}),
+	states: {
+		idle: { on: { START: "checkingPermission" } },
+		checkingPermission: {
+			invoke: {
+				id: "checkPermission",
+				src: "checkPermission",
+				input: ({ context }) => ({ camera: context.camera }),
+				onDone: {
+					target: "routing",
+					actions: "setPermissionResult"
+				},
+				onError: {
+					target: "routing",
+					actions: assign({ permissionResult: () => "prompt" })
+				}
+			},
+			on: { STOP: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		routing: { always: [
+			{
+				target: "requesting",
+				guard: "permissionGranted"
+			},
+			{
+				target: "error",
+				guard: "permissionDenied",
+				actions: assign({
+					error: () => "Camera permission denied",
+					errorType: () => "permission_denied"
+				})
+			},
+			{ target: "requesting" }
+		] },
+		requesting: {
+			invoke: {
+				id: "requestStream",
+				src: "requestStream",
+				input: ({ context }) => ({
+					camera: context.camera,
+					config: context.config
+				}),
+				onDone: {
+					target: "streaming",
+					actions: "setStream"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { STOP: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		streaming: {
+			exit: "stopStream",
+			on: {
+				STOP: {
+					target: "idle",
+					actions: "resetContext"
+				},
+				RESET: {
+					target: "idle",
+					actions: "resetContext"
+				}
+			}
+		},
+		error: { on: {
+			RESET: {
+				target: "idle",
+				actions: "resetContext"
+			},
+			STOP: {
+				target: "idle",
+				actions: "resetContext"
+			}
+		} }
+	}
+});
+//#endregion
 //#region src/modules/id/idCameraStream.ts
 async function getIdCameraStream(deviceId) {
 	return getBackCameraStream(deviceId);
@@ -33,9 +213,9 @@ async function getIdCameraStream(deviceId) {
 * payload whose halves exceed it is halved to fit rather than rejected, and a
 * session whose budget cannot fit a meaningful split runs the countdown arm.
 * Note this means the console payload decides total capture duration — a
-* treatment payload that leaves `framesAggregationIntervalMs` at its 3000
-* default produces a 4500ms window against the 5s default budget, i.e. longer
-* than the countdown arm's 3000ms. Set both halves explicitly.
+* treatment payload that leaves `framesAggregationIntervalMs` at its 1700
+* default produces a 3200ms window against the 5s default budget, i.e. longer
+* than the countdown arm's 1700ms. Set both halves explicitly.
 */
 const MAX_OPTIMIZING_DWELL_MS = 2500;
 const DEFAULT_OPTIMIZING_DWELL_MS = 1500;
@@ -66,7 +246,8 @@ const OPTIMIZING_WATCHDOG_MARGIN_MS = 1e3;
 * the countdown arm, only the pre-boundary half in the treatment arm. Bounding it
 * for one would break the other, so the arm-aware handling lives in
 * `resolveCaptureOptimizingTreatment`. Its code default stays at the
-* canonical 3000 so an unallocated session keeps shipped control behavior.
+* canonical SDK 1-compatible 1700 so an unallocated session keeps production
+* parity.
 */
 const CAPTURE_OPTIMIZING = {
 	storeParam: "idcExp05ShowResult",
@@ -161,8 +342,8 @@ function resolveCaptureOptimizingTreatment(config) {
 /**
 * Single source of truth for the WASM ID-capture thresholds passed to
 * `IIdCaptureCapability.setThresholds`. Resolves `framesAggregationInterval`
-* — the countdown / best-frame aggregation window (canonical default
-* 3000ms) — with precedence:
+* — the countdown / best-frame aggregation window (SDK 1-compatible canonical
+* default 1700ms) — with precedence:
 *
 * 1. An explicit `config.thresholds.framesAggregationInterval` (host/headless
 *    override) always wins. Such a session never runs the IDC-05 treatment
@@ -248,6 +429,7 @@ const DEFAULT_ID_CAPTURE_SETTINGS = {
 };
 async function initializeIdCapture(params) {
 	const { config, deepsightService } = params;
+	await ensureWasmPipelines(["idCapture"]);
 	const provider = new IdCaptureProvider();
 	await provider.initialize({});
 	provider.setThresholds(resolveIdCaptureThresholds(config));
@@ -269,11 +451,13 @@ async function initializeIdCapture(params) {
 		if (typeof settings.width === "number" && typeof settings.height === "number") captureResolution = `${settings.width}x${settings.height}`;
 	}
 	if (deepsightService && videoTrack) deepsightService.metadata.updateCameraInfo(videoTrack);
+	const usingBackCamera = videoTrack ? isBackFacingTrack(videoTrack) : true;
 	return {
 		stream,
 		provider,
 		captureResolution,
-		cameraFallbackLevel: fallbackLevel
+		cameraFallbackLevel: fallbackLevel,
+		usingBackCamera
 	};
 }
 function stopStream(stream) {
@@ -292,6 +476,12 @@ function validateUploadResponse(response, sessionState) {
 		messageDescription: response.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
 		errorKey: ID_ERROR_CODES.WRONG_DOCUMENT_SIDE
 	};
+	if (response.failReason === "DOCUMENT_NOT_READABLE") return {
+		error: true,
+		message: "Info is not readable",
+		messageDescription: "Minimize camera shake by holding your phone steady",
+		errorKey: ID_ERROR_CODES.READABILITY_ISSUE
+	};
 	if (!response.classification) return {
 		error: true,
 		message: "ID classification failed",
@@ -378,71 +568,94 @@ async function uploadIdImage(params) {
 		throw new Error(`${ID_ERROR_CODES.UPLOAD_ERROR}: ${errorMessage}`);
 	}
 }
-function buildStandardResolution(width, height) {
-	return height > width ? {
-		width: 1080,
-		height: 1920
-	} : {
-		width: 1920,
-		height: 1080
-	};
+const multipartIdSessions = /* @__PURE__ */ new WeakMap();
+const idRecordingFinalizations = /* @__PURE__ */ new WeakMap();
+function createMultipartSessionHandle(service, compositor, recordingSource) {
+	const session = {};
+	multipartIdSessions.set(session, {
+		compositor,
+		needsVideoSourceReplacement: false,
+		recorderPaused: false,
+		recordingSource,
+		service
+	});
+	return session;
 }
-function buildResolutionFromStream(stream) {
-	const track = stream.getVideoTracks()[0];
-	if (!track) return "1080x1920";
-	const settings = track.getSettings();
-	const width = settings.width;
-	const height = settings.height;
-	if (typeof width === "number" && typeof height === "number") {
-		const standard = buildStandardResolution(width, height);
-		return `${standard.width}x${standard.height}`;
+async function startRecordingSession(params) {
+	if (params.config.enableIdRecording !== true) return;
+	if (params.existing) {
+		const multipartSession = multipartIdSessions.get(params.existing);
+		if (multipartSession?.needsVideoSourceReplacement) {
+			const recordingSource = params.stream.clone();
+			recordingSource.getAudioTracks().forEach((track) => track.stop());
+			multipartSession.compositor.switchVideo(recordingSource);
+			multipartSession.needsVideoSourceReplacement = false;
+			multipartSession.recordingSource = recordingSource;
+			const resumeResult = await multipartSession.compositor.resume();
+			if (resumeResult !== "resumed") throw new Error(`ID recording camera did not resume: ${resumeResult}`);
+		}
+		if (multipartSession?.recorderPaused && !multipartSession.service.resume()) throw new Error("ID recording did not resume");
+		if (multipartSession) multipartSession.recorderPaused = false;
+		return params.existing;
 	}
-	return "1080x1920";
-}
-function preloadIdRecordingProvider(config) {
-	if (config.enableIdRecording !== true) return;
-	preloadOpenViduProvider();
+	const service = new MultipartRecordingService(params.type);
+	const recordingSource = params.stream.clone();
+	const compositor = new CameraCompositor({ fps: 30 });
+	try {
+		const recordingStream = compositor.start(recordingSource);
+		await service.start(recordingStream);
+	} catch (error) {
+		compositor.stop();
+		service.cleanup();
+		throw error;
+	}
+	return createMultipartSessionHandle(service, compositor, recordingSource);
 }
-async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-Du98qevC.esm.js");
-	return new OpenViduRecordingProvider();
+function pauseRecordingForAttempt(session) {
+	const multipartSession = multipartIdSessions.get(session);
+	if (!multipartSession) return;
+	multipartSession.recorderPaused = multipartSession.service.pause();
 }
-async function startRecordingSession(params) {
-	if (params.config.enableIdRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
-	const clonedStream = params.stream.clone();
-	const hasAudio = clonedStream.getAudioTracks().length > 0;
-	const resolution = buildResolutionFromStream(clonedStream);
-	const session = await createRecordingSession(params.type);
-	const connection = await provider.connect({
-		sessionToken: session.token,
-		stream: clonedStream,
-		events: {}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: params.type,
-		resolution,
-		hasAudio
-	});
-	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
-	};
+function prepareRecordingForCameraRetry(session) {
+	const multipartSession = multipartIdSessions.get(session);
+	if (!multipartSession) return;
+	if (!multipartSession.recorderPaused) multipartSession.recorderPaused = multipartSession.service.pause();
+	multipartSession.compositor.pause();
+	multipartSession.recordingSource.getVideoTracks().forEach((track) => track.stop());
+	multipartSession.needsVideoSourceReplacement = true;
 }
-function stopRecording(session) {
-	(async () => {
+/**
+* Fully drains an ID recording before the protected camera cycle runs POC.
+* Every recorder clone is stopped before this promise settles.
+*/
+async function finalizeRecordingSession(session) {
+	const existing = idRecordingFinalizations.get(session);
+	if (existing) return existing;
+	const multipartSession = multipartIdSessions.get(session);
+	if (!multipartSession) return {};
+	const finalization = (async () => {
+		multipartIdSessions.delete(session);
 		try {
-			await stopRecording$1(session.videoRecordingId);
+			return await multipartSession.service.stop();
 		} finally {
-			await session.connection.disconnect();
+			multipartSession.compositor.stop();
 		}
 	})();
+	idRecordingFinalizations.set(session, finalization);
+	return finalization;
+}
+/** Synchronous teardown used when an attempt is cancelled before finalization. */
+function disposeRecordingSession(session) {
+	const multipartSession = multipartIdSessions.get(session);
+	if (multipartSession) {
+		multipartIdSessions.delete(session);
+		const finalization = multipartSession.service.stop().finally(() => multipartSession.compositor.stop());
+		idRecordingFinalizations.set(session, finalization);
+		finalization.catch(() => {});
+	}
+}
+function stopRecording(session) {
+	finalizeRecordingSession(session).catch(() => {});
 }
 async function processId(isSecondId = false, queueName = "", signal) {
 	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
@@ -519,4 +732,4 @@ async function addBarcode(params) {
 	return res.data;
 }
 //#endregion
-export { getIdCameraStream as _, processId as a, stopStream as c, validateUploadResponse as d, ID_ERROR_CODES as f, OPTIMIZING_WATCHDOG_MARGIN_MS as g, CAPTURE_OPTIMIZING as h, preloadIdRecordingProvider as i, uploadIdImage as l, resolveIdCaptureThresholds as m, barcodeToBase64 as n, startRecordingSession as o, resolveCaptureOptimizingTreatment as p, initializeIdCapture as r, stopRecording as s, addBarcode as t, uploadManualIdFile as u };
+export { resolveCaptureOptimizingTreatment as _, getRealQualityValue as a, OPTIMIZING_WATCHDOG_MARGIN_MS as b, prepareRecordingForCameraRetry as c, stopRecording as d, stopStream as f, ID_ERROR_CODES as g, validateUploadResponse as h, finalizeRecordingSession as i, processId as l, uploadManualIdFile as m, barcodeToBase64 as n, initializeIdCapture as o, uploadIdImage as p, disposeRecordingSession as r, pauseRecordingForAttempt as s, addBarcode as t, startRecordingSession as u, resolveIdCaptureThresholds as v, getIdCameraStream as x, CAPTURE_OPTIMIZING as y };