@incodetech/core 2.2.0 → 2.3.0-rc.0

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

@@ -1,12 +1,193 @@
-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-msLybMbC.esm.js";
+import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-B0sGlozZ.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-D3B9mUHh.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 { n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-CCWy13M-.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-B3C_zlev.esm.js";
+import { i as CameraCompositor, n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-BcxjQDI3.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 +214,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 +247,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 +343,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 +430,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 +452,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 +477,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",
@@ -399,21 +590,73 @@ function buildResolutionFromStream(stream) {
 	}
 	return "1080x1920";
 }
-function preloadIdRecordingProvider(config) {
-	if (config.enableIdRecording !== true) return;
-	preloadOpenViduProvider();
-}
-async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-Du98qevC.esm.js");
-	return new OpenViduRecordingProvider();
+function preloadIdRecordingProvider(config) {}
+const multipartIdSessions = /* @__PURE__ */ new WeakMap();
+const legacyIdRecordingStreams = /* @__PURE__ */ new WeakMap();
+const idRecordingFinalizations = /* @__PURE__ */ new WeakMap();
+const releasedLegacyIdRecordings = /* @__PURE__ */ new WeakSet();
+const legacyIdDisconnects = /* @__PURE__ */ new WeakMap();
+function createMultipartSessionHandle(service, compositor, recordingSource, resolution, hasAudio) {
+	const session = {
+		token: "",
+		sessionId: "",
+		videoRecordingId: "",
+		connection: {
+			sessionId: void 0,
+			publisher: {
+				getStreamId: () => void 0,
+				replaceVideoTrack: async () => {},
+				destroy: () => {}
+			},
+			disconnect: async () => {}
+		},
+		resolution,
+		hasAudio
+	};
+	multipartIdSessions.set(session, {
+		compositor,
+		needsVideoSourceReplacement: false,
+		recorderPaused: false,
+		recordingSource,
+		service
+	});
+	return session;
 }
 async function startRecordingSession(params) {
 	if (params.config.enableIdRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
+	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;
+	}
+	const hasAudio = params.stream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(params.stream);
+	if (!params.config.recording?.capability) {
+		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, resolution, hasAudio);
+	}
+	const provider = params.config.recording.capability;
 	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,
@@ -426,7 +669,7 @@ async function startRecordingSession(params) {
 		resolution,
 		hasAudio
 	});
-	return {
+	const recordingSession = {
 		token: session.token,
 		sessionId: session.sessionId,
 		videoRecordingId: session.videoRecordingId,
@@ -434,15 +677,83 @@ async function startRecordingSession(params) {
 		resolution,
 		hasAudio
 	};
+	legacyIdRecordingStreams.set(recordingSession, clonedStream);
+	return recordingSession;
 }
-function stopRecording(session) {
-	(async () => {
+function pauseRecordingForAttempt(session) {
+	const multipartSession = multipartIdSessions.get(session);
+	if (!multipartSession) return;
+	multipartSession.recorderPaused = multipartSession.service.pause();
+}
+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 releaseLegacyRecordingResources(session) {
+	if (releasedLegacyIdRecordings.has(session)) return;
+	releasedLegacyIdRecordings.add(session);
+	try {
+		session.connection.publisher.destroy();
+	} catch {}
+	const clonedStream = legacyIdRecordingStreams.get(session);
+	legacyIdRecordingStreams.delete(session);
+	for (const track of clonedStream?.getTracks() ?? []) try {
+		track.stop();
+	} catch {}
+}
+function disconnectLegacyRecording(session) {
+	const existing = legacyIdDisconnects.get(session);
+	if (existing) return existing;
+	const disconnect = session.connection.disconnect();
+	legacyIdDisconnects.set(session, disconnect);
+	return disconnect;
+}
+/**
+* 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);
+	const finalization = multipartSession ? (async () => {
+		multipartIdSessions.delete(session);
+		try {
+			return await multipartSession.service.stop();
+		} finally {
+			multipartSession.compositor.stop();
+		}
+	})() : (async () => {
 		try {
 			await stopRecording$1(session.videoRecordingId);
+			return { recordingId: session.videoRecordingId || null };
 		} finally {
-			await session.connection.disconnect();
+			releaseLegacyRecordingResources(session);
+			await disconnectLegacyRecording(session);
 		}
 	})();
+	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(() => {});
+		return;
+	}
+	releaseLegacyRecordingResources(session);
+	disconnectLegacyRecording(session).catch(() => {});
+}
+function stopRecording(session) {
+	finalizeRecordingSession(session).catch(() => {});
 }
 async function processId(isSecondId = false, queueName = "", signal) {
 	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
@@ -519,4 +830,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 { getIdCameraStream as S, ID_ERROR_CODES as _, getRealQualityValue as a, CAPTURE_OPTIMIZING as b, preloadIdRecordingProvider as c, startRecordingSession as d, stopRecording as f, validateUploadResponse as g, uploadManualIdFile as h, finalizeRecordingSession as i, prepareRecordingForCameraRetry as l, uploadIdImage as m, barcodeToBase64 as n, initializeIdCapture as o, stopStream as p, disposeRecordingSession as r, pauseRecordingForAttempt as s, addBarcode as t, processId as u, resolveCaptureOptimizingTreatment as v, OPTIMIZING_WATCHDOG_MARGIN_MS as x, resolveIdCaptureThresholds as y };