@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/recordingService-Ig2UgbLv.esm.js

@@ -0,0 +1,1003 @@
+import { l as WasmPipelineType, r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-C_DLEI40.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-PA2Ljri3.esm.js";
+import { n as IncodeCanvas } from "./deepsightService-O74l4Y__.esm.js";
+import { a as isIPhone14OrHigher, n as isDesktop, r as isIOS, t as isAndroid } from "./platform-CfrjKhmi.esm.js";
+import { n as getDesktopCameraStream, t as getBackCameraStream } from "./backCameraStream-DMdMeGk2.esm.js";
+import { t as addDeviceStats } from "./stats-CIfiPzb1.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
+
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.ts
+var FaceDetectionProvider = class extends BaseWasmProvider {
+	constructor() {
+		super(WasmPipelineType.SelfieWithQualityMetrics);
+		this.defaultThresholds = {
+			frameMinX: 0,
+			frameMinY: 0,
+			frameMaxX: 1,
+			frameMaxY: 1,
+			brightnessThreshold: 50,
+			blurrinessThreshold: 50,
+			tiltRotationAngleThreshold: 15,
+			minMagicCropSize: 200,
+			headwearThreshold: .86,
+			lensesThreshold: .95,
+			closedEyesThreshold: .9,
+			maskThreshold: .85,
+			minFaceQualityScore: .63,
+			faceOcclusionThreshold: .3,
+			getReadyDelay: 2e3,
+			framesAggregationInterval: 2e3,
+			minFramesWithFace: 3
+		};
+		this.currentFrame = null;
+	}
+	async processFrame(image) {
+		this.currentFrame = image;
+		await this.processFrameWasm(image);
+	}
+	async initialize(config) {
+		if (config.useOnDeviceWorkflow === true) {
+			this.pipelineType = WasmPipelineType.OnDeviceSelfieWorkflow;
+			await this.initializeBase(config, "onDeviceSelfie");
+		} else await this.initializeBase(config, "selfie");
+		this.applyDefaults(config.autocaptureInterval ?? 0);
+	}
+	processPhoto(canvas) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.processPhoto(canvas);
+	}
+	async postFaceResults(config) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.postFaceResults(config);
+	}
+	setCallbacks(callbacks) {
+		this.ensureInitialized();
+		const onCaptureWrapper = (wasmCanvas, face) => {
+			let frameCanvas = null;
+			if (this.currentFrame) frameCanvas = IncodeCanvas.fromImageData(this.currentFrame);
+			else if (wasmCanvas) frameCanvas = new IncodeCanvas(wasmCanvas);
+			if (!frameCanvas) return;
+			const faceCoordinates = face ? this.formatFaceCoordinates(face) : this.createDefaultFaceCoordinates(frameCanvas);
+			try {
+				frameCanvas.updateBase64Image();
+				frameCanvas.updateBlob();
+			} catch {}
+			callbacks.onCapture?.(frameCanvas, faceCoordinates);
+		};
+		mlWasmJSApi_default.setFaceDetectionCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onTooClose ?? (() => {}), callbacks.onTooManyFaces ?? (() => {}), callbacks.onNoFace ?? (() => {}), onCaptureWrapper, callbacks.onGetReady ?? (() => {}), callbacks.onGetReadyFinished ?? (() => {}), callbacks.onCenterFace ?? (() => {}), callbacks.onDark ?? (() => {}), callbacks.onBlur ?? (() => {}), callbacks.onFaceAngle ?? (() => {}), callbacks.onLenses ?? (() => {}), callbacks.onMask ?? (() => {}), callbacks.onEyesClosed ?? (() => {}), callbacks.onHeadWear ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onFaceOccluded ?? (() => {}));
+	}
+	setPositionConstraints(constraints) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFacePositionConstraints(this.getPipelineType(), constraints.minX, constraints.minY, constraints.maxX, constraints.maxY);
+	}
+	applyDefaults(autocaptureInterval = 0) {
+		this.ensureInitialized();
+		this.setThresholds({
+			brightnessThreshold: this.defaultThresholds.brightnessThreshold,
+			blurrinessThreshold: this.defaultThresholds.blurrinessThreshold,
+			tiltRotationAngleThreshold: this.defaultThresholds.tiltRotationAngleThreshold,
+			minMagicCropSize: this.defaultThresholds.minMagicCropSize,
+			autocaptureInterval,
+			minFaceQualityScore: this.defaultThresholds.minFaceQualityScore,
+			faceOcclusionThreshold: this.defaultThresholds.faceOcclusionThreshold,
+			getReadyDelay: this.defaultThresholds.getReadyDelay,
+			framesAggregationInterval: this.defaultThresholds.framesAggregationInterval,
+			minFramesWithFace: this.defaultThresholds.minFramesWithFace
+		});
+		this.setPositionConstraints({
+			minX: this.defaultThresholds.frameMinX,
+			minY: this.defaultThresholds.frameMinY,
+			maxX: this.defaultThresholds.frameMaxX,
+			maxY: this.defaultThresholds.frameMaxY
+		});
+		this.setAttributesThresholds({
+			headwearThreshold: this.defaultThresholds.headwearThreshold,
+			lensesThreshold: this.defaultThresholds.lensesThreshold,
+			closedEyesThreshold: this.defaultThresholds.closedEyesThreshold,
+			maskThreshold: this.defaultThresholds.maskThreshold
+		});
+	}
+	setAutocaptureInterval(interval) {
+		this.ensureInitialized();
+		if (!this.currentThresholds) {
+			this.applyDefaults(interval);
+			return;
+		}
+		this.setThresholds({
+			...this.currentThresholds,
+			autocaptureInterval: interval
+		});
+	}
+	setThresholds(thresholds) {
+		this.ensureInitialized();
+		this.currentThresholds = { ...thresholds };
+		mlWasmJSApi_default.setFaceDetectionThresholds(this.getPipelineType(), thresholds.brightnessThreshold, thresholds.blurrinessThreshold, thresholds.tiltRotationAngleThreshold, thresholds.minMagicCropSize, thresholds.autocaptureInterval, thresholds.minFaceQualityScore, thresholds.faceOcclusionThreshold, thresholds.getReadyDelay, thresholds.framesAggregationInterval, thresholds.minFramesWithFace);
+	}
+	setAttributesThresholds(thresholds) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFaceAttributesThresholds(this.getPipelineType(), thresholds.headwearThreshold, thresholds.lensesThreshold, thresholds.closedEyesThreshold, thresholds.maskThreshold);
+	}
+	setChecksEnabled(config) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFaceChecksEnabled(this.getPipelineType(), config.lenses, config.mask, config.closedEyes, config.headWear, config.occlusion);
+	}
+	setVideoSelfieMode(enabled) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFaceDetectionMode(this.getPipelineType(), enabled);
+	}
+	reset() {
+		super.reset();
+		this.currentFrame = null;
+	}
+	createDefaultFaceCoordinates(canvas) {
+		return {
+			rightEyeX: 0,
+			rightEyeY: 0,
+			leftEyeX: 0,
+			leftEyeY: 0,
+			noseTipX: 0,
+			noseTipY: 0,
+			rightMouthX: 0,
+			rightMouthY: 0,
+			mouthX: 0,
+			mouthY: 0,
+			x: 0,
+			y: 0,
+			width: canvas.width() ?? 0,
+			height: canvas.height() ?? 0
+		};
+	}
+	formatFaceCoordinates(face) {
+		return {
+			rightEyeX: face.rightEye.x,
+			rightEyeY: face.rightEye.y,
+			leftEyeX: face.leftEye.x,
+			leftEyeY: face.leftEye.y,
+			noseTipX: face.noseTip.x,
+			noseTipY: face.noseTip.y,
+			rightMouthX: face.rightMouthCorner.x,
+			rightMouthY: face.rightMouthCorner.y,
+			mouthX: face.leftMouthCorner.x,
+			mouthY: face.leftMouthCorner.y,
+			x: face.rect.x,
+			y: face.rect.y,
+			width: face.rect.width,
+			height: face.rect.height
+		};
+	}
+};
+
+//#endregion
+//#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
+//#region src/internal/recordings/recordingsRepository.ts
+async function createRecordingSession(type) {
+	return (await api.post(endpoints.recordingCreateSessionV2, { type })).data;
+}
+async function startRecording(params) {
+	return (await api.post(endpoints.recordingStartV2, {
+		videoRecordingId: params.videoRecordingId,
+		frameRate: 30,
+		outputMode: "COMPOSED",
+		resolution: params.resolution,
+		type: params.type,
+		hasAudio: params.hasAudio ?? false
+	})).data;
+}
+async function stopRecording$1(videoRecordingId) {
+	return (await api.post(endpoints.recordingStopV2, { videoRecordingId })).data;
+}
+async function uploadDeepsightVideo(encryptedVideo, token) {
+	try {
+		return (await api.post(endpoints.deepsightVideoImport, {
+			video: encryptedVideo,
+			type: "selfie"
+		}, { headers: { "X-Incode-Hardware-Id": token } })).data.recordingId ?? "";
+	} catch {
+		return "";
+	}
+}
+
+//#endregion
+//#region src/internal/faceCapture/types.ts
+const FACE_ERROR_CODES = {
+	FACE_OCCLUDED: "FACE_OCCLUDED",
+	LIVENESS: "LIVENESS_ERROR",
+	BRIGHTNESS: "BRIGHTNESS_ERROR",
+	LENSES: "LENSES_ERROR",
+	MASK: "MASK_ERROR",
+	CLOSED_EYES: "CLOSED_EYES_ERROR",
+	HEAD_COVER: "HEAD_COVER_ERROR",
+	SERVER: "SERVER_ERROR",
+	FACE_NOT_FOUND: "FACE_NOT_FOUND",
+	MULTIPLE_FACES: "MULTIPLE_FACES",
+	TOO_BLURRY: "TOO_BLURRY_ERROR",
+	TOO_DARK: "TOO_DARK_ERROR",
+	USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED",
+	SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED",
+	FACE_TOO_DARK: "FACE_TOO_DARK",
+	LENSES_DETECTED: "LENSES_DETECTED",
+	FACE_MASK_DETECTED: "FACE_MASK_DETECTED",
+	CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED",
+	HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED",
+	FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED",
+	FACE_TOO_SMALL: "FACE_TOO_SMALL",
+	FACE_TOO_BLURRY: "FACE_TOO_BLURRY",
+	BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY",
+	PROCESSING_ERROR: "PROCESSING_ERROR",
+	BAD_REQUEST: "BAD_REQUEST",
+	NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER",
+	HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED",
+	SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY"
+};
+
+//#endregion
+//#region src/modules/selfie/selfieUploadService.ts
+/**
+* Uploads a selfie image to the backend.
+*/
+async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId }) {
+	try {
+		const payload = {
+			base64Image: encryptedBase64Image,
+			faceCoordinates: faceCoordinates ?? void 0,
+			encrypted: true,
+			clientInfo: { deviceClass: getDeviceClass() },
+			metadata: metadata ?? void 0
+		};
+		const query = { imageType: "selfie" };
+		if (recordingId) query.recordingId = recordingId;
+		const res = await api.post(endpoints.selfie, payload, {
+			signal,
+			query
+		});
+		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
+		return res.data;
+	} catch (error) {
+		const errorCode = getFaceErrorCodeFromHttpError(error);
+		if (errorCode) throw new Error(errorCode);
+		throw new Error(FACE_ERROR_CODES.SERVER);
+	}
+}
+const getFaceErrorCodeFromHttpError = (error) => {
+	const err = error;
+	if (err.ok !== false || typeof err.status !== "number") return;
+	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
+	if (typeof err.data?.status !== "number") return FACE_ERROR_CODES.BAD_REQUEST;
+	return {
+		3004: FACE_ERROR_CODES.FACE_NOT_FOUND,
+		3005: FACE_ERROR_CODES.FACE_NOT_FOUND,
+		3006: FACE_ERROR_CODES.TOO_BLURRY,
+		3007: FACE_ERROR_CODES.TOO_DARK,
+		4010: FACE_ERROR_CODES.MULTIPLE_FACES,
+		4019: FACE_ERROR_CODES.FACE_NOT_FOUND,
+		4077: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
+		4078: FACE_ERROR_CODES.FACE_OCCLUDED
+	}[err.data.status] ?? FACE_ERROR_CODES.BAD_REQUEST;
+};
+async function processFace(imageType = "selfie", signal) {
+	return (await api.post(endpoints.processFace, {}, {
+		query: { imageType },
+		signal
+	})).data;
+}
+
+//#endregion
+//#region src/internal/faceCapture/faceCaptureServices.ts
+function sendLabelInspectionEvent() {
+	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
+}
+const MOBILE_SELFIE_CONSTRAINTS = {
+	video: {
+		facingMode: "user",
+		height: { ideal: 480 },
+		width: { ideal: 640 }
+	},
+	audio: false
+};
+const IPHONE14_SELFIE_CONSTRAINTS = {
+	video: { height: { ideal: 1080 } },
+	audio: false
+};
+function buildCameraConstraints(resolution) {
+	if (resolution) return {
+		video: {
+			facingMode: "user",
+			height: resolution.height ? { ideal: resolution.height } : void 0,
+			width: resolution.width ? { ideal: resolution.width } : void 0
+		},
+		audio: false
+	};
+	if (isIPhone14OrHigher()) return IPHONE14_SELFIE_CONSTRAINTS;
+	return MOBILE_SELFIE_CONSTRAINTS;
+}
+function stopStream(stream) {
+	stopCameraStream(stream);
+}
+async function getFrontCameraStream(resolution) {
+	if (resolution) return requestCameraAccess(buildCameraConstraints(resolution));
+	if (isDesktop()) return getDesktopCameraStream({});
+	return requestCameraAccess(buildCameraConstraints());
+}
+async function initializeCamera(params) {
+	const { config } = params;
+	const prcConstraints = buildCameraConstraints(config.cameraResolution);
+	const provider = new FaceDetectionProvider();
+	await provider.initialize({
+		autocaptureInterval: config.autoCaptureTimeout * 1e3,
+		useOnDeviceWorkflow: config.onDeviceFaceResultsSubmissionEnabled === true
+	});
+	provider.setChecksEnabled({
+		lenses: config.validateLenses ?? false,
+		mask: config.validateFaceMask ?? false,
+		closedEyes: config.validateClosedEyes ?? false,
+		headWear: config.validateHeadCover ?? false,
+		occlusion: false
+	});
+	await params.deepsightService.performPrcCheck({ constraints: { video: prcConstraints.video } });
+	return {
+		stream: config.assistedOnboarding ? (await getBackCameraStream()).stream : await getFrontCameraStream(config.cameraResolution),
+		provider
+	};
+}
+/**
+* Encrypts the provided selfie image using WASM.
+*/
+async function encryptSelfieImage({ canvas, dependencies }) {
+	const base64Image = canvas.getBase64Image();
+	if (!base64Image) throw new Error("Canvas image is empty or null");
+	return (await dependencies.getWasmUtil()).encryptImage(base64Image);
+}
+function startDetection(params) {
+	let lastStatus;
+	let session;
+	const { provider } = params;
+	const setStatus = (status) => {
+		if (session?.isDisposed() === true) return;
+		if (lastStatus === status) return;
+		lastStatus = status;
+		params.onUpdate(status);
+	};
+	const stopDetectionLoop = () => {
+		session?.dispose();
+	};
+	const reset = () => {
+		provider.reset();
+	};
+	const cleanup = () => {
+		stopDetectionLoop();
+	};
+	(async () => {
+		try {
+			provider.setCallbacks({
+				onFarAway: () => setStatus("tooFar"),
+				onTooClose: () => setStatus("tooClose"),
+				onTooManyFaces: () => setStatus("tooManyFaces"),
+				onNoFace: () => setStatus("idle"),
+				onCenterFace: () => setStatus("centerFace"),
+				onGetReady: () => setStatus("getReady"),
+				onGetReadyFinished: () => setStatus("getReadyFinished"),
+				onDark: () => {
+					if (params.config.validateBrightness) setStatus("dark");
+				},
+				onBlur: () => setStatus("blur"),
+				onFaceAngle: () => setStatus("faceAngle"),
+				onLenses: () => {
+					if (params.config.validateLenses) setStatus("lenses");
+				},
+				onMask: () => {
+					if (params.config.validateFaceMask) setStatus("faceMask");
+				},
+				onEyesClosed: () => {
+					if (params.config.validateClosedEyes) setStatus("eyesClosed");
+				},
+				onHeadWear: () => {
+					if (params.config.validateHeadCover) setStatus("headWear");
+				},
+				onFaceOccluded: () => setStatus("faceOcclusion"),
+				onSwitchToManualCapture: () => {
+					setStatus("manualCapture");
+					stopDetectionLoop();
+				},
+				onCapture: (canvas, faceCoordinates) => {
+					setStatus("success");
+					params.onSuccess(canvas, faceCoordinates);
+					cleanup();
+				}
+			});
+			setStatus("detecting");
+			session = new StreamCanvasProcessingSession({
+				capturer: params.capturer,
+				provider,
+				onFrame: params.onFrame
+			});
+		} catch {
+			setStatus("error");
+			cleanup();
+		}
+	})();
+	return {
+		cleanup,
+		reset
+	};
+}
+function buildResolutionFromStream(stream) {
+	const track = stream.getVideoTracks()[0];
+	if (!track) return;
+	const settings = track.getSettings();
+	const width = settings.width;
+	const height = settings.height;
+	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
+}
+async function createOpenViduRecordingProvider() {
+	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-CMu6XVdc.esm.js");
+	return new OpenViduRecordingProvider();
+}
+async function startRecordingSession(params) {
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
+	if (params.config.enableFaceRecording !== true) return;
+	if (params.existing) return params.existing;
+	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
+	const clonedStream = params.clonedStream;
+	const hasAudio = clonedStream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(clonedStream);
+	const session = await createRecordingSession("selfie");
+	const connection = await provider.connect({
+		sessionToken: session.token,
+		stream: clonedStream,
+		events: {}
+	});
+	await startRecording({
+		videoRecordingId: session.videoRecordingId,
+		type: "selfie",
+		resolution,
+		hasAudio
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+async function stopRecording(session) {
+	try {
+		await stopRecording$1(session.videoRecordingId);
+	} finally {
+		await session.connection.disconnect();
+	}
+}
+async function initializeDeepsightSession(options) {
+	const { loadDeepsightSession } = await import("./deepsightLoader-Cm4JIT_z.esm.js");
+	return loadDeepsightSession({
+		ds: options.ds,
+		storage: options.storage
+	});
+}
+
+//#endregion
+//#region ../infra/src/media/StreamCanvasCapture.ts
+var StreamCanvasCapture = class {
+	constructor(stream, options) {
+		this.hasFrame = false;
+		this.disposed = false;
+		this.eventTarget = new EventTarget();
+		this.video = document.createElement("video");
+		this.video.srcObject = stream;
+		this.video.autoplay = true;
+		this.video.playsInline = true;
+		this.video.muted = true;
+		const settings = stream.getVideoTracks()[0]?.getSettings();
+		const initialWidth = options?.width ?? settings?.width ?? 1280;
+		const initialHeight = options?.height ?? settings?.height ?? 720;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = initialWidth;
+		this.canvas.height = initialHeight;
+		this.ctx = this.canvas.getContext("2d", { willReadFrequently: true });
+		const fps = options?.fps ?? 10;
+		const intervalMs = fps > 0 ? Math.max(16, Math.floor(1e3 / fps)) : 0;
+		this.video.addEventListener("loadedmetadata", () => {
+			if (this.video.videoWidth > 0 && this.video.videoHeight > 0) {
+				this.canvas.width = this.video.videoWidth;
+				this.canvas.height = this.video.videoHeight;
+			}
+		});
+		try {
+			this.video.play();
+		} catch {}
+		this.rafLoop(intervalMs);
+	}
+	addEventListener(type, listener, options) {
+		this.eventTarget.addEventListener(type, listener, options);
+	}
+	removeEventListener(type, listener, options) {
+		this.eventTarget.removeEventListener(type, listener, options);
+	}
+	/**
+	* Returns the latest cached frame as an {@link IncodeCanvas}.
+	*/
+	getLatestCanvas() {
+		if (!this.hasFrame) this.tick();
+		if (!this.hasFrame) return null;
+		return new IncodeCanvas(this.canvas);
+	}
+	/**
+	* Returns the latest cached frame as raw {@link ImageData}.
+	*/
+	getLatestFrame() {
+		if (!this.ctx) return null;
+		if (!this.hasFrame) this.tick();
+		if (!this.hasFrame) return null;
+		try {
+			return this.ctx.getImageData(0, 0, this.canvas.width, this.canvas.height);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Disposes internal resources and stops the capture loop.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.rafId !== void 0) {
+			window.cancelAnimationFrame(this.rafId);
+			this.rafId = void 0;
+		}
+		this.video.srcObject = null;
+		this.canvas.width = 0;
+		this.canvas.height = 0;
+		this.hasFrame = false;
+	}
+	rafLoop(intervalMs) {
+		const loop = (timeMs) => {
+			if (this.disposed) return;
+			if (intervalMs <= 0 || this.lastTickTimeMs === void 0 || timeMs - this.lastTickTimeMs >= intervalMs) {
+				this.lastTickTimeMs = timeMs;
+				const previousFrameTimeSeconds = this.lastFrameTimeSeconds;
+				this.tick();
+				const currentFrameTimeSeconds = this.video.currentTime;
+				if (previousFrameTimeSeconds === void 0) {
+					if (this.hasFrame) {
+						this.lastFrameTimeSeconds = currentFrameTimeSeconds;
+						this.eventTarget.dispatchEvent(new Event("frame"));
+					}
+				} else if (this.hasFrame && currentFrameTimeSeconds !== previousFrameTimeSeconds) {
+					this.lastFrameTimeSeconds = currentFrameTimeSeconds;
+					this.eventTarget.dispatchEvent(new Event("frame"));
+				}
+			}
+			this.rafId = window.requestAnimationFrame(loop);
+		};
+		this.rafId = window.requestAnimationFrame(loop);
+	}
+	tick() {
+		if (!this.ctx) return;
+		if (this.video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) return;
+		const videoWidth = this.video.videoWidth;
+		const videoHeight = this.video.videoHeight;
+		if (videoWidth === 0 || videoHeight === 0) return;
+		if (this.canvas.width !== videoWidth || this.canvas.height !== videoHeight) {
+			this.canvas.width = videoWidth;
+			this.canvas.height = videoHeight;
+		}
+		try {
+			this.ctx.drawImage(this.video, 0, 0);
+			this.hasFrame = true;
+		} catch {
+			this.hasFrame = false;
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/manualReview/manualReviewService.ts
+async function flagFaceManualReview() {
+	try {
+		await api.put(endpoints.updateSession, { manualSelfieCheckNeeded: true });
+	} catch {}
+}
+async function flagIdManualReview() {
+	try {
+		await api.put(endpoints.updateSession, { manualIdCheckNeeded: true });
+	} catch {}
+}
+
+//#endregion
+//#region ../infra/src/media/VideoTrimmer.ts
+async function getDurationBySeek(videoBlob) {
+	const video = document.createElement("video");
+	video.preload = "metadata";
+	video.src = URL.createObjectURL(videoBlob);
+	try {
+		if (!Number.isFinite(video.duration)) {
+			video.currentTime = Number.MAX_SAFE_INTEGER;
+			await new Promise((resolve) => {
+				const onDurationChange = () => {
+					if (Number.isFinite(video.duration)) {
+						video.removeEventListener("durationchange", onDurationChange);
+						video.removeEventListener("timeupdate", onTimeUpdate);
+						resolve(video.duration);
+					}
+				};
+				const onTimeUpdate = () => {
+					if (Number.isFinite(video.duration)) {
+						video.removeEventListener("timeupdate", onTimeUpdate);
+						video.removeEventListener("durationchange", onDurationChange);
+						resolve(video.duration);
+					}
+				};
+				video.addEventListener("durationchange", onDurationChange);
+				video.addEventListener("timeupdate", onTimeUpdate);
+			});
+		}
+		const duration = video.duration;
+		return Number.isFinite(duration) ? duration : null;
+	} finally {
+		URL.revokeObjectURL(video.src);
+		video.src = "";
+	}
+}
+async function trimLastNSecondsUsingPlayback(videoBlob, seconds) {
+	const video = document.createElement("video");
+	video.preload = "metadata";
+	video.playsInline = true;
+	video.muted = true;
+	const videoURL = URL.createObjectURL(videoBlob);
+	video.src = videoURL;
+	const duration = await getDurationBySeek(videoBlob);
+	if (!duration || duration < seconds) {
+		URL.revokeObjectURL(videoURL);
+		return videoBlob;
+	}
+	const startTime = Math.max(0, Math.floor(duration) - seconds);
+	await new Promise((resolve) => {
+		if (video.readyState >= 2) resolve();
+		else video.addEventListener("loadedmetadata", () => resolve(), { once: true });
+	});
+	const canvas = document.createElement("canvas");
+	canvas.width = 230;
+	canvas.height = 320;
+	const captureFps = isAndroid() ? 15 : 24;
+	const stream = canvas.captureStream(captureFps);
+	const ctx = canvas.getContext("2d");
+	video.currentTime = startTime;
+	await new Promise((resolve) => {
+		video.addEventListener("seeked", () => resolve(), { once: true });
+	});
+	ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+	const mimeType = videoBlob.type || (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "video/mp4");
+	const mediaRecorder = new MediaRecorder(stream.clone(), {
+		mimeType,
+		videoBitsPerSecond: 5e5,
+		bitsPerSecond: 5e5
+	});
+	const chunks = [];
+	mediaRecorder.ondataavailable = (event) => {
+		if (event.data.size > 0) chunks.push(event.data);
+	};
+	const recordingPromise = new Promise((resolve) => {
+		mediaRecorder.onstop = () => {
+			const trimmedBlob$1 = new Blob(chunks, { type: mimeType });
+			URL.revokeObjectURL(videoURL);
+			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
+			stream.getTracks().forEach((track) => track.stop());
+			video.src = "";
+			resolve(trimmedBlob$1);
+		};
+	});
+	video.addEventListener("play", () => {
+		function drawVideo() {
+			if (video.currentTime >= duration) {
+				mediaRecorder.stop();
+				video.pause();
+				return;
+			}
+			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			requestAnimationFrame(drawVideo);
+		}
+		drawVideo();
+		setTimeout(() => {
+			mediaRecorder.start(100);
+		}, 500);
+	});
+	video.play().catch(() => {
+		URL.revokeObjectURL(videoURL);
+	});
+	const trimmedBlob = await recordingPromise;
+	console.timeEnd("trimLastNSecondsUsingPlayback");
+	return trimmedBlob;
+}
+async function trimLastNSeconds(videoBlob, seconds) {
+	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/LocalRecordingProvider.ts
+function toBase64(videoBlob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const base64 = reader.result.split(",")[1];
+			resolve(base64);
+		};
+		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("FileReader error"));
+		reader.readAsDataURL(videoBlob);
+	});
+}
+function getSupportedMediaRecorderMimeType() {
+	const possibleTypes = isIOS() ? [
+		"video/mp4",
+		"video/webm",
+		"video/webm;codecs=vp9",
+		"video/webm;codecs=vp8"
+	] : [
+		"video/webm",
+		"video/webm;codecs=vp9",
+		"video/webm;codecs=vp8",
+		"video/mp4"
+	];
+	for (const type of possibleTypes) if (MediaRecorder.isTypeSupported(type)) return type;
+	return "";
+}
+function getAdaptiveMediaRecorderOptions() {
+	const mimeType = getSupportedMediaRecorderMimeType();
+	if (isIOS()) return {
+		mimeType,
+		videoBitsPerSecond: 1e6,
+		bitsPerSecond: 1e6
+	};
+	return {
+		mimeType,
+		videoBitsPerSecond: 5e5,
+		bitsPerSecond: 5e5
+	};
+}
+var LocalRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.stream = null;
+		this.pauseRecordingBound = this.pauseRecording.bind(this);
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream) {
+		this.reset();
+		this.registerEventListeners();
+		this.stream = stream;
+		try {
+			const options = getAdaptiveMediaRecorderOptions();
+			this.mimeType = options.mimeType;
+			const recorder = new MediaRecorder(stream.clone(), options);
+			recorder.onerror = (event) => {
+				this._error = `Recording error: ${event}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start();
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			this._error = `Failed to start recording: ${err}`;
+			this._hasError = true;
+		}
+	}
+	async stopRecording(trimSeconds, encrypt, generateChecksum) {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve, reject) => {
+			this.removeEventListeners();
+			if (recorder && this._isRecording) {
+				const chunks = [];
+				recorder.ondataavailable = (event) => {
+					if (event.data.size > 0) chunks.push(event.data);
+				};
+				recorder.onstop = async () => {
+					try {
+						const trimmedVideo = await trimLastNSeconds(new Blob(chunks, { type: this.mimeType }), trimSeconds);
+						const encryptedVideoBase64 = encrypt(await toBase64(trimmedVideo));
+						generateChecksum(await trimmedVideo.arrayBuffer());
+						this._isRecording = false;
+						resolve({
+							trimmedBlob: trimmedVideo,
+							encryptedVideo: encryptedVideoBase64
+						});
+					} catch (error) {
+						this._isRecording = false;
+						this._error = `Recording stop failed: ${error}`;
+						this._hasError = true;
+						reject(error);
+					}
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve({
+				trimmedBlob: new Blob([], { type: this.mimeType }),
+				encryptedVideo: ""
+			});
+			recorder?.stream?.getTracks().forEach((track) => track.stop());
+		});
+	}
+	reset() {
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+	pauseRecording() {
+		if (!this._isRecording) return;
+		if (this.mediaRecorder?.state === "recording") try {
+			this.mediaRecorder.pause();
+		} catch {}
+	}
+	registerEventListeners() {
+		document.addEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+	removeEventListeners() {
+		document.removeEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+};
+
+//#endregion
+//#region src/internal/faceCapture/recordingService.ts
+let openViduProviderImportPromise;
+let openViduBrowserImportPromise;
+function loadOpenViduProviderModule() {
+	if (!openViduProviderImportPromise) openViduProviderImportPromise = import("./OpenViduRecordingProvider-CMu6XVdc.esm.js");
+	return openViduProviderImportPromise;
+}
+function loadOpenViduBrowserModule() {
+	if (!openViduBrowserImportPromise) openViduBrowserImportPromise = (async () => {
+		return (await import("./openviduLazy-Cm0XFh_v.esm.js")).loadOpenVidu();
+	})();
+	return openViduBrowserImportPromise;
+}
+function preloadOpenViduProvider() {
+	loadOpenViduProviderModule();
+	loadOpenViduBrowserModule();
+}
+/**
+* Records on-device and uploads encrypted video for liveness.
+*/
+var LocalRecordingService = class {
+	constructor(wasmUtil, sessionToken) {
+		this.recorder = new LocalRecordingProvider();
+		this.sessionToken = sessionToken;
+		this.wasmUtil = wasmUtil;
+	}
+	async start(stream) {
+		this.recorder.startRecording(stream);
+	}
+	async stop() {
+		if (!this.recorder.isRecording) return { recordingId: null };
+		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
+		if (!this.sessionToken) return { recordingId: null };
+		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
+	}
+	async stopAndGetVideo() {
+		if (!this.recorder.isRecording) return { videoBase64: void 0 };
+		try {
+			const videoBase64 = (await this.recorder.stopRecording(10, (base64) => base64, () => {})).encryptedVideo;
+			return { videoBase64: videoBase64 ? videoBase64 : void 0 };
+		} catch {
+			return { videoBase64: void 0 };
+		}
+	}
+	cleanup() {
+		this.recorder.reset();
+	}
+};
+/**
+* Records through OpenVidu and manages the session lifecycle.
+*/
+var OpenViduRecordingService = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async start(stream) {
+		if (!this.provider) {
+			const { OpenViduRecordingProvider } = await loadOpenViduProviderModule();
+			this.provider = new OpenViduRecordingProvider();
+		}
+		this.session = await startRecordingSession({
+			config: {
+				...this.config,
+				recording: { capability: this.provider }
+			},
+			clonedStream: stream.clone(),
+			existing: this.session
+		});
+	}
+	async stop() {
+		if (this.session) {
+			stopRecording(this.session);
+			this.session = void 0;
+		}
+		return { recordingId: null };
+	}
+	async stopAndGetVideo() {
+		if (this.session) {
+			stopRecording(this.session);
+			this.session = void 0;
+		}
+		return { videoBase64: void 0 };
+	}
+	cleanup() {
+		if (this.session) stopRecording(this.session);
+	}
+};
+/**
+* Creates the recording service for the current configuration.
+*
+* Order of precedence:
+* 1. `onDeviceFaceResultsSubmissionEnabled === true` → no recording. The
+*    on-device workflow never uploads media, only the staged face-results
+*    JSON via `WebApi.postFaceResults`. Mirrors V1's
+*    `FaceFlowManager.setRecorders()` early return.
+* 2. `deepsightLiveness === 'VIDEOLIVENESS'` → local Deepsight recorder.
+* 3. `enableFaceRecording === true` → server-side OpenVidu recorder.
+* 4. otherwise → no recording.
+*/
+function createRecordingService(params) {
+	if (params.config.onDeviceFaceResultsSubmissionEnabled === true) return;
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
+	if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
+}
+
+//#endregion
+export { stopRecording$1 as _, StreamCanvasCapture as a, initializeDeepsightSession as c, stopStream as d, processFace as f, startRecording as g, createRecordingSession as h, flagIdManualReview as i, sendLabelInspectionEvent as l, FACE_ERROR_CODES as m, preloadOpenViduProvider as n, encryptSelfieImage as o, uploadSelfie as p, flagFaceManualReview as r, initializeCamera as s, createRecordingService as t, startDetection as u, StreamCanvasProcessingSession as v };