@incodetech/core 2.0.0-alpha.10 → 2.0.0-alpha.11

package/dist/{endpoints-BSTFaHYo.esm.js → endpoints-B0ltwtb5.esm.js}

@@ -1,5 +1,17 @@
 import { a as __toDynamicImportESM } from "./chunk-C_Yo44FK.esm.js";
 
+//#region ../infra/src/capabilities/platform.ts
+function isIOS(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	const hasTouchPoints = typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false;
+	return /iPad|iPhone|iPod/.test(ua) || /Mac OS/.test(ua) && hasTouchPoints || /iPadOS/.test(ua);
+}
+function isAndroid(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return /Android/i.test(ua);
+}
+
+//#endregion
 //#region ../infra/src/http/createApi.ts
 var FetchHttpError = class extends Error {
 	constructor(status, statusText, url, method, headers, data) {
@@ -552,8 +564,15 @@ var StreamCanvasCapture = class {
 	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.canvas.width, this.canvas.height);
+			this.ctx.drawImage(this.video, 0, 0);
 			this.hasFrame = true;
 		} catch {
 			this.hasFrame = false;
@@ -603,17 +622,528 @@ var StreamCanvasProcessingSession = class {
 	}
 };
 
+//#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) {
+	console.log("[VideoTrimmer] Starting playback-based trimming...");
+	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);
+	console.log("[VideoTrimmer] Video duration:", duration);
+	if (!duration || duration < seconds) {
+		console.log("[VideoTrimmer] Video too short, returning original");
+		URL.revokeObjectURL(videoURL);
+		return videoBlob;
+	}
+	const startTime = Math.max(0, Math.floor(duration) - seconds);
+	console.log("[VideoTrimmer] Trimming from", startTime, "to", duration);
+	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 = () => {
+			console.log("[VideoTrimmer] Recording stopped, chunks:", chunks.length);
+			const trimmedBlob = new Blob(chunks, { type: mimeType });
+			URL.revokeObjectURL(videoURL);
+			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
+			stream.getTracks().forEach((track) => track.stop());
+			video.src = "";
+			console.log("[VideoTrimmer] Playback-based trimming complete, size:", trimmedBlob.size);
+			resolve(trimmedBlob);
+		};
+	});
+	video.addEventListener("play", () => {
+		console.log("[VideoTrimmer] Video playing, starting recording...");
+		function drawVideo() {
+			if (video.currentTime >= duration) {
+				console.log("[VideoTrimmer] Reached end, stopping...");
+				mediaRecorder.stop();
+				video.pause();
+				return;
+			}
+			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			requestAnimationFrame(drawVideo);
+		}
+		drawVideo();
+		setTimeout(() => {
+			console.log("[VideoTrimmer] Starting MediaRecorder...");
+			mediaRecorder.start(100);
+		}, 500);
+	});
+	console.log("[VideoTrimmer] Starting video playback...");
+	video.play().catch((err) => {
+		console.error("[VideoTrimmer] Play failed:", err);
+		URL.revokeObjectURL(videoURL);
+	});
+	return await recordingPromise;
+}
+async function trimLastNSeconds(videoBlob, seconds) {
+	console.log(`[VideoTrimmer] trimLastNSeconds called (trim to ${seconds}s from ${videoBlob.size} bytes)`);
+	console.log("[VideoTrimmer] Using playback-based trimming");
+	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/DeepsightRecordingProvider.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 DeepsightRecordingProvider = 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) {
+			console.error(`Failed to start recording: ${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 ../infra/src/providers/browser/MotionSensorProvider.ts
+var MotionSensorProvider = class {
+	constructor(thresholds) {
+		this._isRunning = false;
+		this._hasPermission = true;
+		this.acl = null;
+		this.gyro = null;
+		this.minNumberOfFrames = 3;
+		this.maxFrequency = 60;
+		this.emptyParams = {
+			meanX: 0,
+			meanY: 0,
+			meanZ: 0,
+			m2X: 0,
+			m2Y: 0,
+			m2Z: 0,
+			cumulativeAbsErrorX: 0,
+			cumulativeAbsErrorY: 0,
+			cumulativeAbsErrorZ: 0,
+			ptsNum: 0
+		};
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+		this.deviceMotionListener = (event) => {
+			if (event.accelerationIncludingGravity) {
+				const accGrVal = {
+					x: event.accelerationIncludingGravity.x,
+					y: event.accelerationIncludingGravity.y,
+					z: event.accelerationIncludingGravity.z
+				};
+				if (this.checkFields(accGrVal)) {
+					this.paramsAccGrOld.ptsNum += 1;
+					this.updateParams(this.paramsAccGrOld, accGrVal);
+				}
+			}
+			if (event.acceleration) {
+				const accVal = {
+					x: event.acceleration.x,
+					y: event.acceleration.y,
+					z: event.acceleration.z
+				};
+				if (this.checkFields(accVal)) {
+					this.paramsAccOld.ptsNum += 1;
+					this.updateParams(this.paramsAccOld, accVal);
+				}
+			}
+			if (event.rotationRate) {
+				const gyroVal = {
+					x: event.rotationRate.alpha,
+					y: event.rotationRate.beta,
+					z: event.rotationRate.gamma
+				};
+				if (this.checkFields(gyroVal)) {
+					this.paramsGyroscopeOld.ptsNum += 1;
+					this.updateParams(this.paramsGyroscopeOld, gyroVal);
+				}
+			}
+		};
+		this.deviceOrientationListener = (event) => {
+			const orientationVal = {
+				x: event.alpha,
+				y: event.beta,
+				z: event.gamma
+			};
+			if (this.checkFields(orientationVal)) {
+				this.paramsOrientationOld.ptsNum += 1;
+				this.updateParams(this.paramsOrientationOld, orientationVal);
+			}
+		};
+		this.thresholds = {
+			accThreshold: thresholds?.accThreshold ?? .3,
+			gyroThreshold: thresholds?.gyroThreshold ?? .3,
+			accGrOldThreshold: thresholds?.accGrOldThreshold ?? .3,
+			accOldThreshold: thresholds?.accOldThreshold ?? .3,
+			gyroscopeOldThreshold: thresholds?.gyroscopeOldThreshold ?? 10,
+			orientationOldThreshold: thresholds?.orientationOldThreshold ?? 10,
+			maeAccThreshold: thresholds?.maeAccThreshold ?? .3,
+			maeGyroThreshold: thresholds?.maeGyroThreshold ?? .3,
+			maeAccGrOldThreshold: thresholds?.maeAccGrOldThreshold ?? .3,
+			maeAccOldThreshold: thresholds?.maeAccOldThreshold ?? .3,
+			maeGyroscopeOldThreshold: thresholds?.maeGyroscopeOldThreshold ?? 10,
+			maeOrientationOldThreshold: thresholds?.maeOrientationOldThreshold ?? 10
+		};
+	}
+	get isRunning() {
+		return this._isRunning;
+	}
+	get hasPermission() {
+		return this._hasPermission;
+	}
+	async requestPermission() {
+		if (typeof DeviceMotionEvent !== "undefined" && typeof DeviceMotionEvent.requestPermission === "function") {
+			sessionStorage.setItem("motionSensorsPermissionsRequested", String(true));
+			try {
+				if (await DeviceMotionEvent.requestPermission() !== "granted") {
+					this._hasPermission = false;
+					return "denied";
+				}
+				return "granted";
+			} catch {
+				this._hasPermission = false;
+				return "denied";
+			}
+		}
+		return "not-required";
+	}
+	initializeAccelerometer() {
+		if (!("Accelerometer" in window)) return;
+		try {
+			const AccelerometerConstructor = window.Accelerometer;
+			if (AccelerometerConstructor) {
+				this.acl = new AccelerometerConstructor({ frequency: this.maxFrequency });
+				this.acl.addEventListener("reading", () => this.updateAcc());
+			}
+		} catch {}
+	}
+	initializeGyroscope() {
+		if (!("Gyroscope" in window)) return;
+		try {
+			const GyroscopeConstructor = window.Gyroscope;
+			if (GyroscopeConstructor) {
+				this.gyro = new GyroscopeConstructor({ frequency: this.maxFrequency });
+				this.gyro.addEventListener("reading", () => this.updateGyro());
+			}
+		} catch {}
+	}
+	async start() {
+		if (this._isRunning || !this._hasPermission) return;
+		try {
+			this.initializeAccelerometer();
+			if (this.acl) this.acl.start();
+		} catch {}
+		try {
+			this.initializeGyroscope();
+			if (this.gyro) this.gyro.start();
+		} catch {}
+		window.addEventListener("devicemotion", this.deviceMotionListener);
+		window.addEventListener("deviceorientation", this.deviceOrientationListener);
+		this._isRunning = true;
+	}
+	stop() {
+		this._isRunning = false;
+		if (this.acl) this.acl.stop();
+		if (this.gyro) this.gyro.stop();
+		window.removeEventListener("devicemotion", this.deviceMotionListener);
+		window.removeEventListener("deviceorientation", this.deviceOrientationListener);
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+	}
+	updateAcc() {
+		if (!this._isRunning || !this.acl) return;
+		this.paramsAcc.ptsNum += 1;
+		const val = {
+			x: this.acl.x,
+			y: this.acl.y,
+			z: this.acl.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsAcc, val);
+	}
+	updateGyro() {
+		if (!this._isRunning || !this.gyro) return;
+		this.paramsGyro.ptsNum += 1;
+		const val = {
+			x: this.gyro.x,
+			y: this.gyro.y,
+			z: this.gyro.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsGyro, val);
+	}
+	check() {
+		if (!this._hasPermission) return "UNCLEAR";
+		const result = this.checkStability();
+		return result === null ? "UNCLEAR" : result ? "FAIL" : "PASS";
+	}
+	checkStability() {
+		if (!this._isRunning) return null;
+		const filteredStdChecks = [
+			this.gyro ? this.isBelowStdThreshold(this.paramsGyro, this.thresholds.gyroThreshold) : null,
+			this.acl ? this.isBelowStdThreshold(this.paramsAcc, this.thresholds.accThreshold) : null,
+			this.isBelowStdThreshold(this.paramsAccGrOld, this.thresholds.accGrOldThreshold),
+			this.isBelowStdThreshold(this.paramsAccOld, this.thresholds.accOldThreshold),
+			this.isBelowStdThreshold(this.paramsGyroscopeOld, this.thresholds.gyroscopeOldThreshold),
+			this.isBelowStdThreshold(this.paramsOrientationOld, this.thresholds.orientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalStdCheck = filteredStdChecks.length > 0 ? filteredStdChecks.every((check) => check) : null;
+		const filteredMaeChecks = [
+			this.gyro ? this.isBelowMaeThreshold(this.paramsGyro, this.thresholds.maeGyroThreshold) : null,
+			this.acl ? this.isBelowMaeThreshold(this.paramsAcc, this.thresholds.maeAccThreshold) : null,
+			this.isBelowMaeThreshold(this.paramsAccGrOld, this.thresholds.maeAccGrOldThreshold),
+			this.isBelowMaeThreshold(this.paramsAccOld, this.thresholds.maeAccOldThreshold),
+			this.isBelowMaeThreshold(this.paramsGyroscopeOld, this.thresholds.maeGyroscopeOldThreshold),
+			this.isBelowMaeThreshold(this.paramsOrientationOld, this.thresholds.maeOrientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalMaeCheck = filteredMaeChecks.length > 0 ? filteredMaeChecks.every((check) => check) : null;
+		return finalStdCheck === null ? finalMaeCheck === null ? null : finalMaeCheck : finalMaeCheck !== null ? finalStdCheck && finalMaeCheck : finalStdCheck;
+	}
+	updateParams(params, val) {
+		const deltaX = val.x - params.meanX;
+		const deltaY = val.y - params.meanY;
+		const deltaZ = val.z - params.meanZ;
+		params.meanX += deltaX / params.ptsNum;
+		params.meanY += deltaY / params.ptsNum;
+		params.meanZ += deltaZ / params.ptsNum;
+		params.m2X += deltaX * (val.x - params.meanX);
+		params.m2Y += deltaY * (val.y - params.meanY);
+		params.m2Z += deltaZ * (val.z - params.meanZ);
+		params.cumulativeAbsErrorX += Math.abs(val.x - params.meanX);
+		params.cumulativeAbsErrorY += Math.abs(val.y - params.meanY);
+		params.cumulativeAbsErrorZ += Math.abs(val.z - params.meanZ);
+	}
+	calculateStd(params) {
+		const variance = {
+			x: params.m2X / params.ptsNum,
+			y: params.m2Y / params.ptsNum,
+			z: params.m2Z / params.ptsNum
+		};
+		return {
+			x: Math.sqrt(variance.x),
+			y: Math.sqrt(variance.y),
+			z: Math.sqrt(variance.z)
+		};
+	}
+	calculateMae(params) {
+		return {
+			x: params.cumulativeAbsErrorX / params.ptsNum,
+			y: params.cumulativeAbsErrorY / params.ptsNum,
+			z: params.cumulativeAbsErrorZ / params.ptsNum
+		};
+	}
+	checkFields(point) {
+		return point.x !== null && point.y !== null && point.z !== null;
+	}
+	isBelowStdThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const std = this.calculateStd(params);
+		return std.x < threshold && std.y < threshold && std.z < threshold;
+	}
+	isBelowMaeThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const mae = this.calculateMae(params);
+		return mae.x < threshold && mae.y < threshold && mae.z < threshold;
+	}
+};
+
 //#endregion
 //#region ../infra/src/providers/browser/openviduLazy.ts
 let openViduImport;
 async function enableProdModeBeforeLoad() {
-	const { OpenViduLogger } = await import("./OpenViduLogger-BdPfiZO6.esm.js").then(__toDynamicImportESM(1));
+	const { OpenViduLogger } = await import("./OpenViduLogger-20ZYS-mT.esm.js").then(__toDynamicImportESM(1));
 	OpenViduLogger.getInstance().enableProdMode();
 }
 async function loadOpenVidu() {
 	if (openViduImport) return openViduImport;
 	await enableProdModeBeforeLoad();
-	openViduImport = import("./lib-Bu9XGMBW.esm.js").then(__toDynamicImportESM(1));
+	openViduImport = import("./lib-CykGFCEr.esm.js").then(__toDynamicImportESM(1));
 	return openViduImport;
 }
 
@@ -701,6 +1231,28 @@ var OpenViduRecordingProvider = class {
 	}
 };
 
+//#endregion
+//#region ../infra/src/providers/browser/VisibilityProvider.ts
+var VisibilityProvider = class {
+	constructor() {
+		this._wasBackgrounded = false;
+		this.visibilityChangeHandler = this.onVisibilityChange.bind(this);
+		document.addEventListener("visibilitychange", this.visibilityChangeHandler);
+	}
+	get wasBackgrounded() {
+		return this._wasBackgrounded;
+	}
+	reset() {
+		this._wasBackgrounded = false;
+	}
+	cleanup() {
+		document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
+	}
+	onVisibilityChange() {
+		if (document.hidden) this._wasBackgrounded = true;
+	}
+};
+
 //#endregion
 //#region ../infra/src/wasm/IdCaptureModelType.ts
 let IdCaptureModelType = /* @__PURE__ */ function(IdCaptureModelType$1) {
@@ -1129,6 +1681,10 @@ var MlWasmJSApi = class MlWasmJSApi {
 		this.checkWasmInitialization("Unable to pc, cpp API hasn't been initialized");
 		await this.wasmCallWrapper(this.utilityApi.pc.bind(this.utilityApi), [deviceId]);
 	}
+	ckvcks(data) {
+		this.checkWasmInitialization("Unable to ckvcks, cpp API hasn't been initialized");
+		this.utilityApi.ckvcks(data);
+	}
 	pipelineTypeToWasmEnum(type) {
 		switch (type) {
 			case WasmPipelineType.IdBlurGlarePipeline: return this.wasmModule.PipelineType.IdBlurGlarePipeline;
@@ -1632,8 +2188,77 @@ var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
 		await this.initializeBase(config, pipeline);
 	}
 	encryptImage(image) {
+		this.ensureInitialized();
 		return mlWasmJSApi_default.ens(image);
 	}
+	setSdkVersion(version) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkVersion(version);
+	}
+	setSdkPlatform(platform) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkPlatform(platform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setMotionStatus(status) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setMotionStatus(status);
+	}
+	setBackgroundMode(backgroundMode) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBackgroundMode(backgroundMode);
+	}
+	setZc(zc) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setZc(zc);
+	}
+	setInspectorOpened(opened) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setInspectorOpened(opened);
+	}
+	getMetadata() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getMetadata();
+	}
+	async analyzeFrame(image) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.analyzeFrame(image);
+	}
+	getCheck() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getCheck();
+	}
+	estimatePerformance() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.estimatePerformance();
+	}
+	isVirtualCamera(label) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.isVirtualCamera(label);
+	}
+	async poc(output) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.poc(output);
+	}
+	ckvcks(data) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.ckvcks(data);
+	}
+	async getVersions() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getVersions();
+	}
 };
 
 //#endregion
@@ -1646,6 +2271,9 @@ function setClient(httpClient) {
 function setToken(token) {
 	currentToken = token;
 }
+function getToken() {
+	return currentToken;
+}
 function getApi() {
 	if (!client) throw new Error("SDK not configured. Call setup({ apiURL: \"...\" }) first.");
 	return client;
@@ -1692,6 +2320,7 @@ const endpoints = {
 	recordingCreateSessionV2: "/omni/recordings/create-session/v2",
 	recordingStartV2: "/omni/recordings/record-start/v2",
 	recordingStopV2: "/omni/recordings/record-stop/v2",
+	deepsightVideoImport: "/omni/recordings/import",
 	phone: "/omni/add/phone",
 	phoneInstant: "/omni/instant/add/phone",
 	getPhone: "/omni/get/phone",
@@ -1703,4 +2332,4 @@ const endpoints = {
 };
 
 //#endregion
-export { createApi_default as _, setClient as a, FaceDetectionProvider as c, StreamCanvasProcessingSession as d, StreamCanvasCapture as f, createManager as g, stopCameraStream as h, resetApi as i, warmupWasm as l, requestCameraAccess as m, api as n, setToken as o, queryCameraPermission as p, getApi as r, WasmUtilProvider as s, endpoints as t, OpenViduRecordingProvider as u };
+export { queryCameraPermission as _, resetApi as a, createManager as b, WasmUtilProvider as c, VisibilityProvider as d, OpenViduRecordingProvider as f, StreamCanvasCapture as g, StreamCanvasProcessingSession as h, getToken as i, FaceDetectionProvider as l, DeepsightRecordingProvider as m, api as n, setClient as o, MotionSensorProvider as p, getApi as r, setToken as s, endpoints as t, warmupWasm as u, requestCameraAccess as v, createApi_default as x, stopCameraStream as y };