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

package/dist/{OpenViduLogger-CQyDxBvM.esm.js → OpenViduLogger-CRbRNZA7.esm.js}

@@ -1,4 +1,4 @@
-import { t as __commonJS } from "./chunk-C_Yo44FK.esm.js";
+import { t as __commonJS } from "./chunk-FbsBJI8u.esm.js";
 
 //#region ../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js
 var require_jsnlog = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js": ((exports) => {

package/dist/OpenViduLogger-Dy5P806a.esm.js

@@ -0,0 +1,3 @@
+import { t as require_OpenViduLogger } from "./OpenViduLogger-CRbRNZA7.esm.js";
+
+export default require_OpenViduLogger();

package/dist/{warmup-CEJTfxQr.d.ts → StateMachine-pi8byl8C.d.ts}

@@ -1,4 +1,7 @@
+import { AnyStateMachine, StateMachine } from "xstate";
+
 //#region ../infra/src/wasm/warmup.d.ts
+
 /**
  * All available ML pipelines in the SDK.
  * - 'selfie' - Face detection for selfie capture
@@ -52,4 +55,4 @@ interface WarmupConfig {
  */
 declare function warmupWasm(config: WarmupConfig): Promise<void>;
 //#endregion
-export { warmupWasm as n, WasmPipeline as t };
+export { warmupWasm as i, StateMachine as n, WasmPipeline as r, AnyStateMachine as t };

package/dist/{addEvent-W0ORK0jT.esm.js → addEvent-BGKc_lHF.esm.js}

@@ -1,4 +1,4 @@
-import { n as api, t as endpoints } from "./endpoints-BSTFaHYo.esm.js";
+import { n as api, t as endpoints } from "./endpoints-D9TGnxRK.esm.js";
 
 //#region src/internal/events/addEvent.ts
 function addEvent(event) {

package/dist/deepsightLoader-B36_XZ7r.esm.js

@@ -0,0 +1,25 @@
+import { _ as DeepsightRecordingProvider, g as MotionSensorProvider, m as VisibilityProvider, u as WasmUtilProvider } from "./endpoints-D9TGnxRK.esm.js";
+import { i as uploadDeepsightVideo } from "./recordingsRepository-D5MURoVB.esm.js";
+import { t as createDeepsightService } from "./deepsightService-BWxcc4OC.esm.js";
+
+//#region src/modules/selfie/deepsightLoader.ts
+const SDK_VERSION = "2.0.0";
+async function loadDeepsightSession() {
+	const service = createDeepsightService({
+		sdkVersion: SDK_VERSION,
+		wasmUtil: await WasmUtilProvider.getInstance(),
+		visibility: new VisibilityProvider(),
+		motionSensor: new MotionSensorProvider(),
+		recorder: new DeepsightRecordingProvider(),
+		uploadVideo: async (encryptedVideo, token) => {
+			return await uploadDeepsightVideo(encryptedVideo, token);
+		}
+	});
+	await service.initialize();
+	await service.requestMotionPermission();
+	await service.startMotionSensors();
+	return service;
+}
+
+//#endregion
+export { loadDeepsightSession };

package/dist/deepsightService-BWxcc4OC.esm.js

@@ -0,0 +1,225 @@
+import { a as getUserAgent } from "./recordingsRepository-D5MURoVB.esm.js";
+
+//#region src/internal/deepsight/metadataService.ts
+function getWebGLFingerprint() {
+	try {
+		const canvas = document.createElement("canvas");
+		const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+		if (!gl) return "";
+		const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+		if (!debugInfo) return "";
+		return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || "";
+	} catch {
+		return "";
+	}
+}
+function isBrowserSimulation() {
+	const win = window;
+	const nav = navigator;
+	return !!(win.callPhantom || win._phantom || win.phantom || win.__nightmare || nav.webdriver || win.domAutomation || win.domAutomationController);
+}
+async function getFingerPrint(disableIpify = false) {
+	let visitorId = "";
+	let ip = "";
+	try {
+		const canvas = document.createElement("canvas");
+		const ctx = canvas.getContext("2d");
+		if (ctx) {
+			ctx.textBaseline = "top";
+			ctx.font = "14px Arial";
+			ctx.fillText("fingerprint", 2, 2);
+			visitorId = canvas.toDataURL().slice(-50);
+		}
+	} catch {}
+	if (!disableIpify) try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 3e3);
+		const response = await fetch("https://api.ipify.org?format=json", { signal: controller.signal });
+		clearTimeout(timeoutId);
+		ip = (await response.json()).ip || "";
+	} catch {}
+	return {
+		visitorId,
+		ip
+	};
+}
+function createMetadataService(wasmUtil, visibility) {
+	return {
+		async initialize(sdkVersion, disableIpify = false) {
+			wasmUtil.setSdkPlatform("WEBAPP");
+			wasmUtil.setSdkVersion(sdkVersion);
+			const ua = getUserAgent();
+			const isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
+			const fingerPrint = await getFingerPrint(disableIpify).catch(() => ({
+				visitorId: "",
+				ip: ""
+			}));
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model: "",
+				os: void 0,
+				osVersion: void 0,
+				screenDimensions: {
+					width: screen.width,
+					height: screen.height
+				},
+				numTouchPoints: navigator.maxTouchPoints,
+				fingerprintHash: fingerPrint.visitorId || "",
+				ip: fingerPrint.ip || "",
+				backgroundMode: false
+			};
+			wasmUtil.setDeviceInfo(deviceMetadata);
+			const nav = navigator;
+			const browserInfo = {
+				userAgent: ua,
+				getUserMediaAvailability: {
+					webkit: nav.webkitGetUserMedia !== void 0,
+					moz: nav.mozGetUserMedia !== void 0,
+					o: nav.oGetUserMedia !== void 0,
+					ms: nav.msGetUserMedia !== void 0
+				},
+				webglFingerprint: getWebGLFingerprint(),
+				inspectorOpened: false,
+				isMockedBrowser: isBrowserSimulation()
+			};
+			wasmUtil.setBrowserInfo(browserInfo, false);
+		},
+		updateCameraInfo(videoTrack) {
+			const settings = videoTrack.getSettings();
+			const capabilities = videoTrack.getCapabilities?.() ?? {};
+			const labels = videoTrack.label ? [videoTrack.label] : [];
+			const cameraInfo = {
+				facingMode: settings.facingMode === "user" ? "frontal" : settings.facingMode === "environment" ? "back" : settings.facingMode || "unknown",
+				settings,
+				capabilities,
+				labels
+			};
+			wasmUtil.setCameraInfo(cameraInfo);
+		},
+		async checkForVirtualCameraByLabel(videoTrack = null) {
+			try {
+				if (!videoTrack) {
+					const devices = await navigator.mediaDevices.enumerateDevices();
+					for (const device of devices) if (device.kind === "videoinput" && wasmUtil.isVirtualCamera(device.label)) return true;
+				}
+				if (videoTrack && wasmUtil.isVirtualCamera(videoTrack.label)) return true;
+				return false;
+			} catch {
+				return false;
+			}
+		},
+		async analyzeFrame(imageData) {
+			await wasmUtil.analyzeFrame(imageData);
+		},
+		setMotionStatus(status) {
+			wasmUtil.setMotionStatus(status);
+		},
+		setBackgroundMode(backgroundMode) {
+			wasmUtil.setBackgroundMode(backgroundMode || visibility.wasBackgrounded);
+			visibility.reset();
+		},
+		estimatePerformance() {
+			return wasmUtil.estimatePerformance();
+		},
+		getMetadata() {
+			return wasmUtil.getMetadata();
+		},
+		getCheck() {
+			return wasmUtil.getCheck();
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/motionStatusService.ts
+function createMotionStatusService(motionSensor) {
+	return {
+		async requestPermission() {
+			return motionSensor.requestPermission();
+		},
+		async start() {
+			await motionSensor.start();
+		},
+		stop() {
+			motionSensor.stop();
+		},
+		check() {
+			return motionSensor.check();
+		},
+		get isRunning() {
+			return motionSensor.isRunning;
+		},
+		get hasPermission() {
+			return motionSensor.hasPermission;
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/deepsightService.ts
+function createDeepsightService(config) {
+	const metadata = createMetadataService(config.wasmUtil, config.visibility);
+	const motion = createMotionStatusService(config.motionSensor);
+	return {
+		metadata,
+		motion,
+		recorder: config.recorder,
+		async initialize(disableIpify = false) {
+			await metadata.initialize(config.sdkVersion, disableIpify);
+			metadata.estimatePerformance();
+		},
+		async requestMotionPermission() {
+			return motion.requestPermission();
+		},
+		async startMotionSensors() {
+			await motion.start();
+		},
+		stopMotionSensors() {
+			motion.stop();
+		},
+		startRecording(stream) {
+			config.recorder.startRecording(stream);
+		},
+		async checkVirtualCamera(videoTrack) {
+			metadata.updateCameraInfo(videoTrack);
+			return metadata.checkForVirtualCameraByLabel(videoTrack);
+		},
+		async performVirtualCameraCheck() {
+			const output = {
+				canvas: null,
+				itr: null,
+				skipped: null
+			};
+			await config.wasmUtil.poc(output);
+			if (output?.skipped === false) config.wasmUtil.setZc(output?.itr === true ? "FAIL" : "PASS");
+		},
+		async performCapture(sessionToken, imageData) {
+			let recordingId = null;
+			if (config.recorder.isRecording) {
+				const result = await config.recorder.stopRecording(10, (base64) => config.wasmUtil.encryptImage(base64), (buffer) => config.wasmUtil.ckvcks(buffer));
+				try {
+					recordingId = await config.uploadVideo(result.encryptedVideo, sessionToken);
+				} catch (error) {
+					console.error("[DeepsightService] Failed to upload video:", error);
+				}
+			}
+			await this.performVirtualCameraCheck();
+			await metadata.analyzeFrame(imageData);
+			const motionStatus = motion.check();
+			metadata.setMotionStatus(motionStatus);
+			metadata.getCheck();
+			metadata.setBackgroundMode(false);
+			return {
+				metadata: metadata.getMetadata(),
+				recordingId
+			};
+		},
+		cleanup() {
+			motion.stop();
+			config.recorder.reset();
+		}
+	};
+}
+
+//#endregion
+export { createDeepsightService as t };

package/dist/email.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-BGfxEmyv.js";
+import { t as Manager } from "./Manager-BZUZTRPx.js";
 
 //#region src/modules/email/types.d.ts
 

package/dist/email.esm.js

@@ -1,6 +1,6 @@
-import { g as createManager, n as api, t as endpoints } from "./endpoints-BSTFaHYo.esm.js";
-import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B_rda9yU.esm.js";
-import { t as addEvent } from "./addEvent-W0ORK0jT.esm.js";
+import { E as createManager, n as api, t as endpoints } from "./endpoints-D9TGnxRK.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-2hDiAXvZ.esm.js";
+import { t as addEvent } from "./addEvent-BGKc_lHF.esm.js";
 
 //#region src/modules/email/emailServices.ts
 async function fetchEmail(signal) {